@leon740727/type-schema 0.0.3

package/src/type.ts

@@ -0,0 +1,367 @@
+import { mergeRight } from "ramda";
+import { addQuestionMarks, flatten, resolveTuple } from "./util";
+
+/**
+ * schema 有幾種類別
+ * 1. atom: 沒有 inner schema 描述的值。例如 number, string ...
+ *    注意，array 或 object 也可以是 atom 的，只要其值沒有另外的 schema 描述
+ * 2. compound: 裡面的值有另外的 inner schema 來描述。又分成二種 object, array
+ */
+
+export enum SchemaType {
+  atom,
+  array, // compound array
+  object, // compound object
+  tuple,
+  union,
+}
+
+type Attr = { [field: string]: any };
+
+export class AtomSchema<VT, VT2> {
+  constructor(
+    readonly type: SchemaType.atom,
+    readonly value: VT,
+    readonly isNullable: boolean,
+    readonly isOptional: boolean,
+    readonly isa: (v) => string | null, // 傳回錯誤訊息
+    readonly transform: (v: VT) => VT2,
+    readonly attr: Attr // 額外附加的屬性
+  ) {}
+
+  nullable() {
+    return new AtomSchema<VT | null, VT2>(
+      SchemaType.atom,
+      this.value,
+      true,
+      this.isOptional,
+      this.isa,
+      this.transform,
+      this.attr
+    );
+  }
+
+  optional() {
+    return new AtomSchema<VT | undefined, VT2>(
+      SchemaType.atom,
+      this.value,
+      this.isNullable,
+      true,
+      this.isa,
+      this.transform,
+      this.attr
+    );
+  }
+
+  transformer<T2>(fn: (v: NonNullable<VT>) => T2) {
+    return new AtomSchema<VT, T2>(
+      SchemaType.atom,
+      this.value,
+      this.isNullable,
+      this.isOptional,
+      this.isa,
+      fn,
+      this.attr
+    );
+  }
+
+  set(attr: Attr) {
+    const newAttr = mergeRight(this.attr, attr);
+    return new AtomSchema<VT, VT2>(
+      SchemaType.atom,
+      this.value,
+      this.isNullable,
+      this.isOptional,
+      this.isa,
+      this.transform,
+      newAttr
+    );
+  }
+}
+
+export class ArraySchema<
+  InnerSchema extends InnerSchemaForArraySchema | null | undefined
+> {
+  readonly innerSchema: InnerSchema;
+
+  constructor(
+    readonly type: SchemaType.array,
+    readonly itemSchema: Schema,
+    readonly isNullable: boolean,
+    readonly isOptional: boolean,
+    readonly attr: Attr // 額外附加的屬性
+  ) {}
+
+  nullable() {
+    return new ArraySchema<InnerSchema | null>(
+      SchemaType.array,
+      this.itemSchema,
+      true,
+      this.isOptional,
+      this.attr
+    );
+  }
+
+  optional() {
+    return new ArraySchema<InnerSchema | undefined>(
+      SchemaType.array,
+      this.itemSchema,
+      this.isNullable,
+      true,
+      this.attr
+    );
+  }
+
+  set(attr: Attr) {
+    const newAttr = mergeRight(this.attr, attr);
+    return new ArraySchema<InnerSchema>(
+      SchemaType.array,
+      this.itemSchema,
+      this.isNullable,
+      this.isOptional,
+      newAttr
+    );
+  }
+}
+
+export class ObjectSchema<
+  InnerSchema extends InnerSchemaForObjectSchema | null | undefined
+> {
+  constructor(
+    readonly type: SchemaType.object,
+    readonly innerSchema: InnerSchema,
+    readonly isNullable: boolean,
+    readonly isOptional: boolean,
+    readonly attr: Attr // 額外附加的屬性
+  ) {}
+
+  nullable() {
+    return new ObjectSchema<InnerSchema | null>(
+      SchemaType.object,
+      this.innerSchema,
+      true,
+      this.isOptional,
+      this.attr
+    );
+  }
+
+  optional() {
+    return new ObjectSchema<InnerSchema | undefined>(
+      SchemaType.object,
+      this.innerSchema,
+      this.isNullable,
+      true,
+      this.attr
+    );
+  }
+
+  set(attr: Attr) {
+    const newAttr = mergeRight(this.attr, attr);
+    return new ObjectSchema<InnerSchema>(
+      SchemaType.object,
+      this.innerSchema,
+      this.isNullable,
+      this.isOptional,
+      newAttr
+    );
+  }
+}
+
+class TupleSchema<
+  InnerSchema extends [Schema, ...Schema[]] | null | undefined
+> {
+  constructor(
+    readonly type: SchemaType.tuple,
+    readonly innerSchema: InnerSchema,
+    readonly isNullable: boolean,
+    readonly isOptional: boolean,
+    readonly attr: Attr // 額外附加的屬性
+  ) {}
+
+  nullable() {
+    return new TupleSchema<InnerSchema | null>(
+      SchemaType.tuple,
+      this.innerSchema,
+      true,
+      this.isOptional,
+      this.attr
+    );
+  }
+
+  optional() {
+    return new TupleSchema<InnerSchema | undefined>(
+      SchemaType.tuple,
+      this.innerSchema,
+      this.isNullable,
+      true,
+      this.attr
+    );
+  }
+
+  set(attr: Attr) {
+    const newAttr = mergeRight(this.attr, attr);
+    return new TupleSchema<InnerSchema>(
+      SchemaType.tuple,
+      this.innerSchema,
+      this.isNullable,
+      this.isOptional,
+      newAttr
+    );
+  }
+}
+
+class UnionSchema<InnerSchema extends Schema[] | null | undefined> {
+  constructor(
+    readonly type: SchemaType.union,
+    readonly innerSchema: InnerSchema,
+    readonly isNullable: boolean,
+    readonly isOptional: boolean,
+    readonly attr: Attr // 額外附加的屬性
+  ) {}
+
+  nullable() {
+    return new UnionSchema<InnerSchema | null>(
+      SchemaType.union,
+      this.innerSchema,
+      true,
+      this.isOptional,
+      this.attr
+    );
+  }
+
+  optional() {
+    return new UnionSchema<InnerSchema | undefined>(
+      SchemaType.union,
+      this.innerSchema,
+      this.isNullable,
+      true,
+      this.attr
+    );
+  }
+
+  set(attr: Attr) {
+    const newAttr = mergeRight(this.attr, attr);
+    return new UnionSchema<InnerSchema>(
+      SchemaType.union,
+      this.innerSchema,
+      this.isNullable,
+      this.isOptional,
+      newAttr
+    );
+  }
+}
+
+export type Schema =
+  | AtomSchema<any, any>
+  | ArraySchema<InnerSchemaForArraySchema | null | undefined>
+  | TupleSchema<[Schema, ...Schema[]] | null | undefined>
+  | UnionSchema<Schema[] | null | undefined>
+  | ObjectSchema<InnerSchemaForObjectSchema | null | undefined>;
+
+type InnerSchemaForArraySchema = Schema[];
+
+export type InnerSchemaForObjectSchema = {
+  [field: string]: Schema;
+};
+
+export namespace Schema {
+  export function value<T>(isa: (v) => string | null) {
+    return new AtomSchema<T, T>(
+      SchemaType.atom,
+      null as any,
+      false,
+      false,
+      isa,
+      (v: T) => v,
+      {}
+    );
+  }
+
+  export function array<S extends Schema>(itemSchema: S) {
+    return new ArraySchema<S[]>(SchemaType.array, itemSchema, false, false, {});
+  }
+
+  export function object<S extends InnerSchemaForObjectSchema>(innerSchema: S) {
+    return new ObjectSchema<S>(
+      SchemaType.object,
+      innerSchema,
+      false,
+      false,
+      {}
+    );
+  }
+
+  export function tuple<tuple extends [Schema, ...Schema[]]>(schemas: tuple) {
+    return new TupleSchema<tuple>(SchemaType.tuple, schemas, false, false, {});
+  }
+
+  export function union<union extends Schema[]>(schemas: union) {
+    return new UnionSchema<union>(SchemaType.union, schemas, false, false, {});
+  }
+}
+
+export type fetchAtom<T extends Schema> = T extends { type: SchemaType.atom }
+  ? T
+  : never;
+export type fetchArray<T extends Schema> = T extends { type: SchemaType.array }
+  ? T
+  : never;
+export type fetchObject<T extends Schema> = T extends {
+  type: SchemaType.object;
+}
+  ? T
+  : never;
+export type fetchTuple<T extends Schema> = Extract<T, TupleSchema<any>>;
+export type fetchUnion<T extends Schema> = Extract<T, UnionSchema<any>>;
+
+export type build<S extends Schema, transformed extends boolean> = S extends {
+  type: SchemaType.object;
+}
+  ? buildObj<fetchObject<S>["innerSchema"], transformed>
+  : S extends { type: SchemaType.array }
+  ? buildArray<fetchArray<S>["innerSchema"], transformed>
+  : S extends { type: SchemaType.tuple }
+  ? buildTuple<fetchTuple<S>["innerSchema"], transformed>
+  : S extends { type: SchemaType.union }
+  ? buildUnion<fetchUnion<S>["innerSchema"], transformed>
+  : S extends { type: SchemaType.atom }
+  ? buildAtom<fetchAtom<S>, transformed>
+  : never;
+
+type buildObj<
+  OS extends InnerSchemaForObjectSchema | null | undefined,
+  transformed extends boolean
+> = OS extends InnerSchemaForObjectSchema
+  ? flatten<addQuestionMarks<{ [f in keyof OS]: build<OS[f], transformed> }>>
+  : OS;
+
+type buildArray<
+  S extends InnerSchemaForArraySchema | null | undefined,
+  transformed extends boolean
+> = S extends InnerSchemaForArraySchema ? build<S[number], transformed>[] : S;
+
+type buildTuple<
+  S extends any[] | null | undefined,
+  transformed extends boolean
+> = S extends [Schema, ...Schema[]]
+  ? [
+      build<resolveTuple<S>[0], transformed>,
+      ...buildTuple<resolveTuple<S>[1], transformed>
+    ]
+  : S;
+
+type buildUnion<
+  S extends Schema[] | null | undefined,
+  transformed extends boolean
+> = S extends Schema[] ? build<S[number], transformed> : S;
+
+type buildAtom<
+  S extends Schema | null | undefined,
+  transformed extends boolean
+> = S extends Schema
+  ? transformed extends true
+    ?
+        | ReturnType<fetchAtom<S>["transform"]>
+        | Extract<fetchAtom<S>["value"], null | undefined>
+    : fetchAtom<S>["value"]
+  : S;

