nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-FQULBZ53.mjs

@@ -0,0 +1,850 @@
+// src/shared/sql-reserved.ts
+var RESERVED_SLUGS = [
+  // API routes
+  "api",
+  "graphql",
+  "rest",
+  // Admin routes
+  "admin",
+  "dashboard",
+  // Auth routes
+  "auth",
+  "login",
+  "logout",
+  "register",
+  "signup",
+  "signin",
+  "signout",
+  "forgot-password",
+  "reset-password",
+  "verify",
+  "verify-email",
+  // System routes
+  "static",
+  "public",
+  "assets",
+  "_next",
+  "health",
+  "status",
+  "metrics",
+  // Common system collections
+  "users",
+  "roles",
+  "permissions",
+  "sessions",
+  "tokens",
+  "media",
+  "uploads",
+  "files"
+];
+var SQL_RESERVED_KEYWORDS = [
+  // Data manipulation
+  "select",
+  "insert",
+  "update",
+  "delete",
+  "from",
+  "where",
+  "set",
+  "values",
+  // Table operations
+  "create",
+  "drop",
+  "alter",
+  "table",
+  "index",
+  "view",
+  "trigger",
+  "database",
+  // Joins and relations
+  "join",
+  "inner",
+  "outer",
+  "left",
+  "right",
+  "cross",
+  "full",
+  "on",
+  "using",
+  // Clauses
+  "order",
+  "group",
+  "by",
+  "having",
+  "limit",
+  "offset",
+  "distinct",
+  "as",
+  "case",
+  "when",
+  "then",
+  "else",
+  "end",
+  // Logical
+  "and",
+  "or",
+  "not",
+  "in",
+  "is",
+  "null",
+  "like",
+  "between",
+  "exists",
+  // Constraints
+  "primary",
+  "foreign",
+  "key",
+  "references",
+  "unique",
+  "check",
+  "constraint",
+  "default",
+  // Transactions
+  "begin",
+  "commit",
+  "rollback",
+  "transaction",
+  // Aggregates (can cause confusion)
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  // Other commonly problematic
+  "all",
+  "any",
+  "union",
+  "except",
+  "intersect",
+  "column",
+  "row",
+  "rows",
+  "for",
+  "to",
+  "into",
+  "with",
+  // High-risk specific keywords
+  "user",
+  "password",
+  "role",
+  "session",
+  "grant",
+  "revoke",
+  "match",
+  "natural"
+];
+
+// src/shared/base-validator.ts
+var SLUG_PATTERN = /^[a-z][a-z0-9_-]*$/;
+var FIELD_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+var VALID_FIELD_TYPES = [
+  // Text types
+  "text",
+  "textarea",
+  "richText",
+  "email",
+  "password",
+  "code",
+  // Numeric types
+  "number",
+  // Selection types
+  "checkbox",
+  "date",
+  "select",
+  "radio",
+  // Media types
+  "upload",
+  // Relational types
+  "relationship",
+  // Structured types
+  "repeater",
+  "group",
+  "json",
+  // Selection / tag types
+  "chips",
+  // Component type
+  "component"
+];
+var VALID_FIELD_TYPES_SET = new Set(VALID_FIELD_TYPES);
+var DEFAULT_SQL_KEYWORDS_SET = new Set(
+  SQL_RESERVED_KEYWORDS
+);
+function isSQLKeyword(name, keywordsSet = DEFAULT_SQL_KEYWORDS_SET) {
+  return keywordsSet.has(name.toLowerCase());
+}
+function validateSlugShared(slug, errors, ctx) {
+  const path = "slug";
+  if (!slug) {
+    errors.push({
+      path,
+      message: `${ctx.entityLabel} slug is required`,
+      code: "SLUG_REQUIRED"
+    });
+    return;
+  }
+  if (typeof slug !== "string") {
+    errors.push({
+      path,
+      message: `${ctx.entityLabel} slug must be a string`,
+      code: "SLUG_INVALID_TYPE"
+    });
+    return;
+  }
+  if (slug.length < 1) {
+    errors.push({
+      path,
+      message: `${ctx.entityLabel} slug must be at least 1 character`,
+      code: "SLUG_TOO_SHORT"
+    });
+  }
+  if (slug.length > 50) {
+    errors.push({
+      path,
+      message: `${ctx.entityLabel} slug must be at most 50 characters`,
+      code: "SLUG_TOO_LONG"
+    });
+  }
+  if (!SLUG_PATTERN.test(slug)) {
+    errors.push({
+      path,
+      message: `${ctx.entityLabel} slug must start with a lowercase letter and contain only lowercase letters, numbers, hyphens, and underscores`,
+      code: "SLUG_INVALID_FORMAT"
+    });
+  }
+  if (ctx.reservedSlugsSet.has(slug.toLowerCase())) {
+    errors.push({
+      path,
+      message: `${ctx.entityLabel} slug '${slug}' is reserved and cannot be used`,
+      code: "SLUG_RESERVED"
+    });
+  }
+  if (isSQLKeyword(slug, ctx.sqlKeywordsSet)) {
+    errors.push({
+      path,
+      message: `${ctx.entityLabel} slug '${slug}' is a SQL reserved keyword. Use a different name or set 'dbName' to customize the table name`,
+      code: "SLUG_SQL_KEYWORD"
+    });
+  }
+}
+function validateFieldNameShared(name, path, errors, seenNames, sqlKeywordsSet = DEFAULT_SQL_KEYWORDS_SET) {
+  if (!name) {
+    errors.push({
+      path: `${path}.name`,
+      message: "Field name is required",
+      code: "FIELD_NAME_REQUIRED"
+    });
+    return;
+  }
+  if (typeof name !== "string") {
+    errors.push({
+      path: `${path}.name`,
+      message: "Field name must be a string",
+      code: "FIELD_NAME_REQUIRED"
+    });
+    return;
+  }
+  if (!FIELD_NAME_PATTERN.test(name)) {
+    errors.push({
+      path: `${path}.name`,
+      message: `Field name '${name}' must start with a letter and contain only letters, numbers, and underscores`,
+      code: "FIELD_NAME_INVALID_FORMAT"
+    });
+  }
+  if (isSQLKeyword(name, sqlKeywordsSet)) {
+    errors.push({
+      path: `${path}.name`,
+      message: `Field name '${name}' is a SQL reserved keyword. Consider using a different name like '${name}Field' or '${name}Value'`,
+      code: "FIELD_NAME_SQL_KEYWORD"
+    });
+  }
+  const nameLower = name.toLowerCase();
+  if (seenNames.has(nameLower)) {
+    errors.push({
+      path: `${path}.name`,
+      message: `Duplicate field name '${name}' at this level`,
+      code: "FIELD_NAME_DUPLICATE"
+    });
+  } else {
+    seenNames.add(nameLower);
+  }
+}
+function validateFieldTypeShared(fieldType, path, errors) {
+  if (!fieldType) {
+    errors.push({
+      path: `${path}.type`,
+      message: "Field type is required",
+      code: "FIELD_TYPE_REQUIRED"
+    });
+    return false;
+  }
+  if (typeof fieldType !== "string" || !VALID_FIELD_TYPES_SET.has(fieldType)) {
+    errors.push({
+      path: `${path}.type`,
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      message: `Invalid field type '${String(fieldType)}'. Valid types: ${VALID_FIELD_TYPES.join(", ")}`,
+      code: "FIELD_TYPE_INVALID"
+    });
+    return false;
+  }
+  return true;
+}
+function validateSelectOptionsShared(field, path, errors, fieldType) {
+  const options = field.options;
+  const requiredCode = fieldType === "select" ? "SELECT_OPTIONS_REQUIRED" : "RADIO_OPTIONS_REQUIRED";
+  const emptyCode = fieldType === "select" ? "SELECT_OPTIONS_EMPTY" : "RADIO_OPTIONS_EMPTY";
+  if (!options) {
+    errors.push({
+      path: `${path}.options`,
+      message: `${fieldType} field must have an 'options' array`,
+      code: requiredCode
+    });
+    return;
+  }
+  if (!Array.isArray(options)) {
+    errors.push({
+      path: `${path}.options`,
+      message: `${fieldType} field 'options' must be an array`,
+      code: requiredCode
+    });
+    return;
+  }
+  if (options.length === 0) {
+    errors.push({
+      path: `${path}.options`,
+      message: `${fieldType} field must have at least one option`,
+      code: emptyCode
+    });
+  }
+}
+function validateRelationshipTargetShared(field, path, errors, validCollectionSlugs) {
+  const relationTo = field.relationTo;
+  if (!relationTo) {
+    errors.push({
+      path: `${path}.relationTo`,
+      message: "Relationship field must specify 'relationTo'",
+      code: "RELATIONSHIP_TARGET_REQUIRED"
+    });
+    return;
+  }
+  const knownSet = validCollectionSlugs ? new Set(validCollectionSlugs) : void 0;
+  const knownList = validCollectionSlugs?.join(", ") ?? "";
+  if (typeof relationTo === "string") {
+    if (!SLUG_PATTERN.test(relationTo)) {
+      errors.push({
+        path: `${path}.relationTo`,
+        message: `Invalid relationTo value '${relationTo}'. Must be a valid collection slug`,
+        code: "RELATIONSHIP_TARGET_INVALID"
+      });
+    } else if (knownSet && !knownSet.has(relationTo)) {
+      errors.push({
+        path: `${path}.relationTo`,
+        message: `Unknown collection '${relationTo}' in relationTo. Available collections: ${knownList}`,
+        code: "RELATIONSHIP_TARGET_UNKNOWN"
+      });
+    }
+    return;
+  }
+  if (Array.isArray(relationTo)) {
+    if (relationTo.length === 0) {
+      errors.push({
+        path: `${path}.relationTo`,
+        message: "Relationship field 'relationTo' array cannot be empty",
+        code: "RELATIONSHIP_TARGET_REQUIRED"
+      });
+      return;
+    }
+    relationTo.forEach((target, index) => {
+      if (typeof target !== "string") {
+        errors.push({
+          path: `${path}.relationTo[${index}]`,
+          message: "Each relationTo value must be a string",
+          code: "RELATIONSHIP_TARGET_INVALID"
+        });
+      } else if (!SLUG_PATTERN.test(target)) {
+        errors.push({
+          path: `${path}.relationTo[${index}]`,
+          message: `Invalid relationTo value '${target}'. Must be a valid collection slug`,
+          code: "RELATIONSHIP_TARGET_INVALID"
+        });
+      } else if (knownSet && !knownSet.has(target)) {
+        errors.push({
+          path: `${path}.relationTo[${index}]`,
+          message: `Unknown collection '${target}' in relationTo. Available collections: ${knownList}`,
+          code: "RELATIONSHIP_TARGET_UNKNOWN"
+        });
+      }
+    });
+    return;
+  }
+  errors.push({
+    path: `${path}.relationTo`,
+    message: "'relationTo' must be a string or array of strings",
+    code: "RELATIONSHIP_TARGET_INVALID"
+  });
+}
+function validateComponentFieldRefShared(field, path, errors) {
+  const singleComp = field.component;
+  const multiComp = field.components;
+  if (!singleComp && !multiComp) {
+    errors.push({
+      path,
+      message: "Component field must specify either 'component' (single) or 'components' (multi/dynamic zone)",
+      code: "COMPONENT_REF_REQUIRED"
+    });
+    return;
+  }
+  if (singleComp && multiComp) {
+    errors.push({
+      path,
+      message: "Component field cannot specify both 'component' and 'components'. Use 'component' for single component or 'components' for dynamic zone",
+      code: "COMPONENT_REF_CONFLICT"
+    });
+    return;
+  }
+  if (singleComp !== void 0 && singleComp !== null) {
+    if (typeof singleComp !== "string") {
+      errors.push({
+        path: `${path}.component`,
+        message: "'component' must be a string (component slug)",
+        code: "COMPONENT_REF_INVALID"
+      });
+    }
+    return;
+  }
+  if (!Array.isArray(multiComp)) {
+    errors.push({
+      path: `${path}.components`,
+      message: "'components' must be an array of component slugs",
+      code: "COMPONENT_REF_INVALID"
+    });
+    return;
+  }
+  if (multiComp.length === 0) {
+    errors.push({
+      path: `${path}.components`,
+      message: "'components' array must have at least one component slug",
+      code: "COMPONENT_REF_EMPTY"
+    });
+    return;
+  }
+  multiComp.forEach((slug, index) => {
+    if (typeof slug !== "string") {
+      errors.push({
+        path: `${path}.components[${index}]`,
+        message: "Each component slug must be a string",
+        code: "COMPONENT_REF_INVALID"
+      });
+    }
+  });
+}
+
+// src/collections/config/validate-config.ts
+var RESERVED_SLUGS_SET = new Set(RESERVED_SLUGS);
+var INDEX_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+function extractFieldNames(fields, prefix = "") {
+  const names = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (!field || typeof field !== "object") continue;
+    const f = field;
+    const name = f.name;
+    if (typeof name === "string") {
+      const fullName = prefix ? `${prefix}.${name}` : name;
+      names.add(name);
+      names.add(fullName);
+    }
+    if (Array.isArray(f.fields)) {
+      const nestedPrefix = typeof name === "string" ? prefix ? `${prefix}.${name}` : name : prefix;
+      const nestedNames = extractFieldNames(
+        f.fields,
+        nestedPrefix
+      );
+      nestedNames.forEach((n) => names.add(n));
+    }
+  }
+  return names;
+}
+function validateIndexes(indexes, fields, errors) {
+  if (!indexes) {
+    return;
+  }
+  if (!Array.isArray(indexes)) {
+    errors.push({
+      path: "indexes",
+      message: "Indexes must be an array",
+      code: "INDEX_INVALID_TYPE"
+    });
+    return;
+  }
+  const validFieldNames = extractFieldNames(fields);
+  validFieldNames.add("id");
+  validFieldNames.add("createdAt");
+  validFieldNames.add("updatedAt");
+  indexes.forEach((index, idx) => {
+    const indexPath = `indexes[${idx}]`;
+    if (!index || typeof index !== "object") {
+      errors.push({
+        path: indexPath,
+        message: "Each index must be an object",
+        code: "INDEX_INVALID_TYPE"
+      });
+      return;
+    }
+    const i = index;
+    if (!i.fields) {
+      errors.push({
+        path: `${indexPath}.fields`,
+        message: "Index must specify 'fields' array",
+        code: "INDEX_FIELDS_REQUIRED"
+      });
+      return;
+    }
+    if (!Array.isArray(i.fields)) {
+      errors.push({
+        path: `${indexPath}.fields`,
+        message: "Index 'fields' must be an array",
+        code: "INDEX_FIELDS_REQUIRED"
+      });
+      return;
+    }
+    if (i.fields.length === 0) {
+      errors.push({
+        path: `${indexPath}.fields`,
+        message: "Index must specify at least one field",
+        code: "INDEX_FIELDS_EMPTY"
+      });
+      return;
+    }
+    i.fields.forEach((fieldName, fieldIdx) => {
+      if (typeof fieldName !== "string") {
+        errors.push({
+          path: `${indexPath}.fields[${fieldIdx}]`,
+          message: "Index field must be a string",
+          code: "INDEX_FIELD_UNKNOWN"
+        });
+        return;
+      }
+      if (!validFieldNames.has(fieldName)) {
+        errors.push({
+          path: `${indexPath}.fields[${fieldIdx}]`,
+          message: `Unknown field '${fieldName}' in index. Available fields: ${Array.from(validFieldNames).sort().join(", ")}`,
+          code: "INDEX_FIELD_UNKNOWN"
+        });
+      }
+    });
+    if (i.name !== void 0) {
+      if (typeof i.name !== "string") {
+        errors.push({
+          path: `${indexPath}.name`,
+          message: "Index name must be a string",
+          code: "INDEX_NAME_INVALID"
+        });
+      } else if (!INDEX_NAME_PATTERN.test(i.name)) {
+        errors.push({
+          path: `${indexPath}.name`,
+          message: `Invalid index name '${i.name}'. Must start with a letter and contain only letters, numbers, and underscores`,
+          code: "INDEX_NAME_INVALID"
+        });
+      }
+    }
+    if (i.unique !== void 0 && typeof i.unique !== "boolean") {
+      errors.push({
+        path: `${indexPath}.unique`,
+        message: "Index 'unique' must be a boolean",
+        code: "INDEX_INVALID_TYPE"
+      });
+    }
+  });
+}
+function validateField(field, path, errors, seenNames, allCollectionSlugs) {
+  if (!field || typeof field !== "object") {
+    return;
+  }
+  const f = field;
+  const errsBase = errors;
+  if (!validateFieldTypeShared(f.type, path, errsBase)) {
+    return;
+  }
+  const fieldType = f.type;
+  validateFieldNameShared(
+    f.name,
+    path,
+    errsBase,
+    seenNames,
+    DEFAULT_SQL_KEYWORDS_SET
+  );
+  switch (fieldType) {
+    case "select":
+      validateSelectOptionsShared(f, path, errsBase, "select");
+      break;
+    case "radio":
+      validateSelectOptionsShared(f, path, errsBase, "radio");
+      break;
+    case "relationship":
+      validateRelationshipTargetShared(f, path, errsBase, allCollectionSlugs);
+      break;
+    case "repeater": {
+      const arrayFields = f.fields;
+      if (!arrayFields) {
+        errors.push({
+          path: `${path}.fields`,
+          message: "Array field must have a 'fields' array",
+          code: "ARRAY_FIELDS_REQUIRED"
+        });
+      } else if (Array.isArray(arrayFields)) {
+        validateFieldsArray(
+          arrayFields,
+          `${path}.fields`,
+          errors,
+          allCollectionSlugs
+        );
+      }
+      break;
+    }
+    case "group": {
+      const groupFields = f.fields;
+      if (!groupFields) {
+        errors.push({
+          path: `${path}.fields`,
+          message: "Group field must have a 'fields' array",
+          code: "GROUP_FIELDS_REQUIRED"
+        });
+      } else if (Array.isArray(groupFields)) {
+        validateFieldsArray(
+          groupFields,
+          `${path}.fields`,
+          errors,
+          allCollectionSlugs
+        );
+      }
+      break;
+    }
+    case "component":
+      validateComponentFieldRefShared(f, path, errsBase);
+      break;
+  }
+}
+function validateFieldsArray(fields, basePath, errors, allCollectionSlugs) {
+  const seenNames = /* @__PURE__ */ new Set();
+  fields.forEach((field, index) => {
+    const fieldPath = `${basePath}[${index}]`;
+    validateField(field, fieldPath, errors, seenNames, allCollectionSlugs);
+  });
+}
+function validateFields(fields, errors, allCollectionSlugs) {
+  const path = "fields";
+  if (!fields) {
+    errors.push({
+      path,
+      message: "Collection fields are required",
+      code: "FIELDS_REQUIRED"
+    });
+    return;
+  }
+  if (!Array.isArray(fields)) {
+    errors.push({
+      path,
+      message: "Collection fields must be an array",
+      code: "FIELDS_INVALID_TYPE"
+    });
+    return;
+  }
+  if (fields.length === 0) {
+    errors.push({
+      path,
+      message: "Collection must have at least one field",
+      code: "FIELDS_EMPTY"
+    });
+    return;
+  }
+  validateFieldsArray(fields, path, errors, allCollectionSlugs);
+}
+function validateAccess(access, errors) {
+  if (!access) {
+    return;
+  }
+  if (typeof access !== "object" || Array.isArray(access)) {
+    errors.push({
+      path: "access",
+      message: "Access control must be an object",
+      code: "ACCESS_INVALID_TYPE"
+    });
+    return;
+  }
+  const accessObj = access;
+  const validAccessKeys = ["create", "read", "update", "delete"];
+  for (const key of validAccessKeys) {
+    const fn = accessObj[key];
+    if (fn !== void 0 && typeof fn !== "function") {
+      errors.push({
+        path: `access.${key}`,
+        message: `Access control '${key}' must be a function`,
+        code: "ACCESS_FUNCTION_INVALID"
+      });
+    }
+  }
+}
+function validateCollectionConfig(config, allCollectionSlugs) {
+  const errors = [];
+  const errsBase = errors;
+  validateSlugShared(config.slug, errsBase, {
+    entityLabel: "Collection",
+    reservedSlugsSet: RESERVED_SLUGS_SET,
+    sqlKeywordsSet: DEFAULT_SQL_KEYWORDS_SET
+  });
+  validateFields(config.fields, errors, allCollectionSlugs);
+  validateIndexes(config.indexes, config.fields, errors);
+  validateAccess(config.access, errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertValidCollectionConfig(config, allCollectionSlugs) {
+  const result = validateCollectionConfig(config, allCollectionSlugs);
+  if (!result.valid) {
+    const errorMessages = result.errors.map((err) => `  - [${err.code}] ${err.path}: ${err.message}`).join("\n");
+    throw new Error(
+      `Invalid collection config for '${config.slug || "unknown"}':
+${errorMessages}`
+    );
+  }
+}
+
+// src/components/config/validate-component.ts
+var MAX_COMPONENT_NESTING_DEPTH = 3;
+var RESERVED_COMPONENT_SLUGS = [
+  ...RESERVED_SLUGS,
+  // API namespace for Components
+  "components",
+  "component"
+];
+var RESERVED_COMPONENT_SLUGS_SET = new Set(
+  RESERVED_COMPONENT_SLUGS
+);
+function validateField2(field, path, errors, seenNames) {
+  if (!field || typeof field !== "object") {
+    return;
+  }
+  const f = field;
+  const errsBase = errors;
+  if (!validateFieldTypeShared(f.type, path, errsBase)) {
+    return;
+  }
+  const fieldType = f.type;
+  validateFieldNameShared(
+    f.name,
+    path,
+    errsBase,
+    seenNames,
+    DEFAULT_SQL_KEYWORDS_SET
+  );
+  switch (fieldType) {
+    case "select":
+      validateSelectOptionsShared(f, path, errsBase, "select");
+      break;
+    case "radio":
+      validateSelectOptionsShared(f, path, errsBase, "radio");
+      break;
+    case "relationship":
+      validateRelationshipTargetShared(f, path, errsBase);
+      break;
+    case "repeater": {
+      const arrayFields = f.fields;
+      if (!arrayFields) {
+        errors.push({
+          path: `${path}.fields`,
+          message: "Array field must have a 'fields' array",
+          code: "ARRAY_FIELDS_REQUIRED"
+        });
+      } else if (Array.isArray(arrayFields)) {
+        validateFieldsArray2(arrayFields, `${path}.fields`, errors);
+      }
+      break;
+    }
+    case "group": {
+      const groupFields = f.fields;
+      if (!groupFields) {
+        errors.push({
+          path: `${path}.fields`,
+          message: "Group field must have a 'fields' array",
+          code: "GROUP_FIELDS_REQUIRED"
+        });
+      } else if (Array.isArray(groupFields)) {
+        validateFieldsArray2(groupFields, `${path}.fields`, errors);
+      }
+      break;
+    }
+    case "component":
+      validateComponentFieldRefShared(f, path, errsBase);
+      break;
+  }
+}
+function validateFieldsArray2(fields, basePath, errors) {
+  const seenNames = /* @__PURE__ */ new Set();
+  fields.forEach((field, index) => {
+    const fieldPath = `${basePath}[${index}]`;
+    validateField2(field, fieldPath, errors, seenNames);
+  });
+}
+function validateFields2(fields, errors) {
+  const path = "fields";
+  if (!fields) {
+    errors.push({
+      path,
+      message: "Component fields are required",
+      code: "FIELDS_REQUIRED"
+    });
+    return;
+  }
+  if (!Array.isArray(fields)) {
+    errors.push({
+      path,
+      message: "Component fields must be an array",
+      code: "FIELDS_INVALID_TYPE"
+    });
+    return;
+  }
+  validateFieldsArray2(fields, path, errors);
+}
+function validateComponentConfig(config) {
+  const errors = [];
+  const errsBase = errors;
+  validateSlugShared(config.slug, errsBase, {
+    entityLabel: "Component",
+    reservedSlugsSet: RESERVED_COMPONENT_SLUGS_SET,
+    sqlKeywordsSet: DEFAULT_SQL_KEYWORDS_SET
+  });
+  validateFields2(config.fields, errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertValidComponentConfig(config) {
+  const result = validateComponentConfig(config);
+  if (!result.valid) {
+    const errorMessages = result.errors.map((err) => `  - [${err.code}] ${err.path}: ${err.message}`).join("\n");
+    throw new Error(
+      `Invalid Component config for '${config.slug || "unknown"}':
+${errorMessages}`
+    );
+  }
+}
+
+export {
+  RESERVED_SLUGS,
+  SQL_RESERVED_KEYWORDS,
+  DEFAULT_SQL_KEYWORDS_SET,
+  validateSlugShared,
+  validateFieldNameShared,
+  validateFieldTypeShared,
+  validateSelectOptionsShared,
+  validateRelationshipTargetShared,
+  validateComponentFieldRefShared,
+  validateCollectionConfig,
+  assertValidCollectionConfig,
+  MAX_COMPONENT_NESTING_DEPTH,
+  RESERVED_COMPONENT_SLUGS,
+  validateComponentConfig,
+  assertValidComponentConfig
+};