shapecraft 1.0.0

package/packages/core/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/packages/core/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/packages/core/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/packages/core/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"]
+}

package/packages/samples/node_modules/.bin/prettier

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/prettier@3.8.3/node_modules/prettier/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/prettier@3.8.3/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/prettier@3.8.3/node_modules/prettier/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/prettier@3.8.3/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../prettier/bin/prettier.cjs" "$@"
+else
+  exec node  "$basedir/../prettier/bin/prettier.cjs" "$@"
+fi

package/packages/samples/node_modules/.bin/tsc

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/typescript@6.0.3/node_modules/typescript/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/typescript@6.0.3/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/typescript@6.0.3/node_modules/typescript/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/typescript@6.0.3/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsc" "$@"
+fi

package/packages/samples/node_modules/.bin/tsserver

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/typescript@6.0.3/node_modules/typescript/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/typescript@6.0.3/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/typescript@6.0.3/node_modules/typescript/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/typescript@6.0.3/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsserver" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsserver" "$@"
+fi

package/packages/samples/node_modules/.bin/tsx

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/tsx@4.22.0/node_modules/tsx/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/tsx@4.22.0/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/tsx@4.22.0/node_modules/tsx/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/tsx@4.22.0/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../tsx/dist/cli.mjs" "$@"
+else
+  exec node  "$basedir/../tsx/dist/cli.mjs" "$@"
+fi

package/packages/samples/node_modules/.bin/vitest

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/vitest@4.1.6_@types+node@25.8.0_vite@8.0.13_@types+node@25.8.0_esbuild@0.28.0_tsx@4.22.0_/node_modules/vitest/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/vitest@4.1.6_@types+node@25.8.0_vite@8.0.13_@types+node@25.8.0_esbuild@0.28.0_tsx@4.22.0_/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/vitest@4.1.6_@types+node@25.8.0_vite@8.0.13_@types+node@25.8.0_esbuild@0.28.0_tsx@4.22.0_/node_modules/vitest/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/vitest@4.1.6_@types+node@25.8.0_vite@8.0.13_@types+node@25.8.0_esbuild@0.28.0_tsx@4.22.0_/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../vitest/vitest.mjs" "$@"
+else
+  exec node  "$basedir/../vitest/vitest.mjs" "$@"
+fi

package/packages/samples/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@shapecraft/samples",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./src/index.ts",
+  "scripts": {
+    "test": "vitest --passWithNoTests","check":
+    "tsc -p ./tsconfig.json --noEmit",
+    "format": "prettier --experimental-ternaries ./src --write",
+    "build": "tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.33.2",
+  "dependencies": {
+    "@shapecraft/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "prettier": "^3.8.3",
+    "tsx": "^4.22.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
+  },
+  "publishConfig": {
+    "main": "./dist/cjs/index.js",
+    "types": "./dist/cjs/index.d.ts",
+    "typings": "./dist/cjs/index.d.ts",
+    "exports": {
+      ".": {
+        "import": {
+          "types": "./dist/esm/index.d.ts",
+          "default": "./dist/esm/index.js"
+        },
+        "require": {
+          "types": "./dist/cjs/index.d.ts",
+          "default": "./dist/cjs/index.js"
+        },
+        "default": {
+          "types": "./dist/cjs/index.d.ts",
+          "default": "./dist/cjs/index.js"
+        }
+      }
+    }
+  }
+}

package/packages/samples/src/blog.ts

@@ -0,0 +1,49 @@
+import { B } from "@shapecraft/core";
+
+export const Author = B.mapping({
+  id: B.uint64().primary().autoIncrement(),
+  username: B.string().min(3).max(32).unique(),
+  displayName: B.string().min(1).max(80),
+  bio: B.string().max(280).optional(),
+  createdAt: B.date(),
+}).title("Author");
+
+export const Tag = B.mapping({
+  id: B.uint32().primary().autoIncrement(),
+  slug: B.string()
+    .regex(/^[a-z0-9-]+$/)
+    .unique(),
+  label: B.string().min(1).max(40),
+}).title("Tag");
+
+export const Post = B.mapping({
+  id: B.uint64().primary().autoIncrement(),
+  author: B.uint64().references(Author, "id"),
+  title: B.string().min(1).max(200),
+  slug: B.string()
+    .regex(/^[a-z0-9-]+$/)
+    .unique(),
+  body: B.string(),
+  status: B.union(
+    B.literal("draft"),
+    B.literal("published"),
+    B.literal("archived"),
+  ),
+  publishedAt: B.date().optional(),
+  createdAt: B.date(),
+  updatedAt: B.date(),
+}).title("Post");
+
+export const PostTag = B.mapping({
+  post: B.uint64().references(Post, "id"),
+  tag: B.uint32().references(Tag, "id"),
+}).title("PostTag");
+
+export const Comment = B.mapping({
+  id: B.uint64().primary().autoIncrement(),
+  post: B.uint64().references(Post, "id"),
+  author: B.uint64().references(Author, "id"),
+  parent: B.uint64().references(Author, "id").optional(),
+  body: B.string().min(1).max(4000),
+  createdAt: B.date(),
+}).title("Comment");