@omnifyjp/omnify 2.0.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Schema-driven code generation for Laravel, TypeScript, and SQL",
   "license": "MIT",
   "repository": {
@@ -36,10 +36,10 @@
     "zod": "^3.24.0"
   },
   "optionalDependencies": {
-    "@omnifyjp/omnify-darwin-arm64": "2.0.0",
-    "@omnifyjp/omnify-darwin-x64": "2.0.0",
-    "@omnifyjp/omnify-linux-x64": "2.0.0",
-    "@omnifyjp/omnify-linux-arm64": "2.0.0",
-    "@omnifyjp/omnify-win32-x64": "2.0.0"
+    "@omnifyjp/omnify-darwin-arm64": "2.1.0",
+    "@omnifyjp/omnify-darwin-x64": "2.1.0",
+    "@omnifyjp/omnify-linux-x64": "2.1.0",
+    "@omnifyjp/omnify-linux-arm64": "2.1.0",
+    "@omnifyjp/omnify-win32-x64": "2.1.0"
   }
 }

package/ts-dist/generator.js

@@ -46,16 +46,26 @@ function generateBaseInterfaceFile(schemaName, schemas, options) {
     const parts = [generateBaseHeader()];
     // Zod import
     parts.push(`import { z } from 'zod';\n`);
-    // DateTimeString / DateString imports
+    // DateTimeString / DateString / OmnifyFile imports
     const dateImports = needsDateTimeImports(iface);
     const commonImports = [];
+    const commonValueImports = [];
     if (dateImports.dateTime)
         commonImports.push('DateTimeString');
     if (dateImports.date)
         commonImports.push('DateString');
+    // Check if any property uses OmnifyFile
+    const usesFile = iface.properties.some(p => p.type.includes('OmnifyFile'));
+    if (usesFile) {
+        commonImports.push('OmnifyFile');
+        commonValueImports.push('OmnifyFileSchema');
+    }
     if (commonImports.length > 0) {
         parts.push(`import type { ${commonImports.join(', ')} } from '../common';\n`);
     }
+    if (commonValueImports.length > 0) {
+        parts.push(`import { ${commonValueImports.join(', ')} } from '../common';\n`);
+    }
     // Enum imports (schema enums + plugin enums are all in ../enum/)
     if (iface.enumDependencies && iface.enumDependencies.length > 0) {
         for (const enumName of iface.enumDependencies) {
@@ -125,8 +135,54 @@ function generateModelFile(schemaName) {
     };
 }
 /** Generate common.ts with shared types. */
-function generateCommonFile(options) {
+function generateCommonFile(options, hasFiles) {
     const localeUnion = options.locales.map(l => `'${l}'`).join(' | ');
+    const types = ['LocaleMap', 'Locale', 'DateTimeString', 'DateString'];
+    let fileSection = '';
+    if (hasFiles) {
+        types.push('OmnifyFile', 'OmnifyFileSchema');
+        fileSection = `
+import { z } from 'zod';
+
+/**
+ * Omnify file attachment.
+ */
+export interface OmnifyFile {
+  readonly id: string;
+  readonly collection: string;
+  readonly disk: string;
+  readonly path: string;
+  readonly original_name: string;
+  readonly mime_type: string;
+  readonly size: number;
+  readonly status: 'temporary' | 'permanent';
+  readonly url: string | null;
+  readonly expires_at: DateTimeString | null;
+  readonly sort_order: number;
+  readonly created_at: DateTimeString;
+  readonly updated_at: DateTimeString;
+}
+
+/**
+ * Zod schema for OmnifyFile.
+ */
+export const OmnifyFileSchema = z.object({
+  id: z.string(),
+  collection: z.string(),
+  disk: z.string(),
+  path: z.string(),
+  original_name: z.string(),
+  mime_type: z.string(),
+  size: z.number(),
+  status: z.enum(['temporary', 'permanent']),
+  url: z.string().nullable(),
+  expires_at: z.string().nullable(),
+  sort_order: z.number(),
+  created_at: z.string(),
+  updated_at: z.string(),
+});
+`;
+    }
     const content = `${generateBaseHeader()}/**
  * Locale map for multi-language support.
  */
@@ -148,11 +204,11 @@ export type DateTimeString = string;
  * ISO 8601 date string (YYYY-MM-DD).
  */
 export type DateString = string;
-`;
+${fileSection}`;
     return {
         filePath: 'common.ts',
         content,
-        types: ['LocaleMap', 'Locale', 'DateTimeString', 'DateString'],
+        types,
         overwrite: true,
     };
 }
@@ -166,11 +222,17 @@ function generateI18nFile(options) {
     };
 }
 /** Generate index.ts re-exports. */
-function generateIndexFile(schemas, schemaEnums, pluginEnums, typeAliases) {
+function generateIndexFile(schemas, schemaEnums, pluginEnums, typeAliases, hasFiles = false) {
     const parts = [generateBaseHeader()];
     // Common types
     parts.push(`// Common Types\n`);
-    parts.push(`export type { LocaleMap, Locale, DateTimeString, DateString } from './common';\n\n`);
+    if (hasFiles) {
+        parts.push(`export type { LocaleMap, Locale, DateTimeString, DateString, OmnifyFile } from './common';\n`);
+        parts.push(`export { OmnifyFileSchema } from './common';\n`);
+    }
+    else {
+        parts.push(`export type { LocaleMap, Locale, DateTimeString, DateString } from './common';\n`);
+    }
     // I18n
     parts.push(`// i18n (Internationalization)\n`);
     parts.push(`export {\n`);
@@ -320,11 +382,18 @@ export function generateTypeScript(input) {
             continue;
         files.push(generateModelFile(schema.name));
     }
+    // Detect if any schema has File properties
+    const hasFiles = Object.values(schemas).some(s => {
+        if (s.kind === 'enum')
+            return false;
+        const props = s.properties ?? {};
+        return Object.values(props).some(p => p.type === 'File');
+    });
     // Common types
-    files.push(generateCommonFile(options));
+    files.push(generateCommonFile(options, hasFiles));
     // I18n
     files.push(generateI18nFile(options));
     // Index re-exports
-    files.push(generateIndexFile(schemas, schemaEnums, pluginEnums, inlineTypeAliases));
+    files.push(generateIndexFile(schemas, schemaEnums, pluginEnums, inlineTypeAliases, hasFiles));
     return files;
 }

package/ts-dist/interface-generator.js

@@ -53,7 +53,7 @@ function getIdType(options) {
 /** Gets TypeScript type for a property. */
 export function getPropertyType(property, allSchemas) {
     if (property.type === 'File') {
-        return 'File | null';
+        return property.multiple ? 'OmnifyFile[]' : 'OmnifyFile | null';
     }
     if (property.type === 'Association') {
         const targetName = property.target ?? 'unknown';

package/ts-dist/php/factory-generator.d.ts

@@ -5,3 +5,5 @@ import { SchemaReader } from './schema-reader.js';
 import type { GeneratedFile, PhpConfig } from './types.js';
 /** Generate Factory classes for all project-owned visible object schemas. */
 export declare function generateFactories(reader: SchemaReader, config: PhpConfig): GeneratedFile[];
+/** Generate the FileFactory class (only when schemas use File type). */
+export declare function generateFileFactory(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/ts-dist/php/factory-generator.js

@@ -42,6 +42,9 @@ function generateFactory(name, schema, reader, schemas, config) {
             }
             continue;
         }
+        // Skip File type (files are relational, not direct columns)
+        if (type === 'File')
+            continue;
         // Handle compound types
         if (expandedProperties[propName]) {
             const expansion = expandedProperties[propName];
@@ -96,3 +99,97 @@ ${attributesStr}
 `;
     return userFile(`${config.factories.path}/${modelName}Factory.php`, content);
 }
+/** Generate the FileFactory class (only when schemas use File type). */
+export function generateFileFactory(reader, config) {
+    if (!reader.hasFileProperties())
+        return [];
+    const modelNamespace = config.models.namespace;
+    const factoryNamespace = config.factories.namespace;
+    const content = `<?php
+
+/**
+ * File Factory
+ *
+ * SAFE TO EDIT - This file is never overwritten by Omnify.
+ */
+
+namespace ${factoryNamespace};
+
+use ${modelNamespace}\\File;
+use ${modelNamespace}\\FileStatusEnum;
+use Illuminate\\Database\\Eloquent\\Factories\\Factory;
+use Illuminate\\Support\\Str;
+
+/**
+ * @extends Factory<File>
+ */
+class FileFactory extends Factory
+{
+    protected $model = File::class;
+
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        $extension = fake()->randomElement(['jpg', 'png', 'pdf', 'docx']);
+        $originalName = fake()->word() . '.' . $extension;
+        $mimeTypes = [
+            'jpg' => 'image/jpeg',
+            'png' => 'image/png',
+            'pdf' => 'application/pdf',
+            'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        ];
+
+        return [
+            'collection' => 'default',
+            'disk' => 'public',
+            'path' => 'files/' . now()->format('Y/m') . '/' . Str::uuid() . '.' . $extension,
+            'original_name' => $originalName,
+            'mime_type' => $mimeTypes[$extension] ?? 'application/octet-stream',
+            'size' => fake()->numberBetween(1024, 10485760),
+            'status' => FileStatusEnum::Temporary,
+            'expires_at' => now()->addHours(24),
+            'sort_order' => 0,
+        ];
+    }
+
+    /**
+     * Indicate that the file is permanent.
+     */
+    public function permanent(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'status' => FileStatusEnum::Permanent,
+            'expires_at' => null,
+        ]);
+    }
+
+    /**
+     * Indicate that the file has expired.
+     */
+    public function expired(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'status' => FileStatusEnum::Temporary,
+            'expires_at' => now()->subHour(),
+        ]);
+    }
+
+    /**
+     * Set a specific collection.
+     */
+    public function inCollection(string $collection): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'collection' => $collection,
+        ]);
+    }
+}
+`;
+    return [
+        userFile(`${config.factories.path}/FileFactory.php`, content),
+    ];
+}

package/ts-dist/php/file-cleanup-generator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates the CleanupExpiredFiles artisan command.
+ * Only generated when fileConfig.tempFlow is enabled.
+ */
+import { SchemaReader } from './schema-reader.js';
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate the cleanup command (only when tempFlow is enabled). */
+export declare function generateFileCleanup(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/ts-dist/php/file-cleanup-generator.js

@@ -0,0 +1,79 @@
+/**
+ * Generates the CleanupExpiredFiles artisan command.
+ * Only generated when fileConfig.tempFlow is enabled.
+ */
+import { baseFile } from './types.js';
+/** Generate the cleanup command (only when tempFlow is enabled). */
+export function generateFileCleanup(reader, config) {
+    const fileConfig = reader.getFileConfig();
+    if (!fileConfig?.tempFlow)
+        return [];
+    const modelNamespace = config.models.namespace;
+    const content = `<?php
+
+namespace App\\Console\\Commands;
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+
+use Illuminate\\Console\\Command;
+use Illuminate\\Support\\Facades\\Storage;
+use ${modelNamespace}\\File;
+
+class CleanupExpiredFiles extends Command
+{
+    /**
+     * The name and signature of the console command.
+     */
+    protected $signature = 'omnify:cleanup-expired-files
+                            {--dry-run : Show what would be deleted without actually deleting}';
+
+    /**
+     * The console command description.
+     */
+    protected $description = 'Delete expired temporary files';
+
+    /**
+     * Execute the console command.
+     */
+    public function handle(): int
+    {
+        $query = File::expired();
+        $count = $query->count();
+
+        if ($count === 0) {
+            $this->info('No expired files found.');
+            return self::SUCCESS;
+        }
+
+        if ($this->option('dry-run')) {
+            $this->info("Would delete {$count} expired file(s).");
+            return self::SUCCESS;
+        }
+
+        $deleted = 0;
+        $query->chunkById(100, function ($files) use (&$deleted) {
+            foreach ($files as $file) {
+                // Delete from storage
+                if ($file->path && Storage::disk($file->disk)->exists($file->path)) {
+                    Storage::disk($file->disk)->delete($file->path);
+                }
+                // Soft delete the record
+                $file->delete();
+                $deleted++;
+            }
+        });
+
+        $this->info("Deleted {$deleted} expired file(s).");
+        return self::SUCCESS;
+    }
+}
+`;
+    return [
+        baseFile('app/Console/Commands/CleanupExpiredFiles.php', content),
+    ];
+}

package/ts-dist/php/file-model-generator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generates File model infrastructure:
+ * - FileBaseModel.php (base, always overwritten)
+ * - File.php (user, created once)
+ * - FileStatusEnum.php (base, always overwritten)
+ * - FileLocales.php (base, always overwritten)
+ */
+import { SchemaReader } from './schema-reader.js';
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate all File model infrastructure files. */
+export declare function generateFileModels(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/ts-dist/php/file-model-generator.js

@@ -0,0 +1,359 @@
+/**
+ * Generates File model infrastructure:
+ * - FileBaseModel.php (base, always overwritten)
+ * - File.php (user, created once)
+ * - FileStatusEnum.php (base, always overwritten)
+ * - FileLocales.php (base, always overwritten)
+ */
+import { baseFile, userFile } from './types.js';
+/** Generate all File model infrastructure files. */
+export function generateFileModels(reader, config) {
+    if (!reader.hasFileProperties())
+        return [];
+    const files = [];
+    const locale = reader.getLocale();
+    const defaultDisk = reader.getFileConfig()?.defaultDisk ?? 'public';
+    files.push(generateFileBaseModel(config, defaultDisk));
+    files.push(generateFileUserModel(config));
+    files.push(generateFileStatusEnum(config));
+    if (locale) {
+        files.push(generateFileLocales(config, locale.locales));
+    }
+    return files;
+}
+function generateFileBaseModel(config, defaultDisk) {
+    const baseNamespace = config.models.baseNamespace;
+    const modelNamespace = config.models.namespace;
+    const content = `<?php
+
+namespace ${baseNamespace};
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+
+use Illuminate\\Database\\Eloquent\\Concerns\\HasUuids;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphTo;
+use Illuminate\\Database\\Eloquent\\SoftDeletes;
+use Illuminate\\Database\\Eloquent\\Builder;
+use ${baseNamespace}\\Locales\\FileLocales;
+use ${baseNamespace}\\Traits\\HasLocalizedDisplayName;
+
+/**
+ * FileBaseModel
+ *
+ * @property string $id
+ * @property string|null $organization_id
+ * @property string|null $fileable_type
+ * @property string|null $fileable_id
+ * @property string $collection
+ * @property string $disk
+ * @property string $path
+ * @property string $original_name
+ * @property string $mime_type
+ * @property int $size
+ * @property \\${modelNamespace}\\FileStatusEnum $status
+ * @property \\Illuminate\\Support\\Carbon|null $expires_at
+ * @property int $sort_order
+ */
+class FileBaseModel extends BaseModel
+{
+    use HasUuids;
+    use SoftDeletes;
+    use HasLocalizedDisplayName;
+
+    /**
+     * The table associated with the model.
+     */
+    protected $table = 'files';
+
+    /**
+     * The primary key for the model.
+     */
+    protected $primaryKey = 'id';
+
+    /**
+     * The type of the primary key.
+     */
+    protected $keyType = 'string';
+
+    /**
+     * Indicates if the IDs are auto-incrementing.
+     */
+    public $incrementing = false;
+
+    /**
+     * Indicates if the model should be timestamped.
+     */
+    public $timestamps = true;
+
+    /**
+     * Localized display names for this model.
+     */
+    protected static array $localizedDisplayNames = FileLocales::DISPLAY_NAMES;
+
+    /**
+     * Localized display names for properties.
+     */
+    protected static array $localizedPropertyDisplayNames = FileLocales::PROPERTY_DISPLAY_NAMES;
+
+    /**
+     * The attributes that are mass assignable.
+     */
+    protected $fillable = [
+        'organization_id',
+        'fileable_type',
+        'fileable_id',
+        'collection',
+        'disk',
+        'path',
+        'original_name',
+        'mime_type',
+        'size',
+        'status',
+        'expires_at',
+        'sort_order',
+    ];
+
+    /**
+     * Get the attributes that should be cast.
+     */
+    protected function casts(): array
+    {
+        return [
+            'size' => 'integer',
+            'sort_order' => 'integer',
+            'status' => \\${modelNamespace}\\FileStatusEnum::class,
+            'expires_at' => 'datetime',
+        ];
+    }
+
+    // -----------------------------------------------------------------------
+    // Relations
+    // -----------------------------------------------------------------------
+
+    /**
+     * Get the parent fileable model.
+     */
+    public function fileable(): MorphTo
+    {
+        return $this->morphTo();
+    }
+
+    // -----------------------------------------------------------------------
+    // Scopes
+    // -----------------------------------------------------------------------
+
+    /**
+     * Scope to a specific collection.
+     */
+    public function scopeInCollection(Builder $query, string $collection): Builder
+    {
+        return $query->where('collection', $collection);
+    }
+
+    /**
+     * Scope to permanent files.
+     */
+    public function scopePermanent(Builder $query): Builder
+    {
+        return $query->where('status', 'permanent');
+    }
+
+    /**
+     * Scope to temporary files.
+     */
+    public function scopeTemporary(Builder $query): Builder
+    {
+        return $query->where('status', 'temporary');
+    }
+
+    /**
+     * Scope to expired files (temporary + past expires_at).
+     */
+    public function scopeExpired(Builder $query): Builder
+    {
+        return $query->where('status', 'temporary')
+            ->whereNotNull('expires_at')
+            ->where('expires_at', '<', now());
+    }
+
+    // -----------------------------------------------------------------------
+    // Helpers
+    // -----------------------------------------------------------------------
+
+    /**
+     * Check if the file is permanent.
+     */
+    public function isPermanent(): bool
+    {
+        return $this->status === \\${modelNamespace}\\FileStatusEnum::Permanent;
+    }
+
+    /**
+     * Check if the file has expired.
+     */
+    public function isExpired(): bool
+    {
+        return $this->status === \\${modelNamespace}\\FileStatusEnum::Temporary
+            && $this->expires_at !== null
+            && $this->expires_at->isPast();
+    }
+
+    /**
+     * Make the file permanent.
+     */
+    public function makePermanent(): static
+    {
+        $this->update([
+            'status' => \\${modelNamespace}\\FileStatusEnum::Permanent,
+            'expires_at' => null,
+        ]);
+
+        return $this;
+    }
+}
+`;
+    return baseFile(`${config.models.basePath}/FileBaseModel.php`, content);
+}
+function generateFileUserModel(config) {
+    const modelNamespace = config.models.namespace;
+    const baseNamespace = config.models.baseNamespace;
+    const factoryNamespace = config.factories.namespace;
+    const content = `<?php
+
+/**
+ * File Model
+ *
+ * SAFE TO EDIT - This file is never overwritten by Omnify.
+ */
+
+namespace ${modelNamespace};
+
+use ${baseNamespace}\\FileBaseModel;
+use ${factoryNamespace}\\FileFactory;
+use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
+
+/**
+ * File — add project-specific model logic here.
+ */
+class File extends FileBaseModel
+{
+    use HasFactory;
+
+    /**
+     * Create a new factory instance for the model.
+     */
+    protected static function newFactory(): FileFactory
+    {
+        return FileFactory::new();
+    }
+
+    //
+}
+`;
+    return userFile(`${config.models.path}/File.php`, content);
+}
+function generateFileStatusEnum(config) {
+    const modelNamespace = config.models.namespace;
+    const content = `<?php
+
+namespace ${modelNamespace};
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+enum FileStatusEnum: string
+{
+    case Temporary = 'temporary';
+    case Permanent = 'permanent';
+
+    /**
+     * Get human-readable label.
+     */
+    public function label(): string
+    {
+        return match ($this) {
+            self::Temporary => __('Temporary'),
+            self::Permanent => __('Permanent'),
+        };
+    }
+
+    /**
+     * Get all possible values.
+     *
+     * @return array<string>
+     */
+    public static function values(): array
+    {
+        return array_column(self::cases(), 'value');
+    }
+}
+`;
+    return baseFile(`${config.models.path}/FileStatusEnum.php`, content);
+}
+function generateFileLocales(config, locales) {
+    const baseNamespace = config.models.baseNamespace;
+    // Display names for the File model
+    const displayNames = {
+        ja: 'ファイル',
+        en: 'File',
+        vi: 'Tệp',
+    };
+    // Property display names
+    const propertyDisplayNames = {
+        collection: { ja: 'コレクション', en: 'Collection', vi: 'Bộ sưu tập' },
+        disk: { ja: 'ディスク', en: 'Disk', vi: 'Đĩa' },
+        path: { ja: 'パス', en: 'Path', vi: 'Đường dẫn' },
+        original_name: { ja: 'ファイル名', en: 'File Name', vi: 'Tên tệp' },
+        mime_type: { ja: 'MIMEタイプ', en: 'MIME Type', vi: 'Loại MIME' },
+        size: { ja: 'サイズ', en: 'Size', vi: 'Kích thước' },
+        status: { ja: 'ステータス', en: 'Status', vi: 'Trạng thái' },
+        expires_at: { ja: '有効期限', en: 'Expires At', vi: 'Hết hạn' },
+        sort_order: { ja: '並び順', en: 'Sort Order', vi: 'Thứ tự sắp xếp' },
+    };
+    // Filter to configured locales
+    const filteredDisplayNames = Object.fromEntries(locales.filter(l => displayNames[l]).map(l => [l, displayNames[l]]));
+    const displayNamesPhp = formatPhpArray(filteredDisplayNames);
+    const propertyNamesPhp = Object.entries(propertyDisplayNames)
+        .map(([prop, names]) => {
+        const filtered = Object.fromEntries(locales.filter(l => names[l]).map(l => [l, names[l]]));
+        return `        '${prop}' => ${formatPhpArray(filtered)}`;
+    })
+        .join(',\n');
+    const content = `<?php
+
+namespace ${baseNamespace}\\Locales;
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+class FileLocales
+{
+    public const DISPLAY_NAMES = ${displayNamesPhp};
+
+    public const PROPERTY_DISPLAY_NAMES = [
+${propertyNamesPhp},
+    ];
+}
+`;
+    return baseFile(`${config.models.basePath}/Locales/FileLocales.php`, content);
+}
+function formatPhpArray(obj) {
+    const entries = Object.entries(obj)
+        .map(([key, val]) => `'${key}' => '${escapePhp(val)}'`)
+        .join(', ');
+    return `[${entries}]`;
+}
+function escapePhp(s) {
+    return s.replace(/'/g, "\\'");
+}

package/ts-dist/php/file-trait-generator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates the HasFiles trait for models with File-type properties.
+ */
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate the HasFiles trait. */
+export declare function generateFileTrait(config: PhpConfig): GeneratedFile[];

package/ts-dist/php/file-trait-generator.js

@@ -0,0 +1,96 @@
+/**
+ * Generates the HasFiles trait for models with File-type properties.
+ */
+import { baseFile } from './types.js';
+/** Generate the HasFiles trait. */
+export function generateFileTrait(config) {
+    const baseNamespace = config.models.baseNamespace;
+    const modelNamespace = config.models.namespace;
+    const content = `<?php
+
+namespace ${baseNamespace}\\Traits;
+
+/**
+ * Trait for models with polymorphic file attachments.
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+
+use Illuminate\\Database\\Eloquent\\Relations\\MorphMany;
+use ${modelNamespace}\\File;
+use ${modelNamespace}\\FileStatusEnum;
+
+trait HasFiles
+{
+    /**
+     * Get all files attached to this model.
+     */
+    public function files(): MorphMany
+    {
+        return $this->morphMany(File::class, 'fileable');
+    }
+
+    /**
+     * Get files in a specific collection.
+     */
+    public function filesInCollection(string $collection): MorphMany
+    {
+        return $this->files()->where('collection', $collection);
+    }
+
+    /**
+     * Get all permanent files.
+     */
+    public function permanentFiles(): MorphMany
+    {
+        return $this->files()->where('status', FileStatusEnum::Permanent);
+    }
+
+    /**
+     * Attach files by IDs to a collection, making them permanent.
+     *
+     * @param array<string> $fileIds
+     */
+    public function attachFiles(array $fileIds, string $collection = 'default', int $startOrder = 0): void
+    {
+        if (empty($fileIds)) return;
+
+        File::whereIn('id', $fileIds)->update([
+            'fileable_type' => $this->getMorphClass(),
+            'fileable_id' => $this->getKey(),
+            'collection' => $collection,
+            'status' => FileStatusEnum::Permanent,
+            'expires_at' => null,
+            'sort_order' => \\Illuminate\\Support\\Facades\\DB::raw('sort_order + ' . $startOrder),
+        ]);
+    }
+
+    /**
+     * Sync files for a collection (detach old, attach new).
+     *
+     * @param array<string> $fileIds
+     */
+    public function syncFiles(array $fileIds, string $collection = 'default'): void
+    {
+        // Soft-delete files no longer in the list
+        $this->filesInCollection($collection)
+            ->whereNotIn('id', $fileIds)
+            ->delete();
+
+        // Attach new files
+        $this->attachFiles($fileIds, $collection);
+
+        // Update sort order based on array position
+        foreach ($fileIds as $index => $id) {
+            File::where('id', $id)->update(['sort_order' => $index]);
+        }
+    }
+}
+`;
+    return [
+        baseFile(`${config.models.basePath}/Traits/HasFiles.php`, content),
+    ];
+}

package/ts-dist/php/index.js

@@ -18,10 +18,13 @@ import { generateLocales } from './locales-generator.js';
 import { generateModels } from './model-generator.js';
 import { generateRequests } from './request-generator.js';
 import { generateResources } from './resource-generator.js';
-import { generateFactories } from './factory-generator.js';
+import { generateFactories, generateFileFactory } from './factory-generator.js';
 import { generateServiceProvider } from './service-provider-generator.js';
 import { generateTranslationModels } from './translation-model-generator.js';
 import { generatePolicies } from './policy-generator.js';
+import { generateFileModels } from './file-model-generator.js';
+import { generateFileTrait } from './file-trait-generator.js';
+import { generateFileCleanup } from './file-cleanup-generator.js';
 export { derivePhpConfig } from './types.js';
 /** Generate all PHP files from schemas.json data. */
 export function generatePhp(data, overrides) {
@@ -32,6 +35,13 @@ export function generatePhp(data, overrides) {
     files.push(...generateBaseModel(config));
     files.push(...generateTrait(config));
     files.push(...generateServiceProvider(reader, config));
+    // File infrastructure (only when schemas use File type)
+    if (reader.hasFileProperties()) {
+        files.push(...generateFileModels(reader, config));
+        files.push(...generateFileTrait(config));
+        files.push(...generateFileFactory(reader, config));
+        files.push(...generateFileCleanup(reader, config));
+    }
     // Per-schema files
     files.push(...generateLocales(reader, config));
     files.push(...generateModels(reader, config));

package/ts-dist/php/model-generator.js

@@ -1,7 +1,7 @@
 /**
  * Port of ModelGenerator.php — generates Eloquent model base + user classes.
  */
-import { toPascalCase, toSnakeCase } from './naming-helper.js';
+import { toPascalCase, toSnakeCase, toCamelCase } from './naming-helper.js';
 import { toCast, toPhpDocType, isHiddenByDefault } from './type-mapper.js';
 import { buildRelation } from './relation-builder.js';
 import { baseFile, userFile } from './types.js';
@@ -54,17 +54,23 @@ function generateBaseModel(name, schema, reader, config) {
     const isCompositeKey = primaryKey.includes(',');
     const needsUuidTrait = !isCompositeKey && idType === 'Uuid';
     const needsUlidTrait = !isCompositeKey && idType === 'Ulid';
-    const imports = buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait, needsUlidTrait, hasNestedSet, config.nestedset.namespace);
+    // Detect File properties for HasFiles trait
+    const hasFiles = propertyOrder.some(p => {
+        const prop = properties[p];
+        return prop && prop['type'] === 'File';
+    });
+    const imports = buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait, needsUlidTrait, hasNestedSet, config.nestedset.namespace, hasFiles, modelNamespace);
     const docProperties = buildDocProperties(properties, expandedProperties, propertyOrder);
     const baseClass = isAuthenticatable ? 'Authenticatable' : 'BaseModel';
     const implementsClause = hasTranslatable ? ' implements TranslatableContract' : '';
-    const traits = buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUuidTrait, needsUlidTrait, hasNestedSet);
+    const traits = buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUuidTrait, needsUlidTrait, hasNestedSet, hasFiles);
     const fillable = buildFillable(properties, expandedProperties, propertyOrder);
     const hidden = buildHidden(properties, expandedProperties, propertyOrder);
     const appends = buildAppends(expandedProperties);
     const casts = buildCasts(properties, expandedProperties, propertyOrder, reader);
     const relations = buildRelations(name, properties, propertyOrder, modelNamespace, reader);
     const accessors = buildAccessors(expandedProperties);
+    const fileAccessors = hasFiles ? buildFileAccessors(properties, propertyOrder, modelNamespace) : '';
     const nestedSetMethod = buildNestedSetParentIdMethod(nestedSetParentColumn);
     let keyTypeSection = '';
     if (idType === 'Uuid' || idType === 'Ulid' || idType === 'String') {
@@ -162,7 +168,7 @@ ${appends}    ];
         return [
 ${casts}        ];
     }
-${relations}${accessors}${nestedSetMethod}
+${relations}${accessors}${fileAccessors}${nestedSetMethod}
 }
 `;
     return baseFile(`${config.models.basePath}/${modelName}BaseModel.php`, content);
