@famgia/omnify-cli 0.0.122 → 0.0.124

package/dist/cli.js

@@ -7,10 +7,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/cli.ts
-import { existsSync as existsSync8 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { resolve as resolve12 } from "path";
 import { Command } from "commander";
-import { OmnifyError as OmnifyError5 } from "@famgia/omnify-core";
+import { OmnifyError as OmnifyError7 } from "@famgia/omnify-core";
 
 // src/commands/init.ts
 import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
@@ -892,7 +892,10 @@ import {
   compareSchemasDeep,
   isLockFileV2,
   validateMigrations,
-  getMigrationsToRegenerate
+  getMigrationsToRegenerate,
+  VERSION_CHAIN_FILE,
+  readVersionChain,
+  checkBulkLockViolation
 } from "@famgia/omnify-atlas";
 import {
   generateMigrations,
@@ -1518,6 +1521,42 @@ async function runGenerate(options) {
   const currentSnapshots = await buildSchemaSnapshots(schemas);
   const v2Lock = existingLock && isLockFileV2(existingLock) ? existingLock : null;
   const comparison = compareSchemasDeep(currentSnapshots, v2Lock);
+  const chainFilePath = resolve7(rootDir, VERSION_CHAIN_FILE);
+  const versionChain = await readVersionChain(chainFilePath);
+  if (versionChain && comparison.hasChanges) {
+    const schemaActions = [];
+    for (const change of comparison.changes) {
+      if (change.changeType === "removed") {
+        schemaActions.push({ name: change.schemaName, action: "delete" });
+      } else if (change.changeType === "modified") {
+        schemaActions.push({ name: change.schemaName, action: "modify" });
+      }
+    }
+    if (schemaActions.length > 0) {
+      const lockCheck = checkBulkLockViolation(versionChain, schemaActions);
+      if (!lockCheck.allowed) {
+        logger.newline();
+        logger.error("\u{1F512} VERSION LOCK VIOLATION DETECTED");
+        logger.error("");
+        logger.error("The following schemas are locked in production:");
+        for (const name of lockCheck.affectedSchemas) {
+          logger.error(`  \u2022 ${name}`);
+        }
+        logger.error("");
+        logger.error(`Locked in version(s): ${lockCheck.lockedInVersions.join(", ")}`);
+        logger.error("");
+        logger.error("These schemas CANNOT be modified or deleted.");
+        logger.error("This is enforced by the blockchain-like version chain.");
+        logger.newline();
+        throw new OmnifyError4(
+          lockCheck.reason ?? "Schema modification blocked by version lock",
+          "E407",
+          void 0,
+          "Restore the original schema files or create new schemas instead of modifying locked ones."
+        );
+      }
+    }
+  }
   if (existingLock && config.output.laravel?.migrationsPath) {
     const migrationsDir = resolve7(rootDir, config.output.laravel.migrationsPath);
     const migrationValidation = await validateMigrations(existingLock, migrationsDir);
@@ -1783,10 +1822,10 @@ async function confirm2(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve11) => {
+  return new Promise((resolve13) => {
     rl.question(`${message} (y/N) `, (answer) => {
       rl.close();
-      resolve11(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve13(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -2134,7 +2173,7 @@ function cloneRepo(repo, targetDir) {
   logger.success("Repository cloned successfully");
 }
 function runCommand(command, targetDir) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     const child = spawn(command, [], {
       cwd: targetDir,
       shell: true,
@@ -2142,7 +2181,7 @@ function runCommand(command, targetDir) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve11();
+        resolve13();
       } else {
         reject(new Error(`Command failed with exit code ${code}`));
       }
@@ -2247,6 +2286,384 @@ function registerCreateProjectCommand(program2) {
   });
 }
 
+// src/commands/deploy.ts
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve10, dirname as dirname7 } from "path";
+import { loadSchemas as loadSchemas4, OmnifyError as OmnifyError5 } from "@famgia/omnify-core";
+import {
+  VERSION_CHAIN_FILE as VERSION_CHAIN_FILE2,
+  readVersionChain as readVersionChain2,
+  deployVersion,
+  getChainSummary,
+  verifyChain
+} from "@famgia/omnify-atlas";
+async function confirmDeploy(schemaCount, environment, version) {
+  const { createInterface: createInterface2 } = await import("readline");
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve13) => {
+    logger.newline();
+    logger.warn("\u26A0\uFE0F  WARNING: This action is IRREVERSIBLE!");
+    logger.warn("");
+    logger.warn(`   Environment: ${environment}`);
+    logger.warn(`   Version:     ${version}`);
+    logger.warn(`   Schemas:     ${schemaCount} file(s)`);
+    logger.warn("");
+    logger.warn("   Once locked, these schema files CANNOT be:");
+    logger.warn("   \u2022 Deleted");
+    logger.warn("   \u2022 Modified (content hash is recorded)");
+    logger.warn("");
+    logger.warn("   This creates an immutable blockchain-like record.");
+    logger.newline();
+    rl.question('   Type "LOCK" to confirm: ', (answer) => {
+      rl.close();
+      resolve13(answer.trim().toUpperCase() === "LOCK");
+    });
+  });
+}
+async function collectSchemaFiles(schemasDir) {
+  const files = [];
+  const schemas = await loadSchemas4(schemasDir);
+  for (const [name, schema] of Object.entries(schemas)) {
+    files.push({
+      name,
+      relativePath: schema.relativePath,
+      filePath: schema.filePath
+    });
+  }
+  return files;
+}
+async function runDeploy(options) {
+  logger.setVerbose(options.verbose ?? false);
+  logger.header("Deploy Version Lock");
+  logger.debug("Loading configuration...");
+  const { config, configPath: configPath2 } = await loadConfig();
+  const rootDir = configPath2 ? dirname7(configPath2) : process.cwd();
+  validateConfig(config, rootDir);
+  const schemasDir = resolve10(rootDir, config.schemasDir);
+  const chainFilePath = resolve10(rootDir, VERSION_CHAIN_FILE2);
+  if (!existsSync8(schemasDir)) {
+    throw new OmnifyError5(
+      `Schemas directory not found: ${schemasDir}`,
+      "E003",
+      void 0,
+      "Make sure the schemasDir in omnify.config.ts is correct."
+    );
+  }
+  logger.step("Collecting schema files...");
+  const schemaFiles = await collectSchemaFiles(schemasDir);
+  if (schemaFiles.length === 0) {
+    throw new OmnifyError5(
+      "No schema files found",
+      "E003",
+      void 0,
+      "Create schema files in your schemas directory before deploying."
+    );
+  }
+  logger.info(`Found ${schemaFiles.length} schema file(s)`);
+  const existingChain = await readVersionChain2(chainFilePath);
+  if (existingChain) {
+    const summary = getChainSummary(existingChain);
+    logger.debug(`Existing chain: ${summary.blockCount} block(s), ${summary.schemaCount} schema(s)`);
+    logger.step("Verifying chain integrity...");
+    const verification = await verifyChain(existingChain, schemasDir);
+    if (!verification.valid) {
+      logger.error("Chain integrity verification failed!");
+      if (verification.corruptedBlocks.length > 0) {
+        logger.error("");
+        logger.error("Corrupted blocks:");
+        for (const block of verification.corruptedBlocks) {
+          logger.error(`  \u2022 ${block.version}: ${block.reason}`);
+        }
+      }
+      if (verification.tamperedSchemas.length > 0) {
+        logger.error("");
+        logger.error("Tampered schemas (modified since lock):");
+        for (const schema of verification.tamperedSchemas) {
+          logger.error(`  \u2022 ${schema.schemaName} (locked in ${schema.lockedInVersion})`);
+        }
+      }
+      if (verification.deletedLockedSchemas.length > 0) {
+        logger.error("");
+        logger.error("Deleted locked schemas:");
+        for (const schema of verification.deletedLockedSchemas) {
+          logger.error(`  \u2022 ${schema.schemaName} (locked in ${schema.lockedInVersion})`);
+        }
+      }
+      throw new OmnifyError5(
+        "Cannot deploy: chain integrity compromised",
+        "E406",
+        void 0,
+        "Restore deleted/modified files to match the locked state, or contact support."
+      );
+    }
+    logger.success("Chain integrity verified \u2713");
+  } else {
+    logger.info("Creating new version chain (first deployment)");
+  }
+  const environment = options.environment ?? "production";
+  const version = options.version ?? generateVersionFromTimestamp();
+  if (options.dryRun) {
+    logger.newline();
+    logger.info("DRY RUN - No changes will be made");
+    logger.info("");
+    logger.info(`Would create block:`);
+    logger.info(`  Version:     ${version}`);
+    logger.info(`  Environment: ${environment}`);
+    logger.info(`  Schemas:     ${schemaFiles.length} file(s)`);
+    logger.info("");
+    for (const file of schemaFiles) {
+      logger.info(`    \u2022 ${file.name} (${file.relativePath})`);
+    }
+    return;
+  }
+  if (!options.yes) {
+    const confirmed = await confirmDeploy(schemaFiles.length, environment, version);
+    if (!confirmed) {
+      logger.newline();
+      logger.info("Deployment cancelled.");
+      return;
+    }
+  }
+  logger.step("Creating version lock...");
+  const deployOptions = {
+    version,
+    environment,
+    deployedBy: options.deployedBy ?? process.env.USER ?? "unknown",
+    comment: options.comment,
+    skipConfirmation: true
+  };
+  const result = await deployVersion(chainFilePath, schemasDir, schemaFiles, deployOptions);
+  if (!result.success) {
+    throw new OmnifyError5(
+      result.error ?? "Deployment failed",
+      "E408"
+    );
+  }
+  logger.newline();
+  logger.success("\u{1F512} Version locked successfully!");
+  logger.newline();
+  if (result.block) {
+    logger.info(`  Version:     ${result.block.version}`);
+    logger.info(`  Block Hash:  ${result.block.blockHash.substring(0, 16)}...`);
+    logger.info(`  Locked At:   ${result.block.lockedAt}`);
+    logger.info(`  Environment: ${result.block.environment}`);
+    logger.info(`  Schemas:     ${result.block.schemas.length} file(s)`);
+  }
+  if (result.addedSchemas.length > 0) {
+    logger.newline();
+    logger.info("  New schemas locked:");
+    for (const name of result.addedSchemas) {
+      logger.info(`    + ${name}`);
+    }
+  }
+  if (result.warnings.length > 0) {
+    logger.newline();
+    logger.warn("  Warnings:");
+    for (const warning of result.warnings) {
+      logger.warn(`    \u26A0 ${warning}`);
+    }
+  }
+  logger.newline();
+  logger.info(`  Chain file: ${VERSION_CHAIN_FILE2}`);
+  logger.info("  This file should be committed to version control.");
+}
+function generateVersionFromTimestamp() {
+  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}`;
+}
+function registerDeployCommand(program2) {
+  program2.command("deploy").description("Lock schema version for production (blockchain-like immutable record)").option("-v, --verbose", "Show detailed output").option("--version <version>", "Version name (e.g., v1.0.0, default: auto-generated)").option("-e, --environment <env>", "Deployment environment (default: production)", "production").option("-c, --comment <comment>", "Deployment comment").option("-y, --yes", "Skip confirmation prompt (for CI/CD)").option("--deployed-by <name>", "Deployer name (default: $USER)").option("--dry-run", "Show what would be locked without making changes").action(async (options) => {
+    try {
+      await runDeploy(options);
+    } catch (error) {
+      if (error instanceof OmnifyError5) {
+        logger.formatError(error);
+        process.exit(logger.getExitCode(error));
+      } else if (error instanceof Error) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/verify.ts
+import { existsSync as existsSync9 } from "fs";
+import { resolve as resolve11, dirname as dirname8 } from "path";
+import { OmnifyError as OmnifyError6 } from "@famgia/omnify-core";
+import {
+  VERSION_CHAIN_FILE as VERSION_CHAIN_FILE3,
+  readVersionChain as readVersionChain3,
+  verifyChain as verifyChain2,
+  getChainSummary as getChainSummary2,
+  getLockedSchemas
+} from "@famgia/omnify-atlas";
+async function runVerify(options) {
+  logger.setVerbose(options.verbose ?? false);
+  if (!options.json) {
+    logger.header("Verify Version Chain");
+  }
+  logger.debug("Loading configuration...");
+  const { config, configPath: configPath2 } = await loadConfig();
+  const rootDir = configPath2 ? dirname8(configPath2) : process.cwd();
+  validateConfig(config, rootDir);
+  const schemasDir = resolve11(rootDir, config.schemasDir);
+  const chainFilePath = resolve11(rootDir, VERSION_CHAIN_FILE3);
+  if (!existsSync9(chainFilePath)) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        valid: true,
+        message: "No version chain exists yet",
+        blockCount: 0,
+        schemaCount: 0
+      }, null, 2));
+      return;
+    }
+    logger.info("No version chain exists yet.");
+    logger.info('Run "npx omnify deploy" to create the first version lock.');
+    return;
+  }
+  const chain = await readVersionChain3(chainFilePath);
+  if (!chain) {
+    throw new OmnifyError6(
+      "Failed to read version chain file",
+      "E406",
+      void 0,
+      `Check if ${VERSION_CHAIN_FILE3} is valid JSON.`
+    );
+  }
+  const summary = getChainSummary2(chain);
+  if (!options.json) {
+    logger.step("Chain Summary");
+    logger.info(`  Blocks:       ${summary.blockCount}`);
+    logger.info(`  Schemas:      ${summary.schemaCount}`);
+    logger.info(`  First Lock:   ${summary.firstVersion ?? "N/A"}`);
+    logger.info(`  Latest Lock:  ${summary.latestVersion ?? "N/A"}`);
+    logger.info(`  Environments: ${summary.environments.join(", ") || "N/A"}`);
+    logger.newline();
+  }
+  if (!options.json) {
+    logger.step("Verifying chain integrity...");
+  }
+  const verification = await verifyChain2(chain, schemasDir);
+  if (options.json) {
+    console.log(JSON.stringify({
+      valid: verification.valid,
+      blockCount: verification.blockCount,
+      verifiedBlocks: verification.verifiedBlocks,
+      corruptedBlocks: verification.corruptedBlocks,
+      tamperedSchemas: verification.tamperedSchemas,
+      deletedLockedSchemas: verification.deletedLockedSchemas,
+      summary
+    }, null, 2));
+    if (!verification.valid) {
+      process.exit(1);
+    }
+    return;
+  }
+  if (verification.valid) {
+    logger.success("\u2713 Chain integrity verified");
+    logger.success(`\u2713 All ${verification.blockCount} block(s) valid`);
+    logger.success("\u2713 No tampered or deleted locked schemas");
+    logger.newline();
+    if (options.showAll) {
+      const lockedSchemas = getLockedSchemas(chain);
+      logger.step("Locked Schemas");
+      for (const [name, info] of lockedSchemas) {
+        logger.info(`  \u2022 ${name}`);
+        logger.debug(`    Path:    ${info.relativePath}`);
+        logger.debug(`    Hash:    ${info.hash.substring(0, 16)}...`);
+        logger.debug(`    Version: ${info.version}`);
+      }
+    }
+  } else {
+    logger.error("\u2717 Chain integrity verification FAILED");
+    logger.newline();
+    let exitCode = 0;
+    if (verification.corruptedBlocks.length > 0) {
+      logger.error("Corrupted Blocks:");
+      for (const block of verification.corruptedBlocks) {
+        logger.error(`  \u2717 ${block.version}`);
+        logger.error(`    Reason: ${block.reason}`);
+        logger.error(`    Expected: ${block.expectedHash.substring(0, 16)}...`);
+        logger.error(`    Actual:   ${block.actualHash.substring(0, 16)}...`);
+      }
+      logger.newline();
+      exitCode = 1;
+    }
+    if (verification.tamperedSchemas.length > 0) {
+      logger.error("Tampered Schemas (modified since lock):");
+      for (const schema of verification.tamperedSchemas) {
+        logger.error(`  \u2717 ${schema.schemaName}`);
+        logger.error(`    File:      ${schema.filePath}`);
+        logger.error(`    Locked in: ${schema.lockedInVersion}`);
+        logger.error(`    Locked:    ${schema.lockedHash.substring(0, 16)}...`);
+        logger.error(`    Current:   ${schema.currentHash.substring(0, 16)}...`);
+      }
+      logger.newline();
+      exitCode = 1;
+    }
+    if (verification.deletedLockedSchemas.length > 0) {
+      logger.error("Deleted Locked Schemas:");
+      for (const schema of verification.deletedLockedSchemas) {
+        logger.error(`  \u2717 ${schema.schemaName}`);
+        logger.error(`    File:      ${schema.filePath}`);
+        logger.error(`    Locked in: ${schema.lockedInVersion}`);
+        logger.error(`    Hash:      ${schema.lockedHash.substring(0, 16)}...`);
+      }
+      logger.newline();
+      exitCode = 1;
+    }
+    logger.newline();
+    logger.warn("How to fix:");
+    logger.warn("  1. Restore deleted files from git or backup");
+    logger.warn("  2. Revert modified files to their locked state");
+    logger.warn("  3. Do NOT modify the .omnify.chain file");
+    logger.newline();
+    process.exit(exitCode);
+  }
+}
+function registerVerifyCommand(program2) {
+  program2.command("verify").description("Verify version chain integrity and schema states").option("-v, --verbose", "Show detailed output").option("-a, --show-all", "Show all locked schemas").option("--json", "Output result as JSON").action(async (options) => {
+    try {
+      await runVerify(options);
+    } catch (error) {
+      if (error instanceof OmnifyError6) {
+        if (options.json) {
+          console.log(JSON.stringify({
+            valid: false,
+            error: error.message
+          }, null, 2));
+        } else {
+          logger.formatError(error);
+        }
+        process.exit(logger.getExitCode(error));
+      } else if (error instanceof Error) {
+        if (options.json) {
+          console.log(JSON.stringify({
+            valid: false,
+            error: error.message
+          }, null, 2));
+        } else {
+          logger.error(error.message);
+        }
+        process.exit(1);
+      }
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli.ts
 var VERSION = "0.0.5";
 var program = new Command();
@@ -2257,8 +2674,10 @@ registerDiffCommand(program);
 registerGenerateCommand(program);
 registerResetCommand(program);
 registerCreateProjectCommand(program);
+registerDeployCommand(program);
+registerVerifyCommand(program);
 process.on("uncaughtException", (error) => {
-  if (error instanceof OmnifyError5) {
+  if (error instanceof OmnifyError7) {
     logger.formatError(error);
     process.exit(logger.getExitCode(error));
   } else {
@@ -2267,7 +2686,7 @@ process.on("uncaughtException", (error) => {
   }
 });
 process.on("unhandledRejection", (reason) => {
-  if (reason instanceof OmnifyError5) {
+  if (reason instanceof OmnifyError7) {
     logger.formatError(reason);
     process.exit(logger.getExitCode(reason));
   } else if (reason instanceof Error) {
@@ -2280,8 +2699,8 @@ process.on("unhandledRejection", (reason) => {
 var args = process.argv.slice(2);
 var firstArg = args[0];
 var hasCommand = firstArg !== void 0 && !firstArg.startsWith("-");
-var configPath = resolve10(process.cwd(), "omnify.config.ts");
-var hasConfig = existsSync8(configPath);
+var configPath = resolve12(process.cwd(), "omnify.config.ts");
+var hasConfig = existsSync10(configPath);
 if (!hasCommand && !hasConfig) {
   runInit({}).catch((error) => {
     if (error instanceof Error) {