@omnifyjp/omnify 6.2.0 → 6.3.0

package/package.json

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

package/ts-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,11 +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 && !readFileSync(filePath, 'utf-8').includes(file.expects.needle)) {
+                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
@@ -285,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/ts-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). */
@@ -474,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 = [];

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

@@ -21,6 +21,23 @@ export interface GeneratedFile {
         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;
@@ -28,7 +45,28 @@ export declare function baseFile(path: string, content: string): GeneratedFile;
 export declare function userFile(path: string, content: string, expects?: {
     needle: string;
     hint: string;
-}): GeneratedFile;
+}, 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';
 /**
@@ -418,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/ts-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, expects) {
-    return { path, content, overwrite: false, type: 'user', ...(expects ? { expects } : {}) };
+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');
+}