@omnifyjp/ts 6.8.0 → 7.0.0

package/dist/cli.js

@@ -32,8 +32,6 @@ import { generatePhp, derivePhpConfig } from './php/index.js';
 import { evaluateShadowingConflicts } from './php/shadowing-conflicts.js';
 import { 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)`);
@@ -259,7 +239,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 +302,6 @@ program
                 }
             }
             writeFileSync(filePath, file.content, 'utf-8');
-            writtenPaths.push(filePath);
             if (file.overwrite || !existsSync(filePath)) {
                 phpOverwritten++;
             }
@@ -355,41 +333,6 @@ 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

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/orphan-cleanup.js

@@ -66,25 +66,26 @@ function collectModularLayerDirs(configDir, config, category) {
     return dirs;
 }
 const BASE_SUBDIRS_SKIP = new Set(['Base', 'OmnifyBase']);
-function findEditableSubclassFile(roots, fileName) {
+function findEditableSubclassFile(roots, fileName, excludeAbsPath) {
     for (const root of roots) {
-        if (findFileByName(root, fileName))
+        const found = findFileAbsolutePath(root, fileName);
+        if (found && found !== excludeAbsPath)
             return true;
     }
     return false;
 }
-function findFileByName(dir, fileName) {
+function findFileAbsolutePath(dir, fileName) {
     if (!existsSync(dir))
-        return false;
+        return null;
     let info;
     try {
         info = statSync(dir);
     }
     catch {
-        return false;
+        return null;
     }
     if (!info.isDirectory()) {
-        return basename(dir) === fileName;
+        return basename(dir) === fileName ? resolve(dir) : null;
     }
     for (const entry of readdirSync(dir)) {
         if (BASE_SUBDIRS_SKIP.has(entry))
@@ -97,14 +98,15 @@ function findFileByName(dir, fileName) {
             continue;
         }
         if (info.isDirectory()) {
-            if (findFileByName(full, fileName))
-                return true;
+            const nested = findFileAbsolutePath(full, fileName);
+            if (nested)
+                return nested;
         }
         else if (entry === fileName) {
-            return true;
+            return resolve(full);
         }
     }
-    return false;
+    return null;
 }
 function collectEditableSearchRoots(configDir, config, layer, modularCategory, baseAbsPath) {
     const roots = [];
@@ -151,7 +153,7 @@ function pruneDisabledLayerBasesInRoots(configDir, config, spec, roots, expected
             const editableName = spec.toEditableFileName(entry);
             if (editableName) {
                 const editableRoots = collectEditableSearchRoots(configDir, config, spec.layerConfig, spec.modularCategory, fullPath);
-                if (findEditableSubclassFile(editableRoots, editableName)) {
+                if (findEditableSubclassFile(editableRoots, editableName, fullPath)) {
                     kept += 1;
                     continue;
                 }
@@ -210,12 +212,46 @@ export function hasEditableSubclassForBase(configDir, config, file) {
         if (!editableName)
             return false;
         const roots = collectEditableSearchRoots(configDir, config, spec.layerConfig, spec.modularCategory, resolve(configDir, file.path));
-        return findEditableSubclassFile(roots, editableName);
+        return findEditableSubclassFile(roots, editableName, resolve(configDir, file.path));
     }
     return false;
 }
+const SCAFFOLD_LAYER_BASE_SUFFIX = {
+    request: 'RequestBase.php',
+    resource: 'ResourceBase.php',
+    policy: 'PolicyBase.php',
+    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),
+        };
+    }
+    return { matchesBaseFile: modularMatches, toEditableFileName: modularToEditable };
+}
 function scaffoldLayerSpecs(config) {
-    return [
+    const layers = [
         {
             layer: 'request',
             label: 'request base',
@@ -223,8 +259,6 @@ function scaffoldLayerSpecs(config) {
             layerConfig: config.requests,
             legacyBasePath: config.requests.basePath,
             modularCategory: 'Requests',
-            matchesBaseFile: (name) => name.endsWith('RequestBase.php'),
-            toEditableFileName: (name) => baseToEditableFileName(name, 'RequestBase.php', 'Request.php'),
         },
         {
             layer: 'resource',
@@ -233,8 +267,6 @@ function scaffoldLayerSpecs(config) {
             layerConfig: config.resources,
             legacyBasePath: config.resources.basePath,
             modularCategory: 'Resources',
-            matchesBaseFile: (name) => name.endsWith('ResourceBase.php'),
-            toEditableFileName: (name) => baseToEditableFileName(name, 'ResourceBase.php', 'Resource.php'),
         },
         {
             layer: 'policy',
@@ -243,8 +275,6 @@ function scaffoldLayerSpecs(config) {
             layerConfig: config.policies,
             legacyBasePath: config.policies.basePath,
             modularCategory: 'Policies',
-            matchesBaseFile: (name) => name.endsWith('PolicyBase.php'),
-            toEditableFileName: (name) => baseToEditableFileName(name, 'PolicyBase.php', 'Policy.php'),
         },
         {
             layer: 'controller',
@@ -253,8 +283,6 @@ function scaffoldLayerSpecs(config) {
             layerConfig: config.controllers,
             legacyBasePath: config.controllers.basePath,
             modularCategory: 'Controllers',
-            matchesBaseFile: (name) => name.endsWith('ControllerBase.php'),
-            toEditableFileName: (name) => baseToEditableFileName(name, 'ControllerBase.php', 'Controller.php'),
         },
         {
             layer: 'service',
@@ -263,10 +291,14 @@ function scaffoldLayerSpecs(config) {
             layerConfig: config.services,
             legacyBasePath: config.services.basePath,
             modularCategory: 'Services',
-            matchesBaseFile: (name) => name.endsWith('ServiceBase.php'),
-            toEditableFileName: (name) => baseToEditableFileName(name, 'ServiceBase.php', 'Service.php'),
         },
     ];
+    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);
+        return { ...entry, ...matchers };
+    });
 }
 /**
  * Delete orphan `*ServiceBase.php` files; flag orphan editable services

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