@codenameryuu/adonis-lucid-auto-preload 2.7.0 → 2.9.0

package/README.md

@@ -40,6 +40,8 @@ Relationships will be auto-preloaded for `find` , `all` and `paginate` queries.
 
 **Note:** Relationships must be `belongsTo` , if you are using other relationship types, it may cause infinite loop.
 
+**Note:** Make sure `AutoPreload` extended in the last position, especially when using `SoftDeletes` package.
+
 ### **Using relation name**
 
 ```typescript
@@ -50,10 +52,11 @@ import type { BelongsTo } from "@adonisjs/lucid/types/relations";
 import { compose } from "@adonisjs/core/helpers";
 
 import { AutoPreload } from "@codenameryuu/adonis-lucid-auto-preload";
+import { SoftDeletes } from "@codenameryuu/adonis-lucid-soft-deletes";
 
 import ProductCategory from '#models/product-category'
 
-class Product extends compose(BaseModel, AutoPreload) {
+class Product extends compose(BaseModel, SoftDeletes, AutoPreload) {
   public static $with = ['productCategory'] as const
 
   @column({ isPrimary: true })
@@ -74,18 +77,6 @@ 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
 
@@ -111,10 +102,11 @@ import type { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model'
 import { compose } from '@adonisjs/core/helpers'
 
 import { AutoPreload } from '@codenameryuu/adonis-lucid-auto-preload'
+import { SoftDeletes } from "@codenameryuu/adonis-lucid-soft-deletes";
 
 import ProductCategory from '#models/product-category'
 
-class Product extends compose(BaseModel, AutoPreload) {
+class Product extends compose(BaseModel, SoftDeletes, AutoPreload) {
   public static $with = [
     (query: ModelQueryBuilderContract<typeof this>) => {
       query.preload('productCategory')
@@ -163,10 +155,11 @@ import type { BelongsTo } from "@adonisjs/lucid/types/relations";
 import { compose } from "@adonisjs/core/helpers";
 
 import { AutoPreload } from "@codenameryuu/adonis-lucid-auto-preload";
+import { SoftDeletes } from "@codenameryuu/adonis-lucid-soft-deletes";
 
 import User from '#models/user'
 
-class ProductCategory extends compose(BaseModel, AutoPreload) {
+class ProductCategory extends compose(BaseModel, SoftDeletes, AutoPreload) {
   public static $with = ['user'] as const
 
   @column({ isPrimary: true })
@@ -195,10 +188,11 @@ import type { BelongsTo } from "@adonisjs/lucid/types/relations";
 import { compose } from '@adonisjs/core/helpers'
 
 import { AutoPreload } from '@codenameryuu/adonis-lucid-auto-preload'
+import { SoftDeletes } from "@codenameryuu/adonis-lucid-soft-deletes";
 
 import ProductCategory from '#models/product-category'
 
-class Product extends compose(BaseModel, AutoPreload) {
+class Product extends compose(BaseModel, SoftDeletes, AutoPreload) {
   public static $with = ['productCategory.user'] as const
 
   @column({ isPrimary: true })

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

@@ -3,13 +3,9 @@ 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 | PreloadSpec | ((query: any) => void)>;
+        $with: ReadonlyArray<string | ((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,15 +1,6 @@
 import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
 import type { LucidModel, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-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);
+type PreloadEntry = string | ((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;
@@ -70,12 +61,6 @@ export declare function AutoPreload<T extends NormalizeConstructor<LucidModel>>(
         toAttributes(): Record<string, any>;
         related<Name extends undefined>(relation: Name): NonNullable</*elided*/ any[Name]> extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? (import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> & /*elided*/ any[Name] & {})["client"] : never;
     };
-    /**
-     * 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.
      */
@@ -85,7 +70,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[], options?: PreloadSpec, isRoot?: boolean): void;
+    handleNestedPreload(query: any, parts: string[]): void;
     /**
      * Correct Implementation: Returns the Query Builder to avoid global state pollution
      */

package/build/src/mixins/auto_preload.js

@@ -1,37 +1,5 @@
 export function AutoPreload(superclass) {
     class AutoPreloadModel extends 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) {
-                if (typeof child?.withTrashed === 'function') {
-                    child.withTrashed();
-                }
-                else {
-                    /**
-                     * Fallback for builders that don't have the `withTrashed` macro attached.
-                     * `@codenameryuu/adonis-lucid-soft-deletes` checks `ignoreDeleted === false`.
-                     */
-                    child.ignoreDeleted = false;
-                }
-            }
-            this.inheritQueryFlags(parent, child);
-        }
-        static inheritQueryFlags(parent, child) {
-            if (!parent || !child)
-                return;
-            if (Object.prototype.hasOwnProperty.call(parent, 'ignoreDeleted') &&
-                parent.ignoreDeleted === false) {
-                if (typeof child.withTrashed === 'function') {
-                    child.withTrashed();
-                }
-                else {
-                    child.ignoreDeleted = false;
-                }
-            }
-        }
         /**
          * List of relationships to auto-preload.
          */
@@ -70,20 +38,16 @@ export function AutoPreload(superclass) {
             const skipList = query.$skipPreloads || [];
             const onlyList = query.$onlyPreloads || [];
             for (const relation of relations) {
-                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))
+                if (typeof relation === 'string') {
+                    if (onlyList.length > 0 && !onlyList.includes(relation))
                         continue;
-                    if (skipList.includes(name))
+                    if (skipList.includes(relation))
                         continue;
-                    if (name.includes('.')) {
-                        this.handleNestedPreload(query, name.split('.'), options, true);
+                    if (relation.includes('.')) {
+                        this.handleNestedPreload(query, relation.split('.'));
                     }
                     else {
-                        query.preload(name, (builder) => {
-                            this.applyPreloadOptions(query, builder, options);
-                        });
+                        query.preload(relation);
                     }
                 }
                 else if (typeof relation === 'function') {
@@ -91,15 +55,13 @@ export function AutoPreload(superclass) {
                 }
             }
         }
-        static handleNestedPreload(query, parts, options, isRoot = false) {
+        static handleNestedPreload(query, parts) {
             const current = parts.shift();
             if (!current)
                 return;
             query.preload(current, (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], options, false);
+                    this.handleNestedPreload(builder, [...parts]);
                 }
             });
         }

package/package.json

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