@omnifyjp/ts 6.0.7 → 6.3.0

package/dist/cli.js

@@ -29,6 +29,7 @@ import { Command } from 'commander';
 import { parse as parseYaml } from 'yaml';
 import { generateTypeScript } from './generator.js';
 import { generatePhp, derivePhpConfig } from './php/index.js';
+import { stripPhpComments } from './php/types.js';
 import { pruneOrphanServiceFilesIfEnabled } from './php/orphan-cleanup.js';
 import { findSiblingWithSameBasename, findAppRootAncestor } from './php/sibling-skip.js';
 import { runPintFormat } from './php/pint-format.js';
@@ -100,6 +101,11 @@ function resolveFromConfig(configPath) {
         route: laravelConfig?.route,
         config: laravelConfig?.config,
         nestedset: laravelConfig?.nestedset,
+        modules: laravelConfig?.modules,
+        shared: laravelConfig?.shared,
+        enums: laravelConfig?.enums,
+        traits: laravelConfig?.traits,
+        openapi: laravelConfig?.openapi,
     } : undefined;
     return {
         inputSpec,
@@ -226,6 +232,7 @@ program
         let phpOverwritten = 0;
         let phpSkipped = 0;
         let phpSkippedSibling = 0;
+        let phpShadowed = 0;
         const skippedSiblingExamples = [];
         const writtenPaths = [];
         for (const file of phpFiles) {
@@ -233,6 +240,24 @@ program
             mkdirSync(dirname(filePath), { recursive: true });
             if (!file.overwrite && existsSync(filePath)) {
                 phpSkipped++;
+                const existing = file.expects || (file.conflicts && file.conflicts.length > 0)
+                    ? readFileSync(filePath, 'utf-8')
+                    : '';
+                // The file predates something the template now needs. Say so once,
+                // naming the file and the line, rather than rewriting user code.
+                if (file.expects && !existing.includes(file.expects.needle)) {
+                    console.warn(`[omnify-ts] ${relative(configDir, filePath)}: ${file.expects.hint}`);
+                }
+                // The mirror: the file contains an edit that silently disables what
+                // the base generates. #171 — a redeclared $fillable shadows the
+                // parent's, so every property added afterwards is stripped on mass
+                // assignment with no error anywhere.
+                for (const conflict of file.conflicts ?? []) {
+                    if (new RegExp(conflict.pattern).test(stripPhpComments(existing))) {
+                        phpShadowed++;
+                        console.warn(`[omnify-ts] ${relative(configDir, filePath)}: ${conflict.hint}`);
+                    }
+                }
                 continue;
             }
             // Issue #98 v5.8.18 / #99 v5.8.19: skip user-editable stub
@@ -280,6 +305,10 @@ program
             console.log(`  ${phpCreated} files created (user-editable)`);
         if (phpSkipped > 0)
             console.log(`  ${phpSkipped} files skipped (already exist)`);
+        if (phpShadowed > 0) {
+            console.warn(`  ${phpShadowed} editable file(s) shadow a generated property — ` +
+                `schema changes will NOT reach them until that is fixed (see warnings above).`);
+        }
         if (phpSkippedSibling > 0) {
             console.log(`  ${phpSkippedSibling} user-editable stub(s) skipped (project sibling with same name found in subfolder)`);
             for (const ex of skippedSiblingExamples) {

package/dist/php/model-generator.js

@@ -5,7 +5,7 @@ import { toPascalCase, toSnakeCase, toCamelCase, toFkColumnName, pluralize } fro
 import { resolveTimestamps } from './timestamps.js';
 import { toCast, toPhpDocType, isHiddenByDefault } from './type-mapper.js';
 import { buildRelation } from './relation-builder.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup, } from './types.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). */
@@ -15,15 +15,105 @@ export function generateModels(reader, config) {
     for (const [name, schema] of Object.entries(reader.getProjectObjectSchemas())) {
         files.push(...generateForSchema(name, schema, reader, config));
     }
-    // Package schemas: user model only (extends package model)
+    // Package schemas: user model only (extends package model), plus a trait
+    // carrying anything a project-level `kind: extend` added to them (#164).
     for (const [name, schema] of Object.entries(reader.getPackageObjectSchemas())) {
         const pkgNs = reader.resolveModelNamespace(name, config.models.namespace);
         if (pkgNs !== config.models.namespace) {
-            files.push(generatePackageUserModel(name, pkgNs, config));
+            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));
         }
     }
     return files;
 }
+/**
+ * The properties a project-level `kind: extend` added to a schema, in merge
+ * order, keeping only the ones the schema still declares.
+ */
+function extendedPropertyNames(schema) {
+    const declared = schema.properties ?? {};
+    return (schema.extendedProperties ?? []).filter(name => declared[name] !== undefined);
+}
+/**
+ * A trait carrying the columns a project-level `kind: extend` added to a
+ * PACKAGE-owned schema (#164).
+ *
+ * The package's own generate run writes that model from the package's schemas
+ * alone; it cannot see a consumer's extend, so `$fillable` and `casts()` there
+ * are missing the added columns. The migration has them — the column exists —
+ * so `$model->new_column = x` is silently dropped by mass-assignment guarding
+ * and a Json column reads back as a raw string. The extend is only half
+ * applied, and nothing says so.
+ *
+ * It is written here, in the CONSUMER's own namespace, rather than back into
+ * the package's model. Writing into the package directory would work in a
+ * monorepo and silently do nothing once that package is installed under
+ * `vendor/`, where the next `composer install` removes it.
+ *
+ * `initialize<TraitName>()` is Laravel's own hook: `Model::__construct` calls
+ * `initializeTraits()`, which invokes it on every used trait. `mergeFillable` /
+ * `mergeCasts` add to what the parent declares instead of replacing it, which a
+ * redeclared `protected $fillable` in the child would do.
+ */
+function generateExtendAttributesTrait(name, schema, extended, reader, config) {
+    const modelName = toPascalCase(name);
+    const traitName = extendAttributesTraitName(name);
+    const properties = (schema.properties ?? {});
+    const expandedProperties = reader.getExpandedProperties(name);
+    // The same two builders the BaseModel uses, over the extended properties
+    // only. Sharing them is the point: a column the BaseModel would have made
+    // fillable, or cast, is made fillable and cast the same way here.
+    const fillable = buildFillable(properties, expandedProperties, extended)
+        .split('\n')
+        .filter(line => line.trim() !== '')
+        .map(line => `            ${line.trim()}`)
+        .join('\n');
+    const casts = buildCasts(properties, expandedProperties, extended, reader, config)
+        .split('\n')
+        .filter(line => line.trim() !== '')
+        .map(line => `            ${line.trim()}`)
+        .join('\n');
+    const body = [];
+    if (fillable !== '') {
+        body.push(`        $this->mergeFillable([\n${fillable}\n        ]);`);
+    }
+    if (casts !== '') {
+        body.push(`        $this->mergeCasts([\n${casts}\n        ]);`);
+    }
+    const content = `<?php
+
+namespace ${config.models.namespace}\\Concerns;
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+
+/**
+ * Columns this project's \`kind: extend\` added to the ${modelName} schema.
+ *
+ * ${modelName} is owned by a package, so the package's own model cannot know
+ * about them. Used by ${config.models.namespace}\\${modelName}.
+ */
+trait ${traitName}
+{
+    /** Called by Laravel's Model::initializeTraits() from the constructor. */
+    public function initialize${traitName}(): void
+    {
+${body.join('\n\n')}
+    }
+}
+`;
+    return baseFile(`${config.models.path}/Concerns/${traitName}.php`, content);
+}
+function extendAttributesTraitName(name) {
+    return `${toPascalCase(name)}ExtendAttributes`;
+}
 function generateForSchema(name, schema, reader, config) {
     const properties = (schema.properties ?? {});
     const options = schema.options ?? {};
@@ -104,9 +194,22 @@ function generateBaseModel(name, schema, reader, config) {
     const nestedSetParentColumn = null;
     const translatableFields = reader.getTranslatableFields(name);
     const hasTranslatable = translatableFields.length > 0;
-    const primaryKey = options['primaryKey'] ?? 'id';
+    // A schema may name its primary key three mutually-exclusive ways: the
+    // `id:` shortcut (always column "id"), `options.primaryKey` (composite),
+    // or a property carrying `primary: true` (custom-named single-column PK
+    // — omnify-go#167). The schema validator rejects any schema declaring
+    // more than one of these, so checking them in this order is safe.
+    const primaryKeyOption = options['primaryKey'];
+    const customPrimaryEntry = primaryKeyOption
+        ? undefined
+        : propertyOrder
+            .map((p) => [p, properties[p]])
+            .find(([, prop]) => prop?.['primary'] === true);
+    const primaryKey = primaryKeyOption ?? (customPrimaryEntry ? toSnakeCase(customPrimaryEntry[0]) : 'id');
     const rawId = options.id;
-    const idType = typeof rawId === 'string' ? rawId : 'BigInt';
+    const idType = customPrimaryEntry
+        ? (customPrimaryEntry[1]['type'] ?? 'String')
+        : (typeof rawId === 'string' ? rawId : 'BigInt');
     const isCompositeKey = primaryKey.includes(',');
     const needsUuidTrait = !isCompositeKey && idType === 'Uuid';
     const needsUlidTrait = !isCompositeKey && idType === 'Ulid';
@@ -168,6 +271,17 @@ function generateBaseModel(name, schema, reader, config) {
      */
     protected $keyType = 'string';
 
+    /**
+     * Indicates if the IDs are auto-incrementing.
+     */
+    public $incrementing = false;`;
+    }
+    else if (customPrimaryEntry && customPrimaryEntry[1]['autoIncrement'] !== true) {
+        // Integer-typed custom primary key not declared `autoIncrement: true`
+        // (omnify-go#167). Eloquent's Model default is $incrementing = true,
+        // which makes it omit the column on insert and read the value back via
+        // lastInsertId() — wrong for a key the caller assigns itself.
+        keyTypeSection = `
     /**
      * Indicates if the IDs are auto-incrementing.
      */
@@ -360,7 +474,11 @@ ${traits.join('\n')}
     //
 }
 `;
-    return userFile(`${editable.path}/${editable.fileName}`, content);
+    // #171: this subclass is created once and then owned by the project. The
+    // most common edit to it — redeclaring $fillable — silently disables every
+    // property omnify adds to the base afterwards. We cannot prevent the edit,
+    // but we can stop it from being invisible.
+    return userFile(`${editable.path}/${editable.fileName}`, content, undefined, shadowingPropertyConflicts(baseAlias));
 }
 function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false, nestedSetNamespace = 'Aimeos\\Nestedset', hasFiles = false, modelNamespace = '', localesNamespace = '', traitsNamespace = '', sharedModelsNamespace = '', config, hasAuditLog = false) {
     const lines = [];
@@ -448,7 +566,11 @@ function buildDocProperties(properties, expandedProperties, propertyOrder, reade
         if (type === 'Association') {
             const relation = prop['relation'] ?? '';
             if (relation === 'ManyToOne') {
-                const snakeName = toFkColumnName(propName);
+                // omnify-go#166: honor the `column:` override (ForeignColumn) the
+                // migration generator already applies — falling back to the
+                // {property}_id convention here documents a column the table
+                // doesn't actually have.
+                const snakeName = prop['column'] || toFkColumnName(propName);
                 const nullable = prop['nullable'] ?? false;
                 const phpType = nullable ? 'int|null' : 'int';
                 lines.push(` * @property ${phpType} $${snakeName}`);
@@ -525,7 +647,8 @@ function buildFillable(properties, expandedProperties, propertyOrder) {
         if (type === 'Association') {
             const relation = prop['relation'] ?? '';
             if (relation === 'ManyToOne') {
-                fields.push(toFkColumnName(propName));
+                // omnify-go#166: honor the `column:` override (ForeignColumn).
+                fields.push(prop['column'] || toFkColumnName(propName));
             }
             else if (relation === 'MorphTo') {
                 const morphName = prop['morphName'] || toSnakeCase(propName);
@@ -633,7 +756,8 @@ function buildCasts(properties, expandedProperties, propertyOrder, reader, confi
                     ? targetSchema.options.id
                     : 'BigInt';
                 if (targetIdType !== 'Uuid' && targetIdType !== 'Ulid') {
-                    casts.push(`'${toFkColumnName(propName)}' => 'integer',`);
+                    // omnify-go#166: honor the `column:` override (ForeignColumn).
+                    casts.push(`'${prop['column'] || toFkColumnName(propName)}' => 'integer',`);
                 }
             }
             continue;
@@ -678,7 +802,9 @@ function buildCasts(properties, expandedProperties, propertyOrder, reader, confi
  *   4. Default — flat editable namespace (Laravel-canonical
  *      `App\Models\<Name>`).
  */
-function resolveRelatedModelNamespace(target, modelNamespace, config, reader) {
+function resolveRelatedModelNamespace(target, modelNamespace, config, reader, 
+/** The property's `targetNamespace`, for a target with no schema. */
+externalNamespace) {
     // 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);
@@ -689,8 +815,16 @@ function resolveRelatedModelNamespace(target, modelNamespace, config, reader) {
         return config.models.namespace;
     }
     const targetSchema = reader.getSchema(target);
-    if (!targetSchema)
-        return config.models.userEditableNamespace;
+    if (!targetSchema) {
+        // A target outside the schema set is an external model, and
+        // `targetNamespace` is the documented way to say where it lives
+        // ("Target model namespace for external packages"). Ignoring it and
+        // falling back to this project's editable namespace emits
+        // `\App\Models\User` for a model that is not there — the relation
+        // resolves to a class that does not exist. The fallback still applies
+        // when the field is absent, which is every schema that does not use it.
+        return externalNamespace || config.models.userEditableNamespace;
+    }
     const editableNs = config.models.userEditableNamespace;
     if (targetSchema.kind === 'pivot') {
         return `${editableNs}\\Pivot`;
@@ -717,7 +851,9 @@ function buildRelations(schemaName, properties, propertyOrder, modelNamespace, r
         // Issue #98 v5.8.6: also nest by target's group / Pivot/ so the
         // FQCN matches the target file's actual location.
         const target = prop['target'] ?? '';
-        const ns = target ? resolveRelatedModelNamespace(target, modelNamespace, config, reader) : modelNamespace;
+        const ns = target
+            ? resolveRelatedModelNamespace(target, modelNamespace, config, reader, prop['targetNamespace'])
+            : modelNamespace;
         const targetTableName = target ? reader.getTableName(target) : '';
         // For ManyToMany, look up the explicit `kind: pivot` schema by pivotFor
         // pair (user-authored filenames may predate the sorted-name convention)
@@ -845,7 +981,11 @@ function buildInverseRelations(parentName, modelNamespace, reader, declaredMetho
             // generate a child-side accessor, not a parent-side one.
             // Here we're emitting the *parent* accessor, so the child's ManyToOne
             // (or owning OneToOne) is what we react to.
-            const fkColumn = toFkColumnName(childPropName);
+            // omnify-go#166: honor the child property's `column:` override
+            // (ForeignColumn) — the physical FK column lives on the child's
+            // table, so it must match whatever the child's own migration/model
+            // used, not the {property}_id convention.
+            const fkColumn = childProp['column'] || toFkColumnName(childPropName);
             // Issue #98 v5.8.6: nest the inverse-side FQCN by the CHILD's
             // group / Pivot/ so the relation resolves to the child's actual
             // file location (which lives in `<childGroup>/<Child>.php` or
@@ -890,16 +1030,28 @@ 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) {
+function generatePackageUserModel(name, packageNamespace, config, hasExtendAttributes = false) {
     const modelName = toPascalCase(name);
     const modelNamespace = config.models.namespace;
     const packageModelClass = `${packageNamespace}\\${modelName}`;
+    const traitName = extendAttributesTraitName(name);
+    // This file is created once and never rewritten, so the `use` line can only
+    // be put here for a model that does not exist yet. A project whose model
+    // 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 content = `<?php
 
 namespace ${modelNamespace};
 
 use ${packageModelClass} as Package${modelName};
-
+${traitImport}
 /**
  * ${modelName} Model (extends package model)
  *
@@ -908,10 +1060,19 @@ use ${packageModelClass} as Package${modelName};
  */
 class ${modelName} extends Package${modelName}
 {
-    // Add your custom methods here
+${traitUse}    // Add your custom methods here
 }
 `;
-    return userFile(`${config.models.path}/${modelName}.php`, content);
+    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);
 }
 /**
  * Detect whether a schema uses nested set (tree structure).

package/dist/php/relation-builder.js

@@ -10,7 +10,7 @@ export function buildRelation(propName, property, modelNamespace, context) {
     let method = null;
     switch (relation) {
         case 'ManyToOne':
-            method = belongsTo(propName, target, modelNamespace);
+            method = belongsTo(propName, property, target, modelNamespace);
             break;
         case 'OneToOne':
             method = oneToOne(propName, property, target, modelNamespace);
@@ -60,8 +60,12 @@ export function getReturnType(relation) {
         default: return 'BelongsTo';
     }
 }
-function belongsTo(propName, target, ns) {
-    const foreignKey = toFkColumnName(propName);
+function belongsTo(propName, property, target, ns) {
+    // omnify-go#166: honor the `column:` override (ForeignColumn) — the
+    // migration generator already names the physical column from it, so
+    // falling back to the {property}_id convention here points the relation
+    // at a column the table doesn't have.
+    const foreignKey = property['column'] || toFkColumnName(propName);
     const methodName = toCamelCase(propName);
     const fqcn = `\\${ns}\\${target}`;
     return `    /**
@@ -86,7 +90,7 @@ function oneToOne(propName, property, target, ns) {
         return $this->hasOne(${fqcn}::class, '${foreignKey}');
     }`;
     }
-    return belongsTo(propName, target, ns);
+    return belongsTo(propName, property, target, ns);
 }
 function hasMany(propName, property, target, ns) {
     const inverse = property['mappedBy'] ?? property['inversedBy'] ?? null;

package/dist/php/resource-generator.js

@@ -18,13 +18,41 @@ import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace
 export function generateResources(reader, config) {
     const files = [];
     for (const [name, schema] of Object.entries(reader.getProjectVisibleObjectSchemas())) {
-        if (schema.kind === 'extend')
+        if (!generatesOwnResource(schema))
             continue;
         files.push(generateBaseResource(name, schema, reader, config));
         files.push(generateUserResource(name, schema, config));
     }
     return files;
 }
+/**
+ * Whether THIS generator writes a Resource for a project-owned schema.
+ *
+ * The loop above and the cross-resource reference below have to agree about
+ * this, and when they were two separate conditions they did not: the loop
+ * skipped `kind: extend`, and the reference did not ask at all — so a relation
+ * pointing at one named a class the loop had just declined to write.
+ */
+function generatesOwnResource(schema) {
+    return schema.kind !== 'extend' && schema.options?.hidden !== true;
+}
+/**
+ * Whether a Resource class exists for an association target — ours or a
+ * package's. `false` means there is no class to name, and the caller must fall
+ * back to a bare `whenLoaded()`.
+ */
+function hasResourceClass(target, reader) {
+    const schema = reader.getSchema(target);
+    // Not a schema at all: an external model reached through `targetNamespace`,
+    // e.g. the app's own User. Omnify generates nothing for it.
+    if (!schema)
+        return false;
+    // A package ships its own resources; whether they are reachable is the
+    // namespace question, which the caller answers separately.
+    if (schema.package != null)
+        return true;
+    return generatesOwnResource(schema);
+}
 function generateBaseResource(name, schema, reader, config) {
     const modelName = toPascalCase(name);
     // Issue #98 v5.8.2: nest namespace by group in legacy structure so the
@@ -242,8 +270,23 @@ function addAssociationFields(propName, prop, fields, resourceNamespace, modelNa
             targetResNs = editableNs;
         }
     }
-    // If target is a package schema without a resource namespace, use simple whenLoaded
-    if (!targetResNs && relation !== 'MorphTo') {
+    // The namespace resolving is not the same question as the class existing.
+    // `resolveResourceNamespace()` only returns null for a PACKAGE schema whose
+    // package declares no resource namespace — a target that is not a schema at
+    // all (an external model reached through `targetNamespace`, e.g. the app's
+    // own User), or one this generator declines to write a Resource for, falls
+    // through and is treated as project-owned. The reference then names
+    // `\<projectResourceNs>\<Target>Resource`, a class nothing declares, and
+    // `whenLoaded(..., fn () => new UserResource(...))` fatals the moment that
+    // relation is loaded and the resource is rendered.
+    //
+    // This is the same rule `interface-generator.ts` already applies on the TS
+    // side (`resolveTargetName` → `unknown` for a target outside the schema set),
+    // arriving late on the PHP side.
+    const targetHasResource = target ? hasResourceClass(target, reader) : false;
+    // 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') {
         if (relation === 'ManyToOne') {
             const snakeName = toFkColumnName(propName);
             fields.push(`            '${snakeName}' => $this->${snakeName},`);

package/dist/php/types.d.ts

@@ -7,11 +7,66 @@ export interface GeneratedFile {
     readonly content: string;
     readonly overwrite: boolean;
     readonly type: 'base' | 'user';
+    /**
+     * For a user file only: something the file has to contain that a version
+     * written by an EARLIER omnify would not have.
+     *
+     * A user file is created once and never rewritten, so a template that grows a
+     * new line reaches new projects and silently misses every existing one. The
+     * writer checks this against the file it skipped and prints `hint` when it is
+     * absent — telling the one project that needs the edit, rather than warning
+     * everybody on every run or overwriting somebody's code to add a line.
+     */
+    readonly expects?: {
+        readonly needle: string;
+        readonly hint: string;
+    };
+    /**
+     * For a user file only: things the file must NOT contain, and why.
+     *
+     * The mirror of `expects`. Some edits to a user-editable subclass silently
+     * disable what the base class generates — the worst being a redeclared
+     * `protected $fillable`, which in PHP REPLACES the parent's rather than
+     * merging, so every property added to the schema afterwards is stripped by
+     * Eloquent on mass assignment. Nothing throws; `save()` returns true and the
+     * column stays NULL (issue #171).
+     *
+     * Each entry is matched against the content of the file we skipped, and
+     * `hint` is printed when it matches.
+     */
+    readonly conflicts?: readonly {
+        readonly pattern: string;
+        readonly hint: string;
+    }[];
 }
 /** Create a base file (always overwritten). */
 export declare function baseFile(path: string, content: string): GeneratedFile;
 /** Create a user file (created once, skip if exists). */
-export declare function userFile(path: string, content: string): GeneratedFile;
+export declare function userFile(path: string, content: string, expects?: {
+    needle: string;
+    hint: string;
+}, conflicts?: readonly {
+    pattern: string;
+    hint: string;
+}[]): GeneratedFile;
+/**
+ * Eloquent array properties that REPLACE the parent's when redeclared in a
+ * subclass, rather than merging. Redeclaring any of these in a user-editable
+ * model shadows whatever the generated base puts there, and the failure is
+ * completely silent. Issue #171.
+ */
+export declare const SHADOWING_ELOQUENT_PROPERTIES: readonly ["fillable", "guarded", "casts", "hidden", "visible", "appends", "dates", "touches", "with"];
+/**
+ * Build the `conflicts` entries for a generated model's editable subclass.
+ *
+ * `baseClass` is named in the hint because the whole point is that the base is
+ * still correct — the generator did emit the property — and the reader needs to
+ * know which file they are shadowing.
+ */
+export declare function shadowingPropertyConflicts(baseClass: string): {
+    pattern: string;
+    hint: string;
+}[];
 /** Category of base file for modular path resolution. */
 export type BaseCategory = 'Models' | 'Controllers' | 'Requests' | 'Resources' | 'Services' | 'Enums' | 'Traits' | 'Locales' | 'Policies';
 /**
@@ -401,3 +456,15 @@ export declare function nestEditableByGroup(layer: BaseEditableLayer, loc: {
  * All paths and namespaces fall back to sensible defaults.
  */
 export declare function derivePhpConfig(overrides?: LaravelCodegenOverrides): PhpConfig;
+/**
+ * Strip PHP comments so a commented-out declaration does not read as a real
+ * one. Without this, the very common
+ *
+ *     // protected $fillable = ['name'];   // left from a refactor
+ *
+ * would be reported as shadowing the base — and a warning that fires on code
+ * that is not running is worse than no warning, because people learn to ignore
+ * it. Naive on purpose: it can strip a `//` inside a string literal, which only
+ * ever costs us a warning we would otherwise have printed, never a false one.
+ */
+export declare function stripPhpComments(source: string): string;

package/dist/php/types.js

@@ -6,8 +6,53 @@ export function baseFile(path, content) {
     return { path, content, overwrite: true, type: 'base' };
 }
 /** Create a user file (created once, skip if exists). */
-export function userFile(path, content) {
-    return { path, content, overwrite: false, type: 'user' };
+export function userFile(path, content, expects, conflicts) {
+    return {
+        path,
+        content,
+        overwrite: false,
+        type: 'user',
+        ...(expects ? { expects } : {}),
+        ...(conflicts && conflicts.length > 0 ? { conflicts } : {}),
+    };
+}
+/**
+ * Eloquent array properties that REPLACE the parent's when redeclared in a
+ * subclass, rather than merging. Redeclaring any of these in a user-editable
+ * model shadows whatever the generated base puts there, and the failure is
+ * completely silent. Issue #171.
+ */
+export const SHADOWING_ELOQUENT_PROPERTIES = [
+    'fillable',
+    'guarded',
+    'casts',
+    'hidden',
+    'visible',
+    'appends',
+    'dates',
+    'touches',
+    'with',
+];
+/**
+ * Build the `conflicts` entries for a generated model's editable subclass.
+ *
+ * `baseClass` is named in the hint because the whole point is that the base is
+ * still correct — the generator did emit the property — and the reader needs to
+ * know which file they are shadowing.
+ */
+export function shadowingPropertyConflicts(baseClass) {
+    return SHADOWING_ELOQUENT_PROPERTIES.map((prop) => ({
+        // Matches `protected $fillable`, `public array $casts`, `protected static
+        // $with` — any redeclaration, whatever the visibility or type hint.
+        pattern: String.raw `(?:public|protected|private)\s+(?:static\s+)?(?:array\s+)?\$` + prop + String.raw `\s*=`,
+        hint: `redeclares $${prop}, which REPLACES ` +
+            `${baseClass}::$${prop} rather than merging with it (PHP does not merge ` +
+            `redeclared properties). Anything omnify adds to $${prop} from now on is ` +
+            `silently dropped: mass assignment strips it, save() still returns true, ` +
+            `and the column stays NULL. Fix: delete the redeclaration and let the base ` +
+            `provide it, or build it from the parent, e.g. ` +
+            `__construct() { $this->${prop} = array_merge(parent::$${prop} ?? [], [...]); }`,
+    }));
 }
 /**
  * Resolve base file path for a schema based on structure.
@@ -382,3 +427,20 @@ export function derivePhpConfig(overrides) {
         },
     };
 }
+/**
+ * Strip PHP comments so a commented-out declaration does not read as a real
+ * one. Without this, the very common
+ *
+ *     // protected $fillable = ['name'];   // left from a refactor
+ *
+ * would be reported as shadowing the base — and a warning that fires on code
+ * that is not running is worse than no warning, because people learn to ignore
+ * it. Naive on purpose: it can strip a `//` inside a string literal, which only
+ * ever costs us a warning we would otherwise have printed, never a false one.
+ */
+export function stripPhpComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/(^|\s)\/\/[^\n]*/g, '$1')
+        .replace(/(^|\s)#[^\n]*/g, '$1');
+}

package/dist/types.d.ts

@@ -240,6 +240,14 @@ export interface SchemaDefinition {
     readonly properties?: Record<string, PropertyDefinition>;
     readonly propertyOrder?: readonly string[];
     readonly expandedProperties?: Record<string, ExpandedProperty>;
+    /**
+     * Properties a project-level `kind: extend` merged into this schema, in
+     * merge order. The Go loader folds an extend into its target and deletes
+     * the extend, so this is the only remaining trace of where they came from
+     * — which a PACKAGE-owned target needs, because the package's own generate
+     * run never saw them (#164).
+     */
+    readonly extendedProperties?: readonly string[];
     readonly values?: readonly EnumValueDefinition[];
     readonly pivotFor?: readonly string[];
     readonly policies?: readonly PolicyDefinition[];

package/package.json

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