@famgia/omnify-atlas 0.0.110 → 0.0.112

package/dist/index.js

@@ -480,8 +480,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);
@@ -551,6 +551,326 @@ function getMigrationsToRegenerate(lockFile, missingFiles) {
   return result;
 }
 
+// src/lock/version-chain.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync } from "fs";
+import { resolve } from "path";
+var VERSION_CHAIN_FILE = ".omnify.chain";
+function computeSha256(content) {
+  return createHash2("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 readFile2(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 writeFile2(chainFilePath, content, "utf8");
+}
+async function getFileContentHash(filePath) {
+  try {
+    const content = await readFile2(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 = resolve(schemasDir, locked.relativePath);
+    if (!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) => ({
@@ -1086,8 +1406,8 @@ function renderHcl(schema) {
 
 // src/atlas/runner.ts
 import { execa } from "execa";
-import { mkdir, writeFile as writeFile2, rm } from "fs/promises";
-import { join } from "path";
+import { mkdir, writeFile as writeFile3, rm } from "fs/promises";
+import { join as join2 } from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
 import { atlasError, atlasNotFoundError } from "@famgia/omnify-core";
@@ -1115,7 +1435,7 @@ function normalizeDevUrl(devUrl, driver) {
   return devUrl;
 }
 async function createTempDir() {
-  const tempPath = join(tmpdir(), `omnify-atlas-${randomUUID()}`);
+  const tempPath = join2(tmpdir(), `omnify-atlas-${randomUUID()}`);
   await mkdir(tempPath, { recursive: true });
   return tempPath;
 }
@@ -1205,12 +1525,12 @@ async function runAtlasDiff(config, options) {
 async function diffHclSchemas(config, fromHcl, toHcl) {
   const tempDir = await createTempDir();
   try {
-    const toPath = join(tempDir, "to.hcl");
-    await writeFile2(toPath, toHcl, "utf8");
+    const toPath = join2(tempDir, "to.hcl");
+    await writeFile3(toPath, toHcl, "utf8");
     let fromPath;
     if (fromHcl) {
-      fromPath = join(tempDir, "from.hcl");
-      await writeFile2(fromPath, fromHcl, "utf8");
+      fromPath = join2(tempDir, "from.hcl");
+      await writeFile3(fromPath, fromHcl, "utf8");
     }
     return await runAtlasDiff(config, {
       fromPath,
@@ -1624,7 +1944,7 @@ function formatDiffSummary(result) {
 }
 
 // src/preview/preview.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { atlasNotFoundError as atlasNotFoundError2 } from "@famgia/omnify-core";
 async function generatePreview(schemas, atlasConfig, options = {}) {
   const atlasVersion = await checkAtlasVersion(atlasConfig);
@@ -1632,7 +1952,7 @@ async function generatePreview(schemas, atlasConfig, options = {}) {
     throw atlasNotFoundError2();
   }
   const currentHashes = await buildSchemaHashes(schemas);
-  const lockFilePath = join2(atlasConfig.workDir ?? process.cwd(), LOCK_FILE_NAME);
+  const lockFilePath = join3(atlasConfig.workDir ?? process.cwd(), LOCK_FILE_NAME);
   const existingLockFile = await readLockFile(lockFilePath);
   const schemaChanges = compareSchemas(currentHashes, existingLockFile);
   const currentHcl = renderHcl(
@@ -1710,17 +2030,26 @@ function hasBlockingIssues(_preview) {
 export {
   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,
@@ -1730,6 +2059,9 @@ export {
   generateHclSchema,
   generateHclTable,
   generatePreview,
+  generateVersionName,
+  getChainSummary,
+  getLockedSchemas,
   getMigrationsToRegenerate,
   getPrimaryKeyType,
   getTimestampType,
@@ -1741,6 +2073,7 @@ export {
   propertyNameToColumnName,
   propertyToSnapshot,
   readLockFile,
+  readVersionChain,
   renderHcl,
   runAtlasDiff,
   schemaNameToTableName,
@@ -1749,6 +2082,8 @@ export {
   updateLockFileV1,
   validateHcl,
   validateMigrations,
-  writeLockFile
+  verifyChain,
+  writeLockFile,
+  writeVersionChain
 };
 //# sourceMappingURL=index.js.map