@omnifyjp/ts 6.7.6 → 6.7.9

package/dist/cli.js

@@ -29,7 +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 { evaluateShadowingConflicts } from './php/shadowing-conflicts.js';
 import { pruneOrphanServiceFilesIfEnabled } from './php/orphan-cleanup.js';
 import { findSiblingWithSameBasename, findAppRootAncestor } from './php/sibling-skip.js';
 import { runPintFormat } from './php/pint-format.js';
@@ -271,11 +271,9 @@ program
                 // 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}`);
-                    }
+                for (const hint of evaluateShadowingConflicts(existing, file.conflicts ?? [])) {
+                    phpShadowed++;
+                    console.warn(`[omnify-ts] ${relative(configDir, filePath)}: ${hint}`);
                 }
                 continue;
             }

package/dist/php/model-generator.js

@@ -5,7 +5,8 @@ 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, shadowingPropertyConflicts, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup, } from './types.js';
+import { shadowingPropertyConflicts } from './shadowing-conflicts.js';
+import { baseFile, userFile, 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, for each package schema the project extends, a user model that
@@ -130,7 +131,7 @@ function generateForSchema(name, schema, reader, config) {
     const hasNestedSet = detectNestedSet(options, properties);
     return [
         generateBaseModel(name, schema, reader, config),
-        generateUserModel(name, schema, config, hasNestedSet),
+        generateUserModel(name, schema, reader, config, hasNestedSet),
     ];
 }
 function generateBaseModel(name, schema, reader, config) {
@@ -402,7 +403,7 @@ ${auditLogProperties}${relations}${accessors}${fileAccessors}${auditSection}${ne
         : `${baseDescriptor.path}/${baseDescriptor.className}.php`;
     return baseFile(filePath, finalContent);
 }
-function generateUserModel(name, schema, config, hasNestedSet = false) {
+function generateUserModel(name, schema, reader, config, hasNestedSet = false) {
     const modelName = toPascalCase(name);
     // Issue #96: editable stub may live at a different path/namespace
     // than the base (e.g. `app/Models/<Name>.php` while base is at
@@ -454,6 +455,14 @@ function generateUserModel(name, schema, config, hasNestedSet = false) {
     if (hasNestedSet) {
         traits.push('    use NodeTrait;');
     }
+    const properties = (schema.properties ?? {});
+    const expandedProperties = reader.getExpandedProperties(name);
+    const propertyOrder = reader.getPropertyOrder(name);
+    const baseArrayValues = {
+        fillable: fillableFieldNames(properties, expandedProperties, propertyOrder),
+        hidden: hiddenFieldNames(properties, expandedProperties, propertyOrder),
+        appends: appendsFieldNames(expandedProperties),
+    };
     const content = `<?php
 
 /**
@@ -488,7 +497,7 @@ ${traits.join('\n')}
     // 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));
+    return userFile(`${editable.path}/${editable.fileName}`, content, undefined, shadowingPropertyConflicts(baseAlias, baseArrayValues));
 }
 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 = [];
@@ -669,7 +678,7 @@ function buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUui
     names.sort((a, b) => (a.toLowerCase() < b.toLowerCase() ? -1 : a.toLowerCase() > b.toLowerCase() ? 1 : 0));
     return names.map((n) => `    use ${n};`).join('\n') + '\n';
 }
-function buildFillable(properties, expandedProperties, propertyOrder) {
+function fillableFieldNames(properties, expandedProperties, propertyOrder) {
     const fields = [];
     for (const propName of propertyOrder) {
         const prop = properties[propName];
@@ -703,11 +712,15 @@ function buildFillable(properties, expandedProperties, propertyOrder) {
         }
         fields.push(toSnakeCase(propName));
     }
+    return fields;
+}
+function buildFillable(properties, expandedProperties, propertyOrder) {
+    const fields = fillableFieldNames(properties, expandedProperties, propertyOrder);
     if (fields.length === 0)
         return '';
     return fields.map(f => `        '${f}',`).join('\n') + '\n';
 }
-function buildHidden(properties, expandedProperties, propertyOrder) {
+function hiddenFieldNames(properties, expandedProperties, propertyOrder) {
     const fields = [];
     for (const propName of propertyOrder) {
         const prop = properties[propName];
@@ -727,7 +740,6 @@ function buildHidden(properties, expandedProperties, propertyOrder) {
             }
             continue;
         }
-        // Check individual field hidden overrides for compound types
         if (expandedProperties[propName]) {
             const fieldOverrides = prop['fields'] ?? {};
             for (const col of expandedProperties[propName].columns ?? []) {
@@ -738,11 +750,15 @@ function buildHidden(properties, expandedProperties, propertyOrder) {
             }
         }
     }
+    return fields;
+}
+function buildHidden(properties, expandedProperties, propertyOrder) {
+    const fields = hiddenFieldNames(properties, expandedProperties, propertyOrder);
     if (fields.length === 0)
         return '';
     return fields.map(f => `        '${f}',`).join('\n') + '\n';
 }
-function buildAppends(expandedProperties) {
+function appendsFieldNames(expandedProperties) {
     const appends = [];
     for (const [propName, expansion] of Object.entries(expandedProperties)) {
         const sourceType = expansion.sourceType ?? '';
@@ -757,6 +773,10 @@ function buildAppends(expandedProperties) {
                 break;
         }
     }
+    return appends;
+}
+function buildAppends(expandedProperties) {
+    const appends = appendsFieldNames(expandedProperties);
     if (appends.length === 0)
         return '';
     return appends.map(a => `        '${a}',`).join('\n') + '\n';

package/dist/php/shadowing-conflicts.d.ts

@@ -0,0 +1,17 @@
+import { type ShadowingEloquentProperty, type ShadowingPropertyConflict } from './types.js';
+/** Case-sensitive intent marker checked against raw file content (issue #222). */
+export declare function hasIntentionalShadowMarker(rawContent: string, prop: string): boolean;
+/**
+ * Build the `conflicts` entries for a generated model's editable subclass.
+ */
+export declare function shadowingPropertyConflicts(baseClass: string, baseArrayValues?: Partial<Record<ShadowingEloquentProperty, readonly string[]>>): ShadowingPropertyConflict[];
+/**
+ * Parse a redeclared PHP string array property (first `];` closes the array).
+ * Operates on comment-stripped source so commented-out earlier declarations are ignored.
+ */
+export declare function parseRedeclaredStringArray(source: string, prop: string): string[] | null;
+export declare function formatShadowingDrift(baseValues: readonly string[], childValues: string[] | null): string;
+/**
+ * Evaluate shadowing conflicts for a skipped user-editable model file.
+ */
+export declare function evaluateShadowingConflicts(existingRaw: string, conflicts: readonly ShadowingPropertyConflict[]): string[];

package/dist/php/shadowing-conflicts.js

@@ -0,0 +1,119 @@
+import { SHADOWING_ELOQUENT_PROPERTIES, stripPhpComments, } from './types.js';
+/** Case-sensitive intent marker checked against raw file content (issue #222). */
+export function hasIntentionalShadowMarker(rawContent, prop) {
+    return rawContent.includes(`@omnify-${prop} intentional`);
+}
+function shadowingConsequence(prop) {
+    switch (prop) {
+        case 'fillable':
+            return (`Anything omnify adds to $fillable from now on is silently dropped: ` +
+                `mass assignment strips it, save() still returns true, and the column stays NULL.`);
+        case 'guarded':
+            return (`Anything omnify adds to $guarded from now on is silently unguarded: ` +
+                `mass assignment can write it.`);
+        case 'hidden':
+            return (`Attributes omnify adds to $hidden from now on would no longer be hidden ` +
+                `and may appear in JSON serialization.`);
+        case 'visible':
+            return (`Attributes omnify adds to $visible from now on would no longer be exposed ` +
+                `in JSON serialization.`);
+        case 'appends':
+            return (`Accessors omnify adds to $appends from now on would not be appended to ` +
+                `the model's array or JSON form.`);
+        default:
+            return `Configuration omnify adds to $${prop} from now on stops applying on this model.`;
+    }
+}
+function shadowingFixAdvice(prop, baseClass) {
+    return (`If this narrowing is intentional, add \`/** @omnify-${prop} intentional */\` ` +
+        `above the property to silence this warning. If not, remove the redeclaration ` +
+        `and let ${baseClass}::$${prop} apply, or merge from the parent explicitly.`);
+}
+/**
+ * Build the `conflicts` entries for a generated model's editable subclass.
+ */
+export function shadowingPropertyConflicts(baseClass, baseArrayValues) {
+    return SHADOWING_ELOQUENT_PROPERTIES.map((prop) => {
+        const values = baseArrayValues?.[prop];
+        const baseValues = values && values.length > 0 && values.every((v) => typeof v === 'string')
+            ? values
+            : undefined;
+        return {
+            property: prop,
+            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). ` +
+                `${shadowingConsequence(prop)} ${shadowingFixAdvice(prop, baseClass)}`,
+            ...(baseValues ? { baseValues } : {}),
+        };
+    });
+}
+/**
+ * Parse a redeclared PHP string array property (first `];` closes the array).
+ * Operates on comment-stripped source so commented-out earlier declarations are ignored.
+ */
+export function parseRedeclaredStringArray(source, prop) {
+    const stripped = stripPhpComments(source);
+    const match = stripped.match(new RegExp(String.raw `\$` + prop + String.raw `\s*=\s*\[[\s\S]*?\];`));
+    if (!match) {
+        return null;
+    }
+    const segment = match[0];
+    const values = [];
+    const singleQuoted = /'([^'\\]*(?:\\.[^'\\]*)*)'/g;
+    for (const m of segment.matchAll(singleQuoted)) {
+        values.push(m[1].replace(/\\'/g, "'"));
+    }
+    const doubleQuoted = /"([^"\\]*(?:\\.[^"\\]*)*)"/g;
+    for (const m of segment.matchAll(doubleQuoted)) {
+        values.push(m[1].replace(/\\"/g, '"'));
+    }
+    return values;
+}
+export function formatShadowingDrift(baseValues, childValues) {
+    if (childValues === null) {
+        return '';
+    }
+    const baseSet = new Set(baseValues);
+    const childSet = new Set(childValues);
+    const missing = baseValues.filter((v) => !childSet.has(v));
+    const extra = childValues.filter((v) => !baseSet.has(v));
+    if (missing.length === 0 && extra.length === 0) {
+        return 'The copy is currently identical and will drift when the schema changes.';
+    }
+    const parts = [];
+    if (missing.length > 0) {
+        parts.push(`missing from child: ${missing.join(', ')}`);
+    }
+    if (extra.length > 0) {
+        parts.push(`extra in child: ${extra.join(', ')}`);
+    }
+    return parts.join('; ') + '.';
+}
+/**
+ * Evaluate shadowing conflicts for a skipped user-editable model file.
+ */
+export function evaluateShadowingConflicts(existingRaw, conflicts) {
+    const stripped = stripPhpComments(existingRaw);
+    const warnings = [];
+    for (const conflict of conflicts) {
+        if (hasIntentionalShadowMarker(existingRaw, conflict.property)) {
+            continue;
+        }
+        if (!new RegExp(conflict.pattern).test(stripped)) {
+            continue;
+        }
+        let message = conflict.hint;
+        if (conflict.baseValues && conflict.baseValues.length > 0) {
+            const childValues = parseRedeclaredStringArray(existingRaw, conflict.property);
+            const drift = formatShadowingDrift(conflict.baseValues, childValues);
+            if (drift) {
+                message += ` ${drift}`;
+            }
+        }
+        warnings.push(message);
+    }
+    return warnings;
+}

package/dist/php/types.d.ts

@@ -34,10 +34,7 @@ export interface GeneratedFile {
      * 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;
-    }[];
+    readonly conflicts?: readonly ShadowingPropertyConflict[];
 }
 /** Create a base file (always overwritten). */
 export declare function baseFile(path: string, content: string): GeneratedFile;
@@ -45,10 +42,7 @@ export declare function baseFile(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;
+}, conflicts?: readonly ShadowingPropertyConflict[]): 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
@@ -56,17 +50,13 @@ export declare function userFile(path: string, content: string, expects?: {
  * 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;
-}[];
+export type ShadowingEloquentProperty = (typeof SHADOWING_ELOQUENT_PROPERTIES)[number];
+export type ShadowingPropertyConflict = {
+    readonly property: ShadowingEloquentProperty;
+    readonly pattern: string;
+    readonly hint: string;
+    readonly baseValues?: readonly string[];
+};
 /** Category of base file for modular path resolution. */
 export type BaseCategory = 'Models' | 'Controllers' | 'Requests' | 'Resources' | 'Services' | 'Enums' | 'Traits' | 'Locales' | 'Policies';
 /**

package/dist/php/types.js

@@ -33,27 +33,6 @@ export const SHADOWING_ELOQUENT_PROPERTIES = [
     '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.
  * Modular: {modules.path}/{SchemaName}/{category}/{fileName}

package/package.json

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