@omnifyjp/ts 8.0.3 → 8.0.4

package/dist/php/audit-observer-generator.js

@@ -167,6 +167,8 @@ class Audit extends Model
     /**
      * The audited record. \`auditable_id\` is unconstrained so the audit
      * row survives a hard-delete of the source row.
+     *
+     * @return MorphTo<\\Illuminate\\Database\\Eloquent\\Model, $this>
      */
     public function auditable(): MorphTo
     {
@@ -176,6 +178,8 @@ class Audit extends Model
     /**
      * The actor who triggered the change. Null \`user_*\` columns
      * indicate a system-driven write (CLI, scheduled job, internal API).
+     *
+     * @return MorphTo<\\Illuminate\\Database\\Eloquent\\Model, $this>
      */
     public function user(): MorphTo
     {
@@ -192,6 +196,8 @@ class Audit extends Model
      *   - \`1y\`  → 1 year
      *
      * Empty / unparseable retention → matches no rows (kept forever).
+     *
+     * @return Builder<static>
      */
     public function prunable(): Builder
     {

package/dist/php/audit-trait-generator.js

@@ -50,6 +50,7 @@ namespace ${traitsNamespace};
  */
 
 use ${modelNamespace}\\Audit;
+use Illuminate\\Database\\Eloquent\\SoftDeletes;
 use Illuminate\\Support\\Facades\\Auth;
 use Illuminate\\Support\\Str;
 
@@ -84,16 +85,18 @@ trait HasOmnifyAuditLog
             $model->writeOmnifyAudit('updated', $old, $dirty);
         });
         static::deleted(function ($model) {
-            $event = method_exists($model, 'isForceDeleting') && $model->isForceDeleting()
-                ? 'deleted'
-                : (method_exists($model, 'trashed') ? 'soft_deleted' : 'deleted');
+            // class_uses_recursive, not method_exists: PHPStan evaluates the
+            // trait per using class and reports method_exists() as always
+            // true (or false) there.
+            $softDeletes = in_array(SoftDeletes::class, class_uses_recursive($model), true);
+            $event = $softDeletes && ! $model->isForceDeleting() ? 'soft_deleted' : 'deleted';
             $model->writeOmnifyAudit($event, $model->getOriginal(), null);
         });
-        if (method_exists(static::class, 'restored')) {
-            static::restored(function ($model) {
-                $model->writeOmnifyAudit('restored', null, $model->getAttributes());
-            });
-        }
+        // \`restored\` only fires for SoftDeletes models; registering the
+        // listener on any other model is a no-op.
+        static::registerModelEvent('restored', function ($model) {
+            $model->writeOmnifyAudit('restored', null, $model->getAttributes());
+        });
     }
 
     /**
@@ -187,7 +190,11 @@ trait HasOmnifyAuditLog
         $this->writeOmnifyAudit($event, $oldValues, $newValues);
     }
 
-    /** Eloquent relation back to every audit row that targets this model. */
+    /**
+     * Eloquent relation back to every audit row that targets this model.
+     *
+     * @return \\Illuminate\\Database\\Eloquent\\Relations\\MorphMany<Audit, $this>
+     */
     public function audits(): \\Illuminate\\Database\\Eloquent\\Relations\\MorphMany
     {
         return $this->morphMany(Audit::class, 'auditable');

package/dist/php/controller-generator.js

@@ -2,7 +2,7 @@
  * Generates base + editable controller classes for schemas with `options.api`.
  */
 import { toPascalCase } from './naming-helper.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup } from './types.js';
 import { buildControllerMethodAttributes, openApiControllerImports } from './openapi-generator.js';
 const DEFAULT_ACTIONS = ['index', 'store', 'show', 'update', 'destroy'];
 /** Generate controller classes for all schemas with api config. */
@@ -27,7 +27,14 @@ function generateBaseController(name, schema, reader, config) {
     const actions = [...(api.actions ?? DEFAULT_ACTIONS)];
     const lookup = api.lookup ?? true;
     const bulkDelete = api.bulkDelete ?? false;
-    const restore = api.restore ?? (schema.options?.softDelete ?? false);
+    // Restoring needs soft deletes: without them the service has no restore()
+    // or withTrashed lookup, so `api.restore: true` alone cannot be honoured.
+    const softDelete = schema.options?.softDelete ?? false;
+    const restore = softDelete && (api.restore ?? true);
+    if (api.restore === true && !softDelete) {
+        console.warn(`[omnify-ts] ${name}.options.api.restore is ignored (#301) — ${name} has no ` +
+            `softDelete, so there is nothing to restore. No restore action or route is generated.`);
+    }
     // Issue #98 v5.8.4 / v5.8.5: cross-layer imports must mirror where
     // the imported file actually lives. BASE layers (Models, Services
     // base, Controllers base) are ALWAYS group-nested in legacy structure.
@@ -51,24 +58,26 @@ function generateBaseController(name, schema, reader, config) {
     // and every project-owned service / policy that takes the
     // editable type fails with TypeError.
     const modelNs = groupNestEditable(config.models.userEditableNamespace, config.models);
-    const serviceBaseNs = config.structure === 'modular'
-        ? resolveModularBaseNamespace(config, name, 'Services', config.services.baseNamespace)
-        : groupNestBase(config.services.baseNamespace);
-    const requestNs = groupNestEditable(config.requests.namespace, config.requests);
-    const resourceNs = groupNestEditable(config.resources.namespace, config.resources);
+    // Each class the controller names must be one a generator actually writes,
+    // at the namespace and short name THAT generator uses: services and requests
+    // ship only their base (#101), resources also ship an editable stub (#114).
+    const service = baseClassRef(config, name, schema, 'services', 'Services', `${modelName}Service`);
+    const storeRequest = baseClassRef(config, name, schema, 'requests', 'Requests', `${modelName}StoreRequest`);
+    const updateRequest = baseClassRef(config, name, schema, 'requests', 'Requests', `${modelName}UpdateRequest`);
+    const resource = editableResourceRef(config, schema, modelName);
     // Build imports
     const imports = [
         `use App\\Http\\Controllers\\Controller;`,
-        `use ${serviceBaseNs}\\${modelName}ServiceBase;`,
+        `use ${service.fqn};`,
     ];
     if (actions.includes('store')) {
-        imports.push(`use ${requestNs}\\${modelName}StoreRequest;`);
+        imports.push(`use ${storeRequest.fqn};`);
     }
     if (actions.includes('update')) {
-        imports.push(`use ${requestNs}\\${modelName}UpdateRequest;`);
+        imports.push(`use ${updateRequest.fqn};`);
     }
-    if (actions.includes('show') || actions.includes('update') || actions.includes('destroy') || restore) {
-        imports.push(`use ${resourceNs}\\${modelName}Resource;`);
+    if (actions.includes('index') || lookup || actions.includes('show') || actions.includes('store') || actions.includes('update') || restore) {
+        imports.push(`use ${resource.fqn};`);
     }
     imports.push(`use ${modelNs}\\${modelName};`);
     imports.push(`use Illuminate\\Http\\JsonResponse;`);
@@ -95,34 +104,34 @@ function generateBaseController(name, schema, reader, config) {
     {
         $result = $this->service->list($request->all());
 
-        return ${modelName}Resource::collection($result);
+        return ${resource.className}::collection($result);
     }`);
     }
     if (actions.includes('store')) {
         methods.push(`${attrFor('store')}
-    public function store(${modelName}StoreRequest $request): JsonResponse
+    public function store(${storeRequest.className} $request): JsonResponse
     {
         $model = $this->service->create($request->validated());
 
-        return (new ${modelName}Resource($model))
+        return (new ${resource.className}($model))
             ->response()
             ->setStatusCode(201);
     }`);
     }
     if (actions.includes('show')) {
         methods.push(`${attrFor('show')}
-    public function show(${modelName} $model): ${modelName}Resource
+    public function show(${modelName} $model): ${resource.className}
     {
-        return new ${modelName}Resource($model);
+        return new ${resource.className}($model);
     }`);
     }
     if (actions.includes('update')) {
         methods.push(`${attrFor('update')}
-    public function update(${modelName}UpdateRequest $request, ${modelName} $model): ${modelName}Resource
+    public function update(${updateRequest.className} $request, ${modelName} $model): ${resource.className}
     {
         $model = $this->service->update($model, $request->validated());
 
-        return new ${modelName}Resource($model);
+        return new ${resource.className}($model);
     }`);
     }
     if (actions.includes('destroy')) {
@@ -140,25 +149,29 @@ function generateBaseController(name, schema, reader, config) {
     {
         $result = $this->service->lookup($request->all());
 
-        return ${modelName}Resource::collection($result);
+        return ${resource.className}::collection($result);
     }`);
     }
     if (bulkDelete) {
         methods.push(`${attrFor('bulkDelete')}
     public function bulkDelete(Request $request): JsonResponse
     {
-        $this->service->bulkDelete($request->input('ids', []));
+        // The service has no bulk method: delete each record through it, so
+        // soft deletes, model events and auditing apply as for destroy().
+        foreach ((array) $request->input('ids', []) as $id) {
+            $this->service->delete($this->service->findById((string) $id));
+        }
 
         return response()->json(null, 204);
     }`);
     }
     if (restore) {
         methods.push(`${attrFor('restore')}
-    public function restore(string $id): ${modelName}Resource
+    public function restore(string $id): ${resource.className}
     {
-        $model = $this->service->restore($id);
+        $model = $this->service->restore($this->service->findById($id, withTrashed: true));
 
-        return new ${modelName}Resource($model);
+        return new ${resource.className}($model);
     }`);
     }
     const content = `<?php
@@ -177,7 +190,7 @@ ${imports.join('\n')}
 abstract class ${modelName}ControllerBase extends Controller
 {
     public function __construct(
-        protected readonly ${modelName}ServiceBase $service,
+        protected readonly ${service.className} $service,
     ) {}
 ${methods.join('\n')}
 }
@@ -254,3 +267,26 @@ function legacyGroupedBase(config, className, group) {
     const { namespace } = nestByGroup({ path: '', namespace: raw.namespace }, group);
     return { className: raw.className, fqn: `${namespace}\\${raw.className}` };
 }
+/**
+ * The base class a scaffold generator writes for `schemaName`, as that
+ * generator names and places it: modular → `<Name>Base` in the module, legacy
+ * → `resolveBaseClass` (flatBase drops the suffix) nested under the group.
+ */
+function baseClassRef(config, name, schema, layer, modularFolder, className) {
+    if (config.structure === 'modular') {
+        const ns = resolveModularBaseNamespace(config, name, modularFolder, config[layer].baseNamespace);
+        return { className: `${className}Base`, fqn: `${ns}\\${className}Base` };
+    }
+    const raw = resolveBaseClass(config[layer], className, 'Base');
+    const { namespace } = nestByGroup({ path: '', namespace: raw.namespace }, schema.group);
+    return { className: raw.className, fqn: `${namespace}\\${raw.className}` };
+}
+/** The editable Resource stub the resource generator writes (#114). */
+function editableResourceRef(config, schema, modelName) {
+    if (config.structure === 'modular') {
+        return { className: `${modelName}Resource`, fqn: `${config.resources.namespace}\\${modelName}Resource` };
+    }
+    const raw = resolveEditableClass(config.resources, modelName, 'Resource');
+    const { namespace } = nestEditableByGroup(config.resources, { path: raw.path, namespace: raw.namespace }, schema.group);
+    return { className: raw.className, fqn: `${namespace}\\${raw.className}` };
+}

package/dist/php/factory-generator.js

@@ -3,7 +3,7 @@
  */
 import { toPascalCase } from './naming-helper.js';
 import { toFaker, compoundFaker, associationFaker } from './faker-mapper.js';
-import { userFile } from './types.js';
+import { userFile, resolveGlobalEnumNamespace } from './types.js';
 /** Generate Factory classes for all project-owned visible object schemas. */
 export function generateFactories(reader, config) {
     const files = [];
@@ -148,6 +148,9 @@ export function generateFileFactory(reader, config) {
         return [];
     const modelNamespace = config.models.namespace;
     const factoryNamespace = config.factories.namespace;
+    // FileStatusEnum is a global enum (file-model-generator casts it from here),
+    // not a class in the models namespace.
+    const enumNamespace = resolveGlobalEnumNamespace(config, config.models.namespace);
     const content = `<?php
 
 /**
@@ -159,7 +162,7 @@ export function generateFileFactory(reader, config) {
 namespace ${factoryNamespace};
 
 use ${modelNamespace}\\File;
-use ${modelNamespace}\\FileStatusEnum;
+use ${enumNamespace}\\FileStatusEnum;
 use Illuminate\\Database\\Eloquent\\Factories\\Factory;
 use Illuminate\\Support\\Str;
 

package/dist/php/faker-mapper.js

@@ -40,14 +40,17 @@ export function toFaker(propName, property, schemas = {}) {
 /** Generate faker expressions for compound type expanded columns. */
 export function compoundFaker(propName, expansion, sourceType) {
     const snakeName = toSnakeCase(propName);
+    // Locale-only providers (ja_JP kana names, ward, en secondaryAddress) are
+    // called through format(): Faker's Generator declares no @method for them,
+    // so a direct call is "undefined method" to static analysis.
     const jaFaker = "fake('ja_JP')";
     switch (sourceType) {
         case 'JapaneseName':
             return [
                 `'${snakeName}_lastname' => ${jaFaker}->lastName(),`,
                 `'${snakeName}_firstname' => ${jaFaker}->firstName(),`,
-                `'${snakeName}_kana_lastname' => ${jaFaker}->lastKanaName(),`,
-                `'${snakeName}_kana_firstname' => ${jaFaker}->firstKanaName(),`,
+                `'${snakeName}_kana_lastname' => ${jaFaker}->format('lastKanaName'),`,
+                `'${snakeName}_kana_firstname' => ${jaFaker}->format('firstKanaName'),`,
             ];
         case 'JapaneseAddress':
             return japaneseAddressFaker(snakeName, expansion);
@@ -57,7 +60,7 @@ export function compoundFaker(propName, expansion, sourceType) {
                 `'${snakeName}_branch_code' => ${jaFaker}->regexify('[0-9]{3}'),`,
                 `'${snakeName}_account_type' => ${jaFaker}->randomElement(['1', '2', '4']),`,
                 `'${snakeName}_account_number' => ${jaFaker}->regexify('[0-9]{7}'),`,
-                `'${snakeName}_account_holder' => ${jaFaker}->lastKanaName().' '.${jaFaker}->firstKanaName(),`,
+                `'${snakeName}_account_holder' => ${jaFaker}->format('lastKanaName').' '.${jaFaker}->format('firstKanaName'),`,
             ];
         default:
             return genericCompoundFaker(snakeName, expansion);
@@ -73,7 +76,8 @@ export function associationFaker(propName, property, modelNamespace, currentSche
     const nullable = property['nullable'] ?? false;
     const fake = nullable
         ? `'${foreignKey}' => ${target}::query()->inRandomOrder()->first()?->id,`
-        : `'${foreignKey}' => ${target}::query()->inRandomOrder()->first()?->id ?? ${target}::factory()->create()->id,`;
+        // `->id ??`, not `?->id ??`: `??` already reads a property of null as null.
+        : `'${foreignKey}' => ${target}::query()->inRandomOrder()->first()->id ?? ${target}::factory()->create()->id,`;
     let importLine = null;
     if (target !== currentSchema) {
         const targetNs = property['targetNamespace'] ?? modelNamespace;
@@ -136,8 +140,10 @@ function stringFakerExpr(propName, snakeName, property) {
     if (lower.includes('code'))
         return `fake()->unique()->regexify('[A-Z0-9]{8}')`;
     const length = property['length'];
+    // text(), not words(3, true): words() is typed array|string, and every
+    // String column is wrapped in mb_substr(), which needs a string.
     if (length != null && length <= 50)
-        return `fake()->words(3, true)`;
+        return `fake()->text(50)`;
     return `fake()->sentence()`;
 }
 /** Largest value a `Decimal(precision, scale)` column accepts (all-9s at that precision/scale). */
@@ -221,9 +227,9 @@ function japaneseAddressFaker(snakeName, expansion) {
     else {
         lines.push(`'${snakeName}_prefecture' => fake()->randomElement(['hokkaido', 'aomori', 'iwate', 'miyagi', 'akita', 'yamagata', 'fukushima', 'ibaraki', 'tochigi', 'gunma', 'saitama', 'chiba', 'tokyo', 'kanagawa', 'niigata', 'toyama', 'ishikawa', 'fukui', 'yamanashi', 'nagano', 'gifu', 'shizuoka', 'aichi', 'mie', 'shiga', 'kyoto', 'osaka', 'hyogo', 'nara', 'wakayama', 'tottori', 'shimane', 'okayama', 'hiroshima', 'yamaguchi', 'tokushima', 'kagawa', 'ehime', 'kochi', 'fukuoka', 'saga', 'nagasaki', 'kumamoto', 'oita', 'miyazaki', 'kagoshima', 'okinawa']),`);
     }
-    lines.push(`'${snakeName}_address1' => ${jaFaker}->city().${jaFaker}->ward(),`);
+    lines.push(`'${snakeName}_address1' => ${jaFaker}->city().${jaFaker}->format('ward'),`);
     lines.push(`'${snakeName}_address2' => ${jaFaker}->streetAddress(),`);
-    lines.push(`'${snakeName}_address3' => ${jaFaker}->optional()->secondaryAddress(),`);
+    lines.push(`'${snakeName}_address3' => ${jaFaker}->optional()->format('secondaryAddress'),`);
     return lines;
 }
 function genericCompoundFaker(snakeName, expansion) {

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

@@ -39,6 +39,7 @@ namespace ${baseNamespace};
 use Illuminate\\Http\\Request;
 use Illuminate\\Http\\Resources\\Json\\JsonResource;
 
+/** @mixin \\${config.models.namespace}\\File */
 class FileResourceBase extends JsonResource
 {
     /**
@@ -56,7 +57,7 @@ class FileResourceBase extends JsonResource
             'original_name' => $this->original_name,
             'mime_type' => $this->mime_type,
             'size' => $this->size,
-            'status' => $this->status?->value,
+            'status' => $this->status->value,
             'url' => $this->url ?? null,
             'expires_at' => $this->expires_at?->toISOString(),
             'sort_order' => $this->sort_order,
@@ -167,11 +168,15 @@ class FileBaseModel extends BaseModel
 
     /**
      * Localized display names for this model.
+     *
+     * @var array<string, string>
      */
     protected static array $localizedDisplayNames = FileLocales::DISPLAY_NAMES;
 
     /**
      * Localized display names for properties.
+     *
+     * @var array<string, array<string, string>>
      */
     protected static array $localizedPropertyDisplayNames = FileLocales::PROPERTY_DISPLAY_NAMES;
 
@@ -212,6 +217,8 @@ class FileBaseModel extends BaseModel
 
     /**
      * Get the parent fileable model.
+     *
+     * @return MorphTo<\\Illuminate\\Database\\Eloquent\\Model, $this>
      */
     public function fileable(): MorphTo
     {
@@ -224,6 +231,9 @@ class FileBaseModel extends BaseModel
 
     /**
      * Scope to a specific collection.
+     *
+     * @param  Builder<self>  $query
+     * @return Builder<self>
      */
     public function scopeInCollection(Builder $query, string $collection): Builder
     {
@@ -232,6 +242,9 @@ class FileBaseModel extends BaseModel
 
     /**
      * Scope to permanent files.
+     *
+     * @param  Builder<self>  $query
+     * @return Builder<self>
      */
     public function scopePermanent(Builder $query): Builder
     {
@@ -240,6 +253,9 @@ class FileBaseModel extends BaseModel
 
     /**
      * Scope to temporary files.
+     *
+     * @param  Builder<self>  $query
+     * @return Builder<self>
      */
     public function scopeTemporary(Builder $query): Builder
     {
@@ -248,6 +264,9 @@ class FileBaseModel extends BaseModel
 
     /**
      * Scope to expired files (temporary + past expires_at).
+     *
+     * @param  Builder<self>  $query
+     * @return Builder<self>
      */
     public function scopeExpired(Builder $query): Builder
     {
@@ -317,6 +336,7 @@ use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
  */
 class File extends FileBaseModel
 {
+    /** @use HasFactory<FileFactory> */
     use HasFactory;
 
     /**

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

@@ -30,6 +30,8 @@ trait HasFiles
 {
     /**
      * Get all files attached to this model.
+     *
+     * @return MorphMany<File, $this>
      */
     public function files(): MorphMany
     {
@@ -38,6 +40,8 @@ trait HasFiles
 
     /**
      * Get files in a specific collection.
+     *
+     * @return MorphMany<File, $this>
      */
     public function filesInCollection(string $collection): MorphMany
     {
@@ -46,6 +50,8 @@ trait HasFiles
 
     /**
      * Get all permanent files.
+     *
+     * @return MorphMany<File, $this>
      */
     public function permanentFiles(): MorphMany
     {
@@ -69,8 +75,13 @@ trait HasFiles
             'collection' => $collection,
             'status' => FileStatusEnum::Permanent,
             'expires_at' => null,
-            'sort_order' => \\Illuminate\\Support\\Facades\\DB::raw('sort_order + '.$startOrder),
         ]);
+
+        // increment(), not DB::raw('sort_order + '.$startOrder): raw SQL is
+        // typed literal-string, and a column offset needs no SQL of our own.
+        if ($startOrder !== 0) {
+            File::whereIn('id', $fileIds)->increment('sort_order', $startOrder);
+        }
     }
 
     /**

package/dist/php/model-generator.js

@@ -443,15 +443,20 @@ function generateUserModel(name, schema, reader, config, hasNestedSet = false) {
     const baseImport = baseAlias === base.className
         ? `use ${base.fqn};`
         : `use ${base.fqn} as ${baseAlias};`;
-    const imports = [
-        baseImport,
-        `use ${factoryNamespace}\\${modelName}Factory;`,
-        `use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;`,
-    ];
+    // The factory generator skips hidden schemas, so a hidden schema's stub
+    // must not name a factory that is never written.
+    const hasFactory = !schema.options?.hidden;
+    const imports = hasFactory
+        ? [
+            baseImport,
+            `use ${factoryNamespace}\\${modelName}Factory;`,
+            `use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;`,
+        ]
+        : [baseImport];
     if (hasNestedSet) {
         imports.push(`use ${nestedSetNamespace}\\NodeTrait;`);
     }
-    const traits = [`    /** @use HasFactory<${modelName}Factory> */\n    use HasFactory;`];
+    const traits = hasFactory ? [`    /** @use HasFactory<${modelName}Factory> */\n    use HasFactory;`] : [];
     if (hasNestedSet) {
         traits.push('    use NodeTrait;');
     }
@@ -481,7 +486,7 @@ ${imports.join('\n')}
  */
 class ${modelName} extends ${baseAlias}
 {
-${traits.join('\n')}
+${hasFactory ? `${traits.join('\n')}
 
     /**
      * Create a new factory instance for the model.
@@ -491,7 +496,9 @@ ${traits.join('\n')}
         return ${modelName}Factory::new();
     }
 
-    //
+` : traits.length > 0 ? `${traits.join('\n')}
+
+` : ''}    //
 }
 `;
     // #171: this subclass is created once and then owned by the project. The
@@ -1087,19 +1094,24 @@ function buildAccessors(expandedProperties) {
     for (const [propName, expansion] of Object.entries(expandedProperties)) {
         const sourceType = expansion.sourceType ?? '';
         const snakeName = toSnakeCase(propName);
+        // A column absent from the expansion is treated as nullable (safe side).
+        const nullable = (column) => {
+            const col = expansion.columns?.find((c) => c.name === column);
+            return col === undefined ? true : (col.nullable ?? false);
+        };
         switch (sourceType) {
             case 'JapaneseName':
                 methods.push(fullNameAccessor(snakeName, 'FullName', [
                     `${snakeName}_lastname`, `${snakeName}_firstname`,
-                ], ' '));
+                ], ' ', nullable));
                 methods.push(fullNameAccessor(snakeName, 'FullNameKana', [
                     `${snakeName}_kana_lastname`, `${snakeName}_kana_firstname`,
-                ], ' '));
+                ], ' ', nullable));
                 break;
             case 'JapaneseAddress':
                 methods.push(fullNameAccessor(snakeName, 'FullAddress', [
                     `${snakeName}_address1`, `${snakeName}_address2`, `${snakeName}_address3`,
-                ], ''));
+                ], '', nullable));
                 break;
         }
     }
@@ -1347,6 +1359,8 @@ function buildFileAccessors(properties, propertyOrder, modelNamespace) {
             methods.push(`
     /**
      * Get ${propName} files (collection: ${collection}).
+     *
+     * @return MorphMany<File, $this>
      */
     public function ${methodName}(): MorphMany
     {
@@ -1357,6 +1371,8 @@ function buildFileAccessors(properties, propertyOrder, modelNamespace) {
             methods.push(`
     /**
      * Get ${propName} file (collection: ${collection}).
+     *
+     * @return MorphOne<File, $this>
      */
     public function ${methodName}(): MorphOne
     {
@@ -1367,17 +1383,20 @@ function buildFileAccessors(properties, propertyOrder, modelNamespace) {
     }
     return methods.join('\n');
 }
-function fullNameAccessor(prefix, suffix, fields, separator) {
+function fullNameAccessor(prefix, suffix, fields, separator, isNullable) {
     const methodName = 'get' + toPascalCase(prefix) + suffix + 'Attribute';
     const fieldAccess = fields.map(f => `$this->${f}`).join(', ');
     const separatorArg = separator === '' ? "''" : `'${separator}'`;
+    // `$v !== null` on parts that are all non-nullable columns is dead code
+    // (PHPStan notIdentical.alwaysTrue); keep it only when a part can be null.
+    const keep = fields.some(isNullable) ? "$v !== null && $v !== ''" : "$v !== ''";
     return `
     /**
      * Get the ${prefix} ${suffix} attribute.
      */
     public function ${methodName}(): ?string
     {
-        $parts = array_filter([${fieldAccess}], fn($v) => $v !== null && $v !== '');
+        $parts = array_filter([${fieldAccess}], fn($v) => ${keep});
         return count($parts) > 0 ? implode(${separatorArg}, $parts) : null;
     }`;
 }

package/dist/php/route-generator.js

@@ -23,7 +23,10 @@ function generateRouteFile(name, schema, config) {
     const actions = [...(api.actions ?? DEFAULT_ACTIONS)];
     const lookup = api.lookup ?? true;
     const bulkDelete = api.bulkDelete ?? false;
-    const restore = api.restore ?? (schema.options?.softDelete ?? false);
+    // Restoring needs soft deletes: without them the service has no restore()
+    // or withTrashed lookup, so `api.restore: true` alone cannot be honoured.
+    const softDelete = schema.options?.softDelete ?? false;
+    const restore = softDelete && (api.restore ?? true);
     const middleware = api.middleware ?? [];
     // Route prefix: use api.prefix or default to snake_case plural
     const prefix = api.prefix ?? pluralize(toSnakeCase(name));
@@ -31,9 +34,14 @@ function generateRouteFile(name, schema, config) {
     const routeParam = toCamelCase(name);
     // Controller namespace
     const group = schema.group ? toPascalCase(schema.group) : null;
+    // The editable controller lives where generateUserController writes it:
+    // under userEditableNamespace (legacy), not the base layer's namespace.
+    const controllerRoot = config.structure === 'modular'
+        ? config.controllers.namespace
+        : config.controllers.userEditableNamespace;
     const controllerNs = group
-        ? `${config.controllers.namespace}\\Api\\V1\\${group}`
-        : `${config.controllers.namespace}\\Api\\V1`;
+        ? `${controllerRoot}\\Api\\V1\\${group}`
+        : `${controllerRoot}\\Api\\V1`;
     // Build use statements
     const useStatements = [
         `use ${controllerNs}\\${modelName}Controller;`,

package/package.json

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