@@ -217,7 +223,7 @@ ${traits.join('\n')}
 `;
     return userFile(`${config.models.path}/${modelName}.php`, content);
 }
-function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false, nestedSetNamespace = 'Aimeos\\Nestedset') {
+function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false, nestedSetNamespace = 'Aimeos\\Nestedset', hasFiles = false, modelNamespace = '') {
     const lines = [];
     if (isAuthenticatable) {
         lines.push('use Illuminate\\Foundation\\Auth\\User as Authenticatable;');
@@ -237,6 +243,12 @@ function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable
     lines.push('use Illuminate\\Database\\Eloquent\\Collection as EloquentCollection;');
     lines.push(`use ${baseNamespace}\\Traits\\HasLocalizedDisplayName;`);
     lines.push(`use ${baseNamespace}\\Locales\\${modelName}Locales;`);
+    if (hasFiles) {
+        lines.push(`use ${baseNamespace}\\Traits\\HasFiles;`);
+        if (modelNamespace) {
+            lines.push(`use ${modelNamespace}\\File;`);
+        }
+    }
     if (hasSoftDelete) {
         lines.push('use Illuminate\\Database\\Eloquent\\SoftDeletes;');
     }
@@ -283,9 +295,11 @@ function buildDocProperties(properties, expandedProperties, propertyOrder) {
     }
     return lines.length === 0 ? '' : lines.join('\n') + '\n';
 }
-function buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false) {
+function buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false, hasFiles = false) {
     const lines = [];
     lines.push('    use HasLocalizedDisplayName;');
+    if (hasFiles)
+        lines.push('    use HasFiles;');
     if (needsUuidTrait)
         lines.push('    use HasUuids;');
     if (needsUlidTrait)
@@ -535,6 +549,38 @@ function buildNestedSetParentIdMethod(parentColumn) {
     }
 `;
 }
