@shapecraft/core 1.0.0

package/src/shape/validate.ts

@@ -0,0 +1,413 @@
+import { isNumeric, isPlainObject, R } from "../common";
+import { remapObjectEntries, remapObjectValues } from "../common/object";
+import { ValidationError } from "./error";
+import { inferNumberTag, numberTagCanBeCastedTo } from "./number";
+import { shapes } from "./shape";
+import { NumberTag } from "./tags";
+
+export function validate(
+  shape: shapes.Shape,
+  input: unknown,
+): Array<ValidationError> {
+  const errUnexpectedType = (
+    path: PropertyKey[],
+    input: unknown,
+    expected: string,
+  ): ValidationError => ({
+    path,
+    message: `Expected type of '${expected}' but got '${typeof input}'`,
+  });
+
+  const errUnexpectedLiteral = (
+    path: PropertyKey[],
+    input: unknown,
+    expected: string,
+  ): ValidationError => ({
+    path,
+    message: `Expected literal ${expected} but got ${input}`,
+  });
+
+  const errNumberFormatMismatch = (
+    path: PropertyKey[],
+    input: NumberTag,
+    expected: NumberTag,
+  ): ValidationError => ({
+    path,
+    message: `Expected number format ${expected} but got ${input}`,
+  });
+
+  const errBelowMin = (
+    path: PropertyKey[],
+    actual: number,
+    min: number,
+    kind: string,
+  ): ValidationError => ({
+    path,
+    message: `Expected ${kind} to be >= ${min} but got ${actual}`,
+  });
+
+  const errAboveMax = (
+    path: PropertyKey[],
+    actual: number,
+    max: number,
+    kind: string,
+  ): ValidationError => ({
+    path,
+    message: `Expected ${kind} to be <= ${max} but got ${actual}`,
+  });
+
+  const checkBounds = (
+    anno: { min?: number; max?: number },
+    actual: number,
+    path: PropertyKey[],
+    kind: string,
+  ): ValidationError[] => {
+    if (anno.min !== undefined && actual < anno.min)
+      return [errBelowMin(path, actual, anno.min, kind)];
+    if (anno.max !== undefined && actual > anno.max)
+      return [errAboveMax(path, actual, anno.max, kind)];
+    return [];
+  };
+
+  const check = (
+    shape: shapes.Shape,
+    input: unknown,
+    path: PropertyKey[],
+  ): ValidationError[] => {
+    switch (shape.type) {
+      case "unknown":
+        return [];
+      case "string": {
+        if (typeof input !== "string")
+          return [errUnexpectedType(path, input, shape.type)];
+        if (shape.literal && input !== shape.input)
+          return [errUnexpectedLiteral(path, input, `${shape.input}`)];
+        const boundsErrors = checkBounds(
+          shape.anno,
+          input.length,
+          path,
+          "string length",
+        );
+        if (boundsErrors.length > 0) return boundsErrors;
+        if (shape.anno.pattern !== undefined) {
+          const re =
+            shape.anno.pattern instanceof RegExp ?
+              shape.anno.pattern
+            : new RegExp(shape.anno.pattern);
+          if (!re.test(input))
+            return [
+              {
+                path,
+                message: `Expected string to match pattern ${re} but got '${input}'`,
+              },
+            ];
+        }
+        return [];
+      }
+      case "boolean": {
+        if (typeof input !== shape.type)
+          return [errUnexpectedType(path, input, shape.type)];
+        if (shape.literal && input !== shape.input)
+          return [errUnexpectedLiteral(path, input, `${shape.input}`)];
+        return [];
+      }
+      case "number": {
+        if (typeof input !== "number")
+          return [errUnexpectedType(path, input, shape.type)];
+        if (shape.literal && input !== shape.input)
+          return [errUnexpectedLiteral(path, input, `${shape.input}`)];
+        const inputTag = inferNumberTag(input);
+        if (!numberTagCanBeCastedTo(inputTag, shape.tag))
+          return [errNumberFormatMismatch(path, inputTag, shape.tag)];
+        const boundsErrors = checkBounds(shape.anno, input, path, "value");
+        if (boundsErrors.length > 0) return boundsErrors;
+        return [];
+      }
+      case "array": {
+        if (!Array.isArray(input))
+          return [errUnexpectedType(path, input, shape.type)];
+        const boundsErrors = checkBounds(
+          shape.anno,
+          input.length,
+          path,
+          "array length",
+        );
+        if (boundsErrors.length > 0) return boundsErrors;
+        const errors = input
+          .map((x, i) => check(shape.input, x, [...path, i]))
+          .flat();
+        if (errors.length > 0) return errors;
+        return [];
+      }
+      case "binary": {
+        if (input instanceof Uint8Array) return [];
+        if (Array.isArray(input)) {
+          const num = shapes.uint8();
+          const errors = input
+            .map((x, i) => check(num, x, [...path, i]))
+            .flat();
+          if (errors.length > 0) return errors;
+          return [];
+        }
+        return [errUnexpectedType(path, input, shape.type)];
+      }
+      case "date": {
+        if (!(input instanceof Date))
+          return [errUnexpectedType(path, input, shape.type)];
+        return [];
+      }
+      case "nil": {
+        if (input !== null)
+          return [errUnexpectedType(path, input, shape.type)];
+        return [];
+      }
+      case "undefined": {
+        if (typeof input !== "undefined")
+          return [errUnexpectedType(path, input, shape.type)];
+        return [];
+      }
+      case "vector": {
+        if (!Array.isArray(input))
+          return [errUnexpectedType(path, input, shape.type)];
+        if (input.length !== shape.input.dims)
+          return [
+            {
+              path,
+              message: `Expected a vector with dimensions ${shape.input.dims} but got an array of length ${input.length}`,
+            },
+          ];
+        const errors = input
+          .map((x, i) => check(shape.input.format, x, [...path, i]))
+          .flat();
+        if (errors.length > 0) return errors;
+        return [];
+      }
+      case "tuple": {
+        if (!Array.isArray(input))
+          return [errUnexpectedType(path, input, shape.type)];
+        if (input.length !== shape.input.length)
+          return [
+            {
+              path,
+              message: `Expected a tuple of length ${shape.input.length} but got an array of length ${input.length}`,
+            },
+          ];
+        const errors = shape.input
+          .map((item, i) => check(item, input[i], [...path, i]))
+          .flat();
+        if (errors.length > 0) return errors;
+        return [];
+      }
+      case "range": {
+        if (typeof input !== "object" || input === null)
+          return [errUnexpectedType(path, input, shape.type)];
+        const rec = input as Record<string, unknown>;
+        if (
+          !("lower" in rec) ||
+          !("upper" in rec) ||
+          !("lowerInclusive" in rec) ||
+          !("upperInclusive" in rec)
+        )
+          return [
+            {
+              path,
+              message:
+                "Expected range with keys 'lower', 'upper', 'lowerInclusive', 'upperInclusive'",
+            },
+          ];
+        if (typeof rec["lowerInclusive"] !== "boolean")
+          return [
+            {
+              path: [...path, "lowerInclusive"],
+              message: `Expected boolean but got '${typeof rec["lowerInclusive"]}'`,
+            },
+          ];
+        if (typeof rec["upperInclusive"] !== "boolean")
+          return [
+            {
+              path: [...path, "upperInclusive"],
+              message: `Expected boolean but got '${typeof rec["upperInclusive"]}'`,
+            },
+          ];
+        const errors: ValidationError[] = [];
+        if (rec["lower"] !== null) {
+          errors.push(
+            ...check(shape.input, rec["lower"], [...path, "lower"]),
+          );
+        }
+        if (rec["upper"] !== null) {
+          errors.push(
+            ...check(shape.input, rec["upper"], [...path, "upper"]),
+          );
+        }
+        return errors;
+      }
+      case "mapping": {
+        if (typeof input !== "object")
+          return [errUnexpectedType(path, input, shape.type)];
+        if (input === null)
+          return [errUnexpectedType(path, input, shape.type)];
+
+        for (const [k, valueShape] of Object.entries(shape.input)) {
+          if (!(k in input)) {
+            if (valueShape.anno.optional) continue;
+            return [
+              { path: [...path, k], message: `Missing required key: '${k}'` },
+            ];
+          }
+          const actualValue = (input as Record<PropertyKey, unknown>)[k];
+          const errors = check(valueShape, actualValue, [...path, k]);
+          if (errors.length > 0) return errors;
+        }
+        return [];
+      }
+      case "record": {
+        if (typeof input !== "object")
+          return [errUnexpectedType(path, input, shape.type)];
+        if (input === null)
+          return [errUnexpectedType(path, input, shape.type)];
+
+        const inputRec = input as Record<PropertyKey, unknown>;
+
+        const keys = Object.keys(inputRec);
+        const keyErrors = keys
+          .map((key) => check(shape.input[0], key, path))
+          .flat();
+        if (keyErrors.length > 0) return keyErrors;
+
+        const valueErrors = Object.entries(inputRec)
+          .map(([k, v]) => check(shape.input[1], v, [...path, k]))
+          .flat();
+        if (valueErrors.length > 0) return valueErrors;
+
+        return [];
+      }
+      case "union": {
+        const errors: ValidationError[] = [];
+        for (const t of shape.input) {
+          const errs = check(t, input, path);
+          if (errs.length <= 0) return [];
+          errors.push(...errs);
+        }
+        return errors;
+      }
+      case "module": {
+        if (typeof input !== "object" || input === null)
+          return [errUnexpectedType(path, input, shape.type)];
+        for (const [k, tableShape] of Object.entries(shape.input)) {
+          if (!(k in input)) {
+            return [
+              {
+                path: [...path, k],
+                message: `Missing required table: '${k}'`,
+              },
+            ];
+          }
+          const actualValue = (input as Record<PropertyKey, unknown>)[k];
+          const errors = check(tableShape, actualValue, [...path, k]);
+          if (errors.length > 0) return errors;
+        }
+        return [];
+      }
+    }
+  };
+
+  return check(shape, input, []);
+}
+
+export function is<S extends shapes.Shape>(
+  shape: S,
+  input: unknown,
+): input is shapes.InferShapeOut<S> {
+  return validate(shape, input).length <= 0;
+}
+
+const autoCastFromString = (shape: shapes.Shape, input: string): unknown => {
+  switch (shape.type) {
+    case "string":
+      return input;
+    case "number":
+      return isNumeric(input) ? Number(input) : input;
+    case "boolean": {
+      const low = input.toLowerCase().trim();
+      return (
+        {
+          true: true,
+          false: false,
+          yes: true,
+          no: false,
+          on: true,
+          off: false,
+          "1": true,
+          "0": false,
+        }[low] ?? input
+      );
+    }
+    case "record":
+    case "array":
+    case "mapping": {
+      const clean = input.trim();
+      try {
+        return JSON.parse(clean);
+      } catch {
+        return input;
+      }
+    }
+    case "date": {
+      const clean = input.trim();
+      try {
+        const date = new Date(clean);
+        const time = date.getTime();
+        if (isNaN(time) || !isFinite(time)) return input;
+        return date;
+      } catch {
+        return input;
+      }
+    }
+    default:
+      return input;
+  }
+};
+
+const autoCast = (shape: shapes.Shape, input: unknown): unknown => {
+  if (typeof input === "string") input = autoCastFromString(shape, input);
+
+  switch (shape.type) {
+    case "mapping": {
+      if (isPlainObject(input)) {
+        return remapObjectValues(input, ([k, v]) => {
+          if (typeof k !== "string") return v;
+          const s = shape.input[k];
+          if (!s) return v;
+          return autoCast(s, v);
+        });
+      }
+      return input;
+    }
+    case "record": {
+      if (isPlainObject(input)) {
+        return remapObjectEntries(input, ([k, v]) => {
+          const ks = shape.input[0];
+          const vs = shape.input[1];
+          const castedK = autoCast(ks, k);
+          const castedV = autoCast(vs, v);
+          if (typeof castedK !== "string") return { [k]: v };
+          return { [castedK]: castedV };
+        });
+      }
+      return input;
+    }
+  }
+
+  return input;
+};
+
+export function parse<S extends shapes.Shape>(
+  shape: S,
+  input: unknown,
+): R.Result<shapes.InferShapeOut<S>, ValidationError[]> {
+  input = autoCast(shape, input);
+  const errors = validate(shape, input);
+  if (errors.length > 0) return R.err(errors);
+  return R.ok(input as shapes.InferShapeOut<S>);
+}

package/tsconfig.cjs.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "ignoreDeprecations": "6.0"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts", "./src/**/*.sample.ts"]
+}

package/tsconfig.esm.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/esm",
+    "module": "esnext",
+    "target": "esnext"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist/esm",
+    "module": "esnext",
+    "target": "esnext",
+    "lib": ["esnext"],
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}