@omnifyjp/ts 5.4.0 → 5.6.0

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 } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass } 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. */
@@ -157,18 +157,36 @@ abstract class ${modelName}ControllerBase extends Controller
 ${methods.join('\n')}
 }
 `;
-    return baseFile(resolveModularBasePath(config, name, 'Controllers', `${modelName}ControllerBase.php`, config.controllers.basePath), content);
+    // Issue #96: legacy honors flatBase (drops ControllerBase suffix + OmnifyBase/ subfolder).
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}ControllerBase`,
+            path: resolveModularBasePath(config, name, 'Controllers', '', config.controllers.basePath).replace(/\/$/, ''),
+        }
+        : resolveBaseClass(config.controllers, `${modelName}Controller`, 'Base');
+    const finalContent = content.replace(new RegExp(`abstract class ${modelName}ControllerBase\\b`, 'g'), `abstract class ${baseDescriptor.className}`);
+    return baseFile(`${baseDescriptor.path}/${baseDescriptor.className}.php`, finalContent);
 }
 function generateUserController(name, schema, config) {
     const modelName = toPascalCase(name);
     const group = schema.group ? toPascalCase(schema.group) : null;
-    const baseNs = resolveModularBaseNamespace(config, name, 'Controllers', config.controllers.baseNamespace);
+    // Issue #96: editable stub may live at userEditablePath; extends-clause adapts to flatBase.
+    // Note: controllers traditionally nest under `Api/V1/<Group>/` regardless of userEditablePath.
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}ControllerBase`,
+            fqn: `${resolveModularBaseNamespace(config, name, 'Controllers', config.controllers.baseNamespace)}\\${modelName}ControllerBase`,
+        }
+        : resolveBaseClass(config.controllers, `${modelName}Controller`, 'Base');
+    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');
     const userNs = group
-        ? `${config.controllers.namespace}\\Api\\V1\\${group}`
-        : `${config.controllers.namespace}\\Api\\V1`;
+        ? `${editable.namespace}\\Api\\V1\\${group}`
+        : `${editable.namespace}\\Api\\V1`;
     const userPath = group
-        ? `${config.controllers.path}/Api/V1/${group}`
-        : `${config.controllers.path}/Api/V1`;
+        ? `${editable.path}/Api/V1/${group}`
+        : `${editable.path}/Api/V1`;
     const content = `<?php
 
 /**
@@ -179,12 +197,12 @@ function generateUserController(name, schema, config) {
 
 namespace ${userNs};
 
-use ${baseNs}\\${modelName}ControllerBase;
+use ${baseDescriptor.fqn};
 
-class ${modelName}Controller extends ${modelName}ControllerBase
+class ${editable.className} extends ${baseDescriptor.className}
 {
     //
 }
 `;
-    return userFile(`${userPath}/${modelName}Controller.php`, content);
+    return userFile(`${userPath}/${editable.fileName}`, content);
 }

package/dist/php/model-generator.js

@@ -4,7 +4,7 @@
 import { toPascalCase, toSnakeCase, toCamelCase, pluralize } from './naming-helper.js';
 import { toCast, toPhpDocType, isHiddenByDefault } from './type-mapper.js';
 import { buildRelation } from './relation-builder.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, resolveBaseClass, resolveEditableClass, } from './types.js';
 import { enumClassName } from './enum-generator.js';
 /** Generate base model and user model for all project-owned object schemas,
  *  plus user models for package schemas (extending the package model). */
@@ -34,7 +34,22 @@ function generateForSchema(name, schema, reader, config) {
 }
 function generateBaseModel(name, schema, reader, config) {
     const modelName = toPascalCase(name);
-    const baseNamespace = resolveModularBaseNamespace(config, name, 'Models', config.models.baseNamespace);
+    // Issue #96: in legacy structure, honor flatBase to drop the
+    // `BaseModel` suffix + Base/ subfolder. In modular structure, keep the
+    // existing per-module layout (modular's per-schema folder already
+    // isolates base from editable). `baseDescriptor` is the resolved
+    // {className, fqn, path} for the base class — `baseClass` (further
+    // below) is the PARENT class string (BaseModel / Authenticatable).
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}BaseModel`,
+            fqn: `${resolveModularBaseNamespace(config, name, 'Models', config.models.baseNamespace)}\\${modelName}BaseModel`,
+            path: resolveModularBasePath(config, name, 'Models', '', config.models.basePath).replace(/\/$/, ''),
+        }
+        : resolveBaseClass(config.models, modelName, 'BaseModel');
+    const baseNamespace = config.structure === 'modular'
+        ? resolveModularBaseNamespace(config, name, 'Models', config.models.baseNamespace)
+        : baseDescriptor.fqn.substring(0, baseDescriptor.fqn.lastIndexOf('\\'));
     const localesNamespace = resolveModularBaseNamespace(config, name, 'Locales', config.models.baseNamespace + '\\Locales');
     // Issue #33: HasLocalizedDisplayName is a global Omnify trait, not a per-shared module file.
     const traitsNamespace = resolveGlobalTraitNamespace(config, config.models.baseNamespace + '\\Traits');
@@ -183,16 +198,31 @@ ${casts}        ];
 ${auditLogProperties}${relations}${accessors}${fileAccessors}${auditSection}${nestedSetMethod}
 }
 `;
