pocketbase-zod-schema 0.1.3 → 0.2.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import * as fs2 from 'fs';
-import * as path4 from 'path';
+import * as fs3 from 'fs';
+import * as path5 from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
 
@@ -78,7 +78,7 @@ function filesField(options) {
   return schema;
 }
 var RELATION_METADATA_KEY = "__pocketbase_relation__";
-function relationField(config) {
+function RelationField(config) {
   const metadata = {
     [RELATION_METADATA_KEY]: {
       type: "single",
@@ -90,7 +90,7 @@ function relationField(config) {
   };
   return z.string().describe(JSON.stringify(metadata));
 }
-function relationsField(config) {
+function RelationsField(config) {
   const metadata = {
     [RELATION_METADATA_KEY]: {
       type: "multiple",
@@ -149,6 +149,22 @@ function withIndexes(schema, indexes) {
   };
   return schema.describe(JSON.stringify(metadata));
 }
+function defineCollection(config) {
+  const { collectionName, schema, permissions, indexes, ...futureOptions } = config;
+  const metadata = {
+    collectionName
+  };
+  if (permissions) {
+    metadata.permissions = permissions;
+  }
+  if (indexes) {
+    metadata.indexes = indexes;
+  }
+  if (Object.keys(futureOptions).length > 0) {
+    Object.assign(metadata, futureOptions);
+  }
+  return schema.describe(JSON.stringify(metadata));
+}
 
 // src/utils/permission-templates.ts
 var PermissionTemplates = {
@@ -369,6 +385,28 @@ function mergePermissions(...schemas) {
   }
   return merged;
 }
+var ProjectInputSchema = z.object({
+  // Required fields
+  title: z.string(),
+  content: z.string(),
+  status: StatusEnum,
+  summary: z.string().optional(),
+  OwnerUser: RelationField({ collection: "Users" }),
+  SubscriberUsers: RelationsField({ collection: "Users" })
+}).extend(inputImageFileSchema);
+var ProjectSchema = ProjectInputSchema.omit(omitImageFilesSchema).extend(baseImageFileSchema);
+var ProjectCollection = defineCollection({
+  collectionName: "Projects",
+  schema: ProjectSchema,
+  permissions: {
+    template: "owner-only",
+    ownerField: "OwnerUser",
+    customRules: {
+      listRule: '@request.auth.id != ""',
+      viewRule: '@request.auth.id != "" && (OwnerUser = @request.auth.id || SubscriberUsers ?= @request.auth.id)'
+    }
+  }
+});
 var UserInputSchema = z.object({
   name: z.string().optional(),
   email: z.string().email(),
@@ -376,14 +414,17 @@ var UserInputSchema = z.object({
   passwordConfirm: z.string(),
   avatar: z.instanceof(File).optional()
 });
-var UserDatabaseSchema = z.object({
+var UserCollectionSchema = z.object({
   name: z.string().optional(),
   email: z.string().email(),
   password: z.string().min(8, "Password must be at least 8 characters"),
   avatar: z.instanceof(File).optional()
 });
-var UserSchema = withIndexes(
-  withPermissions(UserDatabaseSchema.extend(baseSchema), {
+var UserSchema = UserCollectionSchema.extend(baseSchema);
+var UserCollection = defineCollection({
+  collectionName: "Users",
+  schema: UserSchema,
+  permissions: {
     // Users can list their own profile
     listRule: "id = @request.auth.id",
     // Users can view their own profile
@@ -395,13 +436,13 @@ var UserSchema = withIndexes(
     // Users can only delete their own account
     deleteRule: "id = @request.auth.id"
     // manageRule is null in PocketBase default (not set)
-  }),
-  [
+  },
+  indexes: [
     // 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 {
   pb;
   // Define a default property that subclasses will override
@@ -844,10 +885,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;
@@ -1923,6 +1964,16 @@ function getFieldTypeInfo(zodType, fieldName) {
 }
 
 // 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: [
@@ -1950,20 +2001,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 (!fs2.existsSync(schemaDir)) {
+    if (!fs3.existsSync(schemaDir)) {
       throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
     }
-    const files = fs2.readdirSync(schemaDir);
+    const files = fs3.readdirSync(schemaDir);
     const schemaFiles = files.filter((file) => {
       const hasValidExtension = mergedConfig.includeExtensions.some((ext) => file.endsWith(ext));
       if (!hasValidExtension) return false;
@@ -1979,7 +2030,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) {
@@ -2013,40 +2064,66 @@ async function importSchemaModule(filePath, config) {
     let resolvedPath = null;
     const jsPath = `${importPath}.js`;
     const tsPath = `${importPath}.ts`;
-    if (fs2.existsSync(jsPath)) {
+    if (fs3.existsSync(jsPath)) {
       resolvedPath = jsPath;
-    } else if (fs2.existsSync(tsPath)) {
+    } else if (fs3.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 = fs2.existsSync(tsPath);
+    const isTypeScriptFile = fs3.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)) {
@@ -2209,7 +2286,7 @@ async function buildSchemaDefinition(config) {
         importPath = normalizedConfig.pathTransformer(filePath);
       } else if (mergedConfig.useCompiledFiles) {
         const distPath = filePath.replace(/\/src\//, "/dist/");
-        if (fs2.existsSync(`${distPath}.js`) || fs2.existsSync(`${distPath}.mjs`)) {
+        if (fs3.existsSync(`${distPath}.js`) || fs3.existsSync(`${distPath}.mjs`)) {
           importPath = distPath;
         } else {
           importPath = filePath;
@@ -2222,7 +2299,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) {
@@ -2265,7 +2343,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.existsSync(migrationsPath)) {
+      return [];
+    }
+    const files = fs3.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: [] };
+  }
+}
+
+// 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
@@ -2280,7 +2710,7 @@ var DEFAULT_CONFIG2 = {
   snapshotPath: DEFAULT_SNAPSHOT_FILENAME,
   workspaceRoot: process.cwd(),
   autoMigrate: true,
-  version: SNAPSHOT_VERSION
+  version: SNAPSHOT_VERSION2
 };
 function mergeConfig2(config = {}) {
   return {
@@ -2292,15 +2722,15 @@ function getSnapshotPath(config = {}) {
   const mergedConfig = mergeConfig2(config);
   const workspaceRoot = mergedConfig.workspaceRoot;
   const snapshotFilename = mergedConfig.snapshotPath;
-  if (path4.isAbsolute(snapshotFilename)) {
+  if (path5.isAbsolute(snapshotFilename)) {
     return snapshotFilename;
   }
-  return path4.join(workspaceRoot, snapshotFilename);
+  return path5.join(workspaceRoot, snapshotFilename);
 }
 function snapshotExists(config = {}) {
   try {
     const snapshotPath = getSnapshotPath(config);
-    return fs2.existsSync(snapshotPath);
+    return fs3.existsSync(snapshotPath);
   } catch {
     return false;
   }
@@ -2359,13 +2789,13 @@ function addSnapshotMetadata(schema, config) {
 function saveSnapshot(schema, config = {}) {
   const snapshotPath = getSnapshotPath(config);
   try {
-    const snapshotDir = path4.dirname(snapshotPath);
-    if (!fs2.existsSync(snapshotDir)) {
-      fs2.mkdirSync(snapshotDir, { recursive: true });
+    const snapshotDir = path5.dirname(snapshotPath);
+    if (!fs3.existsSync(snapshotDir)) {
+      fs3.mkdirSync(snapshotDir, { recursive: true });
     }
     const snapshotData = addSnapshotMetadata(schema, config);
     const jsonContent = JSON.stringify(snapshotData, null, 2);
-    fs2.writeFileSync(snapshotPath, jsonContent, "utf-8");
+    fs3.writeFileSync(snapshotPath, jsonContent, "utf-8");
   } catch (error) {
     handleFileSystemError(error, "write", snapshotPath);
   }
@@ -2460,7 +2890,7 @@ function deserializeSnapshot(data) {
 function loadSnapshot(config = {}) {
   const snapshotPath = getSnapshotPath(config);
   try {
-    const jsonContent = fs2.readFileSync(snapshotPath, "utf-8");
+    const jsonContent = fs3.readFileSync(snapshotPath, "utf-8");
     const data = parseAndValidateSnapshot(jsonContent, snapshotPath);
     const migratedData = migrateSnapshotFormat(data, config);
     return deserializeSnapshot(migratedData);
@@ -2495,10 +2925,10 @@ function mergeSnapshots(baseSnapshot, customSnapshot) {
 }
 function findLatestSnapshot(migrationsPath) {
   try {
-    if (!fs2.existsSync(migrationsPath)) {
+    if (!fs3.existsSync(migrationsPath)) {
       return null;
     }
-    const files = fs2.readdirSync(migrationsPath);
+    const files = fs3.readdirSync(migrationsPath);
     const snapshotFiles = files.filter(
       (file) => file.endsWith("_collections_snapshot.js") || file.endsWith("_snapshot.js")
     );
@@ -2510,20 +2940,74 @@ function findLatestSnapshot(migrationsPath) {
     if (!latestSnapshot) {
       return null;
     }
-    return path4.join(migrationsPath, latestSnapshot);
+    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 (fs3.existsSync(migrationsPath) && fs3.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs3.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.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 = fs3.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.existsSync(migrationsPath) && fs2.statSync(migrationsPath).isFile()) {
+  if (fs3.existsSync(migrationsPath) && fs3.statSync(migrationsPath).isFile()) {
     try {
-      const migrationContent = fs2.readFileSync(migrationsPath, "utf-8");
+      const migrationContent = fs3.readFileSync(migrationsPath, "utf-8");
       return convertPocketBaseMigration(migrationContent);
     } catch (error) {
       console.warn(`Failed to load snapshot from ${migrationsPath}: ${error}`);
@@ -2533,7 +3017,7 @@ function loadSnapshotIfExists(config = {}) {
   const latestSnapshotPath = findLatestSnapshot(migrationsPath);
   if (latestSnapshotPath) {
     try {
-      const migrationContent = fs2.readFileSync(latestSnapshotPath, "utf-8");
+      const migrationContent = fs3.readFileSync(latestSnapshotPath, "utf-8");
       return convertPocketBaseMigration(migrationContent);
     } catch (error) {
       console.warn(`Failed to load snapshot from ${latestSnapshotPath}: ${error}`);
@@ -2542,100 +3026,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;
-    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
-    );
-  }
-}
 function loadBaseMigration(migrationPath) {
   try {
-    if (!fs2.existsSync(migrationPath)) {
+    if (!fs3.existsSync(migrationPath)) {
       throw new SnapshotError(
         `Base migration file not found: ${migrationPath}
 
@@ -2646,7 +3039,7 @@ If the file exists in a different location, update the configuration.`,
         "read"
       );
     }
-    const migrationContent = fs2.readFileSync(migrationPath, "utf-8");
+    const migrationContent = fs3.readFileSync(migrationPath, "utf-8");
     const snapshot = convertPocketBaseMigration(migrationContent);
     return snapshot;
   } catch (error) {
@@ -2682,14 +3075,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");
@@ -2908,6 +3301,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}`,
@@ -2928,11 +3324,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) {
@@ -3305,10 +3716,10 @@ function mergeConfig4(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) {
@@ -3366,9 +3777,9 @@ function createMigrationFileStructure(upCode, downCode, config) {
 }
 function writeMigrationFile(migrationDir, filename, content) {
   try {
-    if (!fs2.existsSync(migrationDir)) {
+    if (!fs3.existsSync(migrationDir)) {
       try {
-        fs2.mkdirSync(migrationDir, { recursive: true });
+        fs3.mkdirSync(migrationDir, { recursive: true });
       } catch (error) {
         const fsError = error;
         if (fsError.code === "EACCES" || fsError.code === "EPERM") {
@@ -3389,15 +3800,15 @@ function writeMigrationFile(migrationDir, filename, content) {
         );
       }
     }
-    const filePath = path4.join(migrationDir, filename);
-    fs2.writeFileSync(filePath, content, "utf-8");
+    const filePath = path5.join(migrationDir, filename);
+    fs3.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.`,
@@ -4141,8 +4552,8 @@ var DEFAULT_CONFIG5 = {
 };
 function findConfigFile(directory) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path4.join(directory, fileName);
-    if (fs2.existsSync(filePath)) {
+    const filePath = path5.join(directory, fileName);
+    if (fs3.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -4150,7 +4561,7 @@ function findConfigFile(directory) {
 }
 function loadJsonConfig(configPath) {
   try {
-    const content = fs2.readFileSync(configPath, "utf-8");
+    const content = fs3.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -4179,10 +4590,10 @@ async function loadJsConfig(configPath) {
   }
 }
 async function loadConfigFile(configPath) {
-  if (!fs2.existsSync(configPath)) {
+  if (!fs3.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") {
@@ -4249,10 +4660,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) => fs2.existsSync(p));
+  const schemaDir = possiblePaths.find((p) => fs3.existsSync(p));
   if (!schemaDir) {
     throw new ConfigurationError(`Schema directory not found. Tried: ${possiblePaths.join(", ")}`, configPath, [
       "schema.directory"
@@ -4264,15 +4675,15 @@ async function loadConfig(options = {}) {
   let configFilePath;
   const cwd = process.cwd();
   if (options.config) {
-    const explicitPath = path4.resolve(cwd, options.config);
-    if (!fs2.existsSync(explicitPath)) {
+    const explicitPath = path5.resolve(cwd, options.config);
+    if (!fs3.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 (fs2.existsSync(dir)) {
+      if (fs3.existsSync(dir)) {
         const found = findConfigFile(dir);
         if (found) {
           configFilePath = found;
@@ -4301,18 +4712,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) => fs2.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs3.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) => fs2.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs3.existsSync(p)) || possiblePaths[0];
 }
 var currentVerbosity = "normal";
 function setVerbosity(level) {
@@ -4529,7 +4940,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()
     });
@@ -4556,7 +4967,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:");
@@ -4722,7 +5133,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()
     });
@@ -4823,6 +5234,6 @@ async function executeStatus(options) {
   }
 }
 
-export { CLIUsageError, ConfigurationError, DiffEngine, FIELD_TYPE_INFO, FileSystemError, MigrationError, MigrationGenerationError, MigrationGenerator, POCKETBASE_FIELD_TYPES, PermissionTemplates, SchemaAnalyzer, SchemaParsingError, SnapshotError, SnapshotManager, StatusEnum, UserInputSchema, UserMutator, UserSchema, aggregateChanges, baseImageFileSchema, baseSchema, baseSchemaWithTimestamps, boolField, buildFieldDefinition, buildSchemaDefinition, categorizeChangesBySeverity, compare, compareFieldConstraints, compareFieldOptions, compareFieldTypes, comparePermissions, compareRelationConfigurations, convertPocketBaseMigration, convertZodSchemaToCollectionSchema, createMigrationFileStructure, createPermissions, dateField, detectDestructiveChanges, detectFieldChanges, discoverSchemaFiles, editorField, emailField, extractComprehensiveFieldOptions, extractFieldDefinitions, extractFieldOptions, extractIndexes, extractRelationMetadata, extractSchemaDefinitions, fileField, filesField, filterSystemCollections, findLatestSnapshot, findNewCollections, findNewFields, findRemovedCollections, findRemovedFields, formatChangeSummary, generate, generateChangeSummary, generateCollectionCreation, generateCollectionPermissions, generateCollectionRules, generateDownMigration, generateFieldAddition, generateFieldDefinitionObject, generateFieldDeletion, generateFieldModification, generateFieldsArray, generateIndexesArray, executeGenerate as generateMigration, generateMigrationDescription, generateMigrationFilename, generatePermissionUpdate, generateTimestamp, generateUpMigration, geoPointField, getArrayElementType, getCollectionNameFromFile, getDefaultValue, getFieldTypeInfo, getMaxSelect, executeStatus as getMigrationStatus, getMinSelect, getSnapshotPath, getSnapshotVersion, getUsersSystemFields, importSchemaModule, inputImageFileSchema, isArrayType, isAuthCollection, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isPermissionSchema, isRelationField, isSingleRelationField, isSystemCollection, isTemplateConfig, jsonField, loadBaseMigration, loadConfig, loadSnapshot, loadSnapshotIfExists, logError, logInfo, logSection, logSuccess, logWarning, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, matchCollectionsByName, matchFieldsByName, mergePermissions, mergeSnapshots, numberField, omitImageFilesSchema, parseSchemaFiles, pluralize, relationField, relationsField, requiresForceFlag, resolveTargetCollection, resolveTemplate, saveSnapshot, selectField, selectSchemaForCollection, singularize, snapshotExists, textField, toCollectionName, unwrapZodType, urlField, validatePermissionConfig, validateRuleExpression, validateSnapshot, withIndexes, withPermissions, withProgress, writeMigrationFile };
+export { CLIUsageError, ConfigurationError, DiffEngine, FIELD_TYPE_INFO, FileSystemError, MigrationError, MigrationGenerationError, MigrationGenerator, POCKETBASE_FIELD_TYPES, PermissionTemplates, ProjectCollection, ProjectInputSchema, ProjectSchema, RelationField, RelationsField, SchemaAnalyzer, SchemaParsingError, SnapshotError, SnapshotManager, StatusEnum, UserCollection, UserCollectionSchema, UserInputSchema, UserMutator, UserSchema, aggregateChanges, baseImageFileSchema, baseSchema, baseSchemaWithTimestamps, boolField, buildFieldDefinition, buildSchemaDefinition, categorizeChangesBySeverity, compare, compareFieldConstraints, compareFieldOptions, compareFieldTypes, comparePermissions, compareRelationConfigurations, convertPocketBaseMigration, convertZodSchemaToCollectionSchema, createMigrationFileStructure, createPermissions, dateField, defineCollection, detectDestructiveChanges, detectFieldChanges, discoverSchemaFiles, editorField, emailField, extractComprehensiveFieldOptions, extractFieldDefinitions, extractFieldOptions, extractIndexes, extractRelationMetadata, extractSchemaDefinitions, fileField, filesField, filterSystemCollections, findLatestSnapshot, findNewCollections, findNewFields, findRemovedCollections, findRemovedFields, formatChangeSummary, generate, generateChangeSummary, generateCollectionCreation, generateCollectionPermissions, generateCollectionRules, generateDownMigration, generateFieldAddition, generateFieldDefinitionObject, generateFieldDeletion, generateFieldModification, generateFieldsArray, generateIndexesArray, executeGenerate as generateMigration, generateMigrationDescription, generateMigrationFilename, generatePermissionUpdate, generateTimestamp, generateUpMigration, geoPointField, getArrayElementType, getCollectionNameFromFile, getDefaultValue, getFieldTypeInfo, getMaxSelect, executeStatus as getMigrationStatus, getMinSelect, getSnapshotPath, getSnapshotVersion, getUsersSystemFields, importSchemaModule, inputImageFileSchema, isArrayType, isAuthCollection, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isPermissionSchema, isRelationField, isSingleRelationField, isSystemCollection, isTemplateConfig, jsonField, loadBaseMigration, loadConfig, loadSnapshot, loadSnapshotIfExists, loadSnapshotWithMigrations, logError, logInfo, logSection, logSuccess, logWarning, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, matchCollectionsByName, matchFieldsByName, mergePermissions, mergeSnapshots, numberField, omitImageFilesSchema, parseSchemaFiles, pluralize, requiresForceFlag, resolveTargetCollection, resolveTemplate, saveSnapshot, selectField, selectSchemaForCollection, singularize, snapshotExists, textField, toCollectionName, unwrapZodType, urlField, validatePermissionConfig, validateRuleExpression, validateSnapshot, withIndexes, withPermissions, withProgress, writeMigrationFile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map