@omnifyjp/ts 6.3.8 → 6.3.10

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

@@ -4,5 +4,6 @@
 import { SchemaReader } from './schema-reader.js';
 import type { GeneratedFile, PhpConfig } 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). */
+ *  plus, for each package schema the project extends, a user model that
+ *  extends the package model and carries the extend's columns. */
 export declare function generateModels(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/dist/php/model-generator.js

@@ -8,24 +8,34 @@ import { buildRelation } from './relation-builder.js';
 import { baseFile, userFile, shadowingPropertyConflicts, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup, } 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). */
+ *  plus, for each package schema the project extends, a user model that
+ *  extends the package model and carries the extend's columns. */
 export function generateModels(reader, config) {
     const files = [];
     // Project-owned schemas: base model + user model
     for (const [name, schema] of Object.entries(reader.getProjectObjectSchemas())) {
         files.push(...generateForSchema(name, schema, reader, config));
     }
-    // Package schemas: user model only (extends package model), plus a trait
-    // carrying anything a project-level `kind: extend` added to them (#164).
+    // Package schemas the project extends with `kind: extend`: a trait carrying
+    // the added columns (#164) plus a user model in the project namespace that
+    // `use`s it — the trait needs a class to live in, and the package's own
+    // model cannot be that class once it is installed under `vendor/`.
+    //
+    // A package schema the project does NOT extend gets nothing: the package
+    // model is the model, and relations already point at it. Every such
+    // schema used to get an empty `extends Package<Name>` stub anyway, and a
+    // workspace of three packages saw sixteen of them on every fresh checkout
+    // after deleting them (#182). A project that wants a local subclass for one
+    // of these writes the five lines itself, or extends the schema.
     for (const [name, schema] of Object.entries(reader.getPackageObjectSchemas())) {
         const pkgNs = reader.resolveModelNamespace(name, config.models.namespace);
-        if (pkgNs !== config.models.namespace) {
-            const extended = extendedPropertyNames(schema);
-            if (extended.length > 0) {
-                files.push(generateExtendAttributesTrait(name, schema, extended, reader, config));
-            }
-            files.push(generatePackageUserModel(name, pkgNs, config, extended.length > 0, schema.kind === 'pivot'));
-        }
+        if (pkgNs === config.models.namespace)
+            continue;
+        const extended = extendedPropertyNames(schema);
+        if (extended.length === 0)
+            continue;
+        files.push(generateExtendAttributesTrait(name, schema, extended, reader, config));
+        files.push(generatePackageUserModel(name, pkgNs, config, schema.kind === 'pivot'));
     }
     return files;
 }
@@ -1056,8 +1066,9 @@ function buildAccessors(expandedProperties) {
     }
     return methods.join('\n');
 }
