pocketbase-zod-schema 0.1.3 → 0.2.0

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 var zod = require('zod');
-var fs2 = require('fs');
-var path4 = require('path');
+var fs3 = require('fs');
+var path5 = require('path');
 var chalk = require('chalk');
 var ora = require('ora');
 
@@ -26,8 +26,8 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
-var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path5__namespace = /*#__PURE__*/_interopNamespace(path5);
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
 
@@ -105,7 +105,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",
@@ -117,7 +117,7 @@ function relationField(config) {
   };
   return zod.z.string().describe(JSON.stringify(metadata));
 }
-function relationsField(config) {
+function RelationsField(config) {
   const metadata = {
     [RELATION_METADATA_KEY]: {
       type: "multiple",
@@ -176,6 +176,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 = {
@@ -396,6 +412,28 @@ function mergePermissions(...schemas) {
   }
   return merged;
 }
+var ProjectInputSchema = zod.z.object({
+  // Required fields
+  title: zod.z.string(),
+  content: zod.z.string(),
+  status: StatusEnum,
+  summary: zod.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 = zod.z.object({
   name: zod.z.string().optional(),
   email: zod.z.string().email(),
@@ -403,14 +441,17 @@ var UserInputSchema = zod.z.object({
   passwordConfirm: zod.z.string(),
   avatar: zod.z.instanceof(File).optional()
 });
-var UserDatabaseSchema = zod.z.object({
+var UserCollectionSchema = zod.z.object({
   name: zod.z.string().optional(),
   email: zod.z.string().email(),
   password: zod.z.string().min(8, "Password must be at least 8 characters"),
   avatar: zod.z.instanceof(File).optional()
 });
-var UserSchema = withIndexes(
-  withPermissions(UserDatabaseSchema.extend(baseSchema), {
+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
@@ -422,13 +463,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
@@ -871,10 +912,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;
@@ -1950,6 +1991,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: [
@@ -1977,20 +2028,20 @@ function mergeConfig(config) {
 }
 function resolveSchemaDir(config) {
   const workspaceRoot = config.workspaceRoot || process.cwd();
-  if (path4__namespace.isAbsolute(config.schemaDir)) {
+  if (path5__namespace.isAbsolute(config.schemaDir)) {
     return config.schemaDir;
   }
-  return path4__namespace.join(workspaceRoot, config.schemaDir);
+  return path5__namespace.join(workspaceRoot, config.schemaDir);
 }
 function discoverSchemaFiles(config) {
   const normalizedConfig = typeof config === "string" ? { schemaDir: config } : config;
   const mergedConfig = mergeConfig(normalizedConfig);
   const schemaDir = resolveSchemaDir(normalizedConfig);
   try {
-    if (!fs2__namespace.existsSync(schemaDir)) {
+    if (!fs3__namespace.existsSync(schemaDir)) {
       throw new FileSystemError(`Schema directory not found: ${schemaDir}`, schemaDir, "access", "ENOENT");
     }
-    const files = fs2__namespace.readdirSync(schemaDir);
+    const files = fs3__namespace.readdirSync(schemaDir);
     const schemaFiles = files.filter((file) => {
       const hasValidExtension = mergedConfig.includeExtensions.some((ext) => file.endsWith(ext));
       if (!hasValidExtension) return false;
@@ -2006,7 +2057,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) {
@@ -2040,40 +2091,66 @@ async function importSchemaModule(filePath, config) {
     let resolvedPath = null;
     const jsPath = `${importPath}.js`;
     const tsPath = `${importPath}.ts`;
-    if (fs2__namespace.existsSync(jsPath)) {
+    if (fs3__namespace.existsSync(jsPath)) {
       resolvedPath = jsPath;
-    } else if (fs2__namespace.existsSync(tsPath)) {
+    } else if (fs3__namespace.existsSync(tsPath)) {
       resolvedPath = tsPath;
     } else {
       resolvedPath = jsPath;
     }
-    const fileUrl = new URL(`file://${path4__namespace.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__namespace.resolve(resolvedPath)}`);
     const module = await import(fileUrl.href);
     return module;
   } catch (error) {
     const tsPath = `${filePath}.ts`;
-    const isTypeScriptFile = fs2__namespace.existsSync(tsPath);
+    const isTypeScriptFile = fs3__namespace.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__namespace.basename(filePath).replace(/\.(ts|js)$/, "");
+  const filename = path5__namespace.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)) {
@@ -2236,7 +2313,7 @@ async function buildSchemaDefinition(config) {
         importPath = normalizedConfig.pathTransformer(filePath);
       } else if (mergedConfig.useCompiledFiles) {
         const distPath = filePath.replace(/\/src\//, "/dist/");
-        if (fs2__namespace.existsSync(`${distPath}.js`) || fs2__namespace.existsSync(`${distPath}.mjs`)) {
+        if (fs3__namespace.existsSync(`${distPath}.js`) || fs3__namespace.existsSync(`${distPath}.mjs`)) {
           importPath = distPath;
         } else {
           importPath = filePath;
@@ -2249,7 +2326,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) {
@@ -2292,7 +2370,359 @@ var SchemaAnalyzer = class {
     return convertZodSchemaToCollectionSchema(name, schema);
   }
 };
+
+// src/migration/pocketbase-converter.ts
 var SNAPSHOT_VERSION = "1.0.0";
+function resolveCollectionIdToName(collectionId) {
+  if (collectionId === "_pb_users_auth_") {
+    return "Users";
+  }
+  const nameMatch = collectionId.match(/app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\)/);
+  if (nameMatch) {
+    return nameMatch[1];
+  }
+  return collectionId;
+}
+function convertPocketBaseCollection(pbCollection) {
+  const fields = [];
+  const systemFieldNames = ["id", "created", "updated", "collectionId", "collectionName", "expand"];
+  const authSystemFieldNames = ["email", "emailVisibility", "verified", "password", "tokenKey"];
+  if (pbCollection.fields && Array.isArray(pbCollection.fields)) {
+    for (const pbField of pbCollection.fields) {
+      if (pbField.system || systemFieldNames.includes(pbField.name)) {
+        continue;
+      }
+      if (pbCollection.type === "auth" && authSystemFieldNames.includes(pbField.name)) {
+        continue;
+      }
+      const field = {
+        name: pbField.name,
+        type: pbField.type,
+        required: pbField.required || false
+      };
+      field.options = pbField.options ? { ...pbField.options } : {};
+      if (pbField.type === "select") {
+        if (pbField.values && Array.isArray(pbField.values)) {
+          field.options.values = pbField.values;
+        } else if (pbField.options?.values && Array.isArray(pbField.options.values)) {
+          field.options.values = pbField.options.values;
+        }
+      }
+      if (pbField.type === "relation") {
+        const collectionId = pbField.collectionId || pbField.options?.collectionId || "";
+        const collectionName = resolveCollectionIdToName(collectionId);
+        field.relation = {
+          collection: collectionName,
+          cascadeDelete: pbField.cascadeDelete ?? pbField.options?.cascadeDelete ?? false,
+          maxSelect: pbField.maxSelect ?? pbField.options?.maxSelect,
+          minSelect: pbField.minSelect ?? pbField.options?.minSelect
+        };
+      }
+      const hasOnlyValues = Object.keys(field.options).length === 1 && field.options.values !== void 0;
+      if (Object.keys(field.options).length === 0) {
+        delete field.options;
+      } else if (pbField.type === "select" && hasOnlyValues) ;
+      fields.push(field);
+    }
+  }
+  const schema = {
+    name: pbCollection.name,
+    type: pbCollection.type || "base",
+    fields
+  };
+  if (pbCollection.indexes && Array.isArray(pbCollection.indexes)) {
+    schema.indexes = pbCollection.indexes;
+  }
+  const rules = {};
+  if (pbCollection.listRule !== void 0) rules.listRule = pbCollection.listRule;
+  if (pbCollection.viewRule !== void 0) rules.viewRule = pbCollection.viewRule;
+  if (pbCollection.createRule !== void 0) rules.createRule = pbCollection.createRule;
+  if (pbCollection.updateRule !== void 0) rules.updateRule = pbCollection.updateRule;
+  if (pbCollection.deleteRule !== void 0) rules.deleteRule = pbCollection.deleteRule;
+  if (pbCollection.manageRule !== void 0) rules.manageRule = pbCollection.manageRule;
+  if (Object.keys(rules).length > 0) {
+    schema.rules = rules;
+    schema.permissions = { ...rules };
+  }
+  return schema;
+}
+function convertPocketBaseMigration(migrationContent) {
+  try {
+    const snapshotMatch = migrationContent.match(/const\s+snapshot\s*=\s*(\[[\s\S]*?\]);/);
+    if (!snapshotMatch) {
+      throw new Error("Could not find snapshot array in migration file");
+    }
+    const snapshotArrayStr = snapshotMatch[1];
+    let snapshotArray;
+    try {
+      snapshotArray = new Function(`return ${snapshotArrayStr}`)();
+    } catch (parseError) {
+      throw new Error(`Failed to parse snapshot array: ${parseError}`);
+    }
+    if (!Array.isArray(snapshotArray)) {
+      throw new Error("Snapshot is not an array");
+    }
+    const collections = /* @__PURE__ */ new Map();
+    for (const pbCollection of snapshotArray) {
+      if (!pbCollection.name) {
+        console.warn("Skipping collection without name");
+        continue;
+      }
+      const schema = convertPocketBaseCollection(pbCollection);
+      collections.set(pbCollection.name, schema);
+    }
+    return {
+      version: SNAPSHOT_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      collections
+    };
+  } catch (error) {
+    throw new SnapshotError(
+      `Failed to convert PocketBase migration: ${error instanceof Error ? error.message : String(error)}`,
+      void 0,
+      "parse",
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+
+// src/migration/migration-parser.ts
+function extractTimestampFromFilename(filename) {
+  const match = filename.match(/^(\d+)_/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return null;
+}
+function findMigrationsAfterSnapshot(migrationsPath, snapshotTimestamp) {
+  try {
+    if (!fs3__namespace.existsSync(migrationsPath)) {
+      return [];
+    }
+    const files = fs3__namespace.readdirSync(migrationsPath);
+    const migrationFiles = [];
+    for (const file of files) {
+      if (file.endsWith("_collections_snapshot.js") || file.endsWith("_snapshot.js")) {
+        continue;
+      }
+      if (!file.endsWith(".js")) {
+        continue;
+      }
+      const timestamp = extractTimestampFromFilename(file);
+      if (timestamp && timestamp > snapshotTimestamp) {
+        migrationFiles.push({
+          path: path5__namespace.join(migrationsPath, file),
+          timestamp
+        });
+      }
+    }
+    migrationFiles.sort((a, b) => a.timestamp - b.timestamp);
+    return migrationFiles.map((f) => f.path);
+  } catch (error) {
+    console.warn(`Error finding migrations after snapshot: ${error}`);
+    return [];
+  }
+}
+function parseMigrationOperationsFromContent(content) {
+  const collectionsToCreate = [];
+  const collectionsToDelete = [];
+  try {
+    let searchIndex = 0;
+    while (true) {
+      const collectionStart = content.indexOf("new Collection(", searchIndex);
+      if (collectionStart === -1) {
+        break;
+      }
+      const openParen = collectionStart + "new Collection(".length;
+      let braceCount = 0;
+      let parenCount = 1;
+      let inString = false;
+      let stringChar = null;
+      let i = openParen;
+      while (i < content.length && /\s/.test(content[i])) {
+        i++;
+      }
+      if (content[i] !== "{") {
+        searchIndex = i + 1;
+        continue;
+      }
+      const objectStart = i;
+      braceCount = 1;
+      i++;
+      while (i < content.length && (braceCount > 0 || parenCount > 0)) {
+        const char = content[i];
+        const prevChar = i > 0 ? content[i - 1] : "";
+        if (!inString && (char === '"' || char === "'")) {
+          inString = true;
+          stringChar = char;
+        } else if (inString && char === stringChar && prevChar !== "\\") {
+          inString = false;
+          stringChar = null;
+        }
+        if (!inString) {
+          if (char === "{") braceCount++;
+          if (char === "}") braceCount--;
+          if (char === "(") parenCount++;
+          if (char === ")") parenCount--;
+        }
+        i++;
+      }
+      if (braceCount === 0 && parenCount === 0) {
+        const objectContent = content.substring(objectStart, i - 1);
+        try {
+          const collectionObj = new Function(`return ${objectContent}`)();
+          if (collectionObj && collectionObj.name) {
+            const schema = convertPocketBaseCollection(collectionObj);
+            collectionsToCreate.push(schema);
+          }
+        } catch (error) {
+          console.warn(`Failed to parse collection definition: ${error}`);
+        }
+      }
+      searchIndex = i;
+    }
+    const deleteMatches = content.matchAll(
+      /app\.delete\s*\(\s*(?:collection_\w+|app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\))\s*\)/g
+    );
+    for (const match of deleteMatches) {
+      if (match[1]) {
+        collectionsToDelete.push(match[1]);
+      } else {
+        const varNameMatch = match[0].match(/collection_(\w+)/);
+        if (varNameMatch) {
+          const varName = `collection_${varNameMatch[1]}`;
+          const deleteIndex = content.indexOf(match[0]);
+          const beforeDelete = content.substring(0, deleteIndex);
+          const varDefMatch = beforeDelete.match(
+            new RegExp(`const\\s+${varName}\\s*=\\s*new\\s+Collection\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)`, "g")
+          );
+          if (varDefMatch && varDefMatch.length > 0) {
+            const collectionDefMatch = beforeDelete.match(
+              new RegExp(`const\\s+${varName}\\s*=\\s*new\\s+Collection\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)`)
+            );
+            if (collectionDefMatch) {
+              try {
+                const collectionDefStr = collectionDefMatch[1];
+                const collectionObj = new Function(`return ${collectionDefStr}`)();
+                if (collectionObj && collectionObj.name) {
+                  collectionsToDelete.push(collectionObj.name);
+                }
+              } catch {
+              }
+            }
+          }
+        }
+      }
+    }
+    const findAndDeleteMatches = content.matchAll(
+      /app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\)[\s\S]*?app\.delete/g
+    );
+    for (const match of findAndDeleteMatches) {
+      collectionsToDelete.push(match[1]);
+    }
+  } catch (error) {
+    console.warn(`Failed to parse migration operations from content: ${error}`);
+  }
+  return { collectionsToCreate, collectionsToDelete };
+}
+function parseMigrationOperations(migrationContent) {
+  try {
+    const migrateMatch = migrationContent.match(/migrate\s*\(\s*/);
+    if (!migrateMatch) {
+      return parseMigrationOperationsFromContent(migrationContent);
+    }
+    const startIndex = migrateMatch.index + migrateMatch[0].length;
+    let i = startIndex;
+    let parenCount = 0;
+    let foundFirstParen = false;
+    while (i < migrationContent.length) {
+      const char = migrationContent[i];
+      if (char === "(") {
+        parenCount++;
+        foundFirstParen = true;
+        i++;
+        break;
+      }
+      i++;
+    }
+    if (!foundFirstParen) {
+      return parseMigrationOperationsFromContent(migrationContent);
+    }
+    let inString = false;
+    let stringChar = null;
+    let foundBrace = false;
+    let braceStart = -1;
+    while (i < migrationContent.length && !foundBrace) {
+      const char = migrationContent[i];
+      const prevChar = i > 0 ? migrationContent[i - 1] : "";
+      if (!inString && (char === '"' || char === "'")) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && prevChar !== "\\") {
+        inString = false;
+        stringChar = null;
+      }
+      if (!inString) {
+        if (char === "(") parenCount++;
+        if (char === ")") {
+          parenCount--;
+          if (parenCount === 0) {
+            i++;
+            while (i < migrationContent.length && /\s/.test(migrationContent[i])) {
+              i++;
+            }
+            if (i < migrationContent.length - 1 && migrationContent[i] === "=" && migrationContent[i + 1] === ">") {
+              i += 2;
+              while (i < migrationContent.length && /\s/.test(migrationContent[i])) {
+                i++;
+              }
+              if (i < migrationContent.length && migrationContent[i] === "{") {
+                foundBrace = true;
+                braceStart = i + 1;
+                break;
+              }
+            }
+          }
+        }
+      }
+      i++;
+    }
+    if (!foundBrace || braceStart === -1) {
+      return parseMigrationOperationsFromContent(migrationContent);
+    }
+    let braceCount = 1;
+    i = braceStart;
+    inString = false;
+    stringChar = null;
+    while (i < migrationContent.length && braceCount > 0) {
+      const char = migrationContent[i];
+      const prevChar = i > 0 ? migrationContent[i - 1] : "";
+      if (!inString && (char === '"' || char === "'")) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && prevChar !== "\\") {
+        inString = false;
+        stringChar = null;
+      }
+      if (!inString) {
+        if (char === "{") braceCount++;
+        if (char === "}") braceCount--;
+      }
+      i++;
+    }
+    if (braceCount === 0) {
+      const upMigrationContent = migrationContent.substring(braceStart, i - 1);
+      return parseMigrationOperationsFromContent(upMigrationContent);
+    }
+    return parseMigrationOperationsFromContent(migrationContent);
+  } catch (error) {
+    console.warn(`Failed to parse migration operations: ${error}`);
+    return { collectionsToCreate: [], collectionsToDelete: [] };
+  }
+}
+
+// src/migration/snapshot.ts
+var SNAPSHOT_VERSION2 = "1.0.0";
 var DEFAULT_SNAPSHOT_FILENAME = ".migration-snapshot.json";
 var SNAPSHOT_MIGRATIONS = [
   // Add migrations here as the format evolves
@@ -2307,7 +2737,7 @@ var DEFAULT_CONFIG2 = {
   snapshotPath: DEFAULT_SNAPSHOT_FILENAME,
   workspaceRoot: process.cwd(),
   autoMigrate: true,
-  version: SNAPSHOT_VERSION
+  version: SNAPSHOT_VERSION2
 };
 function mergeConfig2(config = {}) {
   return {
@@ -2319,15 +2749,15 @@ function getSnapshotPath(config = {}) {
   const mergedConfig = mergeConfig2(config);
   const workspaceRoot = mergedConfig.workspaceRoot;
   const snapshotFilename = mergedConfig.snapshotPath;
-  if (path4__namespace.isAbsolute(snapshotFilename)) {
+  if (path5__namespace.isAbsolute(snapshotFilename)) {
     return snapshotFilename;
   }
-  return path4__namespace.join(workspaceRoot, snapshotFilename);
+  return path5__namespace.join(workspaceRoot, snapshotFilename);
 }
 function snapshotExists(config = {}) {
   try {
     const snapshotPath = getSnapshotPath(config);
-    return fs2__namespace.existsSync(snapshotPath);
+    return fs3__namespace.existsSync(snapshotPath);
   } catch {
     return false;
   }
@@ -2386,13 +2816,13 @@ function addSnapshotMetadata(schema, config) {
 function saveSnapshot(schema, config = {}) {
   const snapshotPath = getSnapshotPath(config);
   try {
-    const snapshotDir = path4__namespace.dirname(snapshotPath);
-    if (!fs2__namespace.existsSync(snapshotDir)) {
-      fs2__namespace.mkdirSync(snapshotDir, { recursive: true });
+    const snapshotDir = path5__namespace.dirname(snapshotPath);
+    if (!fs3__namespace.existsSync(snapshotDir)) {
+      fs3__namespace.mkdirSync(snapshotDir, { recursive: true });
     }
     const snapshotData = addSnapshotMetadata(schema, config);
     const jsonContent = JSON.stringify(snapshotData, null, 2);
-    fs2__namespace.writeFileSync(snapshotPath, jsonContent, "utf-8");
+    fs3__namespace.writeFileSync(snapshotPath, jsonContent, "utf-8");
   } catch (error) {
     handleFileSystemError(error, "write", snapshotPath);
   }
@@ -2487,7 +2917,7 @@ function deserializeSnapshot(data) {
 function loadSnapshot(config = {}) {
   const snapshotPath = getSnapshotPath(config);
   try {
-    const jsonContent = fs2__namespace.readFileSync(snapshotPath, "utf-8");
+    const jsonContent = fs3__namespace.readFileSync(snapshotPath, "utf-8");
     const data = parseAndValidateSnapshot(jsonContent, snapshotPath);
     const migratedData = migrateSnapshotFormat(data, config);
     return deserializeSnapshot(migratedData);
@@ -2522,10 +2952,10 @@ function mergeSnapshots(baseSnapshot, customSnapshot) {
 }
 function findLatestSnapshot(migrationsPath) {
   try {
-    if (!fs2__namespace.existsSync(migrationsPath)) {
+    if (!fs3__namespace.existsSync(migrationsPath)) {
       return null;
     }
-    const files = fs2__namespace.readdirSync(migrationsPath);
+    const files = fs3__namespace.readdirSync(migrationsPath);
     const snapshotFiles = files.filter(
       (file) => file.endsWith("_collections_snapshot.js") || file.endsWith("_snapshot.js")
     );
@@ -2537,20 +2967,74 @@ function findLatestSnapshot(migrationsPath) {
     if (!latestSnapshot) {
       return null;
     }
-    return path4__namespace.join(migrationsPath, latestSnapshot);
+    return path5__namespace.join(migrationsPath, latestSnapshot);
   } catch (error) {
     console.warn(`Error finding latest snapshot: ${error}`);
     return null;
   }
 }
+function applyMigrationOperations(snapshot, operations) {
+  const updatedCollections = new Map(snapshot.collections);
+  for (const collectionName of operations.collectionsToDelete) {
+    updatedCollections.delete(collectionName);
+  }
+  for (const collection of operations.collectionsToCreate) {
+    updatedCollections.set(collection.name, collection);
+  }
+  return {
+    ...snapshot,
+    collections: updatedCollections
+  };
+}
+function loadSnapshotWithMigrations(config = {}) {
+  const migrationsPath = config.migrationsPath;
+  if (!migrationsPath) {
+    return null;
+  }
+  if (fs3__namespace.existsSync(migrationsPath) && fs3__namespace.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs3__namespace.readFileSync(migrationsPath, "utf-8");
+      return convertPocketBaseMigration(migrationContent);
+    } catch (error) {
+      console.warn(`Failed to load snapshot from ${migrationsPath}: ${error}`);
+      return null;
+    }
+  }
+  const latestSnapshotPath = findLatestSnapshot(migrationsPath);
+  if (!latestSnapshotPath) {
+    return null;
+  }
+  try {
+    const migrationContent = fs3__namespace.readFileSync(latestSnapshotPath, "utf-8");
+    let snapshot = convertPocketBaseMigration(migrationContent);
+    const snapshotFilename = path5__namespace.basename(latestSnapshotPath);
+    const snapshotTimestamp = extractTimestampFromFilename(snapshotFilename);
+    if (snapshotTimestamp) {
+      const migrationFiles = findMigrationsAfterSnapshot(migrationsPath, snapshotTimestamp);
+      for (const migrationFile of migrationFiles) {
+        try {
+          const migrationContent2 = fs3__namespace.readFileSync(migrationFile, "utf-8");
+          const operations = parseMigrationOperations(migrationContent2);
+          snapshot = applyMigrationOperations(snapshot, operations);
+        } catch (error) {
+          console.warn(`Failed to apply migration ${migrationFile}: ${error}`);
+        }
+      }
+    }
+    return snapshot;
+  } catch (error) {
+    console.warn(`Failed to load snapshot from ${latestSnapshotPath}: ${error}`);
+    return null;
+  }
+}
 function loadSnapshotIfExists(config = {}) {
   const migrationsPath = config.migrationsPath;
   if (!migrationsPath) {
     return null;
   }
-  if (fs2__namespace.existsSync(migrationsPath) && fs2__namespace.statSync(migrationsPath).isFile()) {
+  if (fs3__namespace.existsSync(migrationsPath) && fs3__namespace.statSync(migrationsPath).isFile()) {
     try {
-      const migrationContent = fs2__namespace.readFileSync(migrationsPath, "utf-8");
+      const migrationContent = fs3__namespace.readFileSync(migrationsPath, "utf-8");
       return convertPocketBaseMigration(migrationContent);
     } catch (error) {
       console.warn(`Failed to load snapshot from ${migrationsPath}: ${error}`);
@@ -2560,7 +3044,7 @@ function loadSnapshotIfExists(config = {}) {
   const latestSnapshotPath = findLatestSnapshot(migrationsPath);
   if (latestSnapshotPath) {
     try {
-      const migrationContent = fs2__namespace.readFileSync(latestSnapshotPath, "utf-8");
+      const migrationContent = fs3__namespace.readFileSync(latestSnapshotPath, "utf-8");
       return convertPocketBaseMigration(migrationContent);
     } catch (error) {
       console.warn(`Failed to load snapshot from ${latestSnapshotPath}: ${error}`);
@@ -2569,100 +3053,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__namespace.existsSync(migrationPath)) {
+    if (!fs3__namespace.existsSync(migrationPath)) {
       throw new SnapshotError(
         `Base migration file not found: ${migrationPath}
 
@@ -2673,7 +3066,7 @@ If the file exists in a different location, update the configuration.`,
         "read"
       );
     }
-    const migrationContent = fs2__namespace.readFileSync(migrationPath, "utf-8");
+    const migrationContent = fs3__namespace.readFileSync(migrationPath, "utf-8");
     const snapshot = convertPocketBaseMigration(migrationContent);
     return snapshot;
   } catch (error) {
@@ -2709,14 +3102,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");
@@ -2935,6 +3328,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}`,
@@ -2955,11 +3351,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) {
@@ -3332,10 +3743,10 @@ function mergeConfig4(config) {
 }
 function resolveMigrationDir(config) {
   const workspaceRoot = config.workspaceRoot || process.cwd();
-  if (path4__namespace.isAbsolute(config.migrationDir)) {
+  if (path5__namespace.isAbsolute(config.migrationDir)) {
     return config.migrationDir;
   }
-  return path4__namespace.join(workspaceRoot, config.migrationDir);
+  return path5__namespace.join(workspaceRoot, config.migrationDir);
 }
 function generateTimestamp(config) {
   if (config?.timestampGenerator) {
@@ -3393,9 +3804,9 @@ function createMigrationFileStructure(upCode, downCode, config) {
 }
 function writeMigrationFile(migrationDir, filename, content) {
   try {
-    if (!fs2__namespace.existsSync(migrationDir)) {
+    if (!fs3__namespace.existsSync(migrationDir)) {
       try {
-        fs2__namespace.mkdirSync(migrationDir, { recursive: true });
+        fs3__namespace.mkdirSync(migrationDir, { recursive: true });
       } catch (error) {
         const fsError = error;
         if (fsError.code === "EACCES" || fsError.code === "EPERM") {
@@ -3416,15 +3827,15 @@ function writeMigrationFile(migrationDir, filename, content) {
         );
       }
     }
-    const filePath = path4__namespace.join(migrationDir, filename);
-    fs2__namespace.writeFileSync(filePath, content, "utf-8");
+    const filePath = path5__namespace.join(migrationDir, filename);
+    fs3__namespace.writeFileSync(filePath, content, "utf-8");
     return filePath;
   } catch (error) {
     if (error instanceof FileSystemError) {
       throw error;
     }
     const fsError = error;
-    const filePath = path4__namespace.join(migrationDir, filename);
+    const filePath = path5__namespace.join(migrationDir, filename);
     if (fsError.code === "EACCES" || fsError.code === "EPERM") {
       throw new FileSystemError(
         `Permission denied writing migration file. Check file and directory permissions.`,
@@ -4168,8 +4579,8 @@ var DEFAULT_CONFIG5 = {
 };
 function findConfigFile(directory) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path4__namespace.join(directory, fileName);
-    if (fs2__namespace.existsSync(filePath)) {
+    const filePath = path5__namespace.join(directory, fileName);
+    if (fs3__namespace.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -4177,7 +4588,7 @@ function findConfigFile(directory) {
 }
 function loadJsonConfig(configPath) {
   try {
-    const content = fs2__namespace.readFileSync(configPath, "utf-8");
+    const content = fs3__namespace.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -4206,10 +4617,10 @@ async function loadJsConfig(configPath) {
   }
 }
 async function loadConfigFile(configPath) {
-  if (!fs2__namespace.existsSync(configPath)) {
+  if (!fs3__namespace.existsSync(configPath)) {
     return null;
   }
-  const ext = path4__namespace.extname(configPath).toLowerCase();
+  const ext = path5__namespace.extname(configPath).toLowerCase();
   if (ext === ".json") {
     return loadJsonConfig(configPath);
   } else if (ext === ".js" || ext === ".mjs") {
@@ -4276,10 +4687,10 @@ function validateConfig(config, configPath) {
   }
   const cwd = process.cwd();
   const possiblePaths = [
-    path4__namespace.resolve(cwd, config.schema.directory),
-    path4__namespace.resolve(cwd, "shared", config.schema.directory)
+    path5__namespace.resolve(cwd, config.schema.directory),
+    path5__namespace.resolve(cwd, "shared", config.schema.directory)
   ];
-  const schemaDir = possiblePaths.find((p) => fs2__namespace.existsSync(p));
+  const schemaDir = possiblePaths.find((p) => fs3__namespace.existsSync(p));
   if (!schemaDir) {
     throw new ConfigurationError(`Schema directory not found. Tried: ${possiblePaths.join(", ")}`, configPath, [
       "schema.directory"
@@ -4291,15 +4702,15 @@ async function loadConfig(options = {}) {
   let configFilePath;
   const cwd = process.cwd();
   if (options.config) {
-    const explicitPath = path4__namespace.resolve(cwd, options.config);
-    if (!fs2__namespace.existsSync(explicitPath)) {
+    const explicitPath = path5__namespace.resolve(cwd, options.config);
+    if (!fs3__namespace.existsSync(explicitPath)) {
       throw new ConfigurationError(`Configuration file not found: ${explicitPath}`, explicitPath);
     }
     configFilePath = explicitPath;
   } else {
-    const searchDirs = [cwd, path4__namespace.join(cwd, "shared")];
+    const searchDirs = [cwd, path5__namespace.join(cwd, "shared")];
     for (const dir of searchDirs) {
-      if (fs2__namespace.existsSync(dir)) {
+      if (fs3__namespace.existsSync(dir)) {
         const found = findConfigFile(dir);
         if (found) {
           configFilePath = found;
@@ -4328,18 +4739,18 @@ async function loadConfig(options = {}) {
 function getSchemaDirectory(config) {
   const cwd = process.cwd();
   const possiblePaths = [
-    path4__namespace.resolve(cwd, config.schema.directory),
-    path4__namespace.resolve(cwd, "shared", config.schema.directory)
+    path5__namespace.resolve(cwd, config.schema.directory),
+    path5__namespace.resolve(cwd, "shared", config.schema.directory)
   ];
-  return possiblePaths.find((p) => fs2__namespace.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs3__namespace.existsSync(p)) || possiblePaths[0];
 }
 function getMigrationsDirectory(config) {
   const cwd = process.cwd();
   const possiblePaths = [
-    path4__namespace.resolve(cwd, config.migrations.directory),
-    path4__namespace.resolve(cwd, "shared", config.migrations.directory)
+    path5__namespace.resolve(cwd, config.migrations.directory),
+    path5__namespace.resolve(cwd, "shared", config.migrations.directory)
   ];
-  return possiblePaths.find((p) => fs2__namespace.existsSync(p)) || possiblePaths[0];
+  return possiblePaths.find((p) => fs3__namespace.existsSync(p)) || possiblePaths[0];
 }
 var currentVerbosity = "normal";
 function setVerbosity(level) {
@@ -4556,7 +4967,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()
     });
@@ -4583,7 +4994,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:");
@@ -4749,7 +5160,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()
     });
@@ -4860,11 +5271,18 @@ exports.MigrationGenerationError = MigrationGenerationError;
 exports.MigrationGenerator = MigrationGenerator;
 exports.POCKETBASE_FIELD_TYPES = POCKETBASE_FIELD_TYPES;
 exports.PermissionTemplates = PermissionTemplates;
+exports.ProjectCollection = ProjectCollection;
+exports.ProjectInputSchema = ProjectInputSchema;
+exports.ProjectSchema = ProjectSchema;
+exports.RelationField = RelationField;
+exports.RelationsField = RelationsField;
 exports.SchemaAnalyzer = SchemaAnalyzer;
 exports.SchemaParsingError = SchemaParsingError;
 exports.SnapshotError = SnapshotError;
 exports.SnapshotManager = SnapshotManager;
 exports.StatusEnum = StatusEnum;
+exports.UserCollection = UserCollection;
+exports.UserCollectionSchema = UserCollectionSchema;
 exports.UserInputSchema = UserInputSchema;
 exports.UserMutator = UserMutator;
 exports.UserSchema = UserSchema;
@@ -4887,6 +5305,7 @@ exports.convertZodSchemaToCollectionSchema = convertZodSchemaToCollectionSchema;
 exports.createMigrationFileStructure = createMigrationFileStructure;
 exports.createPermissions = createPermissions;
 exports.dateField = dateField;
+exports.defineCollection = defineCollection;
 exports.detectDestructiveChanges = detectDestructiveChanges;
 exports.detectFieldChanges = detectFieldChanges;
 exports.discoverSchemaFiles = discoverSchemaFiles;
@@ -4955,6 +5374,7 @@ exports.loadBaseMigration = loadBaseMigration;
 exports.loadConfig = loadConfig;
 exports.loadSnapshot = loadSnapshot;
 exports.loadSnapshotIfExists = loadSnapshotIfExists;
+exports.loadSnapshotWithMigrations = loadSnapshotWithMigrations;
 exports.logError = logError;
 exports.logInfo = logInfo;
 exports.logSection = logSection;
@@ -4976,8 +5396,6 @@ exports.numberField = numberField;
 exports.omitImageFilesSchema = omitImageFilesSchema;
 exports.parseSchemaFiles = parseSchemaFiles;
 exports.pluralize = pluralize;
-exports.relationField = relationField;
-exports.relationsField = relationsField;
 exports.requiresForceFlag = requiresForceFlag;
 exports.resolveTargetCollection = resolveTargetCollection;
 exports.resolveTemplate = resolveTemplate;