pocketbase-zod-schema 0.1.2 → 0.1.4

package/dist/cli/migrate.cjs

@@ -3,8 +3,9 @@
 
 var chalk = require('chalk');
 var commander = require('commander');
-var path4 = require('path');
-var fs4 = require('fs');
+var fs5 = require('fs');
+var path5 = require('path');
+var url = require('url');
 var zod = require('zod');
 var ora = require('ora');
 
@@ -29,10 +30,43 @@ function _interopNamespace(e) {
 }
 
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
-var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
-var fs4__namespace = /*#__PURE__*/_interopNamespace(fs4);
+var fs5__namespace = /*#__PURE__*/_interopNamespace(fs5);
+var path5__namespace = /*#__PURE__*/_interopNamespace(path5);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
 
+// ../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+({
+  id: zod.z.string().describe("unique id"),
+  collectionId: zod.z.string().describe("collection id"),
+  collectionName: zod.z.string().describe("collection name"),
+  expand: zod.z.record(zod.z.any()).describe("expandable fields")
+});
+({
+  created: zod.z.string().describe("creation timestamp"),
+  updated: zod.z.string().describe("last update timestamp")
+});
+({
+  thumbnailURL: zod.z.string().optional(),
+  imageFiles: zod.z.array(zod.z.string())
+});
+({
+  imageFiles: zod.z.array(zod.z.instanceof(File))
+});
+var RELATION_METADATA_KEY = "__pocketbase_relation__";
+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;
+}
+
 // src/migration/errors.ts
 var MigrationError = class _MigrationError extends Error {
   constructor(message) {
@@ -130,10 +164,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;
@@ -196,7 +230,7 @@ Cause: ${this.originalError.message}`);
   }
 };
 
-// src/schema/permission-templates.ts
+// src/utils/permission-templates.ts
 var PermissionTemplates = {
   /**
    * Public access - anyone can perform all operations
@@ -855,26 +889,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;
 }
 function mapZodStringType(zodType) {
   const checks = zodType._def.checks || [];
@@ -1072,20 +1108,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 (!fs4__namespace.existsSync(schemaDir)) {
+    if (!fs5__namespace.existsSync(schemaDir)) {
       throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
     }
-    const files = fs4__namespace.readdirSync(schemaDir);
+    const files = fs5__namespace.readdirSync(schemaDir);
     const schemaFiles = files.filter((file) => {
       const hasValidExtension = mergedConfig.includeExtensions.some((ext) => file.endsWith(ext));
       if (!hasValidExtension) return false;
@@ -1101,7 +1137,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) {
@@ -1132,13 +1168,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 (fs5__namespace.existsSync(jsPath)) {
+      resolvedPath = jsPath;
+    } else if (fs5__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 = fs5__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,
@@ -1147,7 +1202,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"]) {
@@ -1201,7 +1256,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);
@@ -1213,6 +1278,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;
 }
@@ -1265,11 +1337,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
   };
@@ -1293,7 +1366,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 (fs5__namespace.existsSync(`${distPath}.js`) || fs5__namespace.existsSync(`${distPath}.mjs`)) {
+          importPath = distPath;
+        } else {
+          importPath = filePath;
+        }
       }
       const module = await importSchemaModule(importPath, normalizedConfig);
       const schemas = extractSchemaDefinitions(module, mergedConfig.schemaPatterns);
@@ -1466,6 +1544,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}`,
@@ -1486,11 +1567,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) {
@@ -1691,10 +1787,8 @@ function compare(currentSchema, previousSnapshot, config) {
 var DEFAULT_TEMPLATE = `/// <reference path="{{TYPES_PATH}}" />
 migrate((app) => {
 {{UP_CODE}}
-  return true;
 }, (app) => {
 {{DOWN_CODE}}
-  return true;
 });
 `;
 var DEFAULT_CONFIG3 = {
@@ -1712,10 +1806,10 @@ function mergeConfig3(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) {
@@ -1773,9 +1867,9 @@ function createMigrationFileStructure(upCode, downCode, config) {
 }
 function writeMigrationFile(migrationDir, filename, content) {
   try {
-    if (!fs4__namespace.existsSync(migrationDir)) {
+    if (!fs5__namespace.existsSync(migrationDir)) {
       try {
-        fs4__namespace.mkdirSync(migrationDir, { recursive: true });
+        fs5__namespace.mkdirSync(migrationDir, { recursive: true });
       } catch (error) {
         const fsError = error;
         if (fsError.code === "EACCES" || fsError.code === "EPERM") {
@@ -1796,15 +1890,15 @@ function writeMigrationFile(migrationDir, filename, content) {
         );
       }
     }
-    const filePath = path4__namespace.join(migrationDir, filename);
-    fs4__namespace.writeFileSync(filePath, content, "utf-8");
+    const filePath = path5__namespace.join(migrationDir, filename);
+    fs5__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.`,
@@ -1859,7 +1953,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}`);
@@ -1943,7 +2038,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}",`);
@@ -1959,7 +2054,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) {
@@ -1990,7 +2085,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}`);
@@ -2004,7 +2100,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}`;
@@ -2014,10 +2110,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`;
@@ -2031,7 +2127,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)};`);
@@ -2041,10 +2138,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`;
@@ -2053,18 +2150,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`;
@@ -2073,29 +2170,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) {
@@ -2187,7 +2284,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 = [];
@@ -2289,7 +2403,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;
@@ -2312,57 +2443,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__namespace.existsSync(migrationsPath)) {
-      return null;
-    }
-    const files = fs4__namespace.readdirSync(migrationsPath);
-    const snapshotFiles = files.filter(
-      (file) => file.endsWith("_collections_snapshot.js") || file.endsWith("_snapshot.js")
-    );
-    if (snapshotFiles.length === 0) {
-      return null;
-    }
-    snapshotFiles.sort().reverse();
-    const latestSnapshot = snapshotFiles[0];
-    if (!latestSnapshot) {
-      return null;
-    }
-    return path4__namespace.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;
+  const nameMatch = collectionId.match(/app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\)/);
+  if (nameMatch) {
+    return nameMatch[1];
   }
-  if (fs4__namespace.existsSync(migrationsPath) && fs4__namespace.statSync(migrationsPath).isFile()) {
-    try {
-      const migrationContent = fs4__namespace.readFileSync(migrationsPath, "utf-8");
-      return convertPocketBaseMigration(migrationContent);
-    } catch (error) {
-      console.warn(`Failed to load snapshot from ${migrationsPath}: ${error}`);
-      return null;
-    }
-  }
-  const latestSnapshotPath = findLatestSnapshot(migrationsPath);
-  if (latestSnapshotPath) {
-    try {
-      const migrationContent = fs4__namespace.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 = [];
@@ -2381,17 +2473,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);
     }
   }
@@ -2412,6 +2515,7 @@ function convertPocketBaseCollection(pbCollection) {
   if (pbCollection.manageRule !== void 0) rules.manageRule = pbCollection.manageRule;
   if (Object.keys(rules).length > 0) {
     schema.rules = rules;
+    schema.permissions = { ...rules };
   }
   return schema;
 }
@@ -2455,6 +2559,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__namespace.existsSync(migrationsPath)) {
+      return [];
+    }
+    const files = fs5__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: [] };
+  }
+}
+({
+  workspaceRoot: process.cwd()});
+function findLatestSnapshot(migrationsPath) {
+  try {
+    if (!fs5__namespace.existsSync(migrationsPath)) {
+      return null;
+    }
+    const files = fs5__namespace.readdirSync(migrationsPath);
+    const snapshotFiles = files.filter(
+      (file) => file.endsWith("_collections_snapshot.js") || file.endsWith("_snapshot.js")
+    );
+    if (snapshotFiles.length === 0) {
+      return null;
+    }
+    snapshotFiles.sort().reverse();
+    const latestSnapshot = snapshotFiles[0];
+    if (!latestSnapshot) {
+      return null;
+    }
+    return 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 (fs5__namespace.existsSync(migrationsPath) && fs5__namespace.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs5__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 = fs5__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 = fs5__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;
+  }
+}
+
 // src/migration/validation.ts
 function detectCollectionDeletions(diff) {
   const changes = [];
@@ -2623,8 +3041,8 @@ var DEFAULT_CONFIG5 = {
 };
 function findConfigFile(directory) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path4__namespace.join(directory, fileName);
-    if (fs4__namespace.existsSync(filePath)) {
+    const filePath = path5__namespace.join(directory, fileName);
+    if (fs5__namespace.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -2632,7 +3050,7 @@ function findConfigFile(directory) {
 }
 function loadJsonConfig(configPath) {
   try {
-    const content = fs4__namespace.readFileSync(configPath, "utf-8");
+    const content = fs5__namespace.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -2661,10 +3079,10 @@ async function loadJsConfig(configPath) {
   }
 }
 async function loadConfigFile(configPath) {
-  if (!fs4__namespace.existsSync(configPath)) {
+  if (!fs5__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") {
@@ -2731,10 +3149,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) => fs4__namespace.existsSync(p));
+  const schemaDir = possiblePaths.find((p) => fs5__namespace.existsSync(p));
   if (!schemaDir) {
     throw new ConfigurationError(`Schema directory not found. Tried: ${possiblePaths.join(", ")}`, configPath, [
       "schema.directory"
@@ -2746,15 +3164,15 @@ async function loadConfig(options = {}) {
   let configFilePath;
   const cwd = process.cwd();
   if (options.config) {
-    const explicitPath = path4__namespace.resolve(cwd, options.config);
-    if (!fs4__namespace.existsSync(explicitPath)) {
+    const explicitPath = path5__namespace.resolve(cwd, options.config);
+    if (!fs5__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 (fs4__namespace.existsSync(dir)) {
+      if (fs5__namespace.existsSync(dir)) {
         const found = findConfigFile(dir);
         if (found) {
           configFilePath = found;
@@ -2783,18 +3201,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) => fs4__namespace.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs5__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) => fs4__namespace.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs5__namespace.existsSync(p)) || possiblePaths[0];
 }
 var currentVerbosity = "normal";
 function setVerbosity(level) {
@@ -3002,10 +3420,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()
     });
@@ -3032,7 +3456,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:");
@@ -3201,10 +3625,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()
     });
@@ -3317,7 +3747,19 @@ Examples:
 }
 
 // src/cli/migrate.ts
-var VERSION = "0.1.0";
+function getVersion() {
+  try {
+    const __filename2 = url.fileURLToPath(importMetaUrl);
+    const __dirname = path5.dirname(__filename2);
+    const packageJsonPath = path5.join(__dirname, "../../package.json");
+    const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version || "0.0.0";
+  } catch {
+    console.warn("Warning: Could not read version from package.json");
+    return "0.0.0";
+  }
+}
+var VERSION = getVersion();
 function displayBanner() {
   console.log();
   console.log(chalk__default.default.cyan.bold("  PocketBase Zod Migration Tool"));