@codenameryuu/adonis-lucid-soft-deletes 1.1.0

package/LICENSE.md

@@ -0,0 +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.

package/README.md

@@ -0,0 +1,266 @@
+# Adonis Lucid Soft Deletes
+
+> Works with AdonisJS v6
+
+Docs for [AdonisJS v5](https://github.com/lookinlab/adonis-lucid-soft-deletes/tree/v1)
+
+[![npm-image]][npm-url] [![license-image]][license-url] [![typescript-image]][typescript-url]
+
+This addon adds the functionality to soft deletes Lucid Models through the `deleted_at` flag
+
+> Works with `@adonisjs/lucid@^21.1.*`
+
+Sometimes use the `deleted_at` flag for soft deletes could be not good way. More [about it](https://brandur.org/soft-deletion)
+
+## Introduction
+
+Sometimes you may wish to "no-delete" a model from database.
+When models are soft deleted, they are not actually removed from your database.
+Instead, a `deleted_at` attribute is set on the model indicating the date
+and time at which the model was "deleted".
+
+:point_right: The SoftDeletes mixin will automatically add the `deleted_at` attribute
+as Luxon / DateTime instance.
+
+## Installation
+
+Install it using `npm`, `yarn` or `pnpm`.
+
+```bash
+# npm
+npm i adonis-lucid-soft-deletes
+
+# yarn
+yarn add adonis-lucid-soft-deletes
+
+# pnpm
+pnpm add adonis-lucid-soft-deletes
+```
+
+After install call `configure`:
+
+```bash
+node ace configure adonis-lucid-soft-deletes
+```
+
+## Usage
+
+Make sure to register the provider inside `adonisrc.ts` file.
+
+```ts
+providers: [
+  // ...
+  () => import('adonis-lucid-soft-deletes/provider'),
+]
+```
+
+You should add the `deleted_at` column to your database tables for models with soft deletes.
+
+```ts
+// migrations/1234566666_users.ts
+import { BaseSchema } from '@adonisjs/lucid/schema'
+
+export default class Users extends BaseSchema {
+  protected tableName = 'users'
+
+  async up() {
+    this.schema.createTable(this.tableName, (table) => {
+      // ...
+      table.timestamp('deleted_at').nullable()
+    })
+  }
+  // ...
+}
+```
+
+### Applying Soft Deletes to a Model
+
+```ts
+import { compose } from '@adonisjs/core/helpers'
+import { SoftDeletes } from 'adonis-lucid-soft-deletes'
+
+export default class User 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.
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import User from '#models/user'
+
+export default class UsersController {
+  /**
+   * Delete user by id
+   * DELETE /users/:id
+   */
+  async destroy({ params, response }: HttpContext) {
+    const user = await User.findOrFail(params.id)
+    await user.delete()
+
+    return user // or response.noContent()
+  }
+}
+```
+
+> :boom: Soft delete only works for model instances. `await User.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:
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import User from '#models/user'
+
+export default class UsersController {
+  /**
+   * Get user by id
+   * GET /users/:id
+   */
+  async show({ params }: HttpContext) {
+    const user = await User.withTrashed().where('id', params.id).firstOrFail()
+    if (user.trashed) {
+      return response.forbidden()
+    }
+    return user
+  }
+}
+```
+
+### Set custom column name for `deletedAt`
+
+```ts
+import { compose } from '@adonisjs/core/helpers'
+import { SoftDeletes } from 'adonis-lucid-soft-deletes'
+
+export default class User 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 User from '#models/user'
+
+export default class TrashUsersController {
+  /**
+   * Update trashed user by id
+   * PUT /trash/users/:id
+   */
+  async update({ params }: HttpContext) {
+    const user = await User.withTrashed().where('id', params.id).firstOrFail()
+    await user.restore()
+
+    return user
+
+    // or
+
+    await User.withTrashed().where('id', params.id).restore()
+    await User.query().withTrashed().where('id', params.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:
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import User from '#models/user'
+
+export default class UsersController {
+  /**
+   * Delete user by id
+   * DELETE /users/:id
+   */
+  async destroy({ params, response }: HttpContext) {
+    const user = await User.findOrFail(params.id)
+    await user.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:
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import User from '#models/user'
+
+export default class UsersController {
+  /**
+   * Get a list users
+   * GET /users?withTrashed=1
+   */
+  async index({ request }: HttpContext) {
+    const usersQuery = request.input('withTrashed') ? User.withTrashed() : User.query()
+
+    return usersQuery.exec()
+
+    // or
+
+    return User.query()
+      .if(request.input('withTrashed'), (query) => {
+        query.withTrashed()
+      })
+      .exec()
+  }
+}
+```
+
+### Retrieving only Soft Deleted Models
+
+The `.onlyTrashed()` method will retrieve **only** soft deleted models:
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import User from '#models/user'
+
+export default class TrashUsersController {
+  /**
+   * Get a list trashed users
+   * GET /trash/users
+   */
+  async index({ request }: HttpContext) {
+    return User.onlyTrashed().exec()
+  }
+}
+```
+
+### Soft Deletes methods
+
+Methods `.withTrashed()`, `.onlyTrashed()` and `.restore()` also available
+in ModelQueryBuilder for models with soft delete, example:
+
+```ts
+await User.query().withTrashed().exec()
+await User.query().onlyTrashed().restore()
+```
+
+[npm-image]: https://img.shields.io/npm/v/adonis-lucid-soft-deletes?logo=npm&style=for-the-badge
+[npm-url]: https://www.npmjs.com/package/adonis-lucid-soft-deletes
+[license-image]: https://img.shields.io/npm/l/adonis-lucid-soft-deletes?style=for-the-badge&color=blueviolet
+[license-url]: https://github.com/lookinlab/adonis-lucid-soft-deletes/blob/develop/LICENSE.md
+[typescript-image]: https://img.shields.io/npm/types/adonis-lucid-soft-deletes?color=294E80&label=%20&logo=typescript&style=for-the-badge
+[typescript-url]: https://github.com/lookinlab

package/build/chunk-4FLDNTDF.js

@@ -0,0 +1,32 @@
+// src/bindings/model_query_builder.ts
+import { Exception } from "@adonisjs/core/exceptions";
+function ensureModelWithSoftDeletes(model) {
+  if (!("ignoreDeleted" in model && "ignoreDeletedPaginate" in model)) {
+    throw new Exception(`${model.name} model don't support Soft Deletes`, {
+      code: "E_MODEL_SOFT_DELETE",
+      status: 500
+    });
+  }
+}
+function extendModelQueryBuilder(builder) {
+  builder.macro("restore", async function() {
+    ensureModelWithSoftDeletes(this.model);
+    const deletedAtColumn = this.model.$getColumn("deletedAt")?.columnName;
+    if (!deletedAtColumn) return;
+    await this.update({ [deletedAtColumn]: null });
+  });
+  builder.macro("withTrashed", function() {
+    ensureModelWithSoftDeletes(this.model);
+    return this.model.disableIgnore(this);
+  });
+  builder.macro("onlyTrashed", function() {
+    ensureModelWithSoftDeletes(this.model);
+    const deletedAtColumn = this.model.$getColumn("deletedAt")?.columnName;
+    return this.model.disableIgnore(this).whereNotNull(`${this.model.table}.${deletedAtColumn}`);
+  });
+}
+
+export {
+  extendModelQueryBuilder
+};
+//# sourceMappingURL=chunk-4FLDNTDF.js.map