-    return baseFile(resolveModularBasePath(config, name, 'Models', `${modelName}BaseModel.php`, config.models.basePath), content);
+    // Replace placeholder class name so the file matches resolved className
+    // (issue #96: flatBase emits `<Schema>` instead of `<Schema>BaseModel`).
+    const finalContent = content.replace(new RegExp(`class ${modelName}BaseModel `, 'g'), `class ${baseDescriptor.className} `).replace(new RegExp(`\\* ${modelName}BaseModel`, 'g'), `* ${baseDescriptor.className}`);
+    // Modular preserves per-module path; legacy honors flatBase via baseDescriptor.path.
+    const filePath = config.structure === 'modular'
+        ? resolveModularBasePath(config, name, 'Models', `${modelName}BaseModel.php`, config.models.basePath)
+        : `${baseDescriptor.path}/${baseDescriptor.className}.php`;
+    return baseFile(filePath, finalContent);
 }
 function generateUserModel(name, config, hasNestedSet = false) {
     const modelName = toPascalCase(name);
-    const modelNamespace = config.models.namespace;
-    const baseNamespace = resolveModularBaseNamespace(config, name, 'Models', config.models.baseNamespace);
+    // Issue #96: editable stub may live at a different path/namespace
+    // than the base (e.g. `app/Models/<Name>.php` while base is at
+    // `app/Omnify/Models/<Name>.php`). resolveEditableClass +
+    // resolveBaseClass keep the extends-clause + use-import in sync.
+    const editable = config.structure === 'modular'
+        ? { fileName: `${modelName}.php`, namespace: config.models.namespace, path: config.models.path, fqn: `${config.models.namespace}\\${modelName}`, className: modelName }
+        : resolveEditableClass(config.models, modelName);
+    const base = config.structure === 'modular'
+        ? { className: `${modelName}BaseModel`, fqn: `${resolveModularBaseNamespace(config, name, 'Models', config.models.baseNamespace)}\\${modelName}BaseModel` }
+        : resolveBaseClass(config.models, modelName, 'BaseModel');
     const factoryNamespace = config.factories.namespace;
     const nestedSetNamespace = config.nestedset.namespace;
     const imports = [
-        `use ${baseNamespace}\\${modelName}BaseModel;`,
+        `use ${base.fqn};`,
         `use ${factoryNamespace}\\${modelName}Factory;`,
         `use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;`,
     ];
@@ -211,14 +241,14 @@ function generateUserModel(name, config, hasNestedSet = false) {
  * SAFE TO EDIT - This file is never overwritten by Omnify.
  */
 
-namespace ${modelNamespace};
+namespace ${editable.namespace};
 
 ${imports.join('\n')}
 
 /**
  * ${modelName} — add project-specific model logic here.
  */
-class ${modelName} extends ${modelName}BaseModel
+class ${modelName} extends ${base.className}
 {
 ${traits.join('\n')}
 
@@ -233,7 +263,7 @@ ${traits.join('\n')}
     //
 }
 `;
-    return userFile(`${config.models.path}/${modelName}.php`, content);
+    return userFile(`${editable.path}/${editable.fileName}`, content);
 }
 function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false, nestedSetNamespace = 'Aimeos\\Nestedset', hasFiles = false, modelNamespace = '', localesNamespace = '', traitsNamespace = '', sharedModelsNamespace = '', config, hasAuditLog = false) {
     const lines = [];

package/dist/php/policy-generator.js

@@ -5,7 +5,7 @@
  * Only generates for schemas that have `policies` defined.
  */
 import { toPascalCase, toSnakeCase, toCamelCase } from './naming-helper.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass } from './types.js';
 // ============================================================================
 // Action mapping: Omnify → Laravel
 // ============================================================================
@@ -89,17 +89,33 @@ class ${modelName}PolicyBase
 ${methods.join('\n')}${cidrHelper}
 }
 `;
-    return baseFile(resolveModularBasePath(config, name, 'Policies', `${modelName}PolicyBase.php`, config.policies.basePath), content);
+    // Issue #96: legacy honors flatBase (drops PolicyBase suffix + Base/ subfolder).
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}PolicyBase`,
+            path: resolveModularBasePath(config, name, 'Policies', '', config.policies.basePath).replace(/\/$/, ''),
+        }
+        : resolveBaseClass(config.policies, `${modelName}Policy`, 'Base');
+    const finalContent = content.replace(new RegExp(`class ${modelName}PolicyBase\\b`, 'g'), `class ${baseDescriptor.className}`);
+    return baseFile(`${baseDescriptor.path}/${baseDescriptor.className}.php`, finalContent);
 }
 function generateUserPolicyClass(name, config) {
     const modelName = toPascalCase(name);
-    const policyNamespace = config.policies.namespace;
-    const baseNamespace = resolveModularBaseNamespace(config, name, 'Policies', config.policies.baseNamespace);
+    // Issue #96: editable stub via resolveEditableClass + extends adapts to flatBase.
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}PolicyBase`,
+            fqn: `${resolveModularBaseNamespace(config, name, 'Policies', config.policies.baseNamespace)}\\${modelName}PolicyBase`,
+        }
+        : resolveBaseClass(config.policies, `${modelName}Policy`, 'Base');
+    const editable = config.structure === 'modular'
+        ? { className: `${modelName}Policy`, fileName: `${modelName}Policy.php`, namespace: config.policies.namespace, path: config.policies.path }
+        : resolveEditableClass(config.policies, modelName, 'Policy');
     const content = `<?php
 
-namespace ${policyNamespace};
+namespace ${editable.namespace};
 
-use ${baseNamespace}\\${modelName}PolicyBase;
+use ${baseDescriptor.fqn};
 
 /**
  * ${modelName} Policy
@@ -107,12 +123,12 @@ use ${baseNamespace}\\${modelName}PolicyBase;
  * This file is generated once and can be customized.
  * Add your custom authorization logic here.
  */
-class ${modelName}Policy extends ${modelName}PolicyBase
+class ${editable.className} extends ${baseDescriptor.className}
 {
     // Add your custom policy methods here
 }
 `;
