@famgia/omnify-laravel 0.0.12 → 0.0.14

package/dist/{chunk-2JWTIYRL.js → chunk-UVF7W2J2.js}

@@ -266,11 +266,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) {
@@ -988,503 +995,611 @@ function generateMigrationsFromChanges(changes, options = {}) {
   return migrations;
 }
 
-// src/typescript/interface-generator.ts
-var TYPE_MAP = {
-  String: "string",
-  Int: "number",
-  BigInt: "number",
-  Float: "number",
-  Boolean: "boolean",
-  Text: "string",
-  LongText: "string",
-  Date: "string",
-  Time: "string",
-  Timestamp: "string",
-  Json: "unknown",
-  Email: "string",
-  Password: "string",
-  Enum: "string",
-  Select: "string",
-  Lookup: "number"
-};
-var FILE_INTERFACE_NAME = "File";
-var PK_TYPE_MAP = {
-  Int: "number",
-  BigInt: "number",
-  Uuid: "string",
-  String: "string"
-};
-function toPropertyName(name) {
-  return name;
+// src/utils.ts
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").replace(/^_/, "").toLowerCase();
 }
-function toInterfaceName(schemaName) {
-  return schemaName;
+function toPascalCase(str) {
+  return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase());
 }
-function getPropertyType(property, _allSchemas) {
-  if (property.type === "File") {
-    const fileProp = property;
-    if (fileProp.multiple) {
-      return `${FILE_INTERFACE_NAME}[]`;
-    }
-    return `${FILE_INTERFACE_NAME} | null`;
-  }
-  if (property.type === "Association") {
-    const assocProp = property;
-    const targetName = assocProp.target ?? "unknown";
-    switch (assocProp.relation) {
-      // Standard relations
-      case "OneToOne":
-      case "ManyToOne":
-        return targetName;
-      case "OneToMany":
-      case "ManyToMany":
-        return `${targetName}[]`;
-      // Polymorphic relations
-      case "MorphTo":
-        if (assocProp.targets && assocProp.targets.length > 0) {
-          return assocProp.targets.join(" | ");
-        }
-        return "unknown";
-      case "MorphOne":
-        return targetName;
-      case "MorphMany":
-      case "MorphToMany":
-      case "MorphedByMany":
-        return `${targetName}[]`;
-      default:
-        return "unknown";
-    }
-  }
-  if (property.type === "Enum") {
-    const enumProp = property;
-    if (typeof enumProp.enum === "string") {
-      return enumProp.enum;
-    }
-    if (Array.isArray(enumProp.enum)) {
-      return enumProp.enum.map((v) => `'${v}'`).join(" | ");
-    }
+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 (property.type === "Select") {
-    const selectProp = property;
-    if (selectProp.options && selectProp.options.length > 0) {
-      return selectProp.options.map((v) => `'${v}'`).join(" | ");
-    }
+  if (word.endsWith("s") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ch") || word.endsWith("sh")) {
+    return word + "es";
   }
-  return TYPE_MAP[property.type] ?? "unknown";
+  return word + "s";
 }
-function propertyToTSProperties(propertyName, property, allSchemas, options = {}) {
-  const baseProp = property;
-  const isReadonly = options.readonly ?? true;
-  if (property.type === "Association") {
-    const assocProp = property;
-    if (assocProp.relation === "MorphTo" && assocProp.targets && assocProp.targets.length > 0) {
-      const propBaseName = toPropertyName(propertyName);
-      const targetUnion = assocProp.targets.map((t) => `'${t}'`).join(" | ");
-      const relationUnion = assocProp.targets.join(" | ");
-      return [
-        {
-          name: `${propBaseName}Type`,
-          type: targetUnion,
-          optional: true,
-          // Polymorphic columns are nullable
-          readonly: isReadonly,
-          comment: `Polymorphic type for ${propertyName}`
-        },
-        {
-          name: `${propBaseName}Id`,
-          type: "number",
-          optional: true,
-          readonly: isReadonly,
-          comment: `Polymorphic ID for ${propertyName}`
-        },
-        {
-          name: propBaseName,
-          type: `${relationUnion} | null`,
-          optional: true,
-          readonly: isReadonly,
-          comment: baseProp.displayName ?? `Polymorphic relation to ${assocProp.targets.join(", ")}`
+
+// 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";
         }
-      ];
-    }
-  }
-  const type = getPropertyType(property, allSchemas);
-  return [{
-    name: toPropertyName(propertyName),
-    type,
-    optional: baseProp.nullable ?? false,
-    readonly: isReadonly,
-    comment: baseProp.displayName
-  }];
-}
-function propertyToTSProperty(propertyName, property, allSchemas, options = {}) {
-  return propertyToTSProperties(propertyName, property, allSchemas, options)[0];
-}
-function schemaToInterface(schema, allSchemas, options = {}) {
-  const properties = [];
-  if (schema.options?.id !== false) {
-    const pkType = schema.options?.idType ?? "BigInt";
-    properties.push({
-      name: "id",
-      type: PK_TYPE_MAP[pkType] ?? "number",
-      optional: false,
-      readonly: options.readonly ?? true,
-      comment: "Primary key"
-    });
-  }
-  if (schema.properties) {
-    for (const [propName, property] of Object.entries(schema.properties)) {
-      properties.push(...propertyToTSProperties(propName, property, allSchemas, options));
-    }
-  }
-  if (schema.options?.timestamps !== false) {
-    properties.push(
-      {
-        name: "createdAt",
-        type: "string",
-        optional: true,
-        readonly: options.readonly ?? true,
-        comment: "Creation timestamp"
-      },
-      {
-        name: "updatedAt",
-        type: "string",
-        optional: true,
-        readonly: options.readonly ?? true,
-        comment: "Last update timestamp"
       }
-    );
-  }
-  if (schema.options?.softDelete) {
-    properties.push({
-      name: "deletedAt",
-      type: "string",
-      optional: true,
-      readonly: options.readonly ?? true,
-      comment: "Soft delete timestamp"
-    });
+      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 {
-    name: toInterfaceName(schema.name),
-    properties,
-    comment: schema.displayName ?? schema.name
+    path: `${options.baseModelPath}/${options.baseModelClassName}.php`,
+    content,
+    type: "base-model",
+    overwrite: true,
+    schemaName: "__base__"
   };
 }
-function formatProperty(property) {
-  const readonly = property.readonly ? "readonly " : "";
-  const optional = property.optional ? "?" : "";
-  const comment = property.comment ? `  /** ${property.comment} */
-` : "";
-  return `${comment}  ${readonly}${property.name}${optional}: ${property.type};`;
-}
-function formatInterface(iface) {
-  const comment = iface.comment ? `/**
- * ${iface.comment}
- */
-` : "";
-  const extendsClause = iface.extends && iface.extends.length > 0 ? ` extends ${iface.extends.join(", ")}` : "";
-  const properties = iface.properties.map(formatProperty).join("\n");
-  return `${comment}export interface ${iface.name}${extendsClause} {
-${properties}
-}`;
-}
-function generateInterfaces(schemas, options = {}) {
-  const interfaces = [];
-  for (const schema of Object.values(schemas)) {
-    if (schema.kind === "enum") {
-      continue;
+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, 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}',`);
+      }
     }
-    interfaces.push(schemaToInterface(schema, schemas, options));
   }
-  return interfaces;
-}
+  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';
 
-// src/typescript/enum-generator.ts
-function toEnumMemberName(value) {
-  return value.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-function toEnumName(schemaName) {
-  return schemaName;
-}
-function schemaToEnum(schema) {
-  if (schema.kind !== "enum" || !schema.values) {
-    return null;
+` : "";
+  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 values = schema.values.map((value) => ({
-    name: toEnumMemberName(value),
-    value
-  }));
+  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 {
-    name: toEnumName(schema.name),
-    values,
-    comment: schema.displayName ?? schema.name
+    path: `${options.baseModelPath}/${className}BaseModel.php`,
+    content,
+    type: "entity-base",
+    overwrite: true,
+    schemaName: schema.name
   };
 }
-function generateEnums(schemas) {
-  const enums = [];
-  for (const schema of Object.values(schemas)) {
-    if (schema.kind === "enum") {
-      const enumDef = schemaToEnum(schema);
-      if (enumDef) {
-        enums.push(enumDef);
+function generateRelation(propName, assoc, 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":
+      return `    /**
+     * Get the ${propName} for this model.
+     */
+    public function ${methodName}(): HasMany
+    {
+        return $this->hasMany(${targetClass}::class, '${toSnakeCase(assoc.inversedBy ?? propName)}_id');
+    }`;
+    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();
+    }`;
     }
-  }
-  return enums;
-}
-function formatEnum(enumDef) {
-  const comment = enumDef.comment ? `/**
- * ${enumDef.comment}
- */
-` : "";
-  const values = enumDef.values.map((v) => `  ${v.name} = '${v.value}',`).join("\n");
-  return `${comment}export enum ${enumDef.name} {
-${values}
-}`;
+    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 enumToUnionType(enumDef) {
-  const type = enumDef.values.map((v) => `'${v.value}'`).join(" | ");
+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 {
-    name: enumDef.name,
-    type,
-    comment: enumDef.comment
+    path: `${options.modelPath}/${className}.php`,
+    content,
+    type: "entity",
+    overwrite: false,
+    // Never overwrite user models
+    schemaName: schema.name
   };
 }
-function formatTypeAlias(alias) {
-  const comment = alias.comment ? `/**
- * ${alias.comment}
+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
  */
-` : "";
-  return `${comment}export type ${alias.name} = ${alias.type};`;
-}
-function extractInlineEnums(schemas) {
-  const typeAliases = [];
-  for (const schema of Object.values(schemas)) {
-    if (schema.kind === "enum" || !schema.properties) {
-      continue;
+
+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);
     }
-    for (const [propName, property] of Object.entries(schema.properties)) {
-      if (property.type === "Enum") {
-        const enumProp = property;
-        if (Array.isArray(enumProp.enum) && enumProp.enum.length > 0) {
-          const typeName = `${schema.name}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
-          typeAliases.push({
-            name: typeName,
-            type: enumProp.enum.map((v) => `'${v}'`).join(" | "),
-            comment: enumProp.displayName ?? `${schema.name} ${propName} enum`
-          });
-        }
-      }
-      if (property.type === "Select") {
-        const selectProp = property;
-        if (selectProp.options && selectProp.options.length > 0) {
-          const typeName = `${schema.name}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
-          typeAliases.push({
-            name: typeName,
-            type: selectProp.options.map((v) => `'${v}'`).join(" | "),
-            comment: selectProp.displayName ?? `${schema.name} ${propName} options`
-          });
-        }
-      }
+
+    /**
+     * Get the model class for a given morph type.
+     */
+    public static function getModelClass(string $morphType): ?string
+    {
+        return static::$modelMap[$morphType] ?? null;
     }
-  }
-  return typeAliases;
 }
+`,
+    "entity-base": `<?php
 
-// src/typescript/generator.ts
-var DEFAULT_OPTIONS = {
-  singleFile: true,
-  fileName: "types.ts",
-  readonly: true,
-  strictNullChecks: true
-};
-function generateHeader() {
-  return `/**
- * Auto-generated TypeScript types from Omnify schemas.
- * DO NOT EDIT - This file is automatically generated.
+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
  */
 
-`;
-}
-function generateTypeScriptFile(schemas, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const parts = [generateHeader()];
-  const types = [];
-  const enums = generateEnums(schemas);
-  if (enums.length > 0) {
-    parts.push("// Enums\n");
-    for (const enumDef of enums) {
-      parts.push(formatEnum(enumDef));
-      parts.push("\n\n");
-      types.push(enumDef.name);
-    }
-  }
-  const inlineEnums = extractInlineEnums(schemas);
-  if (inlineEnums.length > 0) {
-    parts.push("// Type Aliases\n");
-    for (const alias of inlineEnums) {
-      parts.push(formatTypeAlias(alias));
-      parts.push("\n\n");
-      types.push(alias.name);
-    }
-  }
-  const interfaces = generateInterfaces(schemas, opts);
-  if (interfaces.length > 0) {
-    parts.push("// Interfaces\n");
-    for (const iface of interfaces) {
-      parts.push(formatInterface(iface));
-      parts.push("\n\n");
-      types.push(iface.name);
+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}}
+        ];
     }
-  }
-  return {
-    fileName: opts.fileName ?? "types.ts",
-    content: parts.join("").trim() + "\n",
-    types
-  };
+
+{{RELATIONS}}
 }
