@codenameryuu/adonis-lucid-auto-preload 1.2.2 → 1.2.4

package/build/adonis-typings/auto-preload.d.ts

@@ -0,0 +1,15 @@
+import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
+import type { LucidModel } from '@adonisjs/lucid/types/model';
+type GetWith<T> = T extends {
+    $with: Array<infer Item>;
+} ? Item extends string ? Item : string : string;
+export interface AutoPreloadMixin {
+    <T extends NormalizeConstructor<LucidModel>>(superclass: T): T & {
+        $with: Array<string | ((query: any) => void)>;
+        without(this: T, relationships: Array<GetWith<T>>): T;
+        withOnly(this: T, relationships: Array<GetWith<T>>): T;
+        withoutAny(this: T): T;
+        new (...args: Array<any>): {};
+    };
+}
+export {};

package/build/adonis-typings/auto-preload.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+import type { AutoPreloadMixin } from './auto-preload';
+declare module '@adonisjs/core/types' {
+    interface ContainerBindings {
+        '@codenameryuu/adonis-lucid-auto-preload': {
+            AutoPreload: AutoPreloadMixin;
+        };
+    }
+}

package/build/adonis-typings/container.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export {};

package/build/adonis-typings/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference path="./auto-preload.ts" />
+/// <reference path="./container.ts" />

package/build/providers/AutoPreloadProvider.d.ts

@@ -0,0 +1,10 @@
+import type { ApplicationService } from "@adonisjs/core/types";
+export default class AutoPreloadProvider {
+    protected app: ApplicationService;
+    static needsApplication: boolean;
+    constructor(app: ApplicationService);
+    register(): void;
+    boot(): Promise<void>;
+    ready(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/build/providers/AutoPreloadProvider.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AutoPreload_1 = require("../src/Mixins/AutoPreload");
+class AutoPreloadProvider {
+    app;
+    static needsApplication = true;
+    constructor(app) {
+        this.app = app;
+    }
+    register() {
+        this.app.container.singleton("@codenameryuu/adonis-lucid-auto-preload", () => {
+            return { AutoPreload: AutoPreload_1.AutoPreload };
+        });
+    }
+    async boot() { }
+    async ready() { }
+    async shutdown() { }
+}
+exports.default = AutoPreloadProvider;

package/build/src/Exceptions/WrongArgumentTypeException.d.ts

@@ -0,0 +1,4 @@
+import { Exception } from '@adonisjs/core/exceptions';
+export default class WrongArgumentTypeException extends Exception {
+    static invoke(method: string): WrongArgumentTypeException;
+}

package/build/src/Exceptions/WrongArgumentTypeException.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const exceptions_1 = require("@adonisjs/core/exceptions");
+class WrongArgumentTypeException extends exceptions_1.Exception {
+    static invoke(method) {
+        return new this(`The method ${method} accepts only an array of strings`);
+    }
+}
+exports.default = WrongArgumentTypeException;

package/build/src/Exceptions/WrongRelationshipTypeException.d.ts

@@ -0,0 +1,4 @@
+import { Exception } from '@adonisjs/core/exceptions';
+export default class WrongRelationshipTypeException extends Exception {
+    static invoke(model: string): WrongRelationshipTypeException;
+}

package/build/src/Exceptions/WrongRelationshipTypeException.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const exceptions_1 = require("@adonisjs/core/exceptions");
+class WrongRelationshipTypeException extends exceptions_1.Exception {
+    static invoke(model) {
+        return new this(`The model "${model}" has wrong relationships to be auto-preloaded. Only string and function types are allowed`);
+    }
+}
+exports.default = WrongRelationshipTypeException;

package/build/src/Mixins/AutoPreload.d.ts

@@ -0,0 +1,11 @@
+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;
+export {};

package/build/src/Mixins/AutoPreload.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoPreload = void 0;
+const WrongRelationshipTypeException_1 = __importDefault(require("../Exceptions/WrongRelationshipTypeException"));
+const WrongArgumentTypeException_1 = __importDefault(require("../Exceptions/WrongArgumentTypeException"));
+const AutoPreload = (superclass) => {
+    class AutoPreloadModel extends superclass {
+        static $with = [];
+        static $originalWith = [];
+        static boot() {
+            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_1.default.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);
+            });
+        }
+        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;
+                }
+                else {
+                    throw WrongArgumentTypeException_1.default.invoke(relationship);
+                }
+            });
+            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_1.default.invoke(relationship);
+                }
+            });
+            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.
+         */
+        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 checkArrayOfRelationships(method, relationships) {
+            if (relationships.length > 0) {
+                const isWrongType = relationships.every((relationship) => {
+                    return !['function', 'string'].includes(typeof relationship);
+                });
+                if (isWrongType) {
+                    throw WrongArgumentTypeException_1.default.invoke(method);
+                }
+            }
+        }
+    }
+    return AutoPreloadModel;
+};
+exports.AutoPreload = AutoPreload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codenameryuu/adonis-lucid-auto-preload",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Auto-preload multiple relationships when retrieving Lucid models on Adonis JS 7",
   "author": "codenameryuu",
   "license": "MIT",
@@ -80,5 +80,9 @@
     "build/providers",
     "build/src",
     "build/instructions.md"
-  ]
+  ],
+  "exports": {
+    ".": "./build/providers/AutoPreloadProvider.js",
+    "./mixins": "./build/src/Mixins/AutoPreload.js"
+  }
 }