@famgia/omnify-atlas 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -25,8 +25,10 @@ __export(index_exports, {
   addMigrationRecord: () => addMigrationRecord,
   applySchema: () => applySchema,
   buildSchemaHashes: () => buildSchemaHashes,
+  buildSchemaSnapshots: () => buildSchemaSnapshots,
   checkAtlasVersion: () => checkAtlasVersion,
   compareSchemas: () => compareSchemas,
+  compareSchemasDeep: () => compareSchemasDeep,
   computeHash: () => computeHash,
   computeSchemaHash: () => computeSchemaHash,
   createEmptyLockFile: () => createEmptyLockFile,
@@ -39,15 +41,19 @@ __export(index_exports, {
   getPrimaryKeyType: () => getPrimaryKeyType,
   getTimestampType: () => getTimestampType,
   hasBlockingIssues: () => hasBlockingIssues,
+  isLockFileV2: () => isLockFileV2,
   mapPropertyToSql: () => mapPropertyToSql,
   parseDiffOutput: () => parseDiffOutput,
   previewSchemaChanges: () => previewSchemaChanges,
   propertyNameToColumnName: () => propertyNameToColumnName,
+  propertyToSnapshot: () => propertyToSnapshot,
   readLockFile: () => readLockFile,
   renderHcl: () => renderHcl,
   runAtlasDiff: () => runAtlasDiff,
   schemaNameToTableName: () => schemaNameToTableName,
+  schemaToSnapshot: () => schemaToSnapshot,
   updateLockFile: () => updateLockFile,
+  updateLockFileV1: () => updateLockFileV1,
   validateHcl: () => validateHcl,
   writeLockFile: () => writeLockFile
 });
@@ -57,7 +63,7 @@ module.exports = __toCommonJS(index_exports);
 var import_node_crypto = require("crypto");
 var import_promises = require("fs/promises");
 var LOCK_FILE_NAME = ".omnify.lock";
-var LOCK_FILE_VERSION = 1;
+var LOCK_FILE_VERSION = 2;
 function computeHash(content) {
   return (0, import_node_crypto.createHash)("sha256").update(content, "utf8").digest("hex");
 }
@@ -80,13 +86,75 @@ function createEmptyLockFile(driver) {
     migrations: []
   };
 }
+function propertyToSnapshot(property) {
+  const prop = property;
+  return {
+    type: prop.type,
+    nullable: prop.nullable,
+    unique: prop.unique,
+    default: prop.default,
+    length: prop.length,
+    unsigned: prop.unsigned,
+    precision: prop.precision,
+    scale: prop.scale,
+    enum: prop.enum,
+    relation: prop.relation,
+    target: prop.target,
+    onDelete: prop.onDelete,
+    onUpdate: prop.onUpdate,
+    mappedBy: prop.mappedBy,
+    joinTable: prop.joinTable,
+    // renamedFrom is kept in snapshot for comparison (rename detection),
+    // but will be stripped when writing to lock file.
+    renamedFrom: prop.renamedFrom
+  };
+}
+function schemaToSnapshot(schema, hash, modifiedAt) {
+  const properties = {};
+  if (schema.properties) {
+    for (const [name, prop] of Object.entries(schema.properties)) {
+      properties[name] = propertyToSnapshot(prop);
+    }
+  }
+  const opts = schema.options;
+  let indexes;
+  if (opts?.indexes && opts.indexes.length > 0) {
+    indexes = opts.indexes.map((idx) => ({
+      columns: idx.columns,
+      unique: idx.unique ?? false,
+      name: idx.name
+    }));
+  }
+  let uniqueConstraints;
+  if (opts?.unique) {
+    uniqueConstraints = Array.isArray(opts.unique[0]) ? opts.unique : [opts.unique];
+  }
+  return {
+    name: schema.name,
+    kind: schema.kind ?? "object",
+    hash,
+    relativePath: schema.relativePath,
+    modifiedAt,
+    properties,
+    primaryKeyType: opts?.primaryKeyType,
+    timestamps: opts?.timestamps,
+    softDelete: opts?.softDelete,
+    indexes,
+    uniqueConstraints,
+    values: schema.values
+  };
+}
+function isLockFileV2(lockFile) {
+  return lockFile.version === 2;
+}
 async function readLockFile(lockFilePath) {
   try {
     const content = await (0, import_promises.readFile)(lockFilePath, "utf8");
     const parsed = JSON.parse(content);
-    if (parsed.version !== LOCK_FILE_VERSION) {
+    const lockFile = parsed;
+    if (lockFile.version !== 1 && lockFile.version !== 2) {
       throw new Error(
-        `Lock file version mismatch: expected ${LOCK_FILE_VERSION}, got ${parsed.version}`
+        `Lock file version mismatch: expected 1 or 2, got ${lockFile.version}`
       );
     }
     return parsed;
@@ -121,6 +189,138 @@ async function buildSchemaHashes(schemas) {
   }
   return hashes;
 }
+async function buildSchemaSnapshots(schemas) {
+  const snapshots = {};
+  for (const [name, schema] of Object.entries(schemas)) {
+    const hash = computeSchemaHash(schema);
+    let modifiedAt;
+    try {
+      const stats = await (0, import_promises.stat)(schema.filePath);
+      modifiedAt = stats.mtime.toISOString();
+    } catch {
+      modifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    snapshots[name] = schemaToSnapshot(schema, hash, modifiedAt);
+  }
+  return snapshots;
+}
+function diffPropertySnapshots(prev, curr) {
+  const modifications = [];
+  if (prev.type !== curr.type) modifications.push("type");
+  if (prev.nullable !== curr.nullable) modifications.push("nullable");
+  if (prev.unique !== curr.unique) modifications.push("unique");
+  if (JSON.stringify(prev.default) !== JSON.stringify(curr.default)) modifications.push("default");
+  if (prev.length !== curr.length) modifications.push("length");
+  if (prev.unsigned !== curr.unsigned) modifications.push("unsigned");
+  if (prev.precision !== curr.precision) modifications.push("precision");
+  if (prev.scale !== curr.scale) modifications.push("scale");
+  if (JSON.stringify(prev.enum) !== JSON.stringify(curr.enum)) modifications.push("enum");
+  if (prev.relation !== curr.relation) modifications.push("relation");
+  if (prev.target !== curr.target) modifications.push("target");
+  if (prev.onDelete !== curr.onDelete) modifications.push("onDelete");
+  if (prev.onUpdate !== curr.onUpdate) modifications.push("onUpdate");
+  if (prev.mappedBy !== curr.mappedBy) modifications.push("mappedBy");
+  return modifications;
+}
+function diffIndexes(prev, curr) {
+  const changes = [];
+  const prevIndexes = prev ?? [];
+  const currIndexes = curr ?? [];
+  const indexKey = (idx) => `${idx.columns.join(",")}:${idx.unique}`;
+  const prevKeys = new Map(prevIndexes.map((idx) => [indexKey(idx), idx]));
+  const currKeys = new Map(currIndexes.map((idx) => [indexKey(idx), idx]));
+  for (const [key, idx] of currKeys) {
+    if (!prevKeys.has(key)) {
+      changes.push({ changeType: "added", index: idx });
+    }
+  }
+  for (const [key, idx] of prevKeys) {
+    if (!currKeys.has(key)) {
+      changes.push({ changeType: "removed", index: idx });
+    }
+  }
+  return changes;
+}
+function diffSchemaSnapshots(prev, curr) {
+  const columnChanges = [];
+  const prevProps = prev.properties;
+  const currProps = curr.properties;
+  const prevNames = new Set(Object.keys(prevProps));
+  const currNames = new Set(Object.keys(currProps));
+  const renamedNewNames = /* @__PURE__ */ new Set();
+  const renamedOldNames = /* @__PURE__ */ new Set();
+  for (const [name, currProp] of Object.entries(currProps)) {
+    if (currProp.renamedFrom && prevProps[currProp.renamedFrom]) {
+      const prevProp = prevProps[currProp.renamedFrom];
+      const mods = diffPropertySnapshots(prevProp, currProp);
+      const filteredMods = mods.filter((m) => m !== "renamedFrom");
+      columnChanges.push({
+        column: name,
+        changeType: "renamed",
+        previousColumn: currProp.renamedFrom,
+        previousDef: prevProp,
+        currentDef: currProp,
+        modifications: filteredMods.length > 0 ? filteredMods : void 0
+      });
+      renamedNewNames.add(name);
+      renamedOldNames.add(currProp.renamedFrom);
+    }
+  }
+  for (const name of currNames) {
+    if (!prevNames.has(name) && !renamedNewNames.has(name)) {
+      columnChanges.push({
+        column: name,
+        changeType: "added",
+        currentDef: currProps[name]
+      });
+    }
+  }
+  for (const name of prevNames) {
+    if (!currNames.has(name) && !renamedOldNames.has(name)) {
+      columnChanges.push({
+        column: name,
+        changeType: "removed",
+        previousDef: prevProps[name]
+      });
+    }
+  }
+  for (const name of currNames) {
+    if (prevNames.has(name) && !renamedNewNames.has(name)) {
+      const prevProp = prevProps[name];
+      const currProp = currProps[name];
+      const mods = diffPropertySnapshots(prevProp, currProp);
+      if (mods.length > 0) {
+        columnChanges.push({
+          column: name,
+          changeType: "modified",
+          previousDef: prevProp,
+          currentDef: currProp,
+          modifications: mods
+        });
+      }
+    }
+  }
+  const indexChanges = diffIndexes(prev.indexes, curr.indexes);
+  const optionChanges = {};
+  let hasOptionChanges = false;
+  if (prev.timestamps !== curr.timestamps) {
+    optionChanges.timestamps = { from: prev.timestamps, to: curr.timestamps };
+    hasOptionChanges = true;
+  }
+  if (prev.softDelete !== curr.softDelete) {
+    optionChanges.softDelete = { from: prev.softDelete, to: curr.softDelete };
+    hasOptionChanges = true;
+  }
+  if (prev.primaryKeyType !== curr.primaryKeyType) {
+    optionChanges.primaryKeyType = { from: prev.primaryKeyType, to: curr.primaryKeyType };
+    hasOptionChanges = true;
+  }
+  return {
+    columnChanges: columnChanges.length > 0 ? columnChanges : void 0,
+    indexChanges: indexChanges.length > 0 ? indexChanges : void 0,
+    optionChanges: hasOptionChanges ? optionChanges : void 0
+  };
+}
 function compareSchemas(currentHashes, lockFile) {
   const changes = [];
   const unchanged = [];
@@ -175,11 +375,95 @@ function compareSchemas(currentHashes, lockFile) {
     unchanged
   };
 }
-function updateLockFile(existingLockFile, currentHashes, driver) {
+function compareSchemasDeep(currentSnapshots, lockFile) {
+  const changes = [];
+  const unchanged = [];
+  const previousSnapshots = lockFile?.schemas ?? {};
+  const previousNames = new Set(Object.keys(previousSnapshots));
+  const currentNames = new Set(Object.keys(currentSnapshots));
+  for (const name of currentNames) {
+    if (!previousNames.has(name)) {
+      const current = currentSnapshots[name];
+      if (current) {
+        changes.push({
+          schemaName: name,
+          changeType: "added",
+          currentHash: current.hash
+        });
+      }
+    }
+  }
+  for (const name of previousNames) {
+    if (!currentNames.has(name)) {
+      const previous = previousSnapshots[name];
+      if (previous) {
+        changes.push({
+          schemaName: name,
+          changeType: "removed",
+          previousHash: previous.hash
+        });
+      }
+    }
+  }
+  for (const name of currentNames) {
+    if (previousNames.has(name)) {
+      const current = currentSnapshots[name];
+      const previous = previousSnapshots[name];
+      if (current.hash !== previous.hash) {
+        const diff = diffSchemaSnapshots(previous, current);
+        changes.push({
+          schemaName: name,
+          changeType: "modified",
+          previousHash: previous.hash,
+          currentHash: current.hash,
+          ...diff
+        });
+      } else {
+        unchanged.push(name);
+      }
+    }
+  }
+  return {
+    hasChanges: changes.length > 0,
+    changes,
+    unchanged
+  };
+}
+function stripTransientInfo(snapshots) {
+  const result = {};
+  for (const [schemaName, snapshot] of Object.entries(snapshots)) {
+    if (!snapshot.properties) {
+      result[schemaName] = snapshot;
+      continue;
+    }
+    const cleanProperties = {};
+    for (const [propName, prop] of Object.entries(snapshot.properties)) {
+      const { renamedFrom, ...rest } = prop;
+      cleanProperties[propName] = rest;
+    }
+    result[schemaName] = {
+      ...snapshot,
+      properties: cleanProperties
+    };
+  }
+  return result;
+}
+function updateLockFile(existingLockFile, currentSnapshots, driver) {
+  const cleanSnapshots = stripTransientInfo(currentSnapshots);
   return {
     version: LOCK_FILE_VERSION,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     driver,
+    schemas: cleanSnapshots,
+    migrations: existingLockFile?.migrations ?? [],
+    hclChecksum: existingLockFile?.hclChecksum
+  };
+}
+function updateLockFileV1(existingLockFile, currentHashes, driver) {
+  return {
+    version: 1,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    driver,
     schemas: currentHashes,
     migrations: existingLockFile?.migrations ?? [],
     hclChecksum: existingLockFile?.hclChecksum
@@ -1360,8 +1644,10 @@ function hasBlockingIssues(_preview) {
   addMigrationRecord,
   applySchema,
   buildSchemaHashes,
+  buildSchemaSnapshots,
   checkAtlasVersion,
   compareSchemas,
+  compareSchemasDeep,
   computeHash,
   computeSchemaHash,
   createEmptyLockFile,
@@ -1374,15 +1660,19 @@ function hasBlockingIssues(_preview) {
   getPrimaryKeyType,
   getTimestampType,
   hasBlockingIssues,
+  isLockFileV2,
   mapPropertyToSql,
   parseDiffOutput,
   previewSchemaChanges,
   propertyNameToColumnName,
+  propertyToSnapshot,
   readLockFile,
   renderHcl,
   runAtlasDiff,
   schemaNameToTableName,
+  schemaToSnapshot,
   updateLockFile,
+  updateLockFileV1,
   validateHcl,
   writeLockFile
 });