package/build/chunk-4FLDNTDF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bindings/model_query_builder.ts"],"sourcesContent":["/*\n * adonis-lucid-soft-deletes\n *\n * (c) Lookin Anton <alsd@lookinlab.ru>\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport type {\n  LucidModel,\n  ModelQueryBuilderContract,\n  ModelWithSoftDeletes,\n} from '@adonisjs/lucid/types/model'\n\nimport { Exception } from '@adonisjs/core/exceptions'\n\n/**\n * Raises exception when model not with soft delete\n */\nfunction ensureModelWithSoftDeletes(model: LucidModel) {\n  if (!('ignoreDeleted' in model && 'ignoreDeletedPaginate' in model)) {\n    throw new Exception(`${model.name} model don't support Soft Deletes`, {\n      code: 'E_MODEL_SOFT_DELETE',\n      status: 500,\n    })\n  }\n}\n\n/**\n * Define SoftDeletes binding to ModelQueryBuilder\n */\nexport function extendModelQueryBuilder(builder: any) {\n  builder.macro('restore', async function (this: ModelQueryBuilderContract<LucidModel>) {\n    ensureModelWithSoftDeletes(this.model)\n\n    const deletedAtColumn = this.model.$getColumn('deletedAt')?.columnName\n    if (!deletedAtColumn) return\n\n    await this.update({ [deletedAtColumn]: null })\n  })\n\n  builder.macro('withTrashed', function (this: ModelQueryBuilderContract<ModelWithSoftDeletes>) {\n    ensureModelWithSoftDeletes(this.model)\n    return this.model.disableIgnore(this)\n  })\n\n  builder.macro('onlyTrashed', function (this: ModelQueryBuilderContract<ModelWithSoftDeletes>) {\n    ensureModelWithSoftDeletes(this.model)\n\n    const deletedAtColumn = this.model.$getColumn('deletedAt')?.columnName\n    return this.model.disableIgnore(this).whereNotNull(`${this.model.table}.${deletedAtColumn}`)\n  })\n}\n"],"mappings":";AAeA,SAAS,iBAAiB;AAK1B,SAAS,2BAA2B,OAAmB;AACrD,MAAI,EAAE,mBAAmB,SAAS,2BAA2B,QAAQ;AACnE,UAAM,IAAI,UAAU,GAAG,MAAM,IAAI,qCAAqC;AAAA,MACpE,MAAM;AAAA,MACN,QAAQ;AAAA,IACV,CAAC;AAAA,EACH;AACF;AAKO,SAAS,wBAAwB,SAAc;AACpD,UAAQ,MAAM,WAAW,iBAA6D;AACpF,+BAA2B,KAAK,KAAK;AAErC,UAAM,kBAAkB,KAAK,MAAM,WAAW,WAAW,GAAG;AAC5D,QAAI,CAAC,gBAAiB;AAEtB,UAAM,KAAK,OAAO,EAAE,CAAC,eAAe,GAAG,KAAK,CAAC;AAAA,EAC/C,CAAC;AAED,UAAQ,MAAM,eAAe,WAAiE;AAC5F,+BAA2B,KAAK,KAAK;AACrC,WAAO,KAAK,MAAM,cAAc,IAAI;AAAA,EACtC,CAAC;AAED,UAAQ,MAAM,eAAe,WAAiE;AAC5F,+BAA2B,KAAK,KAAK;AAErC,UAAM,kBAAkB,KAAK,MAAM,WAAW,WAAW,GAAG;AAC5D,WAAO,KAAK,MAAM,cAAc,IAAI,EAAE,aAAa,GAAG,KAAK,MAAM,KAAK,IAAI,eAAe,EAAE;AAAA,EAC7F,CAAC;AACH;","names":[]}

