@omnifyjp/omnify 5.7.0 → 5.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "5.7.0",
+  "version": "5.8.1",
   "description": "Schema-driven code generation for Laravel, TypeScript, and SQL",
   "license": "MIT",
   "repository": {
@@ -36,10 +36,10 @@
     "zod": "^3.24.0"
   },
   "optionalDependencies": {
-    "@omnifyjp/omnify-darwin-arm64": "5.7.0",
-    "@omnifyjp/omnify-darwin-x64": "5.7.0",
-    "@omnifyjp/omnify-linux-x64": "5.7.0",
-    "@omnifyjp/omnify-linux-arm64": "5.7.0",
-    "@omnifyjp/omnify-win32-x64": "5.7.0"
+    "@omnifyjp/omnify-darwin-arm64": "5.8.1",
+    "@omnifyjp/omnify-darwin-x64": "5.8.1",
+    "@omnifyjp/omnify-linux-x64": "5.8.1",
+    "@omnifyjp/omnify-linux-arm64": "5.8.1",
+    "@omnifyjp/omnify-win32-x64": "5.8.1"
   }
 }

package/ts-dist/php/controller-generator.js

@@ -2,7 +2,7 @@
  * Generates base + editable controller classes for schemas with `options.api`.
  */
 import { toPascalCase } from './naming-helper.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup } 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,13 +157,19 @@ abstract class ${modelName}ControllerBase extends Controller
 ${methods.join('\n')}
 }
 `;
-    // Issue #96: legacy honors flatBase (drops ControllerBase suffix + OmnifyBase/ subfolder).
-    const baseDescriptor = config.structure === 'modular'
-        ? {
+    // Issue #96 + #98 v5.8+: legacy honors flatBase + group-by-folder.
+    let baseDescriptor;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             className: `${modelName}ControllerBase`,
             path: resolveModularBasePath(config, name, 'Controllers', '', config.controllers.basePath).replace(/\/$/, ''),
-        }
-        : resolveBaseClass(config.controllers, `${modelName}Controller`, 'Base');
+        };
+    }
+    else {
+        const raw = resolveBaseClass(config.controllers, `${modelName}Controller`, 'Base');
+        const nested = nestByGroup({ path: raw.path, namespace: '' }, schema.group);
+        baseDescriptor = { className: raw.className, path: nested.path };
+    }
     const finalContent = content.replace(new RegExp(`abstract class ${modelName}ControllerBase\\b`, 'g'), `abstract class ${baseDescriptor.className}`);
     return baseFile(`${baseDescriptor.path}/${baseDescriptor.className}.php`, finalContent);
 }

package/ts-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, resolveBaseClass, resolveEditableClass, } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, } 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). */
@@ -29,7 +29,7 @@ function generateForSchema(name, schema, reader, config) {
     const hasNestedSet = detectNestedSet(options, properties);
     return [
         generateBaseModel(name, schema, reader, config),
-        generateUserModel(name, config, hasNestedSet),
+        generateUserModel(name, schema, config, hasNestedSet),
     ];
 }
 function generateBaseModel(name, schema, reader, config) {
@@ -40,16 +40,24 @@ function generateBaseModel(name, schema, reader, config) {
     // 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'
-        ? {
+    // Issue #98 v5.8+: apply group-by-folder nesting in legacy structure
+    // so 100+ schemas produce a navigable tree mirroring schemas/<group>/.
+    let baseDescriptor;
+    let baseNamespace;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             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('\\'));
+        };
+        baseNamespace = resolveModularBaseNamespace(config, name, 'Models', config.models.baseNamespace);
+    }
+    else {
+        const raw = resolveBaseClass(config.models, modelName, 'BaseModel');
+        const nested = nestByGroup({ path: raw.path, namespace: raw.fqn.substring(0, raw.fqn.lastIndexOf('\\')) }, schema.group);
+        baseDescriptor = { className: raw.className, path: nested.path, fqn: `${nested.namespace}\\${raw.className}` };
+        baseNamespace = nested.namespace;
+    }
     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');
@@ -207,18 +215,27 @@ ${auditLogProperties}${relations}${accessors}${fileAccessors}${auditSection}${ne
         : `${baseDescriptor.path}/${baseDescriptor.className}.php`;
     return baseFile(filePath, finalContent);
 }
-function generateUserModel(name, config, hasNestedSet = false) {
+function generateUserModel(name, schema, config, hasNestedSet = false) {
     const modelName = toPascalCase(name);
     // 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');
+    // Issue #98 v5.8+: same group-by-folder nesting on the editable side.
+    let editable;
+    let base;
+    if (config.structure === 'modular') {
+        editable = { fileName: `${modelName}.php`, namespace: config.models.namespace, path: config.models.path, fqn: `${config.models.namespace}\\${modelName}`, className: modelName };
+        base = { className: `${modelName}BaseModel`, fqn: `${resolveModularBaseNamespace(config, name, 'Models', config.models.baseNamespace)}\\${modelName}BaseModel` };
+    }
+    else {
+        const editRaw = resolveEditableClass(config.models, modelName);
+        const editNested = nestByGroup({ path: editRaw.path, namespace: editRaw.namespace }, schema.group);
+        editable = { className: editRaw.className, fileName: editRaw.fileName, namespace: editNested.namespace, path: editNested.path, fqn: `${editNested.namespace}\\${editRaw.className}` };
+        const baseRaw = resolveBaseClass(config.models, modelName, 'BaseModel');
+        const baseNs = nestByGroup({ path: baseRaw.path, namespace: baseRaw.fqn.substring(0, baseRaw.fqn.lastIndexOf('\\')) }, schema.group).namespace;
+        base = { className: baseRaw.className, fqn: `${baseNs}\\${baseRaw.className}` };
+    }
     const factoryNamespace = config.factories.namespace;
     const nestedSetNamespace = config.nestedset.namespace;
     // Issue #98: when flatBase + userEditablePath both set, base.className

package/ts-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, resolveBaseClass, resolveEditableClass } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup } from './types.js';
 // ============================================================================
 // Action mapping: Omnify → Laravel
 // ============================================================================
@@ -40,7 +40,7 @@ export function generatePolicies(reader, config) {
 function generateForSchema(name, schema, reader, config) {
     return [
         generateBasePolicyClass(name, schema, reader, config),
-        generateUserPolicyClass(name, config),
+        generateUserPolicyClass(name, schema, config),
     ];
 }
 function generateBasePolicyClass(name, schema, reader, config) {
@@ -89,28 +89,42 @@ class ${modelName}PolicyBase
 ${methods.join('\n')}${cidrHelper}
 }
 `;