package/src/util.ts

@@ -0,0 +1,35 @@
+// ref: https://github.com/colinhacks/zod
+
+export type flatten<T> = identity<{ [k in keyof T]: T[k] }>;
+
+export type addQuestionMarks<T extends object> = {
+  [K in requiredKeys<T>]: T[K];
+} & {
+  [K in optionalKeys<T>]?: T[K];
+};
+
+export type resolveTuple<tuple> = tuple extends [infer h, ...infer r]
+  ? [h, r]
+  : never;
+
+type identity<T> = T;
+
+type optionalKeys<T extends object> = {
+  [k in keyof T]: undefined extends T[k] ? k : never;
+}[keyof T];
+
+type requiredKeys<T extends object> = {
+  [k in keyof T]: undefined extends T[k] ? never : k;
+}[keyof T];
+
+class AssertError extends Error {}
+
+export function assert(condition: unknown, message: string): asserts condition {
+  if (!condition) {
+    throw new AssertError(message);
+  }
+}
+
+export function pair<A, B>(a: A, b: B): [A, B] {
+  return [a, b];
+}

package/test/enums.ts

@@ -0,0 +1,32 @@
+import * as assert from "assert";
+import * as Schema from "../src/index";
+
+declare const describe, it;
+
+describe("enums", () => {
+  const schema = Schema.enums([1, 2, "yes", "no"]);
+  type Types = Schema.buildType<typeof schema>;
+
+  it("type", () => {
+    const t1: Types = 1;
+    const t2: Types = 2;
+    const t3: Types = "yes";
+    const t4: Types = "no";
+    //@ts-expect-error
+    const t5: Types = 3;
+    //@ts-expect-error
+    const t6: Types = "error";
+  });
+
+  it("transform", () => {
+    assert.strictEqual(Schema.transform(schema, 2)[0], null);
+    assert.strictEqual(
+      Schema.transform(schema, 3)[0],
+      "not a valid enum value, value should be one of [1,2,yes,no]"
+    );
+    assert.strictEqual(
+      Schema.transform(schema, "e")[0],
+      "not a valid enum value, value should be one of [1,2,yes,no]"
+    );
+  });
+});

