pocketbase-zod-schema 0.1.2

package/dist/migration/generator.cjs

@@ -0,0 +1,778 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/migration/generator.ts
+
+// src/migration/errors.ts
+var MigrationError = class _MigrationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MigrationError";
+    Object.setPrototypeOf(this, _MigrationError.prototype);
+  }
+};
+var MigrationGenerationError = class _MigrationGenerationError extends MigrationError {
+  migrationPath;
+  originalError;
+  constructor(message, migrationPath, originalError) {
+    super(message);
+    this.name = "MigrationGenerationError";
+    this.migrationPath = migrationPath;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _MigrationGenerationError.prototype);
+  }
+  /**
+   * Creates a formatted error message with migration path and original error details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.migrationPath) {
+      parts.push(`
+Migration: ${this.migrationPath}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+var FileSystemError = class _FileSystemError extends MigrationError {
+  path;
+  operation;
+  code;
+  originalError;
+  constructor(message, path2, operation, code, originalError) {
+    super(message);
+    this.name = "FileSystemError";
+    this.path = path2;
+    this.operation = operation;
+    this.code = code;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _FileSystemError.prototype);
+  }
+  /**
+   * Creates a formatted error message with path, operation, and error code details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.operation) {
+      parts.push(`
+Operation: ${this.operation}`);
+    }
+    if (this.path) {
+      parts.push(`
+Path: ${this.path}`);
+    }
+    if (this.code) {
+      parts.push(`
+Error Code: ${this.code}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+
+// src/migration/generator.ts
+var DEFAULT_TEMPLATE = `/// <reference path="{{TYPES_PATH}}" />
+migrate((app) => {
+{{UP_CODE}}
+  return true;
+}, (app) => {
+{{DOWN_CODE}}
+  return true;
+});
+`;
+var DEFAULT_CONFIG = {
+  workspaceRoot: process.cwd(),
+  timestampGenerator: () => Math.floor(Date.now() / 1e3).toString(),
+  template: DEFAULT_TEMPLATE,
+  includeTypeReference: true,
+  typesPath: "../pb_data/types.d.ts"
+};
+function mergeConfig(config) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+}
+function resolveMigrationDir(config) {
+  const workspaceRoot = config.workspaceRoot || process.cwd();
+  if (path__namespace.isAbsolute(config.migrationDir)) {
+    return config.migrationDir;
+  }
+  return path__namespace.join(workspaceRoot, config.migrationDir);
+}
+function generateTimestamp(config) {
+  if (config?.timestampGenerator) {
+    return config.timestampGenerator();
+  }
+  return Math.floor(Date.now() / 1e3).toString();
+}
+function generateMigrationDescription(diff) {
+  const parts = [];
+  if (diff.collectionsToCreate.length > 0) {
+    if (diff.collectionsToCreate.length === 1) {
+      parts.push(`created_${diff.collectionsToCreate[0].name}`);
+    } else {
+      parts.push(`created_${diff.collectionsToCreate.length}_collections`);
+    }
+  }
+  if (diff.collectionsToDelete.length > 0) {
+    if (diff.collectionsToDelete.length === 1) {
+      parts.push(`deleted_${diff.collectionsToDelete[0].name}`);
+    } else {
+      parts.push(`deleted_${diff.collectionsToDelete.length}_collections`);
+    }
+  }
+  if (diff.collectionsToModify.length > 0) {
+    if (diff.collectionsToModify.length === 1) {
+      parts.push(`updated_${diff.collectionsToModify[0].collection}`);
+    } else {
+      parts.push(`updated_${diff.collectionsToModify.length}_collections`);
+    }
+  }
+  if (parts.length === 0) {
+    return "no_changes";
+  }
+  let description = parts.join("_");
+  if (description.length > 80) {
+    description = description.substring(0, 77) + "...";
+  }
+  return description;
+}
+function generateMigrationFilename(diff, config) {
+  const timestamp = generateTimestamp(config);
+  const description = generateMigrationDescription(diff);
+  return `${timestamp}_${description}.js`;
+}
+function createMigrationFileStructure(upCode, downCode, config) {
+  const mergedConfig = config ? mergeConfig(config) : DEFAULT_CONFIG;
+  let template = mergedConfig.template;
+  template = template.replace("{{TYPES_PATH}}", mergedConfig.typesPath);
+  template = template.replace("{{UP_CODE}}", upCode);
+  template = template.replace("{{DOWN_CODE}}", downCode);
+  if (!mergedConfig.includeTypeReference) {
+    template = template.replace(/\/\/\/ <reference path="[^"]*" \/>\n?/, "");
+  }
+  return template;
+}
+function writeMigrationFile(migrationDir, filename, content) {
+  try {
+    if (!fs__namespace.existsSync(migrationDir)) {
+      try {
+        fs__namespace.mkdirSync(migrationDir, { recursive: true });
+      } catch (error) {
+        const fsError = error;
+        if (fsError.code === "EACCES" || fsError.code === "EPERM") {
+          throw new FileSystemError(
+            `Permission denied creating migration directory. Check directory permissions.`,
+            migrationDir,
+            "create",
+            fsError.code,
+            error
+          );
+        }
+        throw new FileSystemError(
+          `Failed to create migration directory: ${fsError.message}`,
+          migrationDir,
+          "create",
+          fsError.code,
+          error
+        );
+      }
+    }
+    const filePath = path__namespace.join(migrationDir, filename);
+    fs__namespace.writeFileSync(filePath, content, "utf-8");
+    return filePath;
+  } catch (error) {
+    if (error instanceof FileSystemError) {
+      throw error;
+    }
+    const fsError = error;
+    const filePath = path__namespace.join(migrationDir, filename);
+    if (fsError.code === "EACCES" || fsError.code === "EPERM") {
+      throw new FileSystemError(
+        `Permission denied writing migration file. Check file and directory permissions.`,
+        filePath,
+        "write",
+        fsError.code,
+        error
+      );
+    } else if (fsError.code === "ENOSPC") {
+      throw new FileSystemError(
+        `No space left on device when writing migration file.`,
+        filePath,
+        "write",
+        fsError.code,
+        error
+      );
+    }
+    throw new MigrationGenerationError(`Failed to write migration file: ${fsError.message}`, filePath, error);
+  }
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((v) => formatValue(v)).join(", ");
+    return `[${items}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${k}: ${formatValue(v)}`).join(", ");
+    return `{ ${entries} }`;
+  }
+  return String(value);
+}
+function generateFieldDefinitionObject(field) {
+  const parts = [];
+  parts.push(`      name: "${field.name}"`);
+  parts.push(`      type: "${field.type}"`);
+  parts.push(`      required: ${field.required}`);
+  if (field.unique !== void 0) {
+    parts.push(`      unique: ${field.unique}`);
+  }
+  if (field.options && Object.keys(field.options).length > 0) {
+    for (const [key, value] of Object.entries(field.options)) {
+      parts.push(`      ${key}: ${formatValue(value)}`);
+    }
+  }
+  if (field.relation) {
+    const collectionIdPlaceholder = field.relation.collection === "Users" ? '"_pb_users_auth_"' : `app.findCollectionByNameOrId("${field.relation.collection}").id`;
+    parts.push(`      collectionId: ${collectionIdPlaceholder}`);
+    if (field.relation.maxSelect !== void 0) {
+      parts.push(`      maxSelect: ${field.relation.maxSelect}`);
+    }
+    if (field.relation.minSelect !== void 0) {
+      parts.push(`      minSelect: ${field.relation.minSelect}`);
+    }
+    if (field.relation.cascadeDelete !== void 0) {
+      parts.push(`      cascadeDelete: ${field.relation.cascadeDelete}`);
+    }
+  }
+  return `    {
+${parts.join(",\n")},
+    }`;
+}
+function generateFieldsArray(fields) {
+  if (fields.length === 0) {
+    return "[]";
+  }
+  const fieldObjects = fields.map((field) => generateFieldDefinitionObject(field));
+  return `[
+${fieldObjects.join(",\n")},
+  ]`;
+}
+function generateCollectionRules(rules) {
+  if (!rules) {
+    return "";
+  }
+  const parts = [];
+  if (rules.listRule !== void 0) {
+    parts.push(`listRule: ${formatValue(rules.listRule)}`);
+  }
+  if (rules.viewRule !== void 0) {
+    parts.push(`viewRule: ${formatValue(rules.viewRule)}`);
+  }
+  if (rules.createRule !== void 0) {
+    parts.push(`createRule: ${formatValue(rules.createRule)}`);
+  }
+  if (rules.updateRule !== void 0) {
+    parts.push(`updateRule: ${formatValue(rules.updateRule)}`);
+  }
+  if (rules.deleteRule !== void 0) {
+    parts.push(`deleteRule: ${formatValue(rules.deleteRule)}`);
+  }
+  if (rules.manageRule !== void 0) {
+    parts.push(`manageRule: ${formatValue(rules.manageRule)}`);
+  }
+  return parts.join(",\n    ");
+}
+function generateCollectionPermissions(permissions) {
+  if (!permissions) {
+    return "";
+  }
+  const parts = [];
+  if (permissions.listRule !== void 0) {
+    parts.push(`listRule: ${formatValue(permissions.listRule)}`);
+  }
+  if (permissions.viewRule !== void 0) {
+    parts.push(`viewRule: ${formatValue(permissions.viewRule)}`);
+  }
+  if (permissions.createRule !== void 0) {
+    parts.push(`createRule: ${formatValue(permissions.createRule)}`);
+  }
+  if (permissions.updateRule !== void 0) {
+    parts.push(`updateRule: ${formatValue(permissions.updateRule)}`);
+  }
+  if (permissions.deleteRule !== void 0) {
+    parts.push(`deleteRule: ${formatValue(permissions.deleteRule)}`);
+  }
+  if (permissions.manageRule !== void 0) {
+    parts.push(`manageRule: ${formatValue(permissions.manageRule)}`);
+  }
+  return parts.join(",\n    ");
+}
+function generateIndexesArray(indexes) {
+  if (!indexes || indexes.length === 0) {
+    return "[]";
+  }
+  const indexStrings = indexes.map((idx) => `"${idx}"`);
+  return `[
+    ${indexStrings.join(",\n    ")},
+  ]`;
+}
+function generateCollectionCreation(collection, varName = "collection") {
+  const lines = [];
+  lines.push(`  const ${varName} = new Collection({`);
+  lines.push(`    name: "${collection.name}",`);
+  lines.push(`    type: "${collection.type}",`);
+  const permissionsCode = generateCollectionPermissions(collection.permissions);
+  const rulesCode = generateCollectionRules(collection.rules);
+  if (permissionsCode) {
+    lines.push(`    ${permissionsCode},`);
+  } else if (rulesCode) {
+    lines.push(`    ${rulesCode},`);
+  }
+  lines.push(`    fields: ${generateFieldsArray(collection.fields)},`);
+  lines.push(`    indexes: ${generateIndexesArray(collection.indexes)},`);
+  lines.push(`  });`);
+  lines.push(``);
+  lines.push(`  app.save(${varName});`);
+  return lines.join("\n");
+}
+function getFieldConstructorName(fieldType) {
+  const constructorMap = {
+    text: "TextField",
+    email: "EmailField",
+    url: "URLField",
+    number: "NumberField",
+    bool: "BoolField",
+    date: "DateField",
+    select: "SelectField",
+    relation: "RelationField",
+    file: "FileField",
+    json: "JSONField"
+  };
+  return constructorMap[fieldType] || "TextField";
+}
+function generateFieldConstructorOptions(field) {
+  const parts = [];
+  parts.push(`    name: "${field.name}"`);
+  parts.push(`    required: ${field.required}`);
+  if (field.unique !== void 0) {
+    parts.push(`    unique: ${field.unique}`);
+  }
+  if (field.options && Object.keys(field.options).length > 0) {
+    for (const [key, value] of Object.entries(field.options)) {
+      parts.push(`    ${key}: ${formatValue(value)}`);
+    }
+  }
+  if (field.relation && field.type === "relation") {
+    const collectionIdPlaceholder = field.relation.collection === "Users" ? '"_pb_users_auth_"' : `app.findCollectionByNameOrId("${field.relation.collection}").id`;
+    parts.push(`    collectionId: ${collectionIdPlaceholder}`);
+    if (field.relation.maxSelect !== void 0) {
+      parts.push(`    maxSelect: ${field.relation.maxSelect}`);
+    }
+    if (field.relation.minSelect !== void 0) {
+      parts.push(`    minSelect: ${field.relation.minSelect}`);
+    }
+    if (field.relation.cascadeDelete !== void 0) {
+      parts.push(`    cascadeDelete: ${field.relation.cascadeDelete}`);
+    }
+  }
+  return parts.join(",\n");
+}
+function generateFieldAddition(collectionName, field, varName) {
+  const lines = [];
+  const constructorName = getFieldConstructorName(field.type);
+  const collectionVar = varName || `collection_${collectionName}_${field.name}`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(``);
+  lines.push(`  ${collectionVar}.fields.add(new ${constructorName}({`);
+  lines.push(generateFieldConstructorOptions(field));
+  lines.push(`  }));`);
+  lines.push(``);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateFieldModification(collectionName, modification, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_${modification.fieldName}`;
+  const fieldVar = `${collectionVar}_field`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  const ${fieldVar} = ${collectionVar}.fields.getByName("${modification.fieldName}");`);
+  lines.push(``);
+  for (const change of modification.changes) {
+    if (change.property.startsWith("options.")) {
+      const optionKey = change.property.replace("options.", "");
+      lines.push(`  ${fieldVar}.${optionKey} = ${formatValue(change.newValue)};`);
+    } else if (change.property.startsWith("relation.")) {
+      const relationKey = change.property.replace("relation.", "");
+      if (relationKey === "collection") {
+        const collectionIdValue = change.newValue === "Users" ? '"_pb_users_auth_"' : `app.findCollectionByNameOrId("${change.newValue}").id`;
+        lines.push(`  ${fieldVar}.collectionId = ${collectionIdValue};`);
+      } else {
+        lines.push(`  ${fieldVar}.${relationKey} = ${formatValue(change.newValue)};`);
+      }
+    } else {
+      lines.push(`  ${fieldVar}.${change.property} = ${formatValue(change.newValue)};`);
+    }
+  }
+  lines.push(``);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateFieldDeletion(collectionName, fieldName, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_${fieldName}`;
+  const fieldVar = `${collectionVar}_field`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  const ${fieldVar} = ${collectionVar}.fields.getByName("${fieldName}");`);
+  lines.push(``);
+  lines.push(`  ${collectionVar}.fields.remove(${fieldVar}.id);`);
+  lines.push(``);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateIndexAddition(collectionName, index, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_idx`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  ${collectionVar}.indexes.push("${index}");`);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateIndexRemoval(collectionName, index, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_idx`;
+  const indexVar = `${collectionVar}_indexToRemove`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  const ${indexVar} = ${collectionVar}.indexes.findIndex(idx => idx === "${index}");`);
+  lines.push(`  if (${indexVar} !== -1) {`);
+  lines.push(`    ${collectionVar}.indexes.splice(${indexVar}, 1);`);
+  lines.push(`  }`);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateRuleUpdate(collectionName, ruleType, newValue, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_${ruleType}`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  ${collectionVar}.${ruleType} = ${formatValue(newValue)};`);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generatePermissionUpdate(collectionName, ruleType, newValue, varName) {
+  const lines = [];
+  const collectionVar = varName || `collection_${collectionName}_${ruleType}`;
+  lines.push(`  const ${collectionVar} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  ${collectionVar}.${ruleType} = ${formatValue(newValue)};`);
+  lines.push(`  app.save(${collectionVar});`);
+  return lines.join("\n");
+}
+function generateCollectionDeletion(collectionName, varName = "collection") {
+  const lines = [];
+  lines.push(`  const ${varName} = app.findCollectionByNameOrId("${collectionName}");`);
+  lines.push(`  app.delete(${varName});`);
+  return lines.join("\n");
+}
+function generateUpMigration(diff) {
+  const lines = [];
+  lines.push(`  // UP MIGRATION`);
+  lines.push(``);
+  if (diff.collectionsToCreate.length > 0) {
+    lines.push(`  // Create new collections`);
+    for (let i = 0; i < diff.collectionsToCreate.length; i++) {
+      const collection = diff.collectionsToCreate[i];
+      const varName = `collection_${collection.name}_create`;
+      lines.push(generateCollectionCreation(collection, varName));
+      lines.push(``);
+    }
+  }
+  if (diff.collectionsToModify.length > 0) {
+    lines.push(`  // Modify existing collections`);
+    for (const modification of diff.collectionsToModify) {
+      const collectionName = modification.collection;
+      if (modification.fieldsToAdd.length > 0) {
+        lines.push(`  // Add fields to ${collectionName}`);
+        for (const field of modification.fieldsToAdd) {
+          const varName = `collection_${collectionName}_add_${field.name}`;
+          lines.push(generateFieldAddition(collectionName, field, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToModify.length > 0) {
+        lines.push(`  // Modify fields in ${collectionName}`);
+        for (const fieldMod of modification.fieldsToModify) {
+          const varName = `collection_${collectionName}_modify_${fieldMod.fieldName}`;
+          lines.push(generateFieldModification(collectionName, fieldMod, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToRemove.length > 0) {
+        lines.push(`  // Remove fields from ${collectionName}`);
+        for (const field of modification.fieldsToRemove) {
+          const varName = `collection_${collectionName}_remove_${field.name}`;
+          lines.push(generateFieldDeletion(collectionName, field.name, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.indexesToAdd.length > 0) {
+        lines.push(`  // Add indexes to ${collectionName}`);
+        for (let i = 0; i < modification.indexesToAdd.length; i++) {
+          const index = modification.indexesToAdd[i];
+          const varName = `collection_${collectionName}_addidx_${i}`;
+          lines.push(generateIndexAddition(collectionName, index, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.indexesToRemove.length > 0) {
+        lines.push(`  // Remove indexes from ${collectionName}`);
+        for (let i = 0; i < modification.indexesToRemove.length; i++) {
+          const index = modification.indexesToRemove[i];
+          const varName = `collection_${collectionName}_rmidx_${i}`;
+          lines.push(generateIndexRemoval(collectionName, index, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.permissionsToUpdate && modification.permissionsToUpdate.length > 0) {
+        lines.push(`  // Update permissions for ${collectionName}`);
+        for (const permission of modification.permissionsToUpdate) {
+          const varName = `collection_${collectionName}_perm_${permission.ruleType}`;
+          lines.push(generatePermissionUpdate(collectionName, permission.ruleType, permission.newValue, varName));
+          lines.push(``);
+        }
+      } else if (modification.rulesToUpdate.length > 0) {
+        lines.push(`  // Update rules for ${collectionName}`);
+        for (const rule of modification.rulesToUpdate) {
+          const varName = `collection_${collectionName}_rule_${rule.ruleType}`;
+          lines.push(generateRuleUpdate(collectionName, rule.ruleType, rule.newValue, varName));
+          lines.push(``);
+        }
+      }
+    }
+  }
+  if (diff.collectionsToDelete.length > 0) {
+    lines.push(`  // Delete collections`);
+    for (let i = 0; i < diff.collectionsToDelete.length; i++) {
+      const collection = diff.collectionsToDelete[i];
+      const varName = `collection_${collection.name}_delete`;
+      lines.push(generateCollectionDeletion(collection.name, varName));
+      lines.push(``);
+    }
+  }
+  if (lines.length === 2) {
+    lines.push(`  // No changes detected`);
+    lines.push(``);
+  }
+  return lines.join("\n");
+}
+function generateDownMigration(diff) {
+  const lines = [];
+  lines.push(`  // DOWN MIGRATION (ROLLBACK)`);
+  lines.push(``);
+  if (diff.collectionsToDelete.length > 0) {
+    lines.push(`  // Recreate deleted collections`);
+    for (let i = 0; i < diff.collectionsToDelete.length; i++) {
+      const collection = diff.collectionsToDelete[i];
+      const varName = `collection_${collection.name}_recreate`;
+      lines.push(generateCollectionCreation(collection, varName));
+      lines.push(``);
+    }
+  }
+  if (diff.collectionsToModify.length > 0) {
+    lines.push(`  // Revert modifications`);
+    for (const modification of diff.collectionsToModify) {
+      const collectionName = modification.collection;
+      if (modification.permissionsToUpdate && modification.permissionsToUpdate.length > 0) {
+        lines.push(`  // Revert permissions for ${collectionName}`);
+        for (const permission of modification.permissionsToUpdate) {
+          const varName = `collection_${collectionName}_revert_perm_${permission.ruleType}`;
+          lines.push(generatePermissionUpdate(collectionName, permission.ruleType, permission.oldValue, varName));
+          lines.push(``);
+        }
+      } else if (modification.rulesToUpdate.length > 0) {
+        lines.push(`  // Revert rules for ${collectionName}`);
+        for (const rule of modification.rulesToUpdate) {
+          const varName = `collection_${collectionName}_revert_rule_${rule.ruleType}`;
+          lines.push(generateRuleUpdate(collectionName, rule.ruleType, rule.oldValue, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.indexesToRemove.length > 0) {
+        lines.push(`  // Restore indexes to ${collectionName}`);
+        for (let i = 0; i < modification.indexesToRemove.length; i++) {
+          const index = modification.indexesToRemove[i];
+          const varName = `collection_${collectionName}_restore_idx_${i}`;
+          lines.push(generateIndexAddition(collectionName, index, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.indexesToAdd.length > 0) {
+        lines.push(`  // Remove indexes from ${collectionName}`);
+        for (let i = 0; i < modification.indexesToAdd.length; i++) {
+          const index = modification.indexesToAdd[i];
+          const varName = `collection_${collectionName}_revert_idx_${i}`;
+          lines.push(generateIndexRemoval(collectionName, index, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToRemove.length > 0) {
+        lines.push(`  // Restore fields to ${collectionName}`);
+        for (const field of modification.fieldsToRemove) {
+          const varName = `collection_${collectionName}_restore_${field.name}`;
+          lines.push(generateFieldAddition(collectionName, field, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToModify.length > 0) {
+        lines.push(`  // Revert field modifications in ${collectionName}`);
+        for (const fieldMod of modification.fieldsToModify) {
+          const reverseChanges = fieldMod.changes.map((change) => ({
+            property: change.property,
+            oldValue: change.newValue,
+            newValue: change.oldValue
+          }));
+          const reverseMod = {
+            fieldName: fieldMod.fieldName,
+            currentDefinition: fieldMod.newDefinition,
+            newDefinition: fieldMod.currentDefinition,
+            changes: reverseChanges
+          };
+          const varName = `collection_${collectionName}_revert_${fieldMod.fieldName}`;
+          lines.push(generateFieldModification(collectionName, reverseMod, varName));
+          lines.push(``);
+        }
+      }
+      if (modification.fieldsToAdd.length > 0) {
+        lines.push(`  // Remove added fields from ${collectionName}`);
+        for (const field of modification.fieldsToAdd) {
+          const varName = `collection_${collectionName}_revert_add_${field.name}`;
+          lines.push(generateFieldDeletion(collectionName, field.name, varName));
+          lines.push(``);
+        }
+      }
+    }
+  }
+  if (diff.collectionsToCreate.length > 0) {
+    lines.push(`  // Delete created collections`);
+    for (let i = 0; i < diff.collectionsToCreate.length; i++) {
+      const collection = diff.collectionsToCreate[i];
+      const varName = `collection_${collection.name}_rollback`;
+      lines.push(generateCollectionDeletion(collection.name, varName));
+      lines.push(``);
+    }
+  }
+  if (lines.length === 2) {
+    lines.push(`  // No changes to revert`);
+    lines.push(``);
+  }
+  return lines.join("\n");
+}
+function generate(diff, config) {
+  const normalizedConfig = typeof config === "string" ? { migrationDir: config } : config;
+  try {
+    const migrationDir = resolveMigrationDir(normalizedConfig);
+    const upCode = generateUpMigration(diff);
+    const downCode = generateDownMigration(diff);
+    const content = createMigrationFileStructure(upCode, downCode, normalizedConfig);
+    const filename = generateMigrationFilename(diff, normalizedConfig);
+    const filePath = writeMigrationFile(migrationDir, filename, content);
+    return filePath;
+  } catch (error) {
+    if (error instanceof MigrationGenerationError || error instanceof FileSystemError) {
+      throw error;
+    }
+    throw new MigrationGenerationError(
+      `Failed to generate migration: ${error instanceof Error ? error.message : String(error)}`,
+      normalizedConfig.migrationDir,
+      error
+    );
+  }
+}
+var MigrationGenerator = class {
+  config;
+  constructor(config) {
+    this.config = mergeConfig(config);
+  }
+  /**
+   * Generates a migration file from a schema diff
+   */
+  generate(diff) {
+    return generate(diff, this.config);
+  }
+  /**
+   * Generates the up migration code without writing to file
+   */
+  generateUpMigration(diff) {
+    return generateUpMigration(diff);
+  }
+  /**
+   * Generates the down migration code without writing to file
+   */
+  generateDownMigration(diff) {
+    return generateDownMigration(diff);
+  }
+  /**
+   * Generates a migration filename
+   */
+  generateMigrationFilename(diff) {
+    return generateMigrationFilename(diff, this.config);
+  }
+};
+
+exports.MigrationGenerator = MigrationGenerator;
+exports.createMigrationFileStructure = createMigrationFileStructure;
+exports.generate = generate;
+exports.generateCollectionCreation = generateCollectionCreation;
+exports.generateCollectionPermissions = generateCollectionPermissions;
+exports.generateCollectionRules = generateCollectionRules;
+exports.generateDownMigration = generateDownMigration;
+exports.generateFieldAddition = generateFieldAddition;
+exports.generateFieldDefinitionObject = generateFieldDefinitionObject;
+exports.generateFieldDeletion = generateFieldDeletion;
+exports.generateFieldModification = generateFieldModification;
+exports.generateFieldsArray = generateFieldsArray;
+exports.generateIndexesArray = generateIndexesArray;
+exports.generateMigrationDescription = generateMigrationDescription;
+exports.generateMigrationFilename = generateMigrationFilename;
+exports.generatePermissionUpdate = generatePermissionUpdate;
+exports.generateTimestamp = generateTimestamp;
+exports.generateUpMigration = generateUpMigration;
+exports.writeMigrationFile = writeMigrationFile;
+//# sourceMappingURL=generator.cjs.map
+//# sourceMappingURL=generator.cjs.map