@famgia/omnify-atlas 0.0.111 → 0.0.112

package/dist/index.cjs

@@ -32,17 +32,26 @@ var index_exports = {};
 __export(index_exports, {
   LOCK_FILE_NAME: () => LOCK_FILE_NAME,
   LOCK_FILE_VERSION: () => LOCK_FILE_VERSION,
+  VERSION_CHAIN_FILE: () => VERSION_CHAIN_FILE,
   addEnhancedMigrationRecord: () => addEnhancedMigrationRecord,
   addMigrationRecord: () => addMigrationRecord,
   applySchema: () => applySchema,
+  buildCurrentSchemaEntries: () => buildCurrentSchemaEntries,
   buildSchemaHashes: () => buildSchemaHashes,
   buildSchemaSnapshots: () => buildSchemaSnapshots,
   checkAtlasVersion: () => checkAtlasVersion,
+  checkBulkLockViolation: () => checkBulkLockViolation,
+  checkLockViolation: () => checkLockViolation,
   compareSchemas: () => compareSchemas,
   compareSchemasDeep: () => compareSchemasDeep,
+  computeBlockHash: () => computeBlockHash,
   computeHash: () => computeHash,
   computeSchemaHash: () => computeSchemaHash,
+  computeSha256: () => computeSha256,
+  createDeployBlock: () => createDeployBlock,
+  createEmptyChain: () => createEmptyChain,
   createEmptyLockFile: () => createEmptyLockFile,
+  deployVersion: () => deployVersion,
   diffHclSchemas: () => diffHclSchemas,
   extractTableNameFromFilename: () => extractTableNameFromFilename,
   extractTimestampFromFilename: () => extractTimestampFromFilename,
@@ -52,6 +61,9 @@ __export(index_exports, {
   generateHclSchema: () => generateHclSchema,
   generateHclTable: () => generateHclTable,
   generatePreview: () => generatePreview,
+  generateVersionName: () => generateVersionName,
+  getChainSummary: () => getChainSummary,
+  getLockedSchemas: () => getLockedSchemas,
   getMigrationsToRegenerate: () => getMigrationsToRegenerate,
   getPrimaryKeyType: () => getPrimaryKeyType,
   getTimestampType: () => getTimestampType,
@@ -63,6 +75,7 @@ __export(index_exports, {
   propertyNameToColumnName: () => propertyNameToColumnName,
   propertyToSnapshot: () => propertyToSnapshot,
   readLockFile: () => readLockFile,
+  readVersionChain: () => readVersionChain,
   renderHcl: () => renderHcl,
   runAtlasDiff: () => runAtlasDiff,
   schemaNameToTableName: () => schemaNameToTableName,
@@ -71,7 +84,9 @@ __export(index_exports, {
   updateLockFileV1: () => updateLockFileV1,
   validateHcl: () => validateHcl,
   validateMigrations: () => validateMigrations,
-  writeLockFile: () => writeLockFile
+  verifyChain: () => verifyChain,
+  writeLockFile: () => writeLockFile,
+  writeVersionChain: () => writeVersionChain
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -557,8 +572,8 @@ async function validateMigrations(lockFile, migrationsDir) {
     if (migration.checksum) {
       try {
         const { readFileSync } = await import("fs");
-        const { join: join3 } = await import("path");
-        const content = readFileSync(join3(migrationsDir, fileName), "utf8");
+        const { join: join4 } = await import("path");
+        const content = readFileSync(join4(migrationsDir, fileName), "utf8");
         const currentChecksum = computeHash(content);
         if (currentChecksum !== migration.checksum) {
           modifiedFiles.push(fileName);
@@ -628,6 +643,326 @@ function getMigrationsToRegenerate(lockFile, missingFiles) {
   return result;
 }
 
+// src/lock/version-chain.ts
+var import_node_crypto2 = require("crypto");
+var import_promises2 = require("fs/promises");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var VERSION_CHAIN_FILE = ".omnify.chain";
+function computeSha256(content) {
+  return (0, import_node_crypto2.createHash)("sha256").update(content, "utf8").digest("hex");
+}
+function computeBlockHash(previousHash, version, lockedAt, environment, schemas) {
+  const content = JSON.stringify({
+    previousHash,
+    version,
+    lockedAt,
+    environment,
+    schemas: schemas.map((s) => ({
+      name: s.name,
+      relativePath: s.relativePath,
+      contentHash: s.contentHash
+    }))
+  });
+  return computeSha256(content);
+}
+function createEmptyChain() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 1,
+    type: "omnify-version-chain",
+    genesisHash: null,
+    latestHash: null,
+    blocks: [],
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function readVersionChain(chainFilePath) {
+  try {
+    const content = await (0, import_promises2.readFile)(chainFilePath, "utf8");
+    const parsed = JSON.parse(content);
+    const chain = parsed;
+    if (chain.type !== "omnify-version-chain" || chain.version !== 1) {
+      throw new Error("Invalid version chain file format");
+    }
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeVersionChain(chainFilePath, chain) {
+  const content = JSON.stringify(chain, null, 2) + "\n";
+  await (0, import_promises2.writeFile)(chainFilePath, content, "utf8");
+}
+async function getFileContentHash(filePath) {
+  try {
+    const content = await (0, import_promises2.readFile)(filePath, "utf8");
+    return computeSha256(content);
+  } catch {
+    return null;
+  }
+}
+async function buildCurrentSchemaEntries(schemasDir, schemaFiles) {
+  const entries = [];
+  for (const schema of schemaFiles) {
+    const contentHash = await getFileContentHash(schema.filePath);
+    if (contentHash) {
+      entries.push({
+        name: schema.name,
+        relativePath: schema.relativePath,
+        contentHash
+      });
+    }
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+function generateVersionName() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hour = String(now.getHours()).padStart(2, "0");
+  const minute = String(now.getMinutes()).padStart(2, "0");
+  const second = String(now.getSeconds()).padStart(2, "0");
+  return `v${year}.${month}.${day}-${hour}${minute}${second}`;
+}
+async function verifyChain(chain, schemasDir) {
+  const verifiedBlocks = [];
+  const corruptedBlocks = [];
+  const tamperedSchemas = [];
+  const deletedLockedSchemas = [];
+  const lockedSchemas = /* @__PURE__ */ new Map();
+  let previousHash = null;
+  for (const block of chain.blocks) {
+    const expectedHash = computeBlockHash(
+      previousHash,
+      block.version,
+      block.lockedAt,
+      block.environment,
+      block.schemas
+    );
+    if (expectedHash !== block.blockHash) {
+      corruptedBlocks.push({
+        version: block.version,
+        expectedHash,
+        actualHash: block.blockHash,
+        reason: "Block hash mismatch - chain integrity compromised"
+      });
+    }
+    if (block.previousHash !== previousHash) {
+      corruptedBlocks.push({
+        version: block.version,
+        expectedHash: previousHash ?? "null",
+        actualHash: block.previousHash ?? "null",
+        reason: "Previous hash chain broken"
+      });
+    }
+    for (const schema of block.schemas) {
+      lockedSchemas.set(schema.name, {
+        hash: schema.contentHash,
+        version: block.version,
+        relativePath: schema.relativePath
+      });
+    }
+    if (corruptedBlocks.length === 0 || corruptedBlocks[corruptedBlocks.length - 1]?.version !== block.version) {
+      verifiedBlocks.push(block.version);
+    }
+    previousHash = block.blockHash;
+  }
+  for (const [name, locked] of lockedSchemas) {
+    const filePath = (0, import_node_path.resolve)(schemasDir, locked.relativePath);
+    if (!(0, import_node_fs.existsSync)(filePath)) {
+      deletedLockedSchemas.push({
+        schemaName: name,
+        filePath: locked.relativePath,
+        lockedInVersion: locked.version,
+        lockedHash: locked.hash
+      });
+    } else {
+      const currentHash = await getFileContentHash(filePath);
+      if (currentHash && currentHash !== locked.hash) {
+        tamperedSchemas.push({
+          schemaName: name,
+          filePath: locked.relativePath,
+          lockedHash: locked.hash,
+          currentHash,
+          lockedInVersion: locked.version
+        });
+      }
+    }
+  }
+  return {
+    valid: corruptedBlocks.length === 0 && tamperedSchemas.length === 0 && deletedLockedSchemas.length === 0,
+    blockCount: chain.blocks.length,
+    verifiedBlocks,
+    corruptedBlocks,
+    tamperedSchemas,
+    deletedLockedSchemas
+  };
+}
+function checkLockViolation(chain, schemaName, action) {
+  const affectedVersions = [];
+  for (const block of chain.blocks) {
+    const schema = block.schemas.find((s) => s.name === schemaName);
+    if (schema) {
+      affectedVersions.push(block.version);
+    }
+  }
+  if (affectedVersions.length > 0) {
+    return {
+      allowed: false,
+      reason: `Schema '${schemaName}' is locked in production version(s): ${affectedVersions.join(", ")}. ${action === "delete" ? "Deletion" : "Modification"} is not allowed.`,
+      affectedSchemas: [schemaName],
+      lockedInVersions: affectedVersions
+    };
+  }
+  return {
+    allowed: true,
+    affectedSchemas: [],
+    lockedInVersions: []
+  };
+}
+function checkBulkLockViolation(chain, schemas) {
+  const violations = [];
+  for (const { name, action } of schemas) {
+    const result = checkLockViolation(chain, name, action);
+    if (!result.allowed) {
+      violations.push({
+        name,
+        versions: [...result.lockedInVersions]
+      });
+    }
+  }
+  if (violations.length > 0) {
+    const schemaList = violations.map((v) => v.name);
+    const allVersions = [...new Set(violations.flatMap((v) => v.versions))];
+    return {
+      allowed: false,
+      reason: `The following schemas are locked: ${schemaList.join(", ")}. They cannot be modified or deleted.`,
+      affectedSchemas: schemaList,
+      lockedInVersions: allVersions
+    };
+  }
+  return {
+    allowed: true,
+    affectedSchemas: [],
+    lockedInVersions: []
+  };
+}
+function createDeployBlock(chain, schemas, options) {
+  const version = options.version ?? generateVersionName();
+  const lockedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const previousHash = chain.latestHash;
+  const blockHash = computeBlockHash(
+    previousHash,
+    version,
+    lockedAt,
+    options.environment,
+    schemas
+  );
+  const block = {
+    version,
+    blockHash,
+    previousHash,
+    lockedAt,
+    environment: options.environment,
+    deployedBy: options.deployedBy,
+    schemas,
+    comment: options.comment
+  };
+  const updatedChain = {
+    ...chain,
+    genesisHash: chain.genesisHash ?? blockHash,
+    latestHash: blockHash,
+    blocks: [...chain.blocks, block],
+    updatedAt: lockedAt
+  };
+  return { chain: updatedChain, block };
+}
+async function deployVersion(chainFilePath, schemasDir, schemaFiles, options) {
+  let chain = await readVersionChain(chainFilePath);
+  if (!chain) {
+    chain = createEmptyChain();
+  }
+  const currentSchemas = await buildCurrentSchemaEntries(schemasDir, schemaFiles);
+  if (currentSchemas.length === 0) {
+    return {
+      success: false,
+      error: "No schema files found to lock",
+      addedSchemas: [],
+      modifiedSchemas: [],
+      warnings: []
+    };
+  }
+  const previousSchemas = /* @__PURE__ */ new Map();
+  for (const block2 of chain.blocks) {
+    for (const schema of block2.schemas) {
+      previousSchemas.set(schema.name, schema.contentHash);
+    }
+  }
+  const addedSchemas = [];
+  const modifiedSchemas = [];
+  const warnings = [];
+  for (const schema of currentSchemas) {
+    const previousHash = previousSchemas.get(schema.name);
+    if (!previousHash) {
+      addedSchemas.push(schema.name);
+    } else if (previousHash !== schema.contentHash) {
+      modifiedSchemas.push(schema.name);
+      warnings.push(
+        `Schema '${schema.name}' has been modified since last lock. This version will include the new state.`
+      );
+    }
+  }
+  const { chain: updatedChain, block } = createDeployBlock(
+    chain,
+    currentSchemas,
+    options
+  );
+  await writeVersionChain(chainFilePath, updatedChain);
+  return {
+    success: true,
+    block,
+    addedSchemas,
+    modifiedSchemas,
+    warnings
+  };
+}
+function getLockedSchemas(chain) {
+  const locked = /* @__PURE__ */ new Map();
+  for (const block of chain.blocks) {
+    for (const schema of block.schemas) {
+      locked.set(schema.name, {
+        hash: schema.contentHash,
+        version: block.version,
+        relativePath: schema.relativePath
+      });
+    }
+  }
+  return locked;
+}
+function getChainSummary(chain) {
+  const schemaNames = /* @__PURE__ */ new Set();
+  const environments = /* @__PURE__ */ new Set();
+  for (const block of chain.blocks) {
+    environments.add(block.environment);
+    for (const schema of block.schemas) {
+      schemaNames.add(schema.name);
+    }
+  }
+  return {
+    blockCount: chain.blocks.length,
+    schemaCount: schemaNames.size,
+    firstVersion: chain.blocks[0]?.version ?? null,
+    latestVersion: chain.blocks[chain.blocks.length - 1]?.version ?? null,
+    environments: [...environments]
+  };
+}
+
 // src/hcl/type-mapper.ts
 var MYSQL_TYPES = {
   String: (prop) => ({
@@ -1163,10 +1498,10 @@ function renderHcl(schema) {
 
 // src/atlas/runner.ts
 var import_execa = require("execa");
-var import_promises2 = require("fs/promises");
-var import_node_path = require("path");
+var import_promises3 = require("fs/promises");
+var import_node_path2 = require("path");
 var import_node_os = require("os");
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var import_omnify_core = require("@famgia/omnify-core");
 var DEFAULT_CONFIG = {
   binaryPath: "atlas",
@@ -1192,8 +1527,8 @@ function normalizeDevUrl(devUrl, driver) {
   return devUrl;
 }
 async function createTempDir() {
-  const tempPath = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `omnify-atlas-${(0, import_node_crypto2.randomUUID)()}`);
-  await (0, import_promises2.mkdir)(tempPath, { recursive: true });
+  const tempPath = (0, import_node_path2.join)((0, import_node_os.tmpdir)(), `omnify-atlas-${(0, import_node_crypto3.randomUUID)()}`);
+  await (0, import_promises3.mkdir)(tempPath, { recursive: true });
   return tempPath;
 }
 async function executeAtlas(config, args) {
@@ -1282,19 +1617,19 @@ async function runAtlasDiff(config, options) {
 async function diffHclSchemas(config, fromHcl, toHcl) {
   const tempDir = await createTempDir();
   try {
-    const toPath = (0, import_node_path.join)(tempDir, "to.hcl");
-    await (0, import_promises2.writeFile)(toPath, toHcl, "utf8");
+    const toPath = (0, import_node_path2.join)(tempDir, "to.hcl");
+    await (0, import_promises3.writeFile)(toPath, toHcl, "utf8");
     let fromPath;
     if (fromHcl) {
-      fromPath = (0, import_node_path.join)(tempDir, "from.hcl");
-      await (0, import_promises2.writeFile)(fromPath, fromHcl, "utf8");
+      fromPath = (0, import_node_path2.join)(tempDir, "from.hcl");
+      await (0, import_promises3.writeFile)(fromPath, fromHcl, "utf8");
     }
     return await runAtlasDiff(config, {
       fromPath,
       toPath
     });
   } finally {
-    await (0, import_promises2.rm)(tempDir, { recursive: true, force: true });
+    await (0, import_promises3.rm)(tempDir, { recursive: true, force: true });
   }
 }
 async function validateHcl(config, hclPath) {
@@ -1701,7 +2036,7 @@ function formatDiffSummary(result) {
 }
 
 // src/preview/preview.ts
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 var import_omnify_core2 = require("@famgia/omnify-core");
 async function generatePreview(schemas, atlasConfig, options = {}) {
   const atlasVersion = await checkAtlasVersion(atlasConfig);
@@ -1709,7 +2044,7 @@ async function generatePreview(schemas, atlasConfig, options = {}) {
     throw (0, import_omnify_core2.atlasNotFoundError)();
   }
   const currentHashes = await buildSchemaHashes(schemas);
-  const lockFilePath = (0, import_node_path2.join)(atlasConfig.workDir ?? process.cwd(), LOCK_FILE_NAME);
+  const lockFilePath = (0, import_node_path3.join)(atlasConfig.workDir ?? process.cwd(), LOCK_FILE_NAME);
   const existingLockFile = await readLockFile(lockFilePath);
   const schemaChanges = compareSchemas(currentHashes, existingLockFile);
   const currentHcl = renderHcl(
@@ -1788,17 +2123,26 @@ function hasBlockingIssues(_preview) {
 0 && (module.exports = {
   LOCK_FILE_NAME,
   LOCK_FILE_VERSION,
+  VERSION_CHAIN_FILE,
   addEnhancedMigrationRecord,
   addMigrationRecord,
   applySchema,
+  buildCurrentSchemaEntries,
   buildSchemaHashes,
   buildSchemaSnapshots,
   checkAtlasVersion,
+  checkBulkLockViolation,
+  checkLockViolation,
   compareSchemas,
   compareSchemasDeep,
+  computeBlockHash,
   computeHash,
   computeSchemaHash,
+  computeSha256,
+  createDeployBlock,
+  createEmptyChain,
   createEmptyLockFile,
+  deployVersion,
   diffHclSchemas,
   extractTableNameFromFilename,
   extractTimestampFromFilename,
@@ -1808,6 +2152,9 @@ function hasBlockingIssues(_preview) {
   generateHclSchema,
   generateHclTable,
   generatePreview,
+  generateVersionName,
+  getChainSummary,
+  getLockedSchemas,
   getMigrationsToRegenerate,
   getPrimaryKeyType,
   getTimestampType,
@@ -1819,6 +2166,7 @@ function hasBlockingIssues(_preview) {
   propertyNameToColumnName,
   propertyToSnapshot,
   readLockFile,
+  readVersionChain,
   renderHcl,
   runAtlasDiff,
   schemaNameToTableName,
@@ -1827,6 +2175,8 @@ function hasBlockingIssues(_preview) {
   updateLockFileV1,
   validateHcl,
   validateMigrations,
-  writeLockFile
+  verifyChain,
+  writeLockFile,
+  writeVersionChain
 });
 //# sourceMappingURL=index.cjs.map