pocketbase-zod-schema 1.0.0 → 1.0.2

package/dist/migration/diff.js

@@ -1,911 +0,0 @@
-import { randomBytes } from 'crypto';
-
-// src/migration/utils/collection-id-generator.ts
-function generateCollectionId() {
-  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-  const idLength = 15;
-  const bytes = randomBytes(idLength);
-  let id = "pb_";
-  for (let i = 0; i < idLength; i++) {
-    const index = bytes[i] % chars.length;
-    id += chars[index];
-  }
-  return id;
-}
-var CollectionIdRegistry = class {
-  ids;
-  constructor() {
-    this.ids = /* @__PURE__ */ new Set();
-  }
-  /**
-   * Generates a unique collection ID for a given collection name
-   * Retries up to 10 times if collision occurs (extremely rare)
-   * Special case: returns "_pb_users_auth_" for users collection
-   *
-   * @param collectionName - The name of the collection (optional)
-   * @returns A unique collection ID
-   * @throws Error if unable to generate unique ID after max attempts
-   */
-  generate(collectionName) {
-    if (collectionName && collectionName.toLowerCase() === "users") {
-      const usersId = "_pb_users_auth_";
-      if (!this.has(usersId)) {
-        this.register(usersId);
-      }
-      return usersId;
-    }
-    const maxAttempts = 10;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const id = generateCollectionId();
-      if (!this.has(id)) {
-        this.register(id);
-        return id;
-      }
-    }
-    throw new Error("Failed to generate unique collection ID after maximum attempts");
-  }
-  /**
-   * Checks if an ID has already been registered
-   *
-   * @param id - The collection ID to check
-   * @returns True if the ID exists in the registry
-   */
-  has(id) {
-    return this.ids.has(id);
-  }
-  /**
-   * Registers a collection ID in the registry
-   *
-   * @param id - The collection ID to register
-   */
-  register(id) {
-    this.ids.add(id);
-  }
-};
-
-// src/migration/diff/config.ts
-var DEFAULT_CONFIG = {
-  warnOnDelete: true,
-  requireForceForDestructive: true,
-  severityThreshold: "high",
-  systemCollections: ["_mfas", "_otps", "_externalAuths", "_authOrigins", "_superusers"],
-  usersSystemFields: ["id", "password", "tokenKey", "email", "emailVisibility", "verified", "created", "updated"]
-};
-function mergeConfig(config) {
-  return {
-    ...DEFAULT_CONFIG,
-    ...config
-  };
-}
-
-// src/migration/diff/utils.ts
-function isSystemCollection(collectionName, config) {
-  const mergedConfig = mergeConfig(config);
-  return mergedConfig.systemCollections.includes(collectionName);
-}
-function getUsersSystemFields(config) {
-  const mergedConfig = mergeConfig(config);
-  return new Set(mergedConfig.usersSystemFields);
-}
-function areValuesEqual(a, b) {
-  if (a === b) return true;
-  if (a == null || b == null) return false;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    return a.every((val, idx) => areValuesEqual(val, b[idx]));
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
-    return keysA.every((key) => areValuesEqual(a[key], b[key]));
-  }
-  return a === b;
-}
-var OPTION_ZERO_VALUES = {
-  autogeneratePattern: "",
-  pattern: "",
-  primaryKey: false,
-  convertURLs: false,
-  cost: 0,
-  hidden: false,
-  presentable: false,
-  system: false
-};
-function normalizeOptionValue(key, value, fieldType) {
-  if (OPTION_ZERO_VALUES[key] !== void 0 && value === OPTION_ZERO_VALUES[key]) {
-    return void 0;
-  }
-  if (key === "maxSelect" && value === 1 && (fieldType === "select" || fieldType === "file")) {
-    return void 0;
-  }
-  if (key === "maxSize" && value === 0 && fieldType === "file") {
-    return void 0;
-  }
-  if (key === "min" && value === 1 && fieldType === "number") {
-    return void 0;
-  }
-  if (fieldType === "file") {
-    if (key === "mimeTypes" && Array.isArray(value) && value.length === 0) {
-      return void 0;
-    }
-    if (key === "thumbs" && Array.isArray(value) && value.length === 0) {
-      return void 0;
-    }
-    if (key === "protected" && value === false) {
-      return void 0;
-    }
-  }
-  if (fieldType === "autodate") {
-    if (key === "onCreate" && value === true) {
-      return void 0;
-    }
-    if (key === "onUpdate" && value === false) {
-      return void 0;
-    }
-  }
-  return value;
-}
-
-// src/migration/diff/fields.ts
-function findNewFields(currentFields, previousFields) {
-  const newFields = [];
-  const previousFieldNames = new Set(previousFields.map((f) => f.name));
-  for (const currentField of currentFields) {
-    if (!previousFieldNames.has(currentField.name)) {
-      newFields.push(currentField);
-    }
-  }
-  return newFields;
-}
-function findRemovedFields(currentFields, previousFields) {
-  const removedFields = [];
-  const currentFieldNames = new Set(currentFields.map((f) => f.name));
-  for (const previousField of previousFields) {
-    if (!currentFieldNames.has(previousField.name)) {
-      removedFields.push(previousField);
-    }
-  }
-  return removedFields;
-}
-function matchFieldsByName(currentFields, previousFields) {
-  const matches = [];
-  const previousFieldMap = /* @__PURE__ */ new Map();
-  for (const previousField of previousFields) {
-    previousFieldMap.set(previousField.name, previousField);
-  }
-  for (const currentField of currentFields) {
-    const previousField = previousFieldMap.get(currentField.name);
-    if (previousField) {
-      matches.push([currentField, previousField]);
-    }
-  }
-  return matches;
-}
-function compareFieldTypes(currentField, previousField) {
-  if (currentField.type !== previousField.type) {
-    return {
-      property: "type",
-      oldValue: previousField.type,
-      newValue: currentField.type
-    };
-  }
-  return null;
-}
-function compareFieldConstraints(currentField, previousField) {
-  const changes = [];
-  if (currentField.required !== previousField.required) {
-    changes.push({
-      property: "required",
-      oldValue: previousField.required,
-      newValue: currentField.required
-    });
-  }
-  if (currentField.unique !== previousField.unique) {
-    changes.push({
-      property: "unique",
-      oldValue: previousField.unique,
-      newValue: currentField.unique
-    });
-  }
-  return changes;
-}
-function compareFieldOptions(currentField, previousField) {
-  const changes = [];
-  const currentOptions = currentField.options || {};
-  const previousOptions = previousField.options || {};
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(currentOptions), ...Object.keys(previousOptions)]);
-  const fieldType = currentField.type;
-  for (const key of allKeys) {
-    const currentValue = currentOptions[key];
-    const previousValue = previousOptions[key];
-    const normalizedCurrent = normalizeOptionValue(key, currentValue, fieldType);
-    const normalizedPrevious = normalizeOptionValue(key, previousValue, fieldType);
-    if (normalizedCurrent === void 0 && normalizedPrevious === void 0) {
-      continue;
-    }
-    if (!areValuesEqual(normalizedCurrent, normalizedPrevious)) {
-      changes.push({
-        property: `options.${key}`,
-        oldValue: previousValue,
-        newValue: currentValue
-      });
-    }
-  }
-  return changes;
-}
-function compareRelationConfigurations(currentField, previousField, collectionIdToName) {
-  const changes = [];
-  const currentRelation = currentField.relation;
-  const previousRelation = previousField.relation;
-  if (!currentRelation && !previousRelation) {
-    return changes;
-  }
-  if (!currentRelation || !previousRelation) {
-    return changes;
-  }
-  const normalizeCollection = (collection) => {
-    if (!collection) return collection;
-    if (collectionIdToName && collectionIdToName.has(collection)) {
-      return collectionIdToName.get(collection);
-    }
-    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.toLowerCase() !== normalizedPrevious.toLowerCase()) {
-    changes.push({
-      property: "relation.collection",
-      oldValue: previousRelation.collection,
-      newValue: currentRelation.collection
-    });
-  }
-  if (currentRelation.cascadeDelete !== previousRelation.cascadeDelete) {
-    changes.push({
-      property: "relation.cascadeDelete",
-      oldValue: previousRelation.cascadeDelete,
-      newValue: currentRelation.cascadeDelete
-    });
-  }
-  const normalizeMax = (val) => val === 1 ? null : val;
-  const currentMax = normalizeMax(currentRelation.maxSelect);
-  const previousMax = normalizeMax(previousRelation.maxSelect);
-  if (currentMax != previousMax) {
-    changes.push({
-      property: "relation.maxSelect",
-      oldValue: previousRelation.maxSelect,
-      newValue: currentRelation.maxSelect
-    });
-  }
-  const normalizeMin = (val) => val === 0 ? null : val;
-  const currentMin = normalizeMin(currentRelation.minSelect);
-  const previousMin = normalizeMin(previousRelation.minSelect);
-  if (currentMin != previousMin) {
-    changes.push({
-      property: "relation.minSelect",
-      oldValue: previousRelation.minSelect,
-      newValue: currentRelation.minSelect
-    });
-  }
-  return changes;
-}
-function detectFieldChanges(currentField, previousField, collectionIdToName) {
-  const changes = [];
-  const typeChange = compareFieldTypes(currentField, previousField);
-  if (typeChange) {
-    changes.push(typeChange);
-  }
-  changes.push(...compareFieldConstraints(currentField, previousField));
-  changes.push(...compareFieldOptions(currentField, previousField));
-  if (currentField.type === "relation" && previousField.type === "relation") {
-    changes.push(...compareRelationConfigurations(currentField, previousField, collectionIdToName));
-  }
-  return changes;
-}
-
-// src/migration/diff/indexes.ts
-function compareIndexes(currentIndexes = [], previousIndexes = []) {
-  const currentSet = new Set(currentIndexes);
-  const previousSet = new Set(previousIndexes);
-  const indexesToAdd = currentIndexes.filter((idx) => !previousSet.has(idx));
-  const indexesToRemove = previousIndexes.filter((idx) => !currentSet.has(idx));
-  return { indexesToAdd, indexesToRemove };
-}
-
-// src/migration/diff/rules.ts
-function compareRules(currentRules, previousRules, currentPermissions, previousPermissions) {
-  const updates = [];
-  const ruleTypes = [
-    "listRule",
-    "viewRule",
-    "createRule",
-    "updateRule",
-    "deleteRule",
-    "manageRule"
-  ];
-  for (const ruleType of ruleTypes) {
-    const currentValue = currentRules?.[ruleType] ?? currentPermissions?.[ruleType] ?? null;
-    const previousValue = previousRules?.[ruleType] ?? previousPermissions?.[ruleType] ?? null;
-    if (currentValue !== previousValue) {
-      updates.push({
-        ruleType,
-        oldValue: previousValue,
-        newValue: currentValue
-      });
-    }
-  }
-  return updates;
-}
-function comparePermissions(currentPermissions, previousPermissions) {
-  const changes = [];
-  const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule", "manageRule"];
-  for (const ruleType of ruleTypes) {
-    const currentValue = currentPermissions?.[ruleType] ?? null;
-    const previousValue = previousPermissions?.[ruleType] ?? null;
-    if (currentValue !== previousValue) {
-      changes.push({
-        ruleType,
-        oldValue: previousValue,
-        newValue: currentValue
-      });
-    }
-  }
-  return changes;
-}
-
-// src/migration/diff/collections.ts
-function filterSystemCollections(schema, config) {
-  const filteredCollections = /* @__PURE__ */ new Map();
-  for (const [collectionName, collectionSchema] of schema.collections) {
-    if (!isSystemCollection(collectionName, config)) {
-      filteredCollections.set(collectionName, collectionSchema);
-    }
-  }
-  return {
-    collections: filteredCollections
-  };
-}
-function findNewCollections(currentSchema, previousSnapshot) {
-  const newCollections = [];
-  if (!previousSnapshot) {
-    return Array.from(currentSchema.collections.values());
-  }
-  for (const [collectionName, collectionSchema] of currentSchema.collections) {
-    if (!previousSnapshot.collections.has(collectionName)) {
-      newCollections.push(collectionSchema);
-    }
-  }
-  return newCollections;
-}
-function findRemovedCollections(currentSchema, previousSnapshot) {
-  const removedCollections = [];
-  if (!previousSnapshot) {
-    return removedCollections;
-  }
-  for (const [collectionName, collectionSchema] of previousSnapshot.collections) {
-    if (!currentSchema.collections.has(collectionName)) {
-      removedCollections.push(collectionSchema);
-    }
-  }
-  return removedCollections;
-}
-function matchCollectionsByName(currentSchema, previousSnapshot) {
-  const matches = [];
-  if (!previousSnapshot) {
-    return matches;
-  }
-  const previousCollectionsLower = /* @__PURE__ */ new Map();
-  for (const [name, collection] of previousSnapshot.collections) {
-    previousCollectionsLower.set(name.toLowerCase(), [name, collection]);
-  }
-  for (const [collectionName, currentCollection] of currentSchema.collections) {
-    const previousEntry = previousCollectionsLower.get(collectionName.toLowerCase());
-    if (previousEntry) {
-      const [, previousCollection] = previousEntry;
-      matches.push([currentCollection, previousCollection]);
-    }
-  }
-  return matches;
-}
-function compareCollectionFields(currentCollection, previousCollection, config, collectionIdToName) {
-  let fieldsToAdd = findNewFields(currentCollection.fields, previousCollection.fields);
-  let fieldsToRemove = findRemovedFields(currentCollection.fields, previousCollection.fields);
-  const fieldsToModify = [];
-  if (currentCollection.name === "users") {
-    const systemFields = getUsersSystemFields(config);
-    fieldsToAdd = fieldsToAdd.filter((field) => !systemFields.has(field.name));
-  }
-  const matchedFields = matchFieldsByName(currentCollection.fields, previousCollection.fields);
-  for (const [currentField, previousField] of matchedFields) {
-    const changes = detectFieldChanges(currentField, previousField, collectionIdToName);
-    if (changes.length > 0) {
-      fieldsToModify.push({
-        fieldName: currentField.name,
-        currentDefinition: previousField,
-        newDefinition: currentField,
-        changes
-      });
-    }
-  }
-  const processedAddIndices = /* @__PURE__ */ new Set();
-  const processedRemoveIndices = /* @__PURE__ */ new Set();
-  const resolveCollectionName = (val) => {
-    if (!val) return val;
-    if (collectionIdToName && collectionIdToName.has(val)) return collectionIdToName.get(val);
-    const match = val.match(/app\.findCollectionByNameOrId\s*\(\s*["']([^"']+)["']\s*\)/);
-    return match ? match[1] : val;
-  };
-  const addedByType = /* @__PURE__ */ new Map();
-  fieldsToAdd.forEach((field, index) => {
-    const type = field.type;
-    if (!addedByType.has(type)) addedByType.set(type, []);
-    addedByType.get(type).push(index);
-  });
-  const removedByType = /* @__PURE__ */ new Map();
-  fieldsToRemove.forEach((field, index) => {
-    const type = field.type;
-    if (!removedByType.has(type)) removedByType.set(type, []);
-    removedByType.get(type).push(index);
-  });
-  for (const [type, removedIndices] of removedByType) {
-    const addedIndices = addedByType.get(type);
-    if (addedIndices && addedIndices.length === 1 && removedIndices.length === 1) {
-      const addedIndex = addedIndices[0];
-      const removedIndex = removedIndices[0];
-      const addedField = fieldsToAdd[addedIndex];
-      const removedField = fieldsToRemove[removedIndex];
-      let isMatch = true;
-      if (type === "relation") {
-        const addedTarget = resolveCollectionName(addedField.relation?.collection || "");
-        const removedTarget = resolveCollectionName(removedField.relation?.collection || "");
-        if (addedTarget.toLowerCase() !== removedTarget.toLowerCase()) {
-          isMatch = false;
-        }
-      }
-      if (isMatch) {
-        processedAddIndices.add(addedIndex);
-        processedRemoveIndices.add(removedIndex);
-        const changes = detectFieldChanges(addedField, removedField, collectionIdToName);
-        changes.push({
-          property: "name",
-          oldValue: removedField.name,
-          newValue: addedField.name
-        });
-        fieldsToModify.push({
-          fieldName: removedField.name,
-          // Use OLD name so generator can find it
-          currentDefinition: removedField,
-          // OLD definition
-          newDefinition: addedField,
-          // NEW definition
-          changes
-        });
-      }
-    }
-  }
-  fieldsToAdd = fieldsToAdd.filter((_, index) => !processedAddIndices.has(index));
-  fieldsToRemove = fieldsToRemove.filter((_, index) => !processedRemoveIndices.has(index));
-  return { fieldsToAdd, fieldsToRemove, fieldsToModify };
-}
-function normalizeSql(query) {
-  if (!query) {
-    return "";
-  }
-  return query.split("\n").map((line) => line.trim()).join(" ").replace(/\s+/g, " ").trim();
-}
-function compareViewQuery(currentCollection, previousCollection) {
-  const newValue = currentCollection.viewQuery;
-  if (typeof newValue !== "string") {
-    return void 0;
-  }
-  if (normalizeSql(newValue) === normalizeSql(previousCollection.viewQuery)) {
-    return void 0;
-  }
-  return {
-    oldValue: previousCollection.viewQuery ?? null,
-    newValue
-  };
-}
-function buildCollectionModification(currentCollection, previousCollection, config, collectionIdToName) {
-  const isView = currentCollection.type === "view" || previousCollection.type === "view";
-  if (isView) {
-    return {
-      collection: currentCollection.name,
-      fieldsToAdd: [],
-      fieldsToRemove: [],
-      fieldsToModify: [],
-      indexesToAdd: [],
-      indexesToRemove: [],
-      rulesToUpdate: compareRules(
-        currentCollection.rules,
-        previousCollection.rules,
-        currentCollection.permissions,
-        previousCollection.permissions
-      ),
-      permissionsToUpdate: comparePermissions(currentCollection.permissions, previousCollection.permissions),
-      viewQueryUpdate: compareViewQuery(currentCollection, previousCollection)
-    };
-  }
-  const { fieldsToAdd, fieldsToRemove, fieldsToModify } = compareCollectionFields(
-    currentCollection,
-    previousCollection,
-    config,
-    collectionIdToName
-  );
-  const { indexesToAdd, indexesToRemove } = compareIndexes(currentCollection.indexes, previousCollection.indexes);
-  const rulesToUpdate = compareRules(
-    currentCollection.rules,
-    previousCollection.rules,
-    currentCollection.permissions,
-    previousCollection.permissions
-  );
-  const permissionsToUpdate = comparePermissions(currentCollection.permissions, previousCollection.permissions);
-  return {
-    collection: currentCollection.name,
-    fieldsToAdd,
-    fieldsToRemove,
-    fieldsToModify,
-    indexesToAdd,
-    indexesToRemove,
-    rulesToUpdate,
-    permissionsToUpdate
-  };
-}
-
-// src/migration/diff/destructiveness.ts
-function detectDestructiveChanges(diff, config) {
-  const destructiveChanges = [];
-  const mergedConfig = mergeConfig(config);
-  for (const collection of diff.collectionsToDelete) {
-    if (collection.type === "view") {
-      continue;
-    }
-    destructiveChanges.push({
-      type: "collection_delete",
-      severity: "high",
-      collection: collection.name,
-      description: `Delete collection: ${collection.name}`
-    });
-  }
-  for (const modification of diff.collectionsToModify) {
-    const collectionName = modification.collection;
-    for (const field of modification.fieldsToRemove) {
-      destructiveChanges.push({
-        type: "field_delete",
-        severity: "high",
-        collection: collectionName,
-        field: field.name,
-        description: `Delete field: ${collectionName}.${field.name}`
-      });
-    }
-    for (const fieldMod of modification.fieldsToModify) {
-      const typeChange = fieldMod.changes.find((c) => c.property === "type");
-      const requiredChange = fieldMod.changes.find((c) => c.property === "required" && c.newValue === true);
-      if (typeChange) {
-        destructiveChanges.push({
-          type: "type_change",
-          severity: "high",
-          collection: collectionName,
-          field: fieldMod.fieldName,
-          description: `Change field type: ${collectionName}.${fieldMod.fieldName} (${typeChange.oldValue} \u2192 ${typeChange.newValue})`,
-          oldValue: typeChange.oldValue,
-          newValue: typeChange.newValue
-        });
-      }
-      if (requiredChange && mergedConfig.severityThreshold !== "high") {
-        destructiveChanges.push({
-          type: "required_change",
-          severity: "medium",
-          collection: collectionName,
-          field: fieldMod.fieldName,
-          description: `Make field required: ${collectionName}.${fieldMod.fieldName}`,
-          oldValue: false,
-          newValue: true
-        });
-      }
-      if (mergedConfig.severityThreshold === "low") {
-        const otherChanges = fieldMod.changes.filter((c) => c.property !== "type" && c.property !== "required");
-        for (const change of otherChanges) {
-          destructiveChanges.push({
-            type: "constraint_change",
-            severity: "low",
-            collection: collectionName,
-            field: fieldMod.fieldName,
-            description: `Change constraint: ${collectionName}.${fieldMod.fieldName}.${change.property}`,
-            oldValue: change.oldValue,
-            newValue: change.newValue
-          });
-        }
-      }
-    }
-  }
-  return destructiveChanges;
-}
-function requiresForceFlag(diff, config) {
-  const mergedConfig = mergeConfig(config);
-  if (!mergedConfig.requireForceForDestructive) {
-    return false;
-  }
-  const destructiveChanges = detectDestructiveChanges(diff, config);
-  const relevantChanges = destructiveChanges.filter((change) => {
-    switch (mergedConfig.severityThreshold) {
-      case "high":
-        return change.severity === "high";
-      case "medium":
-        return change.severity === "high" || change.severity === "medium";
-      case "low":
-        return true;
-      default:
-        return change.severity === "high";
-    }
-  });
-  return relevantChanges.length > 0;
-}
-
-// src/migration/diff/summary.ts
-function categorizeChangesBySeverity(diff, _config) {
-  const destructive = [];
-  const nonDestructive = [];
-  for (const collection of diff.collectionsToDelete) {
-    if (collection.type === "view") {
-      nonDestructive.push(`Delete view collection: ${collection.name}`);
-    } else {
-      destructive.push(`Delete collection: ${collection.name}`);
-    }
-  }
-  for (const collection of diff.collectionsToCreate) {
-    nonDestructive.push(`Create collection: ${collection.name}`);
-  }
-  for (const modification of diff.collectionsToModify) {
-    const collectionName = modification.collection;
-    for (const field of modification.fieldsToRemove) {
-      destructive.push(`Delete field: ${collectionName}.${field.name}`);
-    }
-    for (const field of modification.fieldsToAdd) {
-      nonDestructive.push(`Add field: ${collectionName}.${field.name}`);
-    }
-    for (const fieldMod of modification.fieldsToModify) {
-      const hasTypeChange = fieldMod.changes.some((c) => c.property === "type");
-      const hasRequiredChange = fieldMod.changes.some((c) => c.property === "required" && c.newValue === true);
-      if (hasTypeChange) {
-        destructive.push(
-          `Change field type: ${collectionName}.${fieldMod.fieldName} (${fieldMod.changes.find((c) => c.property === "type")?.oldValue} \u2192 ${fieldMod.changes.find((c) => c.property === "type")?.newValue})`
-        );
-      } else if (hasRequiredChange) {
-        destructive.push(`Make field required: ${collectionName}.${fieldMod.fieldName}`);
-      } else {
-        nonDestructive.push(`Modify field: ${collectionName}.${fieldMod.fieldName}`);
-      }
-    }
-    for (const _index of modification.indexesToAdd) {
-      nonDestructive.push(`Add index: ${collectionName}`);
-    }
-    for (const _index of modification.indexesToRemove) {
-      nonDestructive.push(`Remove index: ${collectionName}`);
-    }
-    for (const rule of modification.rulesToUpdate) {
-      nonDestructive.push(`Update rule: ${collectionName}.${rule.ruleType}`);
-    }
-    if (modification.viewQueryUpdate) {
-      nonDestructive.push(`Update view query: ${collectionName}`);
-    }
-  }
-  return { destructive, nonDestructive };
-}
-function generateChangeSummary(diff, config) {
-  const destructiveChanges = detectDestructiveChanges(diff, config);
-  const { nonDestructive } = categorizeChangesBySeverity(diff);
-  let fieldsToAdd = 0;
-  let fieldsToRemove = 0;
-  let fieldsToModify = 0;
-  let indexChanges = 0;
-  let ruleChanges = 0;
-  let permissionChanges = 0;
-  let viewQueryChanges = 0;
-  for (const modification of diff.collectionsToModify) {
-    fieldsToAdd += modification.fieldsToAdd.length;
-    fieldsToRemove += modification.fieldsToRemove.length;
-    fieldsToModify += modification.fieldsToModify.length;
-    indexChanges += modification.indexesToAdd.length + modification.indexesToRemove.length;
-    ruleChanges += modification.rulesToUpdate.length;
-    permissionChanges += modification.permissionsToUpdate.length;
-    if (modification.viewQueryUpdate) {
-      viewQueryChanges += 1;
-    }
-  }
-  return {
-    totalChanges: diff.collectionsToCreate.length + diff.collectionsToDelete.length + diff.collectionsToModify.length,
-    collectionsToCreate: diff.collectionsToCreate.length,
-    collectionsToDelete: diff.collectionsToDelete.length,
-    collectionsToModify: diff.collectionsToModify.length,
-    fieldsToAdd,
-    fieldsToRemove,
-    fieldsToModify,
-    indexChanges,
-    ruleChanges,
-    permissionChanges,
-    viewQueryChanges,
-    destructiveChanges,
-    nonDestructiveChanges: nonDestructive
-  };
-}
-
-// src/migration/diff/filter.ts
-function matchesPattern(text, patterns) {
-  if (!patterns || patterns.length === 0) return true;
-  return patterns.some((pattern) => {
-    try {
-      const regex = new RegExp(pattern);
-      return regex.test(text);
-    } catch {
-      return text.includes(pattern);
-    }
-  });
-}
-function isDestructiveFieldModification(mod) {
-  const typeChange = mod.changes.find((c) => c.property === "type");
-  const requiredChange = mod.changes.find((c) => c.property === "required" && c.newValue === true);
-  return !!(typeChange || requiredChange);
-}
-function filterDiff(diff, options) {
-  const { patterns = [], skipDestructive = false } = options;
-  const collectionsToCreate = diff.collectionsToCreate.filter((col) => {
-    return matchesPattern(col.name, patterns);
-  });
-  let collectionsToDelete = diff.collectionsToDelete;
-  if (skipDestructive) {
-    collectionsToDelete = collectionsToDelete.filter((col) => col.type === "view");
-  }
-  collectionsToDelete = collectionsToDelete.filter((col) => {
-    return matchesPattern(col.name, patterns);
-  });
-  const collectionsToModify = diff.collectionsToModify.map((mod) => {
-    const collectionMatches = matchesPattern(mod.collection, patterns);
-    const fieldsToAdd = mod.fieldsToAdd.filter((field) => {
-      return collectionMatches || matchesPattern(`${mod.collection}.${field.name}`, patterns);
-    });
-    let fieldsToRemove = mod.fieldsToRemove;
-    if (skipDestructive) {
-      fieldsToRemove = [];
-    } else {
-      fieldsToRemove = fieldsToRemove.filter((field) => {
-        return collectionMatches || matchesPattern(`${mod.collection}.${field.name}`, patterns);
-      });
-    }
-    let fieldsToModify = mod.fieldsToModify;
-    if (skipDestructive) {
-      fieldsToModify = fieldsToModify.filter((f) => !isDestructiveFieldModification(f));
-    }
-    fieldsToModify = fieldsToModify.filter((f) => {
-      return collectionMatches || matchesPattern(`${mod.collection}.${f.fieldName}`, patterns);
-    });
-    const indexesToAdd = collectionMatches ? mod.indexesToAdd : [];
-    const indexesToRemove = collectionMatches ? mod.indexesToRemove : [];
-    const rulesToUpdate = collectionMatches ? mod.rulesToUpdate : [];
-    const permissionsToUpdate = collectionMatches ? mod.permissionsToUpdate : [];
-    const viewQueryUpdate = collectionMatches ? mod.viewQueryUpdate : void 0;
-    return {
-      ...mod,
-      fieldsToAdd,
-      fieldsToRemove,
-      fieldsToModify,
-      indexesToAdd,
-      indexesToRemove,
-      rulesToUpdate,
-      permissionsToUpdate,
-      viewQueryUpdate
-    };
-  }).filter((mod) => {
-    return mod.fieldsToAdd.length > 0 || mod.fieldsToRemove.length > 0 || mod.fieldsToModify.length > 0 || mod.indexesToAdd.length > 0 || mod.indexesToRemove.length > 0 || mod.rulesToUpdate.length > 0 || mod.permissionsToUpdate.length > 0 || mod.viewQueryUpdate !== void 0;
-  });
-  return {
-    ...diff,
-    collectionsToCreate,
-    collectionsToDelete,
-    collectionsToModify
-  };
-}
-
-// src/migration/diff/index.ts
-function hasChanges(modification) {
-  return modification.fieldsToAdd.length > 0 || modification.fieldsToRemove.length > 0 || modification.fieldsToModify.length > 0 || modification.indexesToAdd.length > 0 || modification.indexesToRemove.length > 0 || modification.rulesToUpdate.length > 0 || modification.permissionsToUpdate.length > 0 || modification.viewQueryUpdate !== void 0;
-}
-function aggregateChanges(currentSchema, previousSnapshot, config) {
-  const collectionIdToName = /* @__PURE__ */ new Map();
-  if (previousSnapshot) {
-    for (const [name, collection] of previousSnapshot.collections) {
-      if (collection.id) {
-        collectionIdToName.set(collection.id, name);
-      }
-    }
-  }
-  const collectionsToCreate = findNewCollections(currentSchema, previousSnapshot);
-  const collectionsToDelete = findRemovedCollections(currentSchema, previousSnapshot);
-  const filteredCollectionsToCreate = collectionsToCreate.filter(
-    (collection) => !isSystemCollection(collection.name, config)
-  );
-  const filteredCollectionsToDelete = collectionsToDelete.filter(
-    (collection) => !isSystemCollection(collection.name, config)
-  );
-  const registry = new CollectionIdRegistry();
-  const collectionsWithIds = filteredCollectionsToCreate.map((collection) => {
-    if (collection.id) {
-      registry.register(collection.id);
-      return collection;
-    }
-    const id = registry.generate(collection.name);
-    return {
-      ...collection,
-      id
-    };
-  });
-  const collectionsToModify = [];
-  const matchedCollections = matchCollectionsByName(currentSchema, previousSnapshot);
-  for (const [currentCollection, previousCollection] of matchedCollections) {
-    const modification = buildCollectionModification(currentCollection, previousCollection, config, collectionIdToName);
-    if (hasChanges(modification)) {
-      collectionsToModify.push(modification);
-    }
-  }
-  const existingCollectionIds = /* @__PURE__ */ new Map();
-  if (previousSnapshot) {
-    for (const [name, collection] of previousSnapshot.collections) {
-      if (collection.id) {
-        existingCollectionIds.set(name, collection.id);
-      }
-    }
-  }
-  return {
-    collectionsToCreate: collectionsWithIds,
-    collectionsToDelete: filteredCollectionsToDelete,
-    collectionsToModify,
-    existingCollectionIds
-  };
-}
-function compare(currentSchema, previousSnapshot, config) {
-  return aggregateChanges(currentSchema, previousSnapshot, config);
-}
-var DiffEngine = class {
-  config;
-  constructor(config) {
-    this.config = mergeConfig(config);
-  }
-  /**
-   * Compares current schema with previous snapshot
-   */
-  compare(currentSchema, previousSnapshot) {
-    return compare(currentSchema, previousSnapshot, this.config);
-  }
-  /**
-   * Detects destructive changes in a diff
-   */
-  detectDestructiveChanges(diff) {
-    return detectDestructiveChanges(diff, this.config);
-  }
-  /**
-   * Categorizes changes by severity
-   */
-  categorizeChangesBySeverity(diff) {
-    return categorizeChangesBySeverity(diff, this.config);
-  }
-  /**
-   * Generates a summary of changes
-   */
-  generateChangeSummary(diff) {
-    return generateChangeSummary(diff, this.config);
-  }
-  /**
-   * Checks if force flag is required
-   */
-  requiresForceFlag(diff) {
-    return requiresForceFlag(diff, this.config);
-  }
-};
-
-export { DEFAULT_CONFIG, DiffEngine, aggregateChanges, areValuesEqual, buildCollectionModification, categorizeChangesBySeverity, compare, compareFieldConstraints, compareFieldOptions, compareFieldTypes, compareIndexes, comparePermissions, compareRelationConfigurations, compareRules, detectDestructiveChanges, detectFieldChanges, filterDiff, filterSystemCollections, findNewCollections, findNewFields, findRemovedCollections, findRemovedFields, generateChangeSummary, getUsersSystemFields, isSystemCollection, matchCollectionsByName, matchFieldsByName, mergeConfig, normalizeOptionValue, normalizeSql, requiresForceFlag };
-//# sourceMappingURL=diff.js.map
-//# sourceMappingURL=diff.js.map