-/** Generate a user model for a package schema that extends the package's model class. */
-function generatePackageUserModel(name, packageNamespace, config, hasExtendAttributes = false, isPivot = false) {
+/** Generate a user model for a package schema the project extends: it
+ *  extends the package's model class and `use`s the extend-attributes trait. */
+function generatePackageUserModel(name, packageNamespace, config, isPivot = false) {
     const modelName = toPascalCase(name);
     const modelNamespace = config.models.namespace;
     // #178: a `kind: pivot` schema's editable model is emitted under the
@@ -1074,12 +1085,8 @@ function generatePackageUserModel(name, packageNamespace, config, hasExtendAttri
     // predates its extend keeps the file it has, and `generateModels` warns with
     // the one line to add — overwriting somebody's model to add an import is the
     // worse of the two.
-    const traitImport = hasExtendAttributes
-        ? `use ${modelNamespace}\\Concerns\\${traitName};\n`
-        : '';
-    const traitUse = hasExtendAttributes
-        ? `    use ${traitName};\n\n`
-        : '';
+    const traitImport = `use ${modelNamespace}\\Concerns\\${traitName};\n`;
+    const traitUse = `    use ${traitName};\n\n`;
     const content = `<?php
 
 namespace ${modelNamespace};
@@ -1097,16 +1104,14 @@ class ${modelName} extends Package${modelName}
 ${traitUse}    // Add your custom methods here
 }
 `;
-    return userFile(`${config.models.path}/${modelName}.php`, content, hasExtendAttributes
-        ? {
-            needle: `use ${traitName};`,
-            hint: `this project's \`kind: extend\` adds columns to the package-owned `
-                + `${modelName} schema, but this model predates the trait that carries `
-                + `them, so those columns are still not fillable or cast. Add `
-                + `\`use ${config.models.namespace}\\Concerns\\${traitName};\` and `
-                + `\`use ${traitName};\` inside the class (#164).`,
-        }
-        : undefined);
+    return userFile(`${config.models.path}/${modelName}.php`, content, {
+        needle: `use ${traitName};`,
+        hint: `this project's \`kind: extend\` adds columns to the package-owned `
+            + `${modelName} schema, but this model predates the trait that carries `
+            + `them, so those columns are still not fillable or cast. Add `
+            + `\`use ${config.models.namespace}\\Concerns\\${traitName};\` and `
+            + `\`use ${traitName};\` inside the class (#164).`,
+    });
 }
 /**
  * Detect whether a schema uses nested set (tree structure).

package/dist/php/resource-generator.js

@@ -102,7 +102,7 @@ function generateBaseResource(name, schema, reader, config) {
         if (isHiddenByDefault(type) || hidden)
             continue;
         if (type === 'Association') {
-            addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace, reader, config, importer);
+            addAssociationFields(name, propName, prop, fields, resourceNamespace, modelNamespace, reader, config, importer);
             continue;
         }
         if (expandedProperties[propName]) {
@@ -258,7 +258,7 @@ class ${editable.className} extends ${baseAlias}
 `;
     return userFile(`${editable.path}/${editable.fileName}`, content);
 }
-function addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace, reader, config, importer) {
+function addAssociationFields(schemaName, propName, prop, fields, resourceNamespace, modelNamespace, reader, config, importer) {
     const relation = prop['relation'] ?? '';
     const target = prop['target'] ?? '';
     const methodName = toCamelCase(propName);
@@ -309,6 +309,23 @@ function addAssociationFields(propName, prop, fields, resourceNamespace, modelNa
     // If target is a package schema without a resource namespace, or a model no
     // Resource is written for, use simple whenLoaded
     if ((!targetResNs || !targetHasResource) && relation !== 'MorphTo') {
+        // Say it. An unwrapped relation serializes the raw model instead of the
+        // shaped resource, so the endpoint's response changes shape — and the PHP
+        // still compiles, so the only way anyone noticed was an unexpected line in
+        // a diff (#187). A target that is not a schema at all is the ordinary case
+        // (an external model reached through `targetNamespace`) and stays quiet.
+        if (reader.getSchema(target)) {
+            console.warn(`[omnify-ts] ${schemaName}.${propName}: no Resource class for target `
+                + `'${target}', so it serializes as the raw model instead of `
+                + `${toPascalCase(target)}Resource. `
+                + (targetResNs
+                    ? `Cause: this codegen target writes no Resource for ${target} `
+                        + `(kind: extend, options.hidden, or an includeSchemas / `
+                        + `excludeSchemas filter that leaves it out).`
+                    : `Cause: package '${reader.getSchema(target)?.package}' declares no `
+                        + `codegen.laravel.resource.namespace, so its Resource class cannot `
+                        + `be named from here.`));
+        }
         if (relation === 'ManyToOne') {
             const snakeName = toFkColumnName(propName);
             fields.push(`            '${snakeName}' => $this->${snakeName},`);

package/dist/php/schema-reader.d.ts

@@ -18,6 +18,12 @@ export declare class SchemaReader {
         name: string;
         schema: SchemaDefinition;
     } | undefined;
+    /**
+     * Object schemas this run generates for. `referenceOnly` entries are left
+     * out: they are in the export solely so relation targets resolve (#187),
+     * and every generation loop reaches the set through this method.
+     * `getSchema()` deliberately still returns them.
+     */
     getObjectSchemas(): Record<string, SchemaDefinition>;
     getVisibleObjectSchemas(): Record<string, SchemaDefinition>;
     getEnumSchemas(): Record<string, SchemaDefinition>;

package/dist/php/schema-reader.js

@@ -37,11 +37,17 @@ export class SchemaReader {
         }
         return undefined;
     }
+    /**
+     * Object schemas this run generates for. `referenceOnly` entries are left
+     * out: they are in the export solely so relation targets resolve (#187),
+     * and every generation loop reaches the set through this method.
+     * `getSchema()` deliberately still returns them.
+     */
     getObjectSchemas() {
         const result = {};
         for (const [name, schema] of Object.entries(this.getSchemas())) {
             const kind = schema.kind ?? 'object';
-            if (kind !== 'enum' && kind !== 'partial') {
+            if (kind !== 'enum' && kind !== 'partial' && !schema.referenceOnly) {
                 result[name] = schema;
             }
         }

package/dist/types.d.ts

@@ -248,6 +248,14 @@ export interface SchemaDefinition {
      * run never saw them (#164).
      */
     readonly extendedProperties?: readonly string[];
+    /**
+     * Set by the Go side for a PACKAGE schema that this codegen target's
+     * include/exclude filter keeps out of the output but that relations still
+     * have to resolve against (#187). Generation loops skip it; `getSchema()`
+     * still returns it so a cross-package reference names the package's class
+     * instead of silently degrading.
+     */
+    readonly referenceOnly?: boolean;
     readonly values?: readonly EnumValueDefinition[];
     readonly pivotFor?: readonly string[];
     readonly policies?: readonly PolicyDefinition[];

package/package.json

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