@kyro-cms/core 0.3.2 → 0.3.5

package/dist/chunk-2UOI5MUC.cjs

@@ -0,0 +1,1276 @@
+'use strict';
+
+var chunkK7JPTH3G_cjs = require('./chunk-K7JPTH3G.cjs');
+var chunkDE7OQOMD_cjs = require('./chunk-DE7OQOMD.cjs');
+var chunkIBG6V56E_cjs = require('./chunk-IBG6V56E.cjs');
+var chunkVJT6P4N6_cjs = require('./chunk-VJT6P4N6.cjs');
+var chunkDVD5P72E_cjs = require('./chunk-DVD5P72E.cjs');
+var zod = require('zod');
+
+// src/registry/validator.ts
+function findFieldByName(fields, name) {
+  for (const field of fields) {
+    if (field.name === name) {
+      return true;
+    }
+    if ("tabs" in field && field.tabs) {
+      for (const tab of field.tabs) {
+        if (findFieldByName(tab.fields, name)) {
+          return true;
+        }
+      }
+    }
+    if ("fields" in field && field.fields) {
+      if (findFieldByName(field.fields, name)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var ConfigValidationError = class extends Error {
+  errors;
+  constructor(errors) {
+    super(`Configuration validation failed:
+${errors.join("\n")}`);
+    this.name = "ConfigValidationError";
+    this.errors = errors;
+  }
+};
+function validateCollection(config) {
+  const errors = [];
+  if (!config.slug) {
+    errors.push(`Collection is missing a "slug" property`);
+  } else if (!/^[a-z][a-z0-9_-]*$/.test(config.slug)) {
+    errors.push(`Collection slug "${config.slug}" must be lowercase alphanumeric with dashes`);
+  }
+  if (!config.fields || config.fields.length === 0) {
+    errors.push(`Collection "${config.slug}" has no fields defined`);
+  } else {
+    const fieldErrors = validateFields(config.fields, config.slug);
+    errors.push(...fieldErrors);
+  }
+  if (config.access) {
+    for (const [action, handler] of Object.entries(config.access)) {
+      if (typeof handler !== "boolean" && typeof handler !== "function") {
+        errors.push(`Collection "${config.slug}" has invalid access.${action} (must be boolean or function)`);
+      }
+    }
+  }
+  if (config.admin?.useAsTitle) {
+    const fieldExists = findFieldByName(config.fields, config.admin.useAsTitle);
+    if (!fieldExists) {
+      errors.push(`Collection "${config.slug}" admin.useAsTitle references unknown field "${config.admin.useAsTitle}"`);
+    }
+  }
+  if (config.admin?.defaultColumns) {
+    for (const col of config.admin.defaultColumns) {
+      const fieldExists = findFieldByName(config.fields, col);
+      if (!fieldExists) {
+        errors.push(`Collection "${config.slug}" admin.defaultColumns references unknown field "${col}"`);
+      }
+    }
+  }
+  if (config.upload) {
+    if (config.upload.fileSize && config.upload.fileSize <= 0) {
+      errors.push(`Collection "${config.slug}" upload.fileSize must be positive`);
+    }
+  }
+  if (config.versions) {
+    if (config.versions.maxPerDoc && config.versions.maxPerDoc <= 0) {
+      errors.push(`Collection "${config.slug}" versions.maxPerDoc must be positive`);
+    }
+  }
+  if (config.auth) {
+    const hasEmailField = config.fields.some((f) => f.name === "email");
+    const hasPasswordField = config.fields.some((f) => f.name === "password");
+    if (!hasEmailField) {
+      errors.push(`Collection "${config.slug}" with auth enabled requires an "email" field`);
+    }
+    if (!hasPasswordField) {
+      errors.push(`Collection "${config.slug}" with auth enabled requires a "password" field`);
+    }
+  }
+  return errors;
+}
+function validateGlobal(config) {
+  const errors = [];
+  if (!config.slug) {
+    errors.push(`Global is missing a "slug" property`);
+  } else if (!/^[a-z][a-z0-9_-]*$/.test(config.slug)) {
+    errors.push(`Global slug "${config.slug}" must be lowercase alphanumeric with dashes`);
+  }
+  if (!config.fields || config.fields.length === 0) {
+    errors.push(`Global "${config.slug}" has no fields defined`);
+  } else {
+    const fieldErrors = validateFields(config.fields, `global:${config.slug}`);
+    errors.push(...fieldErrors);
+  }
+  return errors;
+}
+function validateFields(fields, context) {
+  const errors = [];
+  const fieldNames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i];
+    if (field.type === "row" || field.type === "collapsible" || field.type === "tabs") {
+      if ("fields" in field && field.fields) {
+        const nestedErrors = validateFields(field.fields, context);
+        errors.push(...nestedErrors);
+      } else if ("tabs" in field) {
+        for (const tab of field.tabs) {
+          const tabErrors = validateFields(tab.fields, context);
+          errors.push(...tabErrors);
+        }
+      }
+      continue;
+    }
+    const fieldName = field.name;
+    if (!fieldName) {
+      errors.push(`${context}: Field at index ${i} is missing a "name" property`);
+      continue;
+    }
+    if (fieldNames.has(fieldName)) {
+      errors.push(`${context}: Duplicate field name "${fieldName}"`);
+    }
+    fieldNames.add(fieldName);
+    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(fieldName)) {
+      errors.push(`${context}: Field name "${fieldName}" must be alphanumeric with underscores`);
+    }
+    if (!field.type) {
+      errors.push(`${context}: Field "${fieldName}" is missing a "type" property`);
+      continue;
+    }
+    switch (field.type) {
+      case "relationship":
+        if (!field.relationTo) {
+          errors.push(`${context}: Relationship field "${fieldName}" is missing "relationTo"`);
+        }
+        break;
+      case "array":
+        if (!field.fields || field.fields.length === 0) {
+          errors.push(`${context}: Array field "${fieldName}" has no fields defined`);
+        } else {
+          const arrayErrors = validateFields(field.fields, `${context}.${fieldName}`);
+          errors.push(...arrayErrors);
+        }
+        break;
+      case "group":
+        if (!field.fields || field.fields.length === 0) {
+          errors.push(`${context}: Group field "${fieldName}" has no fields defined`);
+        } else {
+          const groupErrors = validateFields(field.fields, `${context}.${fieldName}`);
+          errors.push(...groupErrors);
+        }
+        break;
+      case "blocks":
+        if (!field.blocks || field.blocks.length === 0) {
+          errors.push(`${context}: Blocks field "${fieldName}" has no blocks defined`);
+        } else {
+          const blockErrors = validateBlocks(field.blocks, `${context}.${fieldName}`);
+          errors.push(...blockErrors);
+        }
+        break;
+      case "select":
+      case "radio":
+        if (!field.options || field.options.length === 0) {
+          errors.push(`${context}: ${field.type} field "${fieldName}" has no options defined`);
+        } else {
+          const values = field.options.map((o) => o.value);
+          const uniqueValues = new Set(values);
+          if (values.length !== uniqueValues.size) {
+            errors.push(`${context}: ${field.type} field "${fieldName}" has duplicate option values`);
+          }
+        }
+        break;
+      case "upload":
+        if (!field.relationTo) {
+          errors.push(`${context}: Upload field "${fieldName}" is missing "relationTo"`);
+        }
+        break;
+    }
+    if ("min" in field && "max" in field && field.min > field.max) {
+      errors.push(`${context}: Field "${fieldName}" has min greater than max`);
+    }
+    if ("minLength" in field && "maxLength" in field && field.minLength > field.maxLength) {
+      errors.push(`${context}: Field "${fieldName}" has minLength greater than maxLength`);
+    }
+    if ("minRows" in field && "maxRows" in field && field.minRows > field.maxRows) {
+      errors.push(`${context}: Field "${fieldName}" has minRows greater than maxRows`);
+    }
+  }
+  return errors;
+}
+function validateBlocks(blocks, context) {
+  const errors = [];
+  const slugs = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    if (!block.slug) {
+      errors.push(`${context}: Block is missing a "slug" property`);
+      continue;
+    }
+    if (slugs.has(block.slug)) {
+      errors.push(`${context}: Duplicate block slug "${block.slug}"`);
+    }
+    slugs.add(block.slug);
+    if (!block.label) {
+      errors.push(`${context}: Block "${block.slug}" is missing a "label" property`);
+    }
+    if (!block.fields || block.fields.length === 0) {
+      errors.push(`${context}: Block "${block.slug}" has no fields defined`);
+    } else {
+      const blockErrors = validateFields(block.fields, `${context}.${block.slug}`);
+      errors.push(...blockErrors);
+    }
+  }
+  return errors;
+}
+function validateConfig(collections, globals = []) {
+  const errors = [];
+  const slugs = /* @__PURE__ */ new Set();
+  for (const collection of collections) {
+    if (slugs.has(collection.slug)) {
+      errors.push(`Duplicate collection slug "${collection.slug}"`);
+    }
+    slugs.add(collection.slug);
+  }
+  for (const global of globals) {
+    if (slugs.has(global.slug)) {
+      errors.push(`Duplicate global slug "${global.slug}"`);
+    }
+    slugs.add(global.slug);
+  }
+  for (const collection of collections) {
+    const collectionErrors = validateCollection(collection);
+    errors.push(...collectionErrors);
+  }
+  for (const global of globals) {
+    const globalErrors = validateGlobal(global);
+    errors.push(...globalErrors);
+  }
+  for (const collection of collections) {
+    const relationshipErrors = validateRelationships(collection.fields, collections);
+    errors.push(...relationshipErrors);
+  }
+  if (errors.length > 0) {
+    throw new ConfigValidationError(errors);
+  }
+}
+function validateRelationships(fields, collections) {
+  const errors = [];
+  const collectionSlugs = new Set(collections.map((c) => c.slug));
+  for (const field of fields) {
+    if (field.type === "relationship") {
+      const targets = Array.isArray(field.relationTo) ? field.relationTo : [field.relationTo];
+      for (const target of targets) {
+        if (!collectionSlugs.has(target)) {
+          errors.push(`Relationship field "${field.name}" references unknown collection "${target}"`);
+        }
+      }
+    }
+    if (field.type === "upload") {
+      const targets = Array.isArray(field.relationTo) ? field.relationTo : [field.relationTo];
+      for (const target of targets) {
+        if (!collectionSlugs.has(target)) {
+          errors.push(`Upload field "${field.name}" references unknown collection "${target}"`);
+        }
+      }
+    }
+    if ("fields" in field && field.fields) {
+      const nestedErrors = validateRelationships(field.fields, collections);
+      errors.push(...nestedErrors);
+    }
+    if ("tabs" in field) {
+      for (const tab of field.tabs) {
+        const tabErrors = validateRelationships(tab.fields, collections);
+        errors.push(...tabErrors);
+      }
+    }
+    if ("blocks" in field) {
+      for (const block of field.blocks) {
+        const blockErrors = validateRelationships(block.fields, collections);
+        errors.push(...blockErrors);
+      }
+    }
+  }
+  return errors;
+}
+function fieldToZod(field) {
+  switch (field.type) {
+    case "text":
+      return textToZod(field);
+    case "number":
+      return numberToZod(field);
+    case "checkbox":
+      return checkboxToZod(field);
+    case "date":
+      return dateToZod(field);
+    case "email":
+      return emailToZod(field);
+    case "password":
+      return passwordToZod(field);
+    case "textarea":
+      return textareaToZod(field);
+    case "select":
+      return selectToZod(field);
+    case "radio":
+      return radioToZod(field);
+    case "color":
+      return colorToZod(field);
+    case "richtext":
+      return richTextToZod(field);
+    case "json":
+      return jsonToZod(field);
+    case "code":
+      return codeToZod(field);
+    case "upload":
+      return uploadToZod(field);
+    case "image":
+      return uploadToZod(field);
+    case "markdown":
+      return markdownToZod(field);
+    case "relationship":
+      return relationshipToZod(field);
+    case "relationship-block":
+      return relationshipToZod(field);
+    case "array":
+      return arrayToZod(field);
+    case "list":
+      return listToZod(field);
+    case "group":
+      return groupToZod(field);
+    case "blocks":
+      return blocksToZod(field);
+    case "row":
+      return rowToZod(field);
+    case "collapsible":
+      return collapsibleToZod(field);
+    case "tabs":
+      return tabsToZod(field);
+    default:
+      return zod.z.any();
+  }
+}
+function textToZod(field) {
+  let schema = zod.z.string();
+  if (field.minLength) schema = schema.min(field.minLength);
+  if (field.maxLength) schema = schema.max(field.maxLength);
+  if (field.pattern) schema = schema.regex(new RegExp(field.pattern));
+  if (field.variant === "email") schema = schema.email();
+  if (field.variant === "url") schema = schema.url();
+  if (field.hasMany) schema = zod.z.array(schema);
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function numberToZod(field) {
+  let schema = field.integer ? zod.z.number().int() : zod.z.number();
+  if (field.min !== void 0) schema = schema.min(field.min);
+  if (field.max !== void 0) schema = schema.max(field.max);
+  if (field.step) {
+    schema = schema.refine(
+      (val) => Number.isInteger(val / field.step),
+      `Value must be divisible by ${field.step}`
+    );
+  }
+  if (field.hasMany) schema = zod.z.array(schema);
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function checkboxToZod(field) {
+  let schema = zod.z.boolean();
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function dateToZod(field) {
+  let schema = zod.z.string().refine((val) => !isNaN(Date.parse(val)), "Invalid date format");
+  if (field.minDate) {
+    schema = schema.refine(
+      (val) => new Date(val) >= new Date(field.minDate),
+      `Date must be after ${field.minDate}`
+    );
+  }
+  if (field.maxDate) {
+    schema = schema.refine(
+      (val) => new Date(val) <= new Date(field.maxDate),
+      `Date must be before ${field.maxDate}`
+    );
+  }
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function emailToZod(field) {
+  let schema = zod.z.string().email("Invalid email");
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function passwordToZod(field) {
+  let schema = zod.z.string().min(6, "Password must be at least 6 characters");
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function textareaToZod(field) {
+  let schema = zod.z.string();
+  if (field.minLength) schema = schema.min(field.minLength);
+  if (field.maxLength) schema = schema.max(field.maxLength);
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function selectToZod(field) {
+  const values = field.options.map((opt) => opt.value);
+  let schema;
+  if (field.hasMany) {
+    schema = zod.z.array(zod.z.enum(values));
+  } else {
+    schema = zod.z.enum(values);
+  }
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function radioToZod(field) {
+  const values = field.options.map((opt) => opt.value);
+  let schema = zod.z.enum(values);
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function colorToZod(field) {
+  let schema = zod.z.string();
+  if (field.format === "hex")
+    schema = schema.regex(/^#[0-9A-Fa-f]{6}$/);
+  if (field.format === "rgb")
+    schema = schema.regex(
+      /^rgb\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*\)$/
+    );
+  if (field.format === "hsl")
+    schema = schema.regex(
+      /^hsl\(\s*\d{1,3}\s*,\s*\d{1,3}%\s*,\s*\d{1,3}%\s*\)$/
+    );
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function richTextToZod(field) {
+  let schema = zod.z.union([
+    zod.z.array(zod.z.record(zod.z.any())),
+    zod.z.string()
+  ]);
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function jsonToZod(field) {
+  let schema = zod.z.union([zod.z.record(zod.z.any()), zod.z.array(zod.z.any())]);
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function codeToZod(field) {
+  let schema = zod.z.string();
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function uploadToZod(field) {
+  let schema;
+  if (field.relationTo) {
+    const mediaSchema = zod.z.object({
+      id: zod.z.string(),
+      url: zod.z.string().optional(),
+      filename: zod.z.string().optional(),
+      mimeType: zod.z.string().optional()
+    });
+    schema = zod.z.union([zod.z.string(), mediaSchema]);
+  } else {
+    schema = zod.z.string();
+  }
+  if (field.hasMany) {
+    schema = zod.z.array(schema);
+  }
+  if (!field.required) {
+    schema = schema.optional().nullable();
+  }
+  if (field.validate) {
+    schema = addCustomValidation(schema, field.validate);
+  }
+  return schema;
+}
+function markdownToZod(field) {
+  let schema = zod.z.string();
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function relationshipToZod(field) {
+  let schema;
+  if (Array.isArray(field.relationTo)) {
+    schema = zod.z.object({
+      relationTo: zod.z.enum(field.relationTo),
+      value: zod.z.string()
+    });
+  } else {
+    schema = zod.z.union([
+      zod.z.string(),
+      zod.z.object({ relationTo: zod.z.string(), value: zod.z.string() })
+    ]);
+  }
+  if (field.hasMany) schema = zod.z.array(schema);
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function arrayToZod(field) {
+  const itemSchema = zod.z.object(
+    Object.fromEntries(
+      field.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
+    )
+  );
+  let schema = zod.z.array(itemSchema);
+  if (field.minRows) schema = schema.min(field.minRows);
+  if (field.maxRows) schema = schema.max(field.maxRows);
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function listToZod(field) {
+  let schema = zod.z.array(zod.z.string());
+  if (!field.required) schema = schema.optional().nullable();
+  return schema;
+}
+function groupToZod(field) {
+  const schema = zod.z.object(
+    Object.fromEntries(
+      field.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
+    )
+  );
+  if (!field.required) return schema.optional().nullable();
+  return schema;
+}
+function blocksToZod(field) {
+  const blocks = field.blocks || [];
+  blocks.map((block) => {
+    return zod.z.object({
+      blockType: zod.z.literal(block.slug),
+      ...Object.fromEntries(
+        block.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
+      )
+    });
+  });
+  const knownTypes = blocks.map((b) => b.slug);
+  let schema;
+  if (knownTypes.length > 0) {
+    const knownSchema = zod.z.object({
+      blockType: zod.z.enum(knownTypes)
+    }).catchall(zod.z.any());
+    const unknownSchema = zod.z.object({
+      blockType: zod.z.string()
+    }).catchall(zod.z.any());
+    schema = zod.z.array(zod.z.union([knownSchema, unknownSchema]));
+  } else {
+    schema = zod.z.array(zod.z.object({ blockType: zod.z.string() }).catchall(zod.z.any()));
+  }
+  if (field.minRows) schema = schema.min(field.minRows);
+  if (field.maxRows) schema = schema.max(field.maxRows);
+  if (!field.required) schema = schema.optional().nullable();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function rowToZod(field) {
+  const schema = zod.z.object(
+    Object.fromEntries(
+      field.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
+    )
+  );
+  return schema;
+}
+function collapsibleToZod(field) {
+  const schema = zod.z.object(
+    Object.fromEntries(
+      field.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
+    )
+  );
+  return schema;
+}
+function tabsToZod(field) {
+  const schemas = {};
+  for (const tab of field.tabs) {
+    for (const f of tab.fields) {
+      if (f.name) {
+        schemas[f.name] = fieldToZod(f);
+      }
+    }
+  }
+  return zod.z.object(schemas);
+}
+function addCustomValidation(schema, validate) {
+  return schema.refine(
+    async (val) => {
+      const result = await validate(val, { required: false });
+      return result === true;
+    },
+    {
+      message: "Custom validation failed"
+    }
+  );
+}
+function buildNestedShape(fields) {
+  const shape = {};
+  for (const field of fields) {
+    if (!field.name) continue;
+    if (field.type === "tabs" && "tabs" in field) {
+      const tabShape = {};
+      for (const tab of field.tabs) {
+        const nestedShape = buildNestedShape(tab.fields);
+        Object.assign(tabShape, nestedShape);
+      }
+      shape[field.name] = zod.z.object(tabShape);
+    } else if (field.type === "row" && "fields" in field) {
+      const rowShape = buildNestedShape(field.fields);
+      Object.assign(shape, rowShape);
+    } else if (field.type === "collapsible" && "fields" in field) {
+      shape[field.name] = zod.z.object(buildNestedShape(field.fields));
+    } else {
+      shape[field.name] = fieldToZod(field);
+    }
+  }
+  return shape;
+}
+function collectionToZod(collection) {
+  const shape = buildNestedShape(collection.fields);
+  if (collection.timestamps) {
+    shape["createdAt"] = zod.z.string().optional();
+    shape["updatedAt"] = zod.z.string().optional();
+  }
+  if (collection.tenantScoped) {
+    shape["tenantID"] = zod.z.string().optional();
+  }
+  shape["id"] = zod.z.string().optional();
+  return zod.z.object(shape).passthrough();
+}
+function collectionToCreateZod(collection) {
+  const shape = buildNestedShape(collection.fields);
+  return zod.z.object(shape).passthrough();
+}
+function collectionToUpdateZod(collection) {
+  const shape = {};
+  for (const field of collection.fields) {
+    if (!field.name) continue;
+    if (field.type === "tabs" && "tabs" in field) {
+      const tabShape = {};
+      for (const tab of field.tabs) {
+        for (const tabField of tab.fields) {
+          if (tabField.name) {
+            tabShape[tabField.name] = fieldToZod(tabField).optional().nullable();
+          }
+        }
+      }
+      shape[field.name] = zod.z.object(tabShape).optional().nullable();
+    } else if (field.type === "row" && "fields" in field) {
+      const rowShape = {};
+      for (const rowField of field.fields) {
+        if (rowField.name) {
+          rowShape[rowField.name] = fieldToZod(rowField).optional().nullable();
+        }
+      }
+      Object.assign(shape, rowShape);
+    } else if (field.type === "collapsible" && "fields" in field) {
+      shape[field.name] = zod.z.object(buildNestedShape(field.fields)).optional().nullable();
+    } else {
+      shape[field.name] = fieldToZod(field).optional().nullable();
+    }
+  }
+  return zod.z.object(shape).passthrough();
+}
+function collectionToWhereZod(collection) {
+  const shape = {};
+  for (const field of collection.fields) {
+    if (field.name) {
+      shape[field.name] = zod.z.object({
+        equals: zod.z.any().optional(),
+        not_equals: zod.z.any().optional(),
+        in: zod.z.array(zod.z.any()).optional(),
+        not_in: zod.z.array(zod.z.any()).optional(),
+        greater_than: zod.z.number().optional(),
+        greater_than_equal: zod.z.number().optional(),
+        less_than: zod.z.number().optional(),
+        less_than_equal: zod.z.number().optional(),
+        like: zod.z.string().optional(),
+        not_like: zod.z.string().optional(),
+        contains: zod.z.string().optional(),
+        exists: zod.z.boolean().optional()
+      }).optional();
+    }
+  }
+  shape["AND"] = zod.z.array(zod.z.lazy(() => zod.z.object(shape))).optional();
+  shape["OR"] = zod.z.array(zod.z.lazy(() => zod.z.object(shape))).optional();
+  return zod.z.object(shape).optional();
+}
+function globalToZod(global) {
+  const shape = buildNestedShape(global.fields);
+  shape["id"] = zod.z.string().optional();
+  return zod.z.object(shape).passthrough();
+}
+
+// src/registry/index.ts
+var Registry = class {
+  collections = /* @__PURE__ */ new Map();
+  globals = /* @__PURE__ */ new Map();
+  plugins = [];
+  schemaCache = /* @__PURE__ */ new Map();
+  initialized = false;
+  // ========================================================================
+  // Collection Management
+  // ========================================================================
+  addCollection(config) {
+    if (this.initialized) {
+      throw new Error(
+        "Cannot add collections after Registry has been initialized"
+      );
+    }
+    if (this.collections.has(config.slug)) {
+      console.warn(
+        `[Registry] Duplicate collection slug "${config.slug}" \u2014 skipping`
+      );
+      return;
+    }
+    let finalConfig = { ...config };
+    for (const plugin of this.plugins) {
+      if (plugin.extendCollection) {
+        finalConfig = plugin.extendCollection(finalConfig.slug, finalConfig);
+      }
+    }
+    finalConfig.fields = this.applyFieldDefaults(finalConfig);
+    const errors = validateCollection(finalConfig);
+    if (errors.length > 0) {
+      throw new Error(`Invalid collection config: ${errors.join(", ")}`);
+    }
+    this.collections.set(finalConfig.slug, finalConfig);
+    this.clearSchemaCache(finalConfig.slug);
+  }
+  addCollections(configs) {
+    for (const config of configs) {
+      this.addCollection(config);
+    }
+  }
+  getCollection(slug) {
+    return this.collections.get(slug);
+  }
+  getCollections() {
+    return Array.from(this.collections.values());
+  }
+  getCollectionSlugs() {
+    return Array.from(this.collections.keys());
+  }
+  hasCollection(slug) {
+    return this.collections.has(slug);
+  }
+  removeCollection(slug) {
+    if (this.initialized) {
+      throw new Error(
+        "Cannot remove collections after Registry has been initialized"
+      );
+    }
+    this.clearSchemaCache(slug);
+    return this.collections.delete(slug);
+  }
+  // ========================================================================
+  // Global Management
+  // ========================================================================
+  addGlobal(config) {
+    if (this.initialized) {
+      throw new Error("Cannot add globals after Registry has been initialized");
+    }
+    if (this.globals.has(config.slug)) {
+      console.warn(
+        `[Registry] Duplicate global slug "${config.slug}" \u2014 skipping`
+      );
+      return;
+    }
+    const errors = validateGlobal(config);
+    if (errors.length > 0) {
+      throw new Error(`Invalid global config: ${errors.join(", ")}`);
+    }
+    let finalConfig = { ...config };
+    for (const plugin of this.plugins) {
+      if (plugin.extendGlobal) {
+        finalConfig = plugin.extendGlobal(finalConfig.slug, finalConfig);
+      }
+    }
+    this.globals.set(finalConfig.slug, finalConfig);
+    this.clearSchemaCache(`global:${finalConfig.slug}`);
+  }
+  addGlobals(configs) {
+    for (const config of configs) {
+      this.addGlobal(config);
+    }
+  }
+  getGlobal(slug) {
+    return this.globals.get(slug);
+  }
+  getGlobals() {
+    return Array.from(this.globals.values());
+  }
+  getGlobalSlugs() {
+    return Array.from(this.globals.keys());
+  }
+  hasGlobal(slug) {
+    return this.globals.has(slug);
+  }
+  removeGlobal(slug) {
+    if (this.initialized) {
+      throw new Error(
+        "Cannot remove globals after Registry has been initialized"
+      );
+    }
+    this.clearSchemaCache(`global:${slug}`);
+    return this.globals.delete(slug);
+  }
+  // ========================================================================
+  // Plugin Management
+  // ========================================================================
+  addPlugin(plugin) {
+    if (this.initialized) {
+      throw new Error("Cannot add plugins after Registry has been initialized");
+    }
+    this.plugins.push(plugin);
+  }
+  getPlugins() {
+    return [...this.plugins];
+  }
+  // ========================================================================
+  // Schema Generation
+  // ========================================================================
+  getZodSchema(slug) {
+    const cached = this.schemaCache.get(slug);
+    if (cached) return cached;
+    const collection = this.collections.get(slug);
+    if (collection) {
+      const schema = collectionToZod(collection);
+      this.schemaCache.set(slug, schema);
+      return schema;
+    }
+    const global = this.globals.get(slug);
+    if (global) {
+      const schema = globalToZod(global);
+      this.schemaCache.set(`global:${slug}`, schema);
+      return schema;
+    }
+    throw new Error(`No collection or global found with slug "${slug}"`);
+  }
+  getCreateZodSchema(slug) {
+    const cacheKey = `${slug}:create`;
+    const cached = this.schemaCache.get(cacheKey);
+    if (cached) return cached;
+    const collection = this.collections.get(slug);
+    if (collection) {
+      const schema = collectionToCreateZod(collection);
+      this.schemaCache.set(cacheKey, schema);
+      return schema;
+    }
+    throw new Error(`No collection found with slug "${slug}"`);
+  }
+  getUpdateZodSchema(slug) {
+    const cacheKey = `${slug}:update`;
+    const cached = this.schemaCache.get(cacheKey);
+    if (cached) return cached;
+    const collection = this.collections.get(slug);
+    if (collection) {
+      const schema = collectionToUpdateZod(collection);
+      this.schemaCache.set(cacheKey, schema);
+      return schema;
+    }
+    throw new Error(`No collection found with slug "${slug}"`);
+  }
+  getWhereZodSchema(slug) {
+    const cacheKey = `${slug}:where`;
+    const cached = this.schemaCache.get(cacheKey);
+    if (cached) return cached;
+    const collection = this.collections.get(slug);
+    if (collection) {
+      const schema = collectionToWhereZod(collection);
+      this.schemaCache.set(cacheKey, schema);
+      return schema;
+    }
+    throw new Error(`No collection found with slug "${slug}"`);
+  }
+  getFieldZodSchema(field) {
+    return fieldToZod(field);
+  }
+  clearSchemaCache(slug) {
+    this.schemaCache.delete(slug);
+    this.schemaCache.delete(`${slug}:create`);
+    this.schemaCache.delete(`${slug}:update`);
+    this.schemaCache.delete(`${slug}:where`);
+  }
+  // ========================================================================
+  // Field Helpers
+  // ========================================================================
+  applyFieldDefaults(config) {
+    const fields = [...config.fields];
+    if (!fields.some((f) => f.name === "id")) {
+      fields.unshift({
+        name: "id",
+        type: "text",
+        admin: { readOnly: true, hidden: true }
+      });
+    }
+    if (config.tenantScoped && !fields.some((f) => f.name === "tenantID")) {
+      fields.push({
+        name: "tenantID",
+        type: "text",
+        required: true,
+        admin: { readOnly: true, hidden: true }
+      });
+    }
+    if (config.timestamps && !fields.some((f) => f.name === "createdAt")) {
+      fields.push({
+        name: "createdAt",
+        type: "date",
+        admin: { readOnly: true, hidden: true }
+      });
+      fields.push({
+        name: "updatedAt",
+        type: "date",
+        admin: { readOnly: true, hidden: true }
+      });
+    }
+    if (config.auth && !fields.some((f) => f.name === "password")) {
+      fields.push({
+        name: "password",
+        type: "password",
+        required: true,
+        admin: { hidden: true }
+      });
+    }
+    return fields;
+  }
+  getFields(slug) {
+    const collection = this.collections.get(slug);
+    if (collection) return collection.fields;
+    const global = this.globals.get(slug);
+    if (global) return global.fields;
+    throw new Error(`No collection or global found with slug "${slug}"`);
+  }
+  getFieldMap(slug) {
+    const fields = this.getFields(slug);
+    const map = /* @__PURE__ */ new Map();
+    const addFields = (fields2) => {
+      for (const field of fields2) {
+        if (field.name) {
+          map.set(field.name, field);
+        }
+        if ("fields" in field && field.fields) {
+          addFields(field.fields);
+        }
+        if ("tabs" in field) {
+          for (const tab of field.tabs) {
+            addFields(tab.fields);
+          }
+        }
+        if ("blocks" in field) {
+          for (const block of field.blocks) {
+            addFields(block.fields);
+          }
+        }
+      }
+    };
+    addFields(fields);
+    return map;
+  }
+  getVisibleFields(slug) {
+    const fields = this.getFields(slug);
+    return fields.filter((f) => !f.admin?.hidden);
+  }
+  // ========================================================================
+  // Initialization
+  // ========================================================================
+  validate() {
+    const collections = this.getCollections();
+    const globals = this.getGlobals();
+    validateConfig(collections, globals);
+  }
+  async init() {
+    this.validate();
+    for (const plugin of this.plugins) {
+      if (plugin.init) {
+        await plugin.init(this);
+      }
+    }
+    this.initialized = true;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  // ========================================================================
+  // Query Helpers
+  // ========================================================================
+  getPaginationDefaults(slug) {
+    const collection = this.collections.get(slug);
+    return {
+      defaultLimit: collection?.admin?.pagination?.defaultLimit || 10,
+      limits: collection?.admin?.pagination?.limits || [10, 25, 50, 100]
+    };
+  }
+  getDefaultSort(slug) {
+    const collection = this.collections.get(slug);
+    const useAsTitle = collection?.admin?.useAsTitle;
+    if (useAsTitle) return useAsTitle;
+    return "createdAt";
+  }
+  getDefaultColumns(slug) {
+    const collection = this.collections.get(slug);
+    if (collection?.admin?.defaultColumns) {
+      return collection.admin.defaultColumns;
+    }
+    const fields = this.getVisibleFields(slug);
+    return fields.slice(0, 4).map((f) => f.name);
+  }
+  // ========================================================================
+  // Admin Helpers
+  // ========================================================================
+  getAdminTitle(slug) {
+    const collection = this.collections.get(slug);
+    return collection?.label || collection?.admin?.description || slug;
+  }
+  getAdminLabel(slug) {
+    const collection = this.collections.get(slug);
+    return collection?.singularLabel || collection?.label || slug;
+  }
+  getAdminGroup(slug) {
+    return this.collections.get(slug)?.admin?.group;
+  }
+  // ========================================================================
+  // Debug / Stats
+  // ========================================================================
+  getStats() {
+    let totalFields = 0;
+    for (const collection of this.collections.values()) {
+      totalFields += collection.fields.length;
+    }
+    for (const global of this.globals.values()) {
+      totalFields += global.fields.length;
+    }
+    return {
+      collections: this.collections.size,
+      globals: this.globals.size,
+      plugins: this.plugins.length,
+      fields: totalFields
+    };
+  }
+  toJSON() {
+    return {
+      collections: this.getCollections(),
+      globals: this.getGlobals()
+    };
+  }
+};
+var instance = null;
+function getRegistry() {
+  if (!instance) {
+    instance = new Registry();
+  }
+  return instance;
+}
+function resetRegistry() {
+  instance = null;
+}
+function createRegistry() {
+  instance = new Registry();
+  return instance;
+}
+var Kyro = class {
+  registry;
+  db;
+  pubsub;
+  webhookService;
+  settings;
+  wsServer;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.registry = createRegistry();
+    this.db = config.adapter;
+    this.pubsub = new chunkDVD5P72E_cjs.KyroPubSub(this.registry);
+    this.webhookService = chunkIBG6V56E_cjs.createWebhookService(this.db);
+    if (config.collections) {
+      this.registry.addCollections(config.collections);
+    }
+    if (config.globals) {
+      this.registry.addGlobals(config.globals);
+    }
+    if (config.plugins) {
+      for (const plugin of config.plugins) {
+        this.registry.addPlugin(plugin);
+      }
+    }
+  }
+  async init() {
+    await this.registry.init();
+    if (!this.db) {
+      throw new Error(
+        `Database adapter is null \u2014 failed to load at startup. Check the server console for the exact error.`
+      );
+    }
+    const systemCollection = {
+      slug: chunkIBG6V56E_cjs.API_KEY_COLLECTION,
+      fields: [
+        { name: "userId", type: "text", required: true },
+        { name: "name", type: "text", required: true },
+        { name: "key", type: "text", required: true },
+        { name: "keyPrefix", type: "text", required: true },
+        { name: "permissions", type: "json" },
+        { name: "lastUsedAt", type: "date" },
+        { name: "expiresAt", type: "date" }
+      ]
+    };
+    const webhookCollection = {
+      slug: chunkIBG6V56E_cjs.WEBHOOK_COLLECTION,
+      fields: [
+        { name: "name", type: "text", required: true },
+        { name: "url", type: "text", required: true },
+        { name: "events", type: "json", required: true },
+        { name: "status", type: "text", required: true },
+        { name: "secret", type: "text" },
+        { name: "headers", type: "json" },
+        { name: "lastTriggered", type: "date" },
+        { name: "lastError", type: "text" }
+      ]
+    };
+    const webhookDeliveryCollection = {
+      slug: chunkIBG6V56E_cjs.WEBHOOK_DELIVERY_COLLECTION,
+      fields: [
+        { name: "webhookId", type: "text", required: true },
+        { name: "event", type: "text", required: true },
+        { name: "payload", type: "json", required: true },
+        { name: "attempt", type: "number", required: true },
+        { name: "status", type: "text", required: true },
+        { name: "responseStatus", type: "number" },
+        { name: "responseBody", type: "text" },
+        { name: "error", type: "text" },
+        { name: "duration", type: "number" },
+        { name: "deliveredAt", type: "date" },
+        { name: "nextRetryAt", type: "date" }
+      ]
+    };
+    await this.db.init(
+      [
+        ...this.registry.getCollections(),
+        systemCollection,
+        webhookCollection,
+        webhookDeliveryCollection
+      ],
+      this.registry.getGlobals()
+    );
+    this.pubsub.autoRegisterHooks();
+    console.log("\u2705 Kyro CMS initialized");
+    console.log(`   Collections: ${this.registry.getCollections().length}`);
+    console.log(`   Globals: ${this.registry.getGlobals().length}`);
+  }
+  // ============================================================================
+  // API Methods
+  // ============================================================================
+  // Load settings from globals if not already loaded
+  async loadSettings() {
+    if (this.settings) return this.settings;
+    try {
+      const accessSettings = await this.db.findOne({
+        collection: "_globals",
+        where: { slug: "access-settings" }
+      });
+      if (accessSettings) {
+        this.settings = accessSettings.data;
+      }
+    } catch (e) {
+      console.log("\u26A0\uFE0F No access-settings found, using defaults");
+    }
+    return this.settings || {};
+  }
+  getREST(options) {
+    const authObj = typeof this.config.auth === "object" ? this.config.auth : null;
+    const authSecret = authObj?.secret;
+    const checkSession = authObj?.checkSession !== false;
+    return chunkDE7OQOMD_cjs.createHonoApp({
+      registry: this.registry,
+      db: this.db,
+      authSecret,
+      authAdapter: this.config.authAdapter,
+      checkSession,
+      ...options,
+      cors: this.config.cors,
+      webhookService: this.webhookService,
+      settings: this.settings
+    });
+  }
+  getGraphQL(options) {
+    return chunkVJT6P4N6_cjs.buildGraphQLSchema({
+      registry: this.registry,
+      db: this.db,
+      ...options,
+      settings: this.settings
+    });
+  }
+  getTRPC(options) {
+    return chunkK7JPTH3G_cjs.createKyroServer({
+      registry: this.registry,
+      db: this.db,
+      req: options?.req || { headers: {} },
+      ...options,
+      settings: this.settings
+    });
+  }
+  async startWebSocket(options) {
+    const apiAccess = this.settings?.access?.apiAccess;
+    if (apiAccess?.websocketEnabled === false) {
+      console.log("\u26A0\uFE0F WebSocket is disabled in settings");
+      return null;
+    }
+    this.wsServer = chunkDVD5P72E_cjs.createWSServer({
+      pubsub: this.pubsub,
+      port: options?.port || 8080,
+      requireAuth: options?.requireAuth ?? apiAccess?.requireAuth,
+      verifyToken: options?.verifyToken
+    });
+    console.log(`\u{1F50C} WebSocket server started on port ${options?.port || 8080}`);
+    return this.wsServer;
+  }
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  async shutdown() {
+    if (this.wsServer) {
+      await this.wsServer.close();
+    }
+    await this.db.disconnect();
+    console.log("\u{1F44B} Kyro CMS shut down");
+  }
+};
+function createKyro(config) {
+  return new Kyro(config);
+}
+
+exports.ConfigValidationError = ConfigValidationError;
+exports.Kyro = Kyro;
+exports.Registry = Registry;
+exports.collectionToCreateZod = collectionToCreateZod;
+exports.collectionToUpdateZod = collectionToUpdateZod;
+exports.collectionToWhereZod = collectionToWhereZod;
+exports.collectionToZod = collectionToZod;
+exports.createKyro = createKyro;
+exports.createRegistry = createRegistry;
+exports.fieldToZod = fieldToZod;
+exports.getRegistry = getRegistry;
+exports.globalToZod = globalToZod;
+exports.resetRegistry = resetRegistry;
+exports.validateCollection = validateCollection;
+exports.validateConfig = validateConfig;
+exports.validateFields = validateFields;
+exports.validateGlobal = validateGlobal;
+//# sourceMappingURL=chunk-2UOI5MUC.cjs.map
+//# sourceMappingURL=chunk-2UOI5MUC.cjs.map