@codenameryuu/adonis-lucid-soft-deletes 1.6.0 → 1.8.0

package/build/src/mixin.d.ts

@@ -4,7 +4,7 @@ import type { LucidModel, ModelQueryBuilderContract } from '@adonisjs/lucid/type
 import type { QueryClientContract } from '@adonisjs/lucid/types/database';
 import { BaseModel } from '@adonisjs/lucid/orm';
 type ModelQueryBuilderContractWithIgnoreDeleted<T extends LucidModel, R = InstanceType<T>> = ModelQueryBuilderContract<T, R> & {
-    ignoreDeleted: boolean;
+    ignoreDeleted?: boolean;
 };
 export declare function SoftDeletes<T extends NormalizeConstructor<typeof BaseModel>>(superclass: T): {
     new (...args: any[]): {
@@ -91,8 +91,9 @@ export declare function SoftDeletes<T extends NormalizeConstructor<typeof BaseMo
         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;
     };
+    boot(): void;
     ignoreDeleted<Model extends /*elided*/ any & T>(query: ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>>): void;
-    ignoreDeletedPaginate<Model extends /*elided*/ any & T>([countQuery, query]: [ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>>, ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>>]): void;
+    ignoreDeletedPaginate([countQuery, query]: any): void;
     disableIgnore<Model extends /*elided*/ any & T, Result = InstanceType<Model>>(this: Model, query: ModelQueryBuilderContractWithIgnoreDeleted<Model, Result>): ModelQueryBuilderContractWithIgnoreDeleted<Model, Result>;
     /**
      * Fetch all models without filter by deleted_at
@@ -140,7 +141,6 @@ export declare function SoftDeletes<T extends NormalizeConstructor<typeof BaseMo
         <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;
-    boot: () => 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;

package/build/src/mixin.js

@@ -14,21 +14,35 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { DateTime } from 'luxon';
 import { Exception } from '@adonisjs/core/exceptions';
-import { column, beforeFind, beforeFetch, beforePaginate } from '@adonisjs/lucid/orm';
+import { column } from '@adonisjs/lucid/orm';
 export function SoftDeletes(superclass) {
     class ModelWithSoftDeletes extends superclass {
+        static boot() {
+            super.boot();
+            // `compose()` introduces intermediate classes. Depending on how Lucid handles
+            // boot flags, hooks can be skipped when mixing multiple mixins.
+            // Track hook registration per subclass.
+            if (this.$softDeletesHooksRegistered)
+                return;
+            this.$softDeletesHooksRegistered = true;
+            this.before('find', this.ignoreDeleted.bind(this));
+            this.before('fetch', this.ignoreDeleted.bind(this));
+            this.before('paginate', this.ignoreDeletedPaginate.bind(this));
+        }
         static ignoreDeleted(query) {
             if (query['ignoreDeleted'] === false) {
                 return;
             }
             const isGroupLimitQuery = query.clone().toQuery().includes('adonis_group_limit_counter');
             const deletedAtColumn = query.model.$getColumn('deletedAt')?.columnName;
-            const queryIgnoreDeleted = isGroupLimitQuery
-                ? query.knexQuery['_single'].table
-                : query;
+            if (!deletedAtColumn) {
+                return;
+            }
+            const queryIgnoreDeleted = isGroupLimitQuery ? query.knexQuery : query;
             queryIgnoreDeleted.whereNull(`${query.model.table}.${deletedAtColumn}`);
         }
         static ignoreDeletedPaginate([countQuery, query]) {
+            ;
             countQuery['ignoreDeleted'] = query['ignoreDeleted'];
             this.ignoreDeleted(countQuery);
         }
@@ -118,12 +132,5 @@ export function SoftDeletes(superclass) {
     __decorate([
         column.dateTime()
     ], ModelWithSoftDeletes.prototype, "deletedAt", void 0);
-    __decorate([
-        beforeFind(),
-        beforeFetch()
-    ], ModelWithSoftDeletes, "ignoreDeleted", null);
-    __decorate([
-        beforePaginate()
-    ], ModelWithSoftDeletes, "ignoreDeletedPaginate", null);
     return ModelWithSoftDeletes;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codenameryuu/adonis-lucid-soft-deletes",
   "description": "Addon for soft deletes Adonis JS with Lucid ORM",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "author": "codenameryuu",
   "license": "MIT",
   "homepage": "https://github.com/codenameryuu/adonis-lucid-soft-deletes#readme",