@codenameryuu/adonis-lucid-soft-deletes 1.9.0 → 2.0.1

package/LICENSE.md

@@ -1,9 +1,9 @@
-# The MIT License
-
-Copyright (c) 2024 Lookin Anton
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# The MIT License
+
+Copyright (c) 2026 Codename Ryuu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,234 +1,234 @@
-# @codenameryuu/adonis-lucid-soft-deletes
-
-This addon adds the functionality to soft deletes Lucid Models through the `deleted_at` flag in AdonisJS.
-
-## Requirement
-
-- Adonis Js 7
-- Lucid 22 or higher
-
-## Installation
-
-- Install the package
-
-```bash
-yarn add @codenameryuu/adonis-lucid-soft-deletes
-```
-
-- Configure the package
-
-```bash
-node ace configure @codenameryuu/adonis-lucid-soft-deletes
-```
-
-- Make sure to register the provider inside `adonisrc.ts` file.
-
-```typescript
-providers: [
-  // ...
-  () => import('@codenameryuu/adonis-lucid-soft-deletes/provider'),
-],
-```
-
-You should add the `deleted_at` column to your database tables for models with soft deletes.
-
-```typescript
-// migrations/1234566666_users.ts
-import { BaseSchema } from '@adonisjs/lucid/schema'
-
-export default class extends BaseSchema {
-  protected tableName = 'products'
-
-  async up() {
-    this.schema.createTable(this.tableName, (table) => {
-      // ...
-      table.timestamp('deleted_at').nullable()
-    })
-  }
-  // ...
-}
-```
-
-### Applying Soft Deletes to a Model
-
-```typescript
-import { compose } from '@adonisjs/core/helpers'
-import { SoftDeletes } from '@codenameryuu/adonis-lucid-soft-deletes'
-
-export default class Product extends compose(BaseModel, SoftDeletes) {
-  // ...columns and props
-}
-```
-
-Now, when you call the `.delete()` method on the model, the `deleted_at` ( `customDeletedAtColumn` ) column
-will be set to the current date and time. However, the model's database record will be left in the table.
-
-```typescript
-import type { HttpContext } from '@adonisjs/core/http'
-import Product from '#models/product'
-
-export default class ProductsController {
-  /**
-   * Delete product by id
-   * DELETE /products/:id
-   */
-  async destroy({ request, response }: HttpContext) {
-    const product = await Product.findOrFail(request.input('id'))
-    await product.delete()
-
-    return product // or response.noContent()
-  }
-}
-```
-
-> :boom: Soft delete only works for model instances. `await Product.query().delete()` as before
-> will delete models from database
-
-:point_right: When querying a model that uses soft deletes, the soft deleted models
-will automatically be excluded from all query results.
-
-To determine if a given model instance has been soft deleted, you may use the `.trashed` getter:
-
-```typescript
-import type { HttpContext } from '@adonisjs/core/http'
-import Product from '#models/product'
-
-export default class ProductsController {
-  /**
-   * Get product by id
-   * GET /products/:id
-   */
-  async show({ request, response }: HttpContext) {
-    const product = await Product.withTrashed().where('id', request.input('id')).firstOrFail()
-    if (product.trashed) {
-      return response.forbidden()
-    }
-    return product
-  }
-}
-```
-
-### Set custom column name for `deletedAt`
-
-```typescript
-import { compose } from '@adonisjs/core/helpers'
-import { SoftDeletes } from '@codenameryuu/adonis-lucid-soft-deletes'
-
-export default class Product extends compose(BaseModel, SoftDeletes) {
-  // ...columns and props
-
-  @column.dateTime({ columnName: 'customDeletedAtColumn' })
-  declare deletedAt: DateTime | null
-}
-```
-
-### Restoring Soft Deleted Models
-
-To restore a soft deleted model, you may call the `.restore()` method on a model instance.
-Also, method `.restore()` exists after methods `.withTrashed()` and `.onlyTrashed()`
-
-The `restore` method will set the model's `deleted_at` column to `null` :
-
-```ts
-import type { HttpContext } from '@adonisjs/core/http'
-import Product from '#models/product'
-
-export default class TrashProductsController {
-  /**
-   * Update trashed product by id
-   * PUT /trash/products/:id
-   */
-  async update({ request }: HttpContext) {
-    const product = await Product.withTrashed().where('id', request.input('id')).firstOrFail()
-    await product.restore()
-
-    return product
-
-    // or
-
-    await Product.withTrashed().where('id', request.input('id')).restore()
-    await Product.query().withTrashed().where('id', request.input('id')).restore()
-  }
-}
-```
-
-### Permanently Deleting Models
-
-Sometimes you may need to truly remove a model from your database.
-You may use the `.forceDelete()` method to permanently remove a soft deleted model from the database table:
-
-```typescript
-import type { HttpContext } from '@adonisjs/core/http'
-import Product from '#models/product'
-
-export default class ProductsController {
-  /**
-   * Delete product by id
-   * DELETE /products/:id
-   */
-  async destroy({ request, response }: HttpContext) {
-    const product = await Product.findOrFail(request.input('id'))
-    await product.forceDelete()
-
-    return response.noContent()
-  }
-}
-```
-
-### Including Soft Deleted Models
-
-As noted above, soft deleted models will automatically be excluded from query results.
-However, you may force soft deleted models to be included in a query's results
-by calling the `.withTrashed()` method on the model:
-
-```typescript
-import type { HttpContext } from '@adonisjs/core/http'
-import Product from '#models/product'
-
-export default class ProductsController {
-  /**
-   * Get a list products
-   * GET /products?withTrashed=1
-   */
-  async index({ request }: HttpContext) {
-    return Product.query()
-      .if(request.input('withTrashed'), (query) => {
-        query.withTrashed()
-      })
-      .paginate(request.input('page', 1), request.input('perPage', 10))
-  }
-}
-```
-
-### Retrieving only Soft Deleted Models
-
-The `.onlyTrashed()` method will retrieve **only** soft deleted models:
-
-```typescript
-import type { HttpContext } from '@adonisjs/core/http'
-import Product from '#models/product'
-
-export default class TrashProductsController {
-  /**
-   * Get a list trashed products
-   * GET /trash/products
-   */
-  async index({ request }: HttpContext) {
-    return Product.onlyTrashed().paginate(request.input('page', 1), request.input('perPage', 10))
-  }
-}
-```
-
-### Soft Deletes methods
-
-Methods `.withTrashed()` , `.onlyTrashed()` and `.restore()` also available
-in ModelQueryBuilder for models with soft delete, example:
-
-```typescript
-await Product.query().withTrashed().paginate(request.input('page', 1), request.input('perPage', 10))
-await Product.query().onlyTrashed().paginate(request.input('page', 1), request.input('perPage', 10))
-```
-
-## License
-
-This package is open-sourced software licensed under the [MIT license](LICENSE.md).
+# @codenameryuu/adonis-lucid-soft-deletes
+
+This addon adds the functionality to soft deletes Lucid Models through the `deleted_at` flag in AdonisJS.
+
+## Requirement
+
+* Adonis Js 7
+* Lucid 22 or higher
+
+## Installation
+
+* Install the package
+
+```bash
+yarn add @codenameryuu/adonis-lucid-soft-deletes
+```
+
+* Configure the package
+
+```bash
+node ace configure @codenameryuu/adonis-lucid-soft-deletes
+```
+
+* Make sure to register the provider inside `adonisrc.ts` file.
+
+```typescript
+providers: [
+  // ...
+  () => import('@codenameryuu/adonis-lucid-soft-deletes/provider'),
+],
+```
+
+You should add the `deleted_at` column to your database tables for models with soft deletes.
+
+```typescript
+// migrations/1234566666_users.ts
+import { BaseSchema } from '@adonisjs/lucid/schema'
+
+export default class extends BaseSchema {
+  protected tableName = 'products'
+
+  async up() {
+    this.schema.createTable(this.tableName, (table) => {
+      // ...
+      table.timestamp('deleted_at').nullable()
+    })
+  }
+  // ...
+}
+```
+
+### Applying Soft Deletes to a Model
+
+```typescript
+import { compose } from '@adonisjs/core/helpers'
+import { SoftDeletes } from '@codenameryuu/adonis-lucid-soft-deletes'
+
+export default class Product extends compose(BaseModel, SoftDeletes) {
+  // ...columns and props
+}
+```
+
+Now, when you call the `.delete()` method on the model, the `deleted_at` ( `customDeletedAtColumn` ) column
+will be set to the current date and time. However, the model's database record will be left in the table.
+
+```typescript
+import type { HttpContext } from '@adonisjs/core/http'
+import Product from '#models/product'
+
+export default class ProductsController {
+  /**
+   * Delete product by id
+   * DELETE /products/:id
+   */
+  async destroy({ request, response }: HttpContext) {
+    const product = await Product.findOrFail(request.input('id'))
+    await product.delete()
+
+    return product // or response.noContent()
+  }
+}
+```
+
+> :boom: Soft delete only works for model instances. `await Product.query().delete()` as before
+> will delete models from database
+
+:point_right: When querying a model that uses soft deletes, the soft deleted models
+will automatically be excluded from all query results.
+
+To determine if a given model instance has been soft deleted, you may use the `.trashed` getter:
+
+```typescript
+import type { HttpContext } from '@adonisjs/core/http'
+import Product from '#models/product'
+
+export default class ProductsController {
+  /**
+   * Get product by id
+   * GET /products/:id
+   */
+  async show({ request, response }: HttpContext) {
+    const product = await Product.withTrashed().where('id', request.input('id')).firstOrFail()
+    if (product.trashed) {
+      return response.forbidden()
+    }
+    return product
+  }
+}
+```
+
+### Set custom column name for `deletedAt`
+
+```typescript
+import { compose } from '@adonisjs/core/helpers'
+import { SoftDeletes } from '@codenameryuu/adonis-lucid-soft-deletes'
+
+export default class Product extends compose(BaseModel, SoftDeletes) {
+  // ...columns and props
+
+  @column.dateTime({ columnName: 'customDeletedAtColumn' })
+  declare deletedAt: DateTime | null
+}
+```
+
+### Restoring Soft Deleted Models
+
+To restore a soft deleted model, you may call the `.restore()` method on a model instance.
+Also, method `.restore()` exists after methods `.withTrashed()` and `.onlyTrashed()`
+
+The `restore` method will set the model's `deleted_at` column to `null` :
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import Product from '#models/product'
+
+export default class TrashProductsController {
+  /**
+   * Update trashed product by id
+   * PUT /trash/products/:id
+   */
+  async update({ request }: HttpContext) {
+    const product = await Product.withTrashed().where('id', request.input('id')).firstOrFail()
+    await product.restore()
+
+    return product
+
+    // or
+
+    await Product.withTrashed().where('id', request.input('id')).restore()
+    await Product.query().withTrashed().where('id', request.input('id')).restore()
+  }
+}
+```
+
+### Permanently Deleting Models
+
+Sometimes you may need to truly remove a model from your database.
+You may use the `.forceDelete()` method to permanently remove a soft deleted model from the database table:
+
+```typescript
+import type { HttpContext } from '@adonisjs/core/http'
+import Product from '#models/product'
+
+export default class ProductsController {
+  /**
+   * Delete product by id
+   * DELETE /products/:id
+   */
+  async destroy({ request, response }: HttpContext) {
+    const product = await Product.findOrFail(request.input('id'))
+    await product.forceDelete()
+
+    return response.noContent()
+  }
+}
+```
+
+### Including Soft Deleted Models
+
+As noted above, soft deleted models will automatically be excluded from query results.
+However, you may force soft deleted models to be included in a query's results
+by calling the `.withTrashed()` method on the model:
+
+```typescript
+import type { HttpContext } from '@adonisjs/core/http'
+import Product from '#models/product'
+
+export default class ProductsController {
+  /**
+   * Get a list products
+   * GET /products?withTrashed=1
+   */
+  async index({ request }: HttpContext) {
+    return Product.query()
+      .if(request.input('withTrashed'), (query) => {
+        query.withTrashed()
+      })
+      .paginate(request.input('page', 1), request.input('perPage', 10))
+  }
+}
+```
+
+### Retrieving only Soft Deleted Models
+
+The `.onlyTrashed()` method will retrieve **only** soft deleted models:
+
+```typescript
+import type { HttpContext } from '@adonisjs/core/http'
+import Product from '#models/product'
+
+export default class TrashProductsController {
+  /**
+   * Get a list trashed products
+   * GET /trash/products
+   */
+  async index({ request }: HttpContext) {
+    return Product.onlyTrashed().paginate(request.input('page', 1), request.input('perPage', 10))
+  }
+}
+```
+
+### Soft Deletes methods
+
+Methods `.withTrashed()` , `.onlyTrashed()` and `.restore()` also available
+in ModelQueryBuilder for models with soft delete, example:
+
+```typescript
+await Product.query().withTrashed().paginate(request.input('page', 1), request.input('perPage', 10))
+await Product.query().onlyTrashed().paginate(request.input('page', 1), request.input('perPage', 10))
+```
+
+## License
+
+This package is open-sourced software licensed under the [MIT license](LICENSE.md).

package/build/configure.d.ts

@@ -1,2 +1,2 @@
-import type Configure from '@adonisjs/core/commands/configure';
+import type Configure from "@adonisjs/core/commands/configure";
 export declare function configure(command: Configure): Promise<void>;

package/build/configure.js

@@ -1,14 +1,6 @@
-/*
- * adonis-lucid-soft-deletes
- *
- * (c) Lookin Anton <alsd@lookinlab.ru>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
 export async function configure(command) {
     const codemods = await command.createCodemods();
     await codemods.updateRcFile((rcFile) => {
-        rcFile.addProvider('@codenameryuu/adonis-lucid-soft-deletes/provider');
+        rcFile.addProvider("@codenameryuu/adonis-lucid-soft-deletes/provider");
     });
 }

package/build/index.d.ts

@@ -1,2 +1,2 @@
-export { configure } from './configure.js';
-export { SoftDeletes } from './src/mixin.js';
+export { configure } from "./configure.js";
+export { SoftDeletes } from "./src/mixin.js";

package/build/index.js

@@ -1,10 +1,2 @@
-/*
- * adonis-lucid-soft-deletes
- *
- * (c) Lookin Anton <alsd@lookinlab.ru>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export { configure } from './configure.js';
-export { SoftDeletes } from './src/mixin.js';
+export { configure } from "./configure.js";
+export { SoftDeletes } from "./src/mixin.js";

package/build/providers/lucid_soft_deletes_provider.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationService } from '@adonisjs/core/types';
+import type { ApplicationService } from "@adonisjs/core/types";
 export default class LucidSoftDeletesProvider {
     protected app: ApplicationService;
     constructor(app: ApplicationService);

package/build/providers/lucid_soft_deletes_provider.js

@@ -1,19 +1,12 @@
-/*
- * adonis-lucid-soft-deletes
- *
- * (c) Lookin Anton <alsd@lookinlab.ru>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { extendModelQueryBuilder } from '../src/bindings/model_query_builder.js';
+/// <reference path="../src/types/querybuilder.ts" />
+import { extendModelQueryBuilder } from "../src/bindings/model_query_builder.js";
 export default class LucidSoftDeletesProvider {
     app;
     constructor(app) {
         this.app = app;
     }
     async boot() {
-        const { ModelQueryBuilder } = await this.app.import('@adonisjs/lucid/orm');
+        const { ModelQueryBuilder } = await this.app.import("@adonisjs/lucid/orm");
         extendModelQueryBuilder(ModelQueryBuilder);
     }
 }

package/build/src/bindings/model_query_builder.js

@@ -1,19 +1,11 @@
-/*
- * adonis-lucid-soft-deletes
- *
- * (c) Lookin Anton <alsd@lookinlab.ru>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { Exception } from '@adonisjs/core/exceptions';
+import { Exception } from "@adonisjs/core/exceptions";
 /**
  * Raises exception when model not with soft delete
  */
 function ensureModelWithSoftDeletes(model) {
-    if (!('ignoreDeleted' in model && 'ignoreDeletedPaginate' in model)) {
+    if (!("ignoreDeleted" in model && "ignoreDeletedPaginate" in model)) {
         throw new Exception(`${model.name} model don't support Soft Deletes`, {