-    return userFile(`${config.policies.path}/${modelName}Policy.php`, content);
+    return userFile(`${editable.path}/${editable.fileName}`, content);
 }
 // ============================================================================
 // Method body generation

package/dist/php/request-generator.js

@@ -3,7 +3,7 @@
  */
 import { toPascalCase, toSnakeCase, toCamelCase } from './naming-helper.js';
 import { toStoreRules, toUpdateRules, formatRules, hasRuleObject } from './type-mapper.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass } from './types.js';
 /**
  * Resolve the Laravel validation rule type ('integer', 'uuid', or 'string') for
  * a foreign key column based on the target schema's primary key type.
@@ -257,12 +257,30 @@ ${attributeKeysList}
     }
 }
 `;
-    return baseFile(resolveModularBasePath(config, name, 'Requests', `${modelName}${action}RequestBase.php`, config.requests.basePath), content);
+    // Issue #96: legacy honors flatBase. Suffix is `${action}RequestBase`
+    // when not flat (e.g. BannerStoreRequestBase), bare `${action}Request`
+    // when flat (BannerStoreRequest is the base; user-editable extends it).
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}${action}RequestBase`,
+            path: resolveModularBasePath(config, name, 'Requests', '', config.requests.basePath).replace(/\/$/, ''),
+        }
+        : resolveBaseClass(config.requests, `${modelName}${action}Request`, 'Base');
+    const finalContent = content.replace(new RegExp(`class ${modelName}${action}RequestBase\\b`, 'g'), `class ${baseDescriptor.className}`).replace(new RegExp(`abstract class ${modelName}${action}RequestBase\\b`, 'g'), `abstract class ${baseDescriptor.className}`);
+    return baseFile(`${baseDescriptor.path}/${baseDescriptor.className}.php`, finalContent);
 }
 function generateUserRequest(name, config, action) {
     const modelName = toPascalCase(name);
-    const requestNamespace = config.requests.namespace;
-    const baseNamespace = resolveModularBaseNamespace(config, name, 'Requests', config.requests.baseNamespace);
+    // Issue #96: editable stub may live at userEditablePath; extends-clause adapts to flatBase.
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}${action}RequestBase`,
+            fqn: `${resolveModularBaseNamespace(config, name, 'Requests', config.requests.baseNamespace)}\\${modelName}${action}RequestBase`,
+        }
+        : resolveBaseClass(config.requests, `${modelName}${action}Request`, 'Base');
+    const editable = config.structure === 'modular'
+        ? { className: `${modelName}${action}Request`, fileName: `${modelName}${action}Request.php`, namespace: config.requests.namespace, path: config.requests.path }
+        : resolveEditableClass(config.requests, modelName, `${action}Request`);
     const content = `<?php
 
 /**
@@ -271,9 +289,9 @@ function generateUserRequest(name, config, action) {
  * SAFE TO EDIT - This file is never overwritten by Omnify.
  */
 
-namespace ${requestNamespace};
+namespace ${editable.namespace};
 
-use ${baseNamespace}\\${modelName}${action}RequestBase;
+use ${baseDescriptor.fqn};
 
 /**
  * ${modelName}${action}Request — add project-specific authorization and validation here.
@@ -283,10 +301,10 @@ use ${baseNamespace}\\${modelName}${action}RequestBase;
  *   - rules(): array     (returns schemaRules() — override to add custom rules)
  *   - attributes(): array (returns schemaAttributes() — override to rename fields)
  */
-class ${modelName}${action}Request extends ${modelName}${action}RequestBase
+class ${editable.className} extends ${baseDescriptor.className}
 {
     //
 }
 `;
-    return userFile(`${config.requests.path}/${modelName}${action}Request.php`, content);
+    return userFile(`${editable.path}/${editable.fileName}`, content);
 }

package/dist/php/resource-generator.js

@@ -3,7 +3,7 @@
  */
 import { toPascalCase, toSnakeCase, toCamelCase } from './naming-helper.js';
 import { isHiddenByDefault, toResourceExpression } from './type-mapper.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass } from './types.js';
 /** Generate Resource classes for all project-owned visible object schemas. */
 export function generateResources(reader, config) {
     const files = [];
@@ -119,12 +119,30 @@ ${fieldsContent}
     }
 }
 `;
