@famgia/omnify-atlas 0.0.98 → 0.0.99

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   LOCK_FILE_NAME: () => LOCK_FILE_NAME,
   LOCK_FILE_VERSION: () => LOCK_FILE_VERSION,
+  addEnhancedMigrationRecord: () => addEnhancedMigrationRecord,
   addMigrationRecord: () => addMigrationRecord,
   applySchema: () => applySchema,
   buildSchemaHashes: () => buildSchemaHashes,
@@ -33,11 +44,15 @@ __export(index_exports, {
   computeSchemaHash: () => computeSchemaHash,
   createEmptyLockFile: () => createEmptyLockFile,
   diffHclSchemas: () => diffHclSchemas,
+  extractTableNameFromFilename: () => extractTableNameFromFilename,
+  extractTimestampFromFilename: () => extractTimestampFromFilename,
+  findMigrationByTable: () => findMigrationByTable,
   formatDiffSummary: () => formatDiffSummary,
   formatPreview: () => formatPreview,
   generateHclSchema: () => generateHclSchema,
   generateHclTable: () => generateHclTable,
   generatePreview: () => generatePreview,
+  getMigrationsToRegenerate: () => getMigrationsToRegenerate,
   getPrimaryKeyType: () => getPrimaryKeyType,
   getTimestampType: () => getTimestampType,
   hasBlockingIssues: () => hasBlockingIssues,
@@ -55,6 +70,7 @@ __export(index_exports, {
   updateLockFile: () => updateLockFile,
   updateLockFileV1: () => updateLockFileV1,
   validateHcl: () => validateHcl,
+  validateMigrations: () => validateMigrations,
   writeLockFile: () => writeLockFile
 });
 module.exports = __toCommonJS(index_exports);
@@ -492,6 +508,125 @@ function addMigrationRecord(lockFile, fileName, schemas, migrationContent) {
     migrations: [...lockFile.migrations, record]
   };
 }
+function addEnhancedMigrationRecord(lockFile, options) {
+  const record = {
+    fileName: options.fileName,
+    timestamp: options.timestamp,
+    tableName: options.tableName,
+    type: options.type,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    schemas: options.schemas,
+    checksum: computeHash(options.content)
+  };
+  return {
+    ...lockFile,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    migrations: [...lockFile.migrations, record]
+  };
+}
+function extractTimestampFromFilename(fileName) {
+  const match = fileName.match(/^(\d{4}_\d{2}_\d{2}_\d{6})_/);
+  return match ? match[1] : null;
+}
+function extractTableNameFromFilename(fileName) {
+  const createMatch = fileName.match(/_create_(.+)_table\.php$/);
+  if (createMatch) return createMatch[1];
+  const updateMatch = fileName.match(/_update_(.+)_table\.php$/);
+  if (updateMatch) return updateMatch[1];
+  const dropMatch = fileName.match(/_drop_(.+)_table\.php$/);
+  if (dropMatch) return dropMatch[1];
+  return null;
+}
+async function validateMigrations(lockFile, migrationsDir) {
+  const missingFiles = [];
+  const modifiedFiles = [];
+  const staleFiles = [];
+  let filesOnDisk = [];
+  try {
+    const { readdirSync } = await import("fs");
+    filesOnDisk = readdirSync(migrationsDir).filter((f) => f.endsWith(".php"));
+  } catch {
+  }
+  const filesOnDiskSet = new Set(filesOnDisk);
+  for (const migration of lockFile.migrations) {
+    const fileName = migration.fileName;
+    if (!filesOnDiskSet.has(fileName)) {
+      missingFiles.push(fileName);
+      continue;
+    }
+    if (migration.checksum) {
+      try {
+        const { readFileSync } = await import("fs");
+        const { join: join3 } = await import("path");
+        const content = readFileSync(join3(migrationsDir, fileName), "utf8");
+        const currentChecksum = computeHash(content);
+        if (currentChecksum !== migration.checksum) {
+          modifiedFiles.push(fileName);
+        }
+      } catch {
+      }
+    }
+  }
+  const trackedFileNames = new Set(lockFile.migrations.map((m) => m.fileName));
+  const now = /* @__PURE__ */ new Date();
+  for (const fileName of filesOnDisk) {
+    if (!trackedFileNames.has(fileName)) {
+      const timestamp = extractTimestampFromFilename(fileName);
+      if (timestamp) {
+        const [year, month, day] = timestamp.split("_").slice(0, 3).map(Number);
+        const fileDate = new Date(year, month - 1, day);
+        const daysDiff = (now.getTime() - fileDate.getTime()) / (1e3 * 60 * 60 * 24);
+        if (daysDiff > 7) {
+          staleFiles.push(fileName);
+        }
+      }
+    }
+  }
+  return {
+    valid: missingFiles.length === 0 && modifiedFiles.length === 0,
+    missingFiles,
+    modifiedFiles,
+    staleFiles,
+    totalTracked: lockFile.migrations.length,
+    totalOnDisk: filesOnDisk.length
+  };
+}
+function findMigrationByTable(lockFile, tableName, type) {
+  return lockFile.migrations.find((m) => {
+    const mig = m;
+    if (mig.tableName) {
+      return mig.tableName === tableName && (!type || mig.type === type);
+    }
+    const extractedTable = extractTableNameFromFilename(m.fileName);
+    return extractedTable === tableName;
+  });
+}
+function getMigrationsToRegenerate(lockFile, missingFiles) {
+  const missingSet = new Set(missingFiles);
+  const result = [];
+  for (const migration of lockFile.migrations) {
+    if (!missingSet.has(migration.fileName)) continue;
+    const mig = migration;
+    const timestamp = mig.timestamp ?? extractTimestampFromFilename(migration.fileName);
+    if (!timestamp) continue;
+    const tableName = mig.tableName ?? extractTableNameFromFilename(migration.fileName);
+    if (!tableName) continue;
+    let type = mig.type ?? "create";
+    if (!mig.type) {
+      if (migration.fileName.includes("_create_")) type = "create";
+      else if (migration.fileName.includes("_update_")) type = "alter";
+      else if (migration.fileName.includes("_drop_")) type = "drop";
+    }
+    result.push({
+      fileName: migration.fileName,
+      timestamp,
+      tableName,
+      type,
+      schemas: migration.schemas
+    });
+  }
+  return result;
+}
 
 // src/hcl/type-mapper.ts
 var MYSQL_TYPES = {
@@ -1653,6 +1788,7 @@ function hasBlockingIssues(_preview) {
 0 && (module.exports = {
   LOCK_FILE_NAME,
   LOCK_FILE_VERSION,
+  addEnhancedMigrationRecord,
   addMigrationRecord,
   applySchema,
   buildSchemaHashes,
@@ -1664,11 +1800,15 @@ function hasBlockingIssues(_preview) {
   computeSchemaHash,
   createEmptyLockFile,
   diffHclSchemas,
+  extractTableNameFromFilename,
+  extractTimestampFromFilename,
+  findMigrationByTable,
   formatDiffSummary,
   formatPreview,
   generateHclSchema,
   generateHclTable,
   generatePreview,
+  getMigrationsToRegenerate,
   getPrimaryKeyType,
   getTimestampType,
   hasBlockingIssues,
@@ -1686,6 +1826,7 @@ function hasBlockingIssues(_preview) {
   updateLockFile,
   updateLockFileV1,
   validateHcl,
+  validateMigrations,
   writeLockFile
 });
 //# sourceMappingURL=index.cjs.map