@omnifyjp/ts 6.7.14 → 6.7.16

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';
@@ -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));

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,14 @@ 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 matches, fall back to the owning schema
+ * name (external targets). If two or more matches, throw — omnify-go#242.
+ * 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);
@@ -97,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']);
@@ -111,6 +113,44 @@ 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 matches, fall back to the owning schema
+ * name (external targets). If two or more matches, throw — omnify-go#242.
+ * 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];
+        }
+        if (matches.length >= 2) {
+            const columnList = matches.join(', ');
+            throw new Error(`${owningSchemaName}.${propName}: target ${target} has ${matches.length} ManyToOne associations back to ${owningSchemaName} (${columnList}) — set mappedBy: on the OneToMany to pick one`);
+        }
+        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);

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) {
@@ -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.14",
+  "version": "6.7.16",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",