@leon740727/type-schema 0.0.3

package/dst/test/nullable.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const Schema = require("../src/index");
+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/dst/test/tuple.d.ts

@@ -0,0 +1 @@
+export {};

package/dst/test/tuple.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Schema = require("../src/index");
+const util_1 = require("../src/util");
+describe("tuple", () => {
+    const colorSchema = Schema.tuple([
+        Schema.object({
+            name: Schema.string(),
+        }).nullable(),
+        Schema.number(),
+        Schema.number(),
+        Schema.number(),
+    ]);
+    it("type", () => {
+        const n1 = null;
+        const n2 = { name: "" };
+        //@ts-expect-error
+        const n3 = {};
+        const b = 5;
+        //@ts-expect-error
+        const b1 = null;
+        const e1 = Schema.check(colorSchema, [{ name: "red" }, 255, 0]);
+        (0, util_1.assert)(e1 === "tuple size error", "e1");
+        const e2 = Schema.check(colorSchema, [{ name: "red" }, 255, "0", 0]);
+        (0, util_1.assert)(e2 === "tuple item 2 is wrong (is not a number)", "e2");
+        const e3 = Schema.check(colorSchema, [{ name: "red" }, 255, 0, 0]);
+        (0, util_1.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()),
+            ]),
+        });
+        const [e, c] = Schema.transform(car, {
+            name: "toyota",
+            color: [{ name: "red" }, 255, 0, 0],
+        });
+        (0, util_1.assert)(c !== null, "e1");
+        (0, util_1.assert)(c.color[0].name === "red", "e2");
+        (0, util_1.assert)(c.color[1] === "255", "e3");
+    });
+});

package/dst/test/union.d.ts

@@ -0,0 +1 @@
+export {};

