nextly 0.0.1 → 0.0.2-alpha.1

package/dist/chunk-GDBJ5JCU.mjs

@@ -0,0 +1,488 @@
+import {
+  MAX_COMPONENT_NESTING_DEPTH,
+  SQL_RESERVED_KEYWORDS
+} from "./chunk-FQULBZ53.mjs";
+
+// src/shared/types/config.ts
+var DEFAULT_AUTH_CONFIG = {
+  revealRegistrationConflict: false
+};
+var DEFAULT_TYPESCRIPT_CONFIG = {
+  outputFile: "./src/types/generated/payload-types.ts",
+  declare: true
+};
+var DEFAULT_DB_CONFIG = {
+  schemasDir: "./src/db/schemas/collections",
+  migrationsDir: "./src/db/migrations"
+};
+var DEFAULT_RATE_LIMIT_CONFIG = {
+  readLimit: 100,
+  writeLimit: 30,
+  windowMs: 6e4
+};
+var DEFAULT_API_KEYS_CONFIG = {
+  requestsPerHour: 1e3,
+  windowMs: 36e5
+};
+function sanitizeConfig(config) {
+  if (config.apiKeys?.rateLimit?.requestsPerHour !== void 0) {
+    if (!Number.isInteger(config.apiKeys.rateLimit.requestsPerHour) || config.apiKeys.rateLimit.requestsPerHour <= 0) {
+      throw new Error(
+        `apiKeys.rateLimit.requestsPerHour must be a positive integer (got ${config.apiKeys.rateLimit.requestsPerHour})`
+      );
+    }
+  }
+  if (config.apiKeys?.rateLimit?.windowMs !== void 0) {
+    if (typeof config.apiKeys.rateLimit.windowMs !== "number" || config.apiKeys.rateLimit.windowMs <= 0) {
+      throw new Error(
+        `apiKeys.rateLimit.windowMs must be a positive number (got ${config.apiKeys.rateLimit.windowMs})`
+      );
+    }
+  }
+  let rateLimit;
+  if (config.rateLimit?.enabled !== false) {
+    rateLimit = {
+      enabled: true,
+      readLimit: config.rateLimit?.readLimit ?? DEFAULT_RATE_LIMIT_CONFIG.readLimit,
+      writeLimit: config.rateLimit?.writeLimit ?? DEFAULT_RATE_LIMIT_CONFIG.writeLimit,
+      windowMs: config.rateLimit?.windowMs ?? DEFAULT_RATE_LIMIT_CONFIG.windowMs,
+      store: config.rateLimit?.store,
+      keyGenerator: config.rateLimit?.keyGenerator,
+      skip: config.rateLimit?.skip,
+      collections: config.rateLimit?.collections
+    };
+  }
+  const apiKeys = config.apiKeys ? {
+    rateLimit: {
+      requestsPerHour: config.apiKeys.rateLimit?.requestsPerHour ?? DEFAULT_API_KEYS_CONFIG.requestsPerHour,
+      windowMs: config.apiKeys.rateLimit?.windowMs ?? DEFAULT_API_KEYS_CONFIG.windowMs
+    }
+  } : void 0;
+  return {
+    collections: config.collections ?? [],
+    singles: config.singles ?? [],
+    components: config.components ?? [],
+    users: config.users,
+    email: config.email,
+    typescript: {
+      outputFile: config.typescript?.outputFile ?? DEFAULT_TYPESCRIPT_CONFIG.outputFile,
+      declare: config.typescript?.declare ?? DEFAULT_TYPESCRIPT_CONFIG.declare
+    },
+    db: {
+      schemasDir: config.db?.schemasDir ?? DEFAULT_DB_CONFIG.schemasDir,
+      migrationsDir: config.db?.migrationsDir ?? DEFAULT_DB_CONFIG.migrationsDir
+    },
+    rateLimit,
+    apiKeys,
+    // PR 5 (unified-error-system): always present after sanitization so
+    // downstream code can read `config.auth.revealRegistrationConflict`
+    // without nil checks. Defaults to silent-success per spec §13.2.
+    auth: {
+      revealRegistrationConflict: config.auth?.revealRegistrationConflict ?? DEFAULT_AUTH_CONFIG.revealRegistrationConflict
+    },
+    storage: config.storage ?? [],
+    plugins: config.plugins ?? [],
+    security: config.security,
+    admin: config.admin
+  };
+}
+
+// src/users/config/validate-user-config.ts
+var RESERVED_USER_FIELD_NAMES = [
+  "id",
+  "name",
+  "email",
+  "emailVerified",
+  "passwordHash",
+  "passwordUpdatedAt",
+  "image",
+  "isActive",
+  "createdAt",
+  "updatedAt",
+  "roles",
+  "accounts",
+  "password"
+];
+var ALLOWED_USER_FIELD_TYPES = [
+  "text",
+  "textarea",
+  "number",
+  "email",
+  "select",
+  "radio",
+  "checkbox",
+  "date"
+];
+var RESERVED_NAMES_SET = new Set(
+  RESERVED_USER_FIELD_NAMES.map((n) => n.toLowerCase())
+);
+var ALLOWED_TYPES_SET = new Set(ALLOWED_USER_FIELD_TYPES);
+var SQL_KEYWORDS_SET = new Set(SQL_RESERVED_KEYWORDS);
+var FIELD_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+function isSQLKeyword(name) {
+  return SQL_KEYWORDS_SET.has(name.toLowerCase());
+}
+function isReservedUserFieldName(name) {
+  return RESERVED_NAMES_SET.has(name.toLowerCase());
+}
+function validateUserFieldName(name, path, errors, seenNames) {
+  if (!name) {
+    errors.push({
+      path: `${path}.name`,
+      message: "Field name is required",
+      code: "USER_FIELD_NAME_REQUIRED"
+    });
+    return;
+  }
+  if (typeof name !== "string") {
+    errors.push({
+      path: `${path}.name`,
+      message: "Field name must be a string",
+      code: "USER_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: "USER_FIELD_NAME_INVALID_FORMAT"
+    });
+  }
+  if (isReservedUserFieldName(name)) {
+    errors.push({
+      path: `${path}.name`,
+      message: `Field name '${name}' conflicts with a built-in user field. Reserved names: ${RESERVED_USER_FIELD_NAMES.join(", ")}`,
+      code: "USER_FIELD_NAME_RESERVED"
+    });
+  }
+  if (isSQLKeyword(name)) {
+    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: "USER_FIELD_NAME_SQL_KEYWORD"
+    });
+  }
+  const nameLower = name.toLowerCase();
+  if (seenNames.has(nameLower)) {
+    errors.push({
+      path: `${path}.name`,
+      message: `Duplicate field name '${name}'`,
+      code: "USER_FIELD_NAME_DUPLICATE"
+    });
+  } else {
+    seenNames.add(nameLower);
+  }
+}
+function validateUserFieldType(field, path, errors) {
+  const fieldType = field.type;
+  if (!fieldType) {
+    errors.push({
+      path: `${path}.type`,
+      message: "Field type is required",
+      code: "USER_FIELD_TYPE_REQUIRED"
+    });
+    return;
+  }
+  if (typeof fieldType !== "string" || !ALLOWED_TYPES_SET.has(fieldType)) {
+    errors.push({
+      path: `${path}.type`,
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      message: `User custom fields do not support type '${String(fieldType)}'. Allowed types: ${ALLOWED_USER_FIELD_TYPES.join(", ")}`,
+      code: "USER_FIELD_TYPE_NOT_ALLOWED"
+    });
+  }
+}
+function validateUserSelectOptions(field, path, errors, fieldType) {
+  const options = field.options;
+  if (!options) {
+    errors.push({
+      path: `${path}.options`,
+      message: `${fieldType} field must have an 'options' array`,
+      code: fieldType === "select" ? "USER_SELECT_OPTIONS_REQUIRED" : "USER_RADIO_OPTIONS_REQUIRED"
+    });
+    return;
+  }
+  if (!Array.isArray(options)) {
+    errors.push({
+      path: `${path}.options`,
+      message: `${fieldType} field 'options' must be an array`,
+      code: fieldType === "select" ? "USER_SELECT_OPTIONS_REQUIRED" : "USER_RADIO_OPTIONS_REQUIRED"
+    });
+    return;
+  }
+  if (options.length === 0) {
+    errors.push({
+      path: `${path}.options`,
+      message: `${fieldType} field must have at least one option`,
+      code: fieldType === "select" ? "USER_SELECT_OPTIONS_EMPTY" : "USER_RADIO_OPTIONS_EMPTY"
+    });
+  }
+}
+function validateUserFields(fields, errors) {
+  const fieldNames = /* @__PURE__ */ new Set();
+  if (fields === void 0 || fields === null) {
+    return fieldNames;
+  }
+  if (!Array.isArray(fields)) {
+    errors.push({
+      path: "fields",
+      message: "User fields must be an array",
+      code: "USER_FIELDS_INVALID_TYPE"
+    });
+    return fieldNames;
+  }
+  const seenNames = /* @__PURE__ */ new Set();
+  fields.forEach((field, index) => {
+    const fieldPath = `fields[${index}]`;
+    if (!field || typeof field !== "object") {
+      return;
+    }
+    const f = field;
+    validateUserFieldType(f, fieldPath, errors);
+    validateUserFieldName(f.name, fieldPath, errors, seenNames);
+    const fieldType = f.type;
+    if (fieldType === "select") {
+      validateUserSelectOptions(f, fieldPath, errors, "select");
+    } else if (fieldType === "radio") {
+      validateUserSelectOptions(f, fieldPath, errors, "radio");
+    }
+    if (typeof f.name === "string" && FIELD_NAME_PATTERN.test(f.name)) {
+      fieldNames.add(f.name);
+    }
+  });
+  return fieldNames;
+}
+function validateAdminOptions(admin, fieldNames, errors) {
+  if (admin === void 0 || admin === null) {
+    return;
+  }
+  if (typeof admin !== "object" || Array.isArray(admin)) {
+    errors.push({
+      path: "admin",
+      message: "Admin options must be an object",
+      code: "USER_ADMIN_INVALID_TYPE"
+    });
+    return;
+  }
+  const adminObj = admin;
+  if (adminObj.listFields !== void 0) {
+    if (!Array.isArray(adminObj.listFields)) {
+      errors.push({
+        path: "admin.listFields",
+        message: "admin.listFields must be an array of field names",
+        code: "USER_ADMIN_INVALID_TYPE"
+      });
+    } else {
+      adminObj.listFields.forEach((ref, index) => {
+        if (typeof ref !== "string") {
+          errors.push({
+            path: `admin.listFields[${index}]`,
+            message: "Each listFields entry must be a string",
+            code: "USER_ADMIN_LIST_FIELD_UNKNOWN"
+          });
+        } else if (!fieldNames.has(ref)) {
+          const available = fieldNames.size > 0 ? `Available fields: ${Array.from(fieldNames).sort().join(", ")}` : "No custom fields defined";
+          errors.push({
+            path: `admin.listFields[${index}]`,
+            message: `Unknown field '${ref}' in admin.listFields. ${available}`,
+            code: "USER_ADMIN_LIST_FIELD_UNKNOWN"
+          });
+        }
+      });
+    }
+  }
+  if (adminObj.group !== void 0 && typeof adminObj.group !== "string") {
+    errors.push({
+      path: "admin.group",
+      message: "admin.group must be a string",
+      code: "USER_ADMIN_GROUP_INVALID_TYPE"
+    });
+  }
+}
+function validateUserConfig(config) {
+  const errors = [];
+  const fieldNames = validateUserFields(config.fields, errors);
+  validateAdminOptions(config.admin, fieldNames, errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertValidUserConfig(config) {
+  const result = validateUserConfig(config);
+  if (!result.valid) {
+    const errorMessages = result.errors.map((err) => `  - [${err.code}] ${err.path}: ${err.message}`).join("\n");
+    throw new Error(`Invalid user config:
+${errorMessages}`);
+  }
+}
+
+// src/collections/config/define-config.ts
+function collectComponentRefs(fields, refs) {
+  for (const field of fields) {
+    if (field.type === "component") {
+      if (typeof field.component === "string") {
+        refs.push(field.component);
+      }
+      if (Array.isArray(field.components)) {
+        for (const slug of field.components) {
+          if (typeof slug === "string") {
+            refs.push(slug);
+          }
+        }
+      }
+    }
+    if (Array.isArray(field.fields)) {
+      collectComponentRefs(
+        field.fields,
+        refs
+      );
+    }
+  }
+}
+function validateComponentNesting(components) {
+  const graph = /* @__PURE__ */ new Map();
+  const slugSet = /* @__PURE__ */ new Set();
+  for (const comp of components) {
+    const slug = comp.slug.toLowerCase();
+    slugSet.add(slug);
+    const refs = [];
+    collectComponentRefs(
+      comp.fields,
+      refs
+    );
+    graph.set(
+      slug,
+      refs.filter((r) => slugSet.has(r.toLowerCase())).map((r) => r.toLowerCase())
+    );
+  }
+  for (const [slug, refs] of graph) {
+    graph.set(
+      slug,
+      refs.filter((r) => slugSet.has(r))
+    );
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  function detectCycle(slug, path) {
+    if (inStack.has(slug)) {
+      return [...path, slug];
+    }
+    if (visited.has(slug)) return null;
+    visited.add(slug);
+    inStack.add(slug);
+    for (const ref of graph.get(slug) ?? []) {
+      const cycle = detectCycle(ref, [...path, slug]);
+      if (cycle) return cycle;
+    }
+    inStack.delete(slug);
+    return null;
+  }
+  for (const slug of graph.keys()) {
+    if (!visited.has(slug)) {
+      const cycle = detectCycle(slug, []);
+      if (cycle) {
+        const cycleStr = cycle.join(" \u2192 ");
+        throw new Error(
+          `Circular component reference detected: ${cycleStr}. Components cannot reference each other in a cycle.`
+        );
+      }
+    }
+  }
+  const depthCache = /* @__PURE__ */ new Map();
+  function getMaxDepth(slug) {
+    if (depthCache.has(slug)) return depthCache.get(slug);
+    const refs = graph.get(slug) ?? [];
+    let maxChildDepth = 0;
+    for (const ref of refs) {
+      maxChildDepth = Math.max(maxChildDepth, getMaxDepth(ref));
+    }
+    const depth = 1 + maxChildDepth;
+    depthCache.set(slug, depth);
+    return depth;
+  }
+  for (const slug of graph.keys()) {
+    const depth = getMaxDepth(slug);
+    if (depth > MAX_COMPONENT_NESTING_DEPTH) {
+      throw new Error(
+        `Component nesting depth exceeds maximum of ${MAX_COMPONENT_NESTING_DEPTH} levels (component '${slug}' has a nesting chain ${depth} levels deep). Simplify the component structure to reduce nesting.`
+      );
+    }
+  }
+}
+function validateNextlyConfig(config) {
+  const collections = config.collections ?? [];
+  const slugs = /* @__PURE__ */ new Set();
+  for (const collection of collections) {
+    const slug = collection.slug.toLowerCase();
+    if (slugs.has(slug)) {
+      throw new Error(
+        `Duplicate collection slug: '${collection.slug}'. Each collection must have a unique slug.`
+      );
+    }
+    slugs.add(slug);
+  }
+  const singles = config.singles ?? [];
+  for (const single of singles) {
+    const slug = single.slug.toLowerCase();
+    if (slugs.has(slug)) {
+      const isCollectionConflict = collections.some(
+        (c) => c.slug.toLowerCase() === slug
+      );
+      if (isCollectionConflict) {
+        throw new Error(
+          `Single slug '${single.slug}' conflicts with a Collection slug. Singles and Collections must have unique slugs.`
+        );
+      } else {
+        throw new Error(
+          `Duplicate Single slug: '${single.slug}'. Each Single must have a unique slug.`
+        );
+      }
+    }
+    slugs.add(slug);
+  }
+  const components = config.components ?? [];
+  for (const comp of components) {
+    const slug = comp.slug.toLowerCase();
+    if (slugs.has(slug)) {
+      const isCollectionConflict = collections.some(
+        (c) => c.slug.toLowerCase() === slug
+      );
+      const isSingleConflict = singles.some((s) => s.slug.toLowerCase() === slug);
+      if (isCollectionConflict) {
+        throw new Error(
+          `Component slug '${comp.slug}' conflicts with a Collection slug. Components, Collections, and Singles must have unique slugs.`
+        );
+      } else if (isSingleConflict) {
+        throw new Error(
+          `Component slug '${comp.slug}' conflicts with a Single slug. Components, Collections, and Singles must have unique slugs.`
+        );
+      } else {
+        throw new Error(
+          `Duplicate Component slug: '${comp.slug}'. Each Component must have a unique slug.`
+        );
+      }
+    }
+    slugs.add(slug);
+  }
+  if (components.length > 0) {
+    validateComponentNesting(components);
+  }
+  if (config.users) {
+    assertValidUserConfig(config.users);
+  }
+}
+function defineConfig(config) {
+  validateNextlyConfig(config);
+  return sanitizeConfig(config);
+}
+
+export {
+  sanitizeConfig,
+  RESERVED_USER_FIELD_NAMES,
+  ALLOWED_USER_FIELD_TYPES,
+  validateUserConfig,
+  assertValidUserConfig,
+  defineConfig
+};

package/dist/chunk-GJNSJU4S.mjs

@@ -0,0 +1,19 @@
+import {
+  NextlyError
+} from "./chunk-NRUWQ5Z7.mjs";
+
+// src/api/zod-to-nextly-error.ts
+function nextlyValidationFromZod(err) {
+  return NextlyError.validation({
+    errors: err.issues.map((issue) => ({
+      path: issue.path.join("."),
+      code: issue.code,
+      message: issue.message
+    })),
+    logContext: { zodIssues: err.issues }
+  });
+}
+
+export {
+  nextlyValidationFromZod
+};

package/dist/chunk-GZ6DCQKC.mjs

@@ -0,0 +1,69 @@
+import {
+  RealClassifier,
+  RegexRenameDetector,
+  buildDesiredTableFromComponentFields,
+  buildDesiredTableFromFields,
+  countNulls,
+  countRows,
+  diffSnapshots,
+  introspectLiveSnapshot
+} from "./chunk-SBACDPNX.mjs";
+
+// src/domains/schema/pipeline/preview.ts
+async function previewDesiredSchema(args, deps = {}) {
+  const { desired, db, dialect } = args;
+  const renameDetector = deps.renameDetector ?? new RegexRenameDetector();
+  const classifier = deps.classifier ?? new RealClassifier();
+  const introspect = deps.introspect ?? introspectLiveSnapshot;
+  const managedTableNames = [
+    ...Object.values(desired.collections).map((c) => c.tableName),
+    ...Object.values(desired.singles).map((s) => s.tableName),
+    ...Object.values(desired.components).map((c) => c.tableName)
+  ];
+  const liveSnapshot = await introspect(db, dialect, managedTableNames);
+  const collectionTables = Object.values(desired.collections).map(
+    (c) => buildDesiredTableFromFields(
+      c.tableName,
+      c.fields,
+      dialect
+    )
+  );
+  const singleTables = Object.values(desired.singles).map(
+    (s) => buildDesiredTableFromFields(
+      s.tableName,
+      s.fields,
+      dialect
+    )
+  );
+  const componentTables = Object.values(desired.components).map(
+    (c) => buildDesiredTableFromComponentFields(
+      c.tableName,
+      c.fields,
+      dialect
+    )
+  );
+  const desiredSnapshot = {
+    tables: [...collectionTables, ...singleTables, ...componentTables]
+  };
+  const operations = diffSnapshots(liveSnapshot, desiredSnapshot);
+  const candidates = renameDetector.detect(operations, dialect);
+  const classificationResult = await classifier.classify({
+    operations,
+    drizzleWarnings: [],
+    hasDataLoss: false,
+    countNulls: (table, column) => countNulls(db, dialect, table, column),
+    countRows: (table) => countRows(db, dialect, table),
+    dialect
+  });
+  return {
+    operations,
+    events: classificationResult.events,
+    candidates,
+    classification: classificationResult.level,
+    liveSnapshot
+  };
+}
+
+export {
+  previewDesiredSchema
+};