pocketbase-zod-schema 0.1.2

package/dist/migration/index.cjs

@@ -0,0 +1,3390 @@
+'use strict';
+
+var fs2 = require('fs');
+var path = require('path');
+var zod = require('zod');
+
+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 fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/migration/analyzer.ts
+
+// src/migration/errors.ts
+var MigrationError = class _MigrationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MigrationError";
+    Object.setPrototypeOf(this, _MigrationError.prototype);
+  }
+};
+var SchemaParsingError = class _SchemaParsingError extends MigrationError {
+  filePath;
+  originalError;
+  constructor(message, filePath, originalError) {
+    super(message);
+    this.name = "SchemaParsingError";
+    this.filePath = filePath;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _SchemaParsingError.prototype);
+  }
+  /**
+   * Creates a formatted error message with file path and original error details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.filePath) {
+      parts.push(`
+File: ${this.filePath}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+var SnapshotError = class _SnapshotError extends MigrationError {
+  snapshotPath;
+  operation;
+  originalError;
+  constructor(message, snapshotPath, operation, originalError) {
+    super(message);
+    this.name = "SnapshotError";
+    this.snapshotPath = snapshotPath;
+    this.operation = operation;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _SnapshotError.prototype);
+  }
+  /**
+   * Creates a formatted error message with snapshot path and operation details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.operation) {
+      parts.push(`
+Operation: ${this.operation}`);
+    }
+    if (this.snapshotPath) {
+      parts.push(`
+Snapshot: ${this.snapshotPath}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+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, path4, operation, code, originalError) {
+    super(message);
+    this.name = "FileSystemError";
+    this.path = path4;
+    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("");
+  }
+};
+var ConfigurationError = class _ConfigurationError extends MigrationError {
+  configPath;
+  invalidFields;
+  originalError;
+  constructor(message, configPath, invalidFields, originalError) {
+    super(message);
+    this.name = "ConfigurationError";
+    this.configPath = configPath;
+    this.invalidFields = invalidFields;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _ConfigurationError.prototype);
+  }
+  /**
+   * Creates a formatted error message with configuration details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.configPath) {
+      parts.push(`
+Configuration File: ${this.configPath}`);
+    }
+    if (this.invalidFields && this.invalidFields.length > 0) {
+      parts.push(`
+Invalid Fields: ${this.invalidFields.join(", ")}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+var CLIUsageError = class _CLIUsageError extends MigrationError {
+  command;
+  suggestion;
+  constructor(message, command, suggestion) {
+    super(message);
+    this.name = "CLIUsageError";
+    this.command = command;
+    this.suggestion = suggestion;
+    Object.setPrototypeOf(this, _CLIUsageError.prototype);
+  }
+  /**
+   * Creates a formatted error message with usage suggestions
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.command) {
+      parts.push(`
+Command: ${this.command}`);
+    }
+    if (this.suggestion) {
+      parts.push(`
+Suggestion: ${this.suggestion}`);
+    }
+    return parts.join("");
+  }
+};
+
+// src/schema/permission-templates.ts
+var PermissionTemplates = {
+  /**
+   * Public access - anyone can perform all operations
+   */
+  public: () => ({
+    listRule: "",
+    viewRule: "",
+    createRule: "",
+    updateRule: "",
+    deleteRule: ""
+  }),
+  /**
+   * Authenticated users only - requires valid authentication for all operations
+   */
+  authenticated: () => ({
+    listRule: '@request.auth.id != ""',
+    viewRule: '@request.auth.id != ""',
+    createRule: '@request.auth.id != ""',
+    updateRule: '@request.auth.id != ""',
+    deleteRule: '@request.auth.id != ""'
+  }),
+  /**
+   * Owner-only access - users can only manage their own records
+   * @param ownerField - Name of the relation field pointing to user (default: 'User')
+   */
+  ownerOnly: (ownerField = "User") => ({
+    listRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    viewRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    createRule: '@request.auth.id != ""',
+    updateRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    deleteRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`
+  }),
+  /**
+   * Admin/superuser only access
+   * Assumes a 'role' field exists with 'admin' value
+   * @param roleField - Name of the role field (default: 'role')
+   */
+  adminOnly: (roleField = "role") => ({
+    listRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    viewRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    createRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    updateRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    deleteRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`
+  }),
+  /**
+   * Public read, authenticated write
+   * Anyone can list/view, but only authenticated users can create/update/delete
+   */
+  readPublic: () => ({
+    listRule: "",
+    viewRule: "",
+    createRule: '@request.auth.id != ""',
+    updateRule: '@request.auth.id != ""',
+    deleteRule: '@request.auth.id != ""'
+  }),
+  /**
+   * Locked access - only superusers can perform operations
+   * All rules are set to null (locked)
+   */
+  locked: () => ({
+    listRule: null,
+    viewRule: null,
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  }),
+  /**
+   * Read-only authenticated - authenticated users can read, no write access
+   */
+  readOnlyAuthenticated: () => ({
+    listRule: '@request.auth.id != ""',
+    viewRule: '@request.auth.id != ""',
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  })
+};
+function resolveTemplate(config) {
+  let baseRules;
+  switch (config.template) {
+    case "public":
+      baseRules = PermissionTemplates.public();
+      break;
+    case "authenticated":
+      baseRules = PermissionTemplates.authenticated();
+      break;
+    case "owner-only":
+      baseRules = PermissionTemplates.ownerOnly(config.ownerField);
+      break;
+    case "admin-only":
+      baseRules = PermissionTemplates.adminOnly(config.roleField);
+      break;
+    case "read-public":
+      baseRules = PermissionTemplates.readPublic();
+      break;
+    case "custom":
+      baseRules = {};
+      break;
+    default: {
+      const _exhaustive = config.template;
+      throw new Error(`Unknown template type: ${_exhaustive}`);
+    }
+  }
+  return {
+    ...baseRules,
+    ...config.customRules
+  };
+}
+
+// src/migration/rule-validator.ts
+var RuleValidator = class {
+  fields;
+  collectionName;
+  isAuthCollection;
+  constructor(collectionName, fields, isAuthCollection2 = false) {
+    this.collectionName = collectionName;
+    this.fields = new Map(fields.map((f) => [f.name, f]));
+    this.isAuthCollection = isAuthCollection2;
+    this.addSystemFields();
+  }
+  /**
+   * Add system fields that are always available in PocketBase collections
+   * These fields are automatically added by PocketBase and can be referenced in rules
+   */
+  addSystemFields() {
+    const systemFields = [
+      { name: "id", type: "text", required: true, options: {} },
+      { name: "created", type: "date", required: true, options: {} },
+      { name: "updated", type: "date", required: true, options: {} },
+      { name: "collectionId", type: "text", required: true, options: {} },
+      { name: "collectionName", type: "text", required: true, options: {} }
+    ];
+    if (this.isAuthCollection) {
+      systemFields.push(
+        { name: "email", type: "email", required: true, options: {} },
+        { name: "emailVisibility", type: "bool", required: false, options: {} },
+        { name: "verified", type: "bool", required: false, options: {} },
+        { name: "tokenKey", type: "text", required: true, options: {} },
+        { name: "password", type: "text", required: true, options: {} }
+      );
+    }
+    for (const field of systemFields) {
+      if (!this.fields.has(field.name)) {
+        this.fields.set(field.name, field);
+      }
+    }
+  }
+  /**
+   * Validate a rule expression
+   *
+   * @param ruleType - The type of rule being validated
+   * @param expression - The rule expression to validate
+   * @returns Validation result with errors, warnings, and field references
+   */
+  validate(ruleType, expression) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+      fieldReferences: []
+    };
+    if (expression === null) {
+      return result;
+    }
+    if (expression === "") {
+      result.warnings.push(`${ruleType} is public - anyone can perform this operation`);
+      return result;
+    }
+    if (ruleType === "manageRule" && !this.isAuthCollection) {
+      result.valid = false;
+      result.errors.push("manageRule is only valid for auth collections");
+      return result;
+    }
+    const fieldRefs = this.extractFieldReferences(expression);
+    result.fieldReferences = fieldRefs;
+    for (const fieldRef of fieldRefs) {
+      this.validateFieldReference(fieldRef, result);
+    }
+    this.validateRequestReferences(expression, result);
+    this.validateSyntax(expression, result);
+    return result;
+  }
+  /**
+   * Extract field references from expression
+   *
+   * Matches field names that are not @request references.
+   * Handles dot notation for relations: user.email, post.author.name
+   *
+   * @param expression - The rule expression
+   * @returns Array of unique field references
+   */
+  extractFieldReferences(expression) {
+    const refs = [];
+    let cleaned = expression.replace(/"[^"]*"/g, '""').replace(/'[^']*'/g, "''");
+    cleaned = cleaned.replace(/@request\.[a-zA-Z_][a-zA-Z0-9_.]*/g, "");
+    const fieldPattern = /(?:^|[^@\w])([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)(?=[^a-zA-Z0-9_.]|$)/g;
+    let match;
+    while ((match = fieldPattern.exec(cleaned)) !== null) {
+      const ref = match[1];
+      if (!this.isKeyword(ref)) {
+        refs.push(ref);
+      }
+    }
+    return [...new Set(refs)];
+  }
+  /**
+   * Check if a word is a PocketBase keyword
+   *
+   * @param word - The word to check
+   * @returns True if the word is a keyword
+   */
+  isKeyword(word) {
+    const keywords = ["true", "false", "null", "AND", "OR", "NOT", "LIKE", "IN"];
+    return keywords.includes(word.toUpperCase());
+  }
+  /**
+   * Validate a field reference exists in schema
+   *
+   * Checks if the root field exists and validates relation chains.
+   * For nested references, warns about potential issues since we can't
+   * validate across collections without loading related schemas.
+   *
+   * @param fieldRef - The field reference to validate (e.g., "user" or "user.email")
+   * @param result - The validation result to update
+   */
+  validateFieldReference(fieldRef, result) {
+    const parts = fieldRef.split(".");
+    const rootField = parts[0];
+    if (!this.fields.has(rootField)) {
+      result.errors.push(`Field '${rootField}' does not exist in collection '${this.collectionName}'`);
+      result.valid = false;
+      return;
+    }
+    if (parts.length > 1) {
+      const field = this.fields.get(rootField);
+      if (field.type !== "relation") {
+        result.errors.push(`Field '${rootField}' is not a relation field, cannot access nested property '${parts[1]}'`);
+        result.valid = false;
+      } else {
+        result.warnings.push(
+          `Nested field reference '${fieldRef}' - ensure target collection has field '${parts.slice(1).join(".")}'`
+        );
+      }
+    }
+  }
+  /**
+   * Validate @request references
+   *
+   * Checks that @request references follow valid PocketBase patterns:
+   * - @request.auth.* - authenticated user data
+   * - @request.body.* - request body fields
+   * - @request.query.* - query parameters
+   * - @request.headers.* - request headers
+   * - @request.method - HTTP method
+   * - @request.context - execution context
+   *
+   * @param expression - The rule expression
+   * @param result - The validation result to update
+   */
+  validateRequestReferences(expression, result) {
+    const requestRefs = expression.match(/@request\.[a-zA-Z_][a-zA-Z0-9_.]*/g) || [];
+    for (const ref of requestRefs) {
+      const isValid = ref.startsWith("@request.auth.") || ref === "@request.method" || ref === "@request.context" || ref.startsWith("@request.body.") || ref.startsWith("@request.query.") || ref.startsWith("@request.headers.");
+      if (!isValid) {
+        result.errors.push(`Invalid @request reference: '${ref}'`);
+        result.valid = false;
+      }
+    }
+  }
+  /**
+   * Validate basic syntax patterns
+   *
+   * Checks for:
+   * - Balanced parentheses
+   * - Common operator mistakes (== instead of =)
+   *
+   * @param expression - The rule expression
+   * @param result - The validation result to update
+   */
+  validateSyntax(expression, result) {
+    let parenCount = 0;
+    for (const char of expression) {
+      if (char === "(") parenCount++;
+      if (char === ")") parenCount--;
+      if (parenCount < 0) {
+        result.errors.push("Unbalanced parentheses in expression");
+        result.valid = false;
+        return;
+      }
+    }
+    if (parenCount !== 0) {
+      result.errors.push("Unbalanced parentheses in expression");
+      result.valid = false;
+    }
+    if (expression.includes("==")) {
+      result.warnings.push("Use '=' instead of '==' for equality comparison in PocketBase rules");
+    }
+  }
+};
+
+// src/migration/permission-analyzer.ts
+var PermissionAnalyzer = class {
+  /**
+   * Extract permission metadata from Zod schema description
+   *
+   * Zod schemas can have permission metadata attached via the describe() method.
+   * This method parses the description and extracts the permission configuration.
+   *
+   * @param schemaDescription - The Zod schema description string
+   * @returns Permission schema if found, null otherwise
+   *
+   * @example
+   * ```typescript
+   * const analyzer = new PermissionAnalyzer();
+   * const permissions = analyzer.extractPermissions(schema.description);
+   * ```
+   */
+  extractPermissions(schemaDescription) {
+    if (!schemaDescription) {
+      return null;
+    }
+    try {
+      const metadata = JSON.parse(schemaDescription);
+      if (metadata.permissions) {
+        return metadata.permissions;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  /**
+   * Resolve template configuration to concrete rules
+   *
+   * Takes either a template configuration or a direct permission schema
+   * and returns a fully resolved permission schema with all rules defined.
+   *
+   * If the input is already a permission schema (has rule properties),
+   * it's returned as-is. Otherwise, the template is resolved using the
+   * template resolver.
+   *
+   * @param config - Template configuration or direct permission schema
+   * @returns Resolved permission schema
+   *
+   * @example
+   * ```typescript
+   * const analyzer = new PermissionAnalyzer();
+   *
+   * // Resolve from template
+   * const permissions = analyzer.resolvePermissions({
+   *   template: 'owner-only',
+   *   ownerField: 'User'
+   * });
+   *
+   * // Or pass direct schema
+   * const permissions = analyzer.resolvePermissions({
+   *   listRule: '@request.auth.id != ""',
+   *   viewRule: '@request.auth.id != ""'
+   * });
+   * ```
+   */
+  resolvePermissions(config) {
+    if ("listRule" in config || "viewRule" in config || "createRule" in config || "updateRule" in config || "deleteRule" in config || "manageRule" in config) {
+      return config;
+    }
+    return resolveTemplate(config);
+  }
+  /**
+   * Validate all rules in a permission schema
+   *
+   * Validates each rule in the permission schema against the collection's
+   * field definitions. Returns a map of validation results keyed by rule type.
+   *
+   * Only validates rules that are defined (not undefined). Undefined rules
+   * are treated as null (locked) by default.
+   *
+   * @param collectionName - Name of the collection being validated
+   * @param permissions - Permission schema to validate
+   * @param fields - Collection field definitions
+   * @param isAuthCollection - Whether this is an auth collection (allows manageRule)
+   * @returns Map of validation results by rule type
+   *
+   * @example
+   * ```typescript
+   * const analyzer = new PermissionAnalyzer();
+   * const results = analyzer.validatePermissions(
+   *   'posts',
+   *   { listRule: '@request.auth.id != ""', viewRule: 'author = @request.auth.id' },
+   *   fields,
+   *   false
+   * );
+   *
+   * for (const [ruleType, result] of results) {
+   *   if (!result.valid) {
+   *     console.error(`${ruleType} validation failed:`, result.errors);
+   *   }
+   * }
+   * ```
+   */
+  validatePermissions(collectionName, permissions, fields, isAuthCollection2 = false) {
+    const validator = new RuleValidator(collectionName, fields, isAuthCollection2);
+    const results = /* @__PURE__ */ new Map();
+    const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule"];
+    if (isAuthCollection2) {
+      ruleTypes.push("manageRule");
+    }
+    for (const ruleType of ruleTypes) {
+      const expression = permissions[ruleType];
+      if (expression !== void 0) {
+        results.set(ruleType, validator.validate(ruleType, expression));
+      }
+    }
+    return results;
+  }
+  /**
+   * Merge permissions with defaults
+   *
+   * Ensures all rule types have a defined value. Undefined rules are set
+   * to null (locked to superusers only), which is the PocketBase default.
+   *
+   * This is useful when generating migrations to ensure all rules are
+   * explicitly set in the collection configuration.
+   *
+   * @param permissions - Permission schema (may have undefined rules)
+   * @returns Permission schema with all rules defined (null if not specified)
+   *
+   * @example
+   * ```typescript
+   * const analyzer = new PermissionAnalyzer();
+   * const merged = analyzer.mergeWithDefaults({
+   *   listRule: '@request.auth.id != ""'
+   *   // other rules undefined
+   * });
+   *
+   * // Result:
+   * // {
+   * //   listRule: '@request.auth.id != ""',
+   * //   viewRule: null,
+   * //   createRule: null,
+   * //   updateRule: null,
+   * //   deleteRule: null,
+   * //   manageRule: null
+   * // }
+   * ```
+   */
+  mergeWithDefaults(permissions) {
+    return {
+      listRule: permissions.listRule ?? null,
+      viewRule: permissions.viewRule ?? null,
+      createRule: permissions.createRule ?? null,
+      updateRule: permissions.updateRule ?? null,
+      deleteRule: permissions.deleteRule ?? null,
+      manageRule: permissions.manageRule ?? null
+    };
+  }
+};
+
+// src/migration/utils/pluralize.ts
+var SPECIAL_CASES = {
+  // Common irregular plurals
+  person: "people",
+  Person: "People",
+  child: "children",
+  Child: "Children",
+  man: "men",
+  Man: "Men",
+  woman: "women",
+  Woman: "Women",
+  tooth: "teeth",
+  Tooth: "Teeth",
+  foot: "feet",
+  Foot: "Feet",
+  mouse: "mice",
+  Mouse: "Mice",
+  goose: "geese",
+  Goose: "Geese",
+  // Words ending in -y
+  category: "categories",
+  Category: "Categories",
+  company: "companies",
+  Company: "Companies",
+  city: "cities",
+  City: "Cities",
+  country: "countries",
+  Country: "Countries",
+  story: "stories",
+  Story: "Stories",
+  party: "parties",
+  Party: "Parties",
+  family: "families",
+  Family: "Families",
+  activity: "activities",
+  Activity: "Activities",
+  priority: "priorities",
+  Priority: "Priorities",
+  // Words ending in -f or -fe
+  life: "lives",
+  Life: "Lives",
+  wife: "wives",
+  Wife: "Wives",
+  knife: "knives",
+  Knife: "Knives",
+  leaf: "leaves",
+  Leaf: "Leaves",
+  shelf: "shelves",
+  Shelf: "Shelves",
+  half: "halves",
+  Half: "Halves",
+  // Words ending in -is
+  analysis: "analyses",
+  Analysis: "Analyses",
+  basis: "bases",
+  Basis: "Bases",
+  crisis: "crises",
+  Crisis: "Crises",
+  thesis: "theses",
+  Thesis: "Theses",
+  // Words ending in -us
+  cactus: "cacti",
+  Cactus: "Cacti",
+  focus: "foci",
+  Focus: "Foci",
+  fungus: "fungi",
+  Fungus: "Fungi",
+  nucleus: "nuclei",
+  Nucleus: "Nuclei",
+  radius: "radii",
+  Radius: "Radii",
+  // Words ending in -on
+  phenomenon: "phenomena",
+  Phenomenon: "Phenomena",
+  criterion: "criteria",
+  Criterion: "Criteria",
+  // Words ending in -um
+  datum: "data",
+  Datum: "Data",
+  medium: "media",
+  Medium: "Media",
+  curriculum: "curricula",
+  Curriculum: "Curricula",
+  // Unchanged plurals
+  sheep: "sheep",
+  Sheep: "Sheep",
+  deer: "deer",
+  Deer: "Deer",
+  fish: "fish",
+  Fish: "Fish",
+  species: "species",
+  Species: "Species",
+  series: "series",
+  Series: "Series"
+};
+function pluralize(singular) {
+  if (SPECIAL_CASES[singular]) {
+    return SPECIAL_CASES[singular];
+  }
+  if (singular.length > 3 && singular.endsWith("s") && !singular.endsWith("ss")) {
+    return singular;
+  }
+  const lowerSingular = singular.toLowerCase();
+  let plural;
+  if (/(?:s|ss|sh|ch|x|z)$/.test(lowerSingular)) {
+    plural = singular + "es";
+  } else if (/[^aeiou]y$/.test(lowerSingular)) {
+    plural = singular.slice(0, -1) + "ies";
+  } else if (/[^aeiou]o$/.test(lowerSingular)) {
+    plural = singular + "es";
+  } else if (/fe?$/.test(lowerSingular)) {
+    if (lowerSingular.endsWith("fe")) {
+      plural = singular.slice(0, -2) + "ves";
+    } else {
+      plural = singular.slice(0, -1) + "ves";
+    }
+  } else {
+    plural = singular + "s";
+  }
+  return plural;
+}
+function toCollectionName(entityName) {
+  return pluralize(entityName);
+}
+function singularize(plural) {
+  for (const [singular, pluralForm] of Object.entries(SPECIAL_CASES)) {
+    if (pluralForm === plural) {
+      return singular;
+    }
+  }
+  const lower = plural.toLowerCase();
+  if (lower.endsWith("ies") && plural.length > 3) {
+    return plural.slice(0, -3) + "y";
+  }
+  if (lower.endsWith("ves")) {
+    return plural.slice(0, -3) + "fe";
+  }
+  if (/(?:ses|shes|ches|xes|zes)$/.test(lower)) {
+    return plural.slice(0, -2);
+  }
+  if (lower.endsWith("s") && plural.length > 1) {
+    return plural.slice(0, -1);
+  }
+  return plural;
+}
+function isSingleRelationField(fieldName, zodType) {
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (!(unwrappedType instanceof zod.z.ZodString)) {
+    return false;
+  }
+  const startsWithUppercase = /^[A-Z]/.test(fieldName);
+  const commonStringFields = ["Title", "Name", "Description", "Content", "Summary", "Status", "Type"];
+  const isCommonField = commonStringFields.includes(fieldName);
+  return startsWithUppercase && !isCommonField;
+}
+function isMultipleRelationField(fieldName, zodType) {
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (!(unwrappedType instanceof zod.z.ZodArray)) {
+    return false;
+  }
+  const elementType = unwrappedType._def.type;
+  if (!(elementType instanceof zod.z.ZodString)) {
+    return false;
+  }
+  const hasUppercase = /[A-Z]/.test(fieldName);
+  return hasUppercase;
+}
+function resolveTargetCollection(fieldName) {
+  const matches = fieldName.match(/[A-Z][a-z]+/g);
+  if (!matches || matches.length === 0) {
+    return pluralize(fieldName);
+  }
+  const entityName = matches[matches.length - 1];
+  return pluralize(entityName);
+}
+function isRelationField(fieldName, zodType) {
+  return isSingleRelationField(fieldName, zodType) || isMultipleRelationField(fieldName, zodType);
+}
+function getMaxSelect(fieldName, zodType) {
+  if (isSingleRelationField(fieldName, zodType)) {
+    return 1;
+  }
+  if (isMultipleRelationField(fieldName, zodType)) {
+    let unwrappedType = zodType;
+    if (zodType instanceof zod.z.ZodOptional) {
+      unwrappedType = zodType._def.innerType;
+    }
+    if (unwrappedType instanceof zod.z.ZodNullable) {
+      unwrappedType = unwrappedType._def.innerType;
+    }
+    if (unwrappedType instanceof zod.z.ZodDefault) {
+      unwrappedType = unwrappedType._def.innerType;
+    }
+    if (unwrappedType instanceof zod.z.ZodArray) {
+      const arrayDef = unwrappedType._def;
+      if (arrayDef.maxLength) {
+        return arrayDef.maxLength.value;
+      }
+      return 999;
+    }
+  }
+  return 1;
+}
+function getMinSelect(fieldName, zodType) {
+  if (!isMultipleRelationField(fieldName, zodType)) {
+    return void 0;
+  }
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodArray) {
+    const arrayDef = unwrappedType._def;
+    if (arrayDef.minLength) {
+      return arrayDef.minLength.value;
+    }
+  }
+  return void 0;
+}
+var POCKETBASE_FIELD_TYPES = [
+  "text",
+  "email",
+  "url",
+  "number",
+  "bool",
+  "date",
+  "select",
+  "relation",
+  "file",
+  "json",
+  "editor",
+  "geoPoint",
+  "autodate"
+];
+var FIELD_TYPE_INFO = {
+  text: {
+    type: "text",
+    description: "Plain text field",
+    zodTypes: ["ZodString"],
+    supportsMultiple: false
+  },
+  email: {
+    type: "email",
+    description: "Email address field with validation",
+    zodTypes: ["ZodString with email()"],
+    supportsMultiple: false
+  },
+  url: {
+    type: "url",
+    description: "URL field with validation",
+    zodTypes: ["ZodString with url()"],
+    supportsMultiple: false
+  },
+  editor: {
+    type: "editor",
+    description: "Rich text editor field",
+    zodTypes: ["ZodString"],
+    supportsMultiple: false
+  },
+  number: {
+    type: "number",
+    description: "Numeric field (integer or float)",
+    zodTypes: ["ZodNumber"],
+    supportsMultiple: false
+  },
+  bool: {
+    type: "bool",
+    description: "Boolean field",
+    zodTypes: ["ZodBoolean"],
+    supportsMultiple: false
+  },
+  date: {
+    type: "date",
+    description: "Date/datetime field",
+    zodTypes: ["ZodDate", "ZodString with datetime format"],
+    supportsMultiple: false
+  },
+  autodate: {
+    type: "autodate",
+    description: "Auto-managed date field (created/updated)",
+    zodTypes: ["ZodString"],
+    supportsMultiple: false
+  },
+  select: {
+    type: "select",
+    description: "Single or multiple select from predefined values",
+    zodTypes: ["ZodEnum", "ZodArray<ZodEnum>"],
+    supportsMultiple: true
+  },
+  relation: {
+    type: "relation",
+    description: "Reference to another collection",
+    zodTypes: ["ZodString", "ZodArray<ZodString>"],
+    supportsMultiple: true
+  },
+  file: {
+    type: "file",
+    description: "File upload field",
+    zodTypes: ["File", "ZodArray<File>"],
+    supportsMultiple: true
+  },
+  json: {
+    type: "json",
+    description: "JSON data field",
+    zodTypes: ["ZodRecord", "ZodObject", "ZodArray"],
+    supportsMultiple: false
+  },
+  geoPoint: {
+    type: "geoPoint",
+    description: "Geographic coordinates (lon, lat)",
+    zodTypes: ["ZodObject with lon/lat"],
+    supportsMultiple: false
+  }
+};
+function mapZodStringType(zodType) {
+  const checks = zodType._def.checks || [];
+  const hasEmail = checks.some((check) => check.kind === "email");
+  if (hasEmail) {
+    return "email";
+  }
+  const hasUrl = checks.some((check) => check.kind === "url");
+  if (hasUrl) {
+    return "url";
+  }
+  const hasDatetime = checks.some((check) => check.kind === "datetime");
+  if (hasDatetime) {
+    return "date";
+  }
+  return "text";
+}
+function mapZodNumberType(_zodType) {
+  return "number";
+}
+function mapZodBooleanType(_zodType) {
+  return "bool";
+}
+function mapZodEnumType(_zodType) {
+  return "select";
+}
+function mapZodArrayType(zodType, _fieldName) {
+  const elementType = zodType._def.type;
+  if (elementType instanceof zod.z.ZodType) {
+    const typeName = elementType._def.typeName;
+    if (typeName === "ZodType" && elementType._def?.innerType?.name === "File") {
+      return "file";
+    }
+  }
+  if (elementType._def?.typeName === "ZodType") {
+    const checks = elementType._def?.checks || [];
+    const isFileInstance = checks.some(
+      (check) => check.kind === "instanceof" || elementType._def?.innerType?.name === "File"
+    );
+    if (isFileInstance) {
+      return "file";
+    }
+  }
+  if (elementType instanceof zod.z.ZodString) {
+    return "relation";
+  }
+  return "json";
+}
+function mapZodDateType(_zodType) {
+  return "date";
+}
+function mapZodRecordType(_zodType) {
+  return "json";
+}
+function mapZodTypeToPocketBase(zodType, fieldName) {
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType._def?.typeName === "ZodEffects") {
+    const effect = unwrappedType._def?.effect;
+    if (effect?.type === "refinement") {
+      const fileFieldNames = ["avatar", "image", "file", "attachment", "photo", "picture", "document", "upload"];
+      if (fileFieldNames.some((name) => fieldName.toLowerCase().includes(name))) {
+        return "file";
+      }
+    }
+  }
+  if (unwrappedType._def?.typeName === "ZodType") {
+    const checks = unwrappedType._def?.checks || [];
+    const innerType = unwrappedType._def?.innerType;
+    if (innerType?.name === "File" || checks.some((check) => check.kind === "instanceof")) {
+      return "file";
+    }
+  }
+  if (unwrappedType instanceof zod.z.ZodString) {
+    return mapZodStringType(unwrappedType);
+  }
+  if (unwrappedType instanceof zod.z.ZodNumber) {
+    return mapZodNumberType();
+  }
+  if (unwrappedType instanceof zod.z.ZodBoolean) {
+    return mapZodBooleanType();
+  }
+  if (unwrappedType instanceof zod.z.ZodEnum) {
+    return mapZodEnumType();
+  }
+  if (unwrappedType instanceof zod.z.ZodArray) {
+    return mapZodArrayType(unwrappedType);
+  }
+  if (unwrappedType instanceof zod.z.ZodDate) {
+    return mapZodDateType();
+  }
+  if (unwrappedType instanceof zod.z.ZodRecord || unwrappedType instanceof zod.z.ZodObject) {
+    return mapZodRecordType();
+  }
+  return "text";
+}
+function extractFieldOptions(zodType) {
+  const options = {};
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  const checks = unwrappedType._def?.checks || [];
+  if (unwrappedType instanceof zod.z.ZodString) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+      if (check.kind === "regex") {
+        options.pattern = check.regex.source;
+      }
+    }
+  }
+  if (unwrappedType instanceof zod.z.ZodNumber) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+    }
+  }
+  if (unwrappedType instanceof zod.z.ZodEnum) {
+    options.values = unwrappedType._def.values;
+  }
+  if (unwrappedType instanceof zod.z.ZodArray) {
+    const arrayChecks = unwrappedType._def?.checks || [];
+    for (const check of arrayChecks) {
+      if (check.kind === "min") {
+        options.minSelect = check.value;
+      }
+      if (check.kind === "max") {
+        options.maxSelect = check.value;
+      }
+    }
+  }
+  return options;
+}
+function isFieldRequired(zodType) {
+  if (zodType instanceof zod.z.ZodOptional) {
+    return false;
+  }
+  if (zodType instanceof zod.z.ZodDefault) {
+    return false;
+  }
+  if (zodType instanceof zod.z.ZodNullable) {
+    return false;
+  }
+  return true;
+}
+function unwrapZodType(zodType) {
+  let unwrapped = zodType;
+  if (unwrapped instanceof zod.z.ZodOptional) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  if (unwrapped instanceof zod.z.ZodNullable) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  if (unwrapped instanceof zod.z.ZodDefault) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  return unwrapped;
+}
+function getDefaultValue(zodType) {
+  if (zodType instanceof zod.z.ZodDefault) {
+    return zodType._def.defaultValue();
+  }
+  return void 0;
+}
+function isArrayType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  return unwrapped instanceof zod.z.ZodArray;
+}
+function getArrayElementType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  if (unwrapped instanceof zod.z.ZodArray) {
+    return unwrapped._def.type;
+  }
+  return null;
+}
+function isGeoPointType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  if (!(unwrapped instanceof zod.z.ZodObject)) {
+    return false;
+  }
+  const shape = unwrapped._def.shape();
+  const hasLon = "lon" in shape && shape.lon instanceof zod.z.ZodNumber;
+  const hasLat = "lat" in shape && shape.lat instanceof zod.z.ZodNumber;
+  return hasLon && hasLat;
+}
+function extractComprehensiveFieldOptions(zodType) {
+  const options = {};
+  const unwrapped = unwrapZodType(zodType);
+  const checks = unwrapped._def?.checks || [];
+  if (unwrapped instanceof zod.z.ZodString) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+      if (check.kind === "regex") {
+        options.pattern = check.regex.source;
+      }
+    }
+  }
+  if (unwrapped instanceof zod.z.ZodNumber) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+    }
+  }
+  if (unwrapped instanceof zod.z.ZodEnum) {
+    options.values = unwrapped._def.values;
+  }
+  if (unwrapped instanceof zod.z.ZodArray) {
+    const arrayDef = unwrapped._def;
+    if (arrayDef.minLength) {
+      options.minSelect = arrayDef.minLength.value;
+    }
+    if (arrayDef.maxLength) {
+      options.maxSelect = arrayDef.maxLength.value;
+    }
+    const elementType = arrayDef.type;
+    if (elementType instanceof zod.z.ZodEnum) {
+      options.values = elementType._def.values;
+    }
+  }
+  return options;
+}
+function isEditorField(fieldName) {
+  const editorFieldNames = [
+    "content",
+    "body",
+    "description",
+    "bio",
+    "about",
+    "summary",
+    "notes",
+    "details",
+    "html",
+    "richtext",
+    "editor"
+  ];
+  return editorFieldNames.some((name) => fieldName.toLowerCase().includes(name));
+}
+function isFileFieldByName(fieldName) {
+  const fileFieldNames = [
+    "avatar",
+    "image",
+    "file",
+    "attachment",
+    "photo",
+    "picture",
+    "document",
+    "upload",
+    "thumbnail",
+    "cover",
+    "banner",
+    "logo",
+    "icon",
+    "media"
+  ];
+  return fileFieldNames.some((name) => fieldName.toLowerCase().includes(name));
+}
+function getFieldTypeInfo(zodType, fieldName) {
+  const type = mapZodTypeToPocketBase(zodType, fieldName);
+  const isMultiple = isArrayType(zodType);
+  const options = extractComprehensiveFieldOptions(zodType);
+  return {
+    type,
+    isMultiple,
+    options
+  };
+}
+
+// src/migration/analyzer.ts
+var DEFAULT_CONFIG = {
+  workspaceRoot: process.cwd(),
+  excludePatterns: [
+    "base.ts",
+    "index.ts",
+    "permissions.ts",
+    "permission-templates.ts",
+    "base.js",
+    "index.js",
+    "permissions.js",
+    "permission-templates.js"
+  ],
+  includeExtensions: [".ts", ".js"],
+  schemaPatterns: ["Schema", "InputSchema"],
+  useCompiledFiles: true
+};
+function mergeConfig(config) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    excludePatterns: config.excludePatterns || DEFAULT_CONFIG.excludePatterns,
+    includeExtensions: config.includeExtensions || DEFAULT_CONFIG.includeExtensions,
+    schemaPatterns: config.schemaPatterns || DEFAULT_CONFIG.schemaPatterns
+  };
+}
+function resolveSchemaDir(config) {
+  const workspaceRoot = config.workspaceRoot || process.cwd();
+  if (path__namespace.isAbsolute(config.schemaDir)) {
+    return config.schemaDir;
+  }
+  return path__namespace.join(workspaceRoot, config.schemaDir);
+}
+function discoverSchemaFiles(config) {
+  const normalizedConfig = typeof config === "string" ? { schemaDir: config } : config;
+  const mergedConfig = mergeConfig(normalizedConfig);
+  const schemaDir = resolveSchemaDir(normalizedConfig);
+  try {
+    if (!fs2__namespace.existsSync(schemaDir)) {
+      throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
+    }
+    const files = fs2__namespace.readdirSync(schemaDir);
+    const schemaFiles = files.filter((file) => {
+      const hasValidExtension = mergedConfig.includeExtensions.some((ext) => file.endsWith(ext));
+      if (!hasValidExtension) return false;
+      const isExcluded = mergedConfig.excludePatterns.some((pattern) => {
+        if (pattern.includes("*")) {
+          const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+          return regex.test(file);
+        }
+        return file === pattern;
+      });
+      if (isExcluded) return false;
+      return true;
+    });
+    return schemaFiles.map((file) => {
+      const ext = mergedConfig.includeExtensions.find((ext2) => file.endsWith(ext2)) || ".ts";
+      return path__namespace.join(schemaDir, file.replace(new RegExp(`\\${ext}$`), ""));
+    });
+  } catch (error) {
+    if (error instanceof FileSystemError) {
+      throw error;
+    }
+    const fsError = error;
+    if (fsError.code === "EACCES" || fsError.code === "EPERM") {
+      throw new FileSystemError(
+        `Permission denied reading schema directory: ${schemaDir}`,
+        schemaDir,
+        "read",
+        fsError.code,
+        error
+      );
+    }
+    throw new FileSystemError(
+      `Failed to read schema directory: ${schemaDir}`,
+      schemaDir,
+      "read",
+      fsError.code,
+      error
+    );
+  }
+}
+async function importSchemaModule(filePath, config) {
+  try {
+    let importPath = filePath;
+    if (config?.pathTransformer) {
+      importPath = config.pathTransformer(filePath);
+    }
+    if (!importPath.endsWith(".js")) {
+      importPath = `${importPath}.js`;
+    }
+    const fileUrl = new URL(`file://${path__namespace.resolve(importPath)}`);
+    const module = await import(fileUrl.href);
+    return module;
+  } catch (error) {
+    throw new SchemaParsingError(
+      `Failed to import schema module. Make sure the schema files are compiled to JavaScript.`,
+      filePath,
+      error
+    );
+  }
+}
+function getCollectionNameFromFile(filePath) {
+  const filename = path__namespace.basename(filePath).replace(/\.(ts|js)$/, "");
+  return toCollectionName(filename);
+}
+function extractSchemaDefinitions(module, patterns = ["Schema", "InputSchema"]) {
+  const result = {};
+  for (const [key, value] of Object.entries(module)) {
+    if (value instanceof zod.z.ZodObject) {
+      if (patterns.includes("InputSchema") && key.endsWith("InputSchema")) {
+        result.inputSchema = value;
+      } else if (patterns.includes("Schema") && key.endsWith("Schema") && !key.endsWith("InputSchema")) {
+        result.schema = value;
+      }
+    }
+  }
+  return result;
+}
+function selectSchemaForCollection(schemas) {
+  if (schemas.schema) {
+    return schemas.schema;
+  }
+  if (schemas.inputSchema) {
+    return schemas.inputSchema;
+  }
+  return null;
+}
+function extractFieldDefinitions(zodSchema, excludeFields) {
+  const shape = zodSchema.shape;
+  const fields = [];
+  const baseFields = ["id", "collectionId", "collectionName", "created", "updated", "expand"];
+  const defaultExcludeFields = ["thumbnailURL", "imageFiles"];
+  const allExclusions = /* @__PURE__ */ new Set([...baseFields, ...defaultExcludeFields, ...excludeFields || []]);
+  for (const [fieldName, zodType] of Object.entries(shape)) {
+    if (!allExclusions.has(fieldName)) {
+      fields.push({ name: fieldName, zodType });
+    }
+  }
+  return fields;
+}
+function isAuthCollection(fields) {
+  const fieldNames = fields.map((f) => f.name.toLowerCase());
+  const hasEmail = fieldNames.includes("email");
+  const hasPassword = fieldNames.includes("password");
+  return hasEmail && hasPassword;
+}
+function buildFieldDefinition(fieldName, zodType) {
+  const fieldType = mapZodTypeToPocketBase(zodType, fieldName);
+  const required = isFieldRequired(zodType);
+  const options = extractFieldOptions(zodType);
+  const fieldDef = {
+    name: fieldName,
+    type: fieldType,
+    required,
+    options
+  };
+  if (isRelationField(fieldName, zodType)) {
+    fieldDef.type = "relation";
+    const targetCollection = resolveTargetCollection(fieldName);
+    const maxSelect = getMaxSelect(fieldName, zodType);
+    const minSelect = getMinSelect(fieldName, zodType);
+    fieldDef.relation = {
+      collection: targetCollection,
+      maxSelect,
+      minSelect,
+      cascadeDelete: false
+      // Default to false, can be configured later
+    };
+  }
+  return fieldDef;
+}
+function extractIndexes(schema) {
+  const schemaDescription = schema.description;
+  if (!schemaDescription) {
+    return void 0;
+  }
+  try {
+    const metadata = JSON.parse(schemaDescription);
+    if (metadata.indexes && Array.isArray(metadata.indexes)) {
+      return metadata.indexes;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function convertZodSchemaToCollectionSchema(collectionName, zodSchema) {
+  const rawFields = extractFieldDefinitions(zodSchema);
+  const collectionType = isAuthCollection(rawFields) ? "auth" : "base";
+  const fields = rawFields.map(({ name, zodType }) => buildFieldDefinition(name, zodType));
+  const indexes = extractIndexes(zodSchema) || [];
+  const permissionAnalyzer = new PermissionAnalyzer();
+  let permissions = void 0;
+  const schemaDescription = zodSchema.description;
+  const extractedPermissions = permissionAnalyzer.extractPermissions(schemaDescription);
+  if (extractedPermissions) {
+    const resolvedPermissions = permissionAnalyzer.resolvePermissions(extractedPermissions);
+    const validationResults = permissionAnalyzer.validatePermissions(
+      collectionName,
+      resolvedPermissions,
+      fields,
+      collectionType === "auth"
+    );
+    for (const [ruleType, result] of validationResults) {
+      if (!result.valid) {
+        console.error(`[${collectionName}] Permission validation failed for ${ruleType}:`);
+        result.errors.forEach((error) => console.error(`  - ${error}`));
+      }
+      if (result.warnings.length > 0) {
+        console.warn(`[${collectionName}] Permission warnings for ${ruleType}:`);
+        result.warnings.forEach((warning) => console.warn(`  - ${warning}`));
+      }
+    }
+    permissions = permissionAnalyzer.mergeWithDefaults(resolvedPermissions);
+  }
+  const collectionSchema = {
+    name: collectionName,
+    type: collectionType,
+    fields,
+    indexes,
+    rules: {
+      listRule: null,
+      viewRule: null,
+      createRule: null,
+      updateRule: null,
+      deleteRule: null
+    },
+    permissions
+  };
+  return collectionSchema;
+}
+async function buildSchemaDefinition(config) {
+  const normalizedConfig = typeof config === "string" ? { schemaDir: config } : config;
+  const mergedConfig = mergeConfig(normalizedConfig);
+  const collections = /* @__PURE__ */ new Map();
+  const schemaFiles = discoverSchemaFiles(normalizedConfig);
+  if (schemaFiles.length === 0) {
+    const schemaDir = resolveSchemaDir(normalizedConfig);
+    throw new SchemaParsingError(
+      `No schema files found in ${schemaDir}. Make sure you have schema files in the directory.`,
+      schemaDir
+    );
+  }
+  for (const filePath of schemaFiles) {
+    try {
+      let importPath = filePath;
+      if (normalizedConfig.pathTransformer) {
+        importPath = normalizedConfig.pathTransformer(filePath);
+      } else if (mergedConfig.useCompiledFiles) {
+        importPath = filePath.replace(/\/src\//, "/dist/");
+      }
+      const module = await importSchemaModule(importPath, normalizedConfig);
+      const schemas = extractSchemaDefinitions(module, mergedConfig.schemaPatterns);
+      const zodSchema = selectSchemaForCollection(schemas);
+      if (!zodSchema) {
+        console.warn(`No valid schema found in ${filePath}, skipping...`);
+        continue;
+      }
+      const collectionName = getCollectionNameFromFile(filePath);
+      const collectionSchema = convertZodSchemaToCollectionSchema(collectionName, zodSchema);
+      collections.set(collectionName, collectionSchema);
+    } catch (error) {
+      if (error instanceof SchemaParsingError) {
+        throw error;
+      }
+      throw new SchemaParsingError(
+        `Error processing schema file: ${error instanceof Error ? error.message : String(error)}`,
+        filePath,
+        error
+      );
+    }
+  }
+  return { collections };
+}
+async function parseSchemaFiles(config) {
+  return buildSchemaDefinition(config);
+}
+var SchemaAnalyzer = class {
+  config;
+  constructor(config) {
+    this.config = mergeConfig(config);
+  }
+  /**
+   * Discovers schema files in the configured directory
+   */
+  discoverSchemaFiles() {
+    return discoverSchemaFiles(this.config);
+  }
+  /**
+   * Parses all schema files and returns a SchemaDefinition
+   */
+  async parseSchemaFiles() {
+    return buildSchemaDefinition(this.config);
+  }
+  /**
+   * Converts a single Zod schema to a CollectionSchema
+   */
+  convertZodSchemaToCollectionSchema(name, schema) {
+    return convertZodSchemaToCollectionSchema(name, schema);
+  }
+};
+var SNAPSHOT_VERSION = "1.0.0";
+var DEFAULT_SNAPSHOT_FILENAME = ".migration-snapshot.json";
+var SNAPSHOT_MIGRATIONS = [
+  // Add migrations here as the format evolves
+  // Example:
+  // {
+  //   fromVersion: '0.9.0',
+  //   toVersion: '1.0.0',
+  //   migrate: (data) => ({ ...data, newField: 'default' })
+  // }
+];
+var DEFAULT_CONFIG2 = {
+  snapshotPath: DEFAULT_SNAPSHOT_FILENAME,
+  workspaceRoot: process.cwd(),
+  autoMigrate: true,
+  version: SNAPSHOT_VERSION
+};
+function mergeConfig2(config = {}) {
+  return {
+    ...DEFAULT_CONFIG2,
+    ...config
+  };
+}
+function getSnapshotPath(config = {}) {
+  const mergedConfig = mergeConfig2(config);
+  const workspaceRoot = mergedConfig.workspaceRoot;
+  const snapshotFilename = mergedConfig.snapshotPath;
+  if (path__namespace.isAbsolute(snapshotFilename)) {
+    return snapshotFilename;
+  }
+  return path__namespace.join(workspaceRoot, snapshotFilename);
+}
+function snapshotExists(config = {}) {
+  try {
+    const snapshotPath = getSnapshotPath(config);
+    return fs2__namespace.existsSync(snapshotPath);
+  } catch {
+    return false;
+  }
+}
+function handleFileSystemError(error, operation, filePath) {
+  const fsError = error;
+  if (fsError.code === "ENOENT") {
+    throw new SnapshotError(`Snapshot file not found: ${filePath}`, filePath, operation, error);
+  } else if (fsError.code === "EACCES" || fsError.code === "EPERM") {
+    throw new FileSystemError(
+      `Permission denied ${operation === "read" ? "reading" : "writing"} snapshot file. Check file permissions.`,
+      filePath,
+      operation,
+      fsError.code,
+      error
+    );
+  } else if (fsError.code === "ENOSPC") {
+    throw new FileSystemError(
+      `No space left on device when ${operation === "read" ? "reading" : "writing"} snapshot file.`,
+      filePath,
+      operation,
+      fsError.code,
+      error
+    );
+  } else {
+    throw new SnapshotError(`Failed to ${operation} snapshot file: ${error.message}`, filePath, operation, error);
+  }
+}
+function serializeMap(map) {
+  const obj = {};
+  for (const [key, value] of map.entries()) {
+    obj[key] = value;
+  }
+  return obj;
+}
+function deserializeMap(obj) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(obj)) {
+    map.set(key, value);
+  }
+  return map;
+}
+function serializeSchemaDefinition(schema) {
+  return {
+    collections: serializeMap(schema.collections)
+  };
+}
+function addSnapshotMetadata(schema, config) {
+  const mergedConfig = mergeConfig2(config);
+  return {
+    version: mergedConfig.version,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...serializeSchemaDefinition(schema)
+  };
+}
+function saveSnapshot(schema, config = {}) {
+  const snapshotPath = getSnapshotPath(config);
+  try {
+    const snapshotDir = path__namespace.dirname(snapshotPath);
+    if (!fs2__namespace.existsSync(snapshotDir)) {
+      fs2__namespace.mkdirSync(snapshotDir, { recursive: true });
+    }
+    const snapshotData = addSnapshotMetadata(schema, config);
+    const jsonContent = JSON.stringify(snapshotData, null, 2);
+    fs2__namespace.writeFileSync(snapshotPath, jsonContent, "utf-8");
+  } catch (error) {
+    handleFileSystemError(error, "write", snapshotPath);
+  }
+}
+function parseAndValidateSnapshot(jsonContent, snapshotPath) {
+  try {
+    const data = JSON.parse(jsonContent);
+    if (!data.version) {
+      throw new SnapshotError(
+        "Snapshot file is missing version field. The snapshot may be corrupted.",
+        snapshotPath,
+        "validate"
+      );
+    }
+    if (!data.timestamp) {
+      throw new SnapshotError(
+        "Snapshot file is missing timestamp field. The snapshot may be corrupted.",
+        snapshotPath,
+        "validate"
+      );
+    }
+    if (!data.collections) {
+      throw new SnapshotError(
+        "Snapshot file is missing collections field. The snapshot may be corrupted.",
+        snapshotPath,
+        "validate"
+      );
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof SnapshotError) {
+      throw error;
+    }
+    if (error instanceof SyntaxError) {
+      throw new SnapshotError(
+        `Invalid JSON in snapshot file. The file may be corrupted or manually edited incorrectly.`,
+        snapshotPath,
+        "parse",
+        error
+      );
+    }
+    throw error;
+  }
+}
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  return 0;
+}
+function migrateSnapshotFormat(data, config) {
+  const mergedConfig = mergeConfig2(config);
+  const currentVersion = data.version;
+  const targetVersion = mergedConfig.version;
+  if (currentVersion === targetVersion) {
+    return data;
+  }
+  if (!mergedConfig.autoMigrate) {
+    console.warn(
+      `Snapshot version ${currentVersion} differs from current ${targetVersion}, but auto-migrate is disabled.`
+    );
+    return data;
+  }
+  let migratedData = { ...data };
+  let currentMigrationVersion = currentVersion;
+  const sortedMigrations = [...SNAPSHOT_MIGRATIONS].sort((a, b) => compareVersions(a.fromVersion, b.fromVersion));
+  for (const migration of sortedMigrations) {
+    if (compareVersions(currentMigrationVersion, migration.fromVersion) === 0) {
+      console.log(`Migrating snapshot from ${migration.fromVersion} to ${migration.toVersion}...`);
+      migratedData = migration.migrate(migratedData);
+      migratedData.version = migration.toVersion;
+      currentMigrationVersion = migration.toVersion;
+    }
+  }
+  if (compareVersions(currentMigrationVersion, targetVersion) !== 0) {
+    console.warn(`Unknown snapshot version ${currentVersion}, attempting to load anyway...`);
+  }
+  return migratedData;
+}
+function deserializeSnapshot(data) {
+  return {
+    version: data.version,
+    timestamp: data.timestamp,
+    collections: deserializeMap(data.collections)
+  };
+}
+function loadSnapshot(config = {}) {
+  const snapshotPath = getSnapshotPath(config);
+  try {
+    const jsonContent = fs2__namespace.readFileSync(snapshotPath, "utf-8");
+    const data = parseAndValidateSnapshot(jsonContent, snapshotPath);
+    const migratedData = migrateSnapshotFormat(data, config);
+    return deserializeSnapshot(migratedData);
+  } catch (error) {
+    if (error instanceof SnapshotError || error instanceof FileSystemError) {
+      throw error;
+    }
+    if (error.code === "ENOENT") {
+      throw new SnapshotError(
+        `Snapshot file not found. This may be the first migration run.`,
+        snapshotPath,
+        "read",
+        error
+      );
+    }
+    handleFileSystemError(error, "read", snapshotPath);
+  }
+}
+function mergeSnapshots(baseSnapshot, customSnapshot) {
+  if (!customSnapshot) {
+    return baseSnapshot;
+  }
+  const mergedCollections = new Map(baseSnapshot.collections);
+  for (const [name, schema] of customSnapshot.collections.entries()) {
+    mergedCollections.set(name, schema);
+  }
+  return {
+    version: customSnapshot.version || baseSnapshot.version,
+    timestamp: customSnapshot.timestamp || baseSnapshot.timestamp,
+    collections: mergedCollections
+  };
+}
+function findLatestSnapshot(migrationsPath) {
+  try {
+    if (!fs2__namespace.existsSync(migrationsPath)) {
+      return null;
+    }
+    const files = fs2__namespace.readdirSync(migrationsPath);
+    const snapshotFiles = files.filter(
+      (file) => file.endsWith("_collections_snapshot.js") || file.endsWith("_snapshot.js")
+    );
+    if (snapshotFiles.length === 0) {
+      return null;
+    }
+    snapshotFiles.sort().reverse();
+    const latestSnapshot = snapshotFiles[0];
+    if (!latestSnapshot) {
+      return null;
+    }
+    return path__namespace.join(migrationsPath, latestSnapshot);
+  } catch (error) {
+    console.warn(`Error finding latest snapshot: ${error}`);
+    return null;
+  }
+}
+function loadSnapshotIfExists(config = {}) {
+  const migrationsPath = config.migrationsPath;
+  if (!migrationsPath) {
+    return null;
+  }
+  if (fs2__namespace.existsSync(migrationsPath) && fs2__namespace.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs2__namespace.readFileSync(migrationsPath, "utf-8");
+      return convertPocketBaseMigration(migrationContent);
+    } catch (error) {
+      console.warn(`Failed to load snapshot from ${migrationsPath}: ${error}`);
+      return null;
+    }
+  }
+  const latestSnapshotPath = findLatestSnapshot(migrationsPath);
+  if (latestSnapshotPath) {
+    try {
+      const migrationContent = fs2__namespace.readFileSync(latestSnapshotPath, "utf-8");
+      return convertPocketBaseMigration(migrationContent);
+    } catch (error) {
+      console.warn(`Failed to load snapshot from ${latestSnapshotPath}: ${error}`);
+      return null;
+    }
+  }
+  return null;
+}
+function convertPocketBaseCollection(pbCollection) {
+  const fields = [];
+  const systemFieldNames = ["id", "created", "updated", "collectionId", "collectionName", "expand"];
+  const authSystemFieldNames = ["email", "emailVisibility", "verified", "password", "tokenKey"];
+  if (pbCollection.fields && Array.isArray(pbCollection.fields)) {
+    for (const pbField of pbCollection.fields) {
+      if (pbField.system || systemFieldNames.includes(pbField.name)) {
+        continue;
+      }
+      if (pbCollection.type === "auth" && authSystemFieldNames.includes(pbField.name)) {
+        continue;
+      }
+      const field = {
+        name: pbField.name,
+        type: pbField.type,
+        required: pbField.required || false
+      };
+      if (pbField.options) {
+        field.options = pbField.options;
+      }
+      if (pbField.type === "relation") {
+        field.relation = {
+          collection: pbField.options?.collectionId || "",
+          cascadeDelete: pbField.options?.cascadeDelete || false,
+          maxSelect: pbField.options?.maxSelect,
+          minSelect: pbField.options?.minSelect
+        };
+      }
+      fields.push(field);
+    }
+  }
+  const schema = {
+    name: pbCollection.name,
+    type: pbCollection.type || "base",
+    fields
+  };
+  if (pbCollection.indexes && Array.isArray(pbCollection.indexes)) {
+    schema.indexes = pbCollection.indexes;
+  }
+  const rules = {};
+  if (pbCollection.listRule !== void 0) rules.listRule = pbCollection.listRule;
+  if (pbCollection.viewRule !== void 0) rules.viewRule = pbCollection.viewRule;
+  if (pbCollection.createRule !== void 0) rules.createRule = pbCollection.createRule;
+  if (pbCollection.updateRule !== void 0) rules.updateRule = pbCollection.updateRule;
+  if (pbCollection.deleteRule !== void 0) rules.deleteRule = pbCollection.deleteRule;
+  if (pbCollection.manageRule !== void 0) rules.manageRule = pbCollection.manageRule;
+  if (Object.keys(rules).length > 0) {
+    schema.rules = rules;
+  }
+  return schema;
+}
+function convertPocketBaseMigration(migrationContent) {
+  try {
+    const snapshotMatch = migrationContent.match(/const\s+snapshot\s*=\s*(\[[\s\S]*?\]);/);
+    if (!snapshotMatch) {
+      throw new Error("Could not find snapshot array in migration file");
+    }
+    const snapshotArrayStr = snapshotMatch[1];
+    let snapshotArray;
+    try {
+      snapshotArray = new Function(`return ${snapshotArrayStr}`)();
+    } catch (parseError) {
+      throw new Error(`Failed to parse snapshot array: ${parseError}`);
+    }
+    if (!Array.isArray(snapshotArray)) {
+      throw new Error("Snapshot is not an array");
+    }
+    const collections = /* @__PURE__ */ new Map();
+    for (const pbCollection of snapshotArray) {
+      if (!pbCollection.name) {
+        console.warn("Skipping collection without name");
+        continue;
+      }
+      const schema = convertPocketBaseCollection(pbCollection);
+      collections.set(pbCollection.name, schema);
+    }
+    return {
+      version: SNAPSHOT_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      collections
+    };
+  } catch (error) {
+    throw new SnapshotError(
+      `Failed to convert PocketBase migration: ${error instanceof Error ? error.message : String(error)}`,
+      void 0,
+      "parse",
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function loadBaseMigration(migrationPath) {
+  try {
+    if (!fs2__namespace.existsSync(migrationPath)) {
+      throw new SnapshotError(
+        `Base migration file not found: ${migrationPath}
+
+This file should contain PocketBase's initial schema.
+Please ensure PocketBase is properly set up by running 'yarn setup'.
+If the file exists in a different location, update the configuration.`,
+        migrationPath,
+        "read"
+      );
+    }
+    const migrationContent = fs2__namespace.readFileSync(migrationPath, "utf-8");
+    const snapshot = convertPocketBaseMigration(migrationContent);
+    return snapshot;
+  } catch (error) {
+    if (error instanceof SnapshotError) {
+      throw error;
+    }
+    if (error.code === "ENOENT") {
+      throw new SnapshotError(
+        `Base migration file not found: ${migrationPath}
+
+This file should contain PocketBase's initial schema.
+Please ensure PocketBase is properly set up by running 'yarn setup'.`,
+        migrationPath,
+        "read",
+        error
+      );
+    }
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      throw new FileSystemError(
+        `Permission denied reading base migration file. Check file permissions.`,
+        migrationPath,
+        "read",
+        error.code,
+        error
+      );
+    }
+    throw new SnapshotError(
+      `Failed to load base migration: ${error instanceof Error ? error.message : String(error)}`,
+      migrationPath,
+      "read",
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function getSnapshotVersion() {
+  return SNAPSHOT_VERSION;
+}
+function validateSnapshot(snapshot) {
+  const issues = [];
+  if (!snapshot.version) {
+    issues.push("Missing version field");
+  } else if (compareVersions(snapshot.version, SNAPSHOT_VERSION) > 0) {
+    issues.push(`Snapshot version ${snapshot.version} is newer than supported version ${SNAPSHOT_VERSION}`);
+  }
+  if (!snapshot.timestamp) {
+    issues.push("Missing timestamp field");
+  }
+  if (!snapshot.collections) {
+    issues.push("Missing collections field");
+  } else if (!(snapshot.collections instanceof Map)) {
+    issues.push("Collections field is not a Map");
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+var SnapshotManager = class {
+  config;
+  constructor(config = {}) {
+    this.config = mergeConfig2(config);
+  }
+  /**
+   * Loads the current snapshot
+   */
+  loadSnapshot() {
+    return loadSnapshot(this.config);
+  }
+  /**
+   * Saves a schema as a snapshot
+   */
+  saveSnapshot(schema) {
+    saveSnapshot(schema, this.config);
+  }
+  /**
+   * Loads snapshot if it exists, returns null otherwise
+   */
+  loadSnapshotIfExists() {
+    return loadSnapshotIfExists(this.config);
+  }
+  /**
+   * Checks if a snapshot exists
+   */
+  snapshotExists() {
+    return snapshotExists(this.config);
+  }
+  /**
+   * Converts a PocketBase migration to a snapshot
+   */
+  convertPocketBaseMigration(content) {
+    return convertPocketBaseMigration(content);
+  }
+  /**
+   * Gets the snapshot file path
+   */
+  getSnapshotPath() {
+    return getSnapshotPath(this.config);
+  }
+  /**
+   * Validates a snapshot
+   */
+  validateSnapshot(snapshot) {
+    return validateSnapshot(snapshot);
+  }
+};
+
+// src/migration/diff.ts
+var DEFAULT_CONFIG3 = {
+  warnOnDelete: true,
+  requireForceForDestructive: true,
+  severityThreshold: "high",
+  systemCollections: ["_mfas", "_otps", "_externalAuths", "_authOrigins", "_superusers"],
+  usersSystemFields: ["id", "password", "tokenKey", "email", "emailVisibility", "verified", "created", "updated"]
+};
+function mergeConfig3(config) {
+  return {
+    ...DEFAULT_CONFIG3,
+    ...config
+  };
+}
+function isSystemCollection(collectionName, config) {
+  const mergedConfig = mergeConfig3(config);
+  return mergedConfig.systemCollections.includes(collectionName);
+}
+function getUsersSystemFields(config) {
+  const mergedConfig = mergeConfig3(config);
+  return new Set(mergedConfig.usersSystemFields);
+}
+function filterSystemCollections(schema, config) {
+  const filteredCollections = /* @__PURE__ */ new Map();
+  for (const [collectionName, collectionSchema] of schema.collections) {
+    if (!isSystemCollection(collectionName, config)) {
+      filteredCollections.set(collectionName, collectionSchema);
+    }
+  }
+  return {
+    collections: filteredCollections
+  };
+}
+function findNewCollections(currentSchema, previousSnapshot) {
+  const newCollections = [];
+  if (!previousSnapshot) {
+    return Array.from(currentSchema.collections.values());
+  }
+  for (const [collectionName, collectionSchema] of currentSchema.collections) {
+    if (!previousSnapshot.collections.has(collectionName)) {
+      newCollections.push(collectionSchema);
+    }
+  }
+  return newCollections;
+}
+function findRemovedCollections(currentSchema, previousSnapshot) {
+  const removedCollections = [];
+  if (!previousSnapshot) {
+    return removedCollections;
+  }
+  for (const [collectionName, collectionSchema] of previousSnapshot.collections) {
+    if (!currentSchema.collections.has(collectionName)) {
+      removedCollections.push(collectionSchema);
+    }
+  }
+  return removedCollections;
+}
+function matchCollectionsByName(currentSchema, previousSnapshot) {
+  const matches = [];
+  if (!previousSnapshot) {
+    return matches;
+  }
+  for (const [collectionName, currentCollection] of currentSchema.collections) {
+    const previousCollection = previousSnapshot.collections.get(collectionName);
+    if (previousCollection) {
+      matches.push([currentCollection, previousCollection]);
+    }
+  }
+  return matches;
+}
+function findNewFields(currentFields, previousFields) {
+  const newFields = [];
+  const previousFieldNames = new Set(previousFields.map((f) => f.name));
+  for (const currentField of currentFields) {
+    if (!previousFieldNames.has(currentField.name)) {
+      newFields.push(currentField);
+    }
+  }
+  return newFields;
+}
+function findRemovedFields(currentFields, previousFields) {
+  const removedFields = [];
+  const currentFieldNames = new Set(currentFields.map((f) => f.name));
+  for (const previousField of previousFields) {
+    if (!currentFieldNames.has(previousField.name)) {
+      removedFields.push(previousField);
+    }
+  }
+  return removedFields;
+}
+function matchFieldsByName(currentFields, previousFields) {
+  const matches = [];
+  const previousFieldMap = /* @__PURE__ */ new Map();
+  for (const previousField of previousFields) {
+    previousFieldMap.set(previousField.name, previousField);
+  }
+  for (const currentField of currentFields) {
+    const previousField = previousFieldMap.get(currentField.name);
+    if (previousField) {
+      matches.push([currentField, previousField]);
+    }
+  }
+  return matches;
+}
+function areValuesEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, idx) => areValuesEqual(val, b[idx]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => areValuesEqual(a[key], b[key]));
+  }
+  return a === b;
+}
+function compareFieldTypes(currentField, previousField) {
+  if (currentField.type !== previousField.type) {
+    return {
+      property: "type",
+      oldValue: previousField.type,
+      newValue: currentField.type
+    };
+  }
+  return null;
+}
+function compareFieldConstraints(currentField, previousField) {
+  const changes = [];
+  if (currentField.required !== previousField.required) {
+    changes.push({
+      property: "required",
+      oldValue: previousField.required,
+      newValue: currentField.required
+    });
+  }
+  if (currentField.unique !== previousField.unique) {
+    changes.push({
+      property: "unique",
+      oldValue: previousField.unique,
+      newValue: currentField.unique
+    });
+  }
+  return changes;
+}
+function compareFieldOptions(currentField, previousField) {
+  const changes = [];
+  const currentOptions = currentField.options || {};
+  const previousOptions = previousField.options || {};
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(currentOptions), ...Object.keys(previousOptions)]);
+  for (const key of allKeys) {
+    const currentValue = currentOptions[key];
+    const previousValue = previousOptions[key];
+    if (!areValuesEqual(currentValue, previousValue)) {
+      changes.push({
+        property: `options.${key}`,
+        oldValue: previousValue,
+        newValue: currentValue
+      });
+    }
+  }
+  return changes;
+}
+function compareRelationConfigurations(currentField, previousField) {
+  const changes = [];
+  const currentRelation = currentField.relation;
+  const previousRelation = previousField.relation;
+  if (!currentRelation && !previousRelation) {
+    return changes;
+  }
+  if (!currentRelation || !previousRelation) {
+    return changes;
+  }
+  if (currentRelation.collection !== previousRelation.collection) {
+    changes.push({
+      property: "relation.collection",
+      oldValue: previousRelation.collection,
+      newValue: currentRelation.collection
+    });
+  }
+  if (currentRelation.cascadeDelete !== previousRelation.cascadeDelete) {
+    changes.push({
+      property: "relation.cascadeDelete",
+      oldValue: previousRelation.cascadeDelete,
+      newValue: currentRelation.cascadeDelete
+    });
+  }
+  if (currentRelation.maxSelect !== previousRelation.maxSelect) {
+    changes.push({
+      property: "relation.maxSelect",
+      oldValue: previousRelation.maxSelect,
+      newValue: currentRelation.maxSelect
+    });
+  }
+  if (currentRelation.minSelect !== previousRelation.minSelect) {
+    changes.push({
+      property: "relation.minSelect",
+      oldValue: previousRelation.minSelect,
+      newValue: currentRelation.minSelect
+    });
+  }
+  return changes;
+}
+function detectFieldChanges(currentField, previousField) {
+  const changes = [];
+  const typeChange = compareFieldTypes(currentField, previousField);
+  if (typeChange) {
+    changes.push(typeChange);
+  }
+  changes.push(...compareFieldConstraints(currentField, previousField));
+  changes.push(...compareFieldOptions(currentField, previousField));
+  if (currentField.type === "relation" && previousField.type === "relation") {
+    changes.push(...compareRelationConfigurations(currentField, previousField));
+  }
+  return changes;
+}
+function compareIndexes(currentIndexes = [], previousIndexes = []) {
+  const currentSet = new Set(currentIndexes);
+  const previousSet = new Set(previousIndexes);
+  const indexesToAdd = currentIndexes.filter((idx) => !previousSet.has(idx));
+  const indexesToRemove = previousIndexes.filter((idx) => !currentSet.has(idx));
+  return { indexesToAdd, indexesToRemove };
+}
+function compareRules(currentRules, previousRules) {
+  const updates = [];
+  const ruleTypes = [
+    "listRule",
+    "viewRule",
+    "createRule",
+    "updateRule",
+    "deleteRule",
+    "manageRule"
+  ];
+  for (const ruleType of ruleTypes) {
+    const currentValue = currentRules?.[ruleType] ?? null;
+    const previousValue = previousRules?.[ruleType] ?? null;
+    if (currentValue !== previousValue) {
+      updates.push({
+        ruleType,
+        oldValue: previousValue,
+        newValue: currentValue
+      });
+    }
+  }
+  return updates;
+}
+function comparePermissions(currentPermissions, previousPermissions) {
+  const changes = [];
+  const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule", "manageRule"];
+  for (const ruleType of ruleTypes) {
+    const currentValue = currentPermissions?.[ruleType] ?? null;
+    const previousValue = previousPermissions?.[ruleType] ?? null;
+    if (currentValue !== previousValue) {
+      changes.push({
+        ruleType,
+        oldValue: previousValue,
+        newValue: currentValue
+      });
+    }
+  }
+  return changes;
+}
+function compareCollectionFields(currentCollection, previousCollection, config) {
+  let fieldsToAdd = findNewFields(currentCollection.fields, previousCollection.fields);
+  const fieldsToRemove = findRemovedFields(currentCollection.fields, previousCollection.fields);
+  const fieldsToModify = [];
+  if (currentCollection.name === "users") {
+    const systemFields = getUsersSystemFields(config);
+    fieldsToAdd = fieldsToAdd.filter((field) => !systemFields.has(field.name));
+  }
+  const matchedFields = matchFieldsByName(currentCollection.fields, previousCollection.fields);
+  for (const [currentField, previousField] of matchedFields) {
+    const changes = detectFieldChanges(currentField, previousField);
+    if (changes.length > 0) {
+      fieldsToModify.push({
+        fieldName: currentField.name,
+        currentDefinition: previousField,
+        newDefinition: currentField,
+        changes
+      });
+    }
+  }
+  return { fieldsToAdd, fieldsToRemove, fieldsToModify };
+}
+function buildCollectionModification(currentCollection, previousCollection, config) {
+  const { fieldsToAdd, fieldsToRemove, fieldsToModify } = compareCollectionFields(
+    currentCollection,
+    previousCollection,
+    config
+  );
+  const { indexesToAdd, indexesToRemove } = compareIndexes(currentCollection.indexes, previousCollection.indexes);
+  const rulesToUpdate = compareRules(currentCollection.rules, previousCollection.rules);
+  const permissionsToUpdate = comparePermissions(currentCollection.permissions, previousCollection.permissions);
+  return {
+    collection: currentCollection.name,
+    fieldsToAdd,
+    fieldsToRemove,
+    fieldsToModify,
+    indexesToAdd,
+    indexesToRemove,
+    rulesToUpdate,
+    permissionsToUpdate
+  };
+}
+function hasChanges(modification) {
+  return modification.fieldsToAdd.length > 0 || modification.fieldsToRemove.length > 0 || modification.fieldsToModify.length > 0 || modification.indexesToAdd.length > 0 || modification.indexesToRemove.length > 0 || modification.rulesToUpdate.length > 0 || modification.permissionsToUpdate.length > 0;
+}
+function aggregateChanges(currentSchema, previousSnapshot, config) {
+  const collectionsToCreate = findNewCollections(currentSchema, previousSnapshot);
+  const collectionsToDelete = findRemovedCollections(currentSchema, previousSnapshot);
+  const filteredCollectionsToCreate = collectionsToCreate.filter(
+    (collection) => !isSystemCollection(collection.name, config)
+  );
+  const filteredCollectionsToDelete = collectionsToDelete.filter(
+    (collection) => !isSystemCollection(collection.name, config)
+  );
+  const collectionsToModify = [];
+  const matchedCollections = matchCollectionsByName(currentSchema, previousSnapshot);
+  for (const [currentCollection, previousCollection] of matchedCollections) {
+    const modification = buildCollectionModification(currentCollection, previousCollection, config);
+    if (hasChanges(modification)) {
+      collectionsToModify.push(modification);
+    }
+  }
+  return {
+    collectionsToCreate: filteredCollectionsToCreate,
+    collectionsToDelete: filteredCollectionsToDelete,
+    collectionsToModify
+  };
+}
+function detectDestructiveChanges(diff, config) {
+  const destructiveChanges = [];
+  const mergedConfig = mergeConfig3(config);
+  for (const collection of diff.collectionsToDelete) {
+    destructiveChanges.push({
+      type: "collection_delete",
+      severity: "high",
+      collection: collection.name,
+      description: `Delete collection: ${collection.name}`
+    });
+  }
+  for (const modification of diff.collectionsToModify) {
+    const collectionName = modification.collection;
+    for (const field of modification.fieldsToRemove) {
+      destructiveChanges.push({
+        type: "field_delete",
+        severity: "high",
+        collection: collectionName,
+        field: field.name,
+        description: `Delete field: ${collectionName}.${field.name}`
+      });
+    }
+    for (const fieldMod of modification.fieldsToModify) {
+      const typeChange = fieldMod.changes.find((c) => c.property === "type");
+      const requiredChange = fieldMod.changes.find((c) => c.property === "required" && c.newValue === true);
+      if (typeChange) {
+        destructiveChanges.push({
+          type: "type_change",
+          severity: "high",
+          collection: collectionName,
+          field: fieldMod.fieldName,
+          description: `Change field type: ${collectionName}.${fieldMod.fieldName} (${typeChange.oldValue} \u2192 ${typeChange.newValue})`,
+          oldValue: typeChange.oldValue,
+          newValue: typeChange.newValue
+        });
+      }
+      if (requiredChange && mergedConfig.severityThreshold !== "high") {
+        destructiveChanges.push({
+          type: "required_change",
+          severity: "medium",
+          collection: collectionName,
+          field: fieldMod.fieldName,
+          description: `Make field required: ${collectionName}.${fieldMod.fieldName}`,
+          oldValue: false,
+          newValue: true
+        });
+      }
+      if (mergedConfig.severityThreshold === "low") {
+        const otherChanges = fieldMod.changes.filter((c) => c.property !== "type" && c.property !== "required");
+        for (const change of otherChanges) {
+          destructiveChanges.push({
+            type: "constraint_change",
+            severity: "low",
+            collection: collectionName,
+            field: fieldMod.fieldName,
+            description: `Change constraint: ${collectionName}.${fieldMod.fieldName}.${change.property}`,
+            oldValue: change.oldValue,
+            newValue: change.newValue
+          });
+        }
+      }
+    }
+  }
+  return destructiveChanges;
+}
+function categorizeChangesBySeverity(diff, _config) {
+  const destructive = [];
+  const nonDestructive = [];
+  for (const collection of diff.collectionsToDelete) {
+    destructive.push(`Delete collection: ${collection.name}`);
+  }
+  for (const collection of diff.collectionsToCreate) {
+    nonDestructive.push(`Create collection: ${collection.name}`);
+  }
+  for (const modification of diff.collectionsToModify) {
+    const collectionName = modification.collection;
+    for (const field of modification.fieldsToRemove) {
+      destructive.push(`Delete field: ${collectionName}.${field.name}`);
+    }
+    for (const field of modification.fieldsToAdd) {
+      nonDestructive.push(`Add field: ${collectionName}.${field.name}`);
+    }
+    for (const fieldMod of modification.fieldsToModify) {
+      const hasTypeChange = fieldMod.changes.some((c) => c.property === "type");
+      const hasRequiredChange = fieldMod.changes.some((c) => c.property === "required" && c.newValue === true);
+      if (hasTypeChange) {
+        destructive.push(
+          `Change field type: ${collectionName}.${fieldMod.fieldName} (${fieldMod.changes.find((c) => c.property === "type")?.oldValue} \u2192 ${fieldMod.changes.find((c) => c.property === "type")?.newValue})`
+        );
+      } else if (hasRequiredChange) {
+        destructive.push(`Make field required: ${collectionName}.${fieldMod.fieldName}`);
+      } else {
+        nonDestructive.push(`Modify field: ${collectionName}.${fieldMod.fieldName}`);
+      }
+    }
+    for (const _index of modification.indexesToAdd) {
+      nonDestructive.push(`Add index: ${collectionName}`);
+    }
+    for (const _index of modification.indexesToRemove) {
+      nonDestructive.push(`Remove index: ${collectionName}`);
+    }
+    for (const rule of modification.rulesToUpdate) {
+      nonDestructive.push(`Update rule: ${collectionName}.${rule.ruleType}`);
+    }
+  }
+  return { destructive, nonDestructive };
+}
+function generateChangeSummary(diff, config) {
+  const destructiveChanges = detectDestructiveChanges(diff, config);
+  const { nonDestructive } = categorizeChangesBySeverity(diff);
+  let fieldsToAdd = 0;
+  let fieldsToRemove = 0;
+  let fieldsToModify = 0;
+  let indexChanges = 0;
+  let ruleChanges = 0;
+  let permissionChanges = 0;
+  for (const modification of diff.collectionsToModify) {
+    fieldsToAdd += modification.fieldsToAdd.length;
+    fieldsToRemove += modification.fieldsToRemove.length;
+    fieldsToModify += modification.fieldsToModify.length;
+    indexChanges += modification.indexesToAdd.length + modification.indexesToRemove.length;
+    ruleChanges += modification.rulesToUpdate.length;
+    permissionChanges += modification.permissionsToUpdate.length;
+  }
+  return {
+    totalChanges: diff.collectionsToCreate.length + diff.collectionsToDelete.length + diff.collectionsToModify.length,
+    collectionsToCreate: diff.collectionsToCreate.length,
+    collectionsToDelete: diff.collectionsToDelete.length,
+    collectionsToModify: diff.collectionsToModify.length,
+    fieldsToAdd,
+    fieldsToRemove,
+    fieldsToModify,
+    indexChanges,
+    ruleChanges,
+    permissionChanges,
+    destructiveChanges,
+    nonDestructiveChanges: nonDestructive
+  };
+}
+function requiresForceFlag(diff, config) {
+  const mergedConfig = mergeConfig3(config);
+  if (!mergedConfig.requireForceForDestructive) {
+    return false;
+  }
+  const destructiveChanges = detectDestructiveChanges(diff, config);
+  const relevantChanges = destructiveChanges.filter((change) => {
+    switch (mergedConfig.severityThreshold) {
+      case "high":
+        return change.severity === "high";
+      case "medium":
+        return change.severity === "high" || change.severity === "medium";
+      case "low":
+        return true;
+      default:
+        return change.severity === "high";
+    }
+  });
+  return relevantChanges.length > 0;
+}
+function compare(currentSchema, previousSnapshot, config) {
+  return aggregateChanges(currentSchema, previousSnapshot, config);
+}
+var DiffEngine = class {
+  config;
+  constructor(config) {
+    this.config = mergeConfig3(config);
+  }
+  /**
+   * Compares current schema with previous snapshot
+   */
+  compare(currentSchema, previousSnapshot) {
+    return compare(currentSchema, previousSnapshot, this.config);
+  }
+  /**
+   * Detects destructive changes in a diff
+   */
+  detectDestructiveChanges(diff) {
+    return detectDestructiveChanges(diff, this.config);
+  }
+  /**
+   * Categorizes changes by severity
+   */
+  categorizeChangesBySeverity(diff) {
+    return categorizeChangesBySeverity(diff, this.config);
+  }
+  /**
+   * Generates a summary of changes
+   */
+  generateChangeSummary(diff) {
+    return generateChangeSummary(diff, this.config);
+  }
+  /**
+   * Checks if force flag is required
+   */
+  requiresForceFlag(diff) {
+    return requiresForceFlag(diff, this.config);
+  }
+};
+var DEFAULT_TEMPLATE = `/// <reference path="{{TYPES_PATH}}" />
+migrate((app) => {
+{{UP_CODE}}
+  return true;
+}, (app) => {
+{{DOWN_CODE}}
+  return true;
+});
+`;
+var DEFAULT_CONFIG4 = {
+  workspaceRoot: process.cwd(),
+  timestampGenerator: () => Math.floor(Date.now() / 1e3).toString(),
+  template: DEFAULT_TEMPLATE,
+  includeTypeReference: true,
+  typesPath: "../pb_data/types.d.ts"
+};
+function mergeConfig4(config) {
+  return {
+    ...DEFAULT_CONFIG4,
+    ...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 ? mergeConfig4(config) : DEFAULT_CONFIG4;
+  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 (!fs2__namespace.existsSync(migrationDir)) {
+      try {
+        fs2__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);
+    fs2__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 = mergeConfig4(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.CLIUsageError = CLIUsageError;
+exports.ConfigurationError = ConfigurationError;
+exports.DiffEngine = DiffEngine;
+exports.FIELD_TYPE_INFO = FIELD_TYPE_INFO;
+exports.FileSystemError = FileSystemError;
+exports.MigrationError = MigrationError;
+exports.MigrationGenerationError = MigrationGenerationError;
+exports.MigrationGenerator = MigrationGenerator;
+exports.POCKETBASE_FIELD_TYPES = POCKETBASE_FIELD_TYPES;
+exports.SchemaAnalyzer = SchemaAnalyzer;
+exports.SchemaParsingError = SchemaParsingError;
+exports.SnapshotError = SnapshotError;
+exports.SnapshotManager = SnapshotManager;
+exports.aggregateChanges = aggregateChanges;
+exports.buildFieldDefinition = buildFieldDefinition;
+exports.buildSchemaDefinition = buildSchemaDefinition;
+exports.categorizeChangesBySeverity = categorizeChangesBySeverity;
+exports.compare = compare;
+exports.compareFieldConstraints = compareFieldConstraints;
+exports.compareFieldOptions = compareFieldOptions;
+exports.compareFieldTypes = compareFieldTypes;
+exports.comparePermissions = comparePermissions;
+exports.compareRelationConfigurations = compareRelationConfigurations;
+exports.convertPocketBaseMigration = convertPocketBaseMigration;
+exports.convertZodSchemaToCollectionSchema = convertZodSchemaToCollectionSchema;
+exports.createMigrationFileStructure = createMigrationFileStructure;
+exports.detectDestructiveChanges = detectDestructiveChanges;
+exports.detectFieldChanges = detectFieldChanges;
+exports.discoverSchemaFiles = discoverSchemaFiles;
+exports.extractComprehensiveFieldOptions = extractComprehensiveFieldOptions;
+exports.extractFieldDefinitions = extractFieldDefinitions;
+exports.extractFieldOptions = extractFieldOptions;
+exports.extractIndexes = extractIndexes;
+exports.extractSchemaDefinitions = extractSchemaDefinitions;
+exports.filterSystemCollections = filterSystemCollections;
+exports.findLatestSnapshot = findLatestSnapshot;
+exports.findNewCollections = findNewCollections;
+exports.findNewFields = findNewFields;
+exports.findRemovedCollections = findRemovedCollections;
+exports.findRemovedFields = findRemovedFields;
+exports.generate = generate;
+exports.generateChangeSummary = generateChangeSummary;
+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.getArrayElementType = getArrayElementType;
+exports.getCollectionNameFromFile = getCollectionNameFromFile;
+exports.getDefaultValue = getDefaultValue;
+exports.getFieldTypeInfo = getFieldTypeInfo;
+exports.getMaxSelect = getMaxSelect;
+exports.getMinSelect = getMinSelect;
+exports.getSnapshotPath = getSnapshotPath;
+exports.getSnapshotVersion = getSnapshotVersion;
+exports.getUsersSystemFields = getUsersSystemFields;
+exports.importSchemaModule = importSchemaModule;
+exports.isArrayType = isArrayType;
+exports.isAuthCollection = isAuthCollection;
+exports.isEditorField = isEditorField;
+exports.isFieldRequired = isFieldRequired;
+exports.isFileFieldByName = isFileFieldByName;
+exports.isGeoPointType = isGeoPointType;
+exports.isMultipleRelationField = isMultipleRelationField;
+exports.isRelationField = isRelationField;
+exports.isSingleRelationField = isSingleRelationField;
+exports.isSystemCollection = isSystemCollection;
+exports.loadBaseMigration = loadBaseMigration;
+exports.loadSnapshot = loadSnapshot;
+exports.loadSnapshotIfExists = loadSnapshotIfExists;
+exports.mapZodArrayType = mapZodArrayType;
+exports.mapZodBooleanType = mapZodBooleanType;
+exports.mapZodDateType = mapZodDateType;
+exports.mapZodEnumType = mapZodEnumType;
+exports.mapZodNumberType = mapZodNumberType;
+exports.mapZodRecordType = mapZodRecordType;
+exports.mapZodStringType = mapZodStringType;
+exports.mapZodTypeToPocketBase = mapZodTypeToPocketBase;
+exports.matchCollectionsByName = matchCollectionsByName;
+exports.matchFieldsByName = matchFieldsByName;
+exports.mergeSnapshots = mergeSnapshots;
+exports.parseSchemaFiles = parseSchemaFiles;
+exports.pluralize = pluralize;
+exports.requiresForceFlag = requiresForceFlag;
+exports.resolveTargetCollection = resolveTargetCollection;
+exports.saveSnapshot = saveSnapshot;
+exports.selectSchemaForCollection = selectSchemaForCollection;
+exports.singularize = singularize;
+exports.snapshotExists = snapshotExists;
+exports.toCollectionName = toCollectionName;
+exports.unwrapZodType = unwrapZodType;
+exports.validateSnapshot = validateSnapshot;
+exports.writeMigrationFile = writeMigrationFile;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map