-function generateTypeScriptFiles(schemas, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const files = [];
-  const enums = generateEnums(schemas);
-  if (enums.length > 0) {
-    const content = generateHeader() + enums.map(formatEnum).join("\n\n") + "\n";
-    files.push({
-      fileName: "enums.ts",
-      content,
-      types: enums.map((e) => e.name)
-    });
-  }
-  const inlineEnums = extractInlineEnums(schemas);
-  if (inlineEnums.length > 0) {
-    const content = generateHeader() + inlineEnums.map(formatTypeAlias).join("\n\n") + "\n";
-    files.push({
-      fileName: "type-aliases.ts",
-      content,
-      types: inlineEnums.map((a) => a.name)
-    });
-  }
-  const interfaces = generateInterfaces(schemas, opts);
-  for (const iface of interfaces) {
-    const imports = collectImports(iface, enums, inlineEnums, interfaces);
-    const importStatement = formatImports(imports);
-    const content = generateHeader() + (importStatement ? importStatement + "\n\n" : "") + formatInterface(iface) + "\n";
-    files.push({
-      fileName: `${toKebabCase(iface.name)}.ts`,
-      content,
-      types: [iface.name]
-    });
-  }
-  const indexContent = generateIndexFile(files);
-  files.push({
-    fileName: "index.ts",
-    content: indexContent,
-    types: []
-  });
-  return files;
-}
-function toKebabCase(name) {
-  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-}
-function collectImports(iface, enums, typeAliases, allInterfaces) {
-  const imports = /* @__PURE__ */ new Map();
-  const enumNames = new Set(enums.map((e) => e.name));
-  const aliasNames = new Set(typeAliases.map((a) => a.name));
-  const interfaceNames = new Set(allInterfaces.map((i) => i.name));
-  for (const prop of iface.properties) {
-    if (enumNames.has(prop.type)) {
-      const existing = imports.get("./enums.js") ?? [];
-      if (!existing.includes(prop.type)) {
-        imports.set("./enums.js", [...existing, prop.type]);
-      }
-    }
-    if (aliasNames.has(prop.type)) {
-      const existing = imports.get("./type-aliases.js") ?? [];
-      if (!existing.includes(prop.type)) {
-        imports.set("./type-aliases.js", [...existing, prop.type]);
-      }
-    }
-    const baseType = prop.type.replace("[]", "");
-    if (interfaceNames.has(baseType) && baseType !== iface.name) {
-      const fileName = `./${toKebabCase(baseType)}.js`;
-      const existing = imports.get(fileName) ?? [];
-      if (!existing.includes(baseType)) {
-        imports.set(fileName, [...existing, baseType]);
-      }
+`,
+    "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}}
+        ];
     }
-  }
-  return imports;
+
+{{RELATIONS}}
 }
-function formatImports(imports) {
-  if (imports.size === 0) return "";
-  const lines = [];
-  for (const [path, names] of imports) {
-    lines.push(`import type { ${names.join(", ")} } from '${path}';`);
-  }
-  return lines.join("\n");
+`,
+    "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
 }
-function generateIndexFile(files) {
-  const exports = [generateHeader().trim(), ""];
-  for (const file of files) {
-    if (file.fileName === "index.ts") continue;
-    const moduleName = file.fileName.replace(".ts", ".js");
-    exports.push(`export * from './${moduleName}';`);
-  }
-  return exports.join("\n") + "\n";
+`
+  };
+  return stubs[stubName] ?? "";
 }
-function generateTypeScript(schemas, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  if (opts.singleFile) {
-    return [generateTypeScriptFile(schemas, opts)];
+function generateModels(schemas, options) {
+  const resolved = resolveOptions(options);
+  const models = [];
+  models.push(generateBaseModel(schemas, resolved, getStubContent("base-model")));
+  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 generateTypeScriptFiles(schemas, opts);
+  return models;
 }
-function getTypeScriptPath(file, outputDir = "src/types") {
-  return `${outputDir}/${file.fileName}`;
+function getModelPath(model) {
+  return model.path;
 }
 
 // src/plugin.ts
 var LARAVEL_CONFIG_SCHEMA = {
   fields: [
-    // Paths group
     {
       key: "migrationsPath",
       type: "path",
       label: "Migrations Path",
       description: "Directory for Laravel migration files",
       default: "database/migrations",
-      group: "paths"
+      group: "output"
     },
     {
-      key: "typesPath",
+      key: "modelsPath",
       type: "path",
-      label: "TypeScript Types Path",
-      description: "Directory for generated TypeScript type files",
-      default: "types",
-      group: "paths"
-    },
-    // Generators group
-    {
-      key: "generateMigrations",
-      type: "boolean",
-      label: "Generate Migrations",
-      description: "Generate Laravel migration files",
-      default: true,
-      group: "generators"
+      label: "Models Path",
+      description: "Directory for user-editable model files",
+      default: "app/Models",
+      group: "output"
     },
     {
-      key: "generateTypes",
-      type: "boolean",
-      label: "Generate TypeScript Types",
-      description: "Generate TypeScript type definitions",
-      default: true,
-      group: "generators"
+      key: "baseModelsPath",
+      type: "path",
+      label: "Base Models Path",
+      description: "Directory for auto-generated base model files",
+      default: "app/Models/OmnifyBase",
+      group: "output"
     },
-    // Options group
     {
-      key: "singleFile",
+      key: "generateModels",
       type: "boolean",
-      label: "Single File Output",
-      description: "Generate all types in a single file",
+      label: "Generate Models",
+      description: "Generate Eloquent model classes",
       default: true,
       group: "options"
     },
@@ -1498,69 +1613,69 @@ var LARAVEL_CONFIG_SCHEMA = {
     }
   ]
 };
-function resolveOptions(options) {
+function resolveOptions2(options) {
   return {
     migrationsPath: options?.migrationsPath ?? "database/migrations",
-    typesPath: options?.typesPath ?? "types",
-    singleFile: options?.singleFile ?? true,
+    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,
     connection: options?.connection,
-    timestamp: options?.timestamp,
-    generateTypes: options?.generateTypes ?? true,
-    generateMigrations: options?.generateMigrations ?? true
+    timestamp: options?.timestamp
   };
 }
 function laravelPlugin(options) {
-  const resolved = resolveOptions(options);
+  const resolved = resolveOptions2(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);
+      return 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
+        }
+      }));
+    }
+  };
   return {
     name: "@famgia/omnify-laravel",
-    version: "0.0.12",
+    version: "0.0.14",
     configSchema: LARAVEL_CONFIG_SCHEMA,
-    generators: [
-      // Laravel Migrations Generator
-      ...resolved.generateMigrations ? [
-        {
-          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
-              }
-            }));
-          }
-        }
-      ] : [],
-      // TypeScript Types Generator
-      ...resolved.generateTypes ? [
-        {
-          name: "typescript-types",
-          description: "Generate TypeScript type definitions",
-          generate: async (ctx) => {
-            const tsOptions = {
-              singleFile: resolved.singleFile
-            };
-            const files = generateTypeScript(ctx.schemas, tsOptions);
-            return files.map((file) => ({
-              path: `${resolved.typesPath}/${file.fileName}`,
-              content: file.content,
-              type: "type",
-              metadata: {
-                types: file.types
-              }
-            }));
-          }
-        }
-      ] : []
-    ]
+    generators: resolved.generateModels ? [migrationGenerator, modelGenerator] : [migrationGenerator]
   };
 }
 
@@ -1584,26 +1699,6 @@ export {
   generateAlterMigration,
   generateDropTableMigration,
   generateMigrationsFromChanges,
-  toPropertyName,
-  toInterfaceName,
-  getPropertyType,
-  propertyToTSProperty,
-  schemaToInterface,
-  formatProperty,
-  formatInterface,
-  generateInterfaces,
-  toEnumMemberName,
-  toEnumName,
-  schemaToEnum,
-  generateEnums,
-  formatEnum,
-  enumToUnionType,
-  formatTypeAlias,
-  extractInlineEnums,
-  generateTypeScriptFile,
-  generateTypeScriptFiles,
-  generateTypeScript,
-  getTypeScriptPath,
   laravelPlugin
 };
-//# sourceMappingURL=chunk-2JWTIYRL.js.map
+//# sourceMappingURL=chunk-UVF7W2J2.js.map