@omnifyjp/ts 6.8.1 → 7.0.1

package/dist/cli.js

@@ -30,10 +30,8 @@ import { parse as parseYaml } from 'yaml';
 import { generateTypeScript } from './generator.js';
 import { generatePhp, derivePhpConfig } from './php/index.js';
 import { evaluateShadowingConflicts } from './php/shadowing-conflicts.js';
-import { hasEditableSubclassForBase, pruneDisabledScaffoldLayerBases, pruneOrphanServiceFilesIfEnabled } from './php/orphan-cleanup.js';
+import { collectReferencedClasses, hasEditableSubclassForBase, pruneDisabledScaffoldLayerBases, pruneOrphanServiceFilesIfEnabled } from './php/orphan-cleanup.js';
 import { findSiblingWithSameBasename, findAppRootAncestor } from './php/sibling-skip.js';
-import { runPintFormat } from './php/pint-format.js';
-import { runPrettierFormat } from './prettier-format.js';
 import { resolveInput, sniffInputKind } from './input-resolver.js';
 function resolveFromConfig(configPath) {
     const raw = readFileSync(configPath, 'utf-8');
@@ -195,7 +193,6 @@ program
         let tsCreated = 0;
         let tsOverwritten = 0;
         let tsSkipped = 0;
-        const tsWrittenPaths = [];
         for (const file of files) {
             let filePath;
             if (file.category === 'enum' || file.category === 'plugin-enum') {
@@ -210,7 +207,6 @@ program
                 continue;
             }
             writeFileSync(filePath, file.content, 'utf-8');
-            tsWrittenPaths.push(filePath);
             if (file.overwrite || !existsSync(filePath)) {
                 tsOverwritten++;
             }
@@ -223,22 +219,6 @@ program
             console.log(`  ${tsCreated} files created (user-editable)`);
         if (tsSkipped > 0)
             console.log(`  ${tsSkipped} files skipped (already exist)`);
-        // Issue #211: format via the consumer project's Prettier (same idea as Pint for PHP).
-        if (tsWrittenPaths.length > 0) {
-            const prettierResult = runPrettierFormat(tsWrittenPaths);
-            if (prettierResult.ran) {
-                if (prettierResult.exitStatus === 0) {
-                    console.log(`  Formatted ${prettierResult.formattedCount} TS file(s) via Prettier`);
-                }
-                else {
-                    console.warn(`  [omnify] Prettier exited with status ${prettierResult.exitStatus}; generated files may not match project formatting preset.`);
-                    if (prettierResult.errorMessage) {
-                        const trimmed = prettierResult.errorMessage.trim().split('\n').slice(0, 5).join('\n');
-                        console.warn(`  ${trimmed}`);
-                    }
-                }
-            }
-        }
     }
     else {
         console.log(`\n[TypeScript] Skipped (disabled)`);
@@ -248,9 +228,12 @@ program
         console.log(`\n[Laravel] Generating PHP files`);
         // #255: a disabled scaffold layer still regenerates the bases that
         // hand-written subclasses extend, so they track the schema.
+        // Read before anything is written, so the answer reflects the project's
+        // own code, not this run's output.
         const phpConfigForGen = derivePhpConfig(laravelOverrides);
+        const referencedClasses = collectReferencedClasses(configDir, phpConfigForGen);
         const phpFiles = generatePhp(input, laravelOverrides, {
-            keepDisabledBase: (file) => hasEditableSubclassForBase(configDir, phpConfigForGen, file),
+            keepDisabledBase: (file) => hasEditableSubclassForBase(phpConfigForGen, referencedClasses, file),
         });
         let phpCreated = 0;
         let phpOverwritten = 0;
@@ -259,7 +242,6 @@ program
         let phpShadowedOutOfSync = 0;
         let phpShadowedAtRisk = 0;
         const skippedSiblingExamples = [];
-        const writtenPaths = [];
         for (const file of phpFiles) {
             const filePath = resolve(configDir, file.path);
             mkdirSync(dirname(filePath), { recursive: true });
@@ -323,7 +305,6 @@ program
                 }
             }
             writeFileSync(filePath, file.content, 'utf-8');
-            writtenPaths.push(filePath);
             if (file.overwrite || !existsSync(filePath)) {
                 phpOverwritten++;
             }
@@ -355,48 +336,13 @@ program
                 console.log(`    ... and ${phpSkippedSibling - skippedSiblingExamples.length} more`);
             }
         }