package/test/nullable.ts

@@ -0,0 +1,84 @@
+import * as assert from "assert";
+import * as Schema from "../src/index";
+
+declare const describe, it;
+
+describe("nullable field", () => {
+  describe("atom", () => {
+    const schema = Schema.object({
+      name: Schema.string(),
+      age: Schema.string().transformer((v) => parseInt(v)),
+    });
+
+    const nullableSchema = Schema.object({
+      name: Schema.string(),
+      age: Schema.string()
+        .nullable()
+        .transformer((v) => parseInt(v)),
+    });
+
+    const o = {
+      name: "jack",
+      age: null,
+    };
+
+    it("is null -- only check", () => {
+      assert.ok(Schema.check(schema, o) !== null);
+      assert.ok(Schema.check(nullableSchema, o) === null);
+    });
+
+    it("is null -- transform", () => {
+      const [error, _] = Schema.transform(schema, o);
+      assert.ok(error !== null);
+
+      const [__, m] = Schema.transform(nullableSchema, o);
+      assert.ok(m !== null);
+      assert.ok(m.age === null);
+    });
+  });
+
+  describe("array", () => {
+    const schema = Schema.object({
+      name: Schema.string(),
+      friends: Schema.array(Schema.number()),
+    });
+
+    const nullableSchema = Schema.object({
+      name: Schema.string(),
+      friends: Schema.array(Schema.number()).nullable(),
+    });
+
+    const o = {
+      name: "jack",
+      friends: null,
+    };
+
+    it("is null -- only check", () => {
+      assert.ok(Schema.check(schema, o) !== null);
+      assert.ok(Schema.check(nullableSchema, o) === null);
+    });
+
+    it("is null -- transform", () => {
+      const [error, _] = Schema.transform(schema, o);
+      assert.ok(error !== null);
+
+      const [__, m] = Schema.transform(nullableSchema, o);
+      assert.ok(m !== null);
+      assert.ok(m.friends === null);
+    });
+  });
+});
+
+it("pass null to a non-nullable schema", () => {
+  const arraySchema = Schema.array(Schema.string());
+
+  const objSchema = Schema.object({
+    name: Schema.string(),
+  });
+
+  assert.strictEqual(Schema.check(objSchema, null), "is not an object");
+  const [_, m] = Schema.transform(objSchema, null);
+  assert.ok(m === null);
+  assert.strictEqual(Schema.check(arraySchema, null), "is not an Array");
+  assert.strictEqual(Schema.check(Schema.string(), null), "is not a string");
+});