package/build/chunk-EUXUH3YW.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+export {
+  __decorateClass
+};
+//# sourceMappingURL=chunk-EUXUH3YW.js.map

package/build/chunk-EUXUH3YW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/configure.d.ts

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

package/build/index.d.ts

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

package/build/index.js

@@ -0,0 +1,128 @@
+import {
+  __decorateClass
+} from "./chunk-EUXUH3YW.js";
+
+// configure.ts
+async function configure(command) {
+  const codemods = await command.createCodemods();
+  await codemods.updateRcFile((rcFile) => {
+    rcFile.addProvider("@codenameryuu/adonis-lucid-soft-deletes/provider");
+  });
+}
+
+// src/mixin.ts
+import { DateTime } from "luxon";
+import { Exception } from "@adonisjs/core/exceptions";
+import { column, beforeFind, beforeFetch, beforePaginate } from "@adonisjs/lucid/orm";
+function SoftDeletes(superclass) {
+  class ModelWithSoftDeletes extends superclass {
+    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;
+      queryIgnoreDeleted.whereNull(`${query.model.table}.${deletedAtColumn}`);
+    }
+    static ignoreDeletedPaginate([countQuery, query]) {
+      countQuery["ignoreDeleted"] = query["ignoreDeleted"];
+      this.ignoreDeleted(countQuery);
+    }
+    static disableIgnore(query) {
+      if (query["ignoreDeleted"] === false) {
+        return query;
+      }
+      query["ignoreDeleted"] = false;
+      return query;
+    }
+    /**
+     * Fetch all models without filter by deleted_at
+     */
+    static withTrashed() {
+      const query = this.query();
+      return this.disableIgnore(query);
+    }
+    /**
+     * Fetch models only with deleted_at
+     */
+    static onlyTrashed() {
+      const query = this.query();
+      const deletedAtColumn = query.model.$getColumn("deletedAt")?.columnName;
+      return this.disableIgnore(query).whereNotNull(`${query.model.table}.${deletedAtColumn}`);
+    }
+    /**
+     * Force delete instance property
+     */
+    $forceDelete = false;
+    /**
+     * Computed trashed property
+     */
+    get trashed() {
+      return this.deletedAt !== null;
+    }
+    /**
+     * Override default $getQueryFor method
+     */
+    $getQueryFor(action, client) {
+      const softDelete = async () => {
+        this.deletedAt = DateTime.local();
+        await this.save();
+      };
+      if (action === "delete" && !this.$forceDelete) {
+        return { del: softDelete, delete: softDelete };
+      }
+      if (action === "insert") {
+        return super.$getQueryFor(action, client);
+      }
+      return super.$getQueryFor(action, client);
+    }
+    /**
+     * Override default delete method
+     */
+    async delete() {
+      await super.delete();
+      this.$isDeleted = this.$forceDelete;
+    }
+    /**
+     * Restore model
+     */
+    async restore() {
+      if (this.$isDeleted) {
+        throw new Exception("Cannot restore a model instance is was force deleted", {
+          code: "E_MODEL_FORCE_DELETED",
+          status: 500
+        });
+      }
+      if (!this.trashed) {
+        return this;
+      }
+      this.deletedAt = null;
+      await this.save();
+      return this;
+    }
+    /**
+     * Force delete model
+     */
+    async forceDelete() {
+      this.$forceDelete = true;
+      await this.delete();
+    }
+  }
+  __decorateClass([
+    column.dateTime()
+  ], ModelWithSoftDeletes.prototype, "deletedAt", 2);
+  __decorateClass([
+    beforeFind(),
+    beforeFetch()
+  ], ModelWithSoftDeletes, "ignoreDeleted", 1);
+  __decorateClass([
+    beforePaginate()
+  ], ModelWithSoftDeletes, "ignoreDeletedPaginate", 1);
+  return ModelWithSoftDeletes;
+}
+export {
+  SoftDeletes,
+  configure
+};
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../configure.ts","../src/mixin.ts"],"sourcesContent":["/*\n * adonis-lucid-soft-deletes\n *\n * (c) Lookin Anton <alsd@lookinlab.ru>\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport type Configure from '@adonisjs/core/commands/configure'\n\nexport async function configure(command: Configure) {\n  const codemods = await command.createCodemods()\n\n  await codemods.updateRcFile((rcFile) => {\n    rcFile.addProvider('@codenameryuu/adonis-lucid-soft-deletes/provider')\n  })\n}\n","/*\n * adonis-lucid-soft-deletes\n *\n * (c) Lookin Anton <alsd@lookinlab.ru>\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport { DateTime } from 'luxon'\nimport type { NormalizeConstructor } from '@adonisjs/core/types/helpers'\nimport type { LucidModel, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model'\nimport type { QueryClientContract } from '@adonisjs/lucid/types/database'\nimport { Exception } from '@adonisjs/core/exceptions'\nimport { column, beforeFind, beforeFetch, beforePaginate, BaseModel } from '@adonisjs/lucid/orm'\n\ntype ModelQueryBuilderContractWithIgnoreDeleted<\n  T extends LucidModel,\n  R = InstanceType<T>,\n> = ModelQueryBuilderContract<T, R> & {\n  ignoreDeleted: boolean\n}\n\nexport function SoftDeletes<T extends NormalizeConstructor<typeof BaseModel>>(superclass: T) {\n  class ModelWithSoftDeletes extends superclass {\n    @beforeFind()\n    @beforeFetch()\n    static ignoreDeleted<Model extends typeof ModelWithSoftDeletes>(\n      query: ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>>\n    ): void {\n      if (query['ignoreDeleted'] === false) {\n        return\n      }\n      const isGroupLimitQuery = query.clone().toQuery().includes('adonis_group_limit_counter')\n      const deletedAtColumn = query.model.$getColumn('deletedAt')?.columnName\n\n      const queryIgnoreDeleted = isGroupLimitQuery\n        ? (query.knexQuery as any)['_single'].table\n        : query\n\n      queryIgnoreDeleted.whereNull(`${query.model.table}.${deletedAtColumn}`)\n    }\n\n    @beforePaginate()\n    static ignoreDeletedPaginate<Model extends typeof ModelWithSoftDeletes>([countQuery, query]: [\n      ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>>,\n      ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>>,\n    ]): void {\n      countQuery['ignoreDeleted'] = query['ignoreDeleted']\n      this.ignoreDeleted(countQuery)\n    }\n\n    static disableIgnore<Model extends typeof ModelWithSoftDeletes, Result = InstanceType<Model>>(\n      this: Model,\n      query: ModelQueryBuilderContractWithIgnoreDeleted<Model, Result>\n    ): ModelQueryBuilderContractWithIgnoreDeleted<Model, Result> {\n      if (query['ignoreDeleted'] === false) {\n        return query\n      }\n      query['ignoreDeleted'] = false\n      return query\n    }\n\n    /**\n     * Fetch all models without filter by deleted_at\n     */\n    static withTrashed<Model extends typeof ModelWithSoftDeletes>(\n      this: Model\n    ): ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<T>> {\n      const query = this.query() as ModelQueryBuilderContractWithIgnoreDeleted<\n        Model,\n        InstanceType<Model>\n      >\n      return this.disableIgnore(query)\n    }\n\n    /**\n     * Fetch models only with deleted_at\n     */\n    static onlyTrashed<Model extends typeof ModelWithSoftDeletes>(\n      this: Model\n    ): ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>> {\n      const query = this.query() as ModelQueryBuilderContractWithIgnoreDeleted<\n        Model,\n        InstanceType<Model>\n      >\n\n      const deletedAtColumn = query.model.$getColumn('deletedAt')?.columnName\n      return this.disableIgnore(query).whereNotNull(`${query.model.table}.${deletedAtColumn}`)\n    }\n\n    /**\n     * Force delete instance property\n     */\n    $forceDelete = false\n\n    /**\n     * Soft deleted property\n     */\n    @column.dateTime()\n    declare deletedAt?: DateTime | null\n\n    /**\n     * Computed trashed property\n     */\n    get trashed(): boolean {\n      return this.deletedAt !== null\n    }\n\n    /**\n     * Override default $getQueryFor method\n     */\n    $getQueryFor(\n      action: 'insert' | 'update' | 'delete' | 'refresh',\n      client: QueryClientContract\n    ): any {\n      /**\n       * Soft Delete\n       */\n      const softDelete = async (): Promise<void> => {\n        this.deletedAt = DateTime.local()\n        await this.save()\n      }\n\n      if (action === 'delete' && !this.$forceDelete) {\n        return { del: softDelete, delete: softDelete }\n      }\n      if (action === 'insert') {\n        return super.$getQueryFor(action, client)\n      }\n      return super.$getQueryFor(action, client)\n    }\n\n    /**\n     * Override default delete method\n     */\n    async delete(): Promise<void> {\n      await super.delete()\n      this.$isDeleted = this.$forceDelete\n    }\n\n    /**\n     * Restore model\n     */\n    async restore(): Promise<this> {\n      if (this.$isDeleted) {\n        throw new Exception('Cannot restore a model instance is was force deleted', {\n          code: 'E_MODEL_FORCE_DELETED',\n          status: 500,\n        })\n      }\n      if (!this.trashed) {\n        return this\n      }\n      this.deletedAt = null\n      await this.save()\n\n      return this\n    }\n\n    /**\n     * Force delete model\n     */\n    async forceDelete(): Promise<void> {\n      this.$forceDelete = true\n      await this.delete()\n    }\n  }\n  return ModelWithSoftDeletes\n}\n"],"mappings":";;;;;AAWA,eAAsB,UAAU,SAAoB;AAClD,QAAM,WAAW,MAAM,QAAQ,eAAe;AAE9C,QAAM,SAAS,aAAa,CAAC,WAAW;AACtC,WAAO,YAAY,kDAAkD;AAAA,EACvE,CAAC;AACH;;;ACRA,SAAS,gBAAgB;AAIzB,SAAS,iBAAiB;AAC1B,SAAS,QAAQ,YAAY,aAAa,sBAAiC;AASpE,SAAS,YAA8D,YAAe;AAAA,EAC3F,MAAM,6BAA6B,WAAW;AAAA,IAG5C,OAAO,cACL,OACM;AACN,UAAI,MAAM,eAAe,MAAM,OAAO;AACpC;AAAA,MACF;AACA,YAAM,oBAAoB,MAAM,MAAM,EAAE,QAAQ,EAAE,SAAS,4BAA4B;AACvF,YAAM,kBAAkB,MAAM,MAAM,WAAW,WAAW,GAAG;AAE7D,YAAM,qBAAqB,oBACtB,MAAM,UAAkB,SAAS,EAAE,QACpC;AAEJ,yBAAmB,UAAU,GAAG,MAAM,MAAM,KAAK,IAAI,eAAe,EAAE;AAAA,IACxE;AAAA,IAGA,OAAO,sBAAiE,CAAC,YAAY,KAAK,GAGjF;AACP,iBAAW,eAAe,IAAI,MAAM,eAAe;AACnD,WAAK,cAAc,UAAU;AAAA,IAC/B;AAAA,IAEA,OAAO,cAEL,OAC2D;AAC3D,UAAI,MAAM,eAAe,MAAM,OAAO;AACpC,eAAO;AAAA,MACT;AACA,YAAM,eAAe,IAAI;AACzB,aAAO;AAAA,IACT;AAAA;AAAA;AAAA;AAAA,IAKA,OAAO,cAE+D;AACpE,YAAM,QAAQ,KAAK,MAAM;AAIzB,aAAO,KAAK,cAAc,KAAK;AAAA,IACjC;AAAA;AAAA;AAAA;AAAA,IAKA,OAAO,cAEmE;AACxE,YAAM,QAAQ,KAAK,MAAM;AAKzB,YAAM,kBAAkB,MAAM,MAAM,WAAW,WAAW,GAAG;AAC7D,aAAO,KAAK,cAAc,KAAK,EAAE,aAAa,GAAG,MAAM,MAAM,KAAK,IAAI,eAAe,EAAE;AAAA,IACzF;AAAA;AAAA;AAAA;AAAA,IAKA,eAAe;AAAA;AAAA;AAAA;AAAA,IAWf,IAAI,UAAmB;AACrB,aAAO,KAAK,cAAc;AAAA,IAC5B;AAAA;AAAA;AAAA;AAAA,IAKA,aACE,QACA,QACK;AAIL,YAAM,aAAa,YAA2B;AAC5C,aAAK,YAAY,SAAS,MAAM;AAChC,cAAM,KAAK,KAAK;AAAA,MAClB;AAEA,UAAI,WAAW,YAAY,CAAC,KAAK,cAAc;AAC7C,eAAO,EAAE,KAAK,YAAY,QAAQ,WAAW;AAAA,MAC/C;AACA,UAAI,WAAW,UAAU;AACvB,eAAO,MAAM,aAAa,QAAQ,MAAM;AAAA,MAC1C;AACA,aAAO,MAAM,aAAa,QAAQ,MAAM;AAAA,IAC1C;AAAA;AAAA;AAAA;AAAA,IAKA,MAAM,SAAwB;AAC5B,YAAM,MAAM,OAAO;AACnB,WAAK,aAAa,KAAK;AAAA,IACzB;AAAA;AAAA;AAAA;AAAA,IAKA,MAAM,UAAyB;AAC7B,UAAI,KAAK,YAAY;AACnB,cAAM,IAAI,UAAU,wDAAwD;AAAA,UAC1E,MAAM;AAAA,UACN,QAAQ;AAAA,QACV,CAAC;AAAA,MACH;AACA,UAAI,CAAC,KAAK,SAAS;AACjB,eAAO;AAAA,MACT;AACA,WAAK,YAAY;AACjB,YAAM,KAAK,KAAK;AAEhB,aAAO;AAAA,IACT;AAAA;AAAA;AAAA;AAAA,IAKA,MAAM,cAA6B;AACjC,WAAK,eAAe;AACpB,YAAM,KAAK,OAAO;AAAA,IACpB;AAAA,EACF;AAnEU;AAAA,IADP,OAAO,SAAS;AAAA,KA3Eb,qBA4EI;AAzED;AAAA,IAFN,WAAW;AAAA,IACX,YAAY;AAAA,KAFT,sBAGG;AAiBA;AAAA,IADN,eAAe;AAAA,KAnBZ,sBAoBG;AA4HT,SAAO;AACT;","names":[]}

