@omnifyjp/ts 5.8.40 → 5.9.1

package/dist/generator.js

@@ -333,15 +333,43 @@ function generateI18nFile(options) {
 /** Generate index.ts re-exports. */
 function generateIndexFile(schemas, schemaEnums, pluginEnums, typeAliases, hasFiles = false) {
     const parts = [generateBaseHeader()];
-    // Common types
+    // Common types.
+    // A generator-owned common type can collide with a user model schema of the
+    // same name (e.g. a `Locale` entity vs the `Locale` locale-code union). The
+    // model is the user's explicit schema and stays canonical (keeps the bare
+    // name in the model section below); the common type is re-exported under an
+    // alias here so the barrel never emits a duplicate identifier (TS2300).
     parts.push(`// Common Types\n`);
+    const modelNames = new Set(Object.values(schemas)
+        .filter((s) => s.kind !== 'enum' && s.options?.hidden !== true)
+        .map((s) => s.name));
+    // Preferred, human-readable aliases for the known common types. Any other
+    // collision falls back to a `Common<Name>` alias.
+    const COMMON_TYPE_ALIASES = {
+        Locale: 'LocaleCode',
+        LocaleMap: 'LocaleStringMap',
+        DateTimeString: 'CommonDateTimeString',
+        DateString: 'CommonDateString',
+        OmnifyFile: 'OmnifyFileType',
+    };
+    const commonTypeNames = hasFiles
+        ? ['LocaleMap', 'Locale', 'DateTimeString', 'DateString', 'OmnifyFile']
+        : ['LocaleMap', 'Locale', 'DateTimeString', 'DateString'];
+    const commonTypeExports = commonTypeNames.map((name) => {
+        if (!modelNames.has(name)) {
+            return name;
+        }
+        const alias = COMMON_TYPE_ALIASES[name] ?? `Common${name}`;
+        // eslint-disable-next-line no-console
+        console.warn(`[omnify-ts] Common type "${name}" collides with model schema "${name}"; ` +
+            `re-exporting the common type from index.ts as "${alias}". ` +
+            `The "${name}" model keeps the canonical name.`);
+        return `${name} as ${alias}`;
+    });
+    parts.push(`export type { ${commonTypeExports.join(', ')} } from './common';\n`);
     if (hasFiles) {
-        parts.push(`export type { LocaleMap, Locale, DateTimeString, DateString, OmnifyFile } from './common';\n`);
         parts.push(`export { OmnifyFileSchema } from './common';\n`);
     }
-    else {
-        parts.push(`export type { LocaleMap, Locale, DateTimeString, DateString } from './common';\n`);
-    }
     // I18n
     parts.push(`// i18n (Internationalization)\n`);
     parts.push(`export {\n`);

package/dist/php/model-generator.js

@@ -77,6 +77,19 @@ function generateBaseModel(name, schema, reader, config) {
     const expandedProperties = reader.getExpandedProperties(name);
     const propertyOrder = reader.getPropertyOrder(name);
     const tableName = reader.getTableName(name);
+    // Multi-database routing: a schema may declare a top-level `connection:`
+    // (matching an omnify.yaml connections key + a Laravel connection). Emit the
+    // matching `$connection` so the model resolves to the right database. The
+    // implicit `default` connection is left unset so Laravel uses its default.
+    const connectionName = schema['connection'];
+    const connectionSection = connectionName && connectionName !== 'default'
+        ? `
+    /**
+     * The database connection for the model.
+     */
+    protected $connection = '${connectionName}';
+`
+        : '';
     const isAuthenticatable = options['authenticatable'] ?? false;
     const hasSoftDelete = options.softDelete ?? false;
     const hasTimestamps = options.timestamps ?? false;
@@ -172,7 +185,7 @@ ${imports}
 ${docProperties} */
 class ${modelName}BaseModel extends ${baseClass}${implementsClause}
 {
-${traits}    /**
+${traits}${connectionSection}    /**
      * The table associated with the model.
      */
     protected $table = '${tableName}';
@@ -373,12 +386,14 @@ function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable
         }
     }
     if (hasAuditLog) {
-        // HasOmnifyAuditLog is a global Omnify trait emitted by
-        // audit-trait-generator.ts. Same global-traits placement as HasFiles
-        // so consumers can update the trait in place without per-schema
-        // duplication.
+        // HasOmnifyAuditLog is a GLOBAL Omnify trait emitted by
+        // audit-trait-generator.ts at `config.models.baseNamespace\Traits`
+        // (e.g. App\Models\Omnify\Base\Traits). The import here must resolve to
+        // that SAME global namespace — using the per-model (group) `baseNamespace`
+        // (e.g. ...\Base\Logistics) yields `Base\Logistics\Traits\HasOmnifyAuditLog`
+        // which does not exist → "Trait not found" fatal on every model load.
         const auditTraitsNs = config
-            ? resolveGlobalTraitNamespace(config, baseNamespace + '\\Traits')
+            ? resolveGlobalTraitNamespace(config, config.models.baseNamespace + '\\Traits')
             : (traitsNamespace || baseNamespace + '\\Traits');
         lines.push(`use ${auditTraitsNs}\\HasOmnifyAuditLog;`);
     }

package/dist/php/request-generator.js

@@ -195,7 +195,7 @@ namespace ${baseNamespace};
 use Illuminate\\Foundation\\Http\\FormRequest;${ruleImport}
 use ${localesClass};
 
-abstract class ${modelName}${action}RequestBase extends FormRequest
+class ${modelName}${action}RequestBase extends FormRequest
 {
     /**
      * Determine if the user is authorized to make this request.
@@ -277,7 +277,10 @@ ${attributeKeysList}
         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}`);
+    // Issue #114: the request base is the class controllers inject directly
+    // (#101) — so it must be CONCRETE, not abstract (an abstract FormRequest is
+    // not container-resolvable → BindingResolutionException / HTTP 500).
+    const finalContent = content.replace(new RegExp(`class ${modelName}${action}RequestBase\\b`, 'g'), `class ${baseDescriptor.className}`);
     return baseFile(`${baseDescriptor.path}/${baseDescriptor.className}.php`, finalContent);
 }
 function generateUserRequest(name, schema, config, action) {

package/dist/php/resource-generator.d.ts

@@ -5,9 +5,12 @@ import { SchemaReader } from './schema-reader.js';
 import type { GeneratedFile, PhpConfig } from './types.js';
 /** Generate Resource classes for all project-owned visible object schemas.
  *
- * Issue #101 v5.8.23: only the base is emitted. Empty editable stubs
- * (every project's 30+ thin `class XResource extends Base {}`) are
- * pure scaffolding noise — devs hand-create wrappers only when custom
- * serialization logic IS needed.
+ * Issue #101 v5.8.23 emitted ONLY the base — but child resources embed a
+ * parent relation via `new \App\Http\Resources\<Parent>Resource(...)` (the
+ * editable sibling). With the sibling gone, any loaded relation fatals with a
+ * "class not found" Error (issue #114). So the editable sibling is re-emitted
+ * as a create-if-missing user file (`overwrite: false`): written once, never
+ * regenerated (so it is not the scaffolding noise #101 removed), and the
+ * cross-resource reference always resolves.
  */
 export declare function generateResources(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/dist/php/resource-generator.js

@@ -6,10 +6,13 @@ import { isHiddenByDefault, toResourceExpression } from './type-mapper.js';
 import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup } from './types.js';
 /** Generate Resource classes for all project-owned visible object schemas.
  *
- * Issue #101 v5.8.23: only the base is emitted. Empty editable stubs
- * (every project's 30+ thin `class XResource extends Base {}`) are
- * pure scaffolding noise — devs hand-create wrappers only when custom
- * serialization logic IS needed.
+ * Issue #101 v5.8.23 emitted ONLY the base — but child resources embed a
+ * parent relation via `new \App\Http\Resources\<Parent>Resource(...)` (the
+ * editable sibling). With the sibling gone, any loaded relation fatals with a
+ * "class not found" Error (issue #114). So the editable sibling is re-emitted
+ * as a create-if-missing user file (`overwrite: false`): written once, never
+ * regenerated (so it is not the scaffolding noise #101 removed), and the
+ * cross-resource reference always resolves.
  */
 export function generateResources(reader, config) {
     const files = [];
@@ -17,6 +20,7 @@ export function generateResources(reader, config) {
         if (schema.kind === 'extend')
             continue;
         files.push(generateBaseResource(name, schema, reader, config));
+        files.push(generateUserResource(name, schema, config));
     }
     return files;
 }

package/dist/php/service-provider-generator.js

@@ -89,8 +89,15 @@ class OmnifyServiceProvider extends ServiceProvider
      */
     public function boot(): void
     {
-        // Load Omnify migrations from custom directory
-        $this->loadMigrationsFrom(database_path('migrations/omnify'));
+        // Load Omnify migrations: the default-connection directory plus every
+        // per-connection subdirectory (multi-database setups route each domain's
+        // migrations into its own subfolder; those migrations target their
+        // connection via Schema::connection(), so a single migrate run suffices).
+        $omnifyMigrations = database_path('migrations/omnify');
+        $this->loadMigrationsFrom($omnifyMigrations);
+        foreach (glob($omnifyMigrations.'/*', GLOB_ONLYDIR) as $connectionDir) {
+            $this->loadMigrationsFrom($connectionDir);
+        }
 ${packageMigrationsBlock}
         // Register morph map for polymorphic relationships
         Relation::enforceMorphMap([

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

@@ -17,7 +17,9 @@ export function generateTranslationModels(reader, config) {
         const translatableFields = reader.getTranslatableFieldDetails(name);
         if (translatableFields.length === 0)
             continue;
-        files.push(generateTranslationBaseModel(name, translatableFields, enforceLanguageFk, config));
+        // A translation table co-locates with its parent — same connection/database.
+        const connectionName = reader.getSchema(name)?.['connection'];
+        files.push(generateTranslationBaseModel(name, translatableFields, enforceLanguageFk, config, connectionName));
         files.push(generateTranslationUserModel(name, config));
     }
     return files;
@@ -53,9 +55,19 @@ function castFor(type) {
             return undefined;
     }
 }
-function generateTranslationBaseModel(name, translatableFields, enforceLanguageFk, config) {
+function generateTranslationBaseModel(name, translatableFields, enforceLanguageFk, config, connectionName) {
     const modelName = toPascalCase(name);
     const modelSnake = toSnakeCase(name);
+    // Multi-database routing: follow the parent schema's connection so the
+    // `*_translations` table resolves to the same database as its parent.
+    const connectionSection = connectionName && connectionName !== 'default'
+        ? `
+    /**
+     * The database connection for the model.
+     */
+    protected $connection = '${connectionName}';
+`
+        : '';
     // Issue #98 v5.8.2: consolidate every Translation model under one
     // dedicated `Translation/` subfolder + sub-namespace. Reporter's
     // rationale: 39 translation models flat at the top of `Models/`
@@ -123,7 +135,7 @@ use Illuminate\\Database\\Eloquent\\Model;
  */
 class ${baseClassName} extends Model
 {
-    /**
+${connectionSection}    /**
      * The table associated with the model.
      */
     protected $table = '${tableName}';

package/package.json

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