-    // Issue #96: legacy honors flatBase (drops PolicyBase suffix + Base/ subfolder).
-    const baseDescriptor = config.structure === 'modular'
-        ? {
+    // Issue #96 + #98 v5.8+: legacy honors flatBase + group-by-folder.
+    let baseDescriptor;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             className: `${modelName}PolicyBase`,
             path: resolveModularBasePath(config, name, 'Policies', '', config.policies.basePath).replace(/\/$/, ''),
-        }
-        : resolveBaseClass(config.policies, `${modelName}Policy`, 'Base');
+        };
+    }
+    else {
+        const raw = resolveBaseClass(config.policies, `${modelName}Policy`, 'Base');
+        const nested = nestByGroup({ path: raw.path, namespace: '' }, schema.group);
+        baseDescriptor = { className: raw.className, path: nested.path };
+    }
     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) {
+function generateUserPolicyClass(name, schema, config) {
     const modelName = toPascalCase(name);
-    // Issue #96: editable stub via resolveEditableClass + extends adapts to flatBase.
-    const baseDescriptor = config.structure === 'modular'
-        ? {
+    // Issue #96 + #98 v5.8+: split paths + flatBase + group-by-folder.
+    let baseDescriptor;
+    let editable;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             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');
+        };
+        editable = { className: `${modelName}Policy`, fileName: `${modelName}Policy.php`, namespace: config.policies.namespace, path: config.policies.path };
+    }
+    else {
+        const baseRaw = resolveBaseClass(config.policies, `${modelName}Policy`, 'Base');
+        const baseNs = nestByGroup({ path: baseRaw.path, namespace: baseRaw.fqn.substring(0, baseRaw.fqn.lastIndexOf('\\')) }, schema.group).namespace;
+        baseDescriptor = { className: baseRaw.className, fqn: `${baseNs}\\${baseRaw.className}` };
+        const editRaw = resolveEditableClass(config.policies, modelName, 'Policy');
+        const editNested = nestByGroup({ path: editRaw.path, namespace: editRaw.namespace }, schema.group);
+        editable = { className: editRaw.className, fileName: editRaw.fileName, namespace: editNested.namespace, path: editNested.path };
+    }
     // Issue #98: alias on class-name collision (flatBase + userEditablePath).
     const baseAlias = baseDescriptor.className === editable.className
         ? `${baseDescriptor.className}Base`

package/ts-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, resolveBaseClass, resolveEditableClass } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup } 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.
@@ -36,8 +36,8 @@ function generateForSchema(name, schema, reader, config) {
     return [
         generateBaseRequest(name, schema, reader, config, 'Store'),
         generateBaseRequest(name, schema, reader, config, 'Update'),
-        generateUserRequest(name, config, 'Store'),
-        generateUserRequest(name, config, 'Update'),
+        generateUserRequest(name, schema, config, 'Store'),
+        generateUserRequest(name, schema, config, 'Update'),
     ];
 }
 function generateBaseRequest(name, schema, reader, config, action) {
@@ -257,30 +257,42 @@ ${attributeKeysList}
     }
 }
 `;
-    // 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'
-        ? {
+    // Issue #96 + #98 v5.8+: legacy honors flatBase + group-by-folder.
+    let baseDescriptor;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             className: `${modelName}${action}RequestBase`,
             path: resolveModularBasePath(config, name, 'Requests', '', config.requests.basePath).replace(/\/$/, ''),
-        }
-        : resolveBaseClass(config.requests, `${modelName}${action}Request`, 'Base');
+        };
+    }
+    else {
+        const raw = resolveBaseClass(config.requests, `${modelName}${action}Request`, 'Base');
+        const nested = nestByGroup({ path: raw.path, namespace: '' }, schema.group);
+        baseDescriptor = { className: raw.className, path: nested.path };
+    }
     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) {
+function generateUserRequest(name, schema, config, action) {
     const modelName = toPascalCase(name);
-    // Issue #96: editable stub may live at userEditablePath; extends-clause adapts to flatBase.
-    const baseDescriptor = config.structure === 'modular'
-        ? {
+    // Issue #96 + #98 v5.8+: split paths + flatBase + group-by-folder.
+    let baseDescriptor;
+    let editable;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             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`);
+        };
+        editable = { className: `${modelName}${action}Request`, fileName: `${modelName}${action}Request.php`, namespace: config.requests.namespace, path: config.requests.path };
+    }
+    else {
+        const baseRaw = resolveBaseClass(config.requests, `${modelName}${action}Request`, 'Base');
+        const baseNs = nestByGroup({ path: baseRaw.path, namespace: baseRaw.fqn.substring(0, baseRaw.fqn.lastIndexOf('\\')) }, schema.group).namespace;
+        baseDescriptor = { className: baseRaw.className, fqn: `${baseNs}\\${baseRaw.className}` };
+        const editRaw = resolveEditableClass(config.requests, modelName, `${action}Request`);
+        const editNested = nestByGroup({ path: editRaw.path, namespace: editRaw.namespace }, schema.group);
+        editable = { className: editRaw.className, fileName: editRaw.fileName, namespace: editNested.namespace, path: editNested.path };
+    }
     // Issue #98: alias on class-name collision (flatBase + userEditablePath).
     const baseAlias = baseDescriptor.className === editable.className
         ? `${baseDescriptor.className}Base`

