@omnifyjp/omnify 3.3.0 → 3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "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": "3.3.0",
-    "@omnifyjp/omnify-darwin-x64": "3.3.0",
-    "@omnifyjp/omnify-linux-x64": "3.3.0",
-    "@omnifyjp/omnify-linux-arm64": "3.3.0",
-    "@omnifyjp/omnify-win32-x64": "3.3.0"
+    "@omnifyjp/omnify-darwin-arm64": "3.5.0",
+    "@omnifyjp/omnify-darwin-x64": "3.5.0",
+    "@omnifyjp/omnify-linux-x64": "3.5.0",
+    "@omnifyjp/omnify-linux-arm64": "3.5.0",
+    "@omnifyjp/omnify-win32-x64": "3.5.0"
   }
 }

package/ts-dist/php/file-model-generator.js

@@ -5,7 +5,7 @@
  * - FileStatusEnum.php (base, always overwritten)
  * - FileLocales.php (base, always overwritten)
  */
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalEnumPath, resolveGlobalEnumNamespace, resolveGlobalTraitNamespace, } from './types.js';
 /** Generate all File model infrastructure files. */
 export function generateFileModels(reader, config) {
     if (!reader.hasFileProperties())
@@ -96,9 +96,10 @@ class FileResource extends FileResourceBase
 function generateFileBaseModel(config, defaultDisk) {
     const baseNamespace = resolveModularBaseNamespace(config, 'File', 'Models', config.models.baseNamespace);
     const localesNamespace = resolveModularBaseNamespace(config, 'File', 'Locales', config.models.baseNamespace + '\\Locales');
-    const traitsNamespace = resolveSharedBaseNamespace(config, 'Traits', config.models.baseNamespace + '\\Traits');
+    // Issue #33: HasLocalizedDisplayName is a global Omnify trait — see trait-generator.ts.
+    const traitsNamespace = resolveGlobalTraitNamespace(config, config.models.baseNamespace + '\\Traits');
     const sharedModelsNamespace = resolveSharedBaseNamespace(config, 'Models', config.models.baseNamespace);
-    const enumNamespace = resolveModularBaseNamespace(config, 'File', 'Enums', config.models.namespace);
+    const enumNamespace = resolveGlobalEnumNamespace(config, config.models.namespace);
     const modelNamespace = config.models.namespace;
     const content = `<?php
 
@@ -334,7 +335,10 @@ class File extends FileBaseModel
     return userFile(`${config.models.path}/File.php`, content);
 }
 function generateFileStatusEnum(config) {
-    const modelNamespace = resolveModularBaseNamespace(config, 'File', 'Enums', config.models.namespace);
+    // Issue #33: FileStatusEnum belongs to the Omnify file-attachment subsystem,
+    // not to a user-defined "File" schema, so it lives in the global enums
+    // folder rather than under `Modules/File/Enums/`.
+    const modelNamespace = resolveGlobalEnumNamespace(config, config.models.namespace);
     const content = `<?php
 
 namespace ${modelNamespace};
@@ -372,7 +376,7 @@ enum FileStatusEnum: string
     }
 }
 `;
-    return baseFile(resolveModularBasePath(config, 'File', 'Enums', 'FileStatusEnum.php', config.models.path), content);
+    return baseFile(resolveGlobalEnumPath(config, 'FileStatusEnum.php', config.models.path), content);
 }
 function generateFileLocales(config, locales) {
     const baseNamespace = resolveModularBaseNamespace(config, 'File', 'Locales', config.models.baseNamespace + '\\Locales');

package/ts-dist/php/file-trait-generator.js

@@ -1,11 +1,13 @@
 /**
  * Generates the HasFiles trait for models with File-type properties.
  */
-import { baseFile, resolveModularBasePath, resolveModularBaseNamespace } from './types.js';
+import { baseFile, resolveGlobalTraitPath, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, } from './types.js';
 /** Generate the HasFiles trait. */
 export function generateFileTrait(config) {
-    const traitsNamespace = resolveModularBaseNamespace(config, 'File', 'Traits', config.models.baseNamespace + '\\Traits');
-    const enumNamespace = resolveModularBaseNamespace(config, 'File', 'Enums', config.models.namespace);
+    // Issue #33: HasFiles is a global Omnify trait — not scoped to any user
+    // schema — so it lives in the dedicated global traits folder.
+    const traitsNamespace = resolveGlobalTraitNamespace(config, config.models.baseNamespace + '\\Traits');
+    const enumNamespace = resolveGlobalEnumNamespace(config, config.models.namespace);
     const modelNamespace = config.models.namespace;
     const content = `<?php
 