package/dst/test/union.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const m = require("../src/index");
+const util_1 = require("../src/util");
+describe("tuple", () => {
+    it("setting usecase", () => {
+        const setting = m.union([
+            m.object({
+                type: m.enums(["position"]),
+                value: m.enums(["left", "right"]),
+            }),
+            m.object({
+                type: m.enums(["width"]),
+                value: m.number(),
+            }),
+        ]);
+        const a = { type: "position", value: "left" };
+        const b = { type: "width", value: 5 };
+        //@ts-expect-error
+        const c = { type: "position", value: "top" };
+        //@ts-expect-error
+        const d = { 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 !== null);
+        (0, util_1.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),
+        ]);
+        const a = "";
+        const b = 1;
+        const c = [{ name: "red", rgb: [1, 2, 3] }];
+        //@ts-expect-error
+        const d = true;
+        //@ts-expect-error
+        const e = { name: "red", rgb: [1, 2, 3] };
+        //@ts-expect-error
+        const f = [{ name: "red", rgb: [1, 2, 3, 4] }];
+        (0, util_1.assert)(m.check(schema, "") === null, "c1");
+        (0, util_1.assert)(m.check(schema, false) === null, "c2");
+        (0, util_1.assert)(m.check(schema, 1) !== null, "c3");
+        (0, util_1.assert)(m.transform(schema, true)[1] === 1, "t1");
+        (0, util_1.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"]),
+                }),
+                m.object({
+                    name: m.enums(["black"]),
+                }),
+            ]),
+        });
+        const a = { name: "toyota", color: { name: "red" } };
+        //@ts-expect-error
+        const b = { 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(result, msg) {
+    const [error, data] = result;
+    (0, util_1.assert)(error === null, msg);
+}
+function assertError(result, msg) {
+    const [error, data] = result;
+    (0, util_1.assert)(error !== null, msg);
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@leon740727/type-schema",
+  "version": "0.0.3",
+  "description": "",
+  "main": "dst/src/index.js",
+  "scripts": {
+    "test": "npx mocha dst/test"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^14.14.34",
+    "@types/ramda": "^0.27.38",
+    "mocha": "^8.3.2",
+    "typescript": "^4.1.5"
+  },
+  "dependencies": {
+    "ramda": "^0.27.1",
+    "types": "https://github.com/leon740727/types.git#semver:~0.3.2"
+  }
+}

package/src/check.ts

@@ -0,0 +1,147 @@
+import { not, toPairs, zip } from "ramda";
+import { Optional } from "types";
+import {
+  Schema,
+  SchemaType,
+  AtomSchema,
+  InnerSchemaForObjectSchema,
+} from "./type";
+import { assert, pair } from "./util";
+
+type Error = {
+  paths: string[];
+  msg: string;
+};
+
+export function check(schema: Schema, value): Optional<string> {
+  return _check(schema, value).map(error2string);
+}
+
+function error2string(error: Error) {
+  if (error.paths.length > 0) {
+    return `obj.${error.paths.join(".")} ${error.msg}`;
+  } else {
+    return error.msg;
+  }
+}
+
+function _check(schema: Schema, value): Optional<Error> {
+  if (value === null && schema.isNullable) {
+    return Optional.empty();
+  }
+  if (value === undefined && schema.isOptional) {
+    return Optional.empty();
+  }
+  if (schema.type === SchemaType.object) {
+    if (typeof value === "object" && value !== null) {
+      // typeof null === 'object'
+      assert(schema.innerSchema, "object inner schema is null or undefined");
+      return checkObject(schema.innerSchema, value);
+    } else {
+      return Optional.of({
+        paths: [],
+        msg: "is not an object",
+      });
+    }
+  } else if (schema.type === SchemaType.array) {
+    if (value instanceof Array) {
+      return checkArray(schema.itemSchema, value);
+    } else {
+      return Optional.of({
+        paths: [],
+        msg: "is not an Array",
+      });
+    }
+  } else if (schema.type === SchemaType.tuple) {
+    if (value instanceof Array) {
+      assert(schema.innerSchema, "tuple inner schema is null or undefined");
+      return checkTuple(schema.innerSchema, value);
+    } else {
+      return Optional.of({
+        paths: [],
+        msg: "is not a tuple",
+      });
+    }
+  } else if (schema.type === SchemaType.union) {
+    assert(schema.innerSchema, "union inner schema is null or undefined");
+    return checkUnion(schema.innerSchema, value);
+  } else {
+    return checkAtom(schema, value);
+  }
+}
+
+function checkObject(
+  schema: InnerSchemaForObjectSchema,
+  value
+): Optional<Error> {
+  // schema 沒有規範到的欄位不檢查
+  const toChecks: [string, Schema][] = toPairs(schema)
+    .filter(([field, schema]) => {
+      return (
+        schema.isOptional === false ||
+        (schema.isOptional && value[field] !== undefined)
+      );
+    })
+    .map(([field, schema]) => [field, schema]);
+
+  const errors = toChecks.map(([field, schema]) => {
+    return _check(schema, value[field]).map((error) => ({
+      paths: [field].concat(error.paths),
+      msg: error.msg,
+    }));
+  });
+
+  return Optional.of(Optional.filter(errors)[0]);
+}
+
+function checkArray(schema: Schema, value: any[]): Optional<Error> {
+  const errors = value.map((v, idx) => {
+    return _check(schema, v).map((error) => pair(idx, error));
+  });
+
+  return Optional.of(Optional.filter(errors)[0]).map(([idx, error]) => ({
+    paths: [],
+    msg: `array item ${idx} is wrong (${error2string(error)})`,
+  }));
+}
+
+function checkTuple(schemas: Schema[], values: any[]): Optional<Error> {
+  if (schemas.length !== values.length) {
+    return Optional.of({ paths: [], msg: "tuple size error" });
+  } else {
+    const errors = zip(schemas, values).map(([schema, value], idx) =>
+      _check(schema, value).map((error) => ({
+        paths: [],
+        msg: `tuple item ${idx} is wrong (${error2string(error)})`,
+      }))
+    );
+
+    return Optional.of(Optional.filter(errors)[0]);
+  }
+}
+
+function checkUnion(schemas: Schema[], value: any): Optional<Error> {
+  const success = schemas.reduce((success, schema) => {
+    if (success) {
+      return success;
+    } else {
+      const error = _check(schema, value);
+      return not(error.present);
+    }
+  }, false);
+  if (success) {
+    return Optional.empty();
+  } else {
+    return Optional.of({
+      paths: [],
+      msg: "not in union",
+    });
+  }
+}
+
+function checkAtom(schema: AtomSchema<any, any>, value): Optional<Error> {
+  return Optional.of(schema.isa(value)).map((msg) => ({
+    paths: [],
+    msg,
+  }));
+}

package/src/index.ts

@@ -0,0 +1,71 @@
+import { Schema, build } from "./type";
+import { check as _check } from "./check";
+import { transform as _transform } from "./transform";
+
+export { Schema, SchemaType } from "./type";
+export const value = Schema.value;
+export const object = Schema.object;
+export const array = Schema.array;
+export const tuple = Schema.tuple;
+export const union = Schema.union;
+export type buildType<
+  T extends Schema,
+  transformed extends boolean = true
+> = build<T, transformed>;
+
+export function check(schema: Schema, value): string | null {
+  return _check(schema, value).orNull();
+}
+
+type Result<R> = [string, null] | [null, R];
+export function transform<S extends Schema>(
+  schema: S,
+  value
+): Result<build<S, true>> {
+  return _transform(schema, value).either(
+    //@ts-ignore
+    (error) => [error, null] as Result<build<S, true>>,
+    (value) => [null, value]
+  );
+}
+
+// helper
+export function any() {
+  return value<any>((v) => null);
+}
+
+export function string() {
+  return value<string>((v) =>
+    typeof v === "string" ? null : "is not a string"
+  );
+}
+
+export function number() {
+  return value<number>((v) =>
+    typeof v === "number" ? null : "is not a number"
+  );
+}
+
+export function boolean() {
+  return value<boolean>((v) =>
+    typeof v === "boolean" ? null : "is not a boolean"
+  );
+}
+
+export function bigint() {
+  return value<bigint>((v) =>
+    typeof v === "bigint" ? null : "is not a bigint"
+  );
+}
+
+export function date() {
+  return value<Date>((v) => (v instanceof Date ? null : "is not a Date"));
+}
+
+export function enums<T extends number | string>(valids: T[]) {
+  return Schema.value<T>((v) =>
+    valids.includes(v)
+      ? null
+      : `not a valid enum value, value should be one of [${valids}]`
+  );
+}

package/src/transform.ts

@@ -0,0 +1,96 @@
+import { fromPairs, mergeRight, toPairs, zip } from "ramda";
+import { Result } from "types";
+import { Schema, SchemaType, build, fetchAtom, fetchObject } from "./type";
+import { check } from "./check";
+import { assert, pair } from "./util";
+
+export function transform<S extends Schema>(
+  schema: S,
+  value
+): Result<string, build<S, true>> {
+  return check(schema, value)
+    .map((error) => Result.fail<string, build<S, true>>(error))
+    .orExec(() => Result.ok(_transform(schema, value)));
+}
+
+function _transform<S extends Schema>(schema: S, value): build<S, true> {
+  if (value === null) {
+    // check() 已經確認過 null 是合法的
+    return null as any;
+  }
+  if (value === undefined) {
+    return undefined as any;
+  }
+  if (schema.type === SchemaType.atom) {
+    return transformAtom(schema, value);
+  } else if (schema.type === SchemaType.array) {
+    return transformArray(schema, value);
+  } else if (schema.type === SchemaType.tuple) {
+    return transformTuple(schema, value);
+  } else if (schema.type === SchemaType.union) {
+    return transformUnion(schema, value);
+  } else {
+    return transformObject(schema, value);
+  }
+}
+
+function transformAtom<S extends Schema>(schema: S, value): build<S, true> {
+  return (schema as fetchAtom<S>).transform(value);
+}
+
+function transformArray<S extends Schema>(
+  schema: S,
+  values: any[]
+): build<S, true> {
+  assert(schema.type === SchemaType.array, "");
+  //@ts-ignore
+  return values.map((value) => _transform(schema.itemSchema, value)) as any;
+}
+
+function transformTuple<S extends Schema>(
+  schema: S,
+  values: any[]
+): build<S, true> {
+  assert(schema.type === SchemaType.tuple, "");
+  assert(schema.innerSchema, "");
+  return zip(schema.innerSchema, values).map(([schema, value]) =>
+    _transform(schema, value)
+  ) as any;
+}
+
+function transformUnion<S extends Schema>(
+  schema: S,
+  value: any
+): build<S, true> {
+  assert(schema.type === SchemaType.union, "");
+  assert(schema.innerSchema, "");
+  // 這裡不能用 _transform
+  // 因為 union 裡面的 schema 可能是錯的，但 _transform 假設每一個 schema 都是對的
+  const results = schema.innerSchema.map((schema) => transform(schema, value));
+  const oks = results.filter((i) => i.ok).map((i) => i.orError());
+  assert(oks.length > 0, "");
+  return oks[0];
+}
+
+function transformObject<S extends Schema>(
+  schema: S,
+  value: { [field: string]: any }
+): build<S, true> {
+  const innerSchema = (schema as fetchObject<Schema>).innerSchema;
+  assert(innerSchema, "object inner schema is null or undefined");
+  const todos: [string, Schema][] = toPairs(innerSchema)
+    .filter(([field, schema]) => {
+      return (
+        schema.isOptional === false ||
+        (schema.isOptional && value[field] !== undefined)
+      );
+    })
+    .map(([field, schema]) => [field, schema]);
+
+  const v2 = fromPairs(
+    todos.map(([field, schema]) =>
+      pair(field, _transform(schema, value[field]))
+    )
+  );
+  return mergeRight(value, v2) as any;
+}