+function buildFileAccessors(properties, propertyOrder, modelNamespace) {
+    const methods = [];
+    for (const propName of propertyOrder) {
+        const prop = properties[propName];
+        if (!prop || prop['type'] !== 'File')
+            continue;
+        const collection = prop['collection'] || toSnakeCase(propName);
+        const multiple = prop['multiple'] ?? false;
+        const methodName = toCamelCase(propName);
+        if (multiple) {
+            methods.push(`
+    /**
+     * Get ${propName} files (collection: ${collection}).
+     */
+    public function ${methodName}(): MorphMany
+    {
+        return $this->filesInCollection('${collection}');
+    }`);
+        }
+        else {
+            methods.push(`
+    /**
+     * Get ${propName} file (collection: ${collection}).
+     */
+    public function ${methodName}(): ?File
+    {
+        return $this->filesInCollection('${collection}')->first();
+    }`);
+        }
+    }
+    return methods.join('\n');
+}
 function fullNameAccessor(prefix, suffix, fields, separator) {
     const methodName = 'get' + toPascalCase(prefix) + suffix + 'Attribute';
     const fieldAccess = fields.map(f => `$this->${f}`).join(', ');

package/ts-dist/php/request-generator.js

@@ -86,6 +86,29 @@ function generateBaseRequest(name, schema, reader, config, action) {
             attributeKeys.push(snakeName);
             continue;
         }
+        // File type: generate array item rules for multiple files
+        if (type === 'File') {
+            const snakeName = toSnakeCase(propName);
+            const multiple = prop['multiple'] ?? false;
+            const rules = isUpdate
+                ? toUpdateRules(prop, tableName, modelRouteParam)
+                : toStoreRules(prop, tableName);
+            rulesLines.push(`            '${snakeName}' => ${formatRules(rules)},`);
+            attributeKeys.push(snakeName);
+            if (multiple) {
+                // Generate array item rules: field.* => ['file', 'mimes:...', 'max:...']
+                const itemRules = ['file'];
+                const accept = prop['accept'];
+                if (accept?.length)
+                    itemRules.push(`mimes:${accept.join(',')}`);
+                const maxSize = prop['maxSize'];
+                if (maxSize)
+                    itemRules.push(`max:${maxSize}`);
+                const formattedItemRules = `[${itemRules.map(r => `'${r}'`).join(', ')}]`;
+                rulesLines.push(`            '${snakeName}.*' => ${formattedItemRules},`);
+            }
+            continue;
+        }
         const snakeName = toSnakeCase(propName);
         const rules = isUpdate
             ? toUpdateRules(prop, tableName, modelRouteParam)

package/ts-dist/php/schema-reader.d.ts

@@ -47,6 +47,12 @@ export declare class SchemaReader {
     getExpandedProperties(schemaName: string): Record<string, ExpandedProperty>;
     getPropertyOrder(schemaName: string): string[];
     getTableName(schemaName: string): string;
+    /** Check if any schema has File-type properties. */
+    hasFileProperties(): boolean;
+    /** Get the file config from schemas.json. */
+    getFileConfig(): import("../types.js").FileConfigExport | null;
+    /** Get all schemas that have File-type properties. */
+    getSchemasWithFileProperties(): Record<string, SchemaDefinition>;
     /** Get translatable field names (snake_case) for a schema. */
     getTranslatableFields(schemaName: string): string[];
 }

package/ts-dist/php/schema-reader.js

@@ -158,6 +158,35 @@ export class SchemaReader {
         const schema = this.getSchema(schemaName);
         return schema?.tableName ?? '';
     }
+    /** Check if any schema has File-type properties. */
+    hasFileProperties() {
+        for (const schema of Object.values(this.getObjectSchemas())) {
+            const props = schema.properties ?? {};
+            for (const prop of Object.values(props)) {
+                if (prop.type === 'File')
+                    return true;
+            }
+        }
+        return false;
+    }
+    /** Get the file config from schemas.json. */
+    getFileConfig() {
+        return this.data.fileConfig ?? null;
+    }
+    /** Get all schemas that have File-type properties. */
+    getSchemasWithFileProperties() {
+        const result = {};
+        for (const [name, schema] of Object.entries(this.getObjectSchemas())) {
+            const props = schema.properties ?? {};
+            for (const prop of Object.values(props)) {
+                if (prop.type === 'File') {
+                    result[name] = schema;
+                    break;
+                }
+            }
+        }
+        return result;
+    }
     /** Get translatable field names (snake_case) for a schema. */
     getTranslatableFields(schemaName) {
         const schema = this.getSchema(schemaName);

package/ts-dist/php/service-provider-generator.js

@@ -12,6 +12,10 @@ export function generateServiceProvider(reader, config) {
         const modelName = toPascalCase(name);
         morphEntries.push(`            '${modelName}' => \\${modelNamespace}\\${modelName}::class,`);
     }
+    // Add File to morph map when any schema uses File type
+    if (reader.hasFileProperties()) {
+        morphEntries.push(`            'File' => \\${modelNamespace}\\File::class,`);
+    }
     morphEntries.sort();
     const morphMapContent = morphEntries.join('\n');
     // Build package migration loading lines

package/ts-dist/php/type-mapper.js

@@ -149,6 +149,25 @@ export function toStoreRules(property, tableName) {
             }
             break;
         }
+        case 'File': {
+            const multiple = property['multiple'] ?? false;
+            if (multiple) {
+                rules.push('array');
+                const maxFiles = property['maxFiles'];
+                if (maxFiles)
+                    rules.push(`max:${maxFiles}`);
+            }
+            else {
+                rules.push('file');
+                const accept = property['accept'];
+                if (accept?.length)
+                    rules.push(`mimes:${accept.join(',')}`);
+                const maxSize = property['maxSize'];
+                if (maxSize)
+                    rules.push(`max:${maxSize}`);
+            }
+            break;
+        }
         default:
             rules.push('string', 'max:255');
     }