@@ -92,6 +94,6 @@ trait HasFiles
 }
 `;
     return [
-        baseFile(resolveModularBasePath(config, 'File', 'Traits', 'HasFiles.php', config.models.basePath + '/Traits'), content),
+        baseFile(resolveGlobalTraitPath(config, 'HasFiles.php', config.models.basePath + '/Traits'), content),
     ];
 }

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

@@ -4,7 +4,7 @@
 import { toPascalCase, toSnakeCase, toCamelCase } from './naming-helper.js';
 import { toCast, toPhpDocType, isHiddenByDefault } from './type-mapper.js';
 import { buildRelation } from './relation-builder.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, } from './types.js';
 /** Generate base model and user model for all project-owned object schemas,
  *  plus user models for package schemas (extending the package model). */
 export function generateModels(reader, config) {
@@ -35,7 +35,8 @@ function generateBaseModel(name, schema, reader, config) {
     const modelName = toPascalCase(name);
     const baseNamespace = resolveModularBaseNamespace(config, name, 'Models', config.models.baseNamespace);
     const localesNamespace = resolveModularBaseNamespace(config, name, 'Locales', config.models.baseNamespace + '\\Locales');
-    const traitsNamespace = resolveSharedBaseNamespace(config, 'Traits', config.models.baseNamespace + '\\Traits');
+    // Issue #33: HasLocalizedDisplayName is a global Omnify trait, not a per-shared module file.
+    const traitsNamespace = resolveGlobalTraitNamespace(config, config.models.baseNamespace + '\\Traits');
     const sharedModelsNamespace = resolveSharedBaseNamespace(config, 'Models', config.models.baseNamespace);
     const modelNamespace = config.models.namespace;
     const options = schema.options ?? {};

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

@@ -1,10 +1,13 @@
 /**
  * Port of TraitGenerator.php — generates HasLocalizedDisplayName trait.
  */
-import { baseFile, resolveSharedBasePath, resolveSharedBaseNamespace } from './types.js';
+import { baseFile, resolveGlobalTraitPath, resolveGlobalTraitNamespace } from './types.js';
 /** Generate the HasLocalizedDisplayName trait. */
 export function generateTrait(config) {
-    const ns = resolveSharedBaseNamespace(config, 'Traits', config.models.baseNamespace + '\\Traits');
+    // Issue #33: HasLocalizedDisplayName is a global Omnify trait shared across
+    // all schemas, so it belongs in the global traits folder, not under any
+    // single schema's `Modules/{Schema}/Traits/` subfolder.
+    const ns = resolveGlobalTraitNamespace(config, config.models.baseNamespace + '\\Traits');
     const content = `<?php
 
 namespace ${ns};
