@omnifyjp/ts 6.7.18 → 6.8.1

package/dist/cli.js

@@ -30,7 +30,7 @@ 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 { pruneOrphanServiceFilesIfEnabled } from './php/orphan-cleanup.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';
@@ -246,7 +246,12 @@ program
     // ---- PHP/Laravel generation ----
     if (laravelEnabled) {
         console.log(`\n[Laravel] Generating PHP files`);
-        const phpFiles = generatePhp(input, laravelOverrides);
+        // #255: a disabled scaffold layer still regenerates the bases that
+        // hand-written subclasses extend, so they track the schema.
+        const phpConfigForGen = derivePhpConfig(laravelOverrides);
+        const phpFiles = generatePhp(input, laravelOverrides, {
+            keepDisabledBase: (file) => hasEditableSubclassForBase(configDir, phpConfigForGen, file),
+        });
         let phpCreated = 0;
         let phpOverwritten = 0;
         let phpSkipped = 0;
@@ -391,6 +396,15 @@ program
         // 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)) {
+            if (summary.prunedCount > 0) {
+                console.log(`  pruned ${summary.prunedCount} stale ${summary.label}(s) — layer disabled`);
+            }
+            if (summary.keptCount > 0) {
+                console.warn(`  kept ${summary.keptCount} ${summary.layer} base(s) still extended by hand-written subclasses — ` +
+                    `set ${summary.layer}.enable: true to keep generating them, or delete the subclasses`);
+            }
+        }
         const cleanup = pruneOrphanServiceFilesIfEnabled(configDir, phpConfig, phpFiles);
         if (cleanup.prunedBases.length > 0) {
             console.log(`  ${cleanup.prunedBases.length} orphan ServiceBase pruned (schema removed/renamed/opted-out)`);

package/dist/php/controller-generator.js

@@ -7,6 +7,8 @@ import { buildControllerMethodAttributes, openApiControllerImports } from './ope
 const DEFAULT_ACTIONS = ['index', 'store', 'show', 'update', 'destroy'];
 /** Generate controller classes for all schemas with api config. */
 export function generateControllers(reader, config) {
+    if (!config.controllers.enabled)
+        return [];
     const files = [];
     for (const [name, schema] of Object.entries(reader.getSchemasWithApi())) {
         files.push(...generateForSchema(name, schema, reader, config));

package/dist/php/index.d.ts

@@ -14,5 +14,14 @@ import type { SchemasJson } from '../types.js';
 import type { GeneratedFile, LaravelCodegenOverrides } from './types.js';
 export type { GeneratedFile, PhpConfig, LaravelCodegenOverrides } from './types.js';
 export { derivePhpConfig } from './types.js';
+export interface GeneratePhpOptions {
+    /**
+     * Issue #255: a disabled scaffold layer still regenerates the BASE files a
+     * hand-written subclass extends, so they never freeze out of step with the
+     * schema. The caller answers "does a subclass exist for this base?" (the CLI
+     * checks the disk); omitted, a disabled layer emits nothing, as before.
+     */
+    readonly keepDisabledBase?: (file: GeneratedFile) => boolean;
+}
 /** Generate all PHP files from schemas.json data. */
-export declare function generatePhp(data: SchemasJson, overrides?: LaravelCodegenOverrides): GeneratedFile[];
+export declare function generatePhp(data: SchemasJson, overrides?: LaravelCodegenOverrides, options?: GeneratePhpOptions): GeneratedFile[];

package/dist/php/index.js

@@ -40,7 +40,7 @@ import { generateOpenApi } from './openapi-generator.js';
 import { generateArchitectureDoc } from './architecture-doc-generator.js';
 export { derivePhpConfig } from './types.js';
 /** Generate all PHP files from schemas.json data. */
-export function generatePhp(data, overrides) {
+export function generatePhp(data, overrides, options = {}) {
     const reader = SchemaReader.fromData(data);
     const config = derivePhpConfig(overrides);
     const files = [];
@@ -84,11 +84,8 @@ export function generatePhp(data, overrides) {
         // we add the standalone Common / Info / Schemas files.
         files.push(...generateOpenApi(reader, config));
     }
-    // Service layer. #81 (v3.23.0): service generation is now opt-out by
-    // default — every project `kind: object` schema gets a base service
-    // unless explicitly opted out via `options.service: false`. The old
-    // opt-in gate here is gone because `generateServices` does its own
-    // filter internally; always call it and let it decide.
+    // Service layer (#81): per-schema opt-out via `options.service: false`.
+    // Layer-level opt-in via `codegen.laravel.service.enable` (issue #252).
     files.push(...generateServices(reader, config));
     // Issue #34: every `kind: enum` schema becomes a global PHP enum class.
     files.push(...generateEnums(reader, config));
@@ -112,6 +109,9 @@ export function generatePhp(data, overrides) {
     // no behavior change for existing consumers, and the doc updates
     // automatically as schemas / config change so it never drifts.
     files.push(...generateArchitectureDoc(reader, config));
+    if (options.keepDisabledBase) {
+        files.push(...extendedBasesOfDisabledLayers(reader, config, options.keepDisabledBase));
+    }
     // #174: every generated PHP file leaves here in Pint's import shape —
     // unused imports dropped, the rest ordered. Doing it once, centrally, is why
     // no template has to remember: the two rules fired on almost every layer.
@@ -125,3 +125,26 @@ export function generatePhp(data, overrides) {
         }
         : file);
 }
+/**
+ * Bases of disabled scaffold layers that a hand-written subclass still extends
+ * (#255). Generated exactly as when the layer is on; editable stubs are never
+ * emitted, so a disabled layer creates no new scaffold.
+ */
+function extendedBasesOfDisabledLayers(reader, config, keep) {
+    const layers = [
+        ['requests', generateRequests],
+        ['resources', generateResources],
+        ['policies', generatePolicies],
+        ['controllers', generateControllers],
+        ['services', generateServices],
+    ];
+    const out = [];
+    for (const [key, generate] of layers) {
+        const layer = config[key];
+        if (layer.enabled)
+            continue;
+        const enabled = { ...config, [key]: { ...layer, enabled: true } };
+        out.push(...generate(reader, enabled).filter((f) => f.type === 'base' && keep(f)));
+    }
+    return out;
+}

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

@@ -33,12 +33,25 @@ export interface ServiceCleanupResult {
      *  preserved (may contain user code). Caller should print a warning. */
     warnedEditables: string[];
 }
+/** Apply service orphan cleanup only while the service layer is enabled. */
+export declare function pruneOrphanServiceFilesIfEnabled(configDir: string, config: PhpConfig, generated: readonly GeneratedFile[]): ServiceCleanupResult;
+export interface DisabledLayerPruneSummary {
+    layer: string;
+    label: string;
+    prunedCount: number;
+    keptCount: number;
+}
 /**
- * Apply service cleanup only while this target is managed by Omnify.
- * A globally disabled service layer is a migration boundary: existing bases
- * must remain available until the host application removes its inheritance.
+ * 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 pruneOrphanServiceFilesIfEnabled(configDir: string, config: PhpConfig, generated: readonly GeneratedFile[]): ServiceCleanupResult;
+export declare function pruneDisabledScaffoldLayerBases(configDir: string, config: PhpConfig, generated: readonly GeneratedFile[]): 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.
+ */
+export declare function hasEditableSubclassForBase(configDir: string, config: PhpConfig, file: GeneratedFile): boolean;
 /**
  * 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 } from 'node:path';
+import { join, resolve, basename, relative, sep } 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/;
@@ -43,17 +43,263 @@ function readEditableServiceHead(filePath) {
         return null;
     }
 }
-/**
- * Apply service cleanup only while this target is managed by Omnify.
- * A globally disabled service layer is a migration boundary: existing bases
- * must remain available until the host application removes its inheritance.
- */
+/** Apply service orphan cleanup only while the service layer is enabled. */
 export function pruneOrphanServiceFilesIfEnabled(configDir, config, generated) {
     if (!config.services.enabled) {
         return { prunedBases: [], warnedEditables: [] };
     }
     return pruneOrphanServiceFiles(configDir, config, generated);
 }
+function collectModularLayerDirs(configDir, config, category) {
+    const dirs = [];
+    if (config.structure !== 'modular')
+        return dirs;
+    const modulesAbs = resolve(configDir, config.modules.path);
+    if (!existsSync(modulesAbs) || !statSync(modulesAbs).isDirectory())
+        return dirs;
+    for (const entry of readdirSync(modulesAbs)) {
+        const layerDir = join(modulesAbs, entry, category);
+        if (existsSync(layerDir) && statSync(layerDir).isDirectory()) {
+            dirs.push(layerDir);
+        }
+    }
+    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) {
+    let pruned = 0;
+    let kept = 0;
+    for (const root of roots) {
+        if (!existsSync(root))
+            continue;
+        for (const entry of readdirSync(root)) {
+            if (!spec.matchesBaseFile(entry))
+                continue;
+            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;
+                }
+            }
+            try {
+                unlinkSync(fullPath);
+                pruned += 1;
+            }
+            catch {
+                // skip uncleanable files
+            }
+        }
+    }
+    return { pruned, kept };
+}
+/**
+ * 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) {
+    const expectedAbs = new Set();
+    for (const f of generated) {
+        expectedAbs.add(resolve(configDir, f.path));
+    }
+    const summaries = [];
+    for (const spec of scaffoldLayerSpecs(config)) {
+        if (spec.enabled)
+            continue;
+        const roots = [
+            ...collectModularLayerDirs(configDir, config, spec.modularCategory),
+            resolve(configDir, spec.legacyBasePath),
+        ];
+        const { pruned, kept } = pruneDisabledLayerBasesInRoots(configDir, config, spec, roots, expectedAbs);
+        if (pruned > 0 || kept > 0) {
+            summaries.push({
+                layer: spec.layer,
+                label: spec.label,
+                prunedCount: pruned,
+                keptCount: kept,
+            });
+        }
+    }
+    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.
+ */
+export function hasEditableSubclassForBase(configDir, config, file) {
+    const name = basename(file.path);
+    for (const spec of scaffoldLayerSpecs(config)) {
+        if (spec.enabled || !spec.matchesBaseFile(name))
+            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));
+    }
+    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) {
+    const layers = [
+        {
+            layer: 'request',
+            label: 'request base',
+            enabled: config.requests.enabled,
+            layerConfig: config.requests,
+            legacyBasePath: config.requests.basePath,
+            modularCategory: 'Requests',
+        },
+        {
+            layer: 'resource',
+            label: 'resource base',
+            enabled: config.resources.enabled,
+            layerConfig: config.resources,
+            legacyBasePath: config.resources.basePath,
+            modularCategory: 'Resources',
+        },
+        {
+            layer: 'policy',
+            label: 'policy base',
+            enabled: config.policies.enabled,
+            layerConfig: config.policies,
+            legacyBasePath: config.policies.basePath,
+            modularCategory: 'Policies',
+        },
+        {
+            layer: 'controller',
+            label: 'controller base',
+            enabled: config.controllers.enabled,
+            layerConfig: config.controllers,
+            legacyBasePath: config.controllers.basePath,
+            modularCategory: 'Controllers',
+        },
+        {
+            layer: 'service',
+            label: 'service base',
+            enabled: config.services.enabled,
+            layerConfig: config.services,
+            legacyBasePath: config.services.basePath,
+            modularCategory: 'Services',
+        },
+    ];
+    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
  * for warning. Pure-ish: takes the generated file list (= source of

package/dist/php/policy-generator.js

@@ -46,6 +46,8 @@ const RECORD_ACTIONS = new Set(['view', 'edit', 'delete']);
  *     overriding the method in the editable child.
  */
 export function generatePolicies(reader, config) {
+    if (!config.policies.enabled)
+        return [];
     const files = [];
     for (const [name, schema] of Object.entries(reader.getProjectVisibleObjectSchemas())) {
         if (schema.kind === 'pivot')

package/dist/php/request-generator.js

@@ -6,6 +6,8 @@ import { toStoreRules, toUpdateRules, formatRules, resolveFkRuleType } from './t
 import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup } from './types.js';
 /** Generate Store/Update request classes for all project-owned visible object schemas. */
 export function generateRequests(reader, config) {
+    if (!config.requests.enabled)
+        return [];
     const files = [];
     for (const [name, schema] of Object.entries(reader.getProjectVisibleObjectSchemas())) {
         if (schema.kind === 'extend')

package/dist/php/resource-generator.js

@@ -17,6 +17,8 @@ import { createClassImporter, renderUseBlock } from './php-style.js';
  * cross-resource reference always resolves.
  */
 export function generateResources(reader, config) {
+    if (!config.resources.enabled)
+        return [];
     const files = [];
     for (const [name, schema] of Object.entries(reader.getProjectVisibleObjectSchemas())) {
         if (!generatesOwnResource(schema))

package/dist/php/route-generator.js

@@ -9,6 +9,8 @@ import { baseFile } from './types.js';
 const DEFAULT_ACTIONS = ['index', 'store', 'show', 'update', 'destroy'];
 /** Generate route files for all schemas with api config. */
 export function generateRoutes(reader, config) {
+    if (!config.routes.enabled || !config.controllers.enabled)
+        return [];
     const files = [];
     for (const [name, schema] of Object.entries(reader.getSchemasWithApi())) {
         files.push(generateRouteFile(name, schema, config));

package/dist/php/types.d.ts

@@ -134,7 +134,13 @@ export declare function resolveGlobalTraitNamespace(config: PhpConfig, legacyNam
  * working.
  */
 export interface LaravelPathOverride {
-    /** Disable generation for layers that support it (currently `service`). */
+    /**
+     * Opt in/out of generating this layer. Defaults vary by layer (issue #252):
+     * `request`, `resource`, `policy`, `controller`, and `service` default to
+     * off; model, factory, provider, route, config, and other infrastructure
+     * layers default to on. Omitted `enable` uses the layer default — not
+     * “enabled unless false”.
+     */
     enable?: boolean;
     /** Path for BASE (auto-generated, regenerated) classes. */
     path?: string;
@@ -304,6 +310,11 @@ export interface BaseEditableLayer {
      */
     userEditableGroupByFolder: boolean;
 }
+/** Base + editable layer with an on/off toggle (issue #252). */
+export type EnabledBaseEditableLayer = BaseEditableLayer & {
+    /** When false, this layer is not generated and stale base files are pruned. */
+    enabled: boolean;
+};
 /** PHP codegen configuration (resolved with defaults). */
 export interface PhpConfig {
     /** Filesystem prefix applied to all generated paths. Empty when not set. */
@@ -340,8 +351,8 @@ export interface PhpConfig {
      */
     modulesPath: string;
     models: BaseEditableLayer;
-    requests: BaseEditableLayer;
-    resources: BaseEditableLayer;
+    requests: EnabledBaseEditableLayer;
+    resources: EnabledBaseEditableLayer;
     factories: {
         namespace: string;
         path: string;
@@ -350,14 +361,13 @@ export interface PhpConfig {
         namespace: string;
         path: string;
     };
-    policies: BaseEditableLayer;
-    controllers: BaseEditableLayer;
-    services: BaseEditableLayer & {
-        /** False disables Laravel service emission and cleanup for this target. */
-        enabled: boolean;
-    };
+    policies: EnabledBaseEditableLayer;
+    controllers: EnabledBaseEditableLayer;
+    services: EnabledBaseEditableLayer;
     routes: {
         path: string;
+        /** Default true. Route files reference controllers; generation is skipped when `controllers.enabled` is false. */
+        enabled: boolean;
     };
     /** Path to the omnify-schemas.php config file (full path including filename). */
     configFile: {
@@ -443,6 +453,17 @@ export declare function nestEditableByGroup(layer: BaseEditableLayer, loc: {
     path: string;
     namespace: string;
 };
+/**
+ * Cross-layer validation for explicit `enable: true` combinations that would
+ * reference classes from a disabled layer. Surfaces at CLI exit 1 via
+ * `derivePhpConfig` (same path as relation-builder throws, issue #242).
+ */
+export declare function validateLaravelCodegenLayerDependencies(overrides?: LaravelCodegenOverrides): void;
+/**
+ * Overrides that restore pre-v6.8 “all scaffold layers on” behaviour for
+ * projects upgrading from 6.7.x. Merge into `derivePhpConfig({ ... })`.
+ */
+export declare const SCAFFOLD_LAYERS_6_7_ENABLED: Pick<LaravelCodegenOverrides, 'request' | 'resource' | 'policy' | 'controller' | 'service'>;
 /**
  * Derive full PHP config from optional overrides.
  * All paths and namespaces fall back to sensible defaults.

package/dist/php/types.js

@@ -302,6 +302,45 @@ const DEFAULT_SHARED_PATH = 'app/Omnify/Shared';
 const DEFAULT_GLOBAL_ENUMS_PATH = 'app/Omnify/Enums';
 const DEFAULT_GLOBAL_TRAITS_PATH = 'app/Omnify/Traits';
 const DEFAULT_OPENAPI_PATH = 'app/Omnify/OpenApi';
+/** Default `enable` for opt-in scaffold layers (issue #252). */
+const SCAFFOLD_LAYER_DEFAULT_ENABLED = false;
+/** Default `enable` for layers that stay on unless explicitly disabled. */
+const INFRA_LAYER_DEFAULT_ENABLED = true;
+function resolveLayerEnable(override, defaultOn = INFRA_LAYER_DEFAULT_ENABLED) {
+    return override?.enable ?? defaultOn;
+}
+/**
+ * Cross-layer validation for explicit `enable: true` combinations that would
+ * reference classes from a disabled layer. Surfaces at CLI exit 1 via
+ * `derivePhpConfig` (same path as relation-builder throws, issue #242).
+ */
+export function validateLaravelCodegenLayerDependencies(overrides) {
+    const requestOn = resolveLayerEnable(overrides?.request, SCAFFOLD_LAYER_DEFAULT_ENABLED);
+    const resourceOn = resolveLayerEnable(overrides?.resource, SCAFFOLD_LAYER_DEFAULT_ENABLED);
+    const controllerOn = resolveLayerEnable(overrides?.controller, SCAFFOLD_LAYER_DEFAULT_ENABLED);
+    if (controllerOn) {
+        if (!requestOn) {
+            throw new Error('codegen.laravel.controller.enable: true requires codegen.laravel.request.enable: true');
+        }
+        if (!resourceOn) {
+            throw new Error('codegen.laravel.controller.enable: true requires codegen.laravel.resource.enable: true');
+        }
+    }
+    if (overrides?.route?.enable === true && !controllerOn) {
+        throw new Error('codegen.laravel.route.enable: true requires codegen.laravel.controller.enable: true');
+    }
+}
+/**
+ * Overrides that restore pre-v6.8 “all scaffold layers on” behaviour for
+ * projects upgrading from 6.7.x. Merge into `derivePhpConfig({ ... })`.
+ */
+export const SCAFFOLD_LAYERS_6_7_ENABLED = {
+    request: { enable: true },
+    resource: { enable: true },
+    policy: { enable: true },
+    controller: { enable: true },
+    service: { enable: true },
+};
 /**
  * Apply a rootPath prefix to a path. Absolute paths and paths that already
  * begin with `${rootPath}/` are returned as-is, so users can mix and match
@@ -321,6 +360,7 @@ function withRoot(rootPath, p) {
  * All paths and namespaces fall back to sensible defaults.
  */
 export function derivePhpConfig(overrides) {
+    validateLaravelCodegenLayerDependencies(overrides);
     // Strip trailing slash for stable join behavior.
     const rootPath = (overrides?.rootPath ?? '').replace(/\/+$/, '');
     // Namespace generation should NOT include the rootPath prefix — it's a
@@ -371,8 +411,14 @@ export function derivePhpConfig(overrides) {
         globalTraits: { namespace: globalTraitsNs, path: globalTraitsPath },
         modulesPath,
         models: modelsLayer,
-        requests: requestsLayer,
-        resources: resourcesLayer,
+        requests: {
+            ...requestsLayer,
+            enabled: resolveLayerEnable(overrides?.request, SCAFFOLD_LAYER_DEFAULT_ENABLED),
+        },
+        resources: {
+            ...resourcesLayer,
+            enabled: resolveLayerEnable(overrides?.resource, SCAFFOLD_LAYER_DEFAULT_ENABLED),
+        },
         factories: {
             namespace: factoryNs,
             path: factoryPath,
@@ -381,14 +427,21 @@ export function derivePhpConfig(overrides) {
             namespace: providerNs,
             path: providerPath,
         },
-        policies: policiesLayer,
-        controllers: controllersLayer,
+        policies: {
+            ...policiesLayer,
+            enabled: resolveLayerEnable(overrides?.policy, SCAFFOLD_LAYER_DEFAULT_ENABLED),
+        },
+        controllers: {
+            ...controllersLayer,
+            enabled: resolveLayerEnable(overrides?.controller, SCAFFOLD_LAYER_DEFAULT_ENABLED),
+        },
         services: {
             ...servicesLayer,
-            enabled: overrides?.service?.enable ?? true,
+            enabled: resolveLayerEnable(overrides?.service, SCAFFOLD_LAYER_DEFAULT_ENABLED),
         },
         routes: {
             path: routePath,
+            enabled: resolveLayerEnable(overrides?.route, INFRA_LAYER_DEFAULT_ENABLED),
         },
         configFile: {
             path: configFilePath,

package/package.json

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