package/ts-dist/types.d.ts

@@ -5,6 +5,13 @@
  */
 /** Localized string — either a plain string or a locale map. */
 export type LocalizedString = string | Record<string, string>;
+/** File upload configuration. */
+export interface FileConfigExport {
+    readonly tempFlow?: boolean;
+    readonly tempTtl?: string;
+    readonly cleanupSchedule?: string;
+    readonly defaultDisk?: string;
+}
 /** Top-level schemas.json structure. */
 export interface SchemasJson {
     readonly generatedAt: string;
@@ -22,6 +29,7 @@ export interface SchemasJson {
         readonly simple: Record<string, SimpleTypeDefinition>;
         readonly enums: Record<string, string[]>;
     };
+    readonly fileConfig?: FileConfigExport;
     readonly packages?: Record<string, PackageExportInfo>;
     readonly schemas: Record<string, SchemaDefinition>;
 }
@@ -189,6 +197,11 @@ export interface PropertyDefinition {
     readonly pattern?: string;
     readonly rules?: ValidationRules;
     readonly enum?: string | readonly string[];
+    readonly multiple?: boolean;
+    readonly maxFiles?: number;
+    readonly accept?: readonly string[];
+    readonly maxSize?: number;
+    readonly collection?: string;
     readonly relation?: string;
     readonly target?: string;
     readonly targets?: readonly string[];

package/ts-dist/zod-generator.js

@@ -227,8 +227,17 @@ function getZodSchemaForType(propDef, _fieldName, options) {
             schema = 'z.number().int().positive()';
             break;
         case 'Association':
-        case 'File':
             return '';
+        case 'File': {
+            const multiple = propDef.multiple ?? false;
+            if (multiple) {
+                schema = 'z.array(OmnifyFileSchema)';
+            }
+            else {
+                schema = 'OmnifyFileSchema.nullable()';
+            }
+            break;
+        }
         default:
             schema = 'z.string()';
     }