@omnifyjp/ts 5.8.8 → 5.8.10

package/dist/php/factory-generator.js

@@ -3,7 +3,7 @@
  */
 import { toPascalCase } from './naming-helper.js';
 import { toFaker, compoundFaker, associationFaker } from './faker-mapper.js';
-import { userFile, nestByGroup } from './types.js';
+import { userFile } from './types.js';
 /** Generate Factory classes for all project-owned visible object schemas. */
 export function generateFactories(reader, config) {
     const files = [];
@@ -15,16 +15,51 @@ export function generateFactories(reader, config) {
     }
     return files;
 }
+/**
+ * Issue #98 v5.8.9: resolve the EDITABLE Model namespace for a given
+ * schema. Factory `$model` + association FK references must land on the
+ * user-editable class (e.g. `App\\Models\\Banner`) — that's what
+ * services / controllers / tests / seeders type-hint against, and what
+ * the project owns. Pre-fix every factory pointed at the BASE
+ * (e.g. `App\\Omnify\\Models\\Cms\\Banner`); calling
+ * `Banner::factory()->create()` returned a base instance and every
+ * downstream signature failed with TypeError.
+ *
+ * Pivot schemas always nest under `Pivot/` regardless of any flag.
+ * Group nesting only applies when the layer's `userEditableGroupByFolder`
+ * is true (matches where the editable file actually lives).
+ */
+function resolveEditableModelNamespace(schemaName, config, reader) {
+    const targetSchema = reader.getSchema(schemaName);
+    // Modular structure: editable shares per-Schema modular path.
+    if (config.structure === 'modular') {
+        return config.models.namespace;
+    }
+    const editableNs = config.models.userEditableNamespace;
+    // Package schemas: use the package's model namespace verbatim
+    // (we don't generate editable stubs for package schemas).
+    const baseFromReader = reader.resolveModelNamespace(schemaName, config.models.namespace);
+    if (baseFromReader !== config.models.namespace) {
+        return baseFromReader;
+    }
+    if (!targetSchema)
+        return editableNs;
+    if (targetSchema.kind === 'pivot') {
+        return `${editableNs}\\Pivot`;
+    }
+    if (config.models.userEditableGroupByFolder && targetSchema.group) {
+        return `${editableNs}\\${toPascalCase(targetSchema.group)}`;
+    }
+    return editableNs;
+}
 function generateFactory(name, schema, reader, schemas, config) {
     const modelName = toPascalCase(name);
-    // Issue #98 v5.8.4: legacy structure groups Models by folder, so the
-    // factory's `use ${modelNamespace}\\${modelName}` import must include
-    // the schema's group too — otherwise the factory references a flat
-    // path that no longer holds the model file. Modular structure
-    // already isolates per-schema so it skips the nesting.
-    const modelNamespace = config.structure === 'modular'
-        ? config.models.namespace
-        : nestByGroup({ path: '', namespace: config.models.namespace }, schema.group).namespace;
+    // Issue #98 v5.8.9: factories type the `$model` reference + associated
+    // FK references against the USER-EDITABLE class (`App\Models\Banner`)
+    // not the base (`App\Omnify\Models\Cms\Banner`). Service / controller /
+    // test signatures all type-hint against the editable; pointing
+    // factories at the base produced TypeErrors at every callsite.
+    const modelNamespace = resolveEditableModelNamespace(name, config, reader);
     const factoryNamespace = config.factories.namespace;
     const properties = (schema.properties ?? {});
     const expandedProperties = reader.getExpandedProperties(name);
@@ -38,9 +73,10 @@ function generateFactory(name, schema, reader, schemas, config) {
         const type = prop['type'] ?? 'String';
         // Handle associations (foreign keys)
         if (type === 'Association') {
-            // Resolve namespace per-target (package schemas use their own model namespace)
+            // Resolve namespace per-target — also points at the EDITABLE
+            // (matches what `<Target>::factory()` resolves to via Eloquent).
             const target = prop['target'] ?? '';
-            const targetNs = target ? reader.resolveModelNamespace(target, modelNamespace) : modelNamespace;
+            const targetNs = target ? resolveEditableModelNamespace(target, config, reader) : modelNamespace;
             const result = associationFaker(propName, prop, targetNs, name);
             if (result) {
                 attributes.push(result.fake);

package/dist/php/model-generator.js

@@ -579,48 +579,46 @@ function buildCasts(properties, expandedProperties, propertyOrder, reader, confi
     return casts.map(c => `            ${c}`).join('\n') + '\n';
 }
 /**
- * Issue #98 v5.8.6: resolve the FQCN namespace of a related Model
- * for inline `belongsTo / hasMany / belongsToMany / morphTo` references.
- * The namespace must match the TARGET's CANONICAL CLASS LOCATION:
+ * Issue #98 v5.8.10: resolve the FQCN namespace of a related Model for
+ * inline `belongsTo / hasMany / belongsToMany / morphTo` references.
+ * Relations must resolve to the USER-EDITABLE class — that's what
+ * services / controllers / tests / seeders type-hint against, and what
+ * `<Target>::factory()` returns since v5.8.9. Pre-fix relations pointed
+ * at the BASE class FQN, so loaded relations were base instances and
+ * every downstream type-hinted call failed with `TypeError`. Same root
+ * cause + fix as the factory `$model` issue.
  *
- *   1. Package schemas — return the package's namespace verbatim
- *      (already handled by reader.resolveModelNamespace).
- *   2. Pivot schemas — always nest under `Pivot/` regardless of any
- *      group / flat flag (matches the dedicated `Pivot/` folder
- *      enforced for pivot models).
- *   3. flatBase: true — the BASE class is the user's canonical class
- *      (no `*BaseModel` suffix, lives at the grouped path). Nest by
- *      group so the FQCN matches the grouped base.
- *   4. flatBase: false + userEditableGroupByFolder: true — the editable
- *      mirrors the base group. Nest by group so the FQCN matches the
- *      grouped editable.
- *   5. flatBase: false + userEditableGroupByFolder: false (Laravel-
- *      canonical default) — the editable is FLAT. Don't nest; the
- *      FQCN matches the flat editable's location.
- *
- * Pre-v5.8.6 every relation emitted `\${modelNamespace}\${target}::class`
- * (flat) regardless of where the target's file actually lived. Grouped
- * projects (especially flatBase) hit `ErrorException: include(... no
- * such file)` on every cross-Model reference.
+ * Resolution rules (mirror `factory-generator.ts:resolveEditableModelNamespace`):
+ *   1. Package schemas — return the package's model namespace verbatim
+ *      (we don't generate editable stubs for package schemas).
+ *   2. Pivot schemas — nest under `<editableNs>\Pivot` regardless of
+ *      any group / flag (matches the dedicated `Pivot/` subfolder).
+ *   3. `userEditableGroupByFolder: true` + target has group → nest by
+ *      group so the FQCN matches where the editable file lives.
+ *   4. Default — flat editable namespace (Laravel-canonical
+ *      `App\Models\<Name>`).
  */
 function resolveRelatedModelNamespace(target, modelNamespace, config, reader) {
-    const baseNs = reader.resolveModelNamespace(target, modelNamespace);
-    // Package schemas — leave as-is.
-    if (baseNs !== modelNamespace)
-        return baseNs;
+    // Package schemas use their own model namespace (we don't generate
+    // editable stubs for them — relations dispatch to the package class).
+    const packageNs = reader.resolveModelNamespace(target, modelNamespace);
+    if (packageNs !== modelNamespace)
+        return packageNs;
+    // Modular structure: editable shares per-Schema modular path.
+    if (config.structure === 'modular') {
+        return config.models.namespace;
+    }
     const targetSchema = reader.getSchema(target);
     if (!targetSchema)
-        return baseNs;
+        return config.models.userEditableNamespace;
+    const editableNs = config.models.userEditableNamespace;
     if (targetSchema.kind === 'pivot') {
-        return `${baseNs}\\Pivot`;
+        return `${editableNs}\\Pivot`;
     }
-    // Nest by group when EITHER flatBase is on (base is canonical, grouped)
-    // OR the editable explicitly mirrors the base group.
-    const shouldNestByGroup = config.models.flatBase || config.models.userEditableGroupByFolder;
-    if (shouldNestByGroup && targetSchema.group) {
-        return `${baseNs}\\${toPascalCase(targetSchema.group)}`;
+    if (config.models.userEditableGroupByFolder && targetSchema.group) {
+        return `${editableNs}\\${toPascalCase(targetSchema.group)}`;
     }
-    return baseNs;
+    return editableNs;
 }
 function buildRelations(schemaName, properties, propertyOrder, modelNamespace, reader, config) {
     const methods = [];

package/package.json

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