package/test/tuple.ts

@@ -0,0 +1,63 @@
+import * as Schema from "../src/index";
+import { assert } from "../src/util";
+
+declare const describe, it;
+
+describe("tuple", () => {
+  const colorSchema = Schema.tuple([
+    Schema.object({
+      name: Schema.string(),
+    }).nullable(),
+    Schema.number(),
+    Schema.number(),
+    Schema.number(),
+  ]);
+  type color = Schema.buildType<typeof colorSchema>;
+
+  it("type", () => {
+    type name = color[0];
+    type r = color[1];
+    type g = color[2];
+    type b = color[3];
+    //@ts-expect-error
+    type x = color[4];
+
+    const n1: name = null;
+    const n2: name = { name: "" };
+    //@ts-expect-error
+    const n3: name = {};
+
+    const b: b = 5;
+    //@ts-expect-error
+    const b1: b = null;
+
+    const e1 = Schema.check(colorSchema, [{ name: "red" }, 255, 0]);
+    assert(e1 === "tuple size error", "e1");
+    const e2 = Schema.check(colorSchema, [{ name: "red" }, 255, "0", 0]);
+    assert(e2 === "tuple item 2 is wrong (is not a number)", "e2");
+    const e3 = Schema.check(colorSchema, [{ name: "red" }, 255, 0, 0]);
+    assert(e3 === null, "e3");
+  });
+
+  it("compound", () => {
+    const car = Schema.object({
+      name: Schema.string(),
+      color: Schema.tuple([
+        Schema.object({
+          name: Schema.string(),
+        }).nullable(),
+        Schema.number().transformer((v) => v.toString()),
+        Schema.number().transformer((v) => v.toString()),
+        Schema.number().transformer((v) => v.toString()),
+      ]),
+    });
+    type car = Schema.buildType<typeof car>;
+    const [e, c] = Schema.transform(car, {
+      name: "toyota",
+      color: [{ name: "red" }, 255, 0, 0],
+    });
+    assert(c !== null, "e1");
+    assert(c.color[0]!.name === "red", "e2");
+    assert(c.color[1] === "255", "e3");
+  });
+});