-        // Issue #100 v5.8.20: auto-format every written PHP file via
-        // Laravel Pint when it's installed in the project. Same preset
-        // the project's CI already uses, so codegen output stops failing
-        // `pint --test` and devs no longer need a manual sweep after
-        // every `omnify generate`.
-        //
-        // NOT a silent no-op when Pint is missing any more. It used to be, and that cost a
-        // consumer several investigation sessions: their CI regenerated without Pint on PATH,
-        // wrote 927 files differing from the committed (Pint-formatted) tree, and the only
-        // evidence was one ABSENT log line. It was read as a Linux/Darwin build divergence and
-        // chased as far as "pick a canonical platform" before anyone ran the two commands that
-        // settle it (godx-jp/godx-corebooks#108, reproduced exactly: hide `vendor/bin/pint`,
-        // regenerate, 927 files; restore it, 0).
-        //
-        // The opt-out (`OMNIFY_NO_PINT=1`) stays quiet — that one is a choice, not a surprise.
-        if (writtenPaths.length > 0) {
-            const pintResult = runPintFormat(writtenPaths);
-            if (pintResult.ran) {
-                if (pintResult.exitStatus === 0) {
-                    console.log(`  Formatted ${pintResult.formattedCount} PHP file(s) via Laravel Pint`);
-                }
-                else {
-                    console.warn(`  [omnify] Laravel Pint exited with status ${pintResult.exitStatus}; generated files may not match project formatting preset.`);
-                    if (pintResult.errorMessage) {
-                        const trimmed = pintResult.errorMessage.trim().split('\n').slice(0, 5).join('\n');
-                        console.warn(`  ${trimmed}`);
-                    }
-                }
-            }
-            else if (pintResult.skipped === 'pint-not-found') {
-                console.warn(`  [omnify] Laravel Pint not found — ${writtenPaths.length} PHP file(s) written UNFORMATTED.`);
-                console.warn('  If this project commits generated PHP, the output will differ from a tree formatted by Pint.');
-                console.warn('  Run `composer install` before `omnify generate`, or set OMNIFY_NO_PINT=1 to silence this deliberately.');
-            }
-        }
         // Orphan cleanup: when a schema is removed, renamed, flipped from
         // kind:object → kind:pivot, or opted out via `options.service: false`,
         // its previously-emitted `*ServiceBase.php` becomes orphan and
         // pollutes Composer autoload. Prune base files automatically; warn
         // about editable `*Service.php` (may contain user code).
         const phpConfig = derivePhpConfig(laravelOverrides);
