@famgia/omnify-laravel 0.0.14 → 0.0.15

package/dist/index.js

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

package/dist/plugin.cjs

@@ -24,6 +24,8 @@ __export(plugin_exports, {
   laravelPlugin: () => laravelPlugin
 });
 module.exports = __toCommonJS(plugin_exports);
+var import_node_fs = require("fs");
+var import_node_path = require("path");
 
 // src/migration/schema-builder.ts
 var TYPE_METHOD_MAP = {
@@ -103,9 +105,8 @@ function propertyToColumnMethod(propertyName, property) {
   if (baseProp.unique) {
     modifiers.push({ method: "unique" });
   }
-  if (baseProp.default !== void 0) {
-    const defaultValue = typeof baseProp.default === "string" ? baseProp.default : JSON.stringify(baseProp.default);
-    modifiers.push({ method: "default", args: [defaultValue] });
+  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" });
@@ -341,6 +342,12 @@ function formatColumnMethod(column) {
         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})`;
@@ -448,6 +455,7 @@ function generatePivotTableBlueprint(pivot) {
     args: [pivot.targetColumn],
     modifiers: []
   });
+  columns.push(...generateTimestampColumns());
   foreignKeys.push({
     columns: [pivot.sourceColumn],
     references: "id",
@@ -846,7 +854,7 @@ function generateEntityBaseModel(schema, schemas, options, stubContent, authStub
       if (assoc.target) {
         imports.push(`use ${options.modelNamespace}\\${toPascalCase(assoc.target)};`);
       }
-      relations.push(generateRelation(propName, assoc, options));
+      relations.push(generateRelation(propName, assoc, schema, schemas, options));
       if (assoc.relation === "ManyToOne" || assoc.relation === "OneToOne") {
         if (!assoc.mappedBy) {
           const fkName = toSnakeCase(propName) + "_id";
@@ -903,7 +911,22 @@ ${docProperties.join("\n")}
     schemaName: schema.name
   };
 }
-function generateRelation(propName, assoc, options) {
+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";
@@ -933,14 +956,28 @@ function generateRelation(propName, assoc, options) {
     {
         return $this->belongsTo(${targetClass}::class, '${fkName}');
     }`;
-    case "OneToMany":
+    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, '${toSnakeCase(assoc.inversedBy ?? propName)}_id');
+        return $this->hasMany(${targetClass}::class, '${foreignKey}');
     }`;
+    }
     case "ManyToMany": {
       const pivotTable = assoc.joinTable ?? `${toSnakeCase(propName)}_pivot`;
       return `    /**
@@ -1237,14 +1274,73 @@ class {{CLASS_NAME}} extends {{CLASS_NAME}}BaseModel
 
     // 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;
@@ -1263,6 +1359,355 @@ function generateModels(schemas, options) {
 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 = {
@@ -1271,8 +1716,8 @@ var LARAVEL_CONFIG_SCHEMA = {
       key: "migrationsPath",
       type: "path",
       label: "Migrations Path",
-      description: "Directory for Laravel migration files",
-      default: "database/migrations",
+      description: "Directory for Laravel migration files (loaded via OmnifyServiceProvider)",
+      default: "database/migrations/omnify",
       group: "output"
     },
     {
@@ -1299,6 +1744,22 @@ var LARAVEL_CONFIG_SCHEMA = {
       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",
@@ -1309,20 +1770,23 @@ var LARAVEL_CONFIG_SCHEMA = {
     }
   ]
 };
-function resolveOptions2(options) {
+function resolveOptions3(options) {
   return {
-    migrationsPath: options?.migrationsPath ?? "database/migrations",
+    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 = resolveOptions2(options);
+  const resolved = resolveOptions3(options);
   const migrationGenerator = {
     name: "laravel-migrations",
     description: "Generate Laravel migration files",
@@ -1354,7 +1818,7 @@ function laravelPlugin(options) {
         baseModelPath: resolved.baseModelsPath
       };
       const models = generateModels(ctx.schemas, modelOptions);
-      return models.map((model) => ({
+      const outputs = models.map((model) => ({
         path: getModelPath(model),
         content: model.content,
         type: "model",
@@ -1365,13 +1829,82 @@ function laravelPlugin(options) {
           schemaName: model.schemaName
         }
       }));
+      const bootstrapProvidersPath = (0, import_node_path.join)(ctx.cwd, "bootstrap/providers.php");
+      const configAppPath = (0, import_node_path.join)(ctx.cwd, "config/app.php");
+      let existingContent = null;
+      let laravelVersion;
+      if ((0, import_node_fs.existsSync)(bootstrapProvidersPath)) {
+        laravelVersion = "laravel11+";
+        try {
+          existingContent = (0, import_node_fs.readFileSync)(bootstrapProvidersPath, "utf-8");
+        } catch {
+          existingContent = null;
+        }
+      } else if ((0, import_node_fs.existsSync)(configAppPath)) {
+        laravelVersion = "laravel10-";
+        try {
+          existingContent = (0, import_node_fs.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: resolved.generateModels ? [migrationGenerator, modelGenerator] : [migrationGenerator]
+    generators
   };
 }
 // Annotate the CommonJS export names for ESM import in node: