@omnifyjp/omnify 3.2.12 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "3.2.12",
+  "version": "3.4.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.2.12",
-    "@omnifyjp/omnify-darwin-x64": "3.2.12",
-    "@omnifyjp/omnify-linux-x64": "3.2.12",
-    "@omnifyjp/omnify-linux-arm64": "3.2.12",
-    "@omnifyjp/omnify-win32-x64": "3.2.12"
+    "@omnifyjp/omnify-darwin-arm64": "3.4.0",
+    "@omnifyjp/omnify-darwin-x64": "3.4.0",
+    "@omnifyjp/omnify-linux-x64": "3.4.0",
+    "@omnifyjp/omnify-linux-arm64": "3.4.0",
+    "@omnifyjp/omnify-win32-x64": "3.4.0"
   }
 }

package/ts-dist/cli.js

@@ -47,6 +47,7 @@ function resolveFromConfig(configPath) {
     const laravelConfig = config.codegen?.laravel;
     const laravelEnabled = laravelConfig?.enable === true;
     const laravelOverrides = laravelEnabled ? {
+        rootPath: laravelConfig?.rootPath,
         structure: laravelConfig?.structure,
         model: laravelConfig?.model,
         request: laravelConfig?.request,
@@ -57,6 +58,7 @@ function resolveFromConfig(configPath) {
         controller: laravelConfig?.controller,
         service: laravelConfig?.service,
         route: laravelConfig?.route,
+        config: laravelConfig?.config,
         nestedset: laravelConfig?.nestedset,
     } : undefined;
     return {

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

@@ -13,7 +13,7 @@ export function generateFileCleanup(reader, config) {
         return [];
     const modelNamespace = config.models.namespace;
     const purgeHours = parseDurationHours(fileConfig.purgeAfter ?? '72h');
-    return [generateCommand(modelNamespace, purgeHours)];
+    return [generateCommand(modelNamespace, purgeHours, config)];
 }
 /** Parse a duration string like "72h" or "3d" to hours. */
 function parseDurationHours(duration) {
@@ -24,7 +24,7 @@ function parseDurationHours(duration) {
     const unit = match[2];
     return unit === 'd' ? value * 24 : value;
 }
-function generateCommand(modelNamespace, purgeHours) {
+function generateCommand(modelNamespace, purgeHours, config) {
     const content = `<?php
 
 namespace App\\Console\\Commands;
@@ -153,5 +153,8 @@ class CleanupFiles extends Command
     }
 }
 `;
-    return baseFile('app/Console/Commands/CleanupFiles.php', content);
+    const path = config.rootPath
+        ? `${config.rootPath}/app/Console/Commands/CleanupFiles.php`
+        : 'app/Console/Commands/CleanupFiles.php';
+    return baseFile(path, content);
 }

package/ts-dist/php/schema-config-generator.js

@@ -22,7 +22,7 @@ export function generateSchemaConfig(reader, config) {
 return [
 ${entries.join('\n')}];
 `;
-    return [baseFile('config/omnify-schemas.php', content)];
+    return [baseFile(config.configFile.path, content)];
 }
 function generateSchemaEntry(name, schema, reader, config) {
     const modelName = toPascalCase(name);

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

@@ -49,6 +49,13 @@ export interface NestedSetOverride {
 }
 /** Overrides from codegen.laravel YAML config (all optional). */
 export interface LaravelCodegenOverrides {
+    /**
+     * Filesystem prefix applied to ALL generated paths (defaults + explicit overrides
+     * that are not already absolute). Use this for monorepo setups where the Laravel
+     * project lives in a subdirectory, e.g. `rootPath: backend` makes everything
+     * write under `backend/app/...`, `backend/config/...`, etc.
+     */
+    rootPath?: string;
     structure?: 'legacy' | 'modular';
     model?: LaravelPathOverride;
     request?: LaravelPathOverride;
@@ -59,10 +66,13 @@ export interface LaravelCodegenOverrides {
     controller?: LaravelPathOverride;
     service?: LaravelPathOverride;
     route?: LaravelPathOverride;
+    config?: LaravelPathOverride;
     nestedset?: NestedSetOverride;
 }
 /** PHP codegen configuration (resolved with defaults). */
 export interface PhpConfig {
+    /** Filesystem prefix applied to all generated paths. Empty when not set. */
+    rootPath: string;
     structure: 'legacy' | 'modular';
     modulesPath: string;
     models: {
@@ -112,6 +122,10 @@ export interface PhpConfig {
     routes: {
         path: string;
     };
+    /** Path to the omnify-schemas.php config file (full path including filename). */
+    configFile: {
+        path: string;
+    };
     nestedset: {
         namespace: string;
     };

package/ts-dist/php/types.js

@@ -27,7 +27,7 @@ export function resolveModularBasePath(config, schemaName, category, fileName, l
  */
 export function resolveModularBaseNamespace(config, schemaName, category, legacyNamespace) {
     if (config.structure === 'modular') {
-        return pathToNamespace(`${config.modulesPath}/${schemaName}/${category}`);
+        return pathToNamespace(`${stripRootPath(config, config.modulesPath)}/${schemaName}/${category}`);
     }
     return legacyNamespace;
 }
@@ -49,10 +49,20 @@ export function resolveSharedBasePath(config, category, fileName, legacyPath) {
  */
 export function resolveSharedBaseNamespace(config, category, legacyNamespace) {
     if (config.structure === 'modular') {
-        return pathToNamespace(`${config.modulesPath}/Shared/${category}`);
+        return pathToNamespace(`${stripRootPath(config, config.modulesPath)}/Shared/${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;
+}
 /** Convert a file path to a PHP namespace (e.g., app/Models/Omnify → App\Models\Omnify). */
 function pathToNamespace(p) {
     return p
@@ -60,42 +70,109 @@ 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';
+/**
+ * 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
+ * if needed.
+ */
+function withRoot(rootPath, p) {
+    if (!rootPath)
+        return p;
+    if (p.startsWith('/'))
+        return p;
+    if (p === rootPath || p.startsWith(`${rootPath}/`))
+        return p;
+    return `${rootPath}/${p}`;
+}
 /**
  * Derive full PHP config from optional overrides.
  * All paths and namespaces fall back to sensible defaults.
  */
 export function derivePhpConfig(overrides) {
-    const modelPath = overrides?.model?.path ?? DEFAULT_MODEL_PATH;
-    const modelNs = overrides?.model?.namespace ?? pathToNamespace(modelPath);
-    const requestPath = overrides?.request?.path ?? DEFAULT_REQUEST_PATH;
-    const requestNs = overrides?.request?.namespace ?? pathToNamespace(requestPath);
-    const resourcePath = overrides?.resource?.path ?? DEFAULT_RESOURCE_PATH;
-    const resourceNs = overrides?.resource?.namespace ?? pathToNamespace(resourcePath);
-    const factoryPath = overrides?.factory?.path ?? DEFAULT_FACTORY_PATH;
-    const factoryNs = overrides?.factory?.namespace ?? pathToNamespace(factoryPath);
-    const providerPath = overrides?.provider?.path ?? DEFAULT_PROVIDER_PATH;
-    const providerNs = overrides?.provider?.namespace ?? pathToNamespace(providerPath);
-    const policyPath = overrides?.policy?.path ?? DEFAULT_POLICY_PATH;
-    const policyNs = overrides?.policy?.namespace ?? pathToNamespace(policyPath);
-    const controllerPath = overrides?.controller?.path ?? DEFAULT_CONTROLLER_PATH;
-    const controllerNs = overrides?.controller?.namespace ?? pathToNamespace(controllerPath);
-    const servicePath = overrides?.service?.path ?? DEFAULT_SERVICE_PATH;
-    const serviceNs = overrides?.service?.namespace ?? pathToNamespace(servicePath);
-    const routePath = overrides?.route?.path ?? DEFAULT_ROUTE_PATH;
+    // Strip trailing slash for stable join behavior.
+    const rootPath = (overrides?.rootPath ?? '').replace(/\/+$/, '');
+    // Namespace generation should NOT include the rootPath prefix — it's a
+    // filesystem location, not a PHP namespace component.
+    const stripRoot = (p) => {
+        if (!rootPath)
+            return p;
+        if (p === rootPath)
+            return '';
+        if (p.startsWith(`${rootPath}/`))
+            return p.slice(rootPath.length + 1);
+        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);
+    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 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 = 'app/Modules';
+    const modulesPath = withRoot(rootPath, DEFAULT_MODULES_PATH);
     return {
+        rootPath,
         structure,
         modulesPath,
         models: {
@@ -145,6 +222,9 @@ export function derivePhpConfig(overrides) {
         routes: {
             path: routePath,
         },
+        configFile: {
+            path: configFilePath,
+        },
         nestedset: {
             namespace: nestedsetNs,
         },

package/types/config.d.ts

@@ -53,6 +53,14 @@ export interface CodegenNestedSetConfig {
 export interface CodegenLaravelConfig {
   /** Enable Laravel codegen. Defaults to false. */
   enable: boolean;
+  /**
+   * Filesystem prefix applied to all generated paths. Use this for monorepo
+   * setups where the Laravel project lives in a subdirectory, e.g. `backend`
+   * makes everything write under `backend/app/...`, `backend/config/...`, etc.
+   */
+  rootPath?: string;
+  /** Directory layout: "legacy" (default) or "modular". */
+  structure?: "legacy" | "modular";
   /** Model output configuration. */
   model?: CodegenLaravelPathConfig;
   /** Request output configuration. */
@@ -65,6 +73,14 @@ export interface CodegenLaravelConfig {
   provider?: CodegenLaravelPathConfig;
   /** Policy output configuration (default: app/Policies/Omnify). */
   policy?: CodegenLaravelPathConfig;
+  /** Controller output configuration (default: app/Http/Controllers). */
+  controller?: CodegenLaravelPathConfig;
+  /** Service output configuration (default: app/Services). */
+  service?: CodegenLaravelPathConfig;
+  /** Route file output configuration (default: routes/api/omnify). */
+  route?: CodegenLaravelPathConfig;
+  /** Path for the omnify-schemas.php config file (default: config/omnify-schemas.php). */
+  config?: CodegenLaravelPathConfig;
   /** Nested set package configuration. Only applies to schemas with nestedSet: true. */
   nestedset?: CodegenNestedSetConfig;
 }