package/build/providers/lucid_soft_deletes_provider.d.ts

@@ -0,0 +1,6 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+export default class LucidSoftDeletesProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    boot(): Promise<void>;
+}

package/build/providers/lucid_soft_deletes_provider.js

@@ -0,0 +1,19 @@
+import {
+  extendModelQueryBuilder
+} from "../chunk-4FLDNTDF.js";
+import "../chunk-EUXUH3YW.js";
+
+// providers/lucid_soft_deletes_provider.ts
+var LucidSoftDeletesProvider = class {
+  constructor(app) {
+    this.app = app;
+  }
+  async boot() {
+    const { ModelQueryBuilder } = await this.app.import("@adonisjs/lucid/orm");
+    extendModelQueryBuilder(ModelQueryBuilder);
+  }
+};
+export {
+  LucidSoftDeletesProvider as default
+};
+//# sourceMappingURL=lucid_soft_deletes_provider.js.map

package/build/providers/lucid_soft_deletes_provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../providers/lucid_soft_deletes_provider.ts"],"sourcesContent":["/*\n * adonis-lucid-soft-deletes\n *\n * (c) Lookin Anton <alsd@lookinlab.ru>\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\n/// <reference path=\"../src/types/querybuilder.ts\" />\n\nimport type { ApplicationService } from '@adonisjs/core/types'\nimport { extendModelQueryBuilder } from '../src/bindings/model_query_builder.js'\n\nexport default class LucidSoftDeletesProvider {\n  constructor(protected app: ApplicationService) {}\n\n  async boot() {\n    const { ModelQueryBuilder } = await this.app.import('@adonisjs/lucid/orm')\n    extendModelQueryBuilder(ModelQueryBuilder)\n  }\n}\n"],"mappings":";;;;;;AAcA,IAAqB,2BAArB,MAA8C;AAAA,EAC5C,YAAsB,KAAyB;AAAzB;AAAA,EAA0B;AAAA,EAEhD,MAAM,OAAO;AACX,UAAM,EAAE,kBAAkB,IAAI,MAAM,KAAK,IAAI,OAAO,qBAAqB;AACzE,4BAAwB,iBAAiB;AAAA,EAC3C;AACF;","names":[]}

package/build/src/bindings/model_query_builder.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Define SoftDeletes binding to ModelQueryBuilder
+ */
+export declare function extendModelQueryBuilder(builder: any): void;