package/ts-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, resolveBaseClass, resolveEditableClass } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup } from './types.js';
 /** Generate Resource classes for all project-owned visible object schemas. */
 export function generateResources(reader, config) {
     const files = [];
@@ -11,7 +11,7 @@ export function generateResources(reader, config) {
         if (schema.kind === 'extend')
             continue;
         files.push(generateBaseResource(name, schema, reader, config));
-        files.push(generateUserResource(name, config));
+        files.push(generateUserResource(name, schema, config));
     }
     return files;
 }
@@ -119,30 +119,42 @@ ${fieldsContent}
     }
 }
 `;
-    // Issue #96: legacy honors flatBase (drops ResourceBase suffix +
-    // OmnifyBase/ subfolder); modular keeps the per-module path.
-    const baseDescriptor = config.structure === 'modular'
-        ? {
+    // Issue #96 + #98 v5.8+: legacy honors flatBase + group-by-folder.
+    let baseDescriptor;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             className: `${modelName}ResourceBase`,
             path: resolveModularBasePath(config, name, 'Resources', '', config.resources.basePath).replace(/\/$/, ''),
-        }
-        : resolveBaseClass(config.resources, `${modelName}Resource`, 'Base');
+        };
+    }
+    else {
+        const raw = resolveBaseClass(config.resources, `${modelName}Resource`, 'Base');
+        const nested = nestByGroup({ path: raw.path, namespace: '' }, schema.group);
+        baseDescriptor = { className: raw.className, path: nested.path };
+    }
     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) {
+function generateUserResource(name, schema, config) {
     const modelName = toPascalCase(name);
-    // Issue #96: editable stub may live at userEditablePath; extends-clause
-    // adapts to flatBase too.
-    const baseDescriptor = config.structure === 'modular'
-        ? {
+    // Issue #96 + #98 v5.8+: split paths + flatBase + group-by-folder nesting.
+    let baseDescriptor;
+    let editable;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             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');
+        };
+        editable = { className: `${modelName}Resource`, fileName: `${modelName}Resource.php`, namespace: config.resources.namespace, path: config.resources.path };
+    }
+    else {
+        const baseRaw = resolveBaseClass(config.resources, `${modelName}Resource`, 'Base');
+        const baseNs = nestByGroup({ path: baseRaw.path, namespace: baseRaw.fqn.substring(0, baseRaw.fqn.lastIndexOf('\\')) }, schema.group).namespace;
+        baseDescriptor = { className: baseRaw.className, fqn: `${baseNs}\\${baseRaw.className}` };
+        const editRaw = resolveEditableClass(config.resources, modelName, 'Resource');
+        const editNested = nestByGroup({ path: editRaw.path, namespace: editRaw.namespace }, schema.group);
+        editable = { className: editRaw.className, fileName: editRaw.fileName, namespace: editNested.namespace, path: editNested.path };
+    }
     // Issue #98: alias on class-name collision (flatBase + userEditablePath).
     const baseAlias = baseDescriptor.className === editable.className
         ? `${baseDescriptor.className}Base`

package/ts-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, resolveBaseClass, resolveEditableClass } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup } from './types.js';
 // ============================================================================
 // Public entry point
 // ============================================================================
@@ -593,15 +593,24 @@ class ${modelName}ServiceBase
 ${sections.join('\n')}
 }
 `;
