@famgia/omnify-laravel 0.0.16 → 0.0.18

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { PropertyDefinition, SchemaCollection, LoadedSchema } from '@famgia/omnify-types';
+import { CustomTypeDefinition, PropertyDefinition, SchemaCollection, LoadedSchema } from '@famgia/omnify-types';
 import { SchemaChange } from '@famgia/omnify-atlas';
 export { LaravelPluginOptions, laravelPlugin } from './plugin.cjs';
 
@@ -7,6 +7,7 @@ export { LaravelPluginOptions, laravelPlugin } from './plugin.cjs';
  *
  * Types for Laravel migration generation.
  */
+
 /**
  * Laravel migration file structure.
  */
@@ -34,6 +35,8 @@ interface MigrationOptions {
     readonly generateDown?: boolean | undefined;
     /** Database connection name */
     readonly connection?: string | undefined;
+    /** Custom types from plugins (for compound type expansion) */
+    readonly customTypes?: ReadonlyMap<string, CustomTypeDefinition> | undefined;
 }
 /**
  * Schema Builder column method.
@@ -161,10 +164,17 @@ declare function generateForeignKey(propertyName: string, property: PropertyDefi
     foreignKey: ForeignKeyDefinition;
     index: IndexDefinition;
 } | null;
+/**
+ * Options for schema to blueprint conversion.
+ */
+interface SchemaToBlueprintOptions {
+    /** Custom types from plugins (for compound type expansion) */
+    customTypes?: ReadonlyMap<string, CustomTypeDefinition>;
+}
 /**
  * Generates table blueprint from schema.
  */
-declare function schemaToBlueprint(schema: LoadedSchema, allSchemas: SchemaCollection): TableBlueprint;
+declare function schemaToBlueprint(schema: LoadedSchema, allSchemas: SchemaCollection, options?: SchemaToBlueprintOptions): TableBlueprint;
 /**
  * Formats a column method to PHP code.
  */

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { PropertyDefinition, SchemaCollection, LoadedSchema } from '@famgia/omnify-types';
+import { CustomTypeDefinition, PropertyDefinition, SchemaCollection, LoadedSchema } from '@famgia/omnify-types';
 import { SchemaChange } from '@famgia/omnify-atlas';
 export { LaravelPluginOptions, laravelPlugin } from './plugin.js';
 
@@ -7,6 +7,7 @@ export { LaravelPluginOptions, laravelPlugin } from './plugin.js';
  *
  * Types for Laravel migration generation.
  */
+
 /**
  * Laravel migration file structure.
  */
@@ -34,6 +35,8 @@ interface MigrationOptions {
     readonly generateDown?: boolean | undefined;
     /** Database connection name */
     readonly connection?: string | undefined;
+    /** Custom types from plugins (for compound type expansion) */
+    readonly customTypes?: ReadonlyMap<string, CustomTypeDefinition> | undefined;
 }
 /**
  * Schema Builder column method.
@@ -161,10 +164,17 @@ declare function generateForeignKey(propertyName: string, property: PropertyDefi
     foreignKey: ForeignKeyDefinition;
     index: IndexDefinition;
 } | null;
+/**
+ * Options for schema to blueprint conversion.
+ */
+interface SchemaToBlueprintOptions {
+    /** Custom types from plugins (for compound type expansion) */
+    customTypes?: ReadonlyMap<string, CustomTypeDefinition>;
+}
 /**
  * Generates table blueprint from schema.
  */
-declare function schemaToBlueprint(schema: LoadedSchema, allSchemas: SchemaCollection): TableBlueprint;
+declare function schemaToBlueprint(schema: LoadedSchema, allSchemas: SchemaCollection, options?: SchemaToBlueprintOptions): TableBlueprint;
 /**
  * Formats a column method to PHP code.
  */

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   schemaToBlueprint,
   toColumnName,
   toTableName
