@codenameryuu/adonis-lucid-auto-preload 2.5.0 → 2.6.0

package/README.md

@@ -74,6 +74,18 @@ class Product extends compose(BaseModel, AutoPreload) {
 }
 ```
 
+### **Preload soft deleted belongsTo**
+
+If you are using soft deletes (for example with [`@codenameryuu/adonis-lucid-soft-deletes`](https://github.com/codenameryuu/adonis-lucid-soft-deletes)), you may want a `belongsTo` relationship to be preloaded even when the related row is soft deleted.
+
+You can opt-in per relationship using an object entry:
+
+```typescript
+class Product extends compose(BaseModel, AutoPreload) {
+  public static $with = [{ relation: 'productCategory', withTrashed: true }] as const
+}
+```
+
 ```typescript
 // App/Controllers/Http/ProductsController.ts
 

package/build/adonis-typings/auto_preload.d.ts

@@ -3,9 +3,13 @@ import type { LucidModel } from '@adonisjs/lucid/types/model';
 type GetWith<T> = T extends {
     $with: Array<infer Item>;
 } ? Item extends string ? Item : string : string;
+type PreloadSpec = {
+    relation: string;
+    withTrashed?: boolean;
+};
 export interface AutoPreloadMixin {
     <T extends NormalizeConstructor<LucidModel>>(superclass: T): T & {
-        $with: ReadonlyArray<string | ((query: any) => void)>;
+        $with: ReadonlyArray<string | PreloadSpec | ((query: any) => void)>;
         without(this: T, relationships: Array<GetWith<T>>): any;
         withOnly(this: T, relationships: Array<GetWith<T>>): any;
         withoutAny(this: T): any;

package/build/src/mixins/auto_preload.d.ts

@@ -1,6 +1,15 @@
 import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
 import type { LucidModel, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-type PreloadEntry = string | ((query: ModelQueryBuilderContract<any, any>) => void);
+type PreloadSpec = {
+    relation: string;
+    /**
+     * When true, attempts to call `.withTrashed()` on the preload builder.
+     * Useful with `@codenameryuu/adonis-lucid-soft-deletes` when the related model
+     * may be soft deleted but should still be returned.
+     */
+    withTrashed?: boolean;
+};
+type PreloadEntry = string | PreloadSpec | ((query: ModelQueryBuilderContract<any, any>) => void);
 export declare function AutoPreload<T extends NormalizeConstructor<LucidModel>>(superclass: T): {
     new (...args: any[]): {
         $attributes: import("@adonisjs/lucid/types/model").ModelObject;
@@ -65,6 +74,7 @@ export declare function AutoPreload<T extends NormalizeConstructor<LucidModel>>(
      * Propagate query flags used by other mixins (e.g. SoftDeletes) to preload builders.
      * SoftDeletes uses `query.ignoreDeleted = false` for `.withTrashed()` / `.onlyTrashed()`.
      */
+    applyPreloadOptions(parent: any, child: any, options?: PreloadSpec): void;
     inheritQueryFlags(parent: any, child: any): void;
     /**
      * List of relationships to auto-preload.
@@ -75,7 +85,7 @@ export declare function AutoPreload<T extends NormalizeConstructor<LucidModel>>(
     beforeFetchHook(query: ModelQueryBuilderContract<any, any>): void;
     beforePaginateHook(queries: any): void;
     applyAutoPreload(query: ModelQueryBuilderContract<any, any>): void;
-    handleNestedPreload(query: any, parts: string[]): void;
+    handleNestedPreload(query: any, parts: string[], options?: PreloadSpec, isRoot?: boolean): void;
     /**
      * Correct Implementation: Returns the Query Builder to avoid global state pollution
      */

package/build/src/mixins/auto_preload.js

@@ -4,6 +4,12 @@ export function AutoPreload(superclass) {
          * Propagate query flags used by other mixins (e.g. SoftDeletes) to preload builders.
          * SoftDeletes uses `query.ignoreDeleted = false` for `.withTrashed()` / `.onlyTrashed()`.
          */
+        static applyPreloadOptions(parent, child, options) {
+            if (options?.withTrashed && typeof child?.withTrashed === 'function') {
+                child.withTrashed();
+            }
+            this.inheritQueryFlags(parent, child);
+        }
         static inheritQueryFlags(parent, child) {
             if (!parent || !child)
                 return;
@@ -55,17 +61,19 @@ export function AutoPreload(superclass) {
             const skipList = query.$skipPreloads || [];
             const onlyList = query.$onlyPreloads || [];
             for (const relation of relations) {
-                if (typeof relation === 'string') {
-                    if (onlyList.length > 0 && !onlyList.includes(relation))
+                if (typeof relation === 'string' || (relation && typeof relation === 'object')) {
+                    const name = typeof relation === 'string' ? relation : relation.relation;
+                    const options = typeof relation === 'string' ? undefined : relation;
+                    if (onlyList.length > 0 && !onlyList.includes(name))
                         continue;
-                    if (skipList.includes(relation))
+                    if (skipList.includes(name))
                         continue;
-                    if (relation.includes('.')) {
-                        this.handleNestedPreload(query, relation.split('.'));
+                    if (name.includes('.')) {
+                        this.handleNestedPreload(query, name.split('.'), options, true);
                     }
                     else {
-                        query.preload(relation, (builder) => {
-                            this.inheritQueryFlags(query, builder);
+                        query.preload(name, (builder) => {
+                            this.applyPreloadOptions(query, builder, options);
                         });
                     }
                 }
@@ -74,14 +82,15 @@ export function AutoPreload(superclass) {
                 }
             }
         }
-        static handleNestedPreload(query, parts) {
+        static handleNestedPreload(query, parts, options, isRoot = false) {
             const current = parts.shift();
             if (!current)
                 return;
             query.preload(current, (builder) => {
-                this.inheritQueryFlags(query, builder);
+                // Apply options only to the first hop ("productCategory" in "productCategory.user")
+                this.applyPreloadOptions(query, builder, isRoot ? options : undefined);
                 if (parts.length > 0) {
-                    this.handleNestedPreload(builder, [...parts]);
+                    this.handleNestedPreload(builder, [...parts], options, false);
                 }
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codenameryuu/adonis-lucid-auto-preload",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Auto-preload (eager loading) multiple relationships when retrieving Lucid models on Adonis JS",
   "author": "codenameryuu",
   "license": "MIT",