@@ -99,6 +102,6 @@ trait HasLocalizedDisplayName
 }
 `;
     return [
-        baseFile(resolveSharedBasePath(config, 'Traits', 'HasLocalizedDisplayName.php', config.models.basePath + '/Traits'), content),
+        baseFile(resolveGlobalTraitPath(config, 'HasLocalizedDisplayName.php', config.models.basePath + '/Traits'), content),
     ];
 }

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

@@ -16,28 +16,42 @@ export declare function userFile(path: string, content: string): GeneratedFile;
 export type BaseCategory = 'Models' | 'Controllers' | 'Requests' | 'Resources' | 'Services' | 'Enums' | 'Traits' | 'Locales' | 'Policies';
 /**
  * Resolve base file path for a schema based on structure.
- * Modular: app/Modules/{SchemaName}/{category}/{fileName}
+ * Modular: {modules.path}/{SchemaName}/{category}/{fileName}
  * Legacy: {legacyPath}/{fileName}
  */
 export declare function resolveModularBasePath(config: PhpConfig, schemaName: string, category: BaseCategory, fileName: string, legacyPath: string): string;
 /**
  * Resolve base namespace for a schema based on structure.
- * Modular: App\Modules\{SchemaName}\{Category}
+ * Modular: {modules.namespace}\{SchemaName}\{Category}
  * Legacy: {legacyNamespace}
  */
 export declare function resolveModularBaseNamespace(config: PhpConfig, schemaName: string, category: BaseCategory, legacyNamespace: string): string;
 /**
- * Resolve shared base path (for cross-module files like BaseModel, HasLocalizedDisplayName).
- * Modular: app/Modules/Shared/{category}/{fileName}
+ * Resolve shared base path (for cross-module files like BaseModel).
+ * Modular: {shared.path}/{category}/{fileName}
  * Legacy: {legacyPath}/{fileName}
  */
 export declare function resolveSharedBasePath(config: PhpConfig, category: BaseCategory, fileName: string, legacyPath: string): string;
 /**
  * Resolve shared base namespace.
- * Modular: App\Modules\Shared\{Category}
+ * Modular: {shared.namespace}\{Category}
  * Legacy: {legacyNamespace}
  */
 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.
+ */
+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;
+/** 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. */
 export interface LaravelPathOverride {
     path?: string;
@@ -65,6 +79,26 @@ export interface LaravelCodegenOverrides {
     policy?: LaravelPathOverride;
     controller?: LaravelPathOverride;
     service?: LaravelPathOverride;
+    /**
+     * Per-schema base-class root for `structure: modular`. Default
+     * `App\Omnify\Modules` (path `app/Omnify/Modules`) so generated base classes
+     * never collide with a team's hand-written `app/Modules/` (Modular Monolith
+     * pattern is common in Laravel).
+     */
+    modules?: LaravelPathOverride;
+    /** Cross-module shared classes (e.g. `BaseModel`). Default `App\Omnify\Shared`. */
+    shared?: LaravelPathOverride;
+    /**
+     * Global Omnify enums that aren't tied to a single user-defined schema
+     * (e.g. `FileStatusEnum` for the file-attachment subsystem).
+     * Default `App\Omnify\Enums`.
+     */
+    enums?: LaravelPathOverride;
+    /**
+     * Global Omnify traits (e.g. `HasFiles`, `HasLocalizedDisplayName`).
+     * Default `App\Omnify\Traits`.
+     */
+    traits?: LaravelPathOverride;
     route?: LaravelPathOverride;
     config?: LaravelPathOverride;
     nestedset?: NestedSetOverride;
@@ -74,6 +108,35 @@ export interface PhpConfig {
     /** Filesystem prefix applied to all generated paths. Empty when not set. */
     rootPath: string;
     structure: 'legacy' | 'modular';
+    /**
+     * Modular base-class root: `{path}/{Schema}/{Layer}/...` and
+     * `{namespace}\{Schema}\{Layer}`. Only consulted in `structure: modular`.
+     */
+    modules: {
+        namespace: string;
+        path: string;
+    };
+    /** Cross-module shared root (e.g. BaseModel lives at `{shared.path}/Models/`). */
+    shared: {
+        namespace: string;
+        path: string;
+    };
+    /** Global Omnify enums (e.g. FileStatusEnum). */
+    globalEnums: {
+        namespace: string;
+        path: string;
+    };
+    /** Global Omnify traits (e.g. HasFiles, HasLocalizedDisplayName). */
+    globalTraits: {
+        namespace: string;
+        path: string;
+    };
+    /**
+     * Backward-compat alias for `modules.path`. Kept so external callers and
+     * tests that read `config.modulesPath` keep working; new code should use
+     * `config.modules.path` instead.
+     * @deprecated use `modules.path`
+     */
     modulesPath: string;
     models: {
         namespace: string;

package/ts-dist/php/types.js

@@ -11,57 +11,81 @@ export function userFile(path, content) {
 }
 /**
  * Resolve base file path for a schema based on structure.
- * Modular: app/Modules/{SchemaName}/{category}/{fileName}
+ * Modular: {modules.path}/{SchemaName}/{category}/{fileName}
  * Legacy: {legacyPath}/{fileName}
  */
 export function resolveModularBasePath(config, schemaName, category, fileName, legacyPath) {
     if (config.structure === 'modular') {
-        return `${config.modulesPath}/${schemaName}/${category}/${fileName}`;
+        return `${config.modules.path}/${schemaName}/${category}/${fileName}`;
     }
     return `${legacyPath}/${fileName}`;
 }
 /**
  * Resolve base namespace for a schema based on structure.
- * Modular: App\Modules\{SchemaName}\{Category}
+ * Modular: {modules.namespace}\{SchemaName}\{Category}
  * Legacy: {legacyNamespace}
  */
 export function resolveModularBaseNamespace(config, schemaName, category, legacyNamespace) {
     if (config.structure === 'modular') {
-        return pathToNamespace(`${stripRootPath(config, config.modulesPath)}/${schemaName}/${category}`);
+        return `${config.modules.namespace}\\${schemaName}\\${category}`;
     }
     return legacyNamespace;
 }
 /**
- * Resolve shared base path (for cross-module files like BaseModel, HasLocalizedDisplayName).
- * Modular: app/Modules/Shared/{category}/{fileName}
+ * Resolve shared base path (for cross-module files like BaseModel).
+ * Modular: {shared.path}/{category}/{fileName}
  * Legacy: {legacyPath}/{fileName}
  */
 export function resolveSharedBasePath(config, category, fileName, legacyPath) {
     if (config.structure === 'modular') {
-        return `${config.modulesPath}/Shared/${category}/${fileName}`;
+        return `${config.shared.path}/${category}/${fileName}`;
     }
     return `${legacyPath}/${fileName}`;
 }
 /**
  * Resolve shared base namespace.
- * Modular: App\Modules\Shared\{Category}
+ * Modular: {shared.namespace}\{Category}
  * Legacy: {legacyNamespace}
  */
 export function resolveSharedBaseNamespace(config, category, legacyNamespace) {
     if (config.structure === 'modular') {
-        return pathToNamespace(`${stripRootPath(config, config.modulesPath)}/Shared/${category}`);
+        return `${config.shared.namespace}\\${category}`;
     }
     return legacyNamespace;
 }
-/** Strip the configured rootPath prefix from a filesystem path. */
-function stripRootPath(config, p) {
-    if (!config.rootPath)
-        return p;
-    if (p === config.rootPath)
-        return '';
-    if (p.startsWith(`${config.rootPath}/`))
-        return p.slice(config.rootPath.length + 1);
-    return p;
+/**
+ * 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.
+ */
+export function resolveGlobalEnumPath(config, fileName, legacyPath) {
+    if (config.structure === 'modular') {
+        return `${config.globalEnums.path}/${fileName}`;
+    }
+    return `${legacyPath}/${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 trait file path (HasFiles, HasLocalizedDisplayName, ...). */
+export function resolveGlobalTraitPath(config, fileName, legacyPath) {
+    if (config.structure === 'modular') {
+        return `${config.globalTraits.path}/${fileName}`;
+    }
+    return `${legacyPath}/${fileName}`;
+}
+/** Resolve global Omnify trait namespace. */
+export function resolveGlobalTraitNamespace(config, legacyNamespace) {
+    if (config.structure === 'modular') {
+        return config.globalTraits.namespace;
+    }
+    return legacyNamespace;
 }
 /** Convert a file path to a PHP namespace (e.g., app/Models/Omnify → App\Models\Omnify). */
 function pathToNamespace(p) {
@@ -70,18 +94,67 @@ function pathToNamespace(p) {
         .map(s => s.charAt(0).toUpperCase() + s.slice(1))
         .join('\\');
 }
-// Default paths
-const DEFAULT_MODEL_PATH = 'app/Models/Omnify';
-const DEFAULT_REQUEST_PATH = 'app/Http/Requests';
-const DEFAULT_RESOURCE_PATH = 'app/Http/Resources';
+/**
+ * Convert a PHP namespace to a Laravel filesystem path
+ * (e.g., App\Models → app/Models, App\Models\Omnify → app/Models/Omnify).
+ *
+ * Lowercases the leading "App" segment to match Laravel's autoload convention.
+ */
+function namespaceToPath(ns) {
+    const parts = ns.split('\\').filter(Boolean);
+    if (parts.length === 0)
+        return '';
+    if (parts[0] === 'App')
+        parts[0] = 'app';
+    return parts.join('/');
+}
+/**
+ * Resolve the path/namespace pair for a target (model, policy, etc.) so they
+ * always stay in sync. Either side can be overridden independently:
+ *   - both unset → use defaults
+ *   - only path set → derive namespace from path
+ *   - only namespace set → derive path from namespace (prevents autoload
+ *     mismatches like generating App\Foo into app/Foo/Bar/)
+ *   - both set → use as-is (caller is responsible for keeping them aligned)
+ */
+function resolvePathAndNamespace(rootPath, override, defaultPath, nsFromPath) {
+    const hasPath = override?.path !== undefined;
+    const hasNs = override?.namespace !== undefined;
+    if (hasNs && !hasPath) {
+        const namespace = override.namespace;
+        const path = withRoot(rootPath, namespaceToPath(namespace));
+        return { path, namespace };
+    }
+    const path = withRoot(rootPath, override?.path ?? defaultPath);
+    const namespace = hasNs ? override.namespace : nsFromPath(path);
+    return { path, namespace };
+}
+// Default paths.
+//
+// Hybrid projects (manual team code + Omnify codegen) need Omnify-generated
+// files to live in their own `Omnify/` subfolder so they don't collide with
+// hand-written controllers/services/requests/resources of the same name.
+// See issue #32. Models keep the standard `app/Models` location because
+// editable models are first-class entities the team owns directly; the
+// regenerated base classes already live under `app/Modules/{Schema}/Models/`
+// in modular structure.
+const DEFAULT_MODEL_PATH = 'app/Models';
+const DEFAULT_REQUEST_PATH = 'app/Http/Requests/Omnify';
+const DEFAULT_RESOURCE_PATH = 'app/Http/Resources/Omnify';
 const DEFAULT_FACTORY_PATH = 'database/factories';
 const DEFAULT_PROVIDER_PATH = 'app/Providers';
 const DEFAULT_POLICY_PATH = 'app/Policies/Omnify';
-const DEFAULT_CONTROLLER_PATH = 'app/Http/Controllers';
-const DEFAULT_SERVICE_PATH = 'app/Services';
+const DEFAULT_CONTROLLER_PATH = 'app/Http/Controllers/Omnify';
+const DEFAULT_SERVICE_PATH = 'app/Services/Omnify';
 const DEFAULT_ROUTE_PATH = 'routes/api/omnify';
 const DEFAULT_CONFIG_FILE_PATH = 'config/omnify-schemas.php';
-const DEFAULT_MODULES_PATH = 'app/Modules';
+// Modular base-class roots — issue #33. All Omnify auto-generated code lives
+// under `app/Omnify/` so it's clearly separated from team's manual `app/Modules/`
+// (Modular Monolith pattern), and easy to gitignore / nuke as a single tree.
+const DEFAULT_MODULES_PATH = 'app/Omnify/Modules';
+const DEFAULT_SHARED_PATH = 'app/Omnify/Shared';
+const DEFAULT_GLOBAL_ENUMS_PATH = 'app/Omnify/Enums';
+const DEFAULT_GLOBAL_TRAITS_PATH = 'app/Omnify/Traits';
 /**
  * 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
@@ -115,30 +188,29 @@ export function derivePhpConfig(overrides) {
         return p;
     };
     const nsFromPath = (p) => pathToNamespace(stripRoot(p));
-    const modelPath = withRoot(rootPath, overrides?.model?.path ?? DEFAULT_MODEL_PATH);
-    const modelNs = overrides?.model?.namespace ?? nsFromPath(modelPath);
-    const requestPath = withRoot(rootPath, overrides?.request?.path ?? DEFAULT_REQUEST_PATH);
-    const requestNs = overrides?.request?.namespace ?? nsFromPath(requestPath);
-    const resourcePath = withRoot(rootPath, overrides?.resource?.path ?? DEFAULT_RESOURCE_PATH);
-    const resourceNs = overrides?.resource?.namespace ?? nsFromPath(resourcePath);
-    const factoryPath = withRoot(rootPath, overrides?.factory?.path ?? DEFAULT_FACTORY_PATH);
-    const factoryNs = overrides?.factory?.namespace ?? nsFromPath(factoryPath);
-    const providerPath = withRoot(rootPath, overrides?.provider?.path ?? DEFAULT_PROVIDER_PATH);
-    const providerNs = overrides?.provider?.namespace ?? nsFromPath(providerPath);
-    const policyPath = withRoot(rootPath, overrides?.policy?.path ?? DEFAULT_POLICY_PATH);
-    const policyNs = overrides?.policy?.namespace ?? nsFromPath(policyPath);
-    const controllerPath = withRoot(rootPath, overrides?.controller?.path ?? DEFAULT_CONTROLLER_PATH);
-    const controllerNs = overrides?.controller?.namespace ?? nsFromPath(controllerPath);
-    const servicePath = withRoot(rootPath, overrides?.service?.path ?? DEFAULT_SERVICE_PATH);
-    const serviceNs = overrides?.service?.namespace ?? nsFromPath(servicePath);
+    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);
+    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);
+    const { path: globalTraitsPath, namespace: globalTraitsNs } = resolvePathAndNamespace(rootPath, overrides?.traits, DEFAULT_GLOBAL_TRAITS_PATH, nsFromPath);
     const routePath = withRoot(rootPath, overrides?.route?.path ?? DEFAULT_ROUTE_PATH);
     const configFilePath = withRoot(rootPath, overrides?.config?.path ?? DEFAULT_CONFIG_FILE_PATH);
     const nestedsetNs = overrides?.nestedset?.namespace ?? 'Aimeos\\Nestedset';
     const structure = overrides?.structure ?? 'legacy';
-    const modulesPath = withRoot(rootPath, DEFAULT_MODULES_PATH);
     return {
         rootPath,
         structure,
+        modules: { namespace: modulesNs, path: modulesPath },
+        shared: { namespace: sharedNs, path: sharedPath },
+        globalEnums: { namespace: globalEnumsNs, path: globalEnumsPath },
+        globalTraits: { namespace: globalTraitsNs, path: globalTraitsPath },
         modulesPath,
         models: {
             namespace: modelNs,