@famgia/omnify-laravel 0.0.13 → 0.0.15

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" });
@@ -293,11 +294,18 @@ function schemaToBlueprint(schema, allSchemas) {
   }
   if (schema.options?.indexes) {
     for (const index of schema.options.indexes) {
-      indexes.push({
-        name: index.name,
-        columns: index.columns.map(toColumnName),
-        unique: index.unique ?? false
-      });
+      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) {
@@ -334,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})`;
@@ -441,6 +455,7 @@ function generatePivotTableBlueprint(pivot) {
     args: [pivot.targetColumn],
     modifiers: []
   });
+  columns.push(...generateTimestampColumns());
   foreignKeys.push({
     columns: [pivot.sourceColumn],
     references: "id",
@@ -684,6 +699,1016 @@ function getMigrationPath(migration, outputDir = "database/migrations") {
   return `${outputDir}/${migration.fileName}`;
 }
 
+// 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: [
@@ -691,10 +1716,50 @@ 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"
+    },
+    {
+      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",
@@ -705,41 +1770,141 @@ var LARAVEL_CONFIG_SCHEMA = {
     }
   ]
 };
-function resolveOptions(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 = resolveOptions(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 = (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.13",
+    version: "0.0.14",
     configSchema: LARAVEL_CONFIG_SCHEMA,
-    generators: [
-      {
-        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
-            }
-          }));
-        }
-      }
-    ]
+    generators
   };
 }
 // Annotate the CommonJS export names for ESM import in node: