@omnifyjp/ts 6.7.16 → 6.7.17

package/dist/php/model-generator.js

@@ -462,6 +462,7 @@ function generateUserModel(name, schema, reader, config, hasNestedSet = false) {
         fillable: fillableFieldNames(properties, expandedProperties, propertyOrder),
         hidden: hiddenFieldNames(properties, expandedProperties, propertyOrder),
         appends: appendsFieldNames(expandedProperties),
+        casts: castsFieldNames(properties, expandedProperties, propertyOrder, reader, config),
     };
     const content = `<?php
 
@@ -837,6 +838,17 @@ function buildCasts(properties, expandedProperties, propertyOrder, reader, confi
         return '';
     return casts.map(c => `            ${c}`).join('\n') + '\n';
 }
+function castsFieldNames(properties, expandedProperties, propertyOrder, reader, config) {
+    const body = buildCasts(properties, expandedProperties, propertyOrder, reader, config);
+    if (body === '') {
+        return [];
+    }
+    const keys = [];
+    for (const m of body.matchAll(/'((?:[^'\\]|\\.)*)'\s*=>/g)) {
+        keys.push(m[1].replace(/\\'/g, "'"));
+    }
+    return keys;
+}
 /**
  * Issue #98 v5.8.10: resolve the FQCN namespace of a related Model for
  * inline `belongsTo / hasMany / belongsToMany / morphTo` references.

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

@@ -1,6 +1,10 @@
 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;
+/** Quoted array keys before `=>` in a PHP array literal segment (casts keys only). */
+export declare function parseCastAssociativeArrayKeys(segment: string): string[];
+export declare function parseRedeclaredCastsPropertyKeys(source: string): string[] | null;
+export declare function parseRedeclaredCastsMethodKeys(source: string): string[] | null;
 /**
  * Build the `conflicts` entries for a generated model's editable subclass.
  */
@@ -17,7 +21,4 @@ export type ShadowingConflictResult = {
     message: string;
     drift: ShadowingDrift;
 };
-/**
- * Evaluate shadowing conflicts for a skipped user-editable model file.
- */
 export declare function evaluateShadowingConflicts(existingRaw: string, conflicts: readonly ShadowingPropertyConflict[]): ShadowingConflictResult[];

package/dist/php/shadowing-conflicts.js

@@ -20,10 +20,66 @@ function shadowingConsequence(prop) {
         case 'appends':
             return (`Accessors omnify adds to $appends from now on would not be appended to ` +
                 `the model's array or JSON form.`);
+        case 'casts':
+            return (`Casts omnify adds from now on are lost: a Json column without its cast throws ` +
+                `"Array to string conversion" at INSERT, and a Decimal column silently returns a ` +
+                `differently-formatted string per driver.`);
         default:
             return `Configuration omnify adds to $${prop} from now on stops applying on this model.`;
     }
 }
+const CASTS_METHOD_PATTERN = String.raw `(?:public|protected)\s+function\s+casts\s*\(`;
+function shadowingCastsMethodHint(baseClass) {
+    return (`redeclares casts(), which REPLACES ${baseClass}::casts() rather than merging with it ` +
+        `(PHP does not merge methods). Casts omnify adds from now on are lost: a Json column ` +
+        `without its cast throws "Array to string conversion" at INSERT, and a Decimal column ` +
+        `silently returns a differently-formatted string per driver. ` +
+        `Fix: return array_merge(parent::casts(), [ … ]). ` +
+        `If intentional, add \`/** @omnify-casts intentional */\` above the method to silence ` +
+        `this warning.`);
+}
+/** Quoted array keys before `=>` in a PHP array literal segment (casts keys only). */
+export function parseCastAssociativeArrayKeys(segment) {
+    const keys = [];
+    const singleQuoted = /'((?:[^'\\]|\\.)*)'\s*=>/g;
+    for (const m of segment.matchAll(singleQuoted)) {
+        keys.push(m[1].replace(/\\'/g, "'"));
+    }
+    const doubleQuoted = /"((?:[^"\\]|\\.)*)"\s*=>/g;
+    for (const m of segment.matchAll(doubleQuoted)) {
+        keys.push(m[1].replace(/\\"/g, '"'));
+    }
+    return keys;
+}
+export function parseRedeclaredCastsPropertyKeys(source) {
+    const stripped = stripPhpComments(source);
+    const match = stripped.match(/\$casts\s*=\s*\[[\s\S]*?\];/);
+    if (!match) {
+        return null;
+    }
+    return parseCastAssociativeArrayKeys(match[0]);
+}
+export function parseRedeclaredCastsMethodKeys(source) {
+    const stripped = stripPhpComments(source);
+    const fnIdx = stripped.search(/function\s+casts\s*\(/);
+    if (fnIdx < 0) {
+        return null;
+    }
+    const tail = stripped.slice(fnIdx);
+    const returnMatch = tail.match(/return\s*\[[\s\S]*?\];/);
+    if (!returnMatch) {
+        return null;
+    }
+    return parseCastAssociativeArrayKeys(returnMatch[0]);
+}
+function redeclaredCastsMethodBody(source) {
+    const stripped = stripPhpComments(source);
+    const match = stripped.match(new RegExp(CASTS_METHOD_PATTERN + String.raw `[\s\S]*?\{([\s\S]*?)\}`));
+    return match ? match[1] : null;
+}
+function childDeclaresCastsMethod(stripped) {
+    return new RegExp(CASTS_METHOD_PATTERN).test(stripped);
+}
 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 ` +
@@ -33,13 +89,20 @@ function shadowingFixAdvice(prop, baseClass) {
  * Build the `conflicts` entries for a generated model's editable subclass.
  */
 export function shadowingPropertyConflicts(baseClass, baseArrayValues) {
-    return SHADOWING_ELOQUENT_PROPERTIES.map((prop) => {
+    const castsBaseValues = baseArrayValues?.casts;
+    const castsKeys = castsBaseValues &&
+        castsBaseValues.length > 0 &&
+        castsBaseValues.every((v) => typeof v === 'string')
+        ? castsBaseValues
+        : undefined;
+    const propertyConflicts = 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,
+            form: 'property',
             pattern: String.raw `(?:public|protected|private)\s+(?:static\s+)?(?:array\s+)?\$` +
                 prop +
                 String.raw `\s*=`,
@@ -49,6 +112,14 @@ export function shadowingPropertyConflicts(baseClass, baseArrayValues) {
             ...(baseValues ? { baseValues } : {}),
         };
     });
+    const methodCastsConflict = {
+        property: 'casts',
+        form: 'method',
+        pattern: CASTS_METHOD_PATTERN,
+        hint: shadowingCastsMethodHint(baseClass),
+        ...(castsKeys ? { baseValues: castsKeys } : {}),
+    };
+    return [...propertyConflicts, methodCastsConflict];
 }
 /**
  * Parse a redeclared PHP string array property (first `];` closes the array).
@@ -114,21 +185,41 @@ function classifyShadowingDrift(baseValues, childValues) {
 /**
  * Evaluate shadowing conflicts for a skipped user-editable model file.
  */
+function childValuesForConflict(existingRaw, conflict, baseValues) {
+    if (!baseValues) {
+        return null;
+    }
+    if (conflict.property === 'casts') {
+        if (conflict.form === 'method') {
+            return parseRedeclaredCastsMethodKeys(existingRaw);
+        }
+        return parseRedeclaredCastsPropertyKeys(existingRaw);
+    }
+    return parseRedeclaredStringArray(existingRaw, conflict.property);
+}
 export function evaluateShadowingConflicts(existingRaw, conflicts) {
     const stripped = stripPhpComments(existingRaw);
     const results = [];
+    const skipsPropertyCasts = childDeclaresCastsMethod(stripped);
     for (const conflict of conflicts) {
+        if (conflict.property === 'casts' && conflict.form !== 'method' && skipsPropertyCasts) {
+            continue;
+        }
         if (hasIntentionalShadowMarker(existingRaw, conflict.property)) {
             continue;
         }
         if (!new RegExp(conflict.pattern).test(stripped)) {
             continue;
         }
+        if (conflict.form === 'method' && conflict.property === 'casts') {
+            const body = redeclaredCastsMethodBody(existingRaw);
+            if (body !== null && body.includes('parent::casts()')) {
+                continue;
+            }
+        }
         let message = conflict.hint;
         const baseValues = conflict.baseValues && conflict.baseValues.length > 0 ? conflict.baseValues : undefined;
-        const childValues = baseValues
-            ? parseRedeclaredStringArray(existingRaw, conflict.property)
-            : null;
+        const childValues = childValuesForConflict(existingRaw, conflict, baseValues);
         const drift = classifyShadowingDrift(baseValues, childValues);
         if (baseValues) {
             const driftText = formatShadowingDrift(baseValues, childValues);

package/dist/php/types.d.ts

@@ -56,6 +56,8 @@ export type ShadowingPropertyConflict = {
     readonly pattern: string;
     readonly hint: string;
     readonly baseValues?: readonly string[];
+    /** Property redeclaration vs method redeclaration (issue #245: casts()). */
+    readonly form?: 'property' | 'method';
 };
 /** Category of base file for modular path resolution. */
 export type BaseCategory = 'Models' | 'Controllers' | 'Requests' | 'Resources' | 'Services' | 'Enums' | 'Traits' | 'Locales' | 'Policies';

package/package.json

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