pocketbase-zod-schema 0.1.3 → 0.2.0

package/dist/cli/migrate.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import chalk from 'chalk';
 import { Command } from 'commander';
-import * as fs4 from 'fs';
+import * as fs5 from 'fs';
 import { readFileSync } from 'fs';
-import * as path4 from 'path';
+import * as path5 from 'path';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { z } from 'zod';
@@ -136,10 +136,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;
@@ -1053,6 +1053,16 @@ function isFieldRequired(zodType) {
 }
 
 // src/migration/analyzer.ts
+var tsxLoaderRegistered = false;
+async function ensureTsxLoader() {
+  if (tsxLoaderRegistered) return;
+  try {
+    await import('tsx/esm');
+    tsxLoaderRegistered = true;
+  } catch {
+    tsxLoaderRegistered = false;
+  }
+}
 var DEFAULT_CONFIG = {
   workspaceRoot: process.cwd(),
   excludePatterns: [
@@ -1080,20 +1090,20 @@ function mergeConfig(config) {
 }
 function resolveSchemaDir(config) {
   const workspaceRoot = config.workspaceRoot || process.cwd();
-  if (path4.isAbsolute(config.schemaDir)) {
+  if (path5.isAbsolute(config.schemaDir)) {
     return config.schemaDir;
   }
-  return path4.join(workspaceRoot, config.schemaDir);
+  return path5.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 (!fs4.existsSync(schemaDir)) {
+    if (!fs5.existsSync(schemaDir)) {
       throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
     }
-    const files = fs4.readdirSync(schemaDir);
+    const files = fs5.readdirSync(schemaDir);
     const schemaFiles = files.filter((file) => {
       const hasValidExtension = mergedConfig.includeExtensions.some((ext) => file.endsWith(ext));
       if (!hasValidExtension) return false;
@@ -1109,7 +1119,7 @@ function discoverSchemaFiles(config) {
     });
     return schemaFiles.map((file) => {
       const ext = mergedConfig.includeExtensions.find((ext2) => file.endsWith(ext2)) || ".ts";
-      return path4.join(schemaDir, file.replace(new RegExp(`\\${ext}$`), ""));
+      return path5.join(schemaDir, file.replace(new RegExp(`\\${ext}$`), ""));
     });
   } catch (error) {
     if (error instanceof FileSystemError) {
@@ -1143,40 +1153,66 @@ async function importSchemaModule(filePath, config) {
     let resolvedPath = null;
     const jsPath = `${importPath}.js`;
     const tsPath = `${importPath}.ts`;
-    if (fs4.existsSync(jsPath)) {
+    if (fs5.existsSync(jsPath)) {
       resolvedPath = jsPath;
-    } else if (fs4.existsSync(tsPath)) {
+    } else if (fs5.existsSync(tsPath)) {
       resolvedPath = tsPath;
     } else {
       resolvedPath = jsPath;
     }
-    const fileUrl = new URL(`file://${path4.resolve(resolvedPath)}`);
+    if (resolvedPath.endsWith(".ts")) {
+      await ensureTsxLoader();
+      if (!tsxLoaderRegistered) {
+        throw new SchemaParsingError(
+          `Failed to import TypeScript schema file. The 'tsx' package is required to load TypeScript files.
+Please install tsx: npm install tsx (or yarn add tsx, or pnpm add tsx)
+Alternatively, compile your schema files to JavaScript first.`,
+          filePath
+        );
+      }
+    }
+    const fileUrl = new URL(`file://${path5.resolve(resolvedPath)}`);
     const module = await import(fileUrl.href);
     return module;
   } catch (error) {
     const tsPath = `${filePath}.ts`;
-    const isTypeScriptFile = fs4.existsSync(tsPath);
+    const isTypeScriptFile = fs5.existsSync(tsPath);
+    if (isTypeScriptFile && error instanceof SchemaParsingError) {
+      throw error;
+    }
     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")`,
+        `Failed to import TypeScript schema file. The 'tsx' package is required to load TypeScript files.
+Please install tsx: npm install tsx (or yarn add tsx, or pnpm add tsx)
+Alternatively, compile your schema files to JavaScript first.`,
         filePath,
         error
       );
     }
     throw new SchemaParsingError(
-      `Failed to import schema module. Make sure the schema files are compiled to JavaScript.`,
+      `Failed to import schema module. Make sure the schema files exist and are valid.`,
       filePath,
       error
     );
   }
 }
 function getCollectionNameFromFile(filePath) {
-  const filename = path4.basename(filePath).replace(/\.(ts|js)$/, "");
+  const filename = path5.basename(filePath).replace(/\.(ts|js)$/, "");
   return toCollectionName(filename);
 }
+function extractCollectionNameFromSchema(zodSchema) {
+  if (!zodSchema.description) {
+    return null;
+  }
+  try {
+    const metadata = JSON.parse(zodSchema.description);
+    if (metadata.collectionName && typeof metadata.collectionName === "string") {
+      return metadata.collectionName;
+    }
+  } catch {
+  }
+  return null;
+}
 function extractSchemaDefinitions(module, patterns = ["Schema", "InputSchema"]) {
   const result = {};
   for (const [key, value] of Object.entries(module)) {
@@ -1339,7 +1375,7 @@ async function buildSchemaDefinition(config) {
         importPath = normalizedConfig.pathTransformer(filePath);
       } else if (mergedConfig.useCompiledFiles) {
         const distPath = filePath.replace(/\/src\//, "/dist/");
-        if (fs4.existsSync(`${distPath}.js`) || fs4.existsSync(`${distPath}.mjs`)) {
+        if (fs5.existsSync(`${distPath}.js`) || fs5.existsSync(`${distPath}.mjs`)) {
           importPath = distPath;
         } else {
           importPath = filePath;
@@ -1352,7 +1388,8 @@ async function buildSchemaDefinition(config) {
         console.warn(`No valid schema found in ${filePath}, skipping...`);
         continue;
       }
-      const collectionName = getCollectionNameFromFile(filePath);
+      const collectionNameFromSchema = extractCollectionNameFromSchema(zodSchema);
+      const collectionName = collectionNameFromSchema ?? getCollectionNameFromFile(filePath);
       const collectionSchema = convertZodSchemaToCollectionSchema(collectionName, zodSchema);
       collections.set(collectionName, collectionSchema);
     } catch (error) {
@@ -1516,6 +1553,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}`,
@@ -1536,11 +1576,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) {
@@ -1760,10 +1815,10 @@ function mergeConfig3(config) {
 }
 function resolveMigrationDir(config) {
   const workspaceRoot = config.workspaceRoot || process.cwd();
-  if (path4.isAbsolute(config.migrationDir)) {
+  if (path5.isAbsolute(config.migrationDir)) {
     return config.migrationDir;
   }
-  return path4.join(workspaceRoot, config.migrationDir);
+  return path5.join(workspaceRoot, config.migrationDir);
 }
 function generateTimestamp(config) {
   if (config?.timestampGenerator) {
@@ -1821,9 +1876,9 @@ function createMigrationFileStructure(upCode, downCode, config) {
 }
 function writeMigrationFile(migrationDir, filename, content) {
   try {
-    if (!fs4.existsSync(migrationDir)) {
+    if (!fs5.existsSync(migrationDir)) {
       try {
-        fs4.mkdirSync(migrationDir, { recursive: true });
+        fs5.mkdirSync(migrationDir, { recursive: true });
       } catch (error) {
         const fsError = error;
         if (fsError.code === "EACCES" || fsError.code === "EPERM") {
@@ -1844,15 +1899,15 @@ function writeMigrationFile(migrationDir, filename, content) {
         );
       }
     }
-    const filePath = path4.join(migrationDir, filename);
-    fs4.writeFileSync(filePath, content, "utf-8");
+    const filePath = path5.join(migrationDir, filename);
+    fs5.writeFileSync(filePath, content, "utf-8");
     return filePath;
   } catch (error) {
     if (error instanceof FileSystemError) {
       throw error;
     }
     const fsError = error;
-    const filePath = path4.join(migrationDir, filename);
+    const filePath = path5.join(migrationDir, filename);
     if (fsError.code === "EACCES" || fsError.code === "EPERM") {
       throw new FileSystemError(
         `Permission denied writing migration file. Check file and directory permissions.`,
@@ -2397,57 +2452,18 @@ function generate(diff, config) {
     );
   }
 }
+
+// src/migration/pocketbase-converter.ts
 var SNAPSHOT_VERSION = "1.0.0";
-({
-  workspaceRoot: process.cwd()});
-function findLatestSnapshot(migrationsPath) {
-  try {
-    if (!fs4.existsSync(migrationsPath)) {
-      return null;
-    }
-    const files = fs4.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 path4.join(migrationsPath, latestSnapshot);
-  } catch (error) {
-    console.warn(`Error finding latest snapshot: ${error}`);
-    return null;
+function resolveCollectionIdToName(collectionId) {
+  if (collectionId === "_pb_users_auth_") {
+    return "Users";
   }
-}
-function loadSnapshotIfExists(config = {}) {
-  const migrationsPath = config.migrationsPath;
-  if (!migrationsPath) {
-    return null;
-  }
-  if (fs4.existsSync(migrationsPath) && fs4.statSync(migrationsPath).isFile()) {
-    try {
-      const migrationContent = fs4.readFileSync(migrationsPath, "utf-8");
-      return convertPocketBaseMigration(migrationContent);
-    } catch (error) {
-      console.warn(`Failed to load snapshot from ${migrationsPath}: ${error}`);
-      return null;
-    }
+  const nameMatch = collectionId.match(/app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\)/);
+  if (nameMatch) {
+    return nameMatch[1];
   }
-  const latestSnapshotPath = findLatestSnapshot(migrationsPath);
-  if (latestSnapshotPath) {
-    try {
-      const migrationContent = fs4.readFileSync(latestSnapshotPath, "utf-8");
-      return convertPocketBaseMigration(migrationContent);
-    } catch (error) {
-      console.warn(`Failed to load snapshot from ${latestSnapshotPath}: ${error}`);
-      return null;
-    }
-  }
-  return null;
+  return collectionId;
 }
 function convertPocketBaseCollection(pbCollection) {
   const fields = [];
@@ -2466,17 +2482,28 @@ function convertPocketBaseCollection(pbCollection) {
         type: pbField.type,
         required: pbField.required || false
       };
-      if (pbField.options) {
-        field.options = pbField.options;
+      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: pbField.options?.collectionId || "",
-          cascadeDelete: pbField.options?.cascadeDelete || false,
-          maxSelect: pbField.options?.maxSelect,
-          minSelect: pbField.options?.minSelect
+          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);
     }
   }
@@ -2541,6 +2568,320 @@ function convertPocketBaseMigration(migrationContent) {
   }
 }
 
+// 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 (!fs5.existsSync(migrationsPath)) {
+      return [];
+    }
+    const files = fs5.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.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: [] };
+  }
+}
+({
+  workspaceRoot: process.cwd()});
+function findLatestSnapshot(migrationsPath) {
+  try {
+    if (!fs5.existsSync(migrationsPath)) {
+      return null;
+    }
+    const files = fs5.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 path5.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 (fs5.existsSync(migrationsPath) && fs5.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs5.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 = fs5.readFileSync(latestSnapshotPath, "utf-8");
+    let snapshot = convertPocketBaseMigration(migrationContent);
+    const snapshotFilename = path5.basename(latestSnapshotPath);
+    const snapshotTimestamp = extractTimestampFromFilename(snapshotFilename);
+    if (snapshotTimestamp) {
+      const migrationFiles = findMigrationsAfterSnapshot(migrationsPath, snapshotTimestamp);
+      for (const migrationFile of migrationFiles) {
+        try {
+          const migrationContent2 = fs5.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;
+  }
+}
+
 // src/migration/validation.ts
 function detectCollectionDeletions(diff) {
   const changes = [];
@@ -2709,8 +3050,8 @@ var DEFAULT_CONFIG5 = {
 };
 function findConfigFile(directory) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path4.join(directory, fileName);
-    if (fs4.existsSync(filePath)) {
+    const filePath = path5.join(directory, fileName);
+    if (fs5.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -2718,7 +3059,7 @@ function findConfigFile(directory) {
 }
 function loadJsonConfig(configPath) {
   try {
-    const content = fs4.readFileSync(configPath, "utf-8");
+    const content = fs5.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -2747,10 +3088,10 @@ async function loadJsConfig(configPath) {
   }
 }
 async function loadConfigFile(configPath) {
-  if (!fs4.existsSync(configPath)) {
+  if (!fs5.existsSync(configPath)) {
     return null;
   }
-  const ext = path4.extname(configPath).toLowerCase();
+  const ext = path5.extname(configPath).toLowerCase();
   if (ext === ".json") {
     return loadJsonConfig(configPath);
   } else if (ext === ".js" || ext === ".mjs") {
@@ -2817,10 +3158,10 @@ function validateConfig(config, configPath) {
   }
   const cwd = process.cwd();
   const possiblePaths = [
-    path4.resolve(cwd, config.schema.directory),
-    path4.resolve(cwd, "shared", config.schema.directory)
+    path5.resolve(cwd, config.schema.directory),
+    path5.resolve(cwd, "shared", config.schema.directory)
   ];
-  const schemaDir = possiblePaths.find((p) => fs4.existsSync(p));
+  const schemaDir = possiblePaths.find((p) => fs5.existsSync(p));
   if (!schemaDir) {
     throw new ConfigurationError(`Schema directory not found. Tried: ${possiblePaths.join(", ")}`, configPath, [
       "schema.directory"
@@ -2832,15 +3173,15 @@ async function loadConfig(options = {}) {
   let configFilePath;
   const cwd = process.cwd();
   if (options.config) {
-    const explicitPath = path4.resolve(cwd, options.config);
-    if (!fs4.existsSync(explicitPath)) {
+    const explicitPath = path5.resolve(cwd, options.config);
+    if (!fs5.existsSync(explicitPath)) {
       throw new ConfigurationError(`Configuration file not found: ${explicitPath}`, explicitPath);
     }
     configFilePath = explicitPath;
   } else {
-    const searchDirs = [cwd, path4.join(cwd, "shared")];
+    const searchDirs = [cwd, path5.join(cwd, "shared")];
     for (const dir of searchDirs) {
-      if (fs4.existsSync(dir)) {
+      if (fs5.existsSync(dir)) {
         const found = findConfigFile(dir);
         if (found) {
           configFilePath = found;
@@ -2869,18 +3210,18 @@ async function loadConfig(options = {}) {
 function getSchemaDirectory(config) {
   const cwd = process.cwd();
   const possiblePaths = [
-    path4.resolve(cwd, config.schema.directory),
-    path4.resolve(cwd, "shared", config.schema.directory)
+    path5.resolve(cwd, config.schema.directory),
+    path5.resolve(cwd, "shared", config.schema.directory)
   ];
-  return possiblePaths.find((p) => fs4.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs5.existsSync(p)) || possiblePaths[0];
 }
 function getMigrationsDirectory(config) {
   const cwd = process.cwd();
   const possiblePaths = [
-    path4.resolve(cwd, config.migrations.directory),
-    path4.resolve(cwd, "shared", config.migrations.directory)
+    path5.resolve(cwd, config.migrations.directory),
+    path5.resolve(cwd, "shared", config.migrations.directory)
   ];
-  return possiblePaths.find((p) => fs4.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs5.existsSync(p)) || possiblePaths[0];
 }
 var currentVerbosity = "normal";
 function setVerbosity(level) {
@@ -3097,7 +3438,7 @@ async function executeGenerate(options) {
     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()
     });
@@ -3124,7 +3465,7 @@ async function executeGenerate(options) {
       "Creating migration file...",
       () => Promise.resolve(generate(diff, migrationsDir))
     );
-    logSuccess(`Migration file created: ${path4.basename(migrationPath)}`);
+    logSuccess(`Migration file created: ${path5.basename(migrationPath)}`);
     logSection("\u2705 Next Steps");
     console.log();
     console.log("  1. Review the generated migration file:");
@@ -3302,7 +3643,7 @@ async function executeStatus(options) {
     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()
     });