-    return baseFile(resolveModularBasePath(config, name, 'Resources', `${modelName}ResourceBase.php`, config.resources.basePath), content);
+    // Issue #96: legacy honors flatBase (drops ResourceBase suffix +
+    // OmnifyBase/ subfolder); modular keeps the per-module path.
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}ResourceBase`,
+            path: resolveModularBasePath(config, name, 'Resources', '', config.resources.basePath).replace(/\/$/, ''),
+        }
+        : resolveBaseClass(config.resources, `${modelName}Resource`, 'Base');
+    const finalContent = content.replace(new RegExp(`class ${modelName}ResourceBase\\b`, 'g'), `class ${baseDescriptor.className}`);
+    return baseFile(`${baseDescriptor.path}/${baseDescriptor.className}.php`, finalContent);
 }
 function generateUserResource(name, config) {
     const modelName = toPascalCase(name);
-    const resourceNamespace = config.resources.namespace;
-    const baseNamespace = resolveModularBaseNamespace(config, name, 'Resources', config.resources.baseNamespace);
+    // Issue #96: editable stub may live at userEditablePath; extends-clause
+    // adapts to flatBase too.
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}ResourceBase`,
+            fqn: `${resolveModularBaseNamespace(config, name, 'Resources', config.resources.baseNamespace)}\\${modelName}ResourceBase`,
+        }
+        : resolveBaseClass(config.resources, `${modelName}Resource`, 'Base');
+    const editable = config.structure === 'modular'
+        ? { className: `${modelName}Resource`, fileName: `${modelName}Resource.php`, namespace: config.resources.namespace, path: config.resources.path }
+        : resolveEditableClass(config.resources, modelName, 'Resource');
     const content = `<?php
 
 /**
@@ -133,9 +151,9 @@ function generateUserResource(name, config) {
  * SAFE TO EDIT - This file is never overwritten by Omnify.
  */
 
-namespace ${resourceNamespace};
+namespace ${editable.namespace};
 
-use ${baseNamespace}\\${modelName}ResourceBase;
+use ${baseDescriptor.fqn};
 
 /**
  * ${modelName}Resource — add project-specific serialization here.
@@ -143,12 +161,12 @@ use ${baseNamespace}\\${modelName}ResourceBase;
  * Inherited from base:
  *   - toArray(Request \\$request): array  (returns schemaArray(\\$request) — override to add fields)
  */
-class ${modelName}Resource extends ${modelName}ResourceBase
+class ${editable.className} extends ${baseDescriptor.className}
 {
     //
 }
 `;
-    return userFile(`${config.resources.path}/${modelName}Resource.php`, content);
+    return userFile(`${editable.path}/${editable.fileName}`, content);
 }
 function addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace, reader) {
     const relation = prop['relation'] ?? '';

package/dist/php/service-generator.js

@@ -13,7 +13,7 @@
  * eagerCount}` keys are deprecated and emit warnings at generate time.
  */
 import { toPascalCase, toSnakeCase } from './naming-helper.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass } from './types.js';
 // ============================================================================
 // Public entry point
 // ============================================================================
@@ -593,7 +593,17 @@ class ${modelName}ServiceBase
 ${sections.join('\n')}
 }
 `;
-    return baseFile(resolveModularBasePath(config, name, 'Services', `${modelName}ServiceBase.php`, config.services.basePath), content);
+    // Issue #96: legacy structure honors flatBase (drops `ServiceBase`
+    // suffix + OmnifyBase/ subfolder); modular keeps the per-module path.
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}ServiceBase`,
+            fileName: `${modelName}ServiceBase.php`,
+            path: resolveModularBasePath(config, name, 'Services', '', config.services.basePath).replace(/\/$/, ''),
+        }
+        : resolveBaseClass(config.services, `${modelName}Service`, 'Base');
+    const finalContent = content.replace(new RegExp(`class ${modelName}ServiceBase\\b`, 'g'), `class ${baseDescriptor.className}`);
+    return baseFile(`${baseDescriptor.path}/${baseDescriptor.fileName}`, finalContent);
 }
 // ============================================================================
 // Method builders
@@ -1739,13 +1749,21 @@ function buildFlushTranslationsMethod(modelName) {
 function generateUserService(name, schema, config) {
     const modelName = toPascalCase(name);
     const group = schema.group ? toPascalCase(schema.group) : null;
-    const baseNs = resolveModularBaseNamespace(config, name, 'Services', config.services.baseNamespace);
-    const userNs = group
-        ? `${config.services.namespace}\\${group}`
-        : config.services.namespace;
-    const userPath = group
-        ? `${config.services.path}/${group}`
-        : config.services.path;
+    // Issue #96: route editable stub via resolveEditableClass +
+    // resolveBaseClass so userEditablePath / userEditableNamespace and
+    // flatBase (drops ServiceBase suffix) are honored. Group nesting
+    // (`<userPath>/<Group>/<Schema>Service.php`) preserved.
+    const baseDescriptor = config.structure === 'modular'
+        ? {
+            className: `${modelName}ServiceBase`,
+            fqn: `${resolveModularBaseNamespace(config, name, 'Services', config.services.baseNamespace)}\\${modelName}ServiceBase`,
+        }
+        : resolveBaseClass(config.services, `${modelName}Service`, 'Base');
+    const editable = config.structure === 'modular'
+        ? { className: `${modelName}Service`, fileName: `${modelName}Service.php`, namespace: config.services.namespace, path: config.services.path }
+        : resolveEditableClass(config.services, modelName, 'Service');
+    const userNs = group ? `${editable.namespace}\\${group}` : editable.namespace;
+    const userPath = group ? `${editable.path}/${group}` : editable.path;
     const content = `<?php
 
 /**
@@ -1756,12 +1774,12 @@ function generateUserService(name, schema, config) {
 
 namespace ${userNs};
 
-use ${baseNs}\\${modelName}ServiceBase;
+use ${baseDescriptor.fqn};
 
-class ${modelName}Service extends ${modelName}ServiceBase
+class ${editable.className} extends ${baseDescriptor.className}
 {
     //
 }
 `;
-    return userFile(`${userPath}/${modelName}Service.php`, content);
+    return userFile(`${userPath}/${editable.fileName}`, content);
 }

package/dist/php/types.d.ts

@@ -39,23 +39,80 @@ export declare function resolveSharedBasePath(config: PhpConfig, category: BaseC
  */
 export declare function resolveSharedBaseNamespace(config: PhpConfig, category: BaseCategory, legacyNamespace: string): string;
 /**
- * Resolve global Omnify enum file path. Used for system enums that aren't tied
- * to a single user-defined schema (e.g. FileStatusEnum belongs to the Omnify
- * file-attachment subsystem). In modular mode these live under their own
- * top-level folder so they're easy to find. In legacy mode the original
- * `legacyPath` is preserved for backward compat.
+ * Resolve global Omnify enum file path. ALWAYS uses
+ * `config.globalEnums.path` regardless of structure mode — enums are
+ * conceptually independent of the model tree they describe and belong
+ * in their own dedicated folder for discoverability. The `legacyPath`
+ * argument is kept for callsite compatibility but ignored.
+ *
+ * Default: `app/Omnify/Enums/`. Override via `codegen.laravel.enums.path`
+ * in `omnify.yaml` (e.g. set to `app/Models/Omnify` to restore the
+ * pre-v5.6 legacy behavior of co-locating enums with models).
+ *
+ * History: pre-v5.6, legacy structure dumped enums into the model dir
+ * (`app/Models/Omnify/<Name>Enum.php`), mixing them with the user
+ * models — confusing for code reviewers and inconsistent with modular
+ * mode. Fixed via dedicated dir always.
+ */
+export declare function resolveGlobalEnumPath(config: PhpConfig, fileName: string, _legacyPath: string): string;
+/**
+ * Resolve global Omnify enum namespace. ALWAYS uses
+ * `config.globalEnums.namespace`. The `legacyNamespace` argument is
+ * kept for callsite compatibility but ignored.
+ *
+ * Default: `App\Omnify\Enums`. Override via
+ * `codegen.laravel.enums.namespace` to match a custom path.
+ *
+ * History: pre-v5.6, legacy structure used the model namespace
+ * (`App\Models\Omnify`), forcing every model file to import enums via
+ * the model dir. Fixed via dedicated namespace always.
  */
