pocketbase-zod-schema 0.1.2

package/dist/migration/snapshot.cjs

@@ -0,0 +1,609 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/migration/snapshot.ts
+
+// src/migration/errors.ts
+var MigrationError = class _MigrationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MigrationError";
+    Object.setPrototypeOf(this, _MigrationError.prototype);
+  }
+};
+var SnapshotError = class _SnapshotError extends MigrationError {
+  snapshotPath;
+  operation;
+  originalError;
+  constructor(message, snapshotPath, operation, originalError) {
+    super(message);
+    this.name = "SnapshotError";
+    this.snapshotPath = snapshotPath;
+    this.operation = operation;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _SnapshotError.prototype);
+  }
+  /**
+   * Creates a formatted error message with snapshot path and operation details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.operation) {
+      parts.push(`
+Operation: ${this.operation}`);
+    }
+    if (this.snapshotPath) {
+      parts.push(`
+Snapshot: ${this.snapshotPath}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+var FileSystemError = class _FileSystemError extends MigrationError {
+  path;
+  operation;
+  code;
+  originalError;
+  constructor(message, path2, operation, code, originalError) {
+    super(message);
+    this.name = "FileSystemError";
+    this.path = path2;
+    this.operation = operation;
+    this.code = code;
+    this.originalError = originalError;
+    Object.setPrototypeOf(this, _FileSystemError.prototype);
+  }
+  /**
+   * Creates a formatted error message with path, operation, and error code details
+   */
+  getDetailedMessage() {
+    const parts = [this.message];
+    if (this.operation) {
+      parts.push(`
+Operation: ${this.operation}`);
+    }
+    if (this.path) {
+      parts.push(`
+Path: ${this.path}`);
+    }
+    if (this.code) {
+      parts.push(`
+Error Code: ${this.code}`);
+    }
+    if (this.originalError) {
+      parts.push(`
+Cause: ${this.originalError.message}`);
+    }
+    return parts.join("");
+  }
+};
+
+// src/migration/snapshot.ts
+var SNAPSHOT_VERSION = "1.0.0";
+var DEFAULT_SNAPSHOT_FILENAME = ".migration-snapshot.json";
+var SNAPSHOT_MIGRATIONS = [
+  // Add migrations here as the format evolves
+  // Example:
+  // {
+  //   fromVersion: '0.9.0',
+  //   toVersion: '1.0.0',
+  //   migrate: (data) => ({ ...data, newField: 'default' })
+  // }
+];
+var DEFAULT_CONFIG = {
+  snapshotPath: DEFAULT_SNAPSHOT_FILENAME,
+  workspaceRoot: process.cwd(),
+  autoMigrate: true,
+  version: SNAPSHOT_VERSION
+};
+function mergeConfig(config = {}) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+}
+function getSnapshotPath(config = {}) {
+  const mergedConfig = mergeConfig(config);
+  const workspaceRoot = mergedConfig.workspaceRoot;
+  const snapshotFilename = mergedConfig.snapshotPath;
+  if (path__namespace.isAbsolute(snapshotFilename)) {
+    return snapshotFilename;
+  }
+  return path__namespace.join(workspaceRoot, snapshotFilename);
+}
+function snapshotExists(config = {}) {
+  try {
+    const snapshotPath = getSnapshotPath(config);
+    return fs__namespace.existsSync(snapshotPath);
+  } catch {
+    return false;
+  }
+}
+function handleFileSystemError(error, operation, filePath) {
+  const fsError = error;
+  if (fsError.code === "ENOENT") {
+    throw new SnapshotError(`Snapshot file not found: ${filePath}`, filePath, operation, error);
+  } else if (fsError.code === "EACCES" || fsError.code === "EPERM") {
+    throw new FileSystemError(
+      `Permission denied ${operation === "read" ? "reading" : "writing"} snapshot file. Check file permissions.`,
+      filePath,
+      operation,
+      fsError.code,
+      error
+    );
+  } else if (fsError.code === "ENOSPC") {
+    throw new FileSystemError(
+      `No space left on device when ${operation === "read" ? "reading" : "writing"} snapshot file.`,
+      filePath,
+      operation,
+      fsError.code,
+      error
+    );
+  } else {
+    throw new SnapshotError(`Failed to ${operation} snapshot file: ${error.message}`, filePath, operation, error);
+  }
+}
+function serializeMap(map) {
+  const obj = {};
+  for (const [key, value] of map.entries()) {
+    obj[key] = value;
+  }
+  return obj;
+}
+function deserializeMap(obj) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(obj)) {
+    map.set(key, value);
+  }
+  return map;
+}
+function serializeSchemaDefinition(schema) {
+  return {
+    collections: serializeMap(schema.collections)
+  };
+}
+function addSnapshotMetadata(schema, config) {
+  const mergedConfig = mergeConfig(config);
+  return {
+    version: mergedConfig.version,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...serializeSchemaDefinition(schema)
+  };
+}
+function saveSnapshot(schema, config = {}) {
+  const snapshotPath = getSnapshotPath(config);
+  try {
+    const snapshotDir = path__namespace.dirname(snapshotPath);
+    if (!fs__namespace.existsSync(snapshotDir)) {
+      fs__namespace.mkdirSync(snapshotDir, { recursive: true });
+    }
+    const snapshotData = addSnapshotMetadata(schema, config);
+    const jsonContent = JSON.stringify(snapshotData, null, 2);
+    fs__namespace.writeFileSync(snapshotPath, jsonContent, "utf-8");
+  } catch (error) {
+    handleFileSystemError(error, "write", snapshotPath);
+  }
+}
+function parseAndValidateSnapshot(jsonContent, snapshotPath) {
+  try {
+    const data = JSON.parse(jsonContent);
+    if (!data.version) {
+      throw new SnapshotError(
+        "Snapshot file is missing version field. The snapshot may be corrupted.",
+        snapshotPath,
+        "validate"
+      );
+    }
+    if (!data.timestamp) {
+      throw new SnapshotError(
+        "Snapshot file is missing timestamp field. The snapshot may be corrupted.",
+        snapshotPath,
+        "validate"
+      );
+    }
+    if (!data.collections) {
+      throw new SnapshotError(
+        "Snapshot file is missing collections field. The snapshot may be corrupted.",
+        snapshotPath,
+        "validate"
+      );
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof SnapshotError) {
+      throw error;
+    }
+    if (error instanceof SyntaxError) {
+      throw new SnapshotError(
+        `Invalid JSON in snapshot file. The file may be corrupted or manually edited incorrectly.`,
+        snapshotPath,
+        "parse",
+        error
+      );
+    }
+    throw error;
+  }
+}
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  return 0;
+}
+function migrateSnapshotFormat(data, config) {
+  const mergedConfig = mergeConfig(config);
+  const currentVersion = data.version;
+  const targetVersion = mergedConfig.version;
+  if (currentVersion === targetVersion) {
+    return data;
+  }
+  if (!mergedConfig.autoMigrate) {
+    console.warn(
+      `Snapshot version ${currentVersion} differs from current ${targetVersion}, but auto-migrate is disabled.`
+    );
+    return data;
+  }
+  let migratedData = { ...data };
+  let currentMigrationVersion = currentVersion;
+  const sortedMigrations = [...SNAPSHOT_MIGRATIONS].sort((a, b) => compareVersions(a.fromVersion, b.fromVersion));
+  for (const migration of sortedMigrations) {
+    if (compareVersions(currentMigrationVersion, migration.fromVersion) === 0) {
+      console.log(`Migrating snapshot from ${migration.fromVersion} to ${migration.toVersion}...`);
+      migratedData = migration.migrate(migratedData);
+      migratedData.version = migration.toVersion;
+      currentMigrationVersion = migration.toVersion;
+    }
+  }
+  if (compareVersions(currentMigrationVersion, targetVersion) !== 0) {
+    console.warn(`Unknown snapshot version ${currentVersion}, attempting to load anyway...`);
+  }
+  return migratedData;
+}
+function deserializeSnapshot(data) {
+  return {
+    version: data.version,
+    timestamp: data.timestamp,
+    collections: deserializeMap(data.collections)
+  };
+}
+function loadSnapshot(config = {}) {
+  const snapshotPath = getSnapshotPath(config);
+  try {
+    const jsonContent = fs__namespace.readFileSync(snapshotPath, "utf-8");
+    const data = parseAndValidateSnapshot(jsonContent, snapshotPath);
+    const migratedData = migrateSnapshotFormat(data, config);
+    return deserializeSnapshot(migratedData);
+  } catch (error) {
+    if (error instanceof SnapshotError || error instanceof FileSystemError) {
+      throw error;
+    }
+    if (error.code === "ENOENT") {
+      throw new SnapshotError(
+        `Snapshot file not found. This may be the first migration run.`,
+        snapshotPath,
+        "read",
+        error
+      );
+    }
+    handleFileSystemError(error, "read", snapshotPath);
+  }
+}
+function mergeSnapshots(baseSnapshot, customSnapshot) {
+  if (!customSnapshot) {
+    return baseSnapshot;
+  }
+  const mergedCollections = new Map(baseSnapshot.collections);
+  for (const [name, schema] of customSnapshot.collections.entries()) {
+    mergedCollections.set(name, schema);
+  }
+  return {
+    version: customSnapshot.version || baseSnapshot.version,
+    timestamp: customSnapshot.timestamp || baseSnapshot.timestamp,
+    collections: mergedCollections
+  };
+}
+function findLatestSnapshot(migrationsPath) {
+  try {
+    if (!fs__namespace.existsSync(migrationsPath)) {
+      return null;
+    }
+    const files = fs__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 path__namespace.join(migrationsPath, latestSnapshot);
+  } catch (error) {
+    console.warn(`Error finding latest snapshot: ${error}`);
+    return null;
+  }
+}
+function loadSnapshotIfExists(config = {}) {
+  const migrationsPath = config.migrationsPath;
+  if (!migrationsPath) {
+    return null;
+  }
+  if (fs__namespace.existsSync(migrationsPath) && fs__namespace.statSync(migrationsPath).isFile()) {
+    try {
+      const migrationContent = fs__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 = fs__namespace.readFileSync(latestSnapshotPath, "utf-8");
+      return convertPocketBaseMigration(migrationContent);
+    } catch (error) {
+      console.warn(`Failed to load snapshot from ${latestSnapshotPath}: ${error}`);
+      return null;
+    }
+  }
+  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;
+  }
+  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 (!fs__namespace.existsSync(migrationPath)) {
+      throw new SnapshotError(
+        `Base migration file not found: ${migrationPath}
+
+This file should contain PocketBase's initial schema.
+Please ensure PocketBase is properly set up by running 'yarn setup'.
+If the file exists in a different location, update the configuration.`,
+        migrationPath,
+        "read"
+      );
+    }
+    const migrationContent = fs__namespace.readFileSync(migrationPath, "utf-8");
+    const snapshot = convertPocketBaseMigration(migrationContent);
+    return snapshot;
+  } catch (error) {
+    if (error instanceof SnapshotError) {
+      throw error;
+    }
+    if (error.code === "ENOENT") {
+      throw new SnapshotError(
+        `Base migration file not found: ${migrationPath}
+
+This file should contain PocketBase's initial schema.
+Please ensure PocketBase is properly set up by running 'yarn setup'.`,
+        migrationPath,
+        "read",
+        error
+      );
+    }
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      throw new FileSystemError(
+        `Permission denied reading base migration file. Check file permissions.`,
+        migrationPath,
+        "read",
+        error.code,
+        error
+      );
+    }
+    throw new SnapshotError(
+      `Failed to load base migration: ${error instanceof Error ? error.message : String(error)}`,
+      migrationPath,
+      "read",
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function getSnapshotVersion() {
+  return SNAPSHOT_VERSION;
+}
+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}`);
+  }
+  if (!snapshot.timestamp) {
+    issues.push("Missing timestamp field");
+  }
+  if (!snapshot.collections) {
+    issues.push("Missing collections field");
+  } else if (!(snapshot.collections instanceof Map)) {
+    issues.push("Collections field is not a Map");
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+var SnapshotManager = class {
+  config;
+  constructor(config = {}) {
+    this.config = mergeConfig(config);
+  }
+  /**
+   * Loads the current snapshot
+   */
+  loadSnapshot() {
+    return loadSnapshot(this.config);
+  }
+  /**
+   * Saves a schema as a snapshot
+   */
+  saveSnapshot(schema) {
+    saveSnapshot(schema, this.config);
+  }
+  /**
+   * Loads snapshot if it exists, returns null otherwise
+   */
+  loadSnapshotIfExists() {
+    return loadSnapshotIfExists(this.config);
+  }
+  /**
+   * Checks if a snapshot exists
+   */
+  snapshotExists() {
+    return snapshotExists(this.config);
+  }
+  /**
+   * Converts a PocketBase migration to a snapshot
+   */
+  convertPocketBaseMigration(content) {
+    return convertPocketBaseMigration(content);
+  }
+  /**
+   * Gets the snapshot file path
+   */
+  getSnapshotPath() {
+    return getSnapshotPath(this.config);
+  }
+  /**
+   * Validates a snapshot
+   */
+  validateSnapshot(snapshot) {
+    return validateSnapshot(snapshot);
+  }
+};
+
+exports.SnapshotManager = SnapshotManager;
+exports.convertPocketBaseMigration = convertPocketBaseMigration;
+exports.findLatestSnapshot = findLatestSnapshot;
+exports.getSnapshotPath = getSnapshotPath;
+exports.getSnapshotVersion = getSnapshotVersion;
+exports.loadBaseMigration = loadBaseMigration;
+exports.loadSnapshot = loadSnapshot;
+exports.loadSnapshotIfExists = loadSnapshotIfExists;
+exports.mergeSnapshots = mergeSnapshots;
+exports.saveSnapshot = saveSnapshot;
+exports.snapshotExists = snapshotExists;
+exports.validateSnapshot = validateSnapshot;
+//# sourceMappingURL=snapshot.cjs.map
+//# sourceMappingURL=snapshot.cjs.map