pocketbase-zod-schema 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 var zod = require('zod');
-var fs2 = require('fs');
-var path4 = require('path');
+var fs3 = require('fs');
+var path5 = require('path');
 var chalk = require('chalk');
 var ora = require('ora');
 
@@ -26,8 +26,8 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
-var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path5__namespace = /*#__PURE__*/_interopNamespace(path5);
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
 
@@ -104,14 +104,48 @@ function filesField(options) {
   if (options?.max !== void 0) schema = schema.max(options.max);
   return schema;
 }
-function relationField() {
-  return zod.z.string();
+var RELATION_METADATA_KEY = "__pocketbase_relation__";
+function relationField(config) {
+  const metadata = {
+    [RELATION_METADATA_KEY]: {
+      type: "single",
+      collection: config.collection,
+      cascadeDelete: config.cascadeDelete ?? false,
+      maxSelect: 1,
+      minSelect: 0
+    }
+  };
+  return zod.z.string().describe(JSON.stringify(metadata));
 }
-function relationsField(options) {
+function relationsField(config) {
+  const metadata = {
+    [RELATION_METADATA_KEY]: {
+      type: "multiple",
+      collection: config.collection,
+      cascadeDelete: config.cascadeDelete ?? false,
+      maxSelect: config.maxSelect ?? 999,
+      minSelect: config.minSelect ?? 0
+    }
+  };
   let schema = zod.z.array(zod.z.string());
-  if (options?.min !== void 0) schema = schema.min(options.min);
-  if (options?.max !== void 0) schema = schema.max(options.max);
-  return schema;
+  if (config.minSelect !== void 0) {
+    schema = schema.min(config.minSelect);
+  }
+  if (config.maxSelect !== void 0) {
+    schema = schema.max(config.maxSelect);
+  }
+  return schema.describe(JSON.stringify(metadata));
+}
+function extractRelationMetadata(description) {
+  if (!description) return null;
+  try {
+    const parsed = JSON.parse(description);
+    if (parsed[RELATION_METADATA_KEY]) {
+      return parsed[RELATION_METADATA_KEY];
+    }
+  } catch {
+  }
+  return null;
 }
 function editorField() {
   return zod.z.string();
@@ -143,7 +177,7 @@ function withIndexes(schema, indexes) {
   return schema.describe(JSON.stringify(metadata));
 }
 
-// src/schema/permission-templates.ts
+// src/utils/permission-templates.ts
 var PermissionTemplates = {
   /**
    * Public access - anyone can perform all operations
@@ -368,38 +402,36 @@ var ProjectInputSchema = zod.z.object({
   content: zod.z.string(),
   status: StatusEnum,
   summary: zod.z.string().optional(),
-  User: zod.z.string().nonempty("User ID is missing"),
-  SubscriberUsers: zod.z.array(zod.z.string())
+  OwnerUser: relationField({ collection: "Users" }),
+  SubscriberUsers: relationsField({ collection: "Users" })
 }).extend(inputImageFileSchema);
 var ProjectSchema = withPermissions(
   ProjectInputSchema.omit(omitImageFilesSchema).extend(baseImageFileSchema),
   {
     template: "owner-only",
-    ownerField: "User",
+    ownerField: "OwnerUser",
     customRules: {
-      // Override list rule to allow authenticated users to see all projects
       listRule: '@request.auth.id != ""',
-      // Allow viewing if user is owner OR a subscriber
-      viewRule: '@request.auth.id != "" && (User = @request.auth.id || SubscriberUsers ?= @request.auth.id)'
+      viewRule: '@request.auth.id != "" && (OwnerUser = @request.auth.id || SubscriberUsers ?= @request.auth.id)'
     }
   }
 );
 var UserInputSchema = zod.z.object({
-  name: zod.z.string().min(2, "Name must be longer").optional(),
+  name: zod.z.string().optional(),
   email: zod.z.string().email(),
   password: zod.z.string().min(8, "Password must be at least 8 characters"),
   passwordConfirm: zod.z.string(),
   avatar: zod.z.instanceof(File).optional()
 });
 var UserDatabaseSchema = zod.z.object({
-  name: zod.z.string().min(2, "Name must be longer").optional(),
+  name: zod.z.string().optional(),
   email: zod.z.string().email(),
   password: zod.z.string().min(8, "Password must be at least 8 characters"),
   avatar: zod.z.instanceof(File).optional()
 });
 var UserSchema = withIndexes(
   withPermissions(UserDatabaseSchema.extend(baseSchema), {
-    // Users can list other users (for mentions, user search, etc.)
+    // Users can list their own profile
     listRule: "id = @request.auth.id",
     // Users can view their own profile
     viewRule: "id = @request.auth.id",
@@ -408,15 +440,13 @@ var UserSchema = withIndexes(
     // Users can only update their own profile
     updateRule: "id = @request.auth.id",
     // Users can only delete their own account
-    deleteRule: "id = @request.auth.id",
-    // Users can only manage their own account (change email, password, etc.)
-    manageRule: "id = @request.auth.id"
+    deleteRule: "id = @request.auth.id"
+    // manageRule is null in PocketBase default (not set)
   }),
   [
-    // Email should be unique for authentication
-    "CREATE UNIQUE INDEX idx_users_email ON users (email)",
-    // Index on name for user search and sorting
-    "CREATE INDEX idx_users_name ON users (name)"
+    // PocketBase's default indexes for auth collections
+    "CREATE UNIQUE INDEX `idx_tokenKey__pb_users_auth_` ON `users` (`tokenKey`)",
+    "CREATE UNIQUE INDEX `idx_email__pb_users_auth_` ON `users` (`email`) WHERE `email` != ''"
   ]
 );
 var BaseMutator = class {
@@ -757,7 +787,7 @@ var UserMutator = class extends BaseMutator {
     };
   }
   getCollection() {
-    return this.pb.collection("Projects");
+    return this.pb.collection("Users");
   }
   async validateInput(input) {
     return UserInputSchema.parse(input);
@@ -861,10 +891,10 @@ var FileSystemError = class _FileSystemError extends MigrationError {
   operation;
   code;
   originalError;
-  constructor(message, path6, operation, code, originalError) {
+  constructor(message, path7, operation, code, originalError) {
     super(message);
     this.name = "FileSystemError";
-    this.path = path6;
+    this.path = path7;
     this.operation = operation;
     this.code = code;
     this.originalError = originalError;
@@ -1523,26 +1553,28 @@ function getMaxSelect(fieldName, zodType) {
   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 (isSingleRelationField(fieldName, zodType)) {
+    return 0;
   }
-  if (unwrappedType instanceof zod.z.ZodArray) {
-    const arrayDef = unwrappedType._def;
-    if (arrayDef.minLength) {
-      return arrayDef.minLength.value;
+  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.minLength) {
+        return arrayDef.minLength.value;
+      }
     }
   }
-  return void 0;
+  return 0;
 }
 var POCKETBASE_FIELD_TYPES = [
   "text",
@@ -1965,20 +1997,20 @@ function mergeConfig(config) {
 }
 function resolveSchemaDir(config) {
   const workspaceRoot = config.workspaceRoot || process.cwd();
-  if (path4__namespace.isAbsolute(config.schemaDir)) {
+  if (path5__namespace.isAbsolute(config.schemaDir)) {
     return config.schemaDir;
   }
-  return path4__namespace.join(workspaceRoot, config.schemaDir);
+  return path5__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)) {
+    if (!fs3__namespace.existsSync(schemaDir)) {
       throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
     }
-    const files = fs2__namespace.readdirSync(schemaDir);
+    const files = fs3__namespace.readdirSync(schemaDir);
     const schemaFiles = files.filter((file) => {
       const hasValidExtension = mergedConfig.includeExtensions.some((ext) => file.endsWith(ext));
       if (!hasValidExtension) return false;
@@ -1994,7 +2026,7 @@ function discoverSchemaFiles(config) {
     });
     return schemaFiles.map((file) => {
       const ext = mergedConfig.includeExtensions.find((ext2) => file.endsWith(ext2)) || ".ts";
-      return path4__namespace.join(schemaDir, file.replace(new RegExp(`\\${ext}$`), ""));
+      return path5__namespace.join(schemaDir, file.replace(new RegExp(`\\${ext}$`), ""));
     });
   } catch (error) {
     if (error instanceof FileSystemError) {
@@ -2025,13 +2057,32 @@ async function importSchemaModule(filePath, config) {
     if (config?.pathTransformer) {
       importPath = config.pathTransformer(filePath);
     }
-    if (!importPath.endsWith(".js")) {
-      importPath = `${importPath}.js`;
+    let resolvedPath = null;
+    const jsPath = `${importPath}.js`;
+    const tsPath = `${importPath}.ts`;
+    if (fs3__namespace.existsSync(jsPath)) {
+      resolvedPath = jsPath;
+    } else if (fs3__namespace.existsSync(tsPath)) {
+      resolvedPath = tsPath;
+    } else {
+      resolvedPath = jsPath;
     }
-    const fileUrl = new URL(`file://${path4__namespace.resolve(importPath)}`);
+    const fileUrl = new URL(`file://${path5__namespace.resolve(resolvedPath)}`);
     const module = await import(fileUrl.href);
     return module;
   } catch (error) {
+    const tsPath = `${filePath}.ts`;
+    const isTypeScriptFile = fs3__namespace.existsSync(tsPath);
+    if (isTypeScriptFile) {
+      throw new SchemaParsingError(
+        `Failed to import TypeScript schema file. Node.js cannot import TypeScript files directly.
+Please either:
+  1. Compile your schema files to JavaScript first, or
+  2. Use tsx to run the migration tool (e.g., "npx tsx package/dist/cli/migrate.js status" or "tsx package/dist/cli/migrate.js status")`,
+        filePath,
+        error
+      );
+    }
     throw new SchemaParsingError(
       `Failed to import schema module. Make sure the schema files are compiled to JavaScript.`,
       filePath,
@@ -2040,7 +2091,7 @@ async function importSchemaModule(filePath, config) {
   }
 }
 function getCollectionNameFromFile(filePath) {
-  const filename = path4__namespace.basename(filePath).replace(/\.(ts|js)$/, "");
+  const filename = path5__namespace.basename(filePath).replace(/\.(ts|js)$/, "");
   return toCollectionName(filename);
 }
 function extractSchemaDefinitions(module, patterns = ["Schema", "InputSchema"]) {
@@ -2094,7 +2145,17 @@ function buildFieldDefinition(fieldName, zodType) {
     required,
     options
   };
-  if (isRelationField(fieldName, zodType)) {
+  const relationMetadata = extractRelationMetadata(zodType.description);
+  if (relationMetadata) {
+    fieldDef.type = "relation";
+    fieldDef.relation = {
+      collection: relationMetadata.collection,
+      maxSelect: relationMetadata.maxSelect,
+      minSelect: relationMetadata.minSelect,
+      cascadeDelete: relationMetadata.cascadeDelete
+    };
+    fieldDef.options = void 0;
+  } else if (isRelationField(fieldName, zodType)) {
     fieldDef.type = "relation";
     const targetCollection = resolveTargetCollection(fieldName);
     const maxSelect = getMaxSelect(fieldName, zodType);
@@ -2106,6 +2167,13 @@ function buildFieldDefinition(fieldName, zodType) {
       cascadeDelete: false
       // Default to false, can be configured later
     };
+    if (fieldDef.options) {
+      const { min, max, pattern, ...relationSafeOptions } = fieldDef.options;
+      console.log("min", min);
+      console.log("max", max);
+      console.log("pattern", pattern);
+      fieldDef.options = Object.keys(relationSafeOptions).length > 0 ? relationSafeOptions : void 0;
+    }
   }
   return fieldDef;
 }
@@ -2158,11 +2226,12 @@ function convertZodSchemaToCollectionSchema(collectionName, zodSchema) {
     fields,
     indexes,
     rules: {
-      listRule: null,
-      viewRule: null,
-      createRule: null,
-      updateRule: null,
-      deleteRule: null
+      listRule: permissions?.listRule ?? null,
+      viewRule: permissions?.viewRule ?? null,
+      createRule: permissions?.createRule ?? null,
+      updateRule: permissions?.updateRule ?? null,
+      deleteRule: permissions?.deleteRule ?? null,
+      manageRule: permissions?.manageRule ?? null
     },
     permissions
   };
@@ -2186,7 +2255,12 @@ async function buildSchemaDefinition(config) {
       if (normalizedConfig.pathTransformer) {
         importPath = normalizedConfig.pathTransformer(filePath);
       } else if (mergedConfig.useCompiledFiles) {
-        importPath = filePath.replace(/\/src\//, "/dist/");
+        const distPath = filePath.replace(/\/src\//, "/dist/");
+        if (fs3__namespace.existsSync(`${distPath}.js`) || fs3__namespace.existsSync(`${distPath}.mjs`)) {
+          importPath = distPath;
+        } else {
+          importPath = filePath;
+        }
       }
       const module = await importSchemaModule(importPath, normalizedConfig);
       const schemas = extractSchemaDefinitions(module, mergedConfig.schemaPatterns);
@@ -2238,7 +2312,359 @@ var SchemaAnalyzer = class {
     return convertZodSchemaToCollectionSchema(name, schema);
   }
 };
+
+// src/migration/pocketbase-converter.ts
 var SNAPSHOT_VERSION = "1.0.0";
+function resolveCollectionIdToName(collectionId) {
+  if (collectionId === "_pb_users_auth_") {
+    return "Users";
+  }
+  const nameMatch = collectionId.match(/app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\)/);
+  if (nameMatch) {
+    return nameMatch[1];
+  }
+  return collectionId;
+}
+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
+      };
+      field.options = pbField.options ? { ...pbField.options } : {};
+      if (pbField.type === "select") {
+        if (pbField.values && Array.isArray(pbField.values)) {
+          field.options.values = pbField.values;
+        } else if (pbField.options?.values && Array.isArray(pbField.options.values)) {
+          field.options.values = pbField.options.values;
+        }
+      }
+      if (pbField.type === "relation") {
+        const collectionId = pbField.collectionId || pbField.options?.collectionId || "";
+        const collectionName = resolveCollectionIdToName(collectionId);
+        field.relation = {
+          collection: collectionName,
+          cascadeDelete: pbField.cascadeDelete ?? pbField.options?.cascadeDelete ?? false,
+          maxSelect: pbField.maxSelect ?? pbField.options?.maxSelect,
+          minSelect: pbField.minSelect ?? pbField.options?.minSelect
+        };
+      }
+      const hasOnlyValues = Object.keys(field.options).length === 1 && field.options.values !== void 0;
+      if (Object.keys(field.options).length === 0) {
+        delete field.options;
+      } else if (pbField.type === "select" && hasOnlyValues) ;
+      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;
+    schema.permissions = { ...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
+    );
+  }
+}
+
+// src/migration/migration-parser.ts
+function extractTimestampFromFilename(filename) {
+  const match = filename.match(/^(\d+)_/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return null;
+}
+function findMigrationsAfterSnapshot(migrationsPath, snapshotTimestamp) {
+  try {
+    if (!fs3__namespace.existsSync(migrationsPath)) {
+      return [];
+    }
+    const files = fs3__namespace.readdirSync(migrationsPath);
+    const migrationFiles = [];
+    for (const file of files) {
+      if (file.endsWith("_collections_snapshot.js") || file.endsWith("_snapshot.js")) {
+        continue;
+      }
+      if (!file.endsWith(".js")) {
+        continue;
+      }
+      const timestamp = extractTimestampFromFilename(file);
+      if (timestamp && timestamp > snapshotTimestamp) {
+        migrationFiles.push({
+          path: path5__namespace.join(migrationsPath, file),
+          timestamp
+        });
+      }
+    }
+    migrationFiles.sort((a, b) => a.timestamp - b.timestamp);
+    return migrationFiles.map((f) => f.path);
+  } catch (error) {
+    console.warn(`Error finding migrations after snapshot: ${error}`);
+    return [];
+  }
+}
+function parseMigrationOperationsFromContent(content) {
+  const collectionsToCreate = [];
+  const collectionsToDelete = [];
+  try {
+    let searchIndex = 0;
+    while (true) {
+      const collectionStart = content.indexOf("new Collection(", searchIndex);
+      if (collectionStart === -1) {
+        break;
+      }
+      const openParen = collectionStart + "new Collection(".length;
+      let braceCount = 0;
+      let parenCount = 1;
+      let inString = false;
+      let stringChar = null;
+      let i = openParen;
+      while (i < content.length && /\s/.test(content[i])) {
+        i++;
+      }
+      if (content[i] !== "{") {
+        searchIndex = i + 1;
+        continue;
+      }
+      const objectStart = i;
+      braceCount = 1;
+      i++;
+      while (i < content.length && (braceCount > 0 || parenCount > 0)) {
+        const char = content[i];
+        const prevChar = i > 0 ? content[i - 1] : "";
+        if (!inString && (char === '"' || char === "'")) {
+          inString = true;
+          stringChar = char;
+        } else if (inString && char === stringChar && prevChar !== "\\") {
+          inString = false;
+          stringChar = null;
+        }
+        if (!inString) {
+          if (char === "{") braceCount++;
+          if (char === "}") braceCount--;
+          if (char === "(") parenCount++;
+          if (char === ")") parenCount--;
+        }
+        i++;
+      }
+      if (braceCount === 0 && parenCount === 0) {
+        const objectContent = content.substring(objectStart, i - 1);
+        try {
+          const collectionObj = new Function(`return ${objectContent}`)();
+          if (collectionObj && collectionObj.name) {
+            const schema = convertPocketBaseCollection(collectionObj);
+            collectionsToCreate.push(schema);
+          }
+        } catch (error) {
+          console.warn(`Failed to parse collection definition: ${error}`);
+        }
+      }
+      searchIndex = i;
+    }
+    const deleteMatches = content.matchAll(
+      /app\.delete\s*\(\s*(?:collection_\w+|app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\))\s*\)/g
+    );
+    for (const match of deleteMatches) {
+      if (match[1]) {
+        collectionsToDelete.push(match[1]);
+      } else {
+        const varNameMatch = match[0].match(/collection_(\w+)/);
+        if (varNameMatch) {
+          const varName = `collection_${varNameMatch[1]}`;
+          const deleteIndex = content.indexOf(match[0]);
+          const beforeDelete = content.substring(0, deleteIndex);
+          const varDefMatch = beforeDelete.match(
+            new RegExp(`const\\s+${varName}\\s*=\\s*new\\s+Collection\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)`, "g")
+          );
+          if (varDefMatch && varDefMatch.length > 0) {
+            const collectionDefMatch = beforeDelete.match(
+              new RegExp(`const\\s+${varName}\\s*=\\s*new\\s+Collection\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)`)
+            );
+            if (collectionDefMatch) {
+              try {
+                const collectionDefStr = collectionDefMatch[1];
+                const collectionObj = new Function(`return ${collectionDefStr}`)();
+                if (collectionObj && collectionObj.name) {
+                  collectionsToDelete.push(collectionObj.name);
+                }
+              } catch {
+              }
+            }
+          }
+        }
+      }
+    }
+    const findAndDeleteMatches = content.matchAll(
+      /app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\)[\s\S]*?app\.delete/g
+    );
+    for (const match of findAndDeleteMatches) {
+      collectionsToDelete.push(match[1]);
+    }
+  } catch (error) {
+    console.warn(`Failed to parse migration operations from content: ${error}`);
+  }
+  return { collectionsToCreate, collectionsToDelete };
+}
+function parseMigrationOperations(migrationContent) {
+  try {
+    const migrateMatch = migrationContent.match(/migrate\s*\(\s*/);
+    if (!migrateMatch) {
+      return parseMigrationOperationsFromContent(migrationContent);
+    }
+    const startIndex = migrateMatch.index + migrateMatch[0].length;
+    let i = startIndex;
+    let parenCount = 0;
+    let foundFirstParen = false;
+    while (i < migrationContent.length) {
+      const char = migrationContent[i];
+      if (char === "(") {
+        parenCount++;
+        foundFirstParen = true;
+        i++;
+        break;
+      }
+      i++;
+    }
+    if (!foundFirstParen) {
+      return parseMigrationOperationsFromContent(migrationContent);
+    }
+    let inString = false;
+    let stringChar = null;
+    let foundBrace = false;
+    let braceStart = -1;
+    while (i < migrationContent.length && !foundBrace) {
+      const char = migrationContent[i];
+      const prevChar = i > 0 ? migrationContent[i - 1] : "";
+      if (!inString && (char === '"' || char === "'")) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && prevChar !== "\\") {
+        inString = false;
+        stringChar = null;
+      }
+      if (!inString) {
+        if (char === "(") parenCount++;
+        if (char === ")") {
+          parenCount--;
+          if (parenCount === 0) {
+            i++;
+            while (i < migrationContent.length && /\s/.test(migrationContent[i])) {
+              i++;
+            }
+            if (i < migrationContent.length - 1 && migrationContent[i] === "=" && migrationContent[i + 1] === ">") {
+              i += 2;
+              while (i < migrationContent.length && /\s/.test(migrationContent[i])) {
+                i++;
+              }
+              if (i < migrationContent.length && migrationContent[i] === "{") {
+                foundBrace = true;
+                braceStart = i + 1;
+                break;
+              }
+            }
+          }
+        }
+      }
+      i++;
+    }
+    if (!foundBrace || braceStart === -1) {
+      return parseMigrationOperationsFromContent(migrationContent);
+    }
+    let braceCount = 1;
+    i = braceStart;
+    inString = false;
+    stringChar = null;
+    while (i < migrationContent.length && braceCount > 0) {
+      const char = migrationContent[i];
+      const prevChar = i > 0 ? migrationContent[i - 1] : "";
+      if (!inString && (char === '"' || char === "'")) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && prevChar !== "\\") {
+        inString = false;
+        stringChar = null;
+      }
+      if (!inString) {
+        if (char === "{") braceCount++;
+        if (char === "}") braceCount--;
+      }
+      i++;
+    }
+    if (braceCount === 0) {
+      const upMigrationContent = migrationContent.substring(braceStart, i - 1);
+      return parseMigrationOperationsFromContent(upMigrationContent);
+    }
+    return parseMigrationOperationsFromContent(migrationContent);
+  } catch (error) {
+    console.warn(`Failed to parse migration operations: ${error}`);
+    return { collectionsToCreate: [], collectionsToDelete: [] };
+  }
+}
+
+// src/migration/snapshot.ts
+var SNAPSHOT_VERSION2 = "1.0.0";
 var DEFAULT_SNAPSHOT_FILENAME = ".migration-snapshot.json";
 var SNAPSHOT_MIGRATIONS = [
   // Add migrations here as the format evolves
@@ -2253,7 +2679,7 @@ var DEFAULT_CONFIG2 = {
   snapshotPath: DEFAULT_SNAPSHOT_FILENAME,
   workspaceRoot: process.cwd(),
   autoMigrate: true,
-  version: SNAPSHOT_VERSION
+  version: SNAPSHOT_VERSION2
 };
 function mergeConfig2(config = {}) {
   return {
@@ -2265,15 +2691,15 @@ function getSnapshotPath(config = {}) {
   const mergedConfig = mergeConfig2(config);
   const workspaceRoot = mergedConfig.workspaceRoot;
   const snapshotFilename = mergedConfig.snapshotPath;
-  if (path4__namespace.isAbsolute(snapshotFilename)) {
+  if (path5__namespace.isAbsolute(snapshotFilename)) {
     return snapshotFilename;
   }
-  return path4__namespace.join(workspaceRoot, snapshotFilename);
+  return path5__namespace.join(workspaceRoot, snapshotFilename);
 }
 function snapshotExists(config = {}) {
   try {
     const snapshotPath = getSnapshotPath(config);
-    return fs2__namespace.existsSync(snapshotPath);
+    return fs3__namespace.existsSync(snapshotPath);
   } catch {
     return false;
   }
@@ -2332,13 +2758,13 @@ function addSnapshotMetadata(schema, config) {
 function saveSnapshot(schema, config = {}) {
   const snapshotPath = getSnapshotPath(config);
   try {
-    const snapshotDir = path4__namespace.dirname(snapshotPath);
-    if (!fs2__namespace.existsSync(snapshotDir)) {
-      fs2__namespace.mkdirSync(snapshotDir, { recursive: true });
+    const snapshotDir = path5__namespace.dirname(snapshotPath);
+    if (!fs3__namespace.existsSync(snapshotDir)) {
+      fs3__namespace.mkdirSync(snapshotDir, { recursive: true });
     }
     const snapshotData = addSnapshotMetadata(schema, config);
     const jsonContent = JSON.stringify(snapshotData, null, 2);
-    fs2__namespace.writeFileSync(snapshotPath, jsonContent, "utf-8");
+    fs3__namespace.writeFileSync(snapshotPath, jsonContent, "utf-8");
   } catch (error) {
     handleFileSystemError(error, "write", snapshotPath);
   }
@@ -2433,7 +2859,7 @@ function deserializeSnapshot(data) {
 function loadSnapshot(config = {}) {
   const snapshotPath = getSnapshotPath(config);
   try {
-    const jsonContent = fs2__namespace.readFileSync(snapshotPath, "utf-8");
+    const jsonContent = fs3__namespace.readFileSync(snapshotPath, "utf-8");
     const data = parseAndValidateSnapshot(jsonContent, snapshotPath);
     const migratedData = migrateSnapshotFormat(data, config);
     return deserializeSnapshot(migratedData);
@@ -2468,10 +2894,10 @@ function mergeSnapshots(baseSnapshot, customSnapshot) {
 }
 function findLatestSnapshot(migrationsPath) {
   try {
-    if (!fs2__namespace.existsSync(migrationsPath)) {
+    if (!fs3__namespace.existsSync(migrationsPath)) {
       return null;
     }
-    const files = fs2__namespace.readdirSync(migrationsPath);
+    const files = fs3__namespace.readdirSync(migrationsPath);
     const snapshotFiles = files.filter(
       (file) => file.endsWith("_collections_snapshot.js") || file.endsWith("_snapshot.js")
     );
@@ -2483,20 +2909,74 @@ function findLatestSnapshot(migrationsPath) {
     if (!latestSnapshot) {
       return null;
     }
-    return path4__namespace.join(migrationsPath, latestSnapshot);
+    return path5__namespace.join(migrationsPath, latestSnapshot);
   } catch (error) {
     console.warn(`Error finding latest snapshot: ${error}`);
     return null;
   }
 }
+function applyMigrationOperations(snapshot, operations) {
+  const updatedCollections = new Map(snapshot.collections);
+  for (const collectionName of operations.collectionsToDelete) {
+    updatedCollections.delete(collectionName);
+  }
+  for (const collection of operations.collectionsToCreate) {
+    updatedCollections.set(collection.name, collection);
+  }
+  return {
+    ...snapshot,
+    collections: updatedCollections
+  };
+}
+function loadSnapshotWithMigrations(config = {}) {
+  const migrationsPath = config.migrationsPath;
+  if (!migrationsPath) {
+    return null;
+  }
+  if (fs3__namespace.existsSync(migrationsPath) && fs3__namespace.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs3__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) {
+    return null;
+  }
+  try {
+    const migrationContent = fs3__namespace.readFileSync(latestSnapshotPath, "utf-8");
+    let snapshot = convertPocketBaseMigration(migrationContent);
+    const snapshotFilename = path5__namespace.basename(latestSnapshotPath);
+    const snapshotTimestamp = extractTimestampFromFilename(snapshotFilename);
+    if (snapshotTimestamp) {
+      const migrationFiles = findMigrationsAfterSnapshot(migrationsPath, snapshotTimestamp);
+      for (const migrationFile of migrationFiles) {
+        try {
+          const migrationContent2 = fs3__namespace.readFileSync(migrationFile, "utf-8");
+          const operations = parseMigrationOperations(migrationContent2);
+          snapshot = applyMigrationOperations(snapshot, operations);
+        } catch (error) {
+          console.warn(`Failed to apply migration ${migrationFile}: ${error}`);
+        }
+      }
+    }
+    return snapshot;
+  } catch (error) {
+    console.warn(`Failed to load snapshot from ${latestSnapshotPath}: ${error}`);
+    return null;
+  }
+}
 function loadSnapshotIfExists(config = {}) {
   const migrationsPath = config.migrationsPath;
   if (!migrationsPath) {
     return null;
   }
-  if (fs2__namespace.existsSync(migrationsPath) && fs2__namespace.statSync(migrationsPath).isFile()) {
+  if (fs3__namespace.existsSync(migrationsPath) && fs3__namespace.statSync(migrationsPath).isFile()) {
     try {
-      const migrationContent = fs2__namespace.readFileSync(migrationsPath, "utf-8");
+      const migrationContent = fs3__namespace.readFileSync(migrationsPath, "utf-8");
       return convertPocketBaseMigration(migrationContent);
     } catch (error) {
       console.warn(`Failed to load snapshot from ${migrationsPath}: ${error}`);
@@ -2506,7 +2986,7 @@ function loadSnapshotIfExists(config = {}) {
   const latestSnapshotPath = findLatestSnapshot(migrationsPath);
   if (latestSnapshotPath) {
     try {
-      const migrationContent = fs2__namespace.readFileSync(latestSnapshotPath, "utf-8");
+      const migrationContent = fs3__namespace.readFileSync(latestSnapshotPath, "utf-8");
       return convertPocketBaseMigration(migrationContent);
     } catch (error) {
       console.warn(`Failed to load snapshot from ${latestSnapshotPath}: ${error}`);
@@ -2515,99 +2995,9 @@ function loadSnapshotIfExists(config = {}) {
   }
   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)) {
+    if (!fs3__namespace.existsSync(migrationPath)) {
       throw new SnapshotError(
         `Base migration file not found: ${migrationPath}
 
@@ -2618,7 +3008,7 @@ If the file exists in a different location, update the configuration.`,
         "read"
       );
     }
-    const migrationContent = fs2__namespace.readFileSync(migrationPath, "utf-8");
+    const migrationContent = fs3__namespace.readFileSync(migrationPath, "utf-8");
     const snapshot = convertPocketBaseMigration(migrationContent);
     return snapshot;
   } catch (error) {
@@ -2654,14 +3044,14 @@ Please ensure PocketBase is properly set up by running 'yarn setup'.`,
   }
 }
 function getSnapshotVersion() {
-  return SNAPSHOT_VERSION;
+  return SNAPSHOT_VERSION2;
 }
 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}`);
+  } else if (compareVersions(snapshot.version, SNAPSHOT_VERSION2) > 0) {
+    issues.push(`Snapshot version ${snapshot.version} is newer than supported version ${SNAPSHOT_VERSION2}`);
   }
   if (!snapshot.timestamp) {
     issues.push("Missing timestamp field");
@@ -2880,6 +3270,9 @@ function compareFieldOptions(currentField, previousField) {
   for (const key of allKeys) {
     const currentValue = currentOptions[key];
     const previousValue = previousOptions[key];
+    if (currentValue === void 0 && previousValue === void 0) {
+      continue;
+    }
     if (!areValuesEqual(currentValue, previousValue)) {
       changes.push({
         property: `options.${key}`,
@@ -2900,11 +3293,26 @@ function compareRelationConfigurations(currentField, previousField) {
   if (!currentRelation || !previousRelation) {
     return changes;
   }
-  if (currentRelation.collection !== previousRelation.collection) {
+  const normalizeCollection = (collection) => {
+    if (!collection) return collection;
+    if (collection === "_pb_users_auth_") {
+      return "Users";
+    }
+    const nameMatch = collection.match(/app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\)/);
+    if (nameMatch) {
+      return nameMatch[1];
+    }
+    return collection;
+  };
+  const normalizedCurrent = normalizeCollection(currentRelation.collection);
+  const normalizedPrevious = normalizeCollection(previousRelation.collection);
+  if (normalizedCurrent !== normalizedPrevious) {
     changes.push({
       property: "relation.collection",
-      oldValue: previousRelation.collection,
-      newValue: currentRelation.collection
+      oldValue: normalizedPrevious,
+      // Use normalized value for clarity
+      newValue: normalizedCurrent
+      // Use normalized value for clarity
     });
   }
   if (currentRelation.cascadeDelete !== previousRelation.cascadeDelete) {
@@ -3258,10 +3666,8 @@ var DiffEngine = class {
 var DEFAULT_TEMPLATE = `/// <reference path="{{TYPES_PATH}}" />
 migrate((app) => {
 {{UP_CODE}}
-  return true;
 }, (app) => {
 {{DOWN_CODE}}
-  return true;
 });
 `;
 var DEFAULT_CONFIG4 = {
@@ -3279,10 +3685,10 @@ function mergeConfig4(config) {
 }
 function resolveMigrationDir(config) {
   const workspaceRoot = config.workspaceRoot || process.cwd();
-  if (path4__namespace.isAbsolute(config.migrationDir)) {
+  if (path5__namespace.isAbsolute(config.migrationDir)) {
     return config.migrationDir;
   }
-  return path4__namespace.join(workspaceRoot, config.migrationDir);
+  return path5__namespace.join(workspaceRoot, config.migrationDir);
 }
 function generateTimestamp(config) {
   if (config?.timestampGenerator) {
@@ -3340,9 +3746,9 @@ function createMigrationFileStructure(upCode, downCode, config) {
 }
 function writeMigrationFile(migrationDir, filename, content) {
   try {
-    if (!fs2__namespace.existsSync(migrationDir)) {
+    if (!fs3__namespace.existsSync(migrationDir)) {
       try {
-        fs2__namespace.mkdirSync(migrationDir, { recursive: true });
+        fs3__namespace.mkdirSync(migrationDir, { recursive: true });
       } catch (error) {
         const fsError = error;
         if (fsError.code === "EACCES" || fsError.code === "EPERM") {
@@ -3363,15 +3769,15 @@ function writeMigrationFile(migrationDir, filename, content) {
         );
       }
     }
-    const filePath = path4__namespace.join(migrationDir, filename);
-    fs2__namespace.writeFileSync(filePath, content, "utf-8");
+    const filePath = path5__namespace.join(migrationDir, filename);
+    fs3__namespace.writeFileSync(filePath, content, "utf-8");
     return filePath;
   } catch (error) {
     if (error instanceof FileSystemError) {
       throw error;
     }
     const fsError = error;
-    const filePath = path4__namespace.join(migrationDir, filename);
+    const filePath = path5__namespace.join(migrationDir, filename);
     if (fsError.code === "EACCES" || fsError.code === "EPERM") {
       throw new FileSystemError(
         `Permission denied writing migration file. Check file and directory permissions.`,
@@ -3426,7 +3832,8 @@ function generateFieldDefinitionObject(field) {
     }
   }
   if (field.relation) {
-    const collectionIdPlaceholder = field.relation.collection === "Users" ? '"_pb_users_auth_"' : `app.findCollectionByNameOrId("${field.relation.collection}").id`;
+    const isUsersCollection = field.relation.collection.toLowerCase() === "users";
+    const collectionIdPlaceholder = isUsersCollection ? '"_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}`);
@@ -3510,7 +3917,7 @@ function generateIndexesArray(indexes) {
     ${indexStrings.join(",\n    ")},
   ]`;
 }
-function generateCollectionCreation(collection, varName = "collection") {
+function generateCollectionCreation(collection, varName = "collection", isLast = false) {
   const lines = [];
   lines.push(`  const ${varName} = new Collection({`);
   lines.push(`    name: "${collection.name}",`);
@@ -3526,7 +3933,7 @@ function generateCollectionCreation(collection, varName = "collection") {
   lines.push(`    indexes: ${generateIndexesArray(collection.indexes)},`);
   lines.push(`  });`);
   lines.push(``);
-  lines.push(`  app.save(${varName});`);
+  lines.push(isLast ? `  return app.save(${varName});` : `  app.save(${varName});`);
   return lines.join("\n");
 }
 function getFieldConstructorName(fieldType) {
@@ -3557,7 +3964,8 @@ function generateFieldConstructorOptions(field) {
     }
   }
   if (field.relation && field.type === "relation") {
-    const collectionIdPlaceholder = field.relation.collection === "Users" ? '"_pb_users_auth_"' : `app.findCollectionByNameOrId("${field.relation.collection}").id`;
+    const isUsersCollection = field.relation.collection.toLowerCase() === "users";
+    const collectionIdPlaceholder = isUsersCollection ? '"_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}`);
@@ -3571,7 +3979,7 @@ function generateFieldConstructorOptions(field) {
   }
   return parts.join(",\n");
 }
-function generateFieldAddition(collectionName, field, varName) {
+function generateFieldAddition(collectionName, field, varName, isLast = false) {
   const lines = [];
   const constructorName = getFieldConstructorName(field.type);
   const collectionVar = varName || `collection_${collectionName}_${field.name}`;
@@ -3581,10 +3989,10 @@ function generateFieldAddition(collectionName, field, varName) {
   lines.push(generateFieldConstructorOptions(field));
   lines.push(`  }));`);
   lines.push(``);
-  lines.push(`  app.save(${collectionVar});`);
+  lines.push(isLast ? `  return app.save(${collectionVar});` : `  app.save(${collectionVar});`);
   return lines.join("\n");
 }
-function generateFieldModification(collectionName, modification, varName) {
+function generateFieldModification(collectionName, modification, varName, isLast = false) {
   const lines = [];
   const collectionVar = varName || `collection_${collectionName}_${modification.fieldName}`;
   const fieldVar = `${collectionVar}_field`;
@@ -3598,7 +4006,8 @@ function generateFieldModification(collectionName, modification, varName) {
     } 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`;
+        const isUsersCollection = String(change.newValue).toLowerCase() === "users";
+        const collectionIdValue = isUsersCollection ? '"_pb_users_auth_"' : `app.findCollectionByNameOrId("${change.newValue}").id`;
         lines.push(`  ${fieldVar}.collectionId = ${collectionIdValue};`);
       } else {
         lines.push(`  ${fieldVar}.${relationKey} = ${formatValue(change.newValue)};`);
@@ -3608,10 +4017,10 @@ function generateFieldModification(collectionName, modification, varName) {
     }
   }
   lines.push(``);
-  lines.push(`  app.save(${collectionVar});`);
+  lines.push(isLast ? `  return app.save(${collectionVar});` : `  app.save(${collectionVar});`);
   return lines.join("\n");
 }
-function generateFieldDeletion(collectionName, fieldName, varName) {
+function generateFieldDeletion(collectionName, fieldName, varName, isLast = false) {
   const lines = [];
   const collectionVar = varName || `collection_${collectionName}_${fieldName}`;
   const fieldVar = `${collectionVar}_field`;
@@ -3620,18 +4029,18 @@ function generateFieldDeletion(collectionName, fieldName, varName) {
   lines.push(``);
   lines.push(`  ${collectionVar}.fields.remove(${fieldVar}.id);`);
   lines.push(``);
-  lines.push(`  app.save(${collectionVar});`);
+  lines.push(isLast ? `  return app.save(${collectionVar});` : `  app.save(${collectionVar});`);
   return lines.join("\n");
 }
-function generateIndexAddition(collectionName, index, varName) {
+function generateIndexAddition(collectionName, index, varName, isLast = false) {
   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});`);
+  lines.push(isLast ? `  return app.save(${collectionVar});` : `  app.save(${collectionVar});`);
   return lines.join("\n");
 }
-function generateIndexRemoval(collectionName, index, varName) {
+function generateIndexRemoval(collectionName, index, varName, isLast = false) {
   const lines = [];
   const collectionVar = varName || `collection_${collectionName}_idx`;
   const indexVar = `${collectionVar}_indexToRemove`;
@@ -3640,29 +4049,29 @@ function generateIndexRemoval(collectionName, index, varName) {
   lines.push(`  if (${indexVar} !== -1) {`);
   lines.push(`    ${collectionVar}.indexes.splice(${indexVar}, 1);`);
   lines.push(`  }`);
-  lines.push(`  app.save(${collectionVar});`);
+  lines.push(isLast ? `  return app.save(${collectionVar});` : `  app.save(${collectionVar});`);
   return lines.join("\n");
 }
-function generateRuleUpdate(collectionName, ruleType, newValue, varName) {
+function generateRuleUpdate(collectionName, ruleType, newValue, varName, isLast = false) {
   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});`);
+  lines.push(isLast ? `  return app.save(${collectionVar});` : `  app.save(${collectionVar});`);
   return lines.join("\n");
 }
-function generatePermissionUpdate(collectionName, ruleType, newValue, varName) {
+function generatePermissionUpdate(collectionName, ruleType, newValue, varName, isLast = false) {
   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});`);
+  lines.push(isLast ? `  return app.save(${collectionVar});` : `  app.save(${collectionVar});`);
   return lines.join("\n");
 }
-function generateCollectionDeletion(collectionName, varName = "collection") {
+function generateCollectionDeletion(collectionName, varName = "collection", isLast = false) {
   const lines = [];
   lines.push(`  const ${varName} = app.findCollectionByNameOrId("${collectionName}");`);
-  lines.push(`  app.delete(${varName});`);
+  lines.push(isLast ? `  return app.delete(${varName});` : `  app.delete(${varName});`);
   return lines.join("\n");
 }
 function generateUpMigration(diff) {
@@ -3754,7 +4163,24 @@ function generateUpMigration(diff) {
     lines.push(`  // No changes detected`);
     lines.push(``);
   }
-  return lines.join("\n");
+  let code = lines.join("\n");
+  const savePattern = /^(\s*)app\.save\((\w+)\);$/gm;
+  const deletePattern = /^(\s*)app\.delete\((\w+)\);$/gm;
+  const saveMatches = [...code.matchAll(savePattern)];
+  const deleteMatches = [...code.matchAll(deletePattern)];
+  const allMatches = [
+    ...saveMatches.map((m) => ({ match: m, type: "save", index: m.index })),
+    ...deleteMatches.map((m) => ({ match: m, type: "delete", index: m.index }))
+  ].sort((a, b) => b.index - a.index);
+  if (allMatches.length > 0) {
+    const lastMatch = allMatches[0];
+    if (lastMatch.type === "save") {
+      code = code.substring(0, lastMatch.match.index) + lastMatch.match[1] + "return app.save(" + lastMatch.match[2] + ");" + code.substring(lastMatch.match.index + lastMatch.match[0].length);
+    } else {
+      code = code.substring(0, lastMatch.match.index) + lastMatch.match[1] + "return app.delete(" + lastMatch.match[2] + ");" + code.substring(lastMatch.match.index + lastMatch.match[0].length);
+    }
+  }
+  return code;
 }
 function generateDownMigration(diff) {
   const lines = [];
@@ -3856,7 +4282,24 @@ function generateDownMigration(diff) {
     lines.push(`  // No changes to revert`);
     lines.push(``);
   }
-  return lines.join("\n");
+  let code = lines.join("\n");
+  const savePattern = /^(\s*)app\.save\((\w+)\);$/gm;
+  const deletePattern = /^(\s*)app\.delete\((\w+)\);$/gm;
+  const saveMatches = [...code.matchAll(savePattern)];
+  const deleteMatches = [...code.matchAll(deletePattern)];
+  const allMatches = [
+    ...saveMatches.map((m) => ({ match: m, type: "save", index: m.index })),
+    ...deleteMatches.map((m) => ({ match: m, type: "delete", index: m.index }))
+  ].sort((a, b) => b.index - a.index);
+  if (allMatches.length > 0) {
+    const lastMatch = allMatches[0];
+    if (lastMatch.type === "save") {
+      code = code.substring(0, lastMatch.match.index) + lastMatch.match[1] + "return app.save(" + lastMatch.match[2] + ");" + code.substring(lastMatch.match.index + lastMatch.match[0].length);
+    } else {
+      code = code.substring(0, lastMatch.match.index) + lastMatch.match[1] + "return app.delete(" + lastMatch.match[2] + ");" + code.substring(lastMatch.match.index + lastMatch.match[0].length);
+    }
+  }
+  return code;
 }
 function generate(diff, config) {
   const normalizedConfig = typeof config === "string" ? { migrationDir: config } : config;
@@ -4078,8 +4521,8 @@ var DEFAULT_CONFIG5 = {
 };
 function findConfigFile(directory) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path4__namespace.join(directory, fileName);
-    if (fs2__namespace.existsSync(filePath)) {
+    const filePath = path5__namespace.join(directory, fileName);
+    if (fs3__namespace.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -4087,7 +4530,7 @@ function findConfigFile(directory) {
 }
 function loadJsonConfig(configPath) {
   try {
-    const content = fs2__namespace.readFileSync(configPath, "utf-8");
+    const content = fs3__namespace.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -4116,10 +4559,10 @@ async function loadJsConfig(configPath) {
   }
 }
 async function loadConfigFile(configPath) {
-  if (!fs2__namespace.existsSync(configPath)) {
+  if (!fs3__namespace.existsSync(configPath)) {
     return null;
   }
-  const ext = path4__namespace.extname(configPath).toLowerCase();
+  const ext = path5__namespace.extname(configPath).toLowerCase();
   if (ext === ".json") {
     return loadJsonConfig(configPath);
   } else if (ext === ".js" || ext === ".mjs") {
@@ -4186,10 +4629,10 @@ function validateConfig(config, configPath) {
   }
   const cwd = process.cwd();
   const possiblePaths = [
-    path4__namespace.resolve(cwd, config.schema.directory),
-    path4__namespace.resolve(cwd, "shared", config.schema.directory)
+    path5__namespace.resolve(cwd, config.schema.directory),
+    path5__namespace.resolve(cwd, "shared", config.schema.directory)
   ];
-  const schemaDir = possiblePaths.find((p) => fs2__namespace.existsSync(p));
+  const schemaDir = possiblePaths.find((p) => fs3__namespace.existsSync(p));
   if (!schemaDir) {
     throw new ConfigurationError(`Schema directory not found. Tried: ${possiblePaths.join(", ")}`, configPath, [
       "schema.directory"
@@ -4201,15 +4644,15 @@ async function loadConfig(options = {}) {
   let configFilePath;
   const cwd = process.cwd();
   if (options.config) {
-    const explicitPath = path4__namespace.resolve(cwd, options.config);
-    if (!fs2__namespace.existsSync(explicitPath)) {
+    const explicitPath = path5__namespace.resolve(cwd, options.config);
+    if (!fs3__namespace.existsSync(explicitPath)) {
       throw new ConfigurationError(`Configuration file not found: ${explicitPath}`, explicitPath);
     }
     configFilePath = explicitPath;
   } else {
-    const searchDirs = [cwd, path4__namespace.join(cwd, "shared")];
+    const searchDirs = [cwd, path5__namespace.join(cwd, "shared")];
     for (const dir of searchDirs) {
-      if (fs2__namespace.existsSync(dir)) {
+      if (fs3__namespace.existsSync(dir)) {
         const found = findConfigFile(dir);
         if (found) {
           configFilePath = found;
@@ -4238,18 +4681,18 @@ async function loadConfig(options = {}) {
 function getSchemaDirectory(config) {
   const cwd = process.cwd();
   const possiblePaths = [
-    path4__namespace.resolve(cwd, config.schema.directory),
-    path4__namespace.resolve(cwd, "shared", config.schema.directory)
+    path5__namespace.resolve(cwd, config.schema.directory),
+    path5__namespace.resolve(cwd, "shared", config.schema.directory)
   ];
-  return possiblePaths.find((p) => fs2__namespace.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs3__namespace.existsSync(p)) || possiblePaths[0];
 }
 function getMigrationsDirectory(config) {
   const cwd = process.cwd();
   const possiblePaths = [
-    path4__namespace.resolve(cwd, config.migrations.directory),
-    path4__namespace.resolve(cwd, "shared", config.migrations.directory)
+    path5__namespace.resolve(cwd, config.migrations.directory),
+    path5__namespace.resolve(cwd, "shared", config.migrations.directory)
   ];
-  return possiblePaths.find((p) => fs2__namespace.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs3__namespace.existsSync(p)) || possiblePaths[0];
 }
 var currentVerbosity = "normal";
 function setVerbosity(level) {
@@ -4457,10 +4900,16 @@ async function executeGenerate(options) {
     const schemaDir = getSchemaDirectory(config);
     const migrationsDir = getMigrationsDirectory(config);
     logSection("\u{1F50D} Analyzing Schema");
-    const currentSchema = await withProgress("Parsing Zod schemas...", () => parseSchemaFiles(schemaDir));
+    const analyzerConfig = {
+      schemaDir,
+      excludePatterns: config.schema.exclude,
+      useCompiledFiles: false
+      // Use source files since we're in development/testing
+    };
+    const currentSchema = await withProgress("Parsing Zod schemas...", () => parseSchemaFiles(analyzerConfig));
     logSuccess(`Found ${currentSchema.collections.size} collection(s)`);
     logInfo("Loading previous snapshot...");
-    const previousSnapshot = loadSnapshotIfExists({
+    const previousSnapshot = loadSnapshotWithMigrations({
       migrationsPath: migrationsDir,
       workspaceRoot: process.cwd()
     });
@@ -4487,7 +4936,7 @@ async function executeGenerate(options) {
       "Creating migration file...",
       () => Promise.resolve(generate(diff, migrationsDir))
     );
-    logSuccess(`Migration file created: ${path4__namespace.basename(migrationPath)}`);
+    logSuccess(`Migration file created: ${path5__namespace.basename(migrationPath)}`);
     logSection("\u2705 Next Steps");
     console.log();
     console.log("  1. Review the generated migration file:");
@@ -4644,10 +5093,16 @@ async function executeStatus(options) {
     const schemaDir = getSchemaDirectory(config);
     const migrationsDir = getMigrationsDirectory(config);
     logSection("\u{1F50D} Checking Migration Status");
-    const currentSchema = await withProgress("Parsing Zod schemas...", () => parseSchemaFiles(schemaDir));
+    const analyzerConfig = {
+      schemaDir,
+      excludePatterns: config.schema.exclude,
+      useCompiledFiles: false
+      // Use source files since we're in development/testing
+    };
+    const currentSchema = await withProgress("Parsing Zod schemas...", () => parseSchemaFiles(analyzerConfig));
     logSuccess(`Found ${currentSchema.collections.size} collection(s) in schema`);
     logInfo("Loading previous snapshot...");
-    const previousSnapshot = loadSnapshotIfExists({
+    const previousSnapshot = loadSnapshotWithMigrations({
       migrationsPath: migrationsDir,
       workspaceRoot: process.cwd()
     });
@@ -4796,6 +5251,7 @@ exports.extractComprehensiveFieldOptions = extractComprehensiveFieldOptions;
 exports.extractFieldDefinitions = extractFieldDefinitions;
 exports.extractFieldOptions = extractFieldOptions;
 exports.extractIndexes = extractIndexes;
+exports.extractRelationMetadata = extractRelationMetadata;
 exports.extractSchemaDefinitions = extractSchemaDefinitions;
 exports.fileField = fileField;
 exports.filesField = filesField;
@@ -4854,6 +5310,7 @@ exports.loadBaseMigration = loadBaseMigration;
 exports.loadConfig = loadConfig;
 exports.loadSnapshot = loadSnapshot;
 exports.loadSnapshotIfExists = loadSnapshotIfExists;
+exports.loadSnapshotWithMigrations = loadSnapshotWithMigrations;
 exports.logError = logError;
 exports.logInfo = logInfo;
 exports.logSection = logSection;