@famgia/omnify-core 0.0.8 → 0.0.9

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   Omnify: () => Omnify,
   OmnifyError: () => OmnifyError,
   PluginManager: () => PluginManager,
+  VersionStore: () => VersionStore,
   atlasError: () => atlasError,
   atlasNotFoundError: () => atlasNotFoundError,
   circularReferenceError: () => circularReferenceError,
@@ -40,6 +41,7 @@ __export(index_exports, {
   configNotFoundError: () => configNotFoundError,
   createOmnify: () => createOmnify,
   createPluginManager: () => createPluginManager,
+  createVersionStore: () => createVersionStore,
   duplicateSchemaError: () => duplicateSchemaError,
   err: () => import_omnify_types.err,
   expandProperty: () => expandProperty,
@@ -3042,11 +3044,309 @@ var Omnify = class {
 function createOmnify(options) {
   return new Omnify(options);
 }
+
+// src/history/version-store.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_js_yaml2 = __toESM(require("js-yaml"), 1);
+var OMNIFY_DIR = ".omnify";
+var VERSIONS_DIR = "versions";
+var CURRENT_FILE = "current.lock";
+var VERSION_FILE_PATTERN = /^(\d{4})(?:_(.+))?\.lock$/;
+function formatVersionNumber(version) {
+  return version.toString().padStart(4, "0");
+}
+function parseVersionFilename(filename) {
+  const match = filename.match(VERSION_FILE_PATTERN);
+  if (!match || !match[1]) return null;
+  const result = {
+    version: parseInt(match[1], 10)
+  };
+  if (match[2] !== void 0) {
+    result.name = match[2];
+  }
+  return result;
+}
+function generateVersionFilename(version, migration) {
+  const versionStr = formatVersionNumber(version);
+  if (migration) {
+    const name = migration.replace(/^\d+_/, "").replace(/\.sql$/, "");
+    return `${versionStr}_${name}.lock`;
+  }
+  return `${versionStr}.lock`;
+}
+async function dirExists(path2) {
+  try {
+    await (0, import_promises.access)(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var VersionStore = class {
+  omnifyDir;
+  versionsDir;
+  maxVersions;
+  constructor(config) {
+    this.omnifyDir = (0, import_path.join)(config.baseDir, OMNIFY_DIR);
+    this.versionsDir = (0, import_path.join)(this.omnifyDir, VERSIONS_DIR);
+    this.maxVersions = config.maxVersions ?? 0;
+  }
+  /**
+   * Initialize the version store directory structure.
+   */
+  async initialize() {
+    await (0, import_promises.mkdir)(this.versionsDir, { recursive: true });
+  }
+  /**
+   * Get the path to the versions directory.
+   */
+  getVersionsDir() {
+    return this.versionsDir;
+  }
+  /**
+   * Get the path to a specific version file.
+   */
+  getVersionPath(version, migration) {
+    const filename = generateVersionFilename(version, migration);
+    return (0, import_path.join)(this.versionsDir, filename);
+  }
+  /**
+   * List all available versions.
+   */
+  async listVersions() {
+    if (!await dirExists(this.versionsDir)) {
+      return [];
+    }
+    const files = await (0, import_promises.readdir)(this.versionsDir);
+    const versions = [];
+    for (const file of files) {
+      const parsed = parseVersionFilename(file);
+      if (!parsed) continue;
+      try {
+        const filePath = (0, import_path.join)(this.versionsDir, file);
+        const content = await (0, import_promises.readFile)(filePath, "utf-8");
+        const versionFile = import_js_yaml2.default.load(content);
+        const summary = {
+          version: versionFile.version,
+          timestamp: versionFile.timestamp,
+          ...versionFile.migration !== void 0 && { migration: versionFile.migration },
+          ...versionFile.description !== void 0 && { description: versionFile.description },
+          schemaCount: Object.keys(versionFile.snapshot).length,
+          changeCount: versionFile.changes.length
+        };
+        versions.push(summary);
+      } catch {
+      }
+    }
+    return versions.sort((a, b) => a.version - b.version);
+  }
+  /**
+   * Get the latest version number.
+   */
+  async getLatestVersion() {
+    const versions = await this.listVersions();
+    if (versions.length === 0) return 0;
+    const lastVersion = versions[versions.length - 1];
+    return lastVersion?.version ?? 0;
+  }
+  /**
+   * Read a specific version file.
+   */
+  async readVersion(version) {
+    if (!await dirExists(this.versionsDir)) {
+      return null;
+    }
+    const files = await (0, import_promises.readdir)(this.versionsDir);
+    for (const file of files) {
+      const parsed = parseVersionFilename(file);
+      if (parsed?.version === version) {
+        const filePath = (0, import_path.join)(this.versionsDir, file);
+        const content = await (0, import_promises.readFile)(filePath, "utf-8");
+        return import_js_yaml2.default.load(content);
+      }
+    }
+    return null;
+  }
+  /**
+   * Read the latest version file.
+   */
+  async readLatestVersion() {
+    const latestVersion = await this.getLatestVersion();
+    if (latestVersion === 0) return null;
+    return this.readVersion(latestVersion);
+  }
+  /**
+   * Create a new version.
+   */
+  async createVersion(snapshot, changes, options) {
+    await this.initialize();
+    const latestVersion = await this.getLatestVersion();
+    const newVersion = latestVersion + 1;
+    const versionFile = {
+      version: newVersion,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      driver: options.driver,
+      ...options.migration !== void 0 && { migration: options.migration },
+      ...options.description !== void 0 && { description: options.description },
+      changes,
+      snapshot
+    };
+    const filePath = this.getVersionPath(newVersion, options.migration);
+    const content = import_js_yaml2.default.dump(versionFile, {
+      lineWidth: -1,
+      // Disable line wrapping
+      noRefs: true,
+      quotingType: '"'
+    });
+    await (0, import_promises.writeFile)(filePath, content, "utf-8");
+    await this.updateCurrentLink(versionFile);
+    if (this.maxVersions > 0) {
+      await this.cleanupOldVersions();
+    }
+    return versionFile;
+  }
+  /**
+   * Update the current.lock file to point to latest version.
+   */
+  async updateCurrentLink(versionFile) {
+    const currentPath = (0, import_path.join)(this.omnifyDir, CURRENT_FILE);
+    const content = import_js_yaml2.default.dump(versionFile, {
+      lineWidth: -1,
+      noRefs: true,
+      quotingType: '"'
+    });
+    await (0, import_promises.writeFile)(currentPath, content, "utf-8");
+  }
+  /**
+   * Cleanup old versions beyond maxVersions limit.
+   */
+  async cleanupOldVersions() {
+    const versions = await this.listVersions();
+    if (versions.length <= this.maxVersions) return;
+    const toDelete = versions.slice(0, versions.length - this.maxVersions);
+    for (const v of toDelete) {
+      const files = await (0, import_promises.readdir)(this.versionsDir);
+      for (const file of files) {
+        const parsed = parseVersionFilename(file);
+        if (parsed?.version === v.version) {
+          await (0, import_promises.rm)((0, import_path.join)(this.versionsDir, file));
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * Get diff between two versions.
+   */
+  async diffVersions(fromVersion, toVersion) {
+    const fromFile = await this.readVersion(fromVersion);
+    const toFile = await this.readVersion(toVersion);
+    if (!fromFile || !toFile) return null;
+    const allChanges = [];
+    if (fromVersion < toVersion) {
+      for (let v = fromVersion + 1; v <= toVersion; v++) {
+        const vFile = await this.readVersion(v);
+        if (vFile) {
+          allChanges.push(...vFile.changes);
+        }
+      }
+    } else {
+      const changes = this.computeSnapshotDiff(fromFile.snapshot, toFile.snapshot);
+      allChanges.push(...changes);
+    }
+    return {
+      fromVersion,
+      toVersion,
+      changes: allChanges
+    };
+  }
+  /**
+   * Compute changes between two snapshots.
+   */
+  computeSnapshotDiff(from, to) {
+    const changes = [];
+    const fromNames = new Set(Object.keys(from));
+    const toNames = new Set(Object.keys(to));
+    for (const name of toNames) {
+      if (!fromNames.has(name)) {
+        changes.push({ action: "schema_added", schema: name });
+      }
+    }
+    for (const name of fromNames) {
+      if (!toNames.has(name)) {
+        changes.push({ action: "schema_removed", schema: name });
+      }
+    }
+    for (const name of fromNames) {
+      if (!toNames.has(name)) continue;
+      const fromSchema = from[name];
+      const toSchema = to[name];
+      if (!fromSchema || !toSchema) continue;
+      const fromProps = fromSchema.properties ?? {};
+      const toProps = toSchema.properties ?? {};
+      const fromPropNames = new Set(Object.keys(fromProps));
+      const toPropNames = new Set(Object.keys(toProps));
+      for (const prop of toPropNames) {
+        if (!fromPropNames.has(prop)) {
+          changes.push({
+            action: "property_added",
+            schema: name,
+            property: prop,
+            to: toProps[prop]
+          });
+        }
+      }
+      for (const prop of fromPropNames) {
+        if (!toPropNames.has(prop)) {
+          changes.push({
+            action: "property_removed",
+            schema: name,
+            property: prop,
+            from: fromProps[prop]
+          });
+        }
+      }
+      for (const prop of fromPropNames) {
+        if (!toPropNames.has(prop)) continue;
+        if (JSON.stringify(fromProps[prop]) !== JSON.stringify(toProps[prop])) {
+          changes.push({
+            action: "property_modified",
+            schema: name,
+            property: prop,
+            from: fromProps[prop],
+            to: toProps[prop]
+          });
+        }
+      }
+      if (JSON.stringify(fromSchema.options) !== JSON.stringify(toSchema.options)) {
+        changes.push({
+          action: "option_changed",
+          schema: name,
+          from: fromSchema.options,
+          to: toSchema.options
+        });
+      }
+    }
+    return changes;
+  }
+  /**
+   * Get snapshot at a specific version (for rollback).
+   */
+  async getSnapshotAt(version) {
+    const versionFile = await this.readVersion(version);
+    return versionFile?.snapshot ?? null;
+  }
+};
+function createVersionStore(config) {
+  return new VersionStore(config);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Omnify,
   OmnifyError,
   PluginManager,
+  VersionStore,
   atlasError,
   atlasNotFoundError,
   circularReferenceError,
@@ -3054,6 +3354,7 @@ function createOmnify(options) {
   configNotFoundError,
   createOmnify,
   createPluginManager,
+  createVersionStore,
   duplicateSchemaError,
   err,
   expandProperty,