@cms0/shared 0.0.1

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@cms0/shared",
+  "version": "0.0.1",
+  "private": false,
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "main": "dist/index.js",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "require": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./src/*.ts",
+      "import": "./src/*.ts",
+      "require": "./dist/*.js"
+    }
+  },
+  "dependencies": {
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "@cms0/typescript-config": "0.0.1"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -b --watch"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./validation";
+
+export const delay = (ms: number) => new Promise((res) => setTimeout(res, ms));

package/src/validation.ts

@@ -0,0 +1,133 @@
+import { z, ZodType } from "zod";
+
+// Map custom primitive-models (or types) you defined
+const customTypeSchemas: Record<string, ZodType<any>> = {
+  Asset: z.object({ id: z.string(), url: z.string().url() }),
+  RichText: z.object({ html: z.string(), delta: z.array(z.any()) }),
+  Url: z.string().url(),
+};
+
+export type PrimitiveType = "string" | "number" | "boolean";
+// Type definitions for descriptor elements
+export type FieldDescriptor =
+  | {
+      kind?: "primitive";
+      type: PrimitiveType;
+      optional?: boolean;
+      nullable?: boolean;
+    }
+  | { kind: "modelRef"; model: string; optional?: boolean; nullable?: boolean }
+  | {
+      kind?: "object";
+      type: "object";
+      properties: Record<string, FieldDescriptor>;
+      optional?: boolean;
+      nullable?: boolean;
+    }
+  | {
+      kind?: "array";
+      type: "array";
+      items: FieldDescriptor;
+      optional?: boolean;
+      nullable?: boolean;
+    };
+
+export type ModelDescriptor = {
+  kind: "model";
+  properties: Record<string, FieldDescriptor>;
+};
+
+export type RootDescriptor = FieldDescriptor;
+
+export type FullDescriptor = {
+  models: Record<string, ModelDescriptor>;
+  roots: Record<string, RootDescriptor>;
+};
+
+function convertDescriptorToZod(
+  desc: FieldDescriptor,
+  modelZodSchemas: Record<string, ZodType<any>>,
+  opts: { loose?: boolean } = {}
+): ZodType<any> {
+  const applyOptionality = (schema: ZodType<any>) => {
+    let out = schema;
+    if (desc.nullable || opts.loose) out = out.nullable();
+    if (desc.optional || opts.loose) out = out.optional();
+    return out;
+  };
+
+  if (desc.kind === "primitive") {
+    switch (desc.type) {
+      case "string":
+        return applyOptionality(z.string());
+      case "number":
+        return applyOptionality(z.number());
+      case "boolean":
+        return applyOptionality(z.boolean());
+    }
+  }
+
+  if (desc.kind === "modelRef") {
+    const schema = modelZodSchemas[desc.model];
+    const base = schema ?? z.any();
+    // For loose schemas (root singletons), accept either the object or just an id.
+    const withId = opts.loose ? z.union([base, z.string()]) : base;
+    return applyOptionality(withId);
+  }
+
+  if (desc.type === "object" && (desc as any).properties) {
+    const shape: Record<string, ZodType<any>> = {};
+    for (const [key, valueDesc] of Object.entries((desc as any).properties)) {
+      shape[key] = convertDescriptorToZod(
+        valueDesc as FieldDescriptor,
+        modelZodSchemas,
+        opts
+      );
+    }
+    const objectSchema = opts.loose ? z.object(shape).partial() : z.object(shape);
+    return applyOptionality(objectSchema);
+  }
+
+  if (desc.type === "array" && (desc as any).items) {
+    return applyOptionality(
+      z.array(
+        convertDescriptorToZod(
+          (desc as any).items as FieldDescriptor,
+          modelZodSchemas,
+          opts
+        )
+      )
+    );
+  }
+
+  if (typeof (desc as any).type === "string") {
+    const custom = customTypeSchemas[(desc as any).type as string];
+    if (custom) {
+      return applyOptionality(custom);
+    }
+  }
+
+  return applyOptionality(z.any());
+}
+
+export function buildZodSchemasFromDescriptor(descriptor: FullDescriptor) {
+  const modelZodSchemas: Record<string, ZodType<any>> = {};
+  const zodSchemas: Record<string, ZodType<any>> = {};
+
+  for (const [modelName, modelDesc] of Object.entries(descriptor.models)) {
+    const shape: Record<string, ZodType<any>> = {};
+    for (const [propName, propDesc] of Object.entries(modelDesc.properties)) {
+      shape[propName] = convertDescriptorToZod(propDesc, modelZodSchemas);
+    }
+    modelZodSchemas[modelName] = z.object(shape);
+  }
+
+  for (const [rootKey, rootDesc] of Object.entries(descriptor.roots)) {
+    // Root schemas are used for singleton PATCH; make nested structures loose/optional.
+    zodSchemas[rootKey] = convertDescriptorToZod(rootDesc, modelZodSchemas, {
+      loose: true,
+    });
+  }
+
+  return { zodSchemas, modelZodSchemas };
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "extends": "@cms0/typescript-config/base.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": "src"
+    },
+    "include": [
+        "src"
+    ]
+}