@omnifyjp/ts 8.0.5 → 8.0.7

package/dist/cli.js

@@ -241,6 +241,7 @@ program
         let phpSkippedSibling = 0;
         let phpShadowedOutOfSync = 0;
         let phpShadowedAtRisk = 0;
+        let phpNotExtendingBase = 0;
         const skippedSiblingExamples = [];
         for (const file of phpFiles) {
             const filePath = resolve(configDir, file.path);
@@ -261,7 +262,10 @@ program
                 // assignment with no error anywhere.
                 const shadowResults = evaluateShadowingConflicts(existing, file.conflicts ?? []);
                 if (shadowResults.length > 0) {
-                    if (shadowResults.some((r) => r.drift === 'out-of-sync')) {
+                    if (shadowResults.some((r) => r.drift === 'not-extending-base')) {
+                        phpNotExtendingBase++;
+                    }
+                    else if (shadowResults.some((r) => r.drift === 'out-of-sync')) {
                         phpShadowedOutOfSync++;
                     }
                     else {
@@ -319,7 +323,7 @@ program
             console.log(`  ${phpCreated} files created (user-editable)`);
         if (phpSkipped > 0)
             console.log(`  ${phpSkipped} files skipped (already exist)`);
-        if (phpShadowedOutOfSync > 0 || phpShadowedAtRisk > 0) {
+        if (phpShadowedOutOfSync > 0 || phpShadowedAtRisk > 0 || phpNotExtendingBase > 0) {
             const summaryParts = [];
             if (phpShadowedOutOfSync > 0) {
                 summaryParts.push(`${phpShadowedOutOfSync} editable file(s) already out of sync with the base`);
@@ -327,6 +331,9 @@ program
             if (phpShadowedAtRisk > 0) {
                 summaryParts.push(`${phpShadowedAtRisk} shadow a generated property and will drift on the next schema change`);
             }
+            if (phpNotExtendingBase > 0) {
+                summaryParts.push(`${phpNotExtendingBase} do not extend their generated base model`);
+            }
             console.warn(`  ${summaryParts.join(', ')} (see warnings above).`);
         }
         if (phpSkippedSibling > 0) {

package/dist/php/file-trait-generator.js

@@ -69,19 +69,16 @@ trait HasFiles
             return;
         }
 
-        File::whereIn('id', $fileIds)->update([
+        // One UPDATE, so the attach is atomic without a caller transaction.
+        // increment() with extra columns, not DB::raw('sort_order + '.$startOrder):
+        // raw SQL is typed literal-string, and the offset is bound here.
+        File::whereIn('id', $fileIds)->increment('sort_order', $startOrder, [
             'fileable_type' => $this->getMorphClass(),
             'fileable_id' => $this->getKey(),
             'collection' => $collection,
             'status' => FileStatusEnum::Permanent,
             'expires_at' => null,
         ]);
-
-        // increment(), not DB::raw('sort_order + '.$startOrder): raw SQL is
-        // typed literal-string, and a column offset needs no SQL of our own.
-        if ($startOrder !== 0) {
-            File::whereIn('id', $fileIds)->increment('sort_order', $startOrder);
-        }
     }
 
     /**

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

@@ -15,9 +15,9 @@ export declare function shadowingPropertyConflicts(baseClass: string, baseArrayV
  */
 export declare function parseRedeclaredStringArray(source: string, prop: string): string[] | null;
 export declare function formatShadowingDrift(baseValues: readonly string[], childValues: string[] | null): string;
-export type ShadowingDrift = 'out-of-sync' | 'extra-only' | 'in-sync' | 'unknown';
+export type ShadowingDrift = 'out-of-sync' | 'extra-only' | 'in-sync' | 'unknown' | 'not-extending-base';
 export type ShadowingConflictResult = {
-    property: ShadowingEloquentProperty;
+    property: ShadowingEloquentProperty | 'extends';
     message: string;
     drift: ShadowingDrift;
 };

package/dist/php/shadowing-conflicts.js

@@ -109,6 +109,7 @@ export function shadowingPropertyConflicts(baseClass, baseArrayValues) {
             hint: `redeclares $${prop}, which REPLACES ${baseClass}::$${prop} rather than ` +
                 `merging with it (PHP does not merge redeclared properties). ` +
                 `${shadowingConsequence(prop)} ${shadowingFixAdvice(prop, baseClass)}`,
+            baseClass,
             ...(baseValues ? { baseValues } : {}),
         };
     });
@@ -117,6 +118,7 @@ export function shadowingPropertyConflicts(baseClass, baseArrayValues) {
         form: 'method',
         pattern: CASTS_METHOD_PATTERN,
         hint: shadowingCastsMethodHint(baseClass),
+        baseClass,
         ...(castsKeys ? { baseValues: castsKeys } : {}),
     };
     return [...propertyConflicts, methodCastsConflict];
@@ -197,9 +199,53 @@ function childValuesForConflict(existingRaw, conflict, baseValues) {
     }
     return parseRedeclaredStringArray(existingRaw, conflict.property);
 }
+/**
+ * Issue #312: a redeclared property only REPLACES the base's when the class
+ * extends that base. Returns the class name and its `extends` target when the
+ * class does not reach `baseClass`, or null when it does (or the class
+ * declaration cannot be read, so the shadowing checks stay as they were).
+ */
+function notExtendingBase(stripped, baseClass) {
+    const decl = stripped.match(/\bclass\s+(\w+)(?:\s+extends\s+([\\\w]+))?/);
+    if (!decl) {
+        return null;
+    }
+    const parent = decl[2] ?? null;
+    if (parent !== null) {
+        const name = parent.split('\\').pop();
+        if (name === baseClass) {
+            return null;
+        }
+        const aliased = new RegExp(String.raw `\buse\s+[\\\w]*\\` + baseClass + String.raw `\s+as\s+` + name + String.raw `\s*;`);
+        if (aliased.test(stripped)) {
+            return null;
+        }
+    }
+    return { className: decl[1], parent };
+}
+function notExtendingBaseHint(className, parent, baseClass) {
+    return (`${className} ${parent ? `extends ${parent}, not ${baseClass}` : `does not extend ${baseClass}`}, ` +
+        `so nothing omnify generates on ${baseClass} (relations, casts, $fillable, $hidden) ` +
+        `applies to this model. Its own $fillable / $casts replace nothing and are not checked. ` +
+        `Fix: extend ${baseClass}. If a parent class in between already extends it, or this ` +
+        `model is intentionally detached, add \`/** @omnify-base intentional */\` to silence this warning.`);
+}
 export function evaluateShadowingConflicts(existingRaw, conflicts) {
     const stripped = stripPhpComments(existingRaw);
     const results = [];
+    const baseClass = conflicts.find((c) => c.baseClass)?.baseClass;
+    const detached = baseClass ? notExtendingBase(stripped, baseClass) : null;
+    if (baseClass && detached) {
+        if (existingRaw.includes('@omnify-base intentional')) {
+            return results;
+        }
+        results.push({
+            property: 'extends',
+            message: notExtendingBaseHint(detached.className, detached.parent, baseClass),
+            drift: 'not-extending-base',
+        });
+        return results;
+    }
     const skipsPropertyCasts = childDeclaresCastsMethod(stripped);
     for (const conflict of conflicts) {
         if (conflict.property === 'casts' && conflict.form !== 'method' && skipsPropertyCasts) {

package/dist/php/types.d.ts

@@ -58,6 +58,8 @@ export type ShadowingPropertyConflict = {
     readonly baseValues?: readonly string[];
     /** Property redeclaration vs method redeclaration (issue #245: casts()). */
     readonly form?: 'property' | 'method';
+    /** Generated base the editable class should extend (issue #312). */
+    readonly baseClass?: string;
 };
 /** 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": "8.0.5",
+  "version": "8.0.7",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",