-            code: 'E_MODEL_SOFT_DELETE',
+            code: "E_MODEL_SOFT_DELETE",
             status: 500,
         });
     }
@@ -22,20 +14,20 @@ function ensureModelWithSoftDeletes(model) {
  * Define SoftDeletes binding to ModelQueryBuilder
  */
 export function extendModelQueryBuilder(builder) {
-    builder.macro('restore', async function () {
+    builder.macro("restore", async function () {
         ensureModelWithSoftDeletes(this.model);
-        const deletedAtColumn = this.model.$getColumn('deletedAt')?.columnName;
+        const deletedAtColumn = this.model.$getColumn("deletedAt")?.columnName;
         if (!deletedAtColumn)
             return;
         await this.update({ [deletedAtColumn]: null });
     });
-    builder.macro('withTrashed', function () {
+    builder.macro("withTrashed", function () {
         ensureModelWithSoftDeletes(this.model);
         return this.model.disableIgnore(this);
     });
-    builder.macro('onlyTrashed', function () {
+    builder.macro("onlyTrashed", function () {
         ensureModelWithSoftDeletes(this.model);
-        const deletedAtColumn = this.model.$getColumn('deletedAt')?.columnName;
+        const deletedAtColumn = this.model.$getColumn("deletedAt")?.columnName;
         return this.model.disableIgnore(this).whereNotNull(`${this.model.table}.${deletedAtColumn}`);
     });
 }

package/build/src/mixin.d.ts

@@ -1,10 +1,10 @@
-import { DateTime } from 'luxon';
-import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
-import type { LucidModel, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import type { QueryClientContract } from '@adonisjs/lucid/types/database';
-import { BaseModel } from '@adonisjs/lucid/orm';
+import { DateTime } from "luxon";
+import type { NormalizeConstructor } from "@adonisjs/core/types/helpers";
+import type { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+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,9 +91,8 @@ 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([countQuery, query]: any): void;
+    ignoreDeletedPaginate<Model extends /*elided*/ any & T>([countQuery, query]: [ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>>, ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>>]): 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
@@ -141,6 +140,7 @@ 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

@@ -1,60 +1,32 @@
-/*
- * adonis-lucid-soft-deletes
- *
- * (c) Lookin Anton <alsd@lookinlab.ru>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { DateTime } from 'luxon';
-import { Exception } from '@adonisjs/core/exceptions';
-import { column } from '@adonisjs/lucid/orm';
+import { DateTime } from "luxon";
+import { Exception } from "@adonisjs/core/exceptions";
+import { column, beforeFind, beforeFetch, beforePaginate } 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;
-            if (!deletedAtColumn) {
+            if (query["ignoreDeleted"] === false) {
                 return;
             }
-            const queryIgnoreDeleted = isGroupLimitQuery ? query.knexQuery : query;
-            /**
-             * Do not prefix with `${model.table}.` since preload/group-limit queries
-             * may use table aliases.
-             */
-            queryIgnoreDeleted.whereNull(deletedAtColumn);
+            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;
+            queryIgnoreDeleted.whereNull(`${query.model.table}.${deletedAtColumn}`);
         }
         static ignoreDeletedPaginate([countQuery, query]) {
-            ;
-            countQuery['ignoreDeleted'] = query['ignoreDeleted'];
+            countQuery["ignoreDeleted"] = query["ignoreDeleted"];
             this.ignoreDeleted(countQuery);
         }
         static disableIgnore(query) {
-            if (query['ignoreDeleted'] === false) {
+            if (query["ignoreDeleted"] === false) {
                 return query;
             }
-            query['ignoreDeleted'] = false;
+            query["ignoreDeleted"] = false;
             return query;
         }
         /**
@@ -69,7 +41,7 @@ export function SoftDeletes(superclass) {
          */
         static onlyTrashed() {
             const query = this.query();
-            const deletedAtColumn = query.model.$getColumn('deletedAt')?.columnName;
+            const deletedAtColumn = query.model.$getColumn("deletedAt")?.columnName;
             return this.disableIgnore(query).whereNotNull(`${query.model.table}.${deletedAtColumn}`);
         }
         /**
@@ -93,10 +65,10 @@ export function SoftDeletes(superclass) {
                 this.deletedAt = DateTime.local();
                 await this.save();
             };
-            if (action === 'delete' && !this.$forceDelete) {
+            if (action === "delete" && !this.$forceDelete) {
                 return { del: softDelete, delete: softDelete };
             }
-            if (action === 'insert') {
+            if (action === "insert") {
                 return super.$getQueryFor(action, client);
             }
             return super.$getQueryFor(action, client);
@@ -113,8 +85,8 @@ export function SoftDeletes(superclass) {
          */
         async restore() {
             if (this.$isDeleted) {
-                throw new Exception('Cannot restore a model instance is was force deleted', {
-                    code: 'E_MODEL_FORCE_DELETED',
+                throw new Exception("Cannot restore a model instance is was force deleted", {
+                    code: "E_MODEL_FORCE_DELETED",
                     status: 500,
                 });
             }
@@ -136,5 +108,12 @@ 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/build/src/types/querybuilder.d.ts

@@ -1,4 +1,4 @@
-declare module '@adonisjs/lucid/types/model' {
+declare module "@adonisjs/lucid/types/model" {
     type ModelWithSoftDeletes = LucidModel & {
         ignoreDeleted(query: any): void;
         ignoreDeletedPaginate([countQuery, query]: [any, any]): void;

package/build/src/types/querybuilder.js

@@ -1,9 +1 @@
-/*
- * adonis-lucid-soft-deletes
- *
- * (c) Lookin Anton <alsd@lookinlab.ru>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
 export {};

package/package.json

@@ -1,108 +1,104 @@
-{
-  "name": "@codenameryuu/adonis-lucid-soft-deletes",
-  "description": "Addon for soft deletes Adonis JS with Lucid ORM",
-  "version": "1.9.0",
-  "author": "codenameryuu",
-  "license": "MIT",
-  "homepage": "https://github.com/codenameryuu/adonis-lucid-soft-deletes#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/codenameryuu/adonis-lucid-soft-deletes.git"
-  },
-  "engines": {
-    "node": ">=24.0.0"
-  },
-  "type": "module",
-  "files": [
-    "build",
-    "!build/bin",
-    "!build/tests"
-  ],
-  "exports": {
-    ".": "./build/index.js",
-    "./types/*": "./build/src/types/*.js",
-    "./bindings": "./build/src/bindings/model_query_builder.js",
-    "./provider": "./build/providers/lucid_soft_deletes_provider.js"
-  },
-  "scripts": {
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "clean": "del-cli build",
-    "precompile": "npm run lint && npm run clean",
-    "compile": "tsc",
-    "build": "npm run compile",
-    "quick:test": "NODE_DEBUG=\"adonis-lucid-soft-deletes\" node --enable-source-maps --loader=ts-node/esm bin/test.ts",
-    "pretest": "npm run lint",
-    "test": "c8 npm run quick:test",
-    "typecheck": "tsc --noEmit",
-    "version": "npm run build",
-    "prepublishOnly": "npm run build",
-    "release": "np"
-  },
-  "devDependencies": {
-    "@adonisjs/assembler": "^7.7.0",
-    "@adonisjs/core": "^7.0.0",
-    "@adonisjs/eslint-config": "^3.0.0",
-    "@adonisjs/lucid": "^22.0.0",
-    "@adonisjs/prettier-config": "^1.4.5",
-    "@adonisjs/tsconfig": "^2.0.0",
-    "@japa/assert": "^4.2.0",
-    "@japa/expect-type": "^2.0.4",
-    "@japa/file-system": "^3.0.0",
-    "@japa/runner": "^5.3.0",
-    "@japa/snapshot": "^2.0.5",
-    "@swc/core": "^1.6.7",
-    "@types/lodash": "^4.17.6",
-    "@types/luxon": "^3.4.2",
-    "@types/node": "^25.5.0",
-    "c8": "^9.1.0",
-    "copyfiles": "^2.4.1",
-    "del-cli": "^5.1.0",
-    "eslint": "^10.0.2",
-    "knex": "^3.1.0",
-    "lodash": "^4.17.23",
-    "luxon": "^3.4.4",
-    "np": "^11.0.2",
-    "prettier": "^3.8.1",
-    "reflect-metadata": "^0.2.2",
-    "ts-node": "^10.9.2",
-    "tsup": "^8.1.0",
-    "typescript": "^5.5.3",
-    "youch": "^4.1.0"
-  },
-  "peerDependencies": {
-    "@adonisjs/core": "^7.0.0",
-    "@adonisjs/lucid": "^22.0.0"
-  },
-  "keywords": [
-    "adonisjs",
-    "adonisjs-lucid",
-    "adonisjs-lucid-soft-deletes",
-    "adonisjs-soft-deletes",
-    "adonis",
-    "adonis-lucid",
-    "adonis-lucid-soft-deletes",
-    "adonis-soft-deletes"
-  ],
-  "publishConfig": {
-    "access": "public",
-    "tag": "latest"
-  },
-  "prettier": "@adonisjs/prettier-config",
-  "np": {
-    "message": "chore(release): %s",
-    "tag": "latest",
-    "branch": "main",
-    "anyBranch": false
-  },
-  "c8": {
-    "reporter": [
-      "text",
-      "html"
-    ],
-    "exclude": [
-      "tests/**",
-      "bin/**"
-    ]
-  }
-}
+{
+  "name": "@codenameryuu/adonis-lucid-soft-deletes",
+  "description": "Addon for soft deletes Adonis JS with Lucid ORM",
+  "version": "2.0.1",
+  "author": "codenameryuu",
+  "license": "MIT",
+  "homepage": "https://github.com/codenameryuu/adonis-lucid-soft-deletes#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codenameryuu/adonis-lucid-soft-deletes.git"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "type": "module",
+  "files": [
+    "build",
+    "!build/bin",
+    "!build/tests"
+  ],
+  "exports": {
+    ".": "./build/index.js",
+    "./types/*": "./build/src/types/*.js",
+    "./bindings": "./build/src/bindings/model_query_builder.js",
+    "./provider": "./build/providers/lucid_soft_deletes_provider.js"
+  },
+  "scripts": {
+    "format": "prettier --write .",
+    "clean": "del-cli build",
+    "precompile": "npm run clean",
+    "compile": "tsc",
+    "build": "npm run compile",
+    "quick:test": "NODE_DEBUG=\"adonis-lucid-soft-deletes\" node --enable-source-maps --loader=ts-node/esm bin/test.ts",
+    "test": "c8 npm run quick:test",
+    "typecheck": "tsc --noEmit",
+    "version": "npm run build",
+    "prepublishOnly": "npm run build",
+    "release": "np"
+  },
+  "devDependencies": {
+    "@adonisjs/assembler": "^7.7.0",
+    "@adonisjs/core": "^7.0.0",
+    "@adonisjs/lucid": "^22.0.0",
+    "@adonisjs/prettier-config": "^1.4.5",
+    "@adonisjs/tsconfig": "^2.0.0",
+    "@japa/assert": "^4.2.0",
+    "@japa/expect-type": "^2.0.4",
+    "@japa/file-system": "^3.0.0",
+    "@japa/runner": "^5.3.0",
+    "@japa/snapshot": "^2.0.5",
+    "@swc/core": "^1.6.7",
+    "@types/lodash": "^4.17.6",
+    "@types/luxon": "^3.4.2",
+    "@types/node": "^25.5.0",
+    "c8": "^9.1.0",
+    "copyfiles": "^2.4.1",
+    "del-cli": "^5.1.0",
+    "knex": "^3.1.0",
+    "lodash": "^4.17.23",
+    "luxon": "^3.4.4",
+    "np": "^11.0.2",
+    "prettier": "^3.8.1",
+    "reflect-metadata": "^0.2.2",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.1.0",
+    "typescript": "^5.5.3",
+    "youch": "^4.1.0"
+  },
+  "peerDependencies": {
+    "@adonisjs/core": "^7.0.0",
+    "@adonisjs/lucid": "^22.0.0"
+  },
+  "keywords": [
+    "adonisjs",
+    "adonisjs-lucid",
+    "adonisjs-lucid-soft-deletes",
+    "adonisjs-soft-deletes",
+    "adonis",
+    "adonis-lucid",
+    "adonis-lucid-soft-deletes",
+    "adonis-soft-deletes"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "prettier": "@adonisjs/prettier-config",
+  "np": {
+    "message": "chore(release): %s",
+    "tag": "latest",
+    "branch": "main",
+    "anyBranch": false
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**",
+      "bin/**"
+    ]
+  }
+}