@omnifyjp/ts 6.7.13 → 6.7.15

package/dist/php/enum-generator.js

@@ -32,6 +32,10 @@ function generateEnumClass(name, schema, config) {
     const values = (schema.values ?? []);
     const cases = values.map(v => buildCase(v));
     const labelsConst = buildLabelsConstant(values);
+    const allValuesHaveLabels = values.every((value) => typeof value.label === 'string' || Object.keys(value.label ?? {}).length > 0);
+    const labelThirdFallback = allValuesHaveLabels
+        ? '$labels[array_key_first($labels)]'
+        : '(array_values($labels)[0] ?? $this->value)';
     const content = `<?php
 
 namespace ${namespace};
@@ -59,12 +63,11 @@ ${labelsConst}
     public function label(?string $locale = null): string
     {
         $locale = $locale ?? app()->getLocale();
-        $labels = self::LABELS[$this->value] ?? [];
+        $labels = self::LABELS[$this->value];
 
         return $labels[$locale]
             ?? $labels[config('app.fallback_locale', 'en')]
-            ?? $labels[array_key_first($labels) ?? 'en']
-            ?? $this->value;
+            ?? ${labelThirdFallback};
     }
 
     /**

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

@@ -122,18 +122,48 @@ class CleanupFiles extends Command
         }
 
         if ($dryRun) {
+            $skippedShared = 0;
+            // Each row is counted independently; the real run force-deletes sequentially so
+            // earlier rows stop counting as references — this total is an upper bound.
+            $query->chunkById(100, function ($files) use (&$skippedShared) {
+                foreach ($files as $file) {
+                    if ($file->path && File::withTrashed()
+                        ->where('disk', $file->disk)
+                        ->where('path', $file->path)
+                        ->where('id', '!=', $file->id)
+                        ->exists()) {
+                        $skippedShared++;
+                    }
+                }
+            });
             $this->info("[Phase 2] Would purge {$count} file(s) older than {$hours}h.");
+            if ($skippedShared > 0) {
+                $this->info("[Phase 2] Would skip up to {$skippedShared} physical delete(s) — object may still be referenced by another row.");
+            }
             return self::SUCCESS;
         }
 
         $purged = 0;
         $errors = 0;
+        $skippedShared = 0;
 
-        $query->chunkById(100, function ($files) use (&$purged, &$errors) {
+        $query->chunkById(100, function ($files) use (&$purged, &$errors, &$skippedShared) {
             foreach ($files as $file) {
                 try {
-                    if ($file->path && Storage::disk($file->disk)->exists($file->path)) {
-                        Storage::disk($file->disk)->delete($file->path);
+                    // Rows force-deleted earlier in this batch no longer appear in withTrashed(),
+                    // so the last row sharing a disk+path deletes the object without extra bookkeeping.
+                    if ($file->path) {
+                        $pathReferencedElsewhere = File::withTrashed()
+                            ->where('disk', $file->disk)
+                            ->where('path', $file->path)
+                            ->where('id', '!=', $file->id)
+                            ->exists();
+
+                        if (! $pathReferencedElsewhere && Storage::disk($file->disk)->exists($file->path)) {
+                            Storage::disk($file->disk)->delete($file->path);
+                        } elseif ($pathReferencedElsewhere) {
+                            $skippedShared++;
+                        }
                     }
                     $file->forceDelete();
                     $purged++;
@@ -144,7 +174,13 @@ class CleanupFiles extends Command
             }
         });
 
-        $this->info("[Phase 2] Purged {$purged} file(s). Physical files removed.");
+        $purgeMsg = "[Phase 2] Purged {$purged} file(s).";
+        if ($skippedShared > 0) {
+            $purgeMsg .= " Skipped {$skippedShared} physical delete(s) — object still referenced by another row.";
+        } else {
+            $purgeMsg .= ' Physical files removed.';
+        }
+        $this->info($purgeMsg);
         if ($errors > 0) {
             $this->warn("{$errors} file(s) failed to purge.");
         }

package/dist/php/model-generator.js

@@ -3,7 +3,7 @@
  */
 import { toPascalCase, toSnakeCase, toCamelCase, toFkColumnName, pluralize } from './naming-helper.js';
 import { resolveTimestamps } from './timestamps.js';
-import { toCast, toPhpDocType, isHiddenByDefault } from './type-mapper.js';
+import { toCast, toPhpDocType, isHiddenByDefault, resolveFkCast, resolveFkPhpDocType } from './type-mapper.js';
 import { buildRelation } from './relation-builder.js';
 import { shadowingPropertyConflicts } from './shadowing-conflicts.js';
 import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup, } from './types.js';
@@ -451,7 +451,7 @@ function generateUserModel(name, schema, reader, config, hasNestedSet = false) {
     if (hasNestedSet) {
         imports.push(`use ${nestedSetNamespace}\\NodeTrait;`);
     }
-    const traits = ['    use HasFactory;'];
+    const traits = [`    /** @use HasFactory<${modelName}Factory> */\n    use HasFactory;`];
     if (hasNestedSet) {
         traits.push('    use NodeTrait;');
     }
@@ -614,7 +614,8 @@ function buildDocProperties(properties, expandedProperties, propertyOrder, reade
                 // doesn't actually have.
                 const snakeName = prop['column'] || toFkColumnName(propName);
                 const nullable = prop['nullable'] ?? false;
-                const phpType = nullable ? 'int|null' : 'int';
+                const target = prop['target'] ?? '';
+                const phpType = resolveFkPhpDocType(prop, target, reader, nullable);
                 lines.push(` * @property ${phpType} $${snakeName}`);
             }
             else if (relation === 'MorphTo') {
@@ -808,13 +809,10 @@ function buildCasts(properties, expandedProperties, propertyOrder, reader, confi
             const relation = prop['relation'] ?? '';
             if (relation === 'ManyToOne') {
                 const target = prop['target'] ?? '';
-                const targetSchema = reader.getSchema(target);
-                const targetIdType = typeof targetSchema?.options?.id === 'string'
-                    ? targetSchema.options.id
-                    : 'BigInt';
-                if (targetIdType !== 'Uuid' && targetIdType !== 'Ulid') {
+                const fkCast = resolveFkCast(prop, target, reader);
+                if (fkCast) {
                     // omnify-go#166: honor the `column:` override (ForeignColumn).
-                    casts.push(`'${prop['column'] || toFkColumnName(propName)}' => 'integer',`);
+                    casts.push(`'${prop['column'] || toFkColumnName(propName)}' => '${fkCast}',`);
                 }
             }
             continue;
@@ -934,7 +932,14 @@ function buildRelations(schemaName, properties, propertyOrder, modelNamespace, r
                     : toSnakeCase(propName));
             }
         }
-        const result = buildRelation(propName, prop, ns, { sourceTableName, targetTableName, pivotProperties, pivotTableName });
+        const result = buildRelation(propName, prop, ns, {
+            sourceTableName,
+            targetTableName,
+            pivotProperties,
+            pivotTableName,
+            reader,
+            sourceSchemaName: schemaName,
+        });
         if (result) {
             methods.push('\n' + result.method);
             declaredMethods.add(toCamelCase(propName));
@@ -1054,6 +1059,7 @@ function buildInverseRelations(parentName, modelNamespace, reader, declaredMetho
             methods.push(`
     /**
      * Auto-generated inverse of ${childName}.${childPropName} (${relation}).
+     * @return ${returnType}<${fqcn}, $this>
      */
     public function ${methodName}(): ${returnType}
     {

package/dist/php/relation-builder.d.ts

@@ -1,6 +1,7 @@
 /**
  * Port of RelationBuilder.php — generates Eloquent relation methods.
  */
+import type { SchemaReader } from './schema-reader.js';
 interface RelationResult {
     method: string;
     imports: string[];
@@ -8,6 +9,9 @@ interface RelationResult {
 interface RelationContext {
     sourceTableName: string;
     targetTableName: string;
+    /** Owning schema name (PascalCase) for OneToMany FK resolution. Issue #237. */
+    sourceSchemaName?: string;
+    reader?: SchemaReader;
     /** Non-conventional physical table resolved from an explicit pivot schema.
      * Omitted when Laravel can infer the joining table from model basenames. */
     pivotTableName?: string;
@@ -24,6 +28,13 @@ export declare function buildRelation(propName: string, property: Record<string,
 export declare function generatePivotTableName(sourceModel: string, targetModel: string): string;
 /** Get the return type hint for a relation. */
 export declare function getReturnType(relation: string): string;
+/**
+ * Resolve the child-table FK column for a OneToMany when `mappedBy` / `inversedBy`
+ * is absent. Prefer the single inverse ManyToOne on the target (omnify-go#166
+ * `column:` override included); if zero or multiple matches, fall back to the
+ * owning schema name — not the plural property name. Issue #237.
+ */
+export declare function resolveHasManyForeignKey(_propName: string, target: string, context?: RelationContext): string;
 /**
  * Build a chained `->orderBy('col', 'dir')` PHP fragment from an OrderByList.
  * Returns an empty string if no ordering is configured. Issue #40.

package/dist/php/relation-builder.js

@@ -16,7 +16,7 @@ export function buildRelation(propName, property, modelNamespace, context) {
             method = oneToOne(propName, property, target, modelNamespace);
             break;
         case 'OneToMany':
-            method = hasMany(propName, property, target, modelNamespace);
+            method = hasMany(propName, property, target, modelNamespace, context);
             break;
         case 'ManyToMany':
             method = belongsToMany(propName, property, target, modelNamespace, context);
@@ -39,6 +39,11 @@ export function buildRelation(propName, property, modelNamespace, context) {
     }
     if (method === null)
         return null;
+    const type = getReturnType(relation);
+    const related = relation === 'MorphTo'
+        ? '\\Illuminate\\Database\\Eloquent\\Model'
+        : '\\' + modelNamespace + '\\' + target;
+    method = method.replace('     */', `     * @return ${type}<${related}, $this>\n     */`);
     return { method, imports };
 }
 /** Generate the table name Laravel's joiningTable() infers from model basenames. */
@@ -92,9 +97,11 @@ function oneToOne(propName, property, target, ns) {
     }
     return belongsTo(propName, property, target, ns);
 }
-function hasMany(propName, property, target, ns) {
+function hasMany(propName, property, target, ns, context) {
     const inverse = property['mappedBy'] ?? property['inversedBy'] ?? null;
-    const foreignKey = inverse ? toFkColumnName(inverse) : toFkColumnName(propName);
+    const foreignKey = inverse
+        ? toFkColumnName(inverse)
+        : resolveHasManyForeignKey(propName, target, context);
     const methodName = toCamelCase(propName);
     const fqcn = `\\${ns}\\${target}`;
     const orderChain = formatOrderByChain(property['orderBy']);
@@ -106,6 +113,39 @@ function hasMany(propName, property, target, ns) {
         return $this->hasMany(${fqcn}::class, '${foreignKey}')${orderChain};
     }`;
 }
+/**
+ * Resolve the child-table FK column for a OneToMany when `mappedBy` / `inversedBy`
+ * is absent. Prefer the single inverse ManyToOne on the target (omnify-go#166
+ * `column:` override included); if zero or multiple matches, fall back to the
+ * owning schema name — not the plural property name. Issue #237.
+ */
+export function resolveHasManyForeignKey(_propName, target, context) {
+    const reader = context?.reader;
+    const owningSchemaName = context?.sourceSchemaName;
+    if (reader && owningSchemaName && target) {
+        const matches = findInverseManyToOneFkColumns(reader, target, owningSchemaName);
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        return toFkColumnName(owningSchemaName);
+    }
+    return toFkColumnName(_propName);
+}
+function findInverseManyToOneFkColumns(reader, targetSchemaName, owningSchemaName) {
+    const targetSchema = reader.getSchema(targetSchemaName);
+    const props = (targetSchema?.properties ?? {});
+    const columns = [];
+    for (const [childPropName, childProp] of Object.entries(props)) {
+        if (childProp['type'] !== 'Association')
+            continue;
+        if (childProp['relation'] !== 'ManyToOne')
+            continue;
+        if (childProp['target'] !== owningSchemaName)
+            continue;
+        columns.push(childProp['column'] || toFkColumnName(childPropName));
+    }
+    return columns;
+}
 /**
  * Build a chained `->orderBy('col', 'dir')` PHP fragment from an OrderByList.
  * Returns an empty string if no ordering is configured. Issue #40.

package/dist/php/request-generator.js

@@ -2,26 +2,8 @@
  * Port of RequestGenerator.php — generates Store/Update request classes.
  */
 import { toPascalCase, toSnakeCase, toCamelCase, toFkColumnName } from './naming-helper.js';
-import { toStoreRules, toUpdateRules, formatRules } from './type-mapper.js';
+import { toStoreRules, toUpdateRules, formatRules, resolveFkRuleType } from './type-mapper.js';
 import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup } from './types.js';
-/**
- * Resolve the Laravel validation rule type ('integer', 'uuid', or 'string') for
- * a foreign key column based on the target schema's primary key type.
- *
- * Mirrors the FK cast logic in `model-generator.ts` so validation rules and
- * Eloquent casts agree about the wire format. Issue #36.
- */
-function resolveFkRuleType(target, reader) {
-    if (!target)
-        return 'integer';
-    const targetSchema = reader.getSchema(target);
-    const id = targetSchema?.options?.id;
-    if (id === 'Uuid')
-        return 'uuid';
-    if (id === 'Ulid' || id === 'String')
-        return 'string';
-    return 'integer';
-}
 /** Generate Store/Update request classes for all project-owned visible object schemas. */
 export function generateRequests(reader, config) {
     const files = [];
@@ -105,7 +87,7 @@ function generateBaseRequest(name, schema, reader, config, action) {
             if (relation === 'ManyToOne') {
                 const snakeName = toFkColumnName(propName);
                 const target = prop['target'] ?? '';
-                const targetIdType = resolveFkRuleType(target, reader);
+                const targetIdType = resolveFkRuleType(prop, target, reader);
                 const rules = isUpdate
                     ? toUpdateRules(prop, tableName, modelRouteParam, targetIdType)
                     : toStoreRules(prop, tableName, targetIdType);
@@ -180,6 +162,58 @@ function generateBaseRequest(name, schema, reader, config, action) {
     const localesClass = `${modelLocalesNamespace}\\${modelName}Locales`;
     const attributeKeysList = attributeKeys.map(k => `            '${k}',`).join('\n');
     const needsRuleImport = rulesContent.includes('Rule::');
+    // WHICH KEYS THE LOCALES CLASS WILL ACTUALLY HOLD, which is not the same
+    // question as which keys exist. `locales-generator` skips every Association
+    // outright, while this generator pushes each ManyToOne's FK column into
+    // `attributeKeys` — so a schema whose properties are ALL associations gets a
+    // non-empty key list and an EMPTY PROPERTY_DISPLAY_NAMES, and the loop below
+    // then reads offsets off `array{}`: ten unfixable PHPStan errors per such schema.
+    //
+    // Measured twice. `PlanItem` hit it first and was dropped for an unrelated
+    // reason, which hid it; `PlanMembership` hit it again and could not be
+    // dropped, because a self-referential many-to-many is REFUSED as a pivot —
+    // omnify itself says "declare a regular `kind: object` schema with two
+    // ManyToOne associations". So it is a shape the generator prescribes and
+    // then cannot generate for.
+    //
+    // Fixing the LOCALES side instead — emitting association display names
+    // under their FK column — was tried and reverted: it is better semantically
+    // (a validation error would say 計画課題 rather than `plan_issue_id`) but it
+    // populates the constant for every schema in the repo, which makes PHPStan
+    // prove the `??` fallback chain dead and turns 0 errors into 317. Worth
+    // doing upstream, where the generated body can change with it. Not here.
+    const hasNamedAttributes = Object.values(properties).some((candidate) => (candidate?.type ?? 'String') !== 'Association');
+    const attributesBody = attributeKeys.length === 0 || !hasNamedAttributes
+        ? [
+            '    protected function schemaAttributes(): array',
+            '    {',
+            '        return [];',
+            '    }',
+        ].join('\n')
+        : [
+            '    protected function schemaAttributes(): array',
+            '    {',
+            "        $locale = app()->getLocale();",
+            "        $fallback = config('app.fallback_locale', 'en');",
+            `        $propertyNames = ${modelName}Locales::PROPERTY_DISPLAY_NAMES;`,
+            '        $attributes = [];',
+            '',
+            '        $keys = [',
+            attributeKeysList,
+            '        ];',
+            '',
+            '        foreach ($keys as $key) {',
+            '            $names = $propertyNames[$key] ?? [];',
+            "            $attributes[$key] = $names[$locale] ?? $names[$fallback] ?? $names[array_key_first($names) ?? 'en'] ?? $key;",
+            '        }',
+            '',
+            '        return $attributes;',
+            '    }',
+        ].join('\n');
+    // Only the non-empty body references the Locales class.
+    const localesImport = attributeKeys.length === 0 || !hasNamedAttributes
+        ? ''
+        : `\nuse ${localesClass};`;
     const ruleImport = needsRuleImport ? '\nuse Illuminate\\Validation\\Rule;' : '';
     const content = `<?php
 
@@ -192,8 +226,7 @@ namespace ${baseNamespace};
  * @generated by omnify
  */
 
-use Illuminate\\Foundation\\Http\\FormRequest;${ruleImport}
-use ${localesClass};
+use Illuminate\\Foundation\\Http\\FormRequest;${ruleImport}${localesImport}
 
 class ${modelName}${action}RequestBase extends FormRequest
 {
@@ -229,7 +262,7 @@ class ${modelName}${action}RequestBase extends FormRequest
     /**
      * Get the schema-defined validation rules.
      *
-     * @return array<string, array>
+     * @return array<string, array<mixed>>
      */
     protected function schemaRules(): array
     {
@@ -244,24 +277,7 @@ ${rulesContent}
      *
      * @return array<string, string>
      */
-    protected function schemaAttributes(): array
-    {
-        $locale = app()->getLocale();
-        $fallback = config('app.fallback_locale', 'en');
-        $propertyNames = ${modelName}Locales::PROPERTY_DISPLAY_NAMES;
-        $attributes = [];
-
-        $keys = [
-${attributeKeysList}
-        ];
-
-        foreach ($keys as $key) {
-            $names = $propertyNames[$key] ?? [];
-            $attributes[$key] = $names[$locale] ?? $names[$fallback] ?? $names[array_key_first($names) ?? 'en'] ?? $key;
-        }
-
-        return $attributes;
-    }
+${attributesBody}
 }
 `;
     // Issue #96 + #98 v5.8+: legacy honors flatBase + group-by-folder.

package/dist/php/resource-generator.js

@@ -165,6 +165,7 @@ namespace ${baseNamespace};
 
 ${useBlock}
 
+/** @mixin \\${modelNamespace}${schema.kind === 'pivot' ? '\\Pivot' : ''}\\${modelName} */
 class ${modelName}ResourceBase extends JsonResource
 {
     /**

package/dist/php/service-generator.js

@@ -554,7 +554,7 @@ function generateBaseService(name, schema, reader, config) {
     // ── Build class body ──────────────────────────────────────────────────────
     const sections = [];
     // Model property
-    sections.push(`    protected string $model = ${modelName}::class;`);
+    sections.push(`    /** @var class-string<${modelName}> */\n    protected string $model = ${modelName}::class;`);
     // ── Query section ─────────────────────────────────────────────────────────
     sections.push('');
     sections.push(buildSectionComment('Query'));
@@ -595,7 +595,7 @@ function generateBaseService(name, schema, reader, config) {
     // ── Eager Load Hooks (#81) ────────────────────────────────────────────────
     sections.push('');
     sections.push(buildSectionComment('Eager Load Hooks (#81)'));
-    sections.push(buildEagerLoadHooks());
+    sections.push(buildEagerLoadHooks(modelName));
     // ── Translatable helpers ──────────────────────────────────────────────────
     if (hasTranslatable) {
         sections.push('');
@@ -675,14 +675,14 @@ function buildSectionComment(title) {
  * config will be removed in a future major release per the #81
  * deprecation path.
  */
-function buildEagerLoadHooks() {
+function buildEagerLoadHooks(modelName) {
     return `
     /**
      * Override in the editable sibling service to eager-load relations
      * on the list() query. Default: no-op. Legacy schema-level eagerLoad
      * configuration still applies before this hook runs.
      *
-     * @param  \\Illuminate\\Database\\Eloquent\\Builder  $query
+     * @param  \\Illuminate\\Database\\Eloquent\\Builder<${modelName}>  $query
      */
     protected function applyListEagerLoads($query): void
     {
@@ -694,7 +694,7 @@ function buildEagerLoadHooks() {
      * Override in the editable sibling service to eager-load relations on
      * the findById() query. Default: no-op.
      *
-     * @param  \\Illuminate\\Database\\Eloquent\\Builder  $query
+     * @param  \\Illuminate\\Database\\Eloquent\\Builder<${modelName}>  $query
      */
     protected function applyFindByIdEagerLoads($query): void
     {
@@ -711,7 +711,7 @@ function buildEagerLoadHooks() {
      * the lookup() query. Default: no-op. Most lookup endpoints should
      * stay lean — eager loading defeats the point of a dropdown projection.
      *
-     * @param  \\Illuminate\\Database\\Eloquent\\Builder  $query
+     * @param  \\Illuminate\\Database\\Eloquent\\Builder<${modelName}>  $query
      */
     protected function applyLookupEagerLoads($query): void
     {
@@ -875,10 +875,7 @@ function buildListFilterShape(filterableFields, allowedSortColumns, hasSoftDelet
         lines.push(`     *     ${f.colName}?: ${phpType},`);
     }
     lines.push(`     *     search?: string,`);
-    const sortUnion = allowedSortColumns.length > 0
-        ? allowedSortColumns.flatMap(c => [`'${c}'`, `'-${c}'`]).join('|')
-        : 'string';
-    lines.push(`     *     sort?: ${sortUnion},`);
+    lines.push(`     *     sort?: string,`);
     lines.push(`     *     per_page?: int,`);
     if (hasSoftDelete) {
         lines.push(`     *     with_trashed?: bool,`);
@@ -1106,6 +1103,7 @@ function buildListMethod(modelName, searchableFields, filterableFields, sortable
      * @param array{
 ${filterShape}
      * } $filters
+     * @return LengthAwarePaginator<int, ${modelName}>
      *
 ${listExample}
      */
@@ -1188,11 +1186,15 @@ function resolvePhpFilterType(type) {
 }
 function buildFilterLine(f) {
     if (f.translatable) {
-        return `        $query->when(isset($filters['${f.colName}']), fn ($q) => $q->whereTranslation('${f.colName}', $filters['${f.colName}']));`;
+        return `        if (isset($filters['${f.colName}'])) {
+            $query->whereTranslation('${f.colName}', $filters['${f.colName}']);
+        }`;
     }
     switch (f.type) {
         case 'Boolean':
-            return `        $query->when(isset($filters['${f.colName}']), fn ($q) => $q->where('${f.colName}', $filters['${f.colName}']));`;
+            return `        if (isset($filters['${f.colName}'])) {
+            $query->where('${f.colName}', $filters['${f.colName}']);
+        }`;
         default:
             return `        $query->when($filters['${f.colName}'] ?? null, fn ($q, $v) => $q->where('${f.colName}', $v));`;
     }

package/dist/php/trait-generator.js

@@ -31,7 +31,7 @@ trait HasLocalizedDisplayName
     public static function displayName(?string $locale = null): string
     {
         $locale = $locale ?? app()->getLocale();
-        $displayNames = static::$localizedDisplayNames ?? [];
+        $displayNames = static::$localizedDisplayNames;
 
         return $displayNames[$locale]
             ?? $displayNames[config('app.fallback_locale', 'en')]
@@ -46,7 +46,7 @@ trait HasLocalizedDisplayName
      */
     public static function allDisplayNames(): array
     {
-        return static::$localizedDisplayNames ?? [];
+        return static::$localizedDisplayNames;
     }
 
     /**
@@ -88,7 +88,7 @@ trait HasLocalizedDisplayName
         $locale = $locale ?? app()->getLocale();
         $result = [];
 
-        foreach (static::$localizedPropertyDisplayNames ?? [] as $property => $displayNames) {
+        foreach (static::$localizedPropertyDisplayNames as $property => $displayNames) {
             $result[$property] = $displayNames[$locale]
                 ?? $displayNames[config('app.fallback_locale', 'en')]
                 ?? $displayNames[array_key_first($displayNames) ?? 'en']

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

@@ -1,7 +1,21 @@
 /**
  * Port of TypeMapper.php — type mappings for PHP casts, rules, resources.
  */
+import type { SchemaReader } from './schema-reader.js';
 type Rule = string | ['rule_in', string[]] | ['rule_unique_ignore', string, string];
+/**
+ * Effective primary-key type for a ManyToOne foreign key column.
+ * Property-level `idType:` wins (required for targets outside the schema set),
+ * then the target schema's `options.id`, then an integer-family default.
+ * Issue #237.
+ */
+export declare function resolveFkIdType(property: Record<string, unknown>, target: string, reader: SchemaReader): string;
+/** Laravel validation rule type for a ManyToOne FK (Issue #36, #237). */
+export declare function resolveFkRuleType(property: Record<string, unknown>, target: string, reader: SchemaReader): 'integer' | 'uuid' | 'string';
+/** Eloquent cast for a ManyToOne FK column. */
+export declare function resolveFkCast(property: Record<string, unknown>, target: string, reader: SchemaReader): 'integer' | 'string' | null;
+/** `@property` doc type for a ManyToOne FK column. */
+export declare function resolveFkPhpDocType(property: Record<string, unknown>, target: string, reader: SchemaReader, nullable: boolean): string;
 /** Map Omnify property type to PHP cast. */
 export declare function toCast(type: string, property?: Record<string, unknown>): string | null;
 /** Map Omnify property type to PHP doc type. */

package/dist/php/type-mapper.js

@@ -2,6 +2,49 @@
  * Port of TypeMapper.php — type mappings for PHP casts, rules, resources.
  */
 import { toTableName } from './naming-helper.js';
+/**
+ * Effective primary-key type for a ManyToOne foreign key column.
+ * Property-level `idType:` wins (required for targets outside the schema set),
+ * then the target schema's `options.id`, then an integer-family default.
+ * Issue #237.
+ */
+export function resolveFkIdType(property, target, reader) {
+    const override = property['idType'];
+    if (typeof override === 'string' && override !== '') {
+        return override;
+    }
+    if (!target)
+        return 'BigInt';
+    const targetSchema = reader.getSchema(target);
+    const id = targetSchema?.options?.id;
+    if (typeof id === 'string')
+        return id;
+    return 'BigInt';
+}
+/** Laravel validation rule type for a ManyToOne FK (Issue #36, #237). */
+export function resolveFkRuleType(property, target, reader) {
+    const idType = resolveFkIdType(property, target, reader);
+    if (idType === 'Uuid')
+        return 'uuid';
+    if (idType === 'Ulid' || idType === 'String')
+        return 'string';
+    return 'integer';
+}
+/** Eloquent cast for a ManyToOne FK column. */
+export function resolveFkCast(property, target, reader) {
+    const idType = resolveFkIdType(property, target, reader);
+    if (idType === 'Uuid' || idType === 'Ulid' || idType === 'String')
+        return 'string';
+    if (idType === 'Int' || idType === 'BigInt' || idType === 'TinyInt')
+        return 'integer';
+    return 'integer';
+}
+/** `@property` doc type for a ManyToOne FK column. */
+export function resolveFkPhpDocType(property, target, reader, nullable) {
+    const idType = resolveFkIdType(property, target, reader);
+    const phpType = idType === 'Int' || idType === 'BigInt' || idType === 'TinyInt' ? 'int' : 'string';
+    return nullable ? `${phpType}|null` : phpType;
+}
 /** Map Omnify property type to PHP cast. */
 export function toCast(type, property = {}) {
     switch (type) {
@@ -56,7 +99,7 @@ export function toPhpDocType(type, nullable = false) {
             phpType = 'mixed';
             break;
         case 'Json':
-            phpType = 'array';
+            phpType = 'array<array-key, mixed>';
             break;
         default:
             phpType = 'mixed';
@@ -85,11 +128,24 @@ export function toStoreRules(property, tableName, fkRuleType = 'integer') {
     const unique = property['unique'] ?? false;
     const vr = property['rules'];
     const rules = [];
-    // required/nullable — rules.required can override
-    const isRequired = vr?.['required'] !== undefined
-        ? vr['required']
+    // required/nullable/sometimes — rules.required can override; non-nullable + default → sometimes (#235)
+    const explicitRequired = vr?.['required'];
+    const hasExplicitRequired = explicitRequired !== undefined;
+    const isRequired = hasExplicitRequired
+        ? explicitRequired
         : !nullable;
-    rules.push(isRequired ? 'required' : 'nullable');
+    // `default: null` on a non-nullable column is contradictory YAML — treat it
+    // as no default so the column stays 'required' rather than silently optional.
+    const hasDefault = property['default'] !== undefined && property['default'] !== null;
+    if (!isRequired) {
+        rules.push('nullable');
+    }
+    else if (!hasExplicitRequired && !nullable && hasDefault) {
+        rules.push('sometimes');
+    }
+    else {
+        rules.push('required');
+    }
     switch (type) {
         case 'String':
         case 'Slug':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/ts",
-  "version": "6.7.13",
+  "version": "6.7.15",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",