package/build/src/bindings/model_query_builder.js

@@ -0,0 +1,8 @@
+import {
+  extendModelQueryBuilder
+} from "../../chunk-4FLDNTDF.js";
+import "../../chunk-EUXUH3YW.js";
+export {
+  extendModelQueryBuilder
+};
+//# sourceMappingURL=model_query_builder.js.map

package/build/src/bindings/model_query_builder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/src/mixin.d.ts

@@ -0,0 +1,186 @@
+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;
+};
+export declare function SoftDeletes<T extends NormalizeConstructor<typeof BaseModel>>(superclass: T): {
+    new (...args: any[]): {
+        /**
+         * Force delete instance property
+         */
+        $forceDelete: boolean;
+        /**
+         * Soft deleted property
+         */
+        deletedAt?: DateTime | null;
+        /**
+         * Computed trashed property
+         */
+        get trashed(): boolean;
+        /**
+         * Override default $getQueryFor method
+         */
+        $getQueryFor(action: "insert" | "update" | "delete" | "refresh", client: QueryClientContract): any;
+        /**
+         * Override default delete method
+         */
+        delete(): Promise<void>;
+        /**
+         * Restore model
+         */
+        restore(): Promise</*elided*/ any>;
+        /**
+         * Force delete model
+         */
+        forceDelete(): Promise<void>;
+        $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;
+        $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?: "$forceDelete" | "deletedAt" | "trashed" | ("$forceDelete" | "deletedAt" | "trashed" | 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>;
+        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;
+    };
+    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;
+    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
+     */
+    withTrashed<Model extends /*elided*/ any & T>(this: Model): ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<T>>;
+    /**
+     * Fetch models only with deleted_at
+     */
+    onlyTrashed<Model extends /*elided*/ any & T>(this: Model): ModelQueryBuilderContractWithIgnoreDeleted<Model, InstanceType<Model>>;
+    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;
+    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;
+        <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/types/querybuilder.d.ts

@@ -0,0 +1,18 @@
+declare module '@adonisjs/lucid/types/model' {
+    type ModelWithSoftDeletes = LucidModel & {
+        ignoreDeleted(query: any): void;
+        ignoreDeletedPaginate([countQuery, query]: [any, any]): void;
+        disableIgnore(query: any): any;
+    };
+    type ExcludeSoftDeletesMethods<Methods, Model> = {
+        [Method in keyof Methods]: Model extends ModelWithSoftDeletes ? Methods[Method] : never;
+    };
+    type SoftDeletesMethods<Model extends LucidModel> = {
+        withTrashed(): ModelQueryBuilderContract<Model>;
+        onlyTrashed(): ModelQueryBuilderContract<Model>;
+        restore(): Promise<void>;
+    };
+    interface ModelQueryBuilderContract<Model extends LucidModel, Result = InstanceType<Model>> extends ExcludeSoftDeletesMethods<SoftDeletesMethods<Model>, Model> {
+    }
+}
+export {};

package/build/src/types/querybuilder.js

@@ -0,0 +1 @@
+//# sourceMappingURL=querybuilder.js.map

package/build/src/types/querybuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@codenameryuu/adonis-lucid-soft-deletes",
+  "description": "Addon for soft deletes Adonis JS 7 Lucid ORM",
+  "version": "1.1.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": "tsup-node && tsc --emitDeclarationOnly --declaration",
+    "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/**"
+    ]
+  },
+  "tsup": {
+    "entry": [
+      "./index.ts",
+      "./src/types/*.ts",
+      "./src/bindings/model_query_builder.ts",
+      "./providers/lucid_soft_deletes_provider.ts"
+    ],
+    "outDir": "./build",
+    "clean": true,
+    "format": "esm",
+    "dts": false,
+    "sourcemap": true,
+    "target": "esnext"
+  }
+}