feat(primitives): implement integer type

packages/primitives/src/boolean.ts

@@ -4,4 +4,4 @@
 
 import { BooleanType, boolean } from "io-ts";
 
-export { BooleanType as Boolean, boolean };
+export { BooleanType, boolean };

packages/primitives/src/index.ts

@@ -2,6 +2,7 @@
  * FHIR Primitive Runtime Types
  */
 
-import { Boolean, boolean } from "./boolean";
+import { BooleanType, boolean } from "./boolean";
+import { IntegerType, integer } from "./integer";
 
-export { Boolean, boolean };
+export { BooleanType, boolean, IntegerType, integer };

packages/primitives/src/integer.ts

@@ -0,0 +1,20 @@
+/**
+ * Integer FHIR Primitive Runtime Type
+ */
+
+import { Type, success, failure, identity } from "io-ts";
+
+export class IntegerType extends Type<number> {
+  readonly _tag: "IntegerType" = "IntegerType";
+  constructor() {
+    super(
+      "integer",
+      (m): m is number => typeof m === "number" && Number.isInteger(m),
+      (m, c) =>
+        this.is(m) && Number.isInteger(m) ? success(m) : failure(m, c),
+      identity
+    );
+  }
+}
+
+export const integer = new IntegerType();

packages/primitives/test/boolean.test.ts

@@ -5,7 +5,7 @@
 import { boolean } from "../src";
 import { assertSuccess, assertFailure, assertStrictEqual } from "./helpers";
 
-describe("boolean", () => {
+describe("BooleanType", () => {
   it("should succeed validating a valid value", () => {
     const T = boolean;
     assertSuccess(T.decode(true));

packages/primitives/test/integer.test.ts

@@ -0,0 +1,31 @@
+/**
+ * Tests for Integer Runtime Type
+ */
+
+import { IntegerType, integer } from "../src";
+import { assertSuccess, assertFailure, assertStrictEqual } from "./helpers";
+
+describe("IntegerType", () => {
+  it("should succeed validating a valid value", () => {
+    const T = integer;
+    assertSuccess(T.decode(2));
+  });
+
+  it("should return the same reference if validation succeeded and nothing changed", () => {
+    const T = integer;
+    const value = 2;
+    assertStrictEqual(T.decode(value), value);
+  });
+
+  it("should fail validating an invalid value", () => {
+    const T = integer;
+    assertFailure(T.decode(1.1), ["Invalid value 1.1 supplied to : integer"]);
+  });
+
+  it("should type guard", () => {
+    const T = new IntegerType();
+    expect(T.is(2)).toEqual(true);
+    expect(T.is(1.1)).toEqual(false);
+    expect(T.is(undefined)).toEqual(false);
+  });
+});