nextly 0.0.1 → 0.0.2-alpha.1

package/dist/chunk-XZKLBMN6.mjs

@@ -0,0 +1,1153 @@
+import {
+  env
+} from "./chunk-UJ2IMJ4W.mjs";
+
+// src/domains/dynamic-collections/services/dynamic-collection-validation-service.ts
+import safeRegex from "safe-regex2";
+import { z } from "zod";
+var MAX_REGEX_PATTERN_LENGTH = 200;
+var REGEX_DDL_FORBIDDEN_CHARS = /[;\\\n\r\0]/;
+var SQL_KEYWORDS = [
+  "select",
+  "insert",
+  "update",
+  "delete",
+  "drop",
+  "create",
+  "alter",
+  "table",
+  "from",
+  "where",
+  "join",
+  "union",
+  "order",
+  "group",
+  "having",
+  "limit",
+  "offset",
+  "index",
+  "constraint",
+  "primary",
+  "foreign",
+  "key",
+  "references",
+  "on",
+  "null",
+  "not",
+  "and",
+  "or",
+  "in",
+  "like",
+  "between",
+  "exists",
+  "case",
+  "when",
+  "then",
+  "else",
+  "end",
+  "as",
+  "distinct",
+  "all",
+  "any",
+  "some",
+  "into",
+  "values",
+  "set",
+  "cascade"
+];
+var RESERVED_COLLECTION_NAMES = [
+  "users",
+  "roles",
+  "permissions",
+  "sessions",
+  "accounts",
+  "dynamic_collections"
+];
+var RESERVED_FIELD_NAMES = [
+  "id",
+  "title",
+  "slug",
+  "created_at",
+  "updated_at"
+];
+var collectionNameSchema = z.string().min(1, "Collection name cannot be empty").max(50, "Collection name must be 50 characters or less").regex(
+  /^[a-z][a-z0-9_]*$/,
+  "Collection name must start with lowercase letter and contain only lowercase letters, numbers, and underscores"
+).refine(
+  (name) => !RESERVED_COLLECTION_NAMES.includes(name),
+  {
+    message: "Collection name is reserved"
+  }
+).refine(
+  (name) => !SQL_KEYWORDS.includes(name.toLowerCase()),
+  {
+    message: "Collection name is a reserved SQL keyword"
+  }
+);
+var fieldNameSchema = z.string().min(1, "Field name cannot be empty").max(50, "Field name must be 50 characters or less").regex(
+  /^[a-z][a-z0-9_]*$/,
+  "Field name must start with lowercase letter and contain only lowercase letters, numbers, and underscores"
+).refine((name) => !RESERVED_FIELD_NAMES.includes(name), {
+  message: "Field name is reserved"
+}).refine(
+  (name) => !SQL_KEYWORDS.includes(name.toLowerCase()),
+  {
+    message: "Field name is a reserved SQL keyword"
+  }
+);
+var fieldsArraySchema = z.array(z.any()).min(0).max(100, "Collection cannot have more than 100 fields");
+var DynamicCollectionValidationService = class {
+  /**
+   * @throws Error if the name is invalid
+   */
+  validateCollectionName(name) {
+    const result = collectionNameSchema.safeParse(name);
+    if (!result.success) {
+      const errorMessage = result.error.issues[0]?.message || "Invalid collection name";
+      throw new Error(errorMessage);
+    }
+  }
+  /**
+   * @throws Error if any field name is invalid or duplicated
+   */
+  validateFieldNames(fields) {
+    const countResult = fieldsArraySchema.safeParse(fields);
+    if (!countResult.success) {
+      const errorMessage = countResult.error.issues[0]?.message || "Invalid fields array";
+      throw new Error(errorMessage);
+    }
+    const fieldNames = /* @__PURE__ */ new Set();
+    const duplicates = [];
+    for (const field of fields) {
+      if (fieldNames.has(field.name)) {
+        duplicates.push(field.name);
+      }
+      fieldNames.add(field.name);
+    }
+    if (duplicates.length > 0) {
+      throw new Error(
+        `Duplicate field names found: ${duplicates.join(", ")}. Each field must have a unique name.`
+      );
+    }
+    for (const field of fields) {
+      const result = fieldNameSchema.safeParse(field.name);
+      if (!result.success) {
+        const errorMessage = result.error.issues[0]?.message || `Invalid field name "${field.name}"`;
+        throw new Error(errorMessage);
+      }
+      if (field.type === "relationship") {
+        this.validateRelationshipField(field);
+      }
+    }
+  }
+  /**
+   * @throws Error if the relationship configuration is invalid
+   */
+  validateRelationshipField(field) {
+    if (!field.options?.target) {
+      throw new Error(
+        `Relationship field "${field.name}" must specify a target collection`
+      );
+    }
+    if (!field.options?.relationType) {
+      throw new Error(
+        `Relationship field "${field.name}" must specify a relationType (oneToOne, oneToMany, manyToOne, or manyToMany)`
+      );
+    }
+    const validTypes = ["oneToOne", "oneToMany", "manyToOne", "manyToMany"];
+    if (!validTypes.includes(field.options.relationType)) {
+      throw new Error(
+        `Invalid relationType "${field.options.relationType}" for field "${field.name}". Must be one of: ${validTypes.join(", ")}`
+      );
+    }
+    if (field.options.onDelete) {
+      const validActions = ["cascade", "set null", "restrict", "no action"];
+      if (!validActions.includes(field.options.onDelete.toLowerCase())) {
+        throw new Error(
+          `Invalid onDelete action "${field.options.onDelete}" for field "${field.name}". Must be one of: ${validActions.join(", ")}`
+        );
+      }
+    }
+    if (field.options.onUpdate) {
+      const validActions = ["cascade", "set null", "restrict", "no action"];
+      if (!validActions.includes(field.options.onUpdate.toLowerCase())) {
+        throw new Error(
+          `Invalid onUpdate action "${field.options.onUpdate}" for field "${field.name}". Must be one of: ${validActions.join(", ")}`
+        );
+      }
+    }
+    if (field.options.relationType === "oneToOne" && !field.unique && !field.required) {
+      console.warn(
+        `One-to-one relationship "${field.name}" should typically be unique. Consider setting unique: true.`
+      );
+    }
+    if (field.options.relationType === "manyToMany" && field.required) {
+      throw new Error(
+        `Many-to-many relationship "${field.name}" cannot be marked as required. Use validation in your application logic instead.`
+      );
+    }
+  }
+  /**
+   * The previous check only blocked `(?{` and `(?>` —
+   * neither of which is even valid JS regex syntax, so the function
+   * accepted catastrophic patterns like `(a+)+b` that DoS the database
+   * regex engine on subsequent writes.
+   *
+   * The new gate has three layers:
+   *
+   *   1. **Length cap** (≤200 chars). Real validation patterns are
+   *      short; long patterns are usually obfuscated.
+   *   2. **JS parse**. If `new RegExp(pattern)` throws, it's malformed
+   *      regardless of the runtime that will execute it.
+   *   3. **`safe-regex2`** static analysis. Detects nested-quantifier
+   *      and alternation explosion patterns (the standard ReDoS shapes).
+   *
+   * In this codebase the runtime engine is the database (Postgres `~`
+   * or MySQL `REGEXP`), not Node — JS-side runtime matching of admin-
+   * supplied patterns does not exist here. So we don't pull in the
+   * native re2 binding; the static `safe-regex2` check + length cap is
+   * the load-bearing defense for what actually ships to the DB.
+   *
+   * @throws Error if the regex is invalid, too long, or unsafe
+   */
+  validateRegexPattern(fieldName, pattern) {
+    if (pattern.length > MAX_REGEX_PATTERN_LENGTH) {
+      throw new Error(
+        `Regex pattern for field "${fieldName}" exceeds the ${MAX_REGEX_PATTERN_LENGTH}-character cap (got ${pattern.length}).`
+      );
+    }
+    try {
+      new RegExp(pattern);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      throw new Error(
+        `Invalid regex pattern for field "${fieldName}": ${message}`
+      );
+    }
+    if (!safeRegex(pattern)) {
+      throw new Error(
+        `Regex pattern for field "${fieldName}" is unsafe (catastrophic backtracking detected).`
+      );
+    }
+    if (REGEX_DDL_FORBIDDEN_CHARS.test(pattern)) {
+      throw new Error(
+        `Regex pattern for field "${fieldName}" contains characters that are not allowed in CHECK constraint expressions (no semicolons, backslashes, newlines, or null bytes).`
+      );
+    }
+  }
+};
+
+// src/domains/dynamic-collections/services/dynamic-collection-schema-service.ts
+var DynamicCollectionSchemaService = class {
+  validationService;
+  dialect;
+  constructor(validationService, dialect) {
+    this.validationService = validationService || new DynamicCollectionValidationService();
+    this.dialect = dialect || env.DB_DIALECT || "postgresql";
+  }
+  /**
+   * Quote identifier based on dialect
+   */
+  quoteIdentifier(name) {
+    if (this.dialect === "mysql") {
+      return `\`${name}\``;
+    }
+    return `"${name}"`;
+  }
+  /** Convert camelCase to snake_case (e.g., publishedAt → published_at) */
+  toSnakeCase(str) {
+    return str.replace(/([A-Z])/g, "_$1").toLowerCase();
+  }
+  /**
+   * Generate SQL migration for creating a new collection table
+   *
+   * @param tableName - The name of the table to create
+   * @param fields - Field definitions for the table
+   * @param options - Optional configuration (reserved for future use)
+   */
+  generateMigrationSQL(tableName, fields, _options) {
+    const constraints = [];
+    const checks = [];
+    const junctionTables = [];
+    const columns = fields.map((f) => {
+      if (f.type === "relationship" && f.options?.relationType === "manyToMany") {
+        return null;
+      }
+      const type = this.mapFieldTypeToSQL(
+        f.type,
+        f.length,
+        f.options,
+        f.validation
+      );
+      const nullable = f.required ? "NOT NULL" : "";
+      const unique = f.unique || f.type === "relationship" && f.options?.relationType === "oneToOne" ? "UNIQUE" : "";
+      const defaultVal = f.default !== void 0 && f.default !== null ? `DEFAULT ${this.formatDefaultValue(f.default, f.type)}` : "";
+      if (f.validation) {
+        if (f.validation.min !== void 0) {
+          checks.push(
+            `${this.quoteIdentifier(f.name)} >= ${f.validation.min}`
+          );
+        }
+        if (f.validation.max !== void 0) {
+          checks.push(
+            `${this.quoteIdentifier(f.name)} <= ${f.validation.max}`
+          );
+        }
+        if (f.validation.minLength !== void 0 && (f.type === "text" || f.type === "textarea" || f.type === "email" || f.type === "password" || f.type === "code")) {
+          checks.push(
+            `LENGTH(${this.quoteIdentifier(f.name)}) >= ${f.validation.minLength}`
+          );
+        }
+        if (f.validation.regex && this.dialect !== "sqlite") {
+          this.validationService.validateRegexPattern(
+            f.name,
+            f.validation.regex
+          );
+          const escapedRegex = f.validation.regex.replace(/'/g, "''");
+          if (this.dialect === "mysql") {
+            checks.push(
+              `${this.quoteIdentifier(this.toSnakeCase(f.name))} REGEXP '${escapedRegex}'`
+            );
+          } else {
+            checks.push(
+              `${this.quoteIdentifier(this.toSnakeCase(f.name))} ~ '${escapedRegex}'`
+            );
+          }
+        }
+      }
+      if (f.type === "relationship" && f.options?.target) {
+        const relationType = f.options.relationType || "manyToOne";
+        const targetTable = `dc_${f.options.target}`;
+        if (relationType === "oneToOne" || relationType === "manyToOne" || relationType === "oneToMany") {
+          const onDelete = this.mapOnDeleteAction(
+            f.options.onDelete || "set null"
+          );
+          const onUpdate = this.mapOnUpdateAction(
+            f.options.onUpdate || "no action"
+          );
+          const fkColName = this.toSnakeCase(f.name);
+          constraints.push(
+            `  CONSTRAINT ${this.quoteIdentifier(`fk_${tableName}_${fkColName}`)} FOREIGN KEY (${this.quoteIdentifier(fkColName)}) REFERENCES ${this.quoteIdentifier(targetTable)}(${this.quoteIdentifier("id")}) ON DELETE ${onDelete} ON UPDATE ${onUpdate}`
+          );
+        }
+      }
+      const colName = this.toSnakeCase(f.name);
+      return `  ${this.quoteIdentifier(colName)} ${type} ${nullable} ${unique} ${defaultVal}`.trim();
+    }).filter(Boolean).join(",\n");
+    const allColumnDefs = [];
+    if (this.dialect === "mysql") {
+      allColumnDefs.push(`  ${this.quoteIdentifier("id")} varchar(36) PRIMARY KEY NOT NULL`);
+    } else {
+      allColumnDefs.push(`  ${this.quoteIdentifier("id")} text PRIMARY KEY NOT NULL`);
+    }
+    const hasTitleField = fields.some((f) => f.name === "title");
+    if (!hasTitleField) {
+      if (this.dialect === "mysql") {
+        allColumnDefs.push(`  ${this.quoteIdentifier("title")} varchar(255) NOT NULL`);
+      } else {
+        allColumnDefs.push(`  ${this.quoteIdentifier("title")} text NOT NULL`);
+      }
+    }
+    const hasSlugField = fields.some((f) => f.name === "slug");
+    if (!hasSlugField) {
+      if (this.dialect === "mysql") {
+        allColumnDefs.push(`  ${this.quoteIdentifier("slug")} varchar(255) NOT NULL`);
+      } else {
+        allColumnDefs.push(`  ${this.quoteIdentifier("slug")} text NOT NULL`);
+      }
+    }
+    if (columns.length > 0) {
+      allColumnDefs.push(columns);
+    }
+    if (_options?.hasStatus) {
+      if (this.dialect === "sqlite") {
+        allColumnDefs.push(
+          `  ${this.quoteIdentifier("status")} text DEFAULT 'draft' NOT NULL`
+        );
+      } else if (this.dialect === "mysql") {
+        allColumnDefs.push(
+          `  ${this.quoteIdentifier("status")} varchar(20) DEFAULT 'draft' NOT NULL`
+        );
+      } else {
+        allColumnDefs.push(
+          `  ${this.quoteIdentifier("status")} varchar(20) DEFAULT 'draft' NOT NULL`
+        );
+      }
+    }
+    if (checks.length > 0) {
+      allColumnDefs.push(`  CONSTRAINT ${this.quoteIdentifier(`chk_${tableName}_validation`)} CHECK (${checks.join(" AND ")})`);
+    }
+    for (const c of constraints) {
+      allColumnDefs.push(c);
+    }
+    if (this.dialect === "sqlite") {
+      allColumnDefs.push(`  ${this.quoteIdentifier("created_at")} integer DEFAULT (strftime('%s', 'now')) NOT NULL`);
+      allColumnDefs.push(`  ${this.quoteIdentifier("updated_at")} integer DEFAULT (strftime('%s', 'now')) NOT NULL`);
+    } else if (this.dialect === "mysql") {
+      allColumnDefs.push(`  ${this.quoteIdentifier("created_at")} timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL`);
+      allColumnDefs.push(`  ${this.quoteIdentifier("updated_at")} timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL`);
+    } else {
+      allColumnDefs.push(`  ${this.quoteIdentifier("created_at")} timestamp DEFAULT now() NOT NULL`);
+      allColumnDefs.push(`  ${this.quoteIdentifier("updated_at")} timestamp DEFAULT now() NOT NULL`);
+    }
+    let sql = `-- Create dynamic collection: ${tableName}
+CREATE TABLE IF NOT EXISTS ${this.quoteIdentifier(tableName)} (
+${allColumnDefs.join(",\n")}
+);`;
+    fields.forEach((f) => {
+      if (f.type === "relationship" && f.options?.relationType === "manyToMany" && f.options?.target) {
+        const junctionTableSQL = this.generateJunctionTable(tableName, f);
+        junctionTables.push(junctionTableSQL);
+      }
+    });
+    const indexStatements = [];
+    fields.forEach((f) => {
+      if (f.type === "relationship" && f.options?.relationType !== "manyToMany") {
+        const indexName = `idx_${tableName}_${f.name}`;
+        if (this.dialect === "mysql") {
+          indexStatements.push(
+            `CREATE INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier(f.name)});`
+          );
+        } else {
+          indexStatements.push(
+            `CREATE INDEX IF NOT EXISTS ${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier(f.name)});`
+          );
+        }
+      }
+    });
+    fields.forEach((f) => {
+      if (f.index && f.type !== "relationship") {
+        const indexName = `idx_${tableName}_${f.name}`;
+        if (this.dialect === "mysql") {
+          indexStatements.push(
+            `CREATE INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier(f.name)});`
+          );
+        } else {
+          indexStatements.push(
+            `CREATE INDEX IF NOT EXISTS ${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier(f.name)});`
+          );
+        }
+      }
+    });
+    let createdAtIndex = "";
+    if (this.dialect === "sqlite") {
+      createdAtIndex = `CREATE INDEX IF NOT EXISTS ${this.quoteIdentifier(`idx_${tableName}_created_at`)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier("created_at")});`;
+    } else if (this.dialect === "mysql") {
+      createdAtIndex = `CREATE INDEX ${this.quoteIdentifier(`idx_${tableName}_created_at`)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier("created_at")} DESC);`;
+    } else {
+      createdAtIndex = `CREATE INDEX IF NOT EXISTS ${this.quoteIdentifier(`idx_${tableName}_created_at`)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier("created_at")} DESC);`;
+    }
+    indexStatements.push(createdAtIndex);
+    let slugIndex = "";
+    if (this.dialect === "sqlite") {
+      slugIndex = `CREATE UNIQUE INDEX IF NOT EXISTS ${this.quoteIdentifier(`idx_${tableName}_slug`)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier("slug")});`;
+    } else if (this.dialect === "mysql") {
+      slugIndex = `CREATE UNIQUE INDEX ${this.quoteIdentifier(`idx_${tableName}_slug`)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier("slug")});`;
+    } else {
+      slugIndex = `CREATE UNIQUE INDEX IF NOT EXISTS ${this.quoteIdentifier(`idx_${tableName}_slug`)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier("slug")});`;
+    }
+    indexStatements.push(slugIndex);
+    if (indexStatements.length > 0) {
+      sql += "\n--> statement-breakpoint\n";
+      sql += indexStatements.join("\n--> statement-breakpoint\n");
+    }
+    if (junctionTables.length > 0) {
+      sql += "\n--> statement-breakpoint\n";
+      sql += junctionTables.join("\n--> statement-breakpoint\n");
+    }
+    return sql;
+  }
+  /**
+   * Generate ALTER TABLE migration for updating a collection
+   *
+   * Note: SQLite has very limited ALTER TABLE support:
+   * - ADD COLUMN is supported
+   * - DROP COLUMN is supported (SQLite 3.35.0+)
+   * - ALTER COLUMN (change type, nullability) is NOT supported
+   *
+   * For complex schema changes in SQLite, a table rebuild is required,
+   * but for dynamic collections we keep it simple and only support
+   * adding/removing columns.
+   */
+  generateAlterTableMigration(tableName, oldFields, newFields, options) {
+    const statements = [`-- Update dynamic collection: ${tableName}`];
+    const wasStatus = options?.wasStatus === true;
+    const hasStatus = options?.hasStatus === true;
+    if (!wasStatus && hasStatus) {
+      const statusType = this.dialect === "sqlite" ? "text" : "varchar(20)";
+      statements.push(
+        `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD COLUMN ${this.quoteIdentifier("status")} ${statusType} DEFAULT 'draft' NOT NULL;`
+      );
+    } else if (wasStatus && !hasStatus) {
+      statements.push(
+        `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier("status")};`
+      );
+    }
+    const oldFieldMap = new Map(oldFields.map((f) => [f.name, f]));
+    const newFieldMap = new Map(newFields.map((f) => [f.name, f]));
+    const rename = this.detectFieldRename(oldFields, newFields);
+    const renamedFromName = rename?.from.name ?? null;
+    const renamedToName = rename?.to.name ?? null;
+    if (rename) {
+      const fromCol = this.toSnakeCase(rename.from.name);
+      const toCol = this.toSnakeCase(rename.to.name);
+      statements.push(
+        `ALTER TABLE ${this.quoteIdentifier(tableName)} RENAME COLUMN ${this.quoteIdentifier(fromCol)} TO ${this.quoteIdentifier(toCol)};`
+      );
+    }
+    for (const field of newFields) {
+      if (field.name === renamedToName) continue;
+      if (!oldFieldMap.has(field.name)) {
+        if (field.type === "relationship" && field.options?.relationType === "manyToMany") {
+          const junctionSQL = this.generateJunctionTable(tableName, field);
+          statements.push(junctionSQL);
+          continue;
+        }
+        const type = this.mapFieldTypeToSQL(field.type, field.length);
+        const nullable = field.required ? "NOT NULL" : "";
+        let defaultVal = "";
+        if (field.default !== void 0) {
+          defaultVal = `DEFAULT ${this.formatDefaultValue(field.default, field.type)}`;
+        } else if (field.required) {
+          defaultVal = `DEFAULT ${this.getDefaultValueForType(field.type)}`;
+        }
+        const addColName = this.toSnakeCase(field.name);
+        statements.push(
+          `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD COLUMN ${this.quoteIdentifier(addColName)} ${type} ${nullable} ${defaultVal};`.trim()
+        );
+        if (this.dialect !== "sqlite") {
+          if (field.type === "relationship" && field.options?.target) {
+            const targetTable = `dc_${field.options.target}`;
+            const onDelete = field.options.onDelete || "set null";
+            const onUpdate = field.options.onUpdate || "no action";
+            statements.push(
+              `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD CONSTRAINT ${this.quoteIdentifier(`fk_${tableName}_${addColName}`)} FOREIGN KEY (${this.quoteIdentifier(addColName)}) REFERENCES ${this.quoteIdentifier(targetTable)}(${this.quoteIdentifier("id")}) ON DELETE ${this.mapOnDeleteAction(onDelete)} ON UPDATE ${this.mapOnUpdateAction(onUpdate)};`
+            );
+          }
+          if (field.unique) {
+            statements.push(
+              `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD CONSTRAINT ${this.quoteIdentifier(`uq_${tableName}_${addColName}`)} UNIQUE (${this.quoteIdentifier(addColName)});`
+            );
+          }
+        } else {
+          if (field.unique) {
+            statements.push(
+              `CREATE UNIQUE INDEX IF NOT EXISTS ${this.quoteIdentifier(`uq_${tableName}_${addColName}`)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier(addColName)});`
+            );
+          }
+        }
+      }
+    }
+    for (const field of newFields) {
+      const oldField = oldFieldMap.get(field.name);
+      if (oldField && oldField.index !== field.index) {
+        const idxCol = this.toSnakeCase(field.name);
+        const indexName = `idx_${tableName}_${idxCol}`;
+        if (field.index) {
+          if (this.dialect === "mysql") {
+            statements.push(
+              `CREATE INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier(idxCol)});`
+            );
+          } else {
+            statements.push(
+              `CREATE INDEX IF NOT EXISTS ${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)}(${this.quoteIdentifier(idxCol)});`
+            );
+          }
+        } else {
+          if (this.dialect === "mysql") {
+            statements.push(
+              `DROP INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)};`
+            );
+          } else {
+            statements.push(
+              `DROP INDEX IF EXISTS ${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)};`
+            );
+          }
+        }
+      }
+    }
+    for (const field of oldFields) {
+      if (field.name === renamedFromName) continue;
+      if (!newFieldMap.has(field.name)) {
+        const dropCol = this.toSnakeCase(field.name);
+        if (this.dialect === "sqlite") {
+          statements.push(
+            `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(dropCol)};`
+          );
+        } else {
+          statements.push(
+            `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN IF EXISTS ${this.quoteIdentifier(dropCol)};`
+          );
+        }
+      }
+    }
+    if (this.dialect !== "sqlite") {
+      for (const field of newFields) {
+        const oldField = oldFieldMap.get(field.name);
+        if (oldField && this.isFieldModified(oldField, field)) {
+          const alterCol = this.toSnakeCase(field.name);
+          const type = this.mapFieldTypeToSQL(field.type, field.length);
+          statements.push(
+            `ALTER TABLE ${this.quoteIdentifier(tableName)} ALTER COLUMN ${this.quoteIdentifier(alterCol)} TYPE ${type};`
+          );
+          if (field.required !== oldField.required) {
+            if (field.required) {
+              statements.push(
+                `ALTER TABLE ${this.quoteIdentifier(tableName)} ALTER COLUMN ${this.quoteIdentifier(alterCol)} SET NOT NULL;`
+              );
+            } else {
+              statements.push(
+                `ALTER TABLE ${this.quoteIdentifier(tableName)} ALTER COLUMN ${this.quoteIdentifier(alterCol)} DROP NOT NULL;`
+              );
+            }
+          }
+        }
+      }
+    }
+    return statements.join("\n--> statement-breakpoint\n");
+  }
+  /**
+   * Check if a field definition has been modified
+   */
+  isFieldModified(oldField, newField) {
+    return oldField.type !== newField.type || oldField.length !== newField.length || oldField.required !== newField.required || oldField.unique !== newField.unique || oldField.index !== newField.index;
+  }
+  /**
+   * Phase D (Option 2) — structural rename detection.
+   *
+   * Pairs a removed field with an added field if and only if:
+   *   1. There is exactly ONE removed field (in oldFields, not in newFields)
+   *   2. AND exactly ONE added field (in newFields, not in oldFields)
+   *   3. AND their types are compatible (same `type`, and for relations
+   *      same target + relationType)
+   *
+   * This is the SAFE heuristic: zero ambiguity. If the user renames
+   * multiple fields in a single save, the heuristic bails out and the
+   * caller falls back to ADD+DROP. A console.warn surfaces the data-
+   * loss risk so the user knows to rename one field at a time, OR an
+   * admin-UI confirmation prompt can be added later (tracked as a
+   * Phase D follow-up).
+   *
+   * Why not the more aggressive multi-pair scoring described in the
+   * design doc: ambiguous pairings can silently rename to the wrong
+   * column. The cost of that bug exceeds the cost of asking the user
+   * to make smaller saves. We can soften this with an admin-UI
+   * confirmation later if friction is real.
+   */
+  detectFieldRename(oldFields, newFields) {
+    const oldNames = new Set(oldFields.map((f) => f.name));
+    const newNames = new Set(newFields.map((f) => f.name));
+    const oldOnly = oldFields.filter((f) => !newNames.has(f.name));
+    const newOnly = newFields.filter((f) => !oldNames.has(f.name));
+    if (oldOnly.length === 0 || newOnly.length === 0) {
+      return null;
+    }
+    if (oldOnly.length > 1 || newOnly.length > 1) {
+      console.warn(
+        `[Nextly schema] Detected ${oldOnly.length} removed and ${newOnly.length} added field(s) in the same save on this collection. Skipping rename detection (ambiguous) \u2014 emitting DROP/ADD which loses any data in the removed columns. To rename safely, edit and save one field at a time. Removed: [` + oldOnly.map((f) => f.name).join(", ") + `]. Added: [` + newOnly.map((f) => f.name).join(", ") + `].`
+      );
+      return null;
+    }
+    const from = oldOnly[0];
+    const to = newOnly[0];
+    if (!this.areFieldTypesCompatible(from, to)) {
+      console.warn(
+        `[Nextly schema] Field "${from.name}" was removed and "${to.name}" was added in the same save, but their types (${from.type} vs ${to.type}) are not compatible. Treating as DROP "${from.name}" + ADD "${to.name}" \u2014 existing data in "${from.name}" will be lost. If this was intended as a type-changing rename, do it in two steps: first rename without changing type, then change the type.`
+      );
+      return null;
+    }
+    return { from, to };
+  }
+  /**
+   * Are two field definitions compatible enough that renaming one to
+   * the other preserves data semantics?
+   *
+   * Strict by design: same type, and for relations same target +
+   * relationType. Length differences are allowed for text/varchar
+   * since a column rename doesn't touch the size constraint. Required/
+   * unique/index differences are allowed (those are independent
+   * attribute changes the user can adjust on either side of a rename).
+   */
+  areFieldTypesCompatible(a, b) {
+    if (a.type !== b.type) return false;
+    if (a.type === "relationship" && a.options?.relationType === "manyToMany") {
+      return false;
+    }
+    if (a.type === "relationship") {
+      return a.options?.target === b.options?.target && a.options?.relationType === b.options?.relationType;
+    }
+    return true;
+  }
+  /**
+   * Generate TypeScript/Drizzle schema code for a collection
+   */
+  generateSchemaCode(tableName, collectionName, fields) {
+    const dialectConfig = this.getDialectConfig();
+    const jsonbFieldTypes = [
+      "json",
+      "repeater",
+      "group",
+      "blocks",
+      "point",
+      "group",
+      "blocks",
+      "point",
+      "chips"
+    ];
+    const hasJsonField = fields.some((f) => jsonbFieldTypes.includes(f.type));
+    const hasRelation = fields.some((f) => f.type === "relationship");
+    const baseImports = ["text", "index", "uniqueIndex"];
+    if (this.dialect !== "sqlite") {
+      baseImports.push("varchar", "decimal", "boolean", "timestamp", "integer");
+    } else {
+      baseImports.push("integer", "real");
+    }
+    if (hasJsonField) {
+      if (this.dialect === "postgresql") {
+        baseImports.push("jsonb");
+      }
+    }
+    let imports = `import { ${dialectConfig.tableFunction}, ${baseImports.join(", ")} } from '${dialectConfig.importPath}';`;
+    if (hasRelation) {
+      imports += `
+import { relations } from 'drizzle-orm';`;
+    }
+    const columns = fields.filter(
+      (f) => !(f.type === "relationship" && f.options?.relationType === "manyToMany")
+    ).map((f) => {
+      const drizzleType = this.mapFieldTypeToDrizzleDialectAware(f);
+      const modifiers = [];
+      if (f.required) modifiers.push(".notNull()");
+      if (f.unique || f.type === "relationship" && f.options?.relationType === "oneToOne") {
+        modifiers.push(".unique()");
+      }
+      const defaultValue = f.default;
+      if (defaultValue !== void 0 && defaultValue !== null) {
+        if (f.type === "json") {
+          modifiers.push(`.default(${JSON.stringify(defaultValue)})`);
+        } else if (typeof defaultValue === "string") {
+          modifiers.push(`.default('${defaultValue}')`);
+        } else {
+          modifiers.push(`.default(${String(defaultValue)})`);
+        }
+      }
+      if (f.type === "relationship" && f.options?.target && f.options?.relationType !== "manyToMany") {
+        const targetTable = `dc_${f.options.target}`;
+        const onDelete = f.options.onDelete || "set null";
+        const onUpdate = f.options.onUpdate || "no action";
+        modifiers.push(
+          `.references(() => ${targetTable}.id, { onDelete: "${onDelete}", onUpdate: "${onUpdate}" })`
+        );
+      }
+      return `  ${f.name}: ${drizzleType}${modifiers.join("")},`;
+    }).join("\n");
+    const relationDefs = this.generateRelationDefinitions(tableName, fields);
+    const fieldIndexes = fields.filter(
+      (f) => f.index || f.type === "relationship" && f.options?.relationType !== "manyToMany"
+    ).map(
+      (f) => `  ${f.name}Idx: index('idx_${tableName}_${f.name}').on(table.${f.name}),`
+    ).join("\n");
+    const allIndexes = fieldIndexes ? `  createdAtIdx: index('idx_${tableName}_created_at').on(table.createdAt),
+${fieldIndexes}` : `  createdAtIdx: index('idx_${tableName}_created_at').on(table.createdAt),`;
+    const timestampColumns = this.generateTimestampColumnsForDialect();
+    return `${imports}
+
+/**
+ * Dynamic collection: ${collectionName}
+ * Generated by nextly
+ */
+export const ${tableName} = ${dialectConfig.tableFunction}('${tableName}', {
+  id: text('id').primaryKey().notNull(),
+  title: text('title').notNull(),
+  slug: text('slug').notNull(),
+${columns}
+${timestampColumns}
+}, (table) => ({
+  slugIdx: uniqueIndex('idx_${tableName}_slug').on(table.slug),
+${allIndexes}
+}));
+${relationDefs}
+export type ${this.toPascalCase(collectionName)} = typeof ${tableName}.$inferSelect;
+export type New${this.toPascalCase(collectionName)} = typeof ${tableName}.$inferInsert;
+`;
+  }
+  /**
+   * Get dialect-specific configuration for schema generation
+   */
+  getDialectConfig() {
+    switch (this.dialect) {
+      case "mysql":
+        return {
+          tableFunction: "mysqlTable",
+          importPath: "drizzle-orm/mysql-core"
+        };
+      case "sqlite":
+        return {
+          tableFunction: "sqliteTable",
+          importPath: "drizzle-orm/sqlite-core"
+        };
+      case "postgresql":
+      default:
+        return {
+          tableFunction: "pgTable",
+          importPath: "drizzle-orm/pg-core"
+        };
+    }
+  }
+  /**
+   * Generate dialect-specific timestamp column definitions
+   */
+  generateTimestampColumnsForDialect() {
+    if (this.dialect === "sqlite") {
+      return `  createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()).$onUpdate(() => new Date()),`;
+    }
+    return `  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),`;
+  }
+  /**
+   * Map field type to Drizzle ORM column definition (dialect-aware)
+   */
+  mapFieldTypeToDrizzleDialectAware(field) {
+    if (this.dialect === "sqlite") {
+      const sqliteTypeMap = {
+        string: (f) => `text('${f.name}')`,
+        text: (f) => `text('${f.name}')`,
+        number: (f) => f.options?.format === "float" ? `real('${f.name}')` : `integer('${f.name}')`,
+        decimal: (f) => `real('${f.name}')`,
+        boolean: (f) => `integer('${f.name}', { mode: 'boolean' })`,
+        date: (f) => `integer('${f.name}', { mode: 'timestamp' })`,
+        email: (f) => `text('${f.name}')`,
+        password: (f) => `text('${f.name}')`,
+        richtext: (f) => `text('${f.name}')`,
+        json: (f) => `text('${f.name}', { mode: 'json' })`,
+        chips: (f) => `text('${f.name}', { mode: 'json' })`,
+        relation: (f) => `text('${f.name}')`
+      };
+      const mapper = sqliteTypeMap[field.type];
+      return mapper ? mapper(field) : `text('${field.name}')`;
+    }
+    if (this.dialect === "mysql") {
+      const mysqlTypeMap = {
+        string: (f) => `varchar('${f.name}', { length: ${f.length || 255} })`,
+        text: (f) => f.options?.variant === "short" ? `varchar('${f.name}', { length: ${f.validation?.maxLength || 255} })` : `text('${f.name}')`,
+        number: (f) => f.options?.format === "float" ? `decimal('${f.name}', { precision: 10, scale: 2 })` : `int('${f.name}')`,
+        decimal: (f) => `decimal('${f.name}', { precision: 10, scale: 2 })`,
+        boolean: (f) => `boolean('${f.name}')`,
+        date: (f) => `timestamp('${f.name}')`,
+        email: (f) => `varchar('${f.name}', { length: ${f.validation?.maxLength || 255} })`,
+        password: (f) => `varchar('${f.name}', { length: ${f.validation?.maxLength || 255} })`,
+        richtext: (f) => `text('${f.name}')`,
+        json: (f) => `json('${f.name}')`,
+        chips: (f) => `json('${f.name}')`,
+        relation: (f) => `varchar('${f.name}', { length: 36 })`
+      };
+      const mapper = mysqlTypeMap[field.type];
+      return mapper ? mapper(field) : `text('${field.name}')`;
+    }
+    return this.mapFieldTypeToDrizzle(field);
+  }
+  /**
+   * Generate DROP TABLE migration SQL
+   */
+  generateDropTableMigration(collectionName, tableName) {
+    const dropStatement = this.dialect === "sqlite" ? `DROP TABLE IF EXISTS ${this.quoteIdentifier(tableName)};` : `DROP TABLE IF EXISTS ${this.quoteIdentifier(tableName)} CASCADE;`;
+    const migrationSQL = `-- Drop dynamic collection: ${collectionName}
+${dropStatement}`;
+    return {
+      migrationSQL,
+      migrationFileName: `${Date.now()}_drop_${collectionName}.sql`
+    };
+  }
+  /**
+   * Generate junction table SQL for many-to-many relationships
+   */
+  generateJunctionTable(sourceTableName, field) {
+    const targetCollectionName = field.options.target;
+    const targetTableName = `dc_${targetCollectionName}`;
+    const junctionTableName = field.options?.junctionTable || this.generateJunctionTableName(
+      sourceTableName,
+      targetTableName,
+      field.name
+    );
+    const onDelete = this.mapOnDeleteAction(
+      field.options?.onDelete || "cascade"
+    );
+    const onUpdate = this.mapOnUpdateAction(
+      field.options?.onUpdate || "no action"
+    );
+    const sourceCollectionName = sourceTableName.replace("dc_", "");
+    let timestampDefault = "";
+    if (this.dialect === "sqlite") {
+      timestampDefault = "integer DEFAULT (strftime('%s', 'now')) NOT NULL";
+    } else if (this.dialect === "mysql") {
+      timestampDefault = "timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL";
+    } else {
+      timestampDefault = "timestamp DEFAULT now() NOT NULL";
+    }
+    return `-- Junction table for many-to-many: ${sourceCollectionName}.${field.name} -> ${targetCollectionName}
+CREATE TABLE IF NOT EXISTS ${this.quoteIdentifier(junctionTableName)} (
+  ${this.quoteIdentifier("id")} ${this.dialect === "mysql" ? "varchar(36)" : "text"} PRIMARY KEY NOT NULL,
+  ${this.quoteIdentifier(`${sourceCollectionName}_id`)} ${this.dialect === "mysql" ? "varchar(36)" : "text"} NOT NULL,
+  ${this.quoteIdentifier(`${targetCollectionName}_id`)} ${this.dialect === "mysql" ? "varchar(36)" : "text"} NOT NULL,
+  ${this.quoteIdentifier("created_at")} ${timestampDefault},
+  CONSTRAINT ${this.quoteIdentifier(`fk_${junctionTableName}_${sourceCollectionName}`)} FOREIGN KEY (${this.quoteIdentifier(`${sourceCollectionName}_id`)}) REFERENCES ${this.quoteIdentifier(sourceTableName)}(${this.quoteIdentifier("id")}) ON DELETE ${onDelete} ON UPDATE ${onUpdate},
+  CONSTRAINT ${this.quoteIdentifier(`fk_${junctionTableName}_${targetCollectionName}`)} FOREIGN KEY (${this.quoteIdentifier(`${targetCollectionName}_id`)}) REFERENCES ${this.quoteIdentifier(targetTableName)}(${this.quoteIdentifier("id")}) ON DELETE ${onDelete} ON UPDATE ${onUpdate},
+  CONSTRAINT ${this.quoteIdentifier(`uq_${junctionTableName}_pair`)} UNIQUE (${this.quoteIdentifier(`${sourceCollectionName}_id`)}, ${this.quoteIdentifier(`${targetCollectionName}_id`)})
+);
+--> statement-breakpoint
+  CONSTRAINT ${this.quoteIdentifier(`uq_${junctionTableName}_pair`)} UNIQUE (${this.quoteIdentifier(`${sourceCollectionName}_id`)}, ${this.quoteIdentifier(`${targetCollectionName}_id`)})
+);
+--> statement-breakpoint
+${this.dialect === "mysql" ? "CREATE INDEX" : "CREATE INDEX IF NOT EXISTS"} ${this.quoteIdentifier(`idx_${junctionTableName}_${sourceCollectionName}`)} ON ${this.quoteIdentifier(junctionTableName)}(${this.quoteIdentifier(`${sourceCollectionName}_id`)});
+--> statement-breakpoint
+${this.dialect === "mysql" ? "CREATE INDEX" : "CREATE INDEX IF NOT EXISTS"} ${this.quoteIdentifier(`idx_${junctionTableName}_${targetCollectionName}`)} ON ${this.quoteIdentifier(junctionTableName)}(${this.quoteIdentifier(`${targetCollectionName}_id`)});`;
+  }
+  /**
+   * Generate junction table name following naming convention
+   */
+  generateJunctionTableName(sourceTable, targetTable, fieldName) {
+    const tables = [sourceTable, targetTable].sort();
+    return `${tables[0]}_${tables[1]}_${fieldName}`;
+  }
+  /**
+   * Generate Drizzle ORM relation definitions
+   */
+  generateRelationDefinitions(tableName, fields) {
+    const relationFields = fields.filter((f) => f.type === "relationship");
+    if (relationFields.length === 0) {
+      return "";
+    }
+    const relationDefs = relationFields.map((f) => {
+      const targetTable = `dc_${f.options.target}`;
+      const relationType = f.options.relationType;
+      switch (relationType) {
+        case "oneToOne":
+          return `    ${f.name}: one(${targetTable}, {
+      fields: [${tableName}.${f.name}],
+      references: [${targetTable}.id],
+    }),`;
+        case "manyToOne":
+          return `    ${f.name}: one(${targetTable}, {
+      fields: [${tableName}.${f.name}],
+      references: [${targetTable}.id],
+    }),`;
+        case "oneToMany":
+          return `    ${f.name}: many(${targetTable}),`;
+        case "manyToMany": {
+          const junctionTableName = f.options?.junctionTable || this.generateJunctionTableName(tableName, targetTable, f.name);
+          return `    ${f.name}: many(${targetTable}), // Through ${junctionTableName}`;
+        }
+        default:
+          return "";
+      }
+    }).filter(Boolean).join("\n");
+    return `
+// Drizzle ORM Relations
+export const ${tableName}Relations = relations(${tableName}, ({ one, many }) => ({
+${relationDefs}
+}));
+`;
+  }
+  // ==================== TYPE MAPPING METHODS ====================
+  /**
+   * Map field type to SQL column type (dialect-aware)
+   */
+  mapFieldTypeToSQL(type, length, options, validation) {
+    if (this.dialect === "sqlite") {
+      const sqliteTypeMap = {
+        text: "text",
+        textarea: "text",
+        number: options?.format === "float" ? "real" : "integer",
+        checkbox: "integer",
+        // SQLite uses 0/1 for boolean
+        date: "integer",
+        // Store as Unix timestamp
+        email: "text",
+        password: "text",
+        code: "text",
+        richText: "text",
+        json: "text",
+        // JSON stored as text in SQLite
+        chips: "text",
+        // Chips stored as JSON text in SQLite
+        relationship: "text"
+        // Store foreign key as text (UUID or ID)
+      };
+      return sqliteTypeMap[type] || "text";
+    }
+    if (this.dialect === "mysql") {
+      const mysqlTypeMap = {
+        text: options?.variant === "short" ? `varchar(${validation?.maxLength || 255})` : "text",
+        textarea: "text",
+        number: options?.format === "float" ? "decimal(10,2)" : "integer",
+        checkbox: "boolean",
+        date: "timestamp",
+        email: `varchar(${validation?.maxLength || 255})`,
+        password: `varchar(${validation?.maxLength || 255})`,
+        code: "text",
+        richText: "text",
+        json: "json",
+        // MySQL uses 'json' type, not 'jsonb'
+        chips: "json",
+        // Chips stored as JSON array
+        relationship: "varchar(36)"
+        // Store foreign key as varchar(36) for UUIDs
+      };
+      return mysqlTypeMap[type] || "text";
+    }
+    const typeMap = {
+      text: options?.variant === "short" ? `varchar(${validation?.maxLength || 255})` : "text",
+      textarea: "text",
+      number: options?.format === "float" ? "decimal(10,2)" : "integer",
+      checkbox: "boolean",
+      date: "timestamp",
+      email: `varchar(${validation?.maxLength || 255})`,
+      password: `varchar(${validation?.maxLength || 255})`,
+      code: "text",
+      richText: "text",
+      json: "jsonb",
+      chips: "jsonb",
+      // Chips stored as JSON array
+      relationship: "text"
+      // Store foreign key as text (UUID or ID)
+    };
+    return typeMap[type] || "text";
+  }
+  /**
+   * Map field type to Drizzle ORM column definition
+   */
+  mapFieldTypeToDrizzle(field) {
+    const typeMap = {
+      string: (f) => `varchar('${f.name}', { length: ${f.length || 255} })`,
+      text: (f) => f.options?.variant === "short" ? `varchar('${f.name}', { length: ${f.validation?.maxLength || 255} })` : `text('${f.name}')`,
+      number: (f) => f.options?.format === "float" ? `decimal('${f.name}', { precision: 10, scale: 2 })` : `integer('${f.name}')`,
+      decimal: (f) => `decimal('${f.name}', { precision: 10, scale: 2 })`,
+      boolean: (f) => `boolean('${f.name}')`,
+      date: (f) => `timestamp('${f.name}')`,
+      email: (f) => `varchar('${f.name}', { length: ${f.validation?.maxLength || 255} })`,
+      password: (f) => `varchar('${f.name}', { length: ${f.validation?.maxLength || 255} })`,
+      richtext: (f) => `text('${f.name}')`,
+      json: (f) => `jsonb('${f.name}')`,
+      chips: (f) => `jsonb('${f.name}')`,
+      relation: (f) => `text('${f.name}')`
+      // Foreign key
+    };
+    const mapper = typeMap[field.type];
+    return mapper ? mapper(field) : `text('${field.name}')`;
+  }
+  /**
+   * Get a sensible default value for a field type.
+   * Used when adding NOT NULL columns to existing tables.
+   */
+  getDefaultValueForType(type) {
+    switch (type) {
+      case "text":
+      case "textarea":
+      case "email":
+      case "password":
+      case "richText":
+      case "code":
+        return "''";
+      case "number":
+        return "0";
+      case "checkbox":
+        return this.dialect === "sqlite" ? "0" : "FALSE";
+      case "date":
+        if (this.dialect === "sqlite") {
+          return String(Math.floor(Date.now() / 1e3));
+        }
+        return "NOW()";
+      case "json":
+      case "repeater":
+      case "group":
+      case "blocks":
+        return "'{}'";
+      case "chips":
+        return "'[]'";
+      case "relationship":
+      case "upload":
+        return "NULL";
+      case "select":
+      case "radio":
+        return "''";
+      case "point":
+        return this.dialect === "postgresql" ? "'(0,0)'" : `'{"x":0,"y":0}'`;
+      default:
+        return "''";
+    }
+  }
+  /**
+   * Format a default value for SQL (dialect-aware)
+   */
+  formatDefaultValue(value, type) {
+    if (type === "text" || type === "textarea" || type === "email" || type === "password" || type === "richText" || type === "code" || type === "select" || type === "radio") {
+      return `'${String(value)}'`;
+    }
+    if (type === "checkbox") {
+      if (this.dialect === "sqlite") {
+        return value ? "1" : "0";
+      }
+      return value ? "TRUE" : "FALSE";
+    }
+    if (type === "json") {
+      return `'${typeof value === "string" ? value : JSON.stringify(value)}'`;
+    }
+    if (type === "date") {
+      if (this.dialect === "sqlite" && typeof value === "string") {
+        const timestamp = new Date(value).getTime() / 1e3;
+        return String(Math.floor(timestamp));
+      }
+      return `'${String(value)}'`;
+    }
+    if (type === "number") {
+      return String(value);
+    }
+    if (type === "relationship") {
+      return `'${String(value)}'`;
+    }
+    return String(value);
+  }
+  // ==================== UTILITY METHODS ====================
+  /**
+   * Convert snake_case to PascalCase
+   */
+  toPascalCase(str) {
+    return str.charAt(0).toUpperCase().concat(str.slice(1).replace(/_([a-z])/g, (_, c) => c.toUpperCase()));
+  }
+  /**
+   * Convert snake_case to camelCase
+   */
+  toCamelCase(str) {
+    return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  }
+  /**
+   * Map onDelete action to SQL syntax
+   */
+  mapOnDeleteAction(action) {
+    const actionMap = {
+      cascade: "CASCADE",
+      "set null": "SET NULL",
+      restrict: "RESTRICT",
+      "no action": "NO ACTION"
+    };
+    return actionMap[action.toLowerCase()] || "SET NULL";
+  }
+  /**
+   * Map onUpdate action to SQL syntax
+   */
+  mapOnUpdateAction(action) {
+    const actionMap = {
+      cascade: "CASCADE",
+      "set null": "SET NULL",
+      restrict: "RESTRICT",
+      "no action": "NO ACTION"
+    };
+    return actionMap[action.toLowerCase()] || "NO ACTION";
+  }
+};
+
+export {
+  DynamicCollectionValidationService,
+  DynamicCollectionSchemaService
+};