@llm-cms/core 0.0.1 → 0.0.2

package/src/validate.ts

@@ -1,7 +1,9 @@
 // packages/core/src/validate.ts
+import { modelFormat, parseDoc } from "./doc-format";
 import type { Frontmatter } from "./mdx";
 import { parseMdx } from "./mdx";
 import type { ModelSnapshot } from "./model";
+import type { BlockInstance, BlockSnapshot } from "./block";
 import { matchAnyModelPath } from "./path";
 import { expectedTypeFor, frontmatterZod, normalizeFrontmatter } from "./zod";
 
@@ -43,6 +45,42 @@ export function validateFrontmatter(
   return { ok: false, errors };
 }
 
+function asBlockList(value: unknown): BlockInstance[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is BlockInstance => {
+    if (!item || typeof item !== "object") return false;
+    const row = item as Record<string, unknown>;
+    return typeof row.id === "string" && typeof row.type === "string";
+  });
+}
+
+/** Validate each block instance against the blocks catalog. */
+export function validateBlocks(
+  blocks: unknown,
+  catalog: BlockSnapshot[],
+  prefix = "blocks",
+): ValidationResult {
+  if (!Array.isArray(blocks)) return { ok: true };
+  const byName = new Map(catalog.map((b) => [b.name, b]));
+  const errors: string[] = [];
+  asBlockList(blocks).forEach((block, i) => {
+    const def = byName.get(block.type);
+    if (!def) {
+      errors.push(`${prefix}[${i}]: unknown type "${block.type}"`);
+      return;
+    }
+    const props = block.props && typeof block.props === "object" ? block.props : {};
+    const result = validateFrontmatter({ fields: def.fields }, props);
+    if (!result.ok) {
+      for (const err of result.errors) {
+        errors.push(`${prefix}[${i}].${err}`);
+      }
+    }
+  });
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true };
+}
+
 /**
  * Parse a raw MDX string and validate its frontmatter. Never throws on
  * malformed frontmatter (an unknown field kind in `model` still throws).
@@ -61,6 +99,32 @@ export function validateMdxFile(
   return validateFrontmatter(model, frontmatter);
 }
 
+export function validateDocFile(
+  model: Pick<ModelSnapshot, "fields" | "format">,
+  raw: string,
+  catalog: BlockSnapshot[] = [],
+): ValidationResult {
+  const format = modelFormat(model);
+  let frontmatter: Frontmatter;
+  try {
+    frontmatter = parseDoc(raw, format).frontmatter;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "invalid";
+    const label = format === "page" ? "JSON" : "frontmatter";
+    return { ok: false, errors: [msg.startsWith("JSON:") ? msg : `${label}: ${msg}`] };
+  }
+  const base = validateFrontmatter(model, frontmatter);
+  if (format !== "page") return base;
+  const blockField = Object.entries(model.fields).find(([, f]) => f.kind === "blocks");
+  if (!blockField) return base;
+  const blockResult = validateBlocks(frontmatter[blockField[0]], catalog, blockField[0]);
+  if (base.ok && blockResult.ok) return { ok: true };
+  return {
+    ok: false,
+    errors: [...(base.ok ? [] : base.errors), ...(blockResult.ok ? [] : blockResult.errors)],
+  };
+}
+
 export type ContentFileResult =
   | { path: string; type: string; ok: true }
   | { path: string; type: string; ok: false; errors: string[] }
@@ -70,13 +134,15 @@ export type ContentFileResult =
 export function validateContentTree(input: {
   models: ModelSnapshot[];
   files: Array<{ path: string; raw: string }>;
+  catalog?: BlockSnapshot[];
 }): ContentFileResult[] {
+  const catalog = input.catalog ?? [];
   return input.files.map((file) => {
     const hit = matchAnyModelPath(input.models, file.path);
     if (!hit) return { path: file.path, type: null, ok: true, skipped: true };
     const model = input.models.find((m) => m.type === hit.type);
     if (!model) return { path: file.path, type: null, ok: true, skipped: true };
-    const result = validateMdxFile(model, file.raw);
+    const result = validateDocFile(model, file.raw, catalog);
     if (result.ok) return { path: file.path, type: model.type, ok: true };
     return { path: file.path, type: model.type, ok: false, errors: result.errors };
   });

package/src/zod.ts

@@ -5,12 +5,14 @@ import type { Frontmatter } from "./mdx";
 import type { ModelSnapshot } from "./model";
 
 /** Primitive a field kind is stored as in frontmatter; used in error messages. */
-export function expectedTypeFor(kind: FieldKind): "string" | "number" | "boolean" {
+export function expectedTypeFor(kind: FieldKind): "string" | "number" | "boolean" | "array" {
   switch (kind) {
     case "number":
       return "number";
     case "boolean":
       return "boolean";
+    case "blocks":
+      return "array";
     case "text":
     case "slug":
     case "locale":
@@ -25,6 +27,15 @@ export function expectedTypeFor(kind: FieldKind): "string" | "number" | "boolean
 }
 
 function fieldZod(field: FieldSnapshot): z.ZodType {
+  if (field.kind === "blocks") {
+    const item = z.object({
+      id: z.string().min(1),
+      type: z.string().min(1),
+      props: z.record(z.string(), z.unknown()).optional().default({}),
+    });
+    const arr = field.required ? z.array(item).min(1) : z.array(item).optional();
+    return arr;
+  }
   let base: z.ZodType;
   switch (expectedTypeFor(field.kind)) {
     case "number":