@codenameryuu/adonis-lucid-auto-preload 1.6.0 → 1.8.0

package/build/index.d.ts

@@ -1,2 +1,2 @@
 export { configure } from './configure.js';
-export { AutoPreload } from './src/mixins/auto_preload.ts';
+export { AutoPreload } from './src/mixins/auto_preload.js';

package/build/index.js

@@ -7,4 +7,4 @@
  * file that was distributed with this source code.
  */
 export { configure } from './configure.js';
-export { AutoPreload } from "./src/mixins/auto_preload.js";
+export { AutoPreload } from './src/mixins/auto_preload.js';

package/build/providers/auto_preload_provider.js

@@ -1,4 +1,3 @@
-import { AutoPreload } from '../src/mixins/auto_preload.js';
 export { configure } from '../configure.js';
 export default class AutoPreloadProvider {
     app;
@@ -6,11 +5,7 @@ export default class AutoPreloadProvider {
     constructor(app) {
         this.app = app;
     }
-    register() {
-        this.app.container.singleton('@codenameryuu/adonis-lucid-auto-preload', () => {
-            return { AutoPreload };
-        });
-    }
+    register() { }
     async boot() { }
     async ready() { }
     async shutdown() { }

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

@@ -1,11 +1,156 @@
 import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
-import type { LucidModel } from '@adonisjs/lucid/types/model';
-type AutoPreloadMixin = <T extends NormalizeConstructor<LucidModel>>(superclass: T) => T & {
-    $with: Array<string | ((query: any) => void)>;
-    without(this: T, relationships: Array<string>): T;
-    withOnly(this: T, relationships: Array<string>): T;
-    withoutAny(this: T): T;
-    new (...args: Array<any>): {};
-};
-export declare const AutoPreload: AutoPreloadMixin;
+import type { LucidModel, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
+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;
+        $extras: import("@adonisjs/lucid/types/model").ModelObject;
+        $original: import("@adonisjs/lucid/types/model").ModelObject;
+        $preloaded: {
+            [relation: string]: import("@adonisjs/lucid/types/model").LucidRow | import("@adonisjs/lucid/types/model").LucidRow[];
+        };
+        $sideloaded: import("@adonisjs/lucid/types/model").ModelObject;
+        $primaryKeyValue?: number | string;
+        $isPersisted: boolean;
+        $isNew: boolean;
+        $isLocal: boolean;
+        $dirty: import("@adonisjs/lucid/types/model").ModelObject;
+        $isDirty: boolean;
+        $isDeleted: boolean;
+        $options?: import("@adonisjs/lucid/types/model").ModelOptions;
+        $trx?: import("@adonisjs/lucid/types/database").TransactionClientContract;
+        $setOptionsAndTrx(options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): void;
+        useTransaction(trx: import("@adonisjs/lucid/types/database").TransactionClientContract): /*elided*/ any;
+        useConnection(connection: string): /*elided*/ any;
+        $getQueryFor(action: "insert", client: import("@adonisjs/lucid/types/database").QueryClientContract): ReturnType<import("@adonisjs/lucid/types/database").QueryClientContract["insertQuery"]>;
+        $getQueryFor(action: "update" | "delete" | "refresh", client: import("@adonisjs/lucid/types/database").QueryClientContract): ModelQueryBuilderContract<LucidModel>;
+        $setAttribute(key: string, value: any): void;
+        $getAttribute(key: string): any;
+        $getAttributeFromCache(key: string, callback: import("@adonisjs/lucid/types/model").CacheNode["getter"]): any;
+        $hasRelated(key: string): boolean;
+        $setRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
+        $pushRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
+        $getRelated(key: string, defaultValue?: any): import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | undefined | null;
+        $consumeAdapterResult(adapterResult: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject): void;
+        $hydrateOriginals(): void;
+        fill(value: Partial<import("@adonisjs/lucid/types/model").ModelAttributes</*elided*/ any>>, allowExtraProperties?: boolean): /*elided*/ any;
+        merge(value: Partial<import("@adonisjs/lucid/types/model").ModelAttributes</*elided*/ any>>, allowExtraProperties?: boolean): /*elided*/ any;
+        isDirty(fields?: undefined[] | undefined): boolean;
+        enableForceUpdate(): /*elided*/ any;
+        save(): Promise</*elided*/ any>;
+        saveQuietly(): Promise</*elided*/ any>;
+        lockForUpdate<T_1>(callback: (user: /*elided*/ any) => T_1 | Promise<T_1>): Promise<T_1>;
+        delete(): Promise<void>;
+        deleteQuietly(): Promise<void>;
+        refresh(): Promise</*elided*/ any>;
+        load: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
+        loadOnce: import("@adonisjs/lucid/types/model").LucidRowPreloadOnce</*elided*/ any>;
+        preload: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
+        loadAggregate: <Self extends /*elided*/ any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? (import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        loadCount: <Self extends /*elided*/ any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? (import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        serializeAttributes(fields?: import("@adonisjs/lucid/types/model").CherryPickFields, raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeComputed(fields?: import("@adonisjs/lucid/types/model").CherryPickFields): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeRelations(fields: undefined, raw: true): {
+            [key: string]: import("@adonisjs/lucid/types/model").LucidRow | import("@adonisjs/lucid/types/model").LucidRow[];
+        };
+        serializeRelations(cherryPick: import("@adonisjs/lucid/types/model").CherryPick["relations"] | undefined, raw: false | undefined): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeRelations(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick["relations"], raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
+        serialize(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick): import("@adonisjs/lucid/types/model").ModelObject;
+        toObject(): import("@adonisjs/lucid/types/model").ModelObject;
+        toJSON(): import("@adonisjs/lucid/types/model").ModelObject;
+        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;
+    };
+    /**
+     * List of relationships to auto-preload.
+     */
+    $with: ReadonlyArray<PreloadEntry>;
+    boot(): void;
+    applyAutoPreload(query: ModelQueryBuilderContract<any, any>): void;
+    handleNestedPreload(query: any, parts: string[]): void;
+    /**
+     * Correct Implementation: Returns the Query Builder to avoid global state pollution
+     */
+    without(relations: string[]): ModelQueryBuilderContract</*elided*/ any & T, InstanceType</*elided*/ any & T>>;
+    withoutAny(): ModelQueryBuilderContract</*elided*/ any & T, InstanceType</*elided*/ any & T>>;
+    readonly booted: boolean;
+    $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
+    $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
+    $computedDefinitions: Map<string, import("@adonisjs/lucid/types/model").ComputedOptions>;
+    primaryKey: string;
+    connection?: string | undefined;
+    namingStrategy: import("@adonisjs/lucid/types/model").NamingStrategyContract;
+    table: string;
+    selfAssignPrimaryKey: boolean;
+    $adapter: import("@adonisjs/lucid/types/model").AdapterContract;
+    useAdapter: (adapter: import("@adonisjs/lucid/types/model").AdapterContract) => void;
+    $hooks: import("@poppinss/hooks").default<any>;
+    $keys: {
+        attributesToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        attributesToSerialized: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        columnsToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        columnsToSerialized: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        serializedToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        serializedToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        columnAliasesToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
+    };
+    $createFromAdapterResult: <T_1 extends LucidModel>(this: T_1, result?: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => null | InstanceType<T_1>;
+    $createMultipleFromAdapterResult: <T_1 extends LucidModel>(this: T_1, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => InstanceType<T_1>[];
+    $addColumn: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ColumnOptions>) => import("@adonisjs/lucid/types/model").ColumnOptions;
+    $hasColumn: (name: string) => boolean;
+    $getColumn: (name: string) => import("@adonisjs/lucid/types/model").ModelColumnOptions | undefined;
+    $getColumnAlias: (columnName: string) => string;
+    columnsForSelect: () => Record<string, string>;
+    $addComputed: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ComputedOptions>) => import("@adonisjs/lucid/types/model").ComputedOptions;
+    $hasComputed: (name: string) => boolean;
+    $getComputed: (name: string) => import("@adonisjs/lucid/types/model").ComputedOptions | undefined;
+    $addRelation: (name: string, type: import("@adonisjs/lucid/types/relations").ModelRelationTypes["__opaque_type"], relatedModel: () => LucidModel, options: import("@adonisjs/lucid/types/model").ModelRelationOptions) => void;
+    $hasRelation: (name: string) => boolean;
+    $getRelation: {
+        <Model extends LucidModel, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<InstanceType<Model>>>(this: Model, name: Name): NonNullable<InstanceType<Model>[Name]> extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? NonNullable<InstanceType<Model>[Name]>["client"]["relation"] : import("@adonisjs/lucid/types/relations").RelationshipsContract;
+        <Model extends LucidModel>(this: Model, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
+    };
+    $defineProperty: <Model extends LucidModel, Prop extends keyof Model>(this: Model, propertyName: Prop, defaultValue: Model[Prop], strategy: "inherit" | "define" | ((value: Model[Prop]) => Model[Prop])) => void;
+    before: {
+        <Model extends LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<ModelQueryBuilderContract<Model>, Event>): void;
+        <Model extends LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[ModelQueryBuilderContract<Model>, ModelQueryBuilderContract<Model>], "paginate">): void;
+        <Model extends LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
+    };
+    after: {
+        <Model extends LucidModel>(this: Model, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>[], "fetch">): void;
+        <Model extends LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
+        <Model extends LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
+    };
+    create: <T_1 extends LucidModel>(this: T_1, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>>;
+    createQuietly: <T_1 extends LucidModel>(this: T_1, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>>;
+    createMany: <T_1 extends LucidModel>(this: T_1, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>[]>;
+    createManyQuietly: <T_1 extends LucidModel>(this: T_1, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>[]>;
+    find: <T_1 extends LucidModel>(this: T_1, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T_1>>;
+    findOrFail: <T_1 extends LucidModel>(this: T_1, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T_1>>;
+    findBy: {
+        <T_1 extends LucidModel>(this: T_1, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T_1>>;
+        <T_1 extends LucidModel>(this: T_1, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T_1>>;
+    };
+    findByOrFail: {
+        <T_1 extends LucidModel>(this: T_1, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T_1>>;
+        <T_1 extends LucidModel>(this: T_1, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T_1>>;
+    };
+    findManyBy: {
+        <T_1 extends LucidModel>(this: T_1, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T_1>[]>;
+        <T_1 extends LucidModel>(this: T_1, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T_1>[]>;
+    };
+    first: <T_1 extends LucidModel>(this: T_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T_1>>;
+    firstOrFail: <T_1 extends LucidModel>(this: T_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T_1>>;
+    findMany: <T_1 extends LucidModel>(this: T_1, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T_1>[]>;
+    firstOrNew: <T_1 extends LucidModel>(this: T_1, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>>;
+    firstOrCreate: <T_1 extends LucidModel>(this: T_1, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>>;
+    updateOrCreate: <T_1 extends LucidModel>(this: T_1, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>>;
+    fetchOrNewUpMany: <T_1 extends LucidModel>(this: T_1, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>[]>;
+    fetchOrCreateMany: <T_1 extends LucidModel>(this: T_1, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>[]>;
+    updateOrCreateMany: <T_1 extends LucidModel>(this: T_1, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>[]>;
+    all: <T_1 extends LucidModel>(this: T_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T_1>[]>;
+    query: <Model extends LucidModel, Result = InstanceType<Model>>(this: Model, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => ModelQueryBuilderContract<Model, Result>;
+    transaction: import("@adonisjs/lucid/types/database").TransactionFn;
+    truncate: (cascade?: boolean) => Promise<void>;
+} & T;
 export {};

package/build/src/mixins/auto_preload.js

@@ -1,112 +1,69 @@
-import WrongRelationshipTypeException from '../exceptions/wrong_relationship_type_exception.js';
-import WrongArgumentTypeException from '../exceptions/wrong_argument_type_exception.js';
-export const AutoPreload = (superclass) => {
-    class AutoPreloadModel extends superclass {
+export function AutoPreload(superclass) {
+    return class extends superclass {
+        /**
+         * List of relationships to auto-preload.
+         */
         static $with = [];
-        static $originalWith = [];
         static boot() {
-            if (this.booted) {
+            if (this.booted)
                 return;
-            }
-            if (this.$with.length > 0) {
-                const isWrongType = this.$with.every((relationship) => {
-                    return !['function', 'string'].includes(typeof relationship);
-                });
-                if (isWrongType) {
-                    throw WrongRelationshipTypeException.invoke(this.name);
-                }
-            }
             super.boot();
-            this.$originalWith = [...this.$with];
-            for (const hook of ['fetch', 'find']) {
-                this.before(hook, (query) => {
-                    this.handleAutoPreload(query);
-                });
-            }
-            this.before('paginate', ([_, query]) => {
-                this.handleAutoPreload(query, false);
+            // We use 'find' and 'fetch' hooks
+            this.before('find', (query) => this.applyAutoPreload(query));
+            this.before('fetch', (query) => this.applyAutoPreload(query));
+            // Lucid v7 paginate sends [countQuery, mainQuery]
+            this.before('paginate', (queries) => {
+                const query = Array.isArray(queries) ? queries[1] : queries;
+                this.applyAutoPreload(query);
             });
         }
-        static without(relationships) {
-            this.checkArrayOfRelationships('without', relationships);
-            this.$with = this.$with.filter((relationship) => {
-                if (typeof relationship === 'string') {
-                    return !relationships.includes(relationship);
-                }
-                else if (typeof relationship === 'function') {
-                    return relationship;
+        static applyAutoPreload(query) {
+            // Check if auto-preload has been disabled for this specific query instance
+            if (query.$disableAutoPreload)
+                return;
+            const relations = this.$with;
+            if (!Array.isArray(relations))
+                return;
+            // Get list of relations to skip for this specific query
+            const skipList = query.$skipPreloads || [];
+            for (const relation of relations) {
+                if (typeof relation === 'string') {
+                    if (skipList.includes(relation))
+                        continue;
+                    if (relation.includes('.')) {
+                        this.handleNestedPreload(query, relation.split('.'));
+                    }
+                    else {
+                        query.preload(relation);
+                    }
                 }
-                else {
-                    throw WrongArgumentTypeException.invoke(relationship);
+                else if (typeof relation === 'function') {
+                    relation(query);
                 }
-            });
-            return this;
+            }
         }
-        static withOnly(relationships) {
-            this.checkArrayOfRelationships('withOnly', relationships);
-            this.$with = this.$with.filter((relationship) => {
-                if (typeof relationship === 'string') {
-                    return relationships.includes(relationship);
-                }
-                else if (typeof relationship === 'function') {
-                    return relationship;
-                }
-                else {
-                    throw WrongArgumentTypeException.invoke(relationship);
+        static handleNestedPreload(query, parts) {
+            const current = parts.shift();
+            if (!current)
+                return;
+            query.preload(current, (builder) => {
+                if (parts.length > 0) {
+                    this.handleNestedPreload(builder, [...parts]);
                 }
             });
-            return this;
-        }
-        static withoutAny() {
-            this.$with = [];
-            return this;
-        }
-        static handleAutoPreload(query, restorePreloads = true) {
-            const preloads = this.$with;
-            if (preloads.length > 0) {
-                for (const preload of preloads) {
-                    if (typeof preload === 'string') {
-                        if (preload.includes('.')) {
-                            this.handleNestedRelationships(query, preload.split('.'));
-                        }
-                        else {
-                            query.preload(preload);
-                        }
-                    }
-                    else if (typeof preload === 'function') {
-                        preload(query);
-                    }
-                }
-            }
-            if (restorePreloads) {
-                this.$with = [...this.$originalWith];
-            }
         }
         /**
-         * Recursive function to handle nested relationships.
+         * Correct Implementation: Returns the Query Builder to avoid global state pollution
          */
-        static handleNestedRelationships(query, relationships) {
-            if (relationships.length > 0) {
-                const nextRelation = relationships.shift();
-                if (nextRelation) {
-                    query.preload(nextRelation, (qb) => {
-                        if (relationships.length > 0) {
-                            this.handleNestedRelationships(qb, relationships);
-                        }
-                    });
-                }
-            }
+        static without(relations) {
+            const query = this.query();
+            query.$skipPreloads = relations;
+            return query;
         }
-        static checkArrayOfRelationships(method, relationships) {
-            if (relationships.length > 0) {
-                const isWrongType = relationships.every((relationship) => {
-                    return !['function', 'string'].includes(typeof relationship);
-                });
-                if (isWrongType) {
-                    throw WrongArgumentTypeException.invoke(method);
-                }
-            }
+        static withoutAny() {
+            const query = this.query();
+            query.$disableAutoPreload = true;
+            return query;
         }
-    }
-    return AutoPreloadModel;
-};
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codenameryuu/adonis-lucid-auto-preload",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Auto-preload multiple relationships when retrieving Lucid models on Adonis JS 7",
   "author": "codenameryuu",
   "license": "MIT",
@@ -20,6 +20,7 @@
   ],
   "exports": {
     ".": "./build/index.js",
+    "./mixins": "./build/src/mixins/auto_preload.js",
     "./adonis-typings/*": "./build/adonis-typings/*.js",
     "./exceptions/*": "./build/exceptions/*.js",
     "./provider": "./build/providers/auto_preload_provider.js"