-export declare function resolveGlobalEnumPath(config: PhpConfig, fileName: string, legacyPath: string): string;
-/** Resolve global Omnify enum namespace. Modular: {globalEnums.namespace}. Legacy: passthrough. */
-export declare function resolveGlobalEnumNamespace(config: PhpConfig, legacyNamespace: string): string;
+export declare function resolveGlobalEnumNamespace(config: PhpConfig, _legacyNamespace: string): string;
 /** Resolve global Omnify trait file path (HasFiles, HasLocalizedDisplayName, ...). */
 export declare function resolveGlobalTraitPath(config: PhpConfig, fileName: string, legacyPath: string): string;
 /** Resolve global Omnify trait namespace. */
 export declare function resolveGlobalTraitNamespace(config: PhpConfig, legacyNamespace: string): string;
-/** Per-target path and namespace override from codegen.laravel config. */
+/**
+ * Per-target path and namespace override from codegen.laravel config.
+ *
+ * Two evolutions in v5.4+ (issue #96): split base / user-editable paths
+ * and `flatBase` to drop the `Base/` subfolder + `*Base*` suffix when
+ * the team has already isolated generated code under its own root
+ * (e.g. `app/Omnify/`).
+ *
+ * Backwards-compat: if `userEditablePath` / `userEditableNamespace` /
+ * `flatBase` are absent, the existing two-tier layout (base + editable
+ * in the same dir, base under `Base/` subfolder with `*Base*` suffix)
+ * stays exactly as before. No project needs to change config to keep
+ * working.
+ */
 export interface LaravelPathOverride {
+    /** Path for BASE (auto-generated, regenerated) classes. */
     path?: string;
+    /** Namespace for BASE (auto-generated) classes. */
     namespace?: string;
+    /**
+     * Path for USER-EDITABLE stubs (omnify writes once, then never touches).
+     * When set, base files write under `path` and editable stubs under
+     * `userEditablePath`. When unset, editable stubs share `path` (legacy
+     * behavior). Issue #96.
+     */
+    userEditablePath?: string;
+    /**
+     * Namespace for USER-EDITABLE stubs. When set, the editable stub uses
+     * this namespace and `extends \{baseNs}\{Class}`. When unset, the
+     * editable stub shares the base namespace (legacy). Issue #96.
+     */
+    userEditableNamespace?: string;
+    /**
+     * `flatBase: true` drops the `Base/` (or `OmnifyBase/`) subfolder AND
+     * the `*BaseModel` / `*RequestBase` / etc. class suffix. Base files
+     * land directly under `path` with the bare schema name as the class.
+     * The user-editable stub then `extends \{path-namespace}\{Schema}` —
+     * one less indirection. Issue #96. Recommended when `path` already
+     * isolates generated code (e.g. `app/Omnify/Models/`).
+     */
+    flatBase?: boolean;
 }
 /** Nested set package configuration. */
 export interface NestedSetOverride {
@@ -131,6 +188,44 @@ export interface LaravelCodegenOverrides {
     /** OpenAPI / Swagger codegen — opt-in. See `OpenApiOverride`. */
     openapi?: OpenApiOverride;
 }
+/**
+ * Resolved per-layer config for layers that follow the Base + Editable
+ * pattern (Model, Service, Request, Resource, Policy, Controller).
+ * Issue #96 added `userEditablePath` / `userEditableNamespace` (split
+ * paths) and `flatBase` (drop Base/ subfolder + *Base* suffix).
+ *
+ * Backwards-compat: when the new fields default, `userEditablePath`
+ * equals `path` and `userEditableNamespace` equals `namespace` —
+ * editable stubs share the same dir as the base, identical to v5.3.x.
+ * `flatBase` defaults false — keeps the existing `*BaseModel` /
+ * `*RequestBase` / etc. suffix + Base/ subfolder.
+ */
+export interface BaseEditableLayer {
+    /** Namespace for base classes. */
+    namespace: string;
+    /** Namespace for base classes' Base/ subfolder (or = namespace when flatBase). */
+    baseNamespace: string;
+    /** Filesystem path where base classes live. */
+    path: string;
+    /** Filesystem path for the Base/ subfolder (or = path when flatBase). */
+    basePath: string;
+    /**
+     * Filesystem path for user-editable stubs. Defaults to `path` (legacy:
+     * stubs share the dir with base). Set via `userEditablePath` override
+     * to relocate the editable stubs to e.g. canonical Laravel paths
+     * (`app/Models/`, `app/Http/Requests/`). Issue #96.
+     */
+    userEditablePath: string;
+    /** Namespace for user-editable stubs. Defaults to `namespace`. Issue #96. */
+    userEditableNamespace: string;
+    /**
+     * `true` collapses the legacy two-tier shape (base under `Base/` with
+     * `*Base*` suffix) into a single flat directory: base lives at `path`
+     * with the bare schema name as the class. The editable stub then
+     * extends `\{namespace}\{Schema}` (no `BaseModel` indirection). Issue #96.
+     */
+    flatBase: boolean;
+}
 /** PHP codegen configuration (resolved with defaults). */
 export interface PhpConfig {
     /** Filesystem prefix applied to all generated paths. Empty when not set. */
@@ -166,24 +261,9 @@ export interface PhpConfig {
      * @deprecated use `modules.path`
      */
     modulesPath: string;
-    models: {
-        namespace: string;
-        baseNamespace: string;
-        path: string;
-        basePath: string;
-    };
-    requests: {
-        namespace: string;
-        baseNamespace: string;
-        path: string;
-        basePath: string;
-    };
-    resources: {
-        namespace: string;
-        baseNamespace: string;
-        path: string;
-        basePath: string;
-    };
+    models: BaseEditableLayer;
+    requests: BaseEditableLayer;
+    resources: BaseEditableLayer;
     factories: {
         namespace: string;
         path: string;
@@ -192,24 +272,9 @@ export interface PhpConfig {
         namespace: string;
         path: string;
     };
-    policies: {
-        namespace: string;
-        baseNamespace: string;
-        path: string;
-        basePath: string;
-    };
-    controllers: {
-        namespace: string;
-        baseNamespace: string;
-        path: string;
-        basePath: string;
-    };
-    services: {
-        namespace: string;
-        baseNamespace: string;
-        path: string;
-        basePath: string;
-    };
+    policies: BaseEditableLayer;
+    controllers: BaseEditableLayer;
+    services: BaseEditableLayer;
     routes: {
         path: string;
     };
@@ -230,6 +295,35 @@ export interface PhpConfig {
         securityScheme: string;
     };
 }
+/**
+ * Class-name + file-name resolver for the BASE class of a layer. Returns
+ * the bare schema name when `layer.flatBase` is true (e.g. `Banner.php`
+ * with class `Banner`); returns the legacy `<Schema><Suffix>` shape
+ * otherwise (e.g. `BannerBaseModel.php` with class `BannerBaseModel`).
+ *
+ * Used by every Base + Editable generator (model, service, request,
+ * resource, policy, controller) so the flatBase semantics stay
+ * consistent across layers. Issue #96.
+ */
+export declare function resolveBaseClass(layer: BaseEditableLayer, schemaName: string, baseSuffix: string): {
+    className: string;
+    fileName: string;
+    namespace: string;
+    path: string;
+    fqn: string;
+};
+/**
+ * Resolver for the user-editable stub of a layer. Always uses the bare
+ * schema name as the class (the editable stub IS the user's class) +
+ * `userEditablePath` / `userEditableNamespace` for location. Issue #96.
+ */
+export declare function resolveEditableClass(layer: BaseEditableLayer, schemaName: string, classSuffix?: string): {
+    className: string;
+    fileName: string;
+    namespace: string;
+    path: string;
+    fqn: string;
+};
 /**
  * Derive full PHP config from optional overrides.
  * All paths and namespaces fall back to sensible defaults.

package/dist/php/types.js

@@ -54,24 +54,38 @@ export function resolveSharedBaseNamespace(config, category, legacyNamespace) {
     return legacyNamespace;
 }
 /**
- * Resolve global Omnify enum file path. Used for system enums that aren't tied
- * to a single user-defined schema (e.g. FileStatusEnum belongs to the Omnify
- * file-attachment subsystem). In modular mode these live under their own
- * top-level folder so they're easy to find. In legacy mode the original
- * `legacyPath` is preserved for backward compat.
+ * Resolve global Omnify enum file path. ALWAYS uses
+ * `config.globalEnums.path` regardless of structure mode — enums are
+ * conceptually independent of the model tree they describe and belong
+ * in their own dedicated folder for discoverability. The `legacyPath`
+ * argument is kept for callsite compatibility but ignored.
+ *
+ * Default: `app/Omnify/Enums/`. Override via `codegen.laravel.enums.path`
+ * in `omnify.yaml` (e.g. set to `app/Models/Omnify` to restore the
+ * pre-v5.6 legacy behavior of co-locating enums with models).
+ *
+ * History: pre-v5.6, legacy structure dumped enums into the model dir
+ * (`app/Models/Omnify/<Name>Enum.php`), mixing them with the user
+ * models — confusing for code reviewers and inconsistent with modular
+ * mode. Fixed via dedicated dir always.
  */
-export function resolveGlobalEnumPath(config, fileName, legacyPath) {
-    if (config.structure === 'modular') {
-        return `${config.globalEnums.path}/${fileName}`;
-    }
-    return `${legacyPath}/${fileName}`;
+export function resolveGlobalEnumPath(config, fileName, _legacyPath) {
+    return `${config.globalEnums.path}/${fileName}`;
 }
-/** Resolve global Omnify enum namespace. Modular: {globalEnums.namespace}. Legacy: passthrough. */
-export function resolveGlobalEnumNamespace(config, legacyNamespace) {
-    if (config.structure === 'modular') {
-        return config.globalEnums.namespace;
-    }
-    return legacyNamespace;
+/**
+ * Resolve global Omnify enum namespace. ALWAYS uses
+ * `config.globalEnums.namespace`. The `legacyNamespace` argument is
+ * kept for callsite compatibility but ignored.
+ *
+ * Default: `App\Omnify\Enums`. Override via
+ * `codegen.laravel.enums.namespace` to match a custom path.
+ *
+ * History: pre-v5.6, legacy structure used the model namespace
+ * (`App\Models\Omnify`), forcing every model file to import enums via
+ * the model dir. Fixed via dedicated namespace always.
+ */
+export function resolveGlobalEnumNamespace(config, _legacyNamespace) {
+    return config.globalEnums.namespace;
 }
 /** Resolve global Omnify trait file path (HasFiles, HasLocalizedDisplayName, ...). */
 export function resolveGlobalTraitPath(config, fileName, legacyPath) {
@@ -129,6 +143,63 @@ function resolvePathAndNamespace(rootPath, override, defaultPath, nsFromPath) {
     const namespace = hasNs ? override.namespace : nsFromPath(path);
     return { path, namespace };
 }
+/**
+ * Build a complete BaseEditableLayer descriptor from per-layer overrides.
+ * Centralizes the v5.4-era defaulting rules (split paths + flatBase) so
+ * every layer (model, service, request, resource, policy, controller)
+ * resolves consistently. Issue #96.
+ */
+function resolveBaseEditableLayer(rootPath, override, defaultPath, baseSubfolder, // "Base" for models/policies, "OmnifyBase" for the rest
+nsFromPath) {
+    const { path, namespace } = resolvePathAndNamespace(rootPath, override, defaultPath, nsFromPath);
+    const flatBase = override?.flatBase ?? false;
+    // Base path + namespace: when flat, base lives directly at `path`;
+    // otherwise it nests under the conventional Base/ (or OmnifyBase/) subfolder.
+    const basePath = flatBase ? path : `${path}/${baseSubfolder}`;
+    const baseNamespace = flatBase ? namespace : `${namespace}\\${baseSubfolder}`;
+    // User-editable: defaults to the same dir as base (legacy behavior),
+    // overridable to e.g. canonical Laravel paths (`app/Models/`).
+    const userEditablePath = override?.userEditablePath
+        ? withRoot(rootPath, override.userEditablePath)
+        : path;
+    const userEditableNamespace = override?.userEditableNamespace ?? namespace;
+    return { namespace, baseNamespace, path, basePath, userEditablePath, userEditableNamespace, flatBase };
+}
+/**
+ * Class-name + file-name resolver for the BASE class of a layer. Returns
+ * the bare schema name when `layer.flatBase` is true (e.g. `Banner.php`
+ * with class `Banner`); returns the legacy `<Schema><Suffix>` shape
+ * otherwise (e.g. `BannerBaseModel.php` with class `BannerBaseModel`).
+ *
+ * Used by every Base + Editable generator (model, service, request,
+ * resource, policy, controller) so the flatBase semantics stay
+ * consistent across layers. Issue #96.
+ */
+export function resolveBaseClass(layer, schemaName, baseSuffix) {
+    const className = layer.flatBase ? schemaName : `${schemaName}${baseSuffix}`;
+    return {
+        className,
+        fileName: `${className}.php`,
+        namespace: layer.baseNamespace,
+        path: layer.basePath,
+        fqn: `${layer.baseNamespace}\\${className}`,
+    };
+}
+/**
+ * Resolver for the user-editable stub of a layer. Always uses the bare
+ * schema name as the class (the editable stub IS the user's class) +
+ * `userEditablePath` / `userEditableNamespace` for location. Issue #96.
+ */
+export function resolveEditableClass(layer, schemaName, classSuffix = '') {
+    const className = `${schemaName}${classSuffix}`;
+    return {
+        className,
+        fileName: `${className}.php`,
+        namespace: layer.userEditableNamespace,
+        path: layer.userEditablePath,
+        fqn: `${layer.userEditableNamespace}\\${className}`,
+    };
+}
 // Default paths.
 //
 // Hybrid projects (manual team code + Omnify codegen) need Omnify-generated
@@ -189,14 +260,18 @@ export function derivePhpConfig(overrides) {
         return p;
     };
     const nsFromPath = (p) => pathToNamespace(stripRoot(p));
-    const { path: modelPath, namespace: modelNs } = resolvePathAndNamespace(rootPath, overrides?.model, DEFAULT_MODEL_PATH, nsFromPath);
-    const { path: requestPath, namespace: requestNs } = resolvePathAndNamespace(rootPath, overrides?.request, DEFAULT_REQUEST_PATH, nsFromPath);
-    const { path: resourcePath, namespace: resourceNs } = resolvePathAndNamespace(rootPath, overrides?.resource, DEFAULT_RESOURCE_PATH, nsFromPath);
+    // Layers that follow the Base + Editable pattern (issue #96): resolve
+    // both layouts (`Base/` + `*Base*` suffix vs flat) and both paths
+    // (base + user-editable) in one place so every layer shares semantics.
+    const modelsLayer = resolveBaseEditableLayer(rootPath, overrides?.model, DEFAULT_MODEL_PATH, 'Base', nsFromPath);
+    const requestsLayer = resolveBaseEditableLayer(rootPath, overrides?.request, DEFAULT_REQUEST_PATH, 'OmnifyBase', nsFromPath);
+    const resourcesLayer = resolveBaseEditableLayer(rootPath, overrides?.resource, DEFAULT_RESOURCE_PATH, 'OmnifyBase', nsFromPath);
+    const policiesLayer = resolveBaseEditableLayer(rootPath, overrides?.policy, DEFAULT_POLICY_PATH, 'Base', nsFromPath);
+    const controllersLayer = resolveBaseEditableLayer(rootPath, overrides?.controller, DEFAULT_CONTROLLER_PATH, 'OmnifyBase', nsFromPath);
+    const servicesLayer = resolveBaseEditableLayer(rootPath, overrides?.service, DEFAULT_SERVICE_PATH, 'OmnifyBase', nsFromPath);
+    // Layers without a Base + Editable split (single-tier files).
     const { path: factoryPath, namespace: factoryNs } = resolvePathAndNamespace(rootPath, overrides?.factory, DEFAULT_FACTORY_PATH, nsFromPath);
     const { path: providerPath, namespace: providerNs } = resolvePathAndNamespace(rootPath, overrides?.provider, DEFAULT_PROVIDER_PATH, nsFromPath);
-    const { path: policyPath, namespace: policyNs } = resolvePathAndNamespace(rootPath, overrides?.policy, DEFAULT_POLICY_PATH, nsFromPath);
-    const { path: controllerPath, namespace: controllerNs } = resolvePathAndNamespace(rootPath, overrides?.controller, DEFAULT_CONTROLLER_PATH, nsFromPath);
-    const { path: servicePath, namespace: serviceNs } = resolvePathAndNamespace(rootPath, overrides?.service, DEFAULT_SERVICE_PATH, nsFromPath);
     const { path: modulesPath, namespace: modulesNs } = resolvePathAndNamespace(rootPath, overrides?.modules, DEFAULT_MODULES_PATH, nsFromPath);
     const { path: sharedPath, namespace: sharedNs } = resolvePathAndNamespace(rootPath, overrides?.shared, DEFAULT_SHARED_PATH, nsFromPath);
     const { path: globalEnumsPath, namespace: globalEnumsNs } = resolvePathAndNamespace(rootPath, overrides?.enums, DEFAULT_GLOBAL_ENUMS_PATH, nsFromPath);
@@ -220,24 +295,9 @@ export function derivePhpConfig(overrides) {
         globalEnums: { namespace: globalEnumsNs, path: globalEnumsPath },
         globalTraits: { namespace: globalTraitsNs, path: globalTraitsPath },
         modulesPath,
-        models: {
-            namespace: modelNs,
-            baseNamespace: `${modelNs}\\Base`,
-            path: modelPath,
-            basePath: `${modelPath}/Base`,
-        },
-        requests: {
-            namespace: requestNs,
-            baseNamespace: `${requestNs}\\OmnifyBase`,
-            path: requestPath,
-            basePath: `${requestPath}/OmnifyBase`,
-        },
-        resources: {
-            namespace: resourceNs,
-            baseNamespace: `${resourceNs}\\OmnifyBase`,
-            path: resourcePath,
-            basePath: `${resourcePath}/OmnifyBase`,
-        },
+        models: modelsLayer,
+        requests: requestsLayer,
+        resources: resourcesLayer,
         factories: {
             namespace: factoryNs,
             path: factoryPath,
@@ -246,24 +306,9 @@ export function derivePhpConfig(overrides) {
             namespace: providerNs,
             path: providerPath,
         },
-        policies: {
-            namespace: policyNs,
-            baseNamespace: `${policyNs}\\Base`,
-            path: policyPath,
-            basePath: `${policyPath}/Base`,
-        },
-        controllers: {
-            namespace: controllerNs,
-            baseNamespace: `${controllerNs}\\OmnifyBase`,
-            path: controllerPath,
-            basePath: `${controllerPath}/OmnifyBase`,
-        },
-        services: {
-            namespace: serviceNs,
-            baseNamespace: `${serviceNs}\\OmnifyBase`,
-            path: servicePath,
-            basePath: `${servicePath}/OmnifyBase`,
-        },
+        policies: policiesLayer,
+        controllers: controllersLayer,
+        services: servicesLayer,
         routes: {
             path: routePath,
         },

package/package.json

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