@famgia/omnify-laravel 0.0.13 → 0.0.15

package/dist/chunk-REDFZUQY.js

@@ -0,0 +1,2239 @@
+// src/plugin.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+// src/migration/schema-builder.ts
+var TYPE_METHOD_MAP = {
+  String: "string",
+  Int: "integer",
+  BigInt: "bigInteger",
+  Float: "double",
+  Decimal: "decimal",
+  Boolean: "boolean",
+  Text: "text",
+  LongText: "longText",
+  Date: "date",
+  Time: "time",
+  Timestamp: "timestamp",
+  Json: "json",
+  Email: "string",
+  Password: "string",
+  Enum: "enum"
+  // Note: File type is now polymorphic - no column generated, uses files table
+};
+var PK_METHOD_MAP = {
+  Int: "increments",
+  BigInt: "bigIncrements",
+  Uuid: "uuid",
+  String: "string"
+};
+function getIdType(schema) {
+  return schema.options?.idType ?? "BigInt";
+}
+function hasAutoId(schema) {
+  return schema.options?.id !== false;
+}
+function toColumnName(propertyName) {
+  return propertyName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function toTableName(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 propertyToColumnMethod(propertyName, property) {
+  if (property.type === "Association") {
+    return null;
+  }
+  if (property.type === "File") {
+    return null;
+  }
+  const columnName = toColumnName(propertyName);
+  const method = TYPE_METHOD_MAP[property.type] ?? "string";
+  const args = [columnName];
+  const modifiers = [];
+  const propWithLength = property;
+  if (method === "string" && propWithLength.length) {
+    args.push(propWithLength.length);
+  }
+  if (property.type === "Decimal") {
+    const decimalProp = property;
+    const precision = decimalProp.precision ?? 8;
+    const scale = decimalProp.scale ?? 2;
+    args.push(precision, scale);
+  }
+  if (property.type === "Enum") {
+    const enumProp = property;
+    if (enumProp.enum && enumProp.enum.length > 0) {
+      args.push(enumProp.enum);
+    }
+  }
+  const baseProp = property;
+  if (baseProp.nullable) {
+    modifiers.push({ method: "nullable" });
+  }
+  if (baseProp.unique) {
+    modifiers.push({ method: "unique" });
+  }
+  if (baseProp.default !== void 0 && baseProp.default !== null) {
+    modifiers.push({ method: "default", args: [baseProp.default] });
+  }
+  if (baseProp.unsigned && (method === "integer" || method === "bigInteger")) {
+    modifiers.push({ method: "unsigned" });
+  }
+  return {
+    name: columnName,
+    method,
+    args,
+    modifiers
+  };
+}
+function generatePrimaryKeyColumn(pkType = "BigInt") {
+  const method = PK_METHOD_MAP[pkType] ?? "bigIncrements";
+  if (pkType === "Uuid") {
+    return {
+      name: "id",
+      method: "uuid",
+      args: ["id"],
+      modifiers: [{ method: "primary" }]
+    };
+  }
+  if (pkType === "String") {
+    return {
+      name: "id",
+      method: "string",
+      args: ["id", 255],
+      modifiers: [{ method: "primary" }]
+    };
+  }
+  return {
+    name: "id",
+    method,
+    args: ["id"],
+    modifiers: []
+  };
+}
+function generateTimestampColumns() {
+  return [
+    {
+      name: "created_at",
+      method: "timestamp",
+      args: ["created_at"],
+      modifiers: [{ method: "nullable" }]
+    },
+    {
+      name: "updated_at",
+      method: "timestamp",
+      args: ["updated_at"],
+      modifiers: [{ method: "nullable" }]
+    }
+  ];
+}
+function generateSoftDeleteColumn() {
+  return {
+    name: "deleted_at",
+    method: "timestamp",
+    args: ["deleted_at"],
+    modifiers: [{ method: "nullable" }]
+  };
+}
+function generatePolymorphicColumns(propertyName, property, allSchemas) {
+  if (property.type !== "Association") {
+    return null;
+  }
+  const assocProp = property;
+  if (assocProp.relation !== "MorphTo") {
+    return null;
+  }
+  const targets = assocProp.targets;
+  if (!targets || targets.length === 0) {
+    return null;
+  }
+  const columnBaseName = toColumnName(propertyName);
+  const typeColumnName = `${columnBaseName}_type`;
+  const idColumnName = `${columnBaseName}_id`;
+  const typeColumn = {
+    name: typeColumnName,
+    method: "enum",
+    args: [typeColumnName, targets],
+    modifiers: [{ method: "nullable" }]
+  };
+  let idMethod = "unsignedBigInteger";
+  for (const targetName of targets) {
+    const targetSchema = allSchemas[targetName];
+    if (targetSchema) {
+      const targetIdType = targetSchema.options?.idType ?? "BigInt";
+      if (targetIdType === "Uuid") {
+        idMethod = "uuid";
+        break;
+      } else if (targetIdType === "String") {
+        idMethod = "string";
+      }
+    }
+  }
+  const idColumn = {
+    name: idColumnName,
+    method: idMethod,
+    args: idMethod === "string" ? [idColumnName, 255] : [idColumnName],
+    modifiers: [{ method: "nullable" }]
+  };
+  const indexes = [
+    {
+      columns: [typeColumnName, idColumnName],
+      unique: false
+    }
+  ];
+  return { typeColumn, idColumn, indexes };
+}
+function generateForeignKey(propertyName, property, allSchemas) {
+  if (property.type !== "Association") {
+    return null;
+  }
+  const assocProp = property;
+  if (assocProp.relation !== "ManyToOne" && assocProp.relation !== "OneToOne") {
+    return null;
+  }
+  if (assocProp.mappedBy) {
+    return null;
+  }
+  const columnName = toColumnName(propertyName) + "_id";
+  const targetSchema = assocProp.target ? allSchemas[assocProp.target] : void 0;
+  const targetTable = assocProp.target ? toTableName(assocProp.target) : "unknown";
+  const targetPkType = targetSchema ? getIdType(targetSchema) : "BigInt";
+  let method = "unsignedBigInteger";
+  if (targetPkType === "Int") {
+    method = "unsignedInteger";
+  } else if (targetPkType === "Uuid") {
+    method = "uuid";
+  } else if (targetPkType === "String") {
+    method = "string";
+  }
+  const column = {
+    name: columnName,
+    method,
+    args: [columnName],
+    modifiers: assocProp.relation === "ManyToOne" ? [{ method: "nullable" }] : []
+  };
+  const foreignKey = {
+    columns: [columnName],
+    references: "id",
+    on: [targetTable],
+    onDelete: assocProp.onDelete ?? "restrict",
+    onUpdate: assocProp.onUpdate ?? "cascade"
+  };
+  const index = {
+    columns: [columnName],
+    unique: false
+  };
+  return { column, foreignKey, index };
+}
+function schemaToBlueprint(schema, allSchemas) {
+  const tableName = toTableName(schema.name);
+  const columns = [];
+  const foreignKeys = [];
+  const indexes = [];
+  if (hasAutoId(schema)) {
+    const pkType = getIdType(schema);
+    columns.push(generatePrimaryKeyColumn(pkType));
+  }
+  if (schema.properties) {
+    for (const [propName, property] of Object.entries(schema.properties)) {
+      const columnMethod = propertyToColumnMethod(propName, property);
+      if (columnMethod) {
+        columns.push(columnMethod);
+      }
+      const fkResult = generateForeignKey(propName, property, allSchemas);
+      if (fkResult) {
+        columns.push(fkResult.column);
+        foreignKeys.push(fkResult.foreignKey);
+        indexes.push(fkResult.index);
+      }
+      const polyResult = generatePolymorphicColumns(propName, property, allSchemas);
+      if (polyResult) {
+        columns.push(polyResult.typeColumn);
+        columns.push(polyResult.idColumn);
+        indexes.push(...polyResult.indexes);
+      }
+    }
+  }
+  if (schema.options?.timestamps !== false) {
+    columns.push(...generateTimestampColumns());
+  }
+  if (schema.options?.softDelete) {
+    columns.push(generateSoftDeleteColumn());
+  }
+  if (schema.options?.indexes) {
+    for (const index of schema.options.indexes) {
+      if (typeof index === "string") {
+        indexes.push({
+          columns: [toColumnName(index)],
+          unique: false
+        });
+      } else {
+        indexes.push({
+          name: index.name,
+          columns: index.columns.map(toColumnName),
+          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) {
+      indexes.push({
+        columns: constraint.map(toColumnName),
+        unique: true
+      });
+    }
+  }
+  return {
+    tableName,
+    columns,
+    primaryKey: ["id"],
+    foreignKeys,
+    indexes
+  };
+}
+function formatColumnMethod(column) {
+  const args = column.args.map((arg) => {
+    if (typeof arg === "string") {
+      return `'${arg}'`;
+    }
+    if (Array.isArray(arg)) {
+      return `[${arg.map((v) => `'${v}'`).join(", ")}]`;
+    }
+    return String(arg);
+  }).join(", ");
+  let code = `$table->${column.method}(${args})`;
+  for (const modifier of column.modifiers) {
+    if (modifier.args && modifier.args.length > 0) {
+      const modArgs = modifier.args.map((arg) => {
+        if (typeof arg === "string") {
+          return `'${arg}'`;
+        }
+        if (typeof arg === "boolean") {
+          return arg ? "true" : "false";
+        }
+        if (typeof arg === "number") {
+          return String(arg);
+        }
+        return String(arg);
+      }).join(", ");
+      code += `->${modifier.method}(${modArgs})`;
+    } else {
+      code += `->${modifier.method}()`;
+    }
+  }
+  return code + ";";
+}
+function formatForeignKey(fk) {
+  const column = fk.columns[0];
+  const table = fk.on[0];
+  let code = `$table->foreign('${column}')->references('${fk.references}')->on('${table}')`;
+  if (fk.onDelete) {
+    code += `->onDelete('${fk.onDelete}')`;
+  }
+  if (fk.onUpdate) {
+    code += `->onUpdate('${fk.onUpdate}')`;
+  }
+  return code + ";";
+}
+function formatIndex(index) {
+  const columns = index.columns.length === 1 ? `'${index.columns[0]}'` : `[${index.columns.map((c) => `'${c}'`).join(", ")}]`;
+  const method = index.unique ? "unique" : "index";
+  const name = index.name ? `, '${index.name}'` : "";
+  return `$table->${method}(${columns}${name});`;
+}
+function generatePivotTableName(sourceTable, targetTable, customName) {
+  if (customName) {
+    return customName;
+  }
+  const tables = [sourceTable, targetTable].sort();
+  const singular1 = tables[0].replace(/ies$/, "y").replace(/s$/, "");
+  const singular2 = tables[1].replace(/ies$/, "y").replace(/s$/, "");
+  return `${singular1}_${singular2}`;
+}
+function extractManyToManyRelations(schema, allSchemas) {
+  const pivotTables = [];
+  if (!schema.properties) {
+    return pivotTables;
+  }
+  const sourceTable = toTableName(schema.name);
+  const sourcePkType = getIdType(schema);
+  for (const [, property] of Object.entries(schema.properties)) {
+    if (property.type !== "Association") {
+      continue;
+    }
+    const assocProp = property;
+    if (assocProp.relation !== "ManyToMany") {
+      continue;
+    }
+    const targetName = assocProp.target;
+    if (!targetName) {
+      continue;
+    }
+    const targetSchema = allSchemas[targetName];
+    const targetTable = toTableName(targetName);
+    const targetPkType = targetSchema ? getIdType(targetSchema) : "BigInt";
+    const isOwningSide = assocProp.owning ?? schema.name < targetName;
+    if (!isOwningSide) {
+      continue;
+    }
+    const pivotTableName = generatePivotTableName(sourceTable, targetTable, assocProp.joinTable);
+    const sourceColumn = sourceTable.replace(/ies$/, "y").replace(/s$/, "") + "_id";
+    const targetColumn = targetTable.replace(/ies$/, "y").replace(/s$/, "") + "_id";
+    pivotTables.push({
+      tableName: pivotTableName,
+      sourceTable,
+      targetTable,
+      sourceColumn,
+      targetColumn,
+      sourcePkType,
+      targetPkType,
+      onDelete: assocProp.onDelete,
+      onUpdate: assocProp.onUpdate
+    });
+  }
+  return pivotTables;
+}
+function generatePivotTableBlueprint(pivot) {
+  const columns = [];
+  const foreignKeys = [];
+  const indexes = [];
+  const getMethodForPkType = (pkType) => {
+    switch (pkType) {
+      case "Int":
+        return "unsignedInteger";
+      case "Uuid":
+        return "uuid";
+      case "String":
+        return "string";
+      default:
+        return "unsignedBigInteger";
+    }
+  };
+  columns.push({
+    name: pivot.sourceColumn,
+    method: getMethodForPkType(pivot.sourcePkType),
+    args: [pivot.sourceColumn],
+    modifiers: []
+  });
+  columns.push({
+    name: pivot.targetColumn,
+    method: getMethodForPkType(pivot.targetPkType),
+    args: [pivot.targetColumn],
+    modifiers: []
+  });
+  columns.push(...generateTimestampColumns());
+  foreignKeys.push({
+    columns: [pivot.sourceColumn],
+    references: "id",
+    on: [pivot.sourceTable],
+    onDelete: pivot.onDelete ?? "cascade",
+    onUpdate: pivot.onUpdate ?? "cascade"
+  });
+  foreignKeys.push({
+    columns: [pivot.targetColumn],
+    references: "id",
+    on: [pivot.targetTable],
+    onDelete: pivot.onDelete ?? "cascade",
+    onUpdate: pivot.onUpdate ?? "cascade"
+  });
+  indexes.push({
+    columns: [pivot.sourceColumn, pivot.targetColumn],
+    unique: true
+  });
+  indexes.push({
+    columns: [pivot.sourceColumn],
+    unique: false
+  });
+  indexes.push({
+    columns: [pivot.targetColumn],
+    unique: false
+  });
+  return {
+    tableName: pivot.tableName,
+    columns,
+    primaryKey: [pivot.sourceColumn, pivot.targetColumn],
+    foreignKeys,
+    indexes
+  };
+}
+
+// src/migration/generator.ts
+function generateTimestamp() {
+  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 toClassName(tableName, type) {
+  const pascalCase = tableName.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  switch (type) {
+    case "create":
+      return `Create${pascalCase}Table`;
+    case "alter":
+      return `Alter${pascalCase}Table`;
+    case "drop":
+      return `Drop${pascalCase}Table`;
+  }
+}
+function generateFileName(tableName, type, timestamp) {
+  const ts = timestamp ?? generateTimestamp();
+  const action = type === "create" ? "create" : type === "drop" ? "drop" : "update";
+  return `${ts}_${action}_${tableName}_table.php`;
+}
+function renderCreateTableUp(blueprint) {
+  const lines = [];
+  for (const column of blueprint.columns) {
+    lines.push(`            ${formatColumnMethod(column)}`);
+  }
+  return lines.join("\n");
+}
+function renderForeignKeys(blueprint) {
+  if (blueprint.foreignKeys.length === 0) {
+    return "";
+  }
+  const lines = blueprint.foreignKeys.map((fk) => `            ${formatForeignKey(fk)}`);
+  return "\n" + lines.join("\n");
+}
+function renderIndexes(blueprint) {
+  const customIndexes = blueprint.indexes.filter((idx) => {
+    if (idx.unique && idx.columns.length === 1) {
+      return false;
+    }
+    return true;
+  });
+  if (customIndexes.length === 0) {
+    return "";
+  }
+  const lines = customIndexes.map((idx) => `            ${formatIndex(idx)}`);
+  return "\n" + lines.join("\n");
+}
+function generateCreateMigration(blueprint, options = {}) {
+  const className = toClassName(blueprint.tableName, "create");
+  const fileName = generateFileName(blueprint.tableName, "create", options.timestamp);
+  const connection = options.connection ? `
+    protected $connection = '${options.connection}';
+` : "";
+  const upContent = renderCreateTableUp(blueprint);
+  const foreignKeyContent = renderForeignKeys(blueprint);
+  const indexContent = renderIndexes(blueprint);
+  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::create('${blueprint.tableName}', function (Blueprint $table) {
+${upContent}${foreignKeyContent}${indexContent}
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('${blueprint.tableName}');
+    }
+};
+`;
+  return {
+    fileName,
+    className,
+    content,
+    tables: [blueprint.tableName],
+    type: "create"
+  };
+}
+function generateDropMigration(tableName, options = {}) {
+  const className = toClassName(tableName, "drop");
+  const fileName = generateFileName(tableName, "drop", options.timestamp);
+  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 schema information
+        // This is a one-way migration
+    }
+};
+`;
+  return {
+    fileName,
+    className,
+    content,
+    tables: [tableName],
+    type: "drop"
+  };
+}
+function extractDependencies(schema) {
+  const deps = [];
+  if (!schema.properties) {
+    return deps;
+  }
+  for (const property of Object.values(schema.properties)) {
+    if (property.type !== "Association") {
+      continue;
+    }
+    const assocProp = property;
+    if ((assocProp.relation === "ManyToOne" || assocProp.relation === "OneToOne") && !assocProp.mappedBy && assocProp.target) {
+      deps.push(assocProp.target);
+    }
+  }
+  return deps;
+}
+function topologicalSort(schemas) {
+  const schemaList = Object.values(schemas).filter((s) => s.kind !== "enum");
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(schema) {
+    if (visited.has(schema.name)) {
+      return;
+    }
+    if (visiting.has(schema.name)) {
+      return;
+    }
+    visiting.add(schema.name);
+    const deps = extractDependencies(schema);
+    for (const depName of deps) {
+      const depSchema = schemas[depName];
+      if (depSchema && depSchema.kind !== "enum") {
+        visit(depSchema);
+      }
+    }
+    visiting.delete(schema.name);
+    visited.add(schema.name);
+    sorted.push(schema);
+  }
+  for (const schema of schemaList) {
+    visit(schema);
+  }
+  return sorted;
+}
+function generateMigrations(schemas, options = {}) {
+  const migrations = [];
+  const pivotTablesGenerated = /* @__PURE__ */ new Set();
+  let timestampOffset = 0;
+  const sortedSchemas = topologicalSort(schemas);
+  for (const schema of sortedSchemas) {
+    const timestamp = options.timestamp ?? generateTimestamp();
+    const offsetTimestamp = incrementTimestamp(timestamp, timestampOffset);
+    timestampOffset++;
+    const blueprint = schemaToBlueprint(schema, schemas);
+    const migration = generateCreateMigration(blueprint, {
+      ...options,
+      timestamp: offsetTimestamp
+    });
+    migrations.push(migration);
+  }
+  for (const schema of sortedSchemas) {
+    const pivotTables = extractManyToManyRelations(schema, schemas);
+    for (const pivot of pivotTables) {
+      if (pivotTablesGenerated.has(pivot.tableName)) {
+        continue;
+      }
+      pivotTablesGenerated.add(pivot.tableName);
+      const timestamp = options.timestamp ?? generateTimestamp();
+      const offsetTimestamp = incrementTimestamp(timestamp, timestampOffset);
+      timestampOffset++;
+      const blueprint = generatePivotTableBlueprint(pivot);
+      const migration = generateCreateMigration(blueprint, {
+        ...options,
+        timestamp: offsetTimestamp
+      });
+      migrations.push(migration);
+    }
+  }
+  return migrations;
+}
+function incrementTimestamp(timestamp, seconds) {
+  if (seconds === 0) return timestamp;
+  const parts = timestamp.split("_");
+  if (parts.length < 4) {
+    return timestamp;
+  }
+  const yearPart = parts[0] ?? "2024";
+  const monthPart = parts[1] ?? "01";
+  const dayPart = parts[2] ?? "01";
+  const timePart = parts[3] ?? "000000";
+  const year = parseInt(yearPart, 10);
+  const month = parseInt(monthPart, 10) - 1;
+  const day = parseInt(dayPart, 10);
+  const hours = parseInt(timePart.substring(0, 2), 10);
+  const minutes = parseInt(timePart.substring(2, 4), 10);
+  const secs = parseInt(timePart.substring(4, 6), 10);
+  const date = new Date(year, month, day, hours, minutes, secs + seconds);
+  const newYear = date.getFullYear();
+  const newMonth = String(date.getMonth() + 1).padStart(2, "0");
+  const newDay = String(date.getDate()).padStart(2, "0");
+  const newHours = String(date.getHours()).padStart(2, "0");
+  const newMinutes = String(date.getMinutes()).padStart(2, "0");
+  const newSecs = String(date.getSeconds()).padStart(2, "0");
+  return `${newYear}_${newMonth}_${newDay}_${newHours}${newMinutes}${newSecs}`;
+}
+function generateMigrationFromSchema(schema, allSchemas, options = {}) {
+  const blueprint = schemaToBlueprint(schema, allSchemas);
+  return generateCreateMigration(blueprint, options);
+}
+function generateDropMigrationForTable(tableName, options = {}) {
+  return generateDropMigration(tableName, options);
+}
+function formatMigrationFile(migration) {
+  return migration.content;
+}
+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",
+  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();
+}
+function toPascalCase(str) {
+  return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function pluralize(word) {
+  if (word.endsWith("y") && !["ay", "ey", "iy", "oy", "uy"].some((v) => word.endsWith(v))) {
+    return word.slice(0, -1) + "ies";
+  }
+  if (word.endsWith("s") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ch") || word.endsWith("sh")) {
+    return word + "es";
+  }
+  return word + "s";
+}
+
+// src/model/generator.ts
+var DEFAULT_OPTIONS = {
+  baseModelNamespace: "App\\Models\\OmnifyBase",
+  modelNamespace: "App\\Models",
+  baseModelClassName: "BaseModel",
+  baseModelPath: "app/Models/OmnifyBase",
+  modelPath: "app/Models"
+};
+function resolveOptions(options) {
+  return {
+    baseModelNamespace: options?.baseModelNamespace ?? DEFAULT_OPTIONS.baseModelNamespace,
+    modelNamespace: options?.modelNamespace ?? DEFAULT_OPTIONS.modelNamespace,
+    baseModelClassName: options?.baseModelClassName ?? DEFAULT_OPTIONS.baseModelClassName,
+    baseModelPath: options?.baseModelPath ?? DEFAULT_OPTIONS.baseModelPath,
+    modelPath: options?.modelPath ?? DEFAULT_OPTIONS.modelPath
+  };
+}
+function getCastType(propDef) {
+  switch (propDef.type) {
+    case "Boolean":
+      return "boolean";
+    case "Int":
+    case "BigInt":
+      return "integer";
+    case "Float":
+      return "float";
+    case "Decimal":
+      return "decimal:" + (propDef.scale ?? 2);
+    case "Json":
+      return "array";
+    case "Date":
+      return "date";
+    case "Timestamp":
+      return "datetime";
+    case "Password":
+      return "hashed";
+    default:
+      return null;
+  }
+}
+function isNullable(propDef) {
+  return "nullable" in propDef && propDef.nullable === true;
+}
+function getPhpDocType(propDef, schemas) {
+  const nullable = isNullable(propDef);
+  switch (propDef.type) {
+    case "String":
+    case "Text":
+    case "LongText":
+    case "Email":
+    case "Password":
+      return "string" + (nullable ? "|null" : "");
+    case "Int":
+    case "BigInt":
+      return "int" + (nullable ? "|null" : "");
+    case "Float":
+    case "Decimal":
+      return "float" + (nullable ? "|null" : "");
+    case "Boolean":
+      return "bool" + (nullable ? "|null" : "");
+    case "Date":
+    case "Time":
+    case "Timestamp":
+      return "\\Carbon\\Carbon" + (nullable ? "|null" : "");
+    case "Json":
+      return "array" + (nullable ? "|null" : "");
+    case "Enum":
+    case "EnumRef":
+      return "string" + (nullable ? "|null" : "");
+    case "Association": {
+      const assoc = propDef;
+      if (assoc.target) {
+        const className = toPascalCase(assoc.target);
+        switch (assoc.relation) {
+          case "OneToMany":
+          case "ManyToMany":
+          case "MorphMany":
+          case "MorphToMany":
+          case "MorphedByMany":
+            return `\\Illuminate\\Database\\Eloquent\\Collection<${className}>`;
+          default:
+            return className + "|null";
+        }
+      }
+      return "mixed";
+    }
+    default:
+      return "mixed";
+  }
+}
+function generateBaseModel(schemas, options, stubContent) {
+  const modelMap = Object.values(schemas).filter((s) => s.kind !== "enum").map((s) => {
+    const className = toPascalCase(s.name);
+    return `        '${s.name}' => \\${options.modelNamespace}\\${className}::class,`;
+  }).join("\n");
+  const content = stubContent.replace(/\{\{BASE_MODEL_NAMESPACE\}\}/g, options.baseModelNamespace).replace(/\{\{BASE_MODEL_CLASS\}\}/g, options.baseModelClassName).replace(/\{\{MODEL_MAP\}\}/g, modelMap);
+  return {
+    path: `${options.baseModelPath}/${options.baseModelClassName}.php`,
+    content,
+    type: "base-model",
+    overwrite: true,
+    schemaName: "__base__"
+  };
+}
+function generateEntityBaseModel(schema, schemas, options, stubContent, authStubContent) {
+  const className = toPascalCase(schema.name);
+  const tableName = schema.options?.tableName ?? pluralize(toSnakeCase(schema.name));
+  const isAuth = schema.options?.authenticatable ?? false;
+  const primaryKey = "id";
+  const idType = schema.options?.idType ?? "BigInt";
+  const isUuid = idType === "Uuid";
+  const isStringKey = idType === "Uuid" || idType === "String";
+  const imports = [];
+  const traits = [];
+  const fillable = [];
+  const hidden = [];
+  const appends = [];
+  const casts = [];
+  const relations = [];
+  const docProperties = [];
+  if (schema.options?.softDelete) {
+    imports.push("use Illuminate\\Database\\Eloquent\\SoftDeletes;");
+    traits.push("    use SoftDeletes;");
+  }
+  const properties = schema.properties ?? {};
+  for (const [propName, propDef] of Object.entries(properties)) {
+    const snakeName = toSnakeCase(propName);
+    const phpType = getPhpDocType(propDef, schemas);
+    docProperties.push(` * @property ${phpType} $${snakeName}`);
+    if (propDef.type === "Association") {
+      const assoc = propDef;
+      if (assoc.target) {
+        imports.push(`use ${options.modelNamespace}\\${toPascalCase(assoc.target)};`);
+      }
+      relations.push(generateRelation(propName, assoc, schema, schemas, options));
+      if (assoc.relation === "ManyToOne" || assoc.relation === "OneToOne") {
+        if (!assoc.mappedBy) {
+          const fkName = toSnakeCase(propName) + "_id";
+          fillable.push(`        '${fkName}',`);
+          docProperties.push(` * @property int|null $${fkName}`);
+        }
+      }
+    } else if (propDef.type === "Password") {
+      fillable.push(`        '${snakeName}',`);
+      hidden.push(`        '${snakeName}',`);
+      const cast = getCastType(propDef);
+      if (cast) {
+        casts.push(`            '${snakeName}' => '${cast}',`);
+      }
+    } else if (propDef.type === "File") {
+      const relMethod = generateFileRelation(propName, propDef);
+      relations.push(relMethod);
+    } else {
+      fillable.push(`        '${snakeName}',`);
+      const cast = getCastType(propDef);
+      if (cast) {
+        casts.push(`            '${snakeName}' => '${cast}',`);
+      }
+    }
+  }
+  const docComment = `/**
+ * ${className}BaseModel
+ *
+${docProperties.join("\n")}
+ */`;
+  const stub = isAuth ? authStubContent : stubContent;
+  const keyType = isStringKey ? `    /**
+     * The "type" of the primary key ID.
+     */
+    protected $keyType = 'string';
+
+` : "";
+  const incrementing = isUuid ? `    /**
+     * Indicates if the IDs are auto-incrementing.
+     */
+    public $incrementing = false;
+
+` : "";
+  if (isUuid) {
+    imports.push("use Illuminate\\Database\\Eloquent\\Concerns\\HasUuids;");
+    traits.push("    use HasUuids;");
+  }
+  const content = stub.replace(/\{\{BASE_MODEL_NAMESPACE\}\}/g, options.baseModelNamespace).replace(/\{\{BASE_MODEL_CLASS\}\}/g, options.baseModelClassName).replace(/\{\{CLASS_NAME\}\}/g, className).replace(/\{\{TABLE_NAME\}\}/g, tableName).replace(/\{\{PRIMARY_KEY\}\}/g, primaryKey).replace(/\{\{KEY_TYPE\}\}/g, keyType).replace(/\{\{INCREMENTING\}\}/g, incrementing).replace(/\{\{TIMESTAMPS\}\}/g, schema.options?.timestamps !== false ? "true" : "false").replace(/\{\{IMPORTS\}\}/g, [...new Set(imports)].sort().join("\n")).replace(/\{\{TRAITS\}\}/g, traits.join("\n")).replace(/\{\{DOC_COMMENT\}\}/g, docComment).replace(/\{\{FILLABLE\}\}/g, fillable.join("\n")).replace(/\{\{HIDDEN\}\}/g, hidden.join("\n")).replace(/\{\{APPENDS\}\}/g, appends.join("\n")).replace(/\{\{CASTS\}\}/g, casts.join("\n")).replace(/\{\{RELATIONS\}\}/g, relations.join("\n\n"));
+  return {
+    path: `${options.baseModelPath}/${className}BaseModel.php`,
+    content,
+    type: "entity-base",
+    overwrite: true,
+    schemaName: schema.name
+  };
+}
+function findInverseRelation(currentSchemaName, targetSchemaName, schemas) {
+  const targetSchema = schemas[targetSchemaName];
+  if (!targetSchema || !targetSchema.properties) {
+    return null;
+  }
+  for (const [propName, propDef] of Object.entries(targetSchema.properties)) {
+    if (propDef.type === "Association") {
+      const assoc = propDef;
+      if (assoc.relation === "ManyToOne" && assoc.target === currentSchemaName) {
+        return propName;
+      }
+    }
+  }
+  return null;
+}
+function generateRelation(propName, assoc, schema, schemas, options) {
+  const methodName = toCamelCase(propName);
+  const targetClass = assoc.target ? toPascalCase(assoc.target) : "";
+  const fkName = toSnakeCase(propName) + "_id";
+  switch (assoc.relation) {
+    case "ManyToOne":
+      return `    /**
+     * Get the ${propName} that owns this model.
+     */
+    public function ${methodName}(): BelongsTo
+    {
+        return $this->belongsTo(${targetClass}::class, '${fkName}');
+    }`;
+    case "OneToOne":
+      if (assoc.mappedBy) {
+        return `    /**
+     * Get the ${propName} for this model.
+     */
+    public function ${methodName}(): HasOne
+    {
+        return $this->hasOne(${targetClass}::class, '${toSnakeCase(assoc.mappedBy)}_id');
+    }`;
+      }
+      return `    /**
+     * Get the ${propName} that owns this model.
+     */
+    public function ${methodName}(): BelongsTo
+    {
+        return $this->belongsTo(${targetClass}::class, '${fkName}');
+    }`;
+    case "OneToMany": {
+      let foreignKey;
+      if (assoc.inversedBy) {
+        foreignKey = toSnakeCase(assoc.inversedBy) + "_id";
+      } else if (assoc.target) {
+        const inverseRelation = findInverseRelation(schema.name, assoc.target, schemas);
+        if (inverseRelation) {
+          foreignKey = toSnakeCase(inverseRelation) + "_id";
+        } else {
+          foreignKey = toSnakeCase(schema.name) + "_id";
+        }
+      } else {
+        foreignKey = toSnakeCase(propName) + "_id";
+      }
+      return `    /**
+     * Get the ${propName} for this model.
+     */
+    public function ${methodName}(): HasMany
+    {
+        return $this->hasMany(${targetClass}::class, '${foreignKey}');
+    }`;
+    }
+    case "ManyToMany": {
+      const pivotTable = assoc.joinTable ?? `${toSnakeCase(propName)}_pivot`;
+      return `    /**
+     * The ${propName} that belong to this model.
+     */
+    public function ${methodName}(): BelongsToMany
+    {
+        return $this->belongsToMany(${targetClass}::class, '${pivotTable}')
+            ->withTimestamps();
+    }`;
+    }
+    case "MorphTo":
+      return `    /**
+     * Get the parent ${propName} model.
+     */
+    public function ${methodName}(): MorphTo
+    {
+        return $this->morphTo('${methodName}');
+    }`;
+    case "MorphOne":
+      return `    /**
+     * Get the ${propName} for this model.
+     */
+    public function ${methodName}(): MorphOne
+    {
+        return $this->morphOne(${targetClass}::class, '${assoc.morphName ?? propName}');
+    }`;
+    case "MorphMany":
+      return `    /**
+     * Get the ${propName} for this model.
+     */
+    public function ${methodName}(): MorphMany
+    {
+        return $this->morphMany(${targetClass}::class, '${assoc.morphName ?? propName}');
+    }`;
+    default:
+      return `    // TODO: Implement ${assoc.relation} relation for ${propName}`;
+  }
+}
+function generateFileRelation(propName, propDef) {
+  const methodName = toCamelCase(propName);
+  const relationType = propDef.multiple ? "MorphMany" : "MorphOne";
+  const relationMethod = propDef.multiple ? "morphMany" : "morphOne";
+  return `    /**
+     * Get the ${propName} file(s) for this model.
+     */
+    public function ${methodName}(): ${relationType}
+    {
+        return $this->${relationMethod}(FileUpload::class, 'uploadable')
+            ->where('attribute_name', '${propName}');
+    }`;
+}
+function generateEntityModel(schema, options, stubContent) {
+  const className = toPascalCase(schema.name);
+  const content = stubContent.replace(/\{\{BASE_MODEL_NAMESPACE\}\}/g, options.baseModelNamespace).replace(/\{\{MODEL_NAMESPACE\}\}/g, options.modelNamespace).replace(/\{\{CLASS_NAME\}\}/g, className);
+  return {
+    path: `${options.modelPath}/${className}.php`,
+    content,
+    type: "entity",
+    overwrite: false,
+    // Never overwrite user models
+    schemaName: schema.name
+  };
+}
+function getStubContent(stubName) {
+  const stubs = {
+    "base-model": `<?php
+
+namespace {{BASE_MODEL_NAMESPACE}};
+
+/**
+ * Base model class for all Omnify-generated models.
+ * Contains model mapping for polymorphic relations.
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by @famgia/omnify-laravel
+ */
+
+use Illuminate\\Database\\Eloquent\\Model;
+use Illuminate\\Database\\Eloquent\\Relations\\Relation;
+
+abstract class {{BASE_MODEL_CLASS}} extends Model
+{
+    /**
+     * Model class map for polymorphic relations.
+     */
+    protected static array $modelMap = [
+{{MODEL_MAP}}
+    ];
+
+    /**
+     * Boot the model and register morph map.
+     */
+    protected static function boot(): void
+    {
+        parent::boot();
+
+        // Register morph map for polymorphic relations
+        Relation::enforceMorphMap(static::$modelMap);
+    }
+
+    /**
+     * Get the model class for a given morph type.
+     */
+    public static function getModelClass(string $morphType): ?string
+    {
+        return static::$modelMap[$morphType] ?? null;
+    }
+}
+`,
+    "entity-base": `<?php
+
+namespace {{BASE_MODEL_NAMESPACE}};
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by @famgia/omnify-laravel
+ */
+
+use Illuminate\\Database\\Eloquent\\Relations\\BelongsTo;
+use Illuminate\\Database\\Eloquent\\Relations\\HasMany;
+use Illuminate\\Database\\Eloquent\\Relations\\HasOne;
+use Illuminate\\Database\\Eloquent\\Relations\\BelongsToMany;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphTo;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphOne;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphMany;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphToMany;
+use Illuminate\\Database\\Eloquent\\Collection as EloquentCollection;
+{{IMPORTS}}
+
+{{DOC_COMMENT}}
+class {{CLASS_NAME}}BaseModel extends {{BASE_MODEL_CLASS}}
+{
+{{TRAITS}}
+    /**
+     * The table associated with the model.
+     */
+    protected $table = '{{TABLE_NAME}}';
+
+    /**
+     * The primary key for the model.
+     */
+    protected $primaryKey = '{{PRIMARY_KEY}}';
+
+{{KEY_TYPE}}
+{{INCREMENTING}}
+    /**
+     * Indicates if the model should be timestamped.
+     */
+    public $timestamps = {{TIMESTAMPS}};
+
+    /**
+     * The attributes that are mass assignable.
+     */
+    protected $fillable = [
+{{FILLABLE}}
+    ];
+
+    /**
+     * The attributes that should be hidden for serialization.
+     */
+    protected $hidden = [
+{{HIDDEN}}
+    ];
+
+    /**
+     * The accessors to append to the model's array form.
+     */
+    protected $appends = [
+{{APPENDS}}
+    ];
+
+    /**
+     * Get the attributes that should be cast.
+     */
+    protected function casts(): array
+    {
+        return [
+{{CASTS}}
+        ];
+    }
+
+{{RELATIONS}}
+}
+`,
+    "entity-base-auth": `<?php
+
+namespace {{BASE_MODEL_NAMESPACE}};
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by @famgia/omnify-laravel
+ */
+
+use Illuminate\\Foundation\\Auth\\User as Authenticatable;
+use Illuminate\\Database\\Eloquent\\Relations\\BelongsTo;
+use Illuminate\\Database\\Eloquent\\Relations\\HasMany;
+use Illuminate\\Database\\Eloquent\\Relations\\HasOne;
+use Illuminate\\Database\\Eloquent\\Relations\\BelongsToMany;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphTo;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphOne;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphMany;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphToMany;
+use Illuminate\\Database\\Eloquent\\Collection as EloquentCollection;
+use Illuminate\\Notifications\\Notifiable;
+{{IMPORTS}}
+
+{{DOC_COMMENT}}
+class {{CLASS_NAME}}BaseModel extends Authenticatable
+{
+    use Notifiable;
+{{TRAITS}}
+    /**
+     * The table associated with the model.
+     */
+    protected $table = '{{TABLE_NAME}}';
+
+    /**
+     * The primary key for the model.
+     */
+    protected $primaryKey = '{{PRIMARY_KEY}}';
+
+{{KEY_TYPE}}
+{{INCREMENTING}}
+    /**
+     * Indicates if the model should be timestamped.
+     */
+    public $timestamps = {{TIMESTAMPS}};
+
+    /**
+     * The attributes that are mass assignable.
+     */
+    protected $fillable = [
+{{FILLABLE}}
+    ];
+
+    /**
+     * The attributes that should be hidden for serialization.
+     */
+    protected $hidden = [
+{{HIDDEN}}
+    ];
+
+    /**
+     * The accessors to append to the model's array form.
+     */
+    protected $appends = [
+{{APPENDS}}
+    ];
+
+    /**
+     * Get the attributes that should be cast.
+     */
+    protected function casts(): array
+    {
+        return [
+{{CASTS}}
+        ];
+    }
+
+{{RELATIONS}}
+}
+`,
+    "entity": `<?php
+
+namespace {{MODEL_NAMESPACE}};
+
+use {{BASE_MODEL_NAMESPACE}}\\{{CLASS_NAME}}BaseModel;
+use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
+
+/**
+ * {{CLASS_NAME}} Model
+ *
+ * This file is generated once and can be customized.
+ * Add your custom methods and logic here.
+ */
+class {{CLASS_NAME}} extends {{CLASS_NAME}}BaseModel
+{
+    use HasFactory;
+
+    /**
+     * Create a new model instance.
+     */
+    public function __construct(array $attributes = [])
+    {
+        parent::__construct($attributes);
+    }
+
+    // Add your custom methods here
+}
+`,
+    "service-provider": `<?php
+
+namespace App\\Providers;
+
+use Illuminate\\Database\\Eloquent\\Relations\\Relation;
+use Illuminate\\Support\\ServiceProvider;
+
+/**
+ * Omnify Service Provider
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * - Loads Omnify migrations from database/migrations/omnify
+ * - Registers morph map for polymorphic relationships
+ *
+ * @generated by @famgia/omnify-laravel
+ */
+class OmnifyServiceProvider extends ServiceProvider
+{
+    /**
+     * Register any application services.
+     */
+    public function register(): void
+    {
+        //
+    }
+
+    /**
+     * Bootstrap any application services.
+     */
+    public function boot(): void
+    {
+        // Load Omnify migrations from custom directory
+        $this->loadMigrationsFrom(database_path('migrations/omnify'));
+
+        // Register morph map for polymorphic relationships
+        Relation::enforceMorphMap([
+{{MORPH_MAP}}
+        ]);
+    }
+}
+`
+  };
+  return stubs[stubName] ?? "";
+}
+function generateServiceProvider(schemas, options, stubContent) {
+  const morphMap = Object.values(schemas).filter((s) => s.kind !== "enum").map((s) => {
+    const className = toPascalCase(s.name);
+    return `            '${s.name}' => \\${options.modelNamespace}\\${className}::class,`;
+  }).join("\n");
+  const content = stubContent.replace(/\{\{MORPH_MAP\}\}/g, morphMap);
+  return {
+    path: "app/Providers/OmnifyServiceProvider.php",
+    content,
+    type: "service-provider",
+    overwrite: true,
+    // Always overwrite to keep morph map in sync
+    schemaName: "__service_provider__"
+  };
+}
+function generateModels(schemas, options) {
+  const resolved = resolveOptions(options);
+  const models = [];
+  models.push(generateBaseModel(schemas, resolved, getStubContent("base-model")));
+  models.push(generateServiceProvider(schemas, resolved, getStubContent("service-provider")));
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") {
+      continue;
+    }
+    models.push(generateEntityBaseModel(
+      schema,
+      schemas,
+      resolved,
+      getStubContent("entity-base"),
+      getStubContent("entity-base-auth")
+    ));
+    models.push(generateEntityModel(schema, resolved, getStubContent("entity")));
+  }
+  return models;
+}
+function getModelPath(model) {
+  return model.path;
+}
+function generateProviderRegistration(existingContent, laravelVersion) {
+  const providerClass = "App\\Providers\\OmnifyServiceProvider::class";
+  const providerLine = `    ${providerClass},`;
+  if (existingContent && existingContent.includes("OmnifyServiceProvider")) {
+    return {
+      path: laravelVersion === "laravel11+" ? "bootstrap/providers.php" : "config/app.php",
+      content: existingContent,
+      laravelVersion,
+      alreadyRegistered: true
+    };
+  }
+  if (laravelVersion === "laravel11+") {
+    if (existingContent) {
+      const lines = existingContent.split("\n");
+      const result = [];
+      let inserted = false;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!inserted && line.trim() === "];") {
+          result.push(providerLine);
+          inserted = true;
+        }
+        result.push(line);
+      }
+      return {
+        path: "bootstrap/providers.php",
+        content: result.join("\n"),
+        laravelVersion,
+        alreadyRegistered: false
+      };
+    } else {
+      return {
+        path: "bootstrap/providers.php",
+        content: `<?php
+
+return [
+    App\\Providers\\AppServiceProvider::class,
+${providerLine}
+];
+`,
+        laravelVersion,
+        alreadyRegistered: false
+      };
+    }
+  } else {
+    if (existingContent) {
+      const providersSectionRegex = /'providers'\s*=>\s*\[[\s\S]*?\n(\s*)\]/m;
+      const match = existingContent.match(providersSectionRegex);
+      if (match) {
+        const providersStart = existingContent.indexOf("'providers'");
+        if (providersStart === -1) {
+          return null;
+        }
+        let depth = 0;
+        let foundStart = false;
+        let insertPos = -1;
+        for (let i = providersStart; i < existingContent.length; i++) {
+          const char = existingContent[i];
+          if (char === "[") {
+            foundStart = true;
+            depth++;
+          } else if (char === "]") {
+            depth--;
+            if (foundStart && depth === 0) {
+              insertPos = i;
+              break;
+            }
+          }
+        }
+        if (insertPos !== -1) {
+          const beforeClose = existingContent.substring(0, insertPos);
+          const lastNewline = beforeClose.lastIndexOf("\n");
+          const content = existingContent.substring(0, lastNewline + 1) + providerLine + "\n" + existingContent.substring(lastNewline + 1);
+          return {
+            path: "config/app.php",
+            content,
+            laravelVersion,
+            alreadyRegistered: false
+          };
+        }
+      }
+      return null;
+    } else {
+      return null;
+    }
+  }
+}
+
+// src/factory/generator.ts
+function resolveOptions2(options) {
+  return {
+    modelNamespace: options?.modelNamespace ?? "App\\Models",
+    factoryPath: options?.factoryPath ?? "database/factories",
+    fakerLocale: options?.fakerLocale ?? "en_US"
+  };
+}
+function getStubContent2() {
+  return `<?php
+
+namespace Database\\Factories;
+
+use {{MODEL_NAMESPACE}}\\{{MODEL_NAME}};
+use Illuminate\\Database\\Eloquent\\Factories\\Factory;
+{{IMPORTS}}
+
+/**
+ * @extends Factory<{{MODEL_NAME}}>
+ */
+class {{MODEL_NAME}}Factory extends Factory
+{
+    protected $model = {{MODEL_NAME}}::class;
+
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+{{ATTRIBUTES}}
+        ];
+    }
+}
+`;
+}
+function generateFakeData(propertyName, property, schema, schemas) {
+  const type = property.type;
+  if (["deleted_at", "created_at", "updated_at"].includes(propertyName)) {
+    return null;
+  }
+  if (type === "Association") {
+    return null;
+  }
+  switch (type) {
+    case "String":
+      return generateStringFake(propertyName, property);
+    case "Email":
+      return `'${propertyName}' => fake()->unique()->safeEmail(),`;
+    case "Password":
+      return `'${propertyName}' => bcrypt('password'),`;
+    case "Int":
+    case "BigInt":
+      return generateIntFake(propertyName, property);
+    case "Float":
+    case "Decimal":
+      return `'${propertyName}' => fake()->randomFloat(2, 1, 10000),`;
+    case "Boolean":
+      return `'${propertyName}' => fake()->boolean(),`;
+    case "Text":
+      return `'${propertyName}' => fake()->paragraphs(3, true),`;
+    case "LongText":
+      return `'${propertyName}' => fake()->paragraphs(5, true),`;
+    case "Date":
+      return `'${propertyName}' => fake()->date(),`;
+    case "Time":
+      return `'${propertyName}' => fake()->time(),`;
+    case "Timestamp":
+    case "DateTime":
+      return `'${propertyName}' => fake()->dateTime(),`;
+    case "Json":
+      return `'${propertyName}' => [],`;
+    case "Enum":
+      return generateEnumFake(propertyName, property);
+    case "EnumRef":
+      return generateEnumRefFake(propertyName, property, schemas);
+    default:
+      return `'${propertyName}' => fake()->sentence(),`;
+  }
+}
+function generateStringFake(propertyName, property) {
+  if (propertyName === "slug") {
+    return `'${propertyName}' => fake()->unique()->slug(),`;
+  }
+  if (propertyName === "uuid" || propertyName === "uid") {
+    return `'${propertyName}' => (string) \\Illuminate\\Support\\Str::uuid(),`;
+  }
+  if (propertyName.includes("email")) {
+    return `'${propertyName}' => fake()->unique()->safeEmail(),`;
+  }
+  if (propertyName.includes("phone")) {
+    return `'${propertyName}' => fake()->phoneNumber(),`;
+  }
+  if (propertyName.includes("image") || propertyName.includes("photo") || propertyName.includes("avatar")) {
+    return `'${propertyName}' => fake()->imageUrl(),`;
+  }
+  if (propertyName.includes("url") || propertyName.includes("website")) {
+    return `'${propertyName}' => fake()->url(),`;
+  }
+  if (propertyName.includes("path") || propertyName.includes("file")) {
+    return `'${propertyName}' => 'uploads/' . fake()->uuid() . '.jpg',`;
+  }
+  if (propertyName === "name" || propertyName === "title") {
+    return `'${propertyName}' => fake()->sentence(3),`;
+  }
+  if (propertyName.includes("name")) {
+    return `'${propertyName}' => fake()->name(),`;
+  }
+  if (propertyName.includes("address")) {
+    return `'${propertyName}' => fake()->address(),`;
+  }
+  if (propertyName.includes("city")) {
+    return `'${propertyName}' => fake()->city(),`;
+  }
+  if (propertyName.includes("country")) {
+    return `'${propertyName}' => fake()->country(),`;
+  }
+  if (propertyName.includes("zip") || propertyName.includes("postal")) {
+    return `'${propertyName}' => fake()->postcode(),`;
+  }
+  if (propertyName.includes("color")) {
+    return `'${propertyName}' => fake()->hexColor(),`;
+  }
+  if (propertyName.includes("token") || propertyName.includes("secret") || propertyName.includes("key")) {
+    return `'${propertyName}' => \\Illuminate\\Support\\Str::random(32),`;
+  }
+  if (propertyName.includes("code")) {
+    return `'${propertyName}' => fake()->unique()->regexify('[A-Z0-9]{8}'),`;
+  }
+  const length = property.length;
+  if (length && length <= 50) {
+    return `'${propertyName}' => fake()->words(3, true),`;
+  }
+  return `'${propertyName}' => fake()->sentence(),`;
+}
+function generateIntFake(propertyName, property) {
+  if (propertyName.includes("count") || propertyName.includes("quantity")) {
+    return `'${propertyName}' => fake()->numberBetween(0, 100),`;
+  }
+  if (propertyName.includes("price") || propertyName.includes("amount") || propertyName.includes("cost")) {
+    return `'${propertyName}' => fake()->numberBetween(100, 10000),`;
+  }
+  if (propertyName.includes("order") || propertyName.includes("sort") || propertyName.includes("position")) {
+    return `'${propertyName}' => fake()->numberBetween(1, 100),`;
+  }
+  if (propertyName.includes("age")) {
+    return `'${propertyName}' => fake()->numberBetween(18, 80),`;
+  }
+  if (propertyName.includes("year")) {
+    return `'${propertyName}' => fake()->year(),`;
+  }
+  return `'${propertyName}' => fake()->numberBetween(1, 1000),`;
+}
+function generateEnumFake(propertyName, property) {
+  const enumValues = property.enum;
+  if (!enumValues || enumValues.length === 0) {
+    return `'${propertyName}' => null,`;
+  }
+  const values = enumValues.map((v) => typeof v === "string" ? v : v.value);
+  const valuesStr = values.map((v) => `'${v}'`).join(", ");
+  return `'${propertyName}' => fake()->randomElement([${valuesStr}]),`;
+}
+function generateEnumRefFake(propertyName, property, schemas) {
+  const enumName = property.enum;
+  if (!enumName) {
+    return `'${propertyName}' => null,`;
+  }
+  const enumSchema = schemas[enumName];
+  if (!enumSchema || enumSchema.kind !== "enum" || !enumSchema.values) {
+    return `'${propertyName}' => null,`;
+  }
+  const valuesStr = enumSchema.values.map((v) => `'${v}'`).join(", ");
+  return `'${propertyName}' => fake()->randomElement([${valuesStr}]),`;
+}
+function generateAssociationFake(propertyName, property, schema, schemas, modelNamespace) {
+  if (property.type !== "Association") {
+    return null;
+  }
+  const relation = property.relation;
+  const target = property.target;
+  if (relation !== "ManyToOne" || !target) {
+    return null;
+  }
+  const foreignKey = `${toSnakeCase(propertyName)}_id`;
+  const isNullable2 = property.nullable ?? false;
+  const targetSchema = schemas[target];
+  if (!targetSchema) {
+    return null;
+  }
+  let fake;
+  if (isNullable2) {
+    fake = `'${foreignKey}' => ${target}::query()->inRandomOrder()->first()?->id,`;
+  } else {
+    fake = `'${foreignKey}' => ${target}::query()->inRandomOrder()->first()?->id ?? ${target}::factory()->create()->id,`;
+  }
+  let importStatement;
+  if (target !== schema.name) {
+    importStatement = `use ${modelNamespace}\\${target};`;
+  }
+  return { fake, import: importStatement };
+}
+function generateFactory(schema, schemas, options, stubContent) {
+  if (schema.kind === "enum") {
+    return null;
+  }
+  const modelName = toPascalCase(schema.name);
+  const factoryName = `${modelName}Factory`;
+  const attributes = [];
+  const imports = [];
+  if (schema.properties) {
+    for (const [propName, prop] of Object.entries(schema.properties)) {
+      if (prop.type === "Association") {
+        const assocResult = generateAssociationFake(propName, prop, schema, schemas, options.modelNamespace);
+        if (assocResult) {
+          attributes.push(assocResult.fake);
+          if (assocResult.import) {
+            imports.push(assocResult.import);
+          }
+        }
+        continue;
+      }
+      const fake = generateFakeData(propName, prop, schema, schemas);
+      if (fake) {
+        attributes.push(fake);
+      }
+    }
+  }
+  let content = stubContent;
+  content = content.replace(/\{\{MODEL_NAMESPACE\}\}/g, options.modelNamespace);
+  content = content.replace(/\{\{MODEL_NAME\}\}/g, modelName);
+  const uniqueImports = [...new Set(imports)];
+  const importsStr = uniqueImports.length > 0 ? "\n" + uniqueImports.join("\n") : "";
+  content = content.replace(/\{\{IMPORTS\}\}/g, importsStr);
+  const attributesStr = attributes.length > 0 ? attributes.map((a) => `            ${a}`).join("\n") : "";
+  content = content.replace(/\{\{ATTRIBUTES\}\}/g, attributesStr);
+  return {
+    name: factoryName,
+    schemaName: schema.name,
+    path: `${options.factoryPath}/${factoryName}.php`,
+    content,
+    overwrite: false
+    // Factories should not overwrite existing files
+  };
+}
+function generateFactories(schemas, options) {
+  const resolved = resolveOptions2(options);
+  const stubContent = getStubContent2();
+  const factories = [];
+  for (const schema of Object.values(schemas)) {
+    const factory = generateFactory(schema, schemas, resolved, stubContent);
+    if (factory) {
+      factories.push(factory);
+    }
+  }
+  return factories;
+}
+function getFactoryPath(factory) {
+  return factory.path;
+}
+
+// src/plugin.ts
+var LARAVEL_CONFIG_SCHEMA = {
+  fields: [
+    {
+      key: "migrationsPath",
+      type: "path",
+      label: "Migrations Path",
+      description: "Directory for Laravel migration files (loaded via OmnifyServiceProvider)",
+      default: "database/migrations/omnify",
+      group: "output"
+    },
+    {
+      key: "modelsPath",
+      type: "path",
+      label: "Models Path",
+      description: "Directory for user-editable model files",
+      default: "app/Models",
+      group: "output"
+    },
+    {
+      key: "baseModelsPath",
+      type: "path",
+      label: "Base Models Path",
+      description: "Directory for auto-generated base model files",
+      default: "app/Models/OmnifyBase",
+      group: "output"
+    },
+    {
+      key: "generateModels",
+      type: "boolean",
+      label: "Generate Models",
+      description: "Generate Eloquent model classes",
+      default: true,
+      group: "options"
+    },
+    {
+      key: "factoriesPath",
+      type: "path",
+      label: "Factories Path",
+      description: "Directory for Laravel factory files",
+      default: "database/factories",
+      group: "output"
+    },
+    {
+      key: "generateFactories",
+      type: "boolean",
+      label: "Generate Factories",
+      description: "Generate Laravel factory classes for testing",
+      default: true,
+      group: "options"
+    },
+    {
+      key: "connection",
+      type: "string",
+      label: "Database Connection",
+      description: "Laravel database connection name (optional)",
+      placeholder: "mysql",
+      group: "options"
+    }
+  ]
+};
+function resolveOptions3(options) {
+  return {
+    migrationsPath: options?.migrationsPath ?? "database/migrations/omnify",
+    modelsPath: options?.modelsPath ?? "app/Models",
+    baseModelsPath: options?.baseModelsPath ?? "app/Models/OmnifyBase",
+    modelNamespace: options?.modelNamespace ?? "App\\Models",
+    baseModelNamespace: options?.baseModelNamespace ?? "App\\Models\\OmnifyBase",
+    generateModels: options?.generateModels ?? true,
+    factoriesPath: options?.factoriesPath ?? "database/factories",
+    generateFactories: options?.generateFactories ?? true,
+    fakerLocale: options?.fakerLocale ?? "en_US",
+    connection: options?.connection,
+    timestamp: options?.timestamp
+  };
+}
+function laravelPlugin(options) {
+  const resolved = resolveOptions3(options);
+  const migrationGenerator = {
+    name: "laravel-migrations",
+    description: "Generate Laravel migration files",
+    generate: async (ctx) => {
+      const migrationOptions = {
+        connection: resolved.connection,
+        timestamp: resolved.timestamp
+      };
+      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 modelGenerator = {
+    name: "laravel-models",
+    description: "Generate Eloquent model classes",
+    generate: async (ctx) => {
+      const modelOptions = {
+        modelNamespace: resolved.modelNamespace,
+        baseModelNamespace: resolved.baseModelNamespace,
+        modelPath: resolved.modelsPath,
+        baseModelPath: resolved.baseModelsPath
+      };
+      const models = generateModels(ctx.schemas, modelOptions);
+      const outputs = models.map((model) => ({
+        path: getModelPath(model),
+        content: model.content,
+        type: "model",
+        // Skip writing user models if they already exist
+        skipIfExists: !model.overwrite,
+        metadata: {
+          modelType: model.type,
+          schemaName: model.schemaName
+        }
+      }));
+      const bootstrapProvidersPath = join(ctx.cwd, "bootstrap/providers.php");
+      const configAppPath = join(ctx.cwd, "config/app.php");
+      let existingContent = null;
+      let laravelVersion;
+      if (existsSync(bootstrapProvidersPath)) {
+        laravelVersion = "laravel11+";
+        try {
+          existingContent = readFileSync(bootstrapProvidersPath, "utf-8");
+        } catch {
+          existingContent = null;
+        }
+      } else if (existsSync(configAppPath)) {
+        laravelVersion = "laravel10-";
+        try {
+          existingContent = readFileSync(configAppPath, "utf-8");
+        } catch {
+          existingContent = null;
+        }
+      } else {
+        laravelVersion = "laravel11+";
+      }
+      const registration = generateProviderRegistration(existingContent, laravelVersion);
+      if (registration && !registration.alreadyRegistered) {
+        outputs.push({
+          path: registration.path,
+          content: registration.content,
+          type: "other",
+          skipIfExists: false,
+          // We want to modify the file
+          metadata: {
+            registrationType: "provider-registration",
+            laravelVersion: registration.laravelVersion
+          }
+        });
+        ctx.logger.info(`OmnifyServiceProvider will be registered in ${registration.path}`);
+      } else if (registration?.alreadyRegistered) {
+        ctx.logger.info("OmnifyServiceProvider is already registered");
+      }
+      return outputs;
+    }
+  };
+  const factoryGenerator = {
+    name: "laravel-factories",
+    description: "Generate Laravel factory classes for testing",
+    generate: async (ctx) => {
+      const factoryOptions = {
+        modelNamespace: resolved.modelNamespace,
+        factoryPath: resolved.factoriesPath,
+        fakerLocale: resolved.fakerLocale
+      };
+      const factories = generateFactories(ctx.schemas, factoryOptions);
+      return factories.map((factory) => ({
+        path: getFactoryPath(factory),
+        content: factory.content,
+        type: "factory",
+        // Skip writing factories if they already exist (allow customization)
+        skipIfExists: !factory.overwrite,
+        metadata: {
+          factoryName: factory.name,
+          schemaName: factory.schemaName
+        }
+      }));
+    }
+  };
+  const generators = [migrationGenerator];
+  if (resolved.generateModels) {
+    generators.push(modelGenerator);
+  }
+  if (resolved.generateFactories) {
+    generators.push(factoryGenerator);
+  }
+  return {
+    name: "@famgia/omnify-laravel",
+    version: "0.0.14",
+    configSchema: LARAVEL_CONFIG_SCHEMA,
+    generators
+  };
+}
+
+export {
+  toColumnName,
+  toTableName,
+  propertyToColumnMethod,
+  generatePrimaryKeyColumn,
+  generateTimestampColumns,
+  generateSoftDeleteColumn,
+  generateForeignKey,
+  schemaToBlueprint,
+  formatColumnMethod,
+  formatForeignKey,
+  formatIndex,
+  generateMigrations,
+  generateMigrationFromSchema,
+  generateDropMigrationForTable,
+  formatMigrationFile,
+  getMigrationPath,
+  generateAlterMigration,
+  generateDropTableMigration,
+  generateMigrationsFromChanges,
+  laravelPlugin
+};
+//# sourceMappingURL=chunk-REDFZUQY.js.map