-        for (const summary of pruneDisabledScaffoldLayerBases(configDir, phpConfig, phpFiles)) {
+        for (const summary of pruneDisabledScaffoldLayerBases(configDir, phpConfig, phpFiles, referencedClasses)) {
             if (summary.prunedCount > 0) {
                 console.log(`  pruned ${summary.prunedCount} stale ${summary.label}(s) — layer disabled`);
             }

package/dist/php/controller-generator.js

@@ -208,7 +208,7 @@ function generateUserController(name, schema, config) {
             className: `${modelName}ControllerBase`,
             fqn: `${resolveModularBaseNamespace(config, name, 'Controllers', config.controllers.baseNamespace)}\\${modelName}ControllerBase`,
         }
-        : resolveBaseClass(config.controllers, `${modelName}Controller`, 'Base');
+        : legacyGroupedBase(config, `${modelName}Controller`, schema.group);
     const editable = config.structure === 'modular'
         ? { className: `${modelName}Controller`, fileName: `${modelName}Controller.php`, namespace: config.controllers.namespace, path: config.controllers.path }
         : resolveEditableClass(config.controllers, modelName, 'Controller');
@@ -244,3 +244,13 @@ class ${editable.className} extends ${baseAlias}
 `;
     return userFile(`${userPath}/${editable.fileName}`, content);
 }
+/**
+ * Legacy layout nests the base controller under its schema group (see
+ * `generateBaseController`), so the stub must import it from the same nested
+ * namespace — a flat import names a class that does not exist.
+ */
+function legacyGroupedBase(config, className, group) {
+    const raw = resolveBaseClass(config.controllers, className, 'Base');
+    const { namespace } = nestByGroup({ path: '', namespace: raw.namespace }, group);
+    return { className: raw.className, fqn: `${namespace}\\${raw.className}` };
+}

package/dist/php/factory-generator.js

@@ -178,7 +178,7 @@ class FileFactory extends Factory
     public function definition(): array
     {
         $extension = fake()->randomElement(['jpg', 'png', 'pdf', 'docx']);
-        $originalName = fake()->word() . '.' . $extension;
+        $originalName = fake()->word().'.'.$extension;
         $mimeTypes = [
             'jpg' => 'image/jpeg',
             'png' => 'image/png',
@@ -189,7 +189,7 @@ class FileFactory extends Factory
         return [
             'collection' => 'default',
             'disk' => 'public',
-            'path' => 'files/' . now()->format('Y/m') . '/' . Str::uuid() . '.' . $extension,
+            'path' => 'files/'.now()->format('Y/m').'/'.Str::uuid().'.'.$extension,
             'original_name' => $originalName,
             'mime_type' => $mimeTypes[$extension] ?? 'application/octet-stream',
             'size' => fake()->numberBetween(1024, 10485760),

package/dist/php/faker-mapper.js

@@ -57,7 +57,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}->lastKanaName().' '.${jaFaker}->firstKanaName(),`,
             ];
         default:
             return genericCompoundFaker(snakeName, expansion);
@@ -96,7 +96,7 @@ function stringFaker(propName, snakeName, property) {
     if (lower.includes('url') || lower.includes('website'))
         return `'${snakeName}' => fake()->url(),`;
     if (lower.includes('path') || lower.includes('file'))
-        return `'${snakeName}' => 'uploads/' . fake()->uuid() . '.jpg',`;
+        return `'${snakeName}' => 'uploads/'.fake()->uuid().'.jpg',`;
     if (propName === 'name' || propName === 'title')
         return `'${snakeName}' => fake()->sentence(3),`;
     if (lower.includes('name'))
@@ -183,7 +183,7 @@ 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}->ward(),`);
     lines.push(`'${snakeName}_address2' => ${jaFaker}->streetAddress(),`);
     lines.push(`'${snakeName}_address3' => ${jaFaker}->optional()->secondaryAddress(),`);
     return lines;

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

@@ -68,12 +68,16 @@ class CleanupFiles extends Command
 
         if ($phase === null || $phase === '1') {
             $r = $this->phase1SoftDelete($dryRun);
-            if ($r !== self::SUCCESS) $result = $r;
+            if ($r !== self::SUCCESS) {
+                $result = $r;
+            }
         }
 
         if ($phase === null || $phase === '2') {
             $r = $this->phase2Purge($dryRun);
-            if ($r !== self::SUCCESS) $result = $r;
+            if ($r !== self::SUCCESS) {
+                $result = $r;
+            }
         }
 
         return $result;

package/dist/php/orphan-cleanup.d.ts

@@ -45,13 +45,24 @@ export interface DisabledLayerPruneSummary {
  * When a scaffold layer is disabled (issue #252), remove stale auto-generated
  * BASE files that have no matching user-editable subclass on disk.
  */
-export declare function pruneDisabledScaffoldLayerBases(configDir: string, config: PhpConfig, generated: readonly GeneratedFile[]): DisabledLayerPruneSummary[];
+export declare function pruneDisabledScaffoldLayerBases(configDir: string, config: PhpConfig, generated: readonly GeneratedFile[], referenced?: ReadonlySet<string>): DisabledLayerPruneSummary[];
 /**
- * Issue #255: does a hand-written subclass exist on disk for this generated
- * base of a disabled scaffold layer? Same lookup the prune above uses to keep
- * a base, so a base is regenerated exactly when it would otherwise be kept.
+ * Issue #255: is this generated base of a disabled scaffold layer still used by
+ * hand-written code? Same question the prune above asks before deleting a base,
+ * so a base is regenerated exactly when it would otherwise be kept.
  */
-export declare function hasEditableSubclassForBase(configDir: string, config: PhpConfig, file: GeneratedFile): boolean;
+export declare function hasEditableSubclassForBase(config: PhpConfig, referenced: ReadonlySet<string>, file: GeneratedFile): boolean;
+/**
+ * Every class hand-written PHP under the Laravel root names in a `use` import
+ * or a fully-qualified `extends` (#260).
+ *
+ * "Is this base still used?" used to be answered by looking for a file named
+ * after it in the layer's configured directories. Real projects keep their
+ * subclasses wherever they like — `app/Policies/`, `app/Services/Promotion/` —
+ * so a used base looked unused and was deleted under running code. The import
+ * is what PHP resolves, so the import is what we check.
+ */
+export declare function collectReferencedClasses(configDir: string, config: PhpConfig): Set<string>;
 /**
  * Delete orphan `*ServiceBase.php` files; flag orphan editable services
  * for warning. Pure-ish: takes the generated file list (= source of

package/dist/php/orphan-cleanup.js

@@ -19,7 +19,7 @@
  * warning is printed so the user can decide whether to clean up by hand.
  */
 import { existsSync, readFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
-import { join, resolve, basename, relative, sep } from 'node:path';
+import { join, resolve, basename } from 'node:path';
 /** Matches the header emitted by `generateEditableService` in service-generator.ts */
 export const OMNIFY_EDITABLE_SERVICE_MARKER = 'SAFE TO EDIT - This file is never overwritten by Omnify.';
 const EXTENDS_SERVICE_BASE_RE = /extends\s+[\w\\]+ServiceBase\b/;
@@ -65,80 +65,7 @@ function collectModularLayerDirs(configDir, config, category) {
     }
     return dirs;
 }
-const BASE_SUBDIRS_SKIP = new Set(['Base', 'OmnifyBase']);
-function findEditableSubclassFile(roots, fileName, excludeAbsPath) {
-    for (const root of roots) {
-        const found = findFileAbsolutePath(root, fileName);
-        if (found && found !== excludeAbsPath)
-            return true;
-    }
-    return false;
-}
-function findFileAbsolutePath(dir, fileName) {
-    if (!existsSync(dir))
-        return null;
-    let info;
-    try {
-        info = statSync(dir);
-    }
-    catch {
-        return null;
-    }
-    if (!info.isDirectory()) {
-        return basename(dir) === fileName ? resolve(dir) : null;
-    }
-    for (const entry of readdirSync(dir)) {
-        if (BASE_SUBDIRS_SKIP.has(entry))
-            continue;
-        const full = join(dir, entry);
-        try {
-            info = statSync(full);
-        }
-        catch {
-            continue;
-        }
-        if (info.isDirectory()) {
-            const nested = findFileAbsolutePath(full, fileName);
-            if (nested)
-                return nested;
-        }
-        else if (entry === fileName) {
-            return resolve(full);
-        }
-    }
-    return null;
-}
-function collectEditableSearchRoots(configDir, config, layer, modularCategory, baseAbsPath) {
-    const roots = [];
-    const add = (p) => {
-        const abs = resolve(configDir, p);
-        if (!roots.includes(abs))
-            roots.push(abs);
-    };
-    add(layer.userEditablePath);
-    if (layer.path !== layer.userEditablePath) {
-        add(layer.path);
-    }
-    if (config.structure === 'modular') {
-        const modulesAbs = resolve(configDir, config.modules.path);
-        const rel = relative(modulesAbs, baseAbsPath);
-        if (rel && !rel.startsWith('..') && !rel.startsWith(`..${sep}`)) {
-            const segments = rel.split(/[/\\]/);
-            if (segments.length >= 2 && segments[1] === modularCategory) {
-                const schemaFolder = segments[0];
-                add(join(layer.userEditablePath, schemaFolder));
-                add(join(layer.path, schemaFolder));
-            }
-        }
-    }
-    return roots;
-}
-function baseToEditableFileName(baseFileName, baseSuffix, editableSuffix) {
-    if (!baseFileName.endsWith(baseSuffix))
-        return null;
-    return `${baseFileName.slice(0, -baseSuffix.length)}${editableSuffix}`;
-}
-function pruneDisabledLayerBasesInRoots(configDir, config, spec, roots, expectedAbs) {
+function pruneDisabledLayerBasesInRoots(spec, roots, expectedAbs, referenced) {
     let pruned = 0;
     let kept = 0;
     for (const root of roots) {
@@ -150,13 +77,17 @@ function pruneDisabledLayerBasesInRoots(configDir, config, spec, roots, expected
             const fullPath = join(root, entry);
             if (expectedAbs.has(fullPath))
                 continue;
-            const editableName = spec.toEditableFileName(entry);
-            if (editableName) {
-                const editableRoots = collectEditableSearchRoots(configDir, config, spec.layerConfig, spec.modularCategory, fullPath);
-                if (findEditableSubclassFile(editableRoots, editableName, fullPath)) {
-                    kept += 1;
-                    continue;
-                }
+            let content = '';
+            try {
+                content = readFileSync(fullPath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const fqcn = declaredClassName(content);
+            if (fqcn && referenced.has(fqcn)) {
+                kept += 1;
+                continue;
             }
             try {
                 unlinkSync(fullPath);
@@ -173,7 +104,7 @@ function pruneDisabledLayerBasesInRoots(configDir, config, spec, roots, expected
  * When a scaffold layer is disabled (issue #252), remove stale auto-generated
  * BASE files that have no matching user-editable subclass on disk.
  */
-export function pruneDisabledScaffoldLayerBases(configDir, config, generated) {
+export function pruneDisabledScaffoldLayerBases(configDir, config, generated, referenced = collectReferencedClasses(configDir, config)) {
     const expectedAbs = new Set();
     for (const f of generated) {
         expectedAbs.add(resolve(configDir, f.path));
@@ -186,7 +117,7 @@ export function pruneDisabledScaffoldLayerBases(configDir, config, generated) {
             ...collectModularLayerDirs(configDir, config, spec.modularCategory),
             resolve(configDir, spec.legacyBasePath),
         ];
-        const { pruned, kept } = pruneDisabledLayerBasesInRoots(configDir, config, spec, roots, expectedAbs);
+        const { pruned, kept } = pruneDisabledLayerBasesInRoots(spec, roots, expectedAbs, referenced);
         if (pruned > 0 || kept > 0) {
             summaries.push({
                 layer: spec.layer,
@@ -199,22 +130,94 @@ export function pruneDisabledScaffoldLayerBases(configDir, config, generated) {
     return summaries;
 }
 /**
- * Issue #255: does a hand-written subclass exist on disk for this generated
- * base of a disabled scaffold layer? Same lookup the prune above uses to keep
- * a base, so a base is regenerated exactly when it would otherwise be kept.
+ * Issue #255: is this generated base of a disabled scaffold layer still used by
+ * hand-written code? Same question the prune above asks before deleting a base,
+ * so a base is regenerated exactly when it would otherwise be kept.
  */
-export function hasEditableSubclassForBase(configDir, config, file) {
+export function hasEditableSubclassForBase(config, referenced, file) {
     const name = basename(file.path);
-    for (const spec of scaffoldLayerSpecs(config)) {
-        if (spec.enabled || !spec.matchesBaseFile(name))
+    const isDisabledScaffoldBase = scaffoldLayerSpecs(config).some((spec) => !spec.enabled && spec.matchesBaseFile(name));
+    if (!isDisabledScaffoldBase)
+        return false;
+    const fqcn = declaredClassName(file.content);
+    return fqcn !== null && referenced.has(fqcn);
+}
+/**
+ * Every class hand-written PHP under the Laravel root names in a `use` import
+ * or a fully-qualified `extends` (#260).
+ *
+ * "Is this base still used?" used to be answered by looking for a file named
+ * after it in the layer's configured directories. Real projects keep their
+ * subclasses wherever they like — `app/Policies/`, `app/Services/Promotion/` —
+ * so a used base looked unused and was deleted under running code. The import
+ * is what PHP resolves, so the import is what we check.
+ */
+export function collectReferencedClasses(configDir, config) {
+    // Paths resolve against configDir, which for a workspace run is a cache
+    // directory; the Laravel app itself sits at rootPath.
+    const laravelRoot = resolve(configDir, config.rootPath);
+    const referenced = new Set();
+    for (const dir of REFERENCE_SCAN_DIRS) {
+        walkPhpFiles(resolve(laravelRoot, dir), (content) => {
+            if (GENERATED_MARKER.test(content))
+                return;
+            for (const m of content.matchAll(/^use\s+\\?([A-Za-z_][\w\\]*)(?:\s+as\s+\w+)?\s*;/gm)) {
+                referenced.add(m[1]);
+            }
+            for (const m of content.matchAll(/\bextends\s+\\([A-Za-z_][\w\\]*)/g)) {
+                referenced.add(m[1]);
+            }
+            // An unqualified parent with no import resolves in the file's own namespace.
+            const ns = content.match(/^namespace\s+([^;\s]+)\s*;/m)?.[1];
+            for (const m of content.matchAll(/\bextends\s+([A-Za-z_]\w*)\b/g)) {
+                referenced.add(ns ? `${ns}\\${m[1]}` : m[1]);
+            }
+        });
+    }
+    return referenced;
+}
+const REFERENCE_SCAN_DIRS = ['app', 'routes', 'tests', 'database', 'config'];
+const GENERATED_MARKER = /auto-generated by Omnify/i;
+const SKIP_DIRS = new Set(['vendor', 'node_modules', 'storage', '.git']);
+function walkPhpFiles(dir, visit) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (SKIP_DIRS.has(entry))
             continue;
-        const editableName = spec.toEditableFileName(name);
-        if (!editableName)
-            return false;
-        const roots = collectEditableSearchRoots(configDir, config, spec.layerConfig, spec.modularCategory, resolve(configDir, file.path));
-        return findEditableSubclassFile(roots, editableName, resolve(configDir, file.path));
+        const full = join(dir, entry);
+        let info;
+        try {
+            info = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (info.isDirectory()) {
+            walkPhpFiles(full, visit);
+        }
+        else if (entry.endsWith('.php')) {
+            try {
+                visit(readFileSync(full, 'utf-8'));
+            }
+            catch {
+                // unreadable file: nothing to learn from it
+            }
+        }
     }
-    return false;
+}
+/** `Namespace\Class` a PHP file declares, or null. */
+function declaredClassName(content) {
+    const ns = content.match(/^namespace\s+([^;\s]+)\s*;/m);
+    const cls = content.match(/^(?:(?:abstract|final|readonly)\s+)*(?:class|interface|trait|enum)\s+(\w+)/m);
+    if (!cls)
+        return null;
+    return ns ? `${ns[1]}\\${cls[1]}` : cls[1];
 }
 const SCAFFOLD_LAYER_BASE_SUFFIX = {
     request: 'RequestBase.php',
@@ -223,32 +226,17 @@ const SCAFFOLD_LAYER_BASE_SUFFIX = {
     controller: 'ControllerBase.php',
     service: 'ServiceBase.php',
 };
-const SCAFFOLD_LAYER_EDITABLE_SUFFIX = {
-    request: 'Request.php',
-    resource: 'Resource.php',
-    policy: 'Policy.php',
-    controller: 'Controller.php',
-    service: 'Service.php',
-};
 /**
  * Legacy `flatBase` puts regenerated bases directly at `layer.basePath` with
  * the same filename as the user-editable stub (different directory). That
  * directory is generated-only: resolveBaseClass() always targets basePath and
  * only per-schema base classes are written there (issue #96).
  */
-function disabledLayerFileMatchers(config, layerConfig, baseSuffix, editableSuffix) {
-    const modularMatches = (name) => name.endsWith(baseSuffix);
-    const modularToEditable = (name) => baseToEditableFileName(name, baseSuffix, editableSuffix);
-    if (config.structure === 'modular') {
-        return { matchesBaseFile: modularMatches, toEditableFileName: modularToEditable };
-    }
-    if (layerConfig.flatBase) {
-        return {
-            matchesBaseFile: (name) => name.endsWith('.php'),
-            toEditableFileName: (name) => (name.endsWith('.php') ? name : null),
-        };
+function disabledLayerFileMatchers(config, layerConfig, baseSuffix) {
+    if (config.structure !== 'modular' && layerConfig.flatBase) {
+        return { matchesBaseFile: (name) => name.endsWith('.php') };
     }
-    return { matchesBaseFile: modularMatches, toEditableFileName: modularToEditable };
+    return { matchesBaseFile: (name) => name.endsWith(baseSuffix) };
 }
 function scaffoldLayerSpecs(config) {
     const layers = [
@@ -295,8 +283,7 @@ function scaffoldLayerSpecs(config) {
     ];
     return layers.map((entry) => {
         const baseSuffix = SCAFFOLD_LAYER_BASE_SUFFIX[entry.layer];
-        const editableSuffix = SCAFFOLD_LAYER_EDITABLE_SUFFIX[entry.layer];
-        const matchers = disabledLayerFileMatchers(config, entry.layerConfig, baseSuffix, editableSuffix);
+        const matchers = disabledLayerFileMatchers(config, entry.layerConfig, baseSuffix);
         return { ...entry, ...matchers };
     });
 }

package/dist/php/relation-builder.js

@@ -43,7 +43,8 @@ export function buildRelation(propName, property, modelNamespace, context) {
     const related = relation === 'MorphTo'
         ? '\\Illuminate\\Database\\Eloquent\\Model'
         : '\\' + modelNamespace + '\\' + target;
-    method = method.replace('     */', `     * @return ${type}<${related}, $this>\n     */`);
+    // Blank line before the tag: Pint's `phpdoc_separation` (laravel preset).
+    method = method.replace('     */', `     *\n     * @return ${type}<${related}, $this>\n     */`);
     return { method, imports };
 }
 /** Generate the table name Laravel's joiningTable() infers from model basenames. */

package/package.json

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