package/test/union.ts

@@ -0,0 +1,112 @@
+import * as m from "../src/index";
+import { assert } from "../src/util";
+
+declare const describe, it;
+
+describe("tuple", () => {
+  it("setting usecase", () => {
+    const setting = m.union([
+      m.object({
+        type: m.enums<"position">(["position"]),
+        value: m.enums<"left" | "right">(["left", "right"]),
+      }),
+      m.object({
+        type: m.enums<"width">(["width"]),
+        value: m.number(),
+      }),
+    ]);
+    type setting = m.buildType<typeof setting>;
+    const a: setting = { type: "position", value: "left" };
+    const b: setting = { type: "width", value: 5 };
+    //@ts-expect-error
+    const c: setting = { type: "position", value: "top" };
+    //@ts-expect-error
+    const d: setting = { type: "height", value: 5 };
+
+    const datas = [
+      { type: "position", value: "left" },
+      { type: "position", value: "top" },
+      { type: "width", value: 5 },
+    ];
+    const valids = datas
+      .map((i) => m.transform(setting, i)[1])
+      .filter((i): i is NonNullable<typeof i> => i !== null);
+    assert(valids.length === 2, "");
+  });
+
+  it("simple", () => {
+    const color = m.object({
+      name: m.string(),
+      rgb: m.tuple([m.number(), m.number(), m.number()]),
+    });
+    const schema = m.union([
+      m.string(),
+      m.boolean().transformer((_) => 1),
+      m.array(color),
+    ]);
+    type u = m.buildType<typeof schema>;
+
+    const a: u = "";
+    const b: u = 1;
+    const c: u = [{ name: "red", rgb: [1, 2, 3] }];
+    //@ts-expect-error
+    const d: u = true;
+    //@ts-expect-error
+    const e: u = { name: "red", rgb: [1, 2, 3] };
+    //@ts-expect-error
+    const f: u = [{ name: "red", rgb: [1, 2, 3, 4] }];
+
+    assert(m.check(schema, "") === null, "c1");
+    assert(m.check(schema, false) === null, "c2");
+    assert(m.check(schema, 1) !== null, "c3");
+
+    assert(m.transform(schema, true)[1] === 1, "t1");
+    assert(
+      m.transform(schema, [{ name: "red", rgb: [1, 2, 3] }])[1]![0].name ===
+        "red",
+      "t2"
+    );
+
+    assertOk(m.transform(schema, true), "t3");
+    assertOk(m.transform(schema, [{ name: "red", rgb: [1, 2, 3] }]), "t4");
+    assertError(m.transform(schema, 1), "t5");
+    assertError(m.transform(schema, [{ name: "red", rgb: [1, 2, "3"] }]), "t6");
+  });
+
+  it("compound", () => {
+    const carSchema = m.object({
+      name: m.string(),
+      color: m.union([
+        m.object({
+          name: m.enums<"red">(["red"]),
+        }),
+        m.object({
+          name: m.enums<"black">(["black"]),
+        }),
+      ]),
+    });
+    type car = m.buildType<typeof carSchema>;
+    const a: car = { name: "toyota", color: { name: "red" } };
+    //@ts-expect-error
+    const b: car = { name: "toyota", color: { name: "blue" } };
+
+    assertOk(
+      m.transform(carSchema, { name: "toyota", color: { name: "red" } }),
+      "e1"
+    );
+    assertError(
+      m.transform(carSchema, { name: "toyota", color: { name: "blue" } }),
+      "e2"
+    );
+  });
+});
+
+function assertOk<data>(result: [null, data] | [string, null], msg: string) {
+  const [error, data] = result;
+  assert(error === null, msg);
+}
+
+function assertError<data>(result: [null, data] | [string, null], msg: string) {
+  const [error, data] = result;
+  assert(error !== null, msg);
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "compilerOptions": {
+        "outDir": "dst/",
+        "declaration": true,
+        "strictNullChecks": true,
+        "target": "ES6",
+        "module": "commonjs",
+        // "jsx": "react",
+    },
+    "files": [
+        "src/index.ts",
+        "test.ts",
+    ],
+    "include": [
+        "test",
+    ],
+}