-} from "./chunk-CAWNYSF3.js";
+} from "./chunk-H37M25AK.js";
 export {
   formatColumnMethod,
   formatForeignKey,

package/dist/plugin.cjs

@@ -39,6 +39,7 @@ var TYPE_METHOD_MAP = {
   LongText: "longText",
   Date: "date",
   Time: "time",
+  DateTime: "dateTime",
   Timestamp: "timestamp",
   Json: "json",
   Email: "string",
@@ -111,6 +112,10 @@ function propertyToColumnMethod(propertyName, property) {
   if (baseProp.unsigned && (method === "integer" || method === "bigInteger")) {
     modifiers.push({ method: "unsigned" });
   }
+  const displayName = property.displayName;
+  if (displayName) {
+    modifiers.push({ method: "comment", args: [displayName] });
+  }
   return {
     name: columnName,
     method,
@@ -239,12 +244,15 @@ function generateForeignKey(propertyName, property, allSchemas) {
     method = "string";
   }
   const modifiers = [];
-  if (assocProp.nullable || assocProp.relation === "ManyToOne") {
+  if (assocProp.nullable === true) {
     modifiers.push({ method: "nullable" });
   }
   if (assocProp.default !== void 0 && assocProp.default !== null) {
     modifiers.push({ method: "default", args: [assocProp.default] });
   }
+  if (assocProp.displayName) {
+    modifiers.push({ method: "comment", args: [assocProp.displayName] });
+  }
   const column = {
     name: columnName,
     method,
@@ -264,7 +272,65 @@ function generateForeignKey(propertyName, property, allSchemas) {
   };
   return { column, foreignKey, index };
 }
-function schemaToBlueprint(schema, allSchemas) {
+function expandCompoundType(propName, property, customTypes) {
+  const typeDef = customTypes.get(property.type);
+  if (!typeDef || !typeDef.compound || !typeDef.expand) {
+    return null;
+  }
+  const expanded = [];
+  const baseProp = property;
+  for (const field of typeDef.expand) {
+    const suffixSnake = toColumnName(field.suffix);
+    const columnName = `${propName}_${suffixSnake}`;
+    const expandedProp = {
+      type: "String"
+      // Default type, will be overridden by sql definition
+    };
+    if (field.sql) {
+      const sqlType = field.sql.sqlType.toUpperCase();
+      if (sqlType === "VARCHAR" || sqlType === "CHAR" || sqlType === "STRING") {
+        expandedProp.type = "String";
+        if (field.sql.length) {
+          expandedProp.length = field.sql.length;
+        }
+      } else if (sqlType === "INT" || sqlType === "INTEGER") {
+        expandedProp.type = "Int";
+      } else if (sqlType === "BIGINT") {
+        expandedProp.type = "BigInt";
+      } else if (sqlType === "TEXT") {
+        expandedProp.type = "Text";
+      } else if (sqlType === "BOOLEAN" || sqlType === "BOOL") {
+        expandedProp.type = "Boolean";
+      } else if (sqlType === "DECIMAL") {
+        expandedProp.type = "Decimal";
+        if (field.sql.precision) expandedProp.precision = field.sql.precision;
+        if (field.sql.scale) expandedProp.scale = field.sql.scale;
+      } else if (sqlType === "DATE") {
+        expandedProp.type = "Date";
+      } else if (sqlType === "TIMESTAMP" || sqlType === "DATETIME") {
+        expandedProp.type = "Timestamp";
+      }
+      if (field.sql.nullable !== void 0) {
+        expandedProp.nullable = field.sql.nullable;
+      } else if (baseProp.nullable !== void 0) {
+        expandedProp.nullable = baseProp.nullable;
+      }
+      if (field.sql.default !== void 0) {
+        expandedProp.default = field.sql.default;
+      }
+    }
+    if (baseProp.displayName) {
+      expandedProp.displayName = `${baseProp.displayName} (${field.suffix})`;
+    }
+    expanded.push({
+      name: columnName,
+      property: expandedProp
+    });
+  }
+  return expanded;
+}
+function schemaToBlueprint(schema, allSchemas, options = {}) {
+  const { customTypes = /* @__PURE__ */ new Map() } = options;
   const tableName = toTableName(schema.name);
   const columns = [];
   const foreignKeys = [];
@@ -275,6 +341,16 @@ function schemaToBlueprint(schema, allSchemas) {
   }
   if (schema.properties) {
     for (const [propName, property] of Object.entries(schema.properties)) {
+      const expandedProps = expandCompoundType(propName, property, customTypes);
+      if (expandedProps) {
+        for (const { name: expandedName, property: expandedProp } of expandedProps) {
+          const columnMethod2 = propertyToColumnMethod(expandedName, expandedProp);
+          if (columnMethod2) {
+            columns.push(columnMethod2);
+          }
+        }
+        continue;
+      }
       const columnMethod = propertyToColumnMethod(propName, property);
       if (columnMethod) {
         columns.push(columnMethod);
@@ -300,36 +376,67 @@ function schemaToBlueprint(schema, allSchemas) {
     columns.push(generateSoftDeleteColumn());
   }
   if (schema.options?.indexes) {
+    const propToColName = (propName) => {
+      const colName = toColumnName(propName);
+      const prop = schema.properties?.[propName];
+      if (prop?.type === "Association") {
+        const assoc = prop;
+        if ((assoc.relation === "ManyToOne" || assoc.relation === "OneToOne") && !assoc.mappedBy) {
+          return colName + "_id";
+        }
+      }
+      return colName;
+    };
     for (const index of schema.options.indexes) {
       if (typeof index === "string") {
         indexes.push({
-          columns: [toColumnName(index)],
+          columns: [propToColName(index)],
           unique: false
         });
       } else {
         indexes.push({
           name: index.name,
-          columns: index.columns.map(toColumnName),
+          columns: index.columns.map(propToColName),
           unique: index.unique ?? false
         });
       }
     }
   }
   if (schema.options?.unique) {
+    const propToColName = (propName) => {
+      const colName = toColumnName(propName);
+      const prop = schema.properties?.[propName];
+      if (prop?.type === "Association") {
+        const assoc = prop;
+        if ((assoc.relation === "ManyToOne" || assoc.relation === "OneToOne") && !assoc.mappedBy) {
+          return colName + "_id";
+        }
+      }
+      return colName;
+    };
     const uniqueConstraints = Array.isArray(schema.options.unique[0]) ? schema.options.unique : [schema.options.unique];
     for (const constraint of uniqueConstraints) {
       indexes.push({
-        columns: constraint.map(toColumnName),
+        columns: constraint.map(propToColName),
         unique: true
       });
     }
   }
+  const seenIndexes = /* @__PURE__ */ new Set();
+  const uniqueIndexes = indexes.filter((idx) => {
+    const key = idx.columns.join(",") + (idx.unique ? ":unique" : "");
+    if (seenIndexes.has(key)) {
+      return false;
+    }
+    seenIndexes.add(key);
+    return true;
+  });
   return {
     tableName,
     columns,
     primaryKey: ["id"],
     foreignKeys,
-    indexes
+    indexes: uniqueIndexes
   };
 }
 function formatColumnMethod(column) {
@@ -650,7 +757,9 @@ function generateMigrations(schemas, options = {}) {
     const timestamp = options.timestamp ?? generateTimestamp();
     const offsetTimestamp = incrementTimestamp(timestamp, timestampOffset);
     timestampOffset++;
-    const blueprint = schemaToBlueprint(schema, schemas);
+    const blueprint = schemaToBlueprint(schema, schemas, {
+      customTypes: options.customTypes
+    });
     const migration = generateCreateMigration(blueprint, {
       ...options,
       timestamp: offsetTimestamp
@@ -706,6 +815,288 @@ function getMigrationPath(migration, outputDir = "database/migrations") {
   return `${outputDir}/${migration.fileName}`;
 }
 
+// src/migration/alter-generator.ts
+var TYPE_METHOD_MAP2 = {
+  String: "string",
+  Int: "integer",
+  BigInt: "bigInteger",
+  Float: "double",
+  Decimal: "decimal",
+  Boolean: "boolean",
+  Text: "text",
+  LongText: "longText",
+  Date: "date",
+  Time: "time",
+  DateTime: "dateTime",
+  Timestamp: "timestamp",
+  Json: "json",
+  Email: "string",
+  Password: "string",
+  File: "string",
+  MultiFile: "json",
+  Enum: "enum",
+  Select: "string",
+  Lookup: "unsignedBigInteger"
+};
+function generateTimestamp2() {
+  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 hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  return `${year}_${month}_${day}_${hours}${minutes}${seconds}`;
+}
+function formatAddColumn(columnName, prop) {
+  const snakeColumn = toColumnName(columnName);
+  const method = TYPE_METHOD_MAP2[prop.type] ?? "string";
+  let code;
+  if (prop.type === "Decimal") {
+    const precision = prop.precision ?? 8;
+    const scale = prop.scale ?? 2;
+    code = `$table->${method}('${snakeColumn}', ${precision}, ${scale})`;
+  } else {
+    code = `$table->${method}('${snakeColumn}')`;
+  }
+  if (prop.nullable) code += "->nullable()";
+  if (prop.unique) code += "->unique()";
+  if (prop.default !== void 0) {
+    const defaultValue = typeof prop.default === "string" ? `'${prop.default}'` : JSON.stringify(prop.default);
+    code += `->default(${defaultValue})`;
+  }
+  return code + ";";
+}
+function formatDropColumn(columnName) {
+  const snakeColumn = toColumnName(columnName);
+  return `$table->dropColumn('${snakeColumn}');`;
+}
+function formatRenameColumn(oldName, newName) {
+  const oldSnake = toColumnName(oldName);
+  const newSnake = toColumnName(newName);
+  return `$table->renameColumn('${oldSnake}', '${newSnake}');`;
+}
+function formatModifyColumn(columnName, _prevProp, currProp) {
+  const snakeColumn = toColumnName(columnName);
+  const method = TYPE_METHOD_MAP2[currProp.type] ?? "string";
+  let code;
+  if (currProp.type === "Decimal") {
+    const precision = currProp.precision ?? 8;
+    const scale = currProp.scale ?? 2;
+    code = `$table->${method}('${snakeColumn}', ${precision}, ${scale})`;
+  } else {
+    code = `$table->${method}('${snakeColumn}')`;
+  }
+  if (currProp.nullable) code += "->nullable()";
+  if (currProp.unique) code += "->unique()";
+  if (currProp.default !== void 0) {
+    const defaultValue = typeof currProp.default === "string" ? `'${currProp.default}'` : JSON.stringify(currProp.default);
+    code += `->default(${defaultValue})`;
+  }
+  return code + "->change();";
+}
+function formatAddIndex(columns, unique) {
+  const snakeColumns = columns.map(toColumnName);
+  const method = unique ? "unique" : "index";
+  const colsArg = snakeColumns.length === 1 ? `'${snakeColumns[0]}'` : `[${snakeColumns.map((c) => `'${c}'`).join(", ")}]`;
+  return `$table->${method}(${colsArg});`;
+}
+function formatDropIndex(tableName, columns, unique) {
+  const snakeColumns = columns.map(toColumnName);
+  const method = unique ? "dropUnique" : "dropIndex";
+  const suffix = unique ? "unique" : "index";
+  const indexName = `${tableName}_${snakeColumns.join("_")}_${suffix}`;
+  return `$table->${method}('${indexName}');`;
+}
+function generateAlterMigrationContent(tableName, change, options = {}) {
+  const upLines = [];
+  const downLines = [];
+  if (change.columnChanges) {
+    for (const col of change.columnChanges) {
+      if (col.changeType === "added" && col.currentDef) {
+        upLines.push(`            ${formatAddColumn(col.column, col.currentDef)}`);
+        downLines.push(`            ${formatDropColumn(col.column)}`);
+      } else if (col.changeType === "removed" && col.previousDef) {
+        upLines.push(`            ${formatDropColumn(col.column)}`);
+        downLines.push(`            ${formatAddColumn(col.column, col.previousDef)}`);
+      } else if (col.changeType === "modified" && col.previousDef && col.currentDef) {
+        upLines.push(`            ${formatModifyColumn(col.column, col.previousDef, col.currentDef)}`);
+        downLines.push(`            ${formatModifyColumn(col.column, col.currentDef, col.previousDef)}`);
+      } else if (col.changeType === "renamed" && col.previousColumn) {
+        upLines.push(`            ${formatRenameColumn(col.previousColumn, col.column)}`);
+        downLines.push(`            ${formatRenameColumn(col.column, col.previousColumn)}`);
+        if (col.modifications && col.modifications.length > 0 && col.previousDef && col.currentDef) {
+          upLines.push(`            ${formatModifyColumn(col.column, col.previousDef, col.currentDef)}`);
+          downLines.push(`            ${formatModifyColumn(col.column, col.currentDef, col.previousDef)}`);
+        }
+      }
+    }
+  }
+  if (change.indexChanges) {
+    for (const idx of change.indexChanges) {
+      if (idx.changeType === "added") {
+        upLines.push(`            ${formatAddIndex(idx.index.columns, idx.index.unique)}`);
+        downLines.push(`            ${formatDropIndex(tableName, idx.index.columns, idx.index.unique)}`);
+      } else {
+        upLines.push(`            ${formatDropIndex(tableName, idx.index.columns, idx.index.unique)}`);
+        downLines.push(`            ${formatAddIndex(idx.index.columns, idx.index.unique)}`);
+      }
+    }
+  }
+  if (change.optionChanges) {
+    if (change.optionChanges.timestamps) {
+      const { from, to } = change.optionChanges.timestamps;
+      if (to && !from) {
+        upLines.push(`            $table->timestamps();`);
+        downLines.push(`            $table->dropTimestamps();`);
+      } else if (from && !to) {
+        upLines.push(`            $table->dropTimestamps();`);
+        downLines.push(`            $table->timestamps();`);
+      }
+    }
+    if (change.optionChanges.softDelete) {
+      const { from, to } = change.optionChanges.softDelete;
+      if (to && !from) {
+        upLines.push(`            $table->softDeletes();`);
+        downLines.push(`            $table->dropSoftDeletes();`);
+      } else if (from && !to) {
+        upLines.push(`            $table->dropSoftDeletes();`);
+        downLines.push(`            $table->softDeletes();`);
+      }
+    }
+  }
+  const connection = options.connection ? `
+    protected $connection = '${options.connection}';
+` : "";
+  return `<?php
+
+use Illuminate\\Database\\Migrations\\Migration;
+use Illuminate\\Database\\Schema\\Blueprint;
+use Illuminate\\Support\\Facades\\Schema;
+
+return new class extends Migration
+{${connection}
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('${tableName}', function (Blueprint $table) {
+${upLines.join("\n")}
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('${tableName}', function (Blueprint $table) {
+${downLines.join("\n")}
+        });
+    }
+};
+`;
+}
+function generateAlterMigration(change, options = {}) {
+  if (change.changeType !== "modified") {
+    return null;
+  }
+  const hasChanges = change.columnChanges && change.columnChanges.length > 0 || change.indexChanges && change.indexChanges.length > 0 || change.optionChanges && (change.optionChanges.timestamps || change.optionChanges.softDelete);
+  if (!hasChanges) {
+    return null;
+  }
+  const tableName = toTableName(change.schemaName);
+  const timestamp = options.timestamp ?? generateTimestamp2();
+  const fileName = `${timestamp}_update_${tableName}_table.php`;
+  const content = generateAlterMigrationContent(tableName, change, options);
+  return {
+    fileName,
+    className: `Update${change.schemaName}Table`,
+    content,
+    tables: [tableName],
+    type: "alter"
+  };
+}
+function generateDropTableMigration(schemaName, options = {}) {
+  const tableName = toTableName(schemaName);
+  const timestamp = options.timestamp ?? generateTimestamp2();
+  const fileName = `${timestamp}_drop_${tableName}_table.php`;
+  const connection = options.connection ? `
+    protected $connection = '${options.connection}';
+` : "";
+  const content = `<?php
+
+use Illuminate\\Database\\Migrations\\Migration;
+use Illuminate\\Database\\Schema\\Blueprint;
+use Illuminate\\Support\\Facades\\Schema;
+
+return new class extends Migration
+{${connection}
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::dropIfExists('${tableName}');
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        // Cannot recreate table without full schema
+        // Consider restoring from backup if needed
+    }
+};
+`;
+  return {
+    fileName,
+    className: `Drop${schemaName}Table`,
+    content,
+    tables: [tableName],
+    type: "drop"
+  };
+}
+function generateMigrationsFromChanges(changes, options = {}) {
+  const migrations = [];
+  let timestampOffset = 0;
+  const getNextTimestamp = () => {
+    const ts = options.timestamp ?? generateTimestamp2();
+    const offset = timestampOffset++;
+    if (offset === 0) return ts;
+    const parts = ts.split("_");
+    if (parts.length >= 4) {
+      const timePart = parts[3] ?? "000000";
+      const secs = parseInt(timePart.substring(4, 6), 10) + offset;
+      const newSecs = String(secs % 60).padStart(2, "0");
+      parts[3] = timePart.substring(0, 4) + newSecs;
+      return parts.join("_");
+    }
+    return ts;
+  };
+  for (const change of changes) {
+    if (change.changeType === "modified") {
+      const migration = generateAlterMigration(change, {
+        ...options,
+        timestamp: getNextTimestamp()
+      });
+      if (migration) {
+        migrations.push(migration);
+      }
+    } else if (change.changeType === "removed") {
+      migrations.push(
+        generateDropTableMigration(change.schemaName, {
+          ...options,
+          timestamp: getNextTimestamp()
+        })
+      );
+    }
+  }
+  return migrations;
+}
+
 // src/utils.ts
 function toSnakeCase(str) {
   return str.replace(/([A-Z])/g, "_$1").replace(/^_/, "").toLowerCase();
@@ -1717,6 +2108,24 @@ function getFactoryPath(factory) {
 }
 
 // src/plugin.ts
+function getExistingMigrationTables(migrationsDir) {
+  const existingTables = /* @__PURE__ */ new Set();
+  if (!(0, import_node_fs.existsSync)(migrationsDir)) {
+    return existingTables;
+  }
+  try {
+    const files = (0, import_node_fs.readdirSync)(migrationsDir);
+    const createMigrationPattern = /^\d{4}_\d{2}_\d{2}_\d{6}_create_(.+)_table\.php$/;
+    for (const file of files) {
+      const match = file.match(createMigrationPattern);
+      if (match) {
+        existingTables.add(match[1]);
+      }
+    }
+  } catch {
+  }
+  return existingTables;
+}
 var LARAVEL_CONFIG_SCHEMA = {
   fields: [
     {
@@ -1800,18 +2209,81 @@ function laravelPlugin(options) {
     generate: async (ctx) => {
       const migrationOptions = {
         connection: resolved.connection,
-        timestamp: resolved.timestamp
+        timestamp: resolved.timestamp,
+        customTypes: ctx.customTypes
       };
-      const migrations = generateMigrations(ctx.schemas, migrationOptions);
-      return migrations.map((migration) => ({
-        path: getMigrationPath(migration, resolved.migrationsPath),
-        content: migration.content,
-        type: "migration",
-        metadata: {
-          tableName: migration.tables[0],
-          migrationType: migration.type
+      const outputs = [];
+      const migrationsDir = (0, import_node_path.join)(ctx.cwd, resolved.migrationsPath);
+      const existingTables = getExistingMigrationTables(migrationsDir);
+      if (ctx.changes !== void 0) {
+        if (ctx.changes.length === 0) {
+          return outputs;
         }
-      }));
+        const addedSchemaNames = new Set(
+          ctx.changes.filter((c) => c.changeType === "added").map((c) => c.schemaName)
+        );
+        if (addedSchemaNames.size > 0) {
+          const addedSchemas = Object.fromEntries(
+            Object.entries(ctx.schemas).filter(([name]) => addedSchemaNames.has(name))
+          );
+          const createMigrations = generateMigrations(addedSchemas, migrationOptions);
+          for (const migration of createMigrations) {
+            const tableName = migration.tables[0];
+            if (existingTables.has(tableName)) {
+              ctx.logger.debug(`Skipping CREATE for ${tableName} (already exists)`);
+              continue;
+            }
+            outputs.push({
+              path: getMigrationPath(migration, resolved.migrationsPath),
+              content: migration.content,
+              type: "migration",
+              metadata: {
+                tableName,
+                migrationType: "create"
+              }
+            });
+          }
+        }
+        const alterChanges = ctx.changes.filter(
+          (c) => c.changeType === "modified" || c.changeType === "removed"
+        );
+        if (alterChanges.length > 0) {
+          const alterMigrations = generateMigrationsFromChanges(
+            alterChanges,
+            migrationOptions
+          );
+          for (const migration of alterMigrations) {
+            outputs.push({
+              path: getMigrationPath(migration, resolved.migrationsPath),
+              content: migration.content,
+              type: "migration",
+              metadata: {
+                tableName: migration.tables[0],
+                migrationType: migration.type
+              }
+            });
+          }
+        }
+      } else {
+        const migrations = generateMigrations(ctx.schemas, migrationOptions);
+        for (const migration of migrations) {
+          const tableName = migration.tables[0];
+          if (migration.type === "create" && existingTables.has(tableName)) {
+            ctx.logger.debug(`Skipping migration for ${tableName} (already exists)`);
+            continue;
+          }
+          outputs.push({
+            path: getMigrationPath(migration, resolved.migrationsPath),
+            content: migration.content,
+            type: "migration",
+            metadata: {
+              tableName,
+              migrationType: migration.type
+            }
+          });
+        }
+      }
+      return outputs;
     }
   };
   const modelGenerator = {