-    // Issue #96: legacy structure honors flatBase (drops `ServiceBase`
-    // suffix + OmnifyBase/ subfolder); modular keeps the per-module path.
-    const baseDescriptor = config.structure === 'modular'
-        ? {
+    // Issue #96 + #98 v5.8+: legacy structure honors flatBase + group-by-folder.
+    let baseDescriptor;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             className: `${modelName}ServiceBase`,
             fileName: `${modelName}ServiceBase.php`,
             path: resolveModularBasePath(config, name, 'Services', '', config.services.basePath).replace(/\/$/, ''),
-        }
-        : resolveBaseClass(config.services, `${modelName}Service`, 'Base');
+        };
+    }
+    else {
+        const raw = resolveBaseClass(config.services, `${modelName}Service`, 'Base');
+        const nested = nestByGroup({ path: raw.path, namespace: '' }, schema.group);
+        baseDescriptor = {
+            className: raw.className,
+            fileName: `${raw.className}.php`,
+            path: nested.path,
+        };
+    }
     const finalContent = content.replace(new RegExp(`class ${modelName}ServiceBase\\b`, 'g'), `class ${baseDescriptor.className}`);
     return baseFile(`${baseDescriptor.path}/${baseDescriptor.fileName}`, finalContent);
 }
@@ -1749,21 +1758,31 @@ function buildFlushTranslationsMethod(modelName) {
 function generateUserService(name, schema, config) {
     const modelName = toPascalCase(name);
     const group = schema.group ? toPascalCase(schema.group) : null;
-    // Issue #96: route editable stub via resolveEditableClass +
+    // Issue #96 + #98 v5.8+: 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'
-        ? {
+    // flatBase (drops ServiceBase suffix) are honored, then nest by group.
+    let baseDescriptor;
+    let editable;
+    if (config.structure === 'modular') {
+        baseDescriptor = {
             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;
+        };
+        editable = { className: `${modelName}Service`, fileName: `${modelName}Service.php`, namespace: config.services.namespace, path: config.services.path };
+    }
+    else {
+        const baseRaw = resolveBaseClass(config.services, `${modelName}Service`, 'Base');
+        const baseNs = nestByGroup({ path: baseRaw.path, namespace: baseRaw.fqn.substring(0, baseRaw.fqn.lastIndexOf('\\')) }, schema.group).namespace;
+        baseDescriptor = { className: baseRaw.className, fqn: `${baseNs}\\${baseRaw.className}` };
+        const editRaw = resolveEditableClass(config.services, modelName, 'Service');
+        const editNested = nestByGroup({ path: editRaw.path, namespace: editRaw.namespace }, schema.group);
+        editable = { className: editRaw.className, fileName: editRaw.fileName, namespace: editNested.namespace, path: editNested.path };
+    }
+    // Group nesting already applied via nestByGroup above; no additional
+    // <Group>/ subfolder needed here. (Pre-#98 had explicit group var; now
+    // baked into the nested editable.path/namespace.)
+    const userNs = editable.namespace;
+    const userPath = editable.path;
     // Issue #98: alias on class-name collision (flatBase + userEditablePath)
     // so `class BannerService extends BannerService` becomes
     // `class BannerService extends BannerServiceBase` via aliased import.

package/ts-dist/php/types.d.ts

@@ -295,6 +295,29 @@ export interface PhpConfig {
         securityScheme: string;
     };
 }
+/**
+ * Apply group-by-folder nesting (issue #98 v5.8+). When the schema's
+ * `group:` field is non-empty, append `<PascalGroup>` as a subfolder
+ * AND a sub-namespace. Schemas without `group:` are unchanged (no
+ * synthetic `Default/` / `Misc/` folder per the issue thread).
+ *
+ * Used by every generator's base + editable path resolution so files
+ * mirror the schema directory layout. With 100+ schemas across many
+ * groups, the flat output is unusable; nesting matches what devs
+ * already expect since the schemas themselves live at
+ * `schemas/<group>/<Name>.yaml`.
+ *
+ * Only applies to LEGACY structure; modular structure already nests
+ * per-Schema (`app/Omnify/Modules/<Schema>/<Layer>/`) so adding group
+ * on top would be redundant.
+ */
+export declare function nestByGroup(base: {
+    path: string;
+    namespace: string;
+}, group: string | undefined): {
+    path: string;
+    namespace: 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`

package/ts-dist/php/types.js

@@ -101,6 +101,31 @@ export function resolveGlobalTraitNamespace(config, legacyNamespace) {
     }
     return legacyNamespace;
 }
+/**
+ * Apply group-by-folder nesting (issue #98 v5.8+). When the schema's
+ * `group:` field is non-empty, append `<PascalGroup>` as a subfolder
+ * AND a sub-namespace. Schemas without `group:` are unchanged (no
+ * synthetic `Default/` / `Misc/` folder per the issue thread).
+ *
+ * Used by every generator's base + editable path resolution so files
+ * mirror the schema directory layout. With 100+ schemas across many
+ * groups, the flat output is unusable; nesting matches what devs
+ * already expect since the schemas themselves live at
+ * `schemas/<group>/<Name>.yaml`.
+ *
+ * Only applies to LEGACY structure; modular structure already nests
+ * per-Schema (`app/Omnify/Modules/<Schema>/<Layer>/`) so adding group
+ * on top would be redundant.
+ */
+export function nestByGroup(base, group) {
+    if (!group)
+        return base;
+    const pascal = group.charAt(0).toUpperCase() + group.slice(1).replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+    return {
+        path: `${base.path}/${pascal}`,
+        namespace: `${base.namespace}\\${pascal}`,
+    };
+}
 /** Convert a file path to a PHP namespace (e.g., app/Models/Omnify → App\Models\Omnify). */
 function pathToNamespace(p) {
     return p