@bobbykim/manguito-cms-core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1119 @@
+// src/config/defineConfig.ts
+function defineConfig(config) {
+  return {
+    name: config.name ?? "Manguito CMS",
+    schema: resolveSchemaConfig(config.schema),
+    db: config.db,
+    migrations: resolveMigrationsConfig(config.migrations, config.db),
+    storage: config.storage,
+    server: config.server,
+    api: config.api,
+    admin: config.admin
+  };
+}
+function resolveSchemaConfig(config) {
+  return {
+    base_path: config?.base_path ?? "./schemas",
+    folders: {
+      content_types: config?.folders?.content_types ?? "content-types",
+      paragraph_types: config?.folders?.paragraph_types ?? "paragraph-types",
+      taxonomy_types: config?.folders?.taxonomy_types ?? "taxonomy-types",
+      enum_types: config?.folders?.enum_types ?? "enum-types"
+    }
+  };
+}
+function resolveMigrationsConfig(config, db) {
+  if (db?.type === "mongodb") return null;
+  return {
+    table: config?.table ?? "__manguito_migrations",
+    folder: config?.folder ?? "./migrations"
+  };
+}
+
+// src/parser/validators.ts
+import { z } from "zod";
+var snakeCaseName = z.string().regex(/^[a-z][a-z0-9_]*$/, 'Must be snake_case (e.g. "blog_post")');
+var maxSizeString = z.string().regex(
+  /^\d+(\.\d+)?\s*(B|KB|MB|GB)$/i,
+  'Must be a file size string like "512KB" or "2MB"'
+);
+var contentMachineName = z.string().regex(
+  /^content--[a-z][a-z0-9_]*$/,
+  'Must match "content--<snake_case_name>" (e.g. "content--blog_post")'
+);
+var paragraphMachineName = z.string().regex(
+  /^paragraph--[a-z][a-z0-9_]*$/,
+  'Must match "paragraph--<snake_case_name>" (e.g. "paragraph--photo_card")'
+);
+var taxonomyMachineName = z.string().regex(
+  /^taxonomy--[a-z][a-z0-9_]*$/,
+  'Must match "taxonomy--<snake_case_name>" (e.g. "taxonomy--daily_post")'
+);
+var enumMachineName = z.string().regex(
+  /^enum--[a-z][a-z0-9_]*$/,
+  'Must match "enum--<snake_case_name>" (e.g. "enum--link_target")'
+);
+var refTargetMachineName = z.string().regex(
+  /^(content|taxonomy)--[a-z][a-z0-9_]*$/,
+  "Target must be a content-type or taxonomy-type machine name"
+);
+var RawFieldBase = z.object({
+  name: snakeCaseName,
+  label: z.string().min(1),
+  required: z.boolean()
+});
+var RawTextPlainFieldSchema = RawFieldBase.extend({
+  type: z.literal("text/plain"),
+  limit: z.number().int().positive().optional(),
+  pattern: z.string().optional()
+});
+var RawTextRichFieldSchema = RawFieldBase.extend({
+  type: z.literal("text/rich")
+});
+var RawIntegerFieldSchema = RawFieldBase.extend({
+  type: z.literal("integer"),
+  // min/max are value bounds — can be any integer, including negative.
+  min: z.number().int().optional(),
+  max: z.number().int().optional()
+});
+var RawFloatFieldSchema = RawFieldBase.extend({
+  type: z.literal("float"),
+  min: z.number().optional(),
+  max: z.number().optional()
+});
+var RawBooleanFieldSchema = RawFieldBase.extend({
+  type: z.literal("boolean")
+});
+var RawDateFieldSchema = RawFieldBase.extend({
+  type: z.literal("date")
+});
+var RawImageFieldSchema = RawFieldBase.extend({
+  type: z.literal("image"),
+  max_size: maxSizeString.optional(),
+  alt: z.boolean().optional()
+});
+var RawVideoFieldSchema = RawFieldBase.extend({
+  type: z.literal("video"),
+  max_size: maxSizeString.optional(),
+  alt: z.boolean().optional()
+});
+var RawFileFieldSchema = RawFieldBase.extend({
+  type: z.literal("file"),
+  max_size: maxSizeString.optional(),
+  alt: z.boolean().optional()
+});
+var RawEnumFieldSchema = RawFieldBase.extend({
+  type: z.literal("enum"),
+  ref: enumMachineName.optional(),
+  values: z.array(z.string().min(1)).min(1).optional()
+}).refine(
+  (d) => d.ref !== void 0 !== (d.values !== void 0),
+  { message: "Enum field must have either ref or values \u2014 not both, not neither" }
+);
+var RawParagraphFieldSchema = RawFieldBase.extend({
+  type: z.literal("paragraph"),
+  ref: paragraphMachineName,
+  rel: z.enum(["one-to-one", "one-to-many"]),
+  max: z.number().int().positive().optional()
+});
+var RawReferenceFieldSchema = RawFieldBase.extend({
+  type: z.literal("reference"),
+  target: refTargetMachineName,
+  rel: z.enum(["one-to-one", "one-to-many", "many-to-many"]),
+  max: z.number().int().positive().optional()
+});
+var RawNonEnumFieldSchema = z.discriminatedUnion("type", [
+  RawTextPlainFieldSchema,
+  RawTextRichFieldSchema,
+  RawIntegerFieldSchema,
+  RawFloatFieldSchema,
+  RawBooleanFieldSchema,
+  RawDateFieldSchema,
+  RawImageFieldSchema,
+  RawVideoFieldSchema,
+  RawFileFieldSchema,
+  RawParagraphFieldSchema,
+  RawReferenceFieldSchema
+]);
+var RawFieldSchema = z.union([RawNonEnumFieldSchema, RawEnumFieldSchema]);
+var RawTabSchema = z.object({
+  tab: z.object({
+    name: snakeCaseName,
+    label: z.string().min(1),
+    fields: z.array(RawFieldSchema).min(1)
+  })
+});
+var ContentTypeRawSchema = z.object({
+  name: contentMachineName,
+  label: z.string().min(1),
+  type: z.literal("content-type"),
+  default_base_path: z.string().min(1),
+  only_one: z.boolean(),
+  fields: z.array(RawTabSchema).min(1)
+});
+var ParagraphTypeRawSchema = z.object({
+  name: paragraphMachineName,
+  label: z.string().min(1),
+  type: z.literal("paragraph-type"),
+  fields: z.array(RawFieldSchema)
+});
+var TaxonomyTypeRawSchema = z.object({
+  name: taxonomyMachineName,
+  label: z.string().min(1),
+  type: z.literal("taxonomy-type"),
+  fields: z.array(RawFieldSchema)
+});
+var EnumTypeRawSchema = z.object({
+  name: enumMachineName,
+  label: z.string().min(1),
+  type: z.literal("enum-type"),
+  values: z.array(z.string().min(1)).min(1)
+});
+var RoutesFileSchema = z.object({
+  base_paths: z.array(
+    z.object({
+      name: snakeCaseName,
+      path: z.string().regex(/^\//, "Path must start with /")
+    })
+  ).min(1)
+});
+
+// src/parser/validate.ts
+function buildSchemaRegistry(parsedSchemas, parsedRoutes, parsedRoles) {
+  const schemas = {};
+  const content_types = {};
+  const paragraph_types = {};
+  const taxonomy_types = {};
+  const enum_types = {};
+  for (const schema of parsedSchemas) {
+    schemas[schema.name] = schema;
+    switch (schema.schema_type) {
+      case "content-type":
+        content_types[schema.name] = schema;
+        break;
+      case "paragraph-type":
+        paragraph_types[schema.name] = schema;
+        break;
+      case "taxonomy-type":
+        taxonomy_types[schema.name] = schema;
+        break;
+      case "enum-type":
+        enum_types[schema.name] = schema;
+        break;
+    }
+  }
+  for (const schema of Object.values(schemas)) {
+    if (schema.schema_type === "enum-type") continue;
+    for (const field of schema.fields) {
+      if (field.field_type !== "enum") continue;
+      const ui = field.ui_component;
+      if (ui.enum_ref === void 0) continue;
+      const enumSchema = enum_types[ui.enum_ref];
+      if (enumSchema === void 0) continue;
+      const values = enumSchema.values;
+      field.validation.allowed_values = values;
+      if (field.db_column !== null) {
+        field.db_column.check_constraint = values;
+      }
+      ui.options = values;
+    }
+  }
+  return {
+    routes: parsedRoutes,
+    roles: parsedRoles,
+    schemas,
+    content_types,
+    paragraph_types,
+    taxonomy_types,
+    enum_types,
+    all_schemas: parsedSchemas
+  };
+}
+function validateCrossReferences(registry, globalMaxFileSize) {
+  const errors = [];
+  errors.push(...checkDuplicateSchemaNames(registry.all_schemas));
+  errors.push(...checkFieldRefs(registry));
+  errors.push(...checkCircularParagraphRefs(registry));
+  if (globalMaxFileSize !== void 0) {
+    errors.push(...checkMaxSizeLimit(registry, globalMaxFileSize));
+  }
+  return errors;
+}
+function checkDuplicateSchemaNames(allSchemas) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const schema of allSchemas) {
+    const firstFile = seen.get(schema.name);
+    if (firstFile !== void 0) {
+      errors.push({
+        file: schema.source_file,
+        code: "DUPLICATE_SCHEMA_NAME",
+        message: `Duplicate schema name "${schema.name}": already defined in "${firstFile}"`
+      });
+    } else {
+      seen.set(schema.name, schema.source_file);
+    }
+  }
+  return errors;
+}
+function checkFieldRefs(registry) {
+  const errors = [];
+  for (const schema of Object.values(registry.schemas)) {
+    if (schema.schema_type === "enum-type") continue;
+    for (const field of schema.fields) {
+      errors.push(...checkSingleFieldRef(field, schema.source_file, registry));
+    }
+  }
+  return errors;
+}
+function checkSingleFieldRef(field, sourceFile, registry) {
+  const errors = [];
+  const fieldPath = (prop) => `fields[${field.order}].${prop}`;
+  switch (field.field_type) {
+    case "paragraph": {
+      const ref = field.ui_component.ref;
+      if (ref in registry.paragraph_types) break;
+      errors.push({
+        file: sourceFile,
+        code: ref in registry.schemas ? "INVALID_REF_TARGET" : "UNKNOWN_REF",
+        message: ref in registry.schemas ? `Field "${field.name}": paragraph ref "${ref}" exists but is not a paragraph-type` : `Field "${field.name}": paragraph ref "${ref}" does not exist`,
+        path: fieldPath("ref")
+      });
+      break;
+    }
+    case "reference": {
+      const target = field.ui_component.ref;
+      if (target in registry.content_types || target in registry.taxonomy_types) break;
+      errors.push({
+        file: sourceFile,
+        code: target in registry.schemas ? "INVALID_REF_TARGET" : "UNKNOWN_REF",
+        message: target in registry.schemas ? `Field "${field.name}": reference target "${target}" exists but is not a content-type or taxonomy-type` : `Field "${field.name}": reference target "${target}" does not exist`,
+        path: fieldPath("target")
+      });
+      break;
+    }
+    case "enum": {
+      const enumRef = field.ui_component.enum_ref;
+      if (enumRef === void 0) break;
+      if (enumRef in registry.enum_types) break;
+      errors.push({
+        file: sourceFile,
+        code: enumRef in registry.schemas ? "INVALID_REF_TARGET" : "UNKNOWN_REF",
+        message: enumRef in registry.schemas ? `Field "${field.name}": enum ref "${enumRef}" exists but is not an enum-type` : `Field "${field.name}": enum ref "${enumRef}" does not exist`,
+        path: fieldPath("ref")
+      });
+      break;
+    }
+  }
+  return errors;
+}
+function checkCircularParagraphRefs(registry) {
+  const errors = [];
+  const adjList = /* @__PURE__ */ new Map();
+  for (const [name, para] of Object.entries(registry.paragraph_types)) {
+    const refs = [];
+    for (const field of para.fields) {
+      if (field.field_type !== "paragraph") continue;
+      const ref = field.ui_component.ref;
+      if (ref in registry.paragraph_types) {
+        refs.push(ref);
+      }
+    }
+    adjList.set(name, refs);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  function dfs(node) {
+    if (inStack.has(node)) {
+      const cycleStart = stack.indexOf(node);
+      const cyclePath = stack.slice(cycleStart);
+      const cycleStr = [...cyclePath, node].join(" \u2192 ");
+      const lastNode = stack[stack.length - 1];
+      const sourceFile = registry.paragraph_types[lastNode]?.source_file ?? "";
+      errors.push({
+        file: sourceFile,
+        code: "CIRCULAR_REFERENCE",
+        message: `Circular paragraph reference detected: ${cycleStr}`
+      });
+      return;
+    }
+    if (visited.has(node)) return;
+    visited.add(node);
+    inStack.add(node);
+    stack.push(node);
+    for (const neighbor of adjList.get(node) ?? []) {
+      dfs(neighbor);
+    }
+    stack.pop();
+    inStack.delete(node);
+  }
+  for (const name of adjList.keys()) {
+    dfs(name);
+  }
+  return errors;
+}
+function checkMaxSizeLimit(registry, globalMaxFileSize) {
+  const errors = [];
+  for (const schema of Object.values(registry.schemas)) {
+    if (schema.schema_type === "enum-type") continue;
+    for (const field of schema.fields) {
+      if (field.field_type !== "image" && field.field_type !== "video" && field.field_type !== "file") {
+        continue;
+      }
+      const fieldMaxSize = field.validation.max_size;
+      if (fieldMaxSize === void 0 || fieldMaxSize <= globalMaxFileSize) continue;
+      errors.push({
+        file: schema.source_file,
+        code: "MAX_SIZE_EXCEEDS_GLOBAL_LIMIT",
+        message: `Field "${field.name}": max_size ${fieldMaxSize} bytes exceeds global limit of ${globalMaxFileSize} bytes`,
+        path: `fields[${field.order}].max_size`
+      });
+    }
+  }
+  return errors;
+}
+function parseRoutes(raw, sourceFile = "routes.json") {
+  const result = RoutesFileSchema.safeParse(raw);
+  if (!result.success) {
+    return {
+      ok: false,
+      errors: result.error.issues.map((issue) => ({
+        file: sourceFile,
+        code: "MISSING_REQUIRED_FIELD",
+        message: issue.message,
+        ...issue.path.length > 0 ? { path: issue.path.map(String).join(".") } : {}
+      }))
+    };
+  }
+  return { ok: true, value: result.data };
+}
+
+// src/parser/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import { parse as parseYaml } from "yaml";
+var FOLDER_KEY_TO_SCHEMA_TYPE = {
+  content_types: "content-type",
+  paragraph_types: "paragraph-type",
+  taxonomy_types: "taxonomy-type",
+  enum_types: "enum-type"
+};
+var SCHEMA_TYPE_TO_PREFIX = {
+  "content-type": "content",
+  "paragraph-type": "paragraph",
+  "taxonomy-type": "taxonomy",
+  "enum-type": "enum"
+};
+function loadSchemaFile(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    return {
+      ok: false,
+      errors: [
+        {
+          file: filePath,
+          code: "FILE_READ_ERROR",
+          message: `Could not read file: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ]
+    };
+  }
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === ".json") {
+    try {
+      return { ok: true, value: JSON.parse(raw) };
+    } catch (err) {
+      return {
+        ok: false,
+        errors: [
+          {
+            file: filePath,
+            code: "FILE_PARSE_ERROR",
+            message: `JSON parse error: ${err instanceof Error ? err.message : String(err)}`
+          }
+        ]
+      };
+    }
+  }
+  if (ext === ".yaml" || ext === ".yml") {
+    try {
+      return { ok: true, value: parseYaml(raw) };
+    } catch (err) {
+      return {
+        ok: false,
+        errors: [
+          {
+            file: filePath,
+            code: "FILE_PARSE_ERROR",
+            message: `YAML parse error: ${err instanceof Error ? err.message : String(err)}`
+          }
+        ]
+      };
+    }
+  }
+  return {
+    ok: false,
+    errors: [
+      {
+        file: filePath,
+        code: "FILE_PARSE_ERROR",
+        message: `Unsupported file extension "${ext}" \u2014 expected .json, .yaml, or .yml`
+      }
+    ]
+  };
+}
+function walkSchemaDirectory(config) {
+  const errors = [];
+  const files = [];
+  if (!directoryExists(config.base_path)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          file: config.base_path,
+          code: "SCHEMA_DIR_NOT_FOUND",
+          message: `Schema base directory does not exist: ${config.base_path}`
+        }
+      ]
+    };
+  }
+  const resolvedFolderPaths = /* @__PURE__ */ new Map();
+  for (const folderKey of Object.keys(FOLDER_KEY_TO_SCHEMA_TYPE)) {
+    const folderName = config.folders[folderKey];
+    const absFolder = path.resolve(config.base_path, folderName);
+    const existing = resolvedFolderPaths.get(absFolder);
+    if (existing !== void 0) {
+      errors.push({
+        file: absFolder,
+        code: "DUPLICATE_SCHEMA_FOLDER",
+        message: `Folders "${existing}" and "${folderKey}" resolve to the same path: ${absFolder}`
+      });
+    } else {
+      resolvedFolderPaths.set(absFolder, folderKey);
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  for (const [folderKey, schemaType] of Object.entries(
+    FOLDER_KEY_TO_SCHEMA_TYPE
+  )) {
+    const folderName = config.folders[folderKey];
+    const folderPath = path.resolve(config.base_path, folderName);
+    if (!directoryExists(folderPath)) {
+      errors.push({
+        file: folderPath,
+        code: "SCHEMA_FOLDER_NOT_FOUND",
+        message: `Schema folder does not exist: ${folderPath} (configured as "${folderName}")`
+      });
+      continue;
+    }
+    const entries = readDirEntries(folderPath);
+    const expectedPrefix = SCHEMA_TYPE_TO_PREFIX[schemaType];
+    for (const entry of entries) {
+      if (!isSupportedExtension(entry)) continue;
+      const filePath = path.join(folderPath, entry);
+      const baseName = path.basename(entry, path.extname(entry));
+      if (!hasCorrectPrefix(baseName, expectedPrefix)) {
+        errors.push({
+          file: filePath,
+          code: "INVALID_MACHINE_NAME",
+          message: `File "${entry}" in folder "${folderName}" does not match the expected "${expectedPrefix}--<name>" prefix for ${schemaType} schemas. Did you put this file in the wrong folder?`
+        });
+        continue;
+      }
+      const result = loadSchemaFile(filePath);
+      if (!result.ok) {
+        errors.push(...result.errors);
+        continue;
+      }
+      files.push({ path: filePath, raw: result.value, schema_type: schemaType });
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, value: files };
+}
+function directoryExists(dirPath) {
+  try {
+    return fs.statSync(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readDirEntries(dirPath) {
+  try {
+    return fs.readdirSync(dirPath);
+  } catch {
+    return [];
+  }
+}
+function isSupportedExtension(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  return ext === ".json" || ext === ".yaml" || ext === ".yml";
+}
+function hasCorrectPrefix(baseName, expectedPrefix) {
+  return baseName.startsWith(`${expectedPrefix}--`);
+}
+
+// src/registry/fieldTypeRegistry.ts
+function machineNameToTableName(machineName) {
+  return machineName.replace("--", "_");
+}
+var MEDIA_ALLOWED_MIME = {
+  image: ["image/jpeg", "image/png", "image/webp", "image/gif", "image/svg+xml"],
+  video: ["video/mp4", "video/webm", "video/quicktime"],
+  file: ["application/pdf"]
+};
+var MEDIA_UI_MIME = {
+  image: ["image/*"],
+  video: ["video/*"],
+  file: ["application/pdf"]
+};
+function parseMaxSize(str) {
+  const m = /^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)$/i.exec(str);
+  if (!m) return 0;
+  const value = parseFloat(m[1]);
+  switch (m[2].toUpperCase()) {
+    case "B":
+      return Math.round(value);
+    case "KB":
+      return Math.round(value * 1024);
+    case "MB":
+      return Math.round(value * 1048576);
+    case "GB":
+      return Math.round(value * 1073741824);
+    default:
+      return 0;
+  }
+}
+function buildMediaField(raw) {
+  const mediaType = raw.type;
+  const maxSizeBytes = raw.max_size ? parseMaxSize(raw.max_size) : void 0;
+  return {
+    validation: {
+      required: raw.required,
+      ...maxSizeBytes !== void 0 && { max_size: maxSizeBytes },
+      allowed_mime_types: MEDIA_ALLOWED_MIME[mediaType]
+    },
+    db_column: {
+      column_name: raw.name,
+      column_type: "uuid",
+      nullable: !raw.required,
+      foreign_key: { table: "media", column: "id", on_delete: "SET NULL" }
+    },
+    ui_component: {
+      component: "file-upload",
+      accepted_mime_types: MEDIA_UI_MIME[mediaType]
+    }
+  };
+}
+var fieldTypeRegistry = {
+  // ── Primitives ──────────────────────────────────────────────────────────────
+  "text/plain": (raw) => ({
+    validation: {
+      required: raw.required,
+      ...raw.limit !== void 0 && { limit: raw.limit },
+      ...raw.pattern !== void 0 && { pattern: raw.pattern }
+    },
+    db_column: { column_name: raw.name, column_type: "varchar", nullable: !raw.required },
+    ui_component: { component: "text-input" }
+  }),
+  "text/rich": (raw) => ({
+    validation: { required: raw.required },
+    db_column: { column_name: raw.name, column_type: "text", nullable: !raw.required },
+    ui_component: { component: "rich-text-editor" }
+  }),
+  integer: (raw) => ({
+    validation: {
+      required: raw.required,
+      ...raw.min !== void 0 && { min: raw.min },
+      ...raw.max !== void 0 && { max: raw.max }
+    },
+    db_column: { column_name: raw.name, column_type: "integer", nullable: !raw.required },
+    ui_component: { component: "number-input", step: 1 }
+  }),
+  float: (raw) => ({
+    validation: {
+      required: raw.required,
+      ...raw.min !== void 0 && { min: raw.min },
+      ...raw.max !== void 0 && { max: raw.max }
+    },
+    db_column: { column_name: raw.name, column_type: "decimal", nullable: !raw.required },
+    ui_component: { component: "number-input", step: 0.01 }
+  }),
+  // Boolean columns are always NOT NULL — false is the natural empty value, not NULL.
+  boolean: (raw) => ({
+    validation: { required: raw.required },
+    db_column: { column_name: raw.name, column_type: "boolean", nullable: false },
+    ui_component: { component: "checkbox" }
+  }),
+  date: (raw) => ({
+    validation: { required: raw.required },
+    db_column: { column_name: raw.name, column_type: "timestamp", nullable: !raw.required },
+    ui_component: { component: "date-picker" }
+  }),
+  // ── Media — FK → media.id, SET NULL on delete ───────────────────────────────
+  image: (raw) => buildMediaField(raw),
+  video: (raw) => buildMediaField(raw),
+  file: (raw) => buildMediaField(raw),
+  // ── Enum — varchar + check constraint ───────────────────────────────────────
+  //
+  // Inline enum: values are present on the field and fully resolved here.
+  // Ref enum: values live in another schema not yet available, so allowed_values
+  // and check_constraint stay empty and enum_ref is stashed in ui_component for
+  // resolveEnumReferences() to fill once the full registry is assembled.
+  enum: (raw) => {
+    const allowedValues = raw.values ?? [];
+    return {
+      validation: { required: raw.required, allowed_values: allowedValues },
+      db_column: {
+        column_name: raw.name,
+        column_type: "varchar",
+        nullable: !raw.required,
+        check_constraint: allowedValues
+      },
+      ui_component: {
+        component: "select",
+        options: allowedValues,
+        ...raw.ref !== void 0 && { enum_ref: raw.ref }
+      }
+    };
+  },
+  // ── Paragraph — no column on the owning table ───────────────────────────────
+  // The association lives on the paragraph table via parent_id/parent_type/
+  // parent_field/order system fields.
+  paragraph: (raw) => ({
+    validation: {
+      required: raw.required,
+      ...raw.max !== void 0 && { max_items: raw.max }
+    },
+    db_column: null,
+    ui_component: {
+      component: "paragraph-embed",
+      ref: raw.ref,
+      rel: raw.rel,
+      ...raw.max !== void 0 && { max: raw.max }
+    }
+  }),
+  // ── Reference — FK column, or a junction table for many-to-many ─────────────
+  reference: (raw, ctx) => {
+    const targetTableName = machineNameToTableName(raw.target);
+    const validation = {
+      required: raw.required,
+      ...raw.max !== void 0 && { max_items: raw.max }
+    };
+    const db_column = raw.rel === "many-to-many" ? {
+      // No FK column — the junction table owns the association.
+      column_name: "",
+      column_type: "uuid",
+      nullable: !raw.required,
+      junction: {
+        table_name: `junction_${ctx.ownerTableName}_${raw.name}`,
+        left_column: "left_id",
+        right_column: "right_id",
+        right_table: targetTableName,
+        order_column: false
+      }
+    } : {
+      // FK column on the owning table. References are independent → SET NULL.
+      column_name: raw.name,
+      column_type: "uuid",
+      nullable: !raw.required,
+      foreign_key: { table: targetTableName, column: "id", on_delete: "SET NULL" }
+    };
+    return {
+      validation,
+      db_column,
+      ui_component: { component: "typeahead-select", ref: raw.target, rel: raw.rel }
+    };
+  }
+};
+
+// src/parser/parseSchema.ts
+var CONTENT_SYSTEM_FIELDS = [
+  { name: "id", db_type: "uuid", primary_key: true, default: "gen_random_uuid()", nullable: false },
+  { name: "slug", db_type: "varchar", nullable: false },
+  { name: "base_path_id", db_type: "uuid", nullable: false },
+  { name: "published", db_type: "boolean", default: "false", nullable: false },
+  { name: "created_at", db_type: "timestamp", default: "now()", nullable: false },
+  { name: "updated_at", db_type: "timestamp", default: "now()", nullable: false }
+];
+var PARAGRAPH_SYSTEM_FIELDS = [
+  { name: "id", db_type: "uuid", primary_key: true, default: "gen_random_uuid()", nullable: false },
+  { name: "parent_id", db_type: "uuid", nullable: false },
+  { name: "parent_type", db_type: "varchar", nullable: false },
+  { name: "parent_field", db_type: "varchar", nullable: false },
+  { name: "order", db_type: "integer", default: "0", nullable: false },
+  { name: "created_at", db_type: "timestamp", default: "now()", nullable: false },
+  { name: "updated_at", db_type: "timestamp", default: "now()", nullable: false }
+];
+var TAXONOMY_SYSTEM_FIELDS = [
+  { name: "id", db_type: "uuid", primary_key: true, default: "gen_random_uuid()", nullable: false },
+  { name: "published", db_type: "boolean", default: "false", nullable: false },
+  { name: "created_at", db_type: "timestamp", default: "now()", nullable: false },
+  { name: "updated_at", db_type: "timestamp", default: "now()", nullable: false }
+];
+function nameSegmentToKebab(segment) {
+  return segment.replace(/_/g, "-");
+}
+function getNameSegment(machineName) {
+  const idx = machineName.indexOf("--");
+  return idx === -1 ? machineName : machineName.slice(idx + 2);
+}
+function zodPathToString(path2) {
+  return path2.reduce((acc, seg) => {
+    const s = typeof seg === "symbol" ? String(seg) : seg;
+    return typeof s === "number" ? `${acc}[${s}]` : acc ? `${acc}.${s}` : s;
+  }, "");
+}
+function zodErrorsToParseErrors(error, sourceFile) {
+  return error.issues.map((issue) => {
+    const pathStr = zodPathToString(issue.path);
+    const lastSeg = issue.path[issue.path.length - 1];
+    let code = "MISSING_REQUIRED_FIELD";
+    if (lastSeg === "name") code = "INVALID_MACHINE_NAME";
+    else if (lastSeg === "type" && issue.path.length <= 2) code = "INVALID_SCHEMA_TYPE";
+    else if (lastSeg === "type") code = "INVALID_FIELD_TYPE";
+    return {
+      file: sourceFile,
+      code,
+      message: issue.message,
+      ...pathStr ? { path: pathStr } : {}
+    };
+  });
+}
+function checkDuplicateFieldNames(fields, sourceFile, schemaName) {
+  const seen = /* @__PURE__ */ new Set();
+  const errors = [];
+  for (const f of fields) {
+    if (seen.has(f.name)) {
+      errors.push({
+        file: sourceFile,
+        code: "DUPLICATE_FIELD_NAME",
+        message: `Duplicate field name "${f.name}" in schema "${schemaName}"`
+      });
+    }
+    seen.add(f.name);
+  }
+  return errors;
+}
+function buildParsedField(rawField, order, sourceFile, ownerTableName) {
+  const build = fieldTypeRegistry[rawField.type];
+  if (!build) {
+    return {
+      ok: false,
+      errors: [{
+        file: sourceFile,
+        code: "INVALID_FIELD_TYPE",
+        message: `Unknown field type: ${String(rawField.type)}`
+      }]
+    };
+  }
+  const { name, label, required } = rawField;
+  const { validation, db_column, ui_component } = build(rawField, { ownerTableName });
+  return {
+    ok: true,
+    value: {
+      name,
+      label,
+      field_type: rawField.type,
+      required,
+      nullable: !required,
+      order,
+      validation,
+      db_column,
+      ui_component
+    }
+  };
+}
+function buildFields(rawFields, sourceFile, ownerTableName) {
+  const fields = [];
+  const errors = [];
+  for (let i = 0; i < rawFields.length; i++) {
+    const result = buildParsedField(rawFields[i], i, sourceFile, ownerTableName);
+    if (result.ok) {
+      fields.push(result.value);
+    } else {
+      errors.push(...result.errors);
+    }
+  }
+  return { fields, errors };
+}
+function parseContentType(raw, sourceFile) {
+  const result = ContentTypeRawSchema.safeParse(raw);
+  if (!result.success) {
+    return { ok: false, errors: zodErrorsToParseErrors(result.error, sourceFile) };
+  }
+  const v = result.data;
+  const flatRawFields = [];
+  const tabs = [];
+  for (const tabWrapper of v.fields) {
+    const tab = tabWrapper.tab;
+    const tabFieldNames = [];
+    for (const f of tab.fields) {
+      flatRawFields.push(f);
+      tabFieldNames.push(f.name);
+    }
+    tabs.push({ name: tab.name, label: tab.label, fields: tabFieldNames });
+  }
+  const dupErrors = checkDuplicateFieldNames(flatRawFields, sourceFile, v.name);
+  if (dupErrors.length > 0) return { ok: false, errors: dupErrors };
+  const tableName = machineNameToTableName(v.name);
+  const { fields, errors } = buildFields(flatRawFields, sourceFile, tableName);
+  if (errors.length > 0) return { ok: false, errors };
+  const junctionTables = [];
+  for (const field of fields) {
+    if (field.field_type === "reference" && field.db_column?.junction) {
+      const j = field.db_column.junction;
+      junctionTables.push({
+        table_name: j.table_name,
+        left_column: j.left_column,
+        right_column: j.right_column,
+        right_table: j.right_table,
+        order_column: j.order_column
+      });
+    }
+  }
+  const nameKebab = nameSegmentToKebab(getNameSegment(v.name));
+  const api = v.only_one ? {
+    default_base_path: v.default_base_path,
+    http_methods: ["GET", "PUT", "PATCH"],
+    item_path: `/api/${v.default_base_path}/${nameKebab}`
+  } : {
+    default_base_path: v.default_base_path,
+    http_methods: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+    collection_path: `/api/${nameKebab}`,
+    item_path: `/api/${nameKebab}/:slug`
+  };
+  const schema = {
+    schema_type: "content-type",
+    name: v.name,
+    label: v.label,
+    source_file: sourceFile,
+    only_one: v.only_one,
+    default_base_path: v.default_base_path,
+    system_fields: CONTENT_SYSTEM_FIELDS,
+    fields,
+    ui: { tabs },
+    db: { table_name: tableName, junction_tables: junctionTables },
+    api
+  };
+  return { ok: true, schema };
+}
+function parseParagraphType(raw, sourceFile) {
+  const result = ParagraphTypeRawSchema.safeParse(raw);
+  if (!result.success) {
+    return { ok: false, errors: zodErrorsToParseErrors(result.error, sourceFile) };
+  }
+  const v = result.data;
+  const dupErrors = checkDuplicateFieldNames(v.fields, sourceFile, v.name);
+  if (dupErrors.length > 0) return { ok: false, errors: dupErrors };
+  const tableName = machineNameToTableName(v.name);
+  const { fields, errors } = buildFields(v.fields, sourceFile, tableName);
+  if (errors.length > 0) return { ok: false, errors };
+  const schema = {
+    schema_type: "paragraph-type",
+    name: v.name,
+    label: v.label,
+    source_file: sourceFile,
+    system_fields: PARAGRAPH_SYSTEM_FIELDS,
+    fields,
+    db: { table_name: tableName }
+  };
+  return { ok: true, schema };
+}
+function parseTaxonomyType(raw, sourceFile) {
+  const result = TaxonomyTypeRawSchema.safeParse(raw);
+  if (!result.success) {
+    return { ok: false, errors: zodErrorsToParseErrors(result.error, sourceFile) };
+  }
+  const v = result.data;
+  const dupErrors = checkDuplicateFieldNames(v.fields, sourceFile, v.name);
+  if (dupErrors.length > 0) return { ok: false, errors: dupErrors };
+  const tableName = machineNameToTableName(v.name);
+  const { fields, errors } = buildFields(v.fields, sourceFile, tableName);
+  if (errors.length > 0) return { ok: false, errors };
+  const nameKebab = nameSegmentToKebab(getNameSegment(v.name));
+  const basePath = `/api/taxonomy/${nameKebab}`;
+  const schema = {
+    schema_type: "taxonomy-type",
+    name: v.name,
+    label: v.label,
+    source_file: sourceFile,
+    system_fields: TAXONOMY_SYSTEM_FIELDS,
+    fields,
+    db: { table_name: tableName },
+    api: {
+      collection_path: basePath,
+      item_path: `${basePath}/:id`
+    }
+  };
+  return { ok: true, schema };
+}
+function parseEnumType(raw, sourceFile) {
+  const result = EnumTypeRawSchema.safeParse(raw);
+  if (!result.success) {
+    return { ok: false, errors: zodErrorsToParseErrors(result.error, sourceFile) };
+  }
+  const v = result.data;
+  const schema = {
+    schema_type: "enum-type",
+    name: v.name,
+    label: v.label,
+    source_file: sourceFile,
+    values: v.values
+  };
+  return { ok: true, schema };
+}
+function parseSchema(raw, schemaType, sourceFile = "") {
+  switch (schemaType) {
+    case "content-type":
+      return parseContentType(raw, sourceFile);
+    case "paragraph-type":
+      return parseParagraphType(raw, sourceFile);
+    case "taxonomy-type":
+      return parseTaxonomyType(raw, sourceFile);
+    case "enum-type":
+      return parseEnumType(raw, sourceFile);
+  }
+}
+
+// src/parser/parseRoles.ts
+import { z as z2 } from "zod";
+var VALID_PERMISSIONS = /* @__PURE__ */ new Set([
+  "content:read",
+  "content:create",
+  "content:edit",
+  "content:delete",
+  "media:read",
+  "media:create",
+  "media:edit",
+  "media:delete",
+  "taxonomy:read",
+  "taxonomy:create",
+  "taxonomy:edit",
+  "taxonomy:delete",
+  "users:read",
+  "users:create",
+  "users:edit",
+  "users:delete",
+  "roles:read"
+]);
+var INVALID_ROLE_PERMISSIONS = /* @__PURE__ */ new Set(["roles:create", "roles:edit", "roles:delete"]);
+var VALID_PERMISSIONS_LIST = [
+  "content:read",
+  "content:create",
+  "content:edit",
+  "content:delete",
+  "media:read",
+  "media:create",
+  "media:edit",
+  "media:delete",
+  "taxonomy:read",
+  "taxonomy:create",
+  "taxonomy:edit",
+  "taxonomy:delete",
+  "users:read",
+  "users:create",
+  "users:edit",
+  "users:delete",
+  "roles:read"
+];
+var RawRoleSchema = z2.object({
+  name: z2.string().min(1),
+  label: z2.string().min(1),
+  is_system: z2.boolean().default(false),
+  hierarchy_level: z2.number().int().min(0),
+  permissions: z2.array(z2.string())
+});
+var RawRolesFileSchema = z2.object({
+  roles: z2.array(RawRoleSchema).min(1)
+});
+function zodRolesErrorsToParseErrors(error, sourceFile) {
+  return error.issues.map((issue) => ({
+    file: sourceFile,
+    code: "MISSING_REQUIRED_FIELD",
+    message: issue.message,
+    ...issue.path.length > 0 ? { path: issue.path.join(".") } : {}
+  }));
+}
+function parseRoles(raw, sourceFile = "roles/roles.json") {
+  const result = RawRolesFileSchema.safeParse(raw);
+  if (!result.success) {
+    return { ok: false, errors: zodRolesErrorsToParseErrors(result.error, sourceFile) };
+  }
+  const { roles } = result.data;
+  const errors = [];
+  for (const role of roles) {
+    for (let i = 0; i < role.permissions.length; i++) {
+      const perm = role.permissions[i];
+      if (INVALID_ROLE_PERMISSIONS.has(perm)) {
+        errors.push({
+          file: sourceFile,
+          code: "INVALID_PERMISSION",
+          message: `Role "${role.name}" contains invalid permission "${perm}" \u2014 roles:create, roles:edit, and roles:delete are not valid permissions; roles are managed through schema files and CLI only`,
+          path: `roles[${roles.indexOf(role)}].permissions[${i}]`
+        });
+      } else if (!VALID_PERMISSIONS.has(perm)) {
+        errors.push({
+          file: sourceFile,
+          code: "UNKNOWN_PERMISSION",
+          message: `Role "${role.name}" contains unknown permission "${perm}"`,
+          path: `roles[${roles.indexOf(role)}].permissions[${i}]`
+        });
+      }
+    }
+  }
+  const levelsSeen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < roles.length; i++) {
+    const role = roles[i];
+    const existing = levelsSeen.get(role.hierarchy_level);
+    if (existing !== void 0) {
+      errors.push({
+        file: sourceFile,
+        code: "DUPLICATE_HIERARCHY_LEVEL",
+        message: `Roles "${existing}" and "${role.name}" both have hierarchy_level ${role.hierarchy_level} \u2014 each role must have a unique hierarchy_level`,
+        path: `roles[${i}].hierarchy_level`
+      });
+    } else {
+      levelsSeen.set(role.hierarchy_level, role.name);
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  const parsedRoles = roles.map((r) => ({
+    name: r.name,
+    label: r.label,
+    is_system: r.is_system,
+    hierarchy_level: r.hierarchy_level,
+    permissions: r.permissions
+  })).sort((a, b) => a.hierarchy_level - b.hierarchy_level);
+  const parsed = {
+    roles: parsedRoles,
+    valid_permissions: VALID_PERMISSIONS_LIST
+  };
+  return { ok: true, value: parsed };
+}
+
+// src/auth.ts
+import bcrypt from "bcryptjs";
+var SALT_ROUNDS = 12;
+async function hashPassword(password) {
+  return bcrypt.hash(password, SALT_ROUNDS);
+}
+async function verifyPassword(password, stored) {
+  return bcrypt.compare(password, stored);
+}
+export {
+  buildSchemaRegistry,
+  defineConfig,
+  hashPassword,
+  loadSchemaFile,
+  parseRoles,
+  parseRoutes,
+  parseSchema,
+  validateCrossReferences,
+  verifyPassword,
+  walkSchemaDirectory
+};
+//# sourceMappingURL=index.mjs.map