@famgia/omnify-atlas 0.0.1

package/dist/index.js

@@ -0,0 +1,1333 @@
+// src/lock/lock-file.ts
+import { createHash } from "crypto";
+import { readFile, writeFile, stat } from "fs/promises";
+var LOCK_FILE_NAME = ".omnify.lock";
+var LOCK_FILE_VERSION = 1;
+function computeHash(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function computeSchemaHash(schema) {
+  const content = JSON.stringify({
+    name: schema.name,
+    kind: schema.kind ?? "object",
+    properties: schema.properties ?? {},
+    options: schema.options ?? {},
+    values: schema.values ?? []
+  });
+  return computeHash(content);
+}
+function createEmptyLockFile(driver) {
+  return {
+    version: LOCK_FILE_VERSION,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    driver,
+    schemas: {},
+    migrations: []
+  };
+}
+async function readLockFile(lockFilePath) {
+  try {
+    const content = await readFile(lockFilePath, "utf8");
+    const parsed = JSON.parse(content);
+    if (parsed.version !== LOCK_FILE_VERSION) {
+      throw new Error(
+        `Lock file version mismatch: expected ${LOCK_FILE_VERSION}, got ${parsed.version}`
+      );
+    }
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeLockFile(lockFilePath, lockFile) {
+  const content = JSON.stringify(lockFile, null, 2) + "\n";
+  await writeFile(lockFilePath, content, "utf8");
+}
+async function buildSchemaHashes(schemas) {
+  const hashes = {};
+  for (const [name, schema] of Object.entries(schemas)) {
+    const hash = computeSchemaHash(schema);
+    let modifiedAt;
+    try {
+      const stats = await stat(schema.filePath);
+      modifiedAt = stats.mtime.toISOString();
+    } catch {
+      modifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    hashes[name] = {
+      name,
+      hash,
+      relativePath: schema.relativePath,
+      modifiedAt
+    };
+  }
+  return hashes;
+}
+function compareSchemas(currentHashes, lockFile) {
+  const changes = [];
+  const unchanged = [];
+  const previousHashes = lockFile?.schemas ?? {};
+  const previousNames = new Set(Object.keys(previousHashes));
+  const currentNames = new Set(Object.keys(currentHashes));
+  for (const name of currentNames) {
+    if (!previousNames.has(name)) {
+      const current = currentHashes[name];
+      if (current) {
+        changes.push({
+          schemaName: name,
+          changeType: "added",
+          currentHash: current.hash
+        });
+      }
+    }
+  }
+  for (const name of previousNames) {
+    if (!currentNames.has(name)) {
+      const previous = previousHashes[name];
+      if (previous) {
+        changes.push({
+          schemaName: name,
+          changeType: "removed",
+          previousHash: previous.hash
+        });
+      }
+    }
+  }
+  for (const name of currentNames) {
+    if (previousNames.has(name)) {
+      const current = currentHashes[name];
+      const previous = previousHashes[name];
+      if (current && previous) {
+        if (current.hash !== previous.hash) {
+          changes.push({
+            schemaName: name,
+            changeType: "modified",
+            previousHash: previous.hash,
+            currentHash: current.hash
+          });
+        } else {
+          unchanged.push(name);
+        }
+      }
+    }
+  }
+  return {
+    hasChanges: changes.length > 0,
+    changes,
+    unchanged
+  };
+}
+function updateLockFile(existingLockFile, currentHashes, driver) {
+  return {
+    version: LOCK_FILE_VERSION,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    driver,
+    schemas: currentHashes,
+    migrations: existingLockFile?.migrations ?? [],
+    hclChecksum: existingLockFile?.hclChecksum
+  };
+}
+function addMigrationRecord(lockFile, fileName, schemas, migrationContent) {
+  const record = {
+    fileName,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    schemas,
+    checksum: computeHash(migrationContent)
+  };
+  return {
+    ...lockFile,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    migrations: [...lockFile.migrations, record]
+  };
+}
+
+// src/hcl/type-mapper.ts
+var MYSQL_TYPES = {
+  String: (prop) => ({
+    type: `varchar(${prop.length ?? 255})`,
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? `'${prop.default}'` : void 0
+  }),
+  Int: (prop) => ({
+    type: "int",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0,
+    unsigned: prop.unsigned ?? false
+  }),
+  BigInt: (prop) => ({
+    type: "bigint",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0,
+    unsigned: prop.unsigned ?? false
+  }),
+  Float: (prop) => ({
+    type: "double",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0
+  }),
+  Boolean: (prop) => ({
+    type: "tinyint(1)",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? prop.default ? "1" : "0" : void 0
+  }),
+  Text: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  LongText: (prop) => ({
+    type: "longtext",
+    nullable: prop.nullable ?? false
+  }),
+  Date: (prop) => ({
+    type: "date",
+    nullable: prop.nullable ?? false
+  }),
+  Time: (prop) => ({
+    type: "time",
+    nullable: prop.nullable ?? false
+  }),
+  Timestamp: (prop) => ({
+    type: "timestamp",
+    nullable: prop.nullable ?? false
+  }),
+  Json: (prop) => ({
+    type: "json",
+    nullable: prop.nullable ?? false
+  }),
+  Email: (prop) => ({
+    type: "varchar(255)",
+    nullable: prop.nullable ?? false
+  }),
+  Password: (prop) => ({
+    type: "varchar(255)",
+    nullable: prop.nullable ?? false
+  }),
+  File: (prop) => ({
+    type: "varchar(500)",
+    nullable: prop.nullable ?? false
+  }),
+  MultiFile: (prop) => ({
+    type: "json",
+    nullable: prop.nullable ?? false
+  }),
+  Enum: (prop) => {
+    const enumProp = prop;
+    const values = enumProp.enum ?? [];
+    const enumDef = values.map((v) => `'${v}'`).join(", ");
+    return {
+      type: `enum(${enumDef})`,
+      nullable: prop.nullable ?? false,
+      default: prop.default !== void 0 ? `'${prop.default}'` : void 0
+    };
+  },
+  Select: (prop) => ({
+    type: "varchar(100)",
+    nullable: prop.nullable ?? false
+  }),
+  Lookup: (prop) => ({
+    type: "bigint",
+    nullable: prop.nullable ?? false,
+    unsigned: true
+  })
+};
+var POSTGRES_TYPES = {
+  String: (prop) => ({
+    type: `varchar(${prop.length ?? 255})`,
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? `'${prop.default}'` : void 0
+  }),
+  Int: (prop) => ({
+    type: "integer",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0
+  }),
+  BigInt: (prop) => ({
+    type: "bigint",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0
+  }),
+  Float: (prop) => ({
+    type: "double precision",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0
+  }),
+  Boolean: (prop) => ({
+    type: "boolean",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0
+  }),
+  Text: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  LongText: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  Date: (prop) => ({
+    type: "date",
+    nullable: prop.nullable ?? false
+  }),
+  Time: (prop) => ({
+    type: "time",
+    nullable: prop.nullable ?? false
+  }),
+  Timestamp: (prop) => ({
+    type: "timestamp",
+    nullable: prop.nullable ?? false
+  }),
+  Json: (prop) => ({
+    type: "jsonb",
+    nullable: prop.nullable ?? false
+  }),
+  Email: (prop) => ({
+    type: "varchar(255)",
+    nullable: prop.nullable ?? false
+  }),
+  Password: (prop) => ({
+    type: "varchar(255)",
+    nullable: prop.nullable ?? false
+  }),
+  File: (prop) => ({
+    type: "varchar(500)",
+    nullable: prop.nullable ?? false
+  }),
+  MultiFile: (prop) => ({
+    type: "jsonb",
+    nullable: prop.nullable ?? false
+  }),
+  // For PostgreSQL, enums are separate types
+  Enum: (prop) => ({
+    type: "varchar(100)",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? `'${prop.default}'` : void 0
+  }),
+  Select: (prop) => ({
+    type: "varchar(100)",
+    nullable: prop.nullable ?? false
+  }),
+  Lookup: (prop) => ({
+    type: "bigint",
+    nullable: prop.nullable ?? false
+  })
+};
+var SQLITE_TYPES = {
+  String: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? `'${prop.default}'` : void 0
+  }),
+  Int: (prop) => ({
+    type: "integer",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0
+  }),
+  BigInt: (prop) => ({
+    type: "integer",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0
+  }),
+  Float: (prop) => ({
+    type: "real",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? String(prop.default) : void 0
+  }),
+  Boolean: (prop) => ({
+    type: "integer",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? prop.default ? "1" : "0" : void 0
+  }),
+  Text: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  LongText: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  Date: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  Time: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  Timestamp: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  Json: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  Email: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  Password: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  File: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  MultiFile: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  Enum: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false,
+    default: prop.default !== void 0 ? `'${prop.default}'` : void 0
+  }),
+  Select: (prop) => ({
+    type: "text",
+    nullable: prop.nullable ?? false
+  }),
+  Lookup: (prop) => ({
+    type: "integer",
+    nullable: prop.nullable ?? false
+  })
+};
+var DRIVER_TYPE_MAPS = {
+  mysql: MYSQL_TYPES,
+  postgres: POSTGRES_TYPES,
+  pgsql: POSTGRES_TYPES,
+  // Alias for postgres
+  sqlite: SQLITE_TYPES,
+  mariadb: MYSQL_TYPES,
+  // MariaDB uses same types as MySQL
+  sqlsrv: MYSQL_TYPES
+  // SQL Server uses similar types to MySQL for now
+};
+function mapPropertyToSql(property, driver) {
+  const typeMap = DRIVER_TYPE_MAPS[driver];
+  const mapper = typeMap[property.type];
+  const baseProp = property;
+  if (mapper) {
+    return mapper(baseProp);
+  }
+  return {
+    type: "varchar(255)",
+    nullable: baseProp.nullable ?? false
+  };
+}
+function getPrimaryKeyType(pkType, driver) {
+  switch (pkType) {
+    case "Int":
+      return {
+        type: driver === "postgres" ? "serial" : "int",
+        nullable: false,
+        autoIncrement: driver !== "postgres",
+        unsigned: driver === "mysql" || driver === "mariadb"
+      };
+    case "BigInt":
+      return {
+        type: driver === "postgres" ? "bigserial" : "bigint",
+        nullable: false,
+        autoIncrement: driver !== "postgres",
+        unsigned: driver === "mysql" || driver === "mariadb"
+      };
+    case "Uuid":
+      return {
+        type: driver === "postgres" ? "uuid" : "char(36)",
+        nullable: false
+      };
+    case "String":
+      return {
+        type: "varchar(255)",
+        nullable: false
+      };
+    default:
+      return {
+        type: driver === "postgres" ? "bigserial" : "bigint",
+        nullable: false,
+        autoIncrement: driver !== "postgres",
+        unsigned: driver === "mysql" || driver === "mariadb"
+      };
+  }
+}
+function getTimestampType(driver) {
+  return {
+    type: driver === "postgres" ? "timestamp" : "timestamp",
+    nullable: true
+  };
+}
+function schemaNameToTableName(schemaName) {
+  const snakeCase = schemaName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+  if (snakeCase.endsWith("y")) {
+    return snakeCase.slice(0, -1) + "ies";
+  } else if (snakeCase.endsWith("s") || snakeCase.endsWith("x") || snakeCase.endsWith("ch") || snakeCase.endsWith("sh")) {
+    return snakeCase + "es";
+  } else {
+    return snakeCase + "s";
+  }
+}
+function propertyNameToColumnName(propertyName) {
+  return propertyName.replace(/([A-Z])/g, "_$1").toLowerCase();
+}
+
+// src/hcl/generator.ts
+function generateHclTable(schema, allSchemas, driver) {
+  const tableName = schemaNameToTableName(schema.name);
+  const columns = [];
+  const indexes = [];
+  const foreignKeys = [];
+  const pkType = schema.options?.primaryKeyType ?? "BigInt";
+  columns.push({
+    name: "id",
+    type: getPrimaryKeyType(pkType, driver),
+    primaryKey: true
+  });
+  if (schema.properties) {
+    for (const [propName, property] of Object.entries(schema.properties)) {
+      if (property.type === "Association") {
+        const assocProp = property;
+        if (assocProp.relation === "ManyToOne" || assocProp.relation === "OneToOne") {
+          const columnName2 = propertyNameToColumnName(propName) + "_id";
+          const targetSchema = assocProp.target ? allSchemas[assocProp.target] : void 0;
+          const targetTable = assocProp.target ? schemaNameToTableName(assocProp.target) : "unknown";
+          const targetPkType = targetSchema?.options?.primaryKeyType ?? "BigInt";
+          const fkType = getPrimaryKeyType(
+            targetPkType,
+            driver
+          );
+          const isNullable = assocProp.relation === "ManyToOne";
+          columns.push({
+            name: columnName2,
+            type: {
+              ...fkType,
+              nullable: isNullable,
+              autoIncrement: false
+            }
+          });
+          foreignKeys.push({
+            name: `fk_${tableName}_${columnName2}`,
+            columns: [columnName2],
+            refTable: targetTable,
+            refColumns: ["id"],
+            onDelete: assocProp.onDelete ?? "RESTRICT",
+            onUpdate: assocProp.onUpdate ?? "CASCADE"
+          });
+          indexes.push({
+            name: `idx_${tableName}_${columnName2}`,
+            columns: [columnName2]
+          });
+        }
+        continue;
+      }
+      const baseProp = property;
+      const columnName = propertyNameToColumnName(propName);
+      const sqlType = mapPropertyToSql(property, driver);
+      columns.push({
+        name: columnName,
+        type: sqlType,
+        unique: baseProp.unique ?? false
+      });
+      if (baseProp.unique) {
+        indexes.push({
+          name: `idx_${tableName}_${columnName}_unique`,
+          columns: [columnName],
+          unique: true
+        });
+      }
+    }
+  }
+  if (schema.options?.timestamps !== false) {
+    const timestampType = getTimestampType(driver);
+    columns.push(
+      { name: "created_at", type: timestampType },
+      { name: "updated_at", type: timestampType }
+    );
+  }
+  if (schema.options?.softDelete) {
+    columns.push({
+      name: "deleted_at",
+      type: getTimestampType(driver)
+    });
+  }
+  if (schema.options?.indexes) {
+    for (const index of schema.options.indexes) {
+      const indexColumns = index.columns.map(propertyNameToColumnName);
+      indexes.push({
+        name: index.name ?? `idx_${tableName}_${indexColumns.join("_")}`,
+        columns: indexColumns,
+        unique: index.unique ?? false
+      });
+    }
+  }
+  if (schema.options?.unique) {
+    const uniqueConstraints = Array.isArray(schema.options.unique[0]) ? schema.options.unique : [schema.options.unique];
+    for (const constraint of uniqueConstraints) {
+      const constraintColumns = constraint.map(propertyNameToColumnName);
+      indexes.push({
+        name: `idx_${tableName}_${constraintColumns.join("_")}_unique`,
+        columns: constraintColumns,
+        unique: true
+      });
+    }
+  }
+  return {
+    name: tableName,
+    columns,
+    indexes,
+    foreignKeys
+  };
+}
+function generateHclSchema(schemas, options) {
+  const tables = [];
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") {
+      continue;
+    }
+    const table = generateHclTable(schema, schemas, options.driver);
+    tables.push(table);
+  }
+  const enums = Object.values(schemas).filter((s) => s.kind === "enum").map((s) => ({
+    name: s.name.toLowerCase(),
+    values: s.values ?? []
+  }));
+  return {
+    driver: options.driver,
+    schemaName: options.schemaName,
+    tables,
+    enums
+  };
+}
+function formatHclColumn(column, driver) {
+  const parts = [`  column "${column.name}" {`];
+  parts.push(`    type = ${formatSqlType(column.type.type, driver)}`);
+  if (column.type.nullable) {
+    parts.push("    null = true");
+  }
+  if (column.type.default !== void 0) {
+    parts.push(`    default = ${column.type.default}`);
+  }
+  if (column.type.autoIncrement) {
+    parts.push("    auto_increment = true");
+  }
+  if (column.type.unsigned && (driver === "mysql" || driver === "mariadb")) {
+    parts.push("    unsigned = true");
+  }
+  parts.push("  }");
+  return parts.join("\n");
+}
+function formatSqlType(type, driver) {
+  if (type.startsWith("enum(")) {
+    if (driver === "mysql" || driver === "mariadb") {
+      return type;
+    }
+    return "varchar(100)";
+  }
+  return type;
+}
+function formatHclIndex(index) {
+  const columns = index.columns.map((c) => `"${c}"`).join(", ");
+  const unique = index.unique ? "unique = true\n    " : "";
+  return `  index "${index.name}" {
+    columns = [${columns}]
+    ${unique}}`;
+}
+function formatHclForeignKey(fk) {
+  const columns = fk.columns.map((c) => `"${c}"`).join(", ");
+  const refColumns = fk.refColumns.map((c) => `"${c}"`).join(", ");
+  return `  foreign_key "${fk.name}" {
+    columns     = [${columns}]
+    ref_columns = [${refColumns}]
+    on_update   = ${fk.onUpdate ?? "CASCADE"}
+    on_delete   = ${fk.onDelete ?? "RESTRICT"}
+  }`;
+}
+function renderHcl(schema) {
+  const lines = [];
+  const schemaPrefix = schema.schemaName ? `schema "${schema.schemaName}" {
+}
+
+` : "";
+  lines.push(schemaPrefix);
+  for (const table of schema.tables) {
+    lines.push(`table "${table.name}" {`);
+    if (schema.schemaName) {
+      lines.push(`  schema = schema.${schema.schemaName}`);
+    }
+    for (const column of table.columns) {
+      lines.push(formatHclColumn(column, schema.driver));
+    }
+    const pkColumn = table.columns.find((c) => c.primaryKey);
+    if (pkColumn) {
+      lines.push(`  primary_key {
+    columns = ["${pkColumn.name}"]
+  }`);
+    }
+    for (const index of table.indexes) {
+      lines.push(formatHclIndex(index));
+    }
+    for (const fk of table.foreignKeys) {
+      lines.push(formatHclForeignKey(fk));
+    }
+    lines.push("}\n");
+  }
+  return lines.join("\n");
+}
+
+// src/atlas/runner.ts
+import { execa } from "execa";
+import { mkdir, writeFile as writeFile2, rm } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { randomUUID } from "crypto";
+import { atlasError, atlasNotFoundError } from "@famgia/omnify-core";
+var DEFAULT_CONFIG = {
+  binaryPath: "atlas",
+  timeout: 6e4
+  // 60 seconds
+};
+function getSchemaUrl(_driver, path) {
+  return `file://${path}`;
+}
+function normalizeDevUrl(devUrl, driver) {
+  if (devUrl === "docker") {
+    switch (driver) {
+      case "mysql":
+        return "docker://mysql/8/dev";
+      case "mariadb":
+        return "docker://mariadb/latest/dev";
+      case "postgres":
+        return "docker://postgres/15/dev";
+      default:
+        return devUrl;
+    }
+  }
+  return devUrl;
+}
+async function createTempDir() {
+  const tempPath = join(tmpdir(), `omnify-atlas-${randomUUID()}`);
+  await mkdir(tempPath, { recursive: true });
+  return tempPath;
+}
+async function executeAtlas(config, args) {
+  const binaryPath = config.binaryPath ?? DEFAULT_CONFIG.binaryPath;
+  const timeout = config.timeout ?? DEFAULT_CONFIG.timeout;
+  const startTime = Date.now();
+  try {
+    const result = config.workDir ? await execa(binaryPath, args, {
+      timeout,
+      reject: false,
+      cwd: config.workDir
+    }) : await execa(binaryPath, args, {
+      timeout,
+      reject: false
+    });
+    const stdout = typeof result.stdout === "string" ? result.stdout : "";
+    const stderr = typeof result.stderr === "string" ? result.stderr : "";
+    return {
+      success: result.exitCode === 0,
+      stdout,
+      stderr,
+      exitCode: result.exitCode ?? 0,
+      duration: Date.now() - startTime
+    };
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      throw atlasNotFoundError();
+    }
+    throw atlasError(`Failed to execute Atlas: ${err.message}`, err);
+  }
+}
+async function checkAtlasVersion(config = {}) {
+  const fullConfig = {
+    ...DEFAULT_CONFIG,
+    ...config,
+    driver: config.driver ?? "mysql",
+    devUrl: config.devUrl ?? ""
+  };
+  try {
+    const result = await executeAtlas(fullConfig, ["version"]);
+    if (result.success) {
+      const match = result.stdout.match(/v?(\d+\.\d+\.\d+)/);
+      return {
+        version: match?.[1] ?? result.stdout.trim(),
+        available: true
+      };
+    }
+    return {
+      version: "",
+      available: false
+    };
+  } catch {
+    return {
+      version: "",
+      available: false
+    };
+  }
+}
+async function runAtlasDiff(config, options) {
+  const devUrl = normalizeDevUrl(config.devUrl, config.driver);
+  const toUrl = getSchemaUrl(config.driver, options.toPath);
+  const args = [
+    "schema",
+    "diff",
+    "--dev-url",
+    devUrl,
+    "--to",
+    toUrl,
+    "--format",
+    '{{ sql . "  " }}'
+  ];
+  if (options.fromPath) {
+    const fromUrl = getSchemaUrl(config.driver, options.fromPath);
+    args.push("--from", fromUrl);
+  }
+  const result = await executeAtlas(config, args);
+  const sql = result.stdout.trim();
+  const hasChanges = sql.length > 0 && !sql.includes("-- No changes");
+  return {
+    ...result,
+    hasChanges,
+    sql: hasChanges ? sql : ""
+  };
+}
+async function diffHclSchemas(config, fromHcl, toHcl) {
+  const tempDir = await createTempDir();
+  try {
+    const toPath = join(tempDir, "to.hcl");
+    await writeFile2(toPath, toHcl, "utf8");
+    let fromPath;
+    if (fromHcl) {
+      fromPath = join(tempDir, "from.hcl");
+      await writeFile2(fromPath, fromHcl, "utf8");
+    }
+    return await runAtlasDiff(config, {
+      fromPath,
+      toPath
+    });
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+async function validateHcl(config, hclPath) {
+  const devUrl = normalizeDevUrl(config.devUrl, config.driver);
+  return executeAtlas(config, [
+    "schema",
+    "inspect",
+    "--dev-url",
+    devUrl,
+    "--url",
+    getSchemaUrl(config.driver, hclPath),
+    "--format",
+    "{{ sql . }}"
+  ]);
+}
+async function applySchema(config, hclPath) {
+  const devUrl = normalizeDevUrl(config.devUrl, config.driver);
+  return executeAtlas(config, [
+    "schema",
+    "apply",
+    "--dev-url",
+    devUrl,
+    "--to",
+    getSchemaUrl(config.driver, hclPath),
+    "--auto-approve"
+  ]);
+}
+
+// src/diff/parser.ts
+var PATTERNS = {
+  createTable: /^CREATE TABLE\s+[`"]?(\w+)[`"]?/i,
+  dropTable: /^DROP TABLE\s+(?:IF EXISTS\s+)?[`"]?(\w+)[`"]?/i,
+  alterTable: /^ALTER TABLE\s+[`"]?(\w+)[`"]?/i,
+  addColumn: /ADD\s+(?:COLUMN\s+)?[`"]?(\w+)[`"]?/i,
+  dropColumn: /DROP\s+(?:COLUMN\s+)?[`"]?(\w+)[`"]?/i,
+  modifyColumn: /MODIFY\s+(?:COLUMN\s+)?[`"]?(\w+)[`"]?/i,
+  changeColumn: /CHANGE\s+(?:COLUMN\s+)?[`"]?(\w+)[`"]?/i,
+  alterColumn: /ALTER\s+(?:COLUMN\s+)?[`"]?(\w+)[`"]?/i,
+  createIndex: /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+[`"]?(\w+)[`"]?\s+ON\s+[`"]?(\w+)[`"]?/i,
+  dropIndex: /^DROP\s+INDEX\s+[`"]?(\w+)[`"]?(?:\s+ON\s+[`"]?(\w+)[`"]?)?/i,
+  addConstraint: /ADD\s+CONSTRAINT\s+[`"]?(\w+)[`"]?/i,
+  dropConstraint: /DROP\s+CONSTRAINT\s+[`"]?(\w+)[`"]?/i,
+  addForeignKey: /ADD\s+(?:CONSTRAINT\s+[`"]?\w+[`"]?\s+)?FOREIGN KEY/i,
+  dropForeignKey: /DROP\s+FOREIGN KEY\s+[`"]?(\w+)[`"]?/i
+};
+function splitStatements(sql) {
+  const statements = [];
+  let current = "";
+  let inString = false;
+  let stringChar = "";
+  for (let i = 0; i < sql.length; i++) {
+    const char = sql[i];
+    if ((char === "'" || char === '"') && sql[i - 1] !== "\\") {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = false;
+      }
+    }
+    if (char === ";" && !inString) {
+      const stmt = current.trim();
+      if (stmt) {
+        statements.push(stmt);
+      }
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  const final = current.trim();
+  if (final) {
+    statements.push(final);
+  }
+  return statements;
+}
+function parseStatement(sql) {
+  const trimmedSql = sql.trim();
+  let match = trimmedSql.match(PATTERNS.createTable);
+  if (match && match[1]) {
+    return {
+      sql: trimmedSql,
+      type: "CREATE_TABLE",
+      tableName: match[1],
+      severity: "safe"
+    };
+  }
+  match = trimmedSql.match(PATTERNS.dropTable);
+  if (match && match[1]) {
+    return {
+      sql: trimmedSql,
+      type: "DROP_TABLE",
+      tableName: match[1],
+      severity: "destructive"
+    };
+  }
+  match = trimmedSql.match(PATTERNS.createIndex);
+  if (match && match[1] && match[2]) {
+    return {
+      sql: trimmedSql,
+      type: "CREATE_INDEX",
+      tableName: match[2],
+      indexName: match[1],
+      severity: "safe"
+    };
+  }
+  match = trimmedSql.match(PATTERNS.dropIndex);
+  if (match && match[1]) {
+    return {
+      sql: trimmedSql,
+      type: "DROP_INDEX",
+      tableName: match[2] ?? "",
+      indexName: match[1],
+      severity: "warning"
+    };
+  }
+  match = trimmedSql.match(PATTERNS.alterTable);
+  if (match && match[1]) {
+    const tableName = match[1];
+    const alterPart = trimmedSql.slice(match[0].length);
+    const addColMatch = alterPart.match(PATTERNS.addColumn);
+    if (addColMatch && addColMatch[1]) {
+      return {
+        sql: trimmedSql,
+        type: "ADD_COLUMN",
+        tableName,
+        columnName: addColMatch[1],
+        severity: "safe"
+      };
+    }
+    const dropColMatch = alterPart.match(PATTERNS.dropColumn);
+    if (dropColMatch && dropColMatch[1]) {
+      return {
+        sql: trimmedSql,
+        type: "DROP_COLUMN",
+        tableName,
+        columnName: dropColMatch[1],
+        severity: "destructive"
+      };
+    }
+    const modifyColMatch = alterPart.match(PATTERNS.modifyColumn) || alterPart.match(PATTERNS.changeColumn) || alterPart.match(PATTERNS.alterColumn);
+    if (modifyColMatch && modifyColMatch[1]) {
+      return {
+        sql: trimmedSql,
+        type: "MODIFY_COLUMN",
+        tableName,
+        columnName: modifyColMatch[1],
+        severity: "warning"
+      };
+    }
+    if (PATTERNS.addForeignKey.test(alterPart)) {
+      const constraintMatch = alterPart.match(PATTERNS.addConstraint);
+      const fkConstraintName = constraintMatch?.[1];
+      if (fkConstraintName) {
+        return {
+          sql: trimmedSql,
+          type: "ADD_FOREIGN_KEY",
+          tableName,
+          constraintName: fkConstraintName,
+          severity: "safe"
+        };
+      }
+      return {
+        sql: trimmedSql,
+        type: "ADD_FOREIGN_KEY",
+        tableName,
+        severity: "safe"
+      };
+    }
+    const dropFkMatch = alterPart.match(PATTERNS.dropForeignKey);
+    if (dropFkMatch && dropFkMatch[1]) {
+      return {
+        sql: trimmedSql,
+        type: "DROP_FOREIGN_KEY",
+        tableName,
+        constraintName: dropFkMatch[1],
+        severity: "warning"
+      };
+    }
+    const addConstraintMatch = alterPart.match(PATTERNS.addConstraint);
+    if (addConstraintMatch && addConstraintMatch[1]) {
+      return {
+        sql: trimmedSql,
+        type: "ADD_CONSTRAINT",
+        tableName,
+        constraintName: addConstraintMatch[1],
+        severity: "safe"
+      };
+    }
+    const dropConstraintMatch = alterPart.match(PATTERNS.dropConstraint);
+    if (dropConstraintMatch && dropConstraintMatch[1]) {
+      return {
+        sql: trimmedSql,
+        type: "DROP_CONSTRAINT",
+        tableName,
+        constraintName: dropConstraintMatch[1],
+        severity: "warning"
+      };
+    }
+    return {
+      sql: trimmedSql,
+      type: "ALTER_TABLE",
+      tableName,
+      severity: "warning"
+    };
+  }
+  return {
+    sql: trimmedSql,
+    type: "UNKNOWN",
+    tableName: "",
+    severity: "warning"
+  };
+}
+function createEmptyTableChange(tableName) {
+  return {
+    tableName,
+    isNew: false,
+    isDropped: false,
+    addedColumns: [],
+    droppedColumns: [],
+    modifiedColumns: [],
+    addedIndexes: [],
+    droppedIndexes: [],
+    addedForeignKeys: [],
+    droppedForeignKeys: []
+  };
+}
+function getOrCreateTable(tables, tableName) {
+  const existing = tables[tableName];
+  if (existing) {
+    return existing;
+  }
+  const newTable = createEmptyTableChange(tableName);
+  tables[tableName] = newTable;
+  return newTable;
+}
+function groupByTable(statements) {
+  const tables = {};
+  for (const stmt of statements) {
+    if (!stmt.tableName) continue;
+    const table = getOrCreateTable(tables, stmt.tableName);
+    switch (stmt.type) {
+      case "CREATE_TABLE":
+        tables[stmt.tableName] = { ...table, isNew: true };
+        break;
+      case "DROP_TABLE":
+        tables[stmt.tableName] = { ...table, isDropped: true };
+        break;
+      case "ADD_COLUMN":
+        if (stmt.columnName) {
+          tables[stmt.tableName] = {
+            ...table,
+            addedColumns: [...table.addedColumns, stmt.columnName]
+          };
+        }
+        break;
+      case "DROP_COLUMN":
+        if (stmt.columnName) {
+          tables[stmt.tableName] = {
+            ...table,
+            droppedColumns: [...table.droppedColumns, stmt.columnName]
+          };
+        }
+        break;
+      case "MODIFY_COLUMN":
+        if (stmt.columnName) {
+          tables[stmt.tableName] = {
+            ...table,
+            modifiedColumns: [...table.modifiedColumns, stmt.columnName]
+          };
+        }
+        break;
+      case "CREATE_INDEX":
+        if (stmt.indexName) {
+          tables[stmt.tableName] = {
+            ...table,
+            addedIndexes: [...table.addedIndexes, stmt.indexName]
+          };
+        }
+        break;
+      case "DROP_INDEX":
+        if (stmt.indexName) {
+          tables[stmt.tableName] = {
+            ...table,
+            droppedIndexes: [...table.droppedIndexes, stmt.indexName]
+          };
+        }
+        break;
+      case "ADD_FOREIGN_KEY":
+        tables[stmt.tableName] = {
+          ...table,
+          addedForeignKeys: [
+            ...table.addedForeignKeys,
+            stmt.constraintName ?? "unnamed"
+          ]
+        };
+        break;
+      case "DROP_FOREIGN_KEY":
+        if (stmt.constraintName) {
+          tables[stmt.tableName] = {
+            ...table,
+            droppedForeignKeys: [...table.droppedForeignKeys, stmt.constraintName]
+          };
+        }
+        break;
+    }
+  }
+  return tables;
+}
+function calculateSummary(statements) {
+  return {
+    totalStatements: statements.length,
+    tablesCreated: statements.filter((s) => s.type === "CREATE_TABLE").length,
+    tablesDropped: statements.filter((s) => s.type === "DROP_TABLE").length,
+    tablesAltered: statements.filter((s) => s.type === "ALTER_TABLE").length,
+    columnsAdded: statements.filter((s) => s.type === "ADD_COLUMN").length,
+    columnsDropped: statements.filter((s) => s.type === "DROP_COLUMN").length,
+    columnsModified: statements.filter((s) => s.type === "MODIFY_COLUMN").length,
+    indexesAdded: statements.filter((s) => s.type === "CREATE_INDEX").length,
+    indexesDropped: statements.filter((s) => s.type === "DROP_INDEX").length,
+    foreignKeysAdded: statements.filter((s) => s.type === "ADD_FOREIGN_KEY").length,
+    foreignKeysDropped: statements.filter((s) => s.type === "DROP_FOREIGN_KEY").length
+  };
+}
+function parseDiffOutput(sql) {
+  const trimmedSql = sql.trim();
+  if (!trimmedSql || trimmedSql === "-- No changes") {
+    return {
+      hasChanges: false,
+      hasDestructiveChanges: false,
+      statements: [],
+      tableChanges: {},
+      summary: {
+        totalStatements: 0,
+        tablesCreated: 0,
+        tablesDropped: 0,
+        tablesAltered: 0,
+        columnsAdded: 0,
+        columnsDropped: 0,
+        columnsModified: 0,
+        indexesAdded: 0,
+        indexesDropped: 0,
+        foreignKeysAdded: 0,
+        foreignKeysDropped: 0
+      },
+      rawSql: trimmedSql
+    };
+  }
+  const sqlWithoutComments = trimmedSql.split("\n").filter((line) => !line.trim().startsWith("--")).join("\n");
+  const rawStatements = splitStatements(sqlWithoutComments);
+  const statements = rawStatements.map(parseStatement);
+  const hasDestructiveChanges = statements.some(
+    (s) => s.severity === "destructive"
+  );
+  return {
+    hasChanges: statements.length > 0,
+    hasDestructiveChanges,
+    statements,
+    tableChanges: groupByTable(statements),
+    summary: calculateSummary(statements),
+    rawSql: trimmedSql
+  };
+}
+function formatDiffSummary(result) {
+  if (!result.hasChanges) {
+    return "No schema changes detected.";
+  }
+  const lines = ["Schema changes detected:"];
+  const { summary } = result;
+  if (summary.tablesCreated > 0) {
+    lines.push(`  + ${summary.tablesCreated} table(s) created`);
+  }
+  if (summary.tablesDropped > 0) {
+    lines.push(`  - ${summary.tablesDropped} table(s) dropped [DESTRUCTIVE]`);
+  }
+  if (summary.columnsAdded > 0) {
+    lines.push(`  + ${summary.columnsAdded} column(s) added`);
+  }
+  if (summary.columnsDropped > 0) {
+    lines.push(`  - ${summary.columnsDropped} column(s) dropped [DESTRUCTIVE]`);
+  }
+  if (summary.columnsModified > 0) {
+    lines.push(`  ~ ${summary.columnsModified} column(s) modified`);
+  }
+  if (summary.indexesAdded > 0) {
+    lines.push(`  + ${summary.indexesAdded} index(es) added`);
+  }
+  if (summary.indexesDropped > 0) {
+    lines.push(`  - ${summary.indexesDropped} index(es) dropped`);
+  }
+  if (summary.foreignKeysAdded > 0) {
+    lines.push(`  + ${summary.foreignKeysAdded} foreign key(s) added`);
+  }
+  if (summary.foreignKeysDropped > 0) {
+    lines.push(`  - ${summary.foreignKeysDropped} foreign key(s) dropped`);
+  }
+  lines.push("");
+  lines.push(`Total: ${summary.totalStatements} statement(s)`);
+  if (result.hasDestructiveChanges) {
+    lines.push("");
+    lines.push("WARNING: This diff contains destructive changes!");
+  }
+  return lines.join("\n");
+}
+
+// src/preview/preview.ts
+import { join as join2 } from "path";
+import { atlasNotFoundError as atlasNotFoundError2 } from "@famgia/omnify-core";
+async function generatePreview(schemas, atlasConfig, options = {}) {
+  const atlasVersion = await checkAtlasVersion(atlasConfig);
+  if (!atlasVersion.available) {
+    throw atlasNotFoundError2();
+  }
+  const currentHashes = await buildSchemaHashes(schemas);
+  const lockFilePath = join2(atlasConfig.workDir ?? process.cwd(), LOCK_FILE_NAME);
+  const existingLockFile = await readLockFile(lockFilePath);
+  const schemaChanges = compareSchemas(currentHashes, existingLockFile);
+  const currentHcl = renderHcl(
+    generateHclSchema(schemas, {
+      driver: atlasConfig.driver
+    })
+  );
+  let previousHcl = null;
+  if (existingLockFile?.hclChecksum) {
+    previousHcl = null;
+  }
+  const atlasDiff = await diffHclSchemas(atlasConfig, previousHcl, currentHcl);
+  const databaseChanges = parseDiffOutput(atlasDiff.sql);
+  const summary = buildSummary(schemaChanges, databaseChanges, options);
+  return {
+    hasChanges: schemaChanges.hasChanges || databaseChanges.hasChanges,
+    hasDestructiveChanges: databaseChanges.hasDestructiveChanges,
+    schemaChanges,
+    databaseChanges,
+    summary,
+    sql: atlasDiff.sql
+  };
+}
+function buildSummary(schemaChanges, databaseChanges, options) {
+  const lines = [];
+  if (!schemaChanges.hasChanges && !databaseChanges.hasChanges) {
+    return "No changes detected. Schema is up to date.";
+  }
+  if (schemaChanges.hasChanges) {
+    lines.push("Schema file changes:");
+    for (const change of schemaChanges.changes) {
+      const icon = change.changeType === "added" ? "+" : change.changeType === "removed" ? "-" : "~";
+      lines.push(`  ${icon} ${change.schemaName} (${change.changeType})`);
+    }
+    lines.push("");
+  }
+  if (databaseChanges.hasChanges) {
+    lines.push(formatDiffSummary(databaseChanges));
+  }
+  if (options.warnDestructive && databaseChanges.hasDestructiveChanges) {
+    lines.push("");
+    lines.push("\u26A0\uFE0F  WARNING: This preview contains destructive changes!");
+    lines.push("   Review carefully before generating migrations.");
+  }
+  return lines.join("\n");
+}
+async function previewSchemaChanges(schemas, lockFilePath) {
+  const currentHashes = await buildSchemaHashes(schemas);
+  const existingLockFile = await readLockFile(lockFilePath);
+  return compareSchemas(currentHashes, existingLockFile);
+}
+function formatPreview(preview, format = "text") {
+  switch (format) {
+    case "json":
+      return JSON.stringify(preview, null, 2);
+    case "minimal":
+      if (!preview.hasChanges) {
+        return "No changes";
+      }
+      const parts = [];
+      const { summary } = preview.databaseChanges;
+      if (summary.tablesCreated > 0) parts.push(`+${summary.tablesCreated} tables`);
+      if (summary.tablesDropped > 0) parts.push(`-${summary.tablesDropped} tables`);
+      if (summary.columnsAdded > 0) parts.push(`+${summary.columnsAdded} columns`);
+      if (summary.columnsDropped > 0) parts.push(`-${summary.columnsDropped} columns`);
+      return parts.join(", ") || "Changes detected";
+    case "text":
+    default:
+      return preview.summary;
+  }
+}
+function hasBlockingIssues(_preview) {
+  return false;
+}
+export {
+  LOCK_FILE_NAME,
+  LOCK_FILE_VERSION,
+  addMigrationRecord,
+  applySchema,
+  buildSchemaHashes,
+  checkAtlasVersion,
+  compareSchemas,
+  computeHash,
+  computeSchemaHash,
+  createEmptyLockFile,
+  diffHclSchemas,
+  formatDiffSummary,
+  formatPreview,
+  generateHclSchema,
+  generateHclTable,
+  generatePreview,
+  getPrimaryKeyType,
+  getTimestampType,
+  hasBlockingIssues,
+  mapPropertyToSql,
+  parseDiffOutput,
+  previewSchemaChanges,
+  propertyNameToColumnName,
+  readLockFile,
+  renderHcl,
+  runAtlasDiff,
+  schemaNameToTableName,
+  updateLockFile,
+  validateHcl,
+  writeLockFile
+};
+//# sourceMappingURL=index.js.map