@codenameryuu/adonis-lucid-filter 3.1.0 → 3.2.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,218 +1,218 @@
-# @codenameryuu/adonis-lucid-filter
-
-This addon adds the functionality to filter Lucid Models Adonis JS 7. Inspired by [EloquentFilter](https://github.com/Tucker-Eric/EloquentFilter)
-
-## Requirement
-
-- Adonis Js 7
-- Lucid 22 or higher
-
-## Installation
-
-- Install the package
-
-```bash
-yarn add @codenameryuu/adonis-lucid-filter
-```
-
-- Configure the package
-
-```bash
-node ace configure @codenameryuu/adonis-lucid-filter
-```
-
-- Make sure to register the provider inside `adonisrc.ts` file.
-
-```typescript
-providers: [
-  // ...
-  () => import('@codenameryuu/adonis-lucid-filter/provider'),
-],
-commands: [
-  // ...
-  () => import('@codenameryuu/adonis-lucid-filter/commands')
-]
-```
-
-## Usage
-
-You can create a model filter with the following ace command:
-
-```bash
-node ace make:filter product
-```
-
-Where `product` is the Lucid Model you are creating the filter for. This will create `app/models/filters/product_filter.ts`
-
-### Defining The Filter Logic
-
-Define the filter logic based on the camel cased input key passed to the `filter()` method.
-
-- Empty strings are ignored
-- `setup()` will be called regardless of input
-- `_id` is dropped from the end of the input to define the method so filtering `product_id` would use the `product()` method
-- Input without a corresponding filter method are ignored
-- The value of the key is injected into the method
-- All values are accessible through the `this.$input` a property
-- All QueryBuilder methods are accessible in `this.$query` object in the model filter class.
-
-To define methods for the following input:
-
-```json
-{
-  "productCategoryId": 1,
-  "name": "Car",
-  "price": 100000
-}
-```
-
-You would use the following methods:
-
-```typescript
-import { BaseModelFilter } from '@codenameryuu/adonis-lucid-filter'
-import type { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model'
-import Product from '#models/product'
-
-export default class ProductFilter extends BaseModelFilter {
-  declare $query: ModelQueryBuilderContract<typeof Product>
-
-  // Blacklisted methods
-  static blacklist: string[] = ['secretMethod']
-
-  // Dropped `_id` from the end of the input
-  // Doing this would allow you to have a `company()` filter method as well as a `companyId()` filter method.
-  static dropId: boolean = true
-
-  // Doing this would allow you to have a mobile_phone() filter method instead of mobilePhone().
-  // By default, mobilePhone() filter method can be called thanks to one of the following input key:
-  // mobile_phone, mobilePhone, mobile_phone_id, mobilePhoneId
-  static camelCase: boolean = true
-
-  // This will filter 'productCategoryId', 'product_category_id' OR 'productCategory'
-  productCategory(id: number) {
-    this.$query.where('product_category_id', id)
-  }
-
-  name(name: string) {
-    this.$query.where('name', 'LIKE', `%${name}%`)
-  }
-
-  price(price: number) {
-    this.$query.where('price', price)
-  }
-
-  secretMethod(secretParameter: any) {
-    this.$query.where('some_column', true)
-  }
-}
-```
-
-#### Blacklist
-
-Any methods defined in the `blacklist` array will not be called by the filter.
-Those methods are normally used for internal filter logic.
-
-The `whitelistMethod()` methods can be used to dynamically blacklist methods.
-
-Example:
-
-```typescript
-setup($query) {
-  this.whitelistMethod('secretMethod')
-  this.$query.where('is_admin', true)
-}
-```
-
-> `setup()` not may be async
-
-> **Note:** All methods inside `setup()` will be called every time `filter()` is called on the model
-
-In the example above `secretMethod()` will not be called, even if there is a `secret_method` key in the input object.
-In order to call this method it would need to be whitelisted dynamically:
-
-### Applying The Filter To A Model
-
-```typescript
-import { compose } from '@adonisjs/core/helpers'
-import { Filterable } from '@codenameryuu/adonis-lucid-filter'
-
-import ProductFilter from '#models/filters/product_filter'
-
-export default class Product extends compose(BaseModel, Filterable) {
-  static $filter = () => ProductFilter
-
-  // ...columns and props
-}
-```
-
-This gives you access to the `filter()` method that accepts an object of input:
-
-```typescript
-import type { HttpContext } from '@adonisjs/core/http'
-import Product from '#models/product'
-
-export default class ProductsController {
-  async index({ request }: HttpContext): Promise<Product[]> {
-    return Product.filter(request.all()).orderBy('created_at', 'desc')
-  }
-
-  // or with paginate method
-
-  async index({ request }: HttpContext): Promise<ModelPaginatorContract<Product>> {
-    return Product.filter(request.all()).paginate(1, 10)
-  }
-}
-```
-
-### Dynamic Filters
-
-You can define the filter dynamically by passing the filter to use as the second parameter of the filter() method.
-Defining a filter dynamically will take precedent over any other filters defined for the model.
-
-```typescript
-import type { HttpContext } from '@adonisjs/core/http'
-import ProductFilter from '#models/filters/product_filter'
-import ProductExclusiveFilter from '#models/filters/product_exclusive_filter'
-
-export default class ProductsController {
-  async index({ request, auth }: HttpContext): Promise<Product[]> {
-    const filter = auth.user.isAdmin() ? ProductFilter : ProductExclusiveFilter
-    return Product.filter(request.all(), filter).orderBy('created_at', 'desc')
-  }
-}
-```
-
-### Filtering relations
-
-For filtering relations of model may be use `.query().filter()` or scope `filtration` , example:
-
-```typescript
-import type { HttpContext } from '@adonisjs/core/http'
-import ProductCategory from '#models/product_category'
-
-export default class ProductCategoriesController {
-  /**
-   * Get a list products of product category
-   * GET /product-categories/:product_category_id/products
-   */
-  async index({ params, request }: HttpContext): Promise<Product[]> {
-    const productCategory: ProductCategory = await ProductCategory.findOrFail(
-      params.product_category_id
-    )
-
-    return productCategory
-      .related('products')
-      .query()
-      .filter(request.all())
-      .orderBy('created_at', 'desc')
-  }
-}
-```
-
-Documentation by [Query Scopes](https://lucid.adonisjs.com/docs/model-query-scopes)
-
-**Note:** The relation model must be `Filterable` and `$filter` must be defined in it
-
-## License
-
-This project is [MIT](https://github.com/codenameryuu/adonis-lucid-filter/blob/master/LICENSE.md) licensed.
+# @codenameryuu/adonis-lucid-filter
+
+This addon adds the functionality to filter Lucid Models Adonis JS 7. Inspired by [EloquentFilter](https://github.com/Tucker-Eric/EloquentFilter)
+
+## Requirement
+
+* Adonis Js 7
+* Lucid 22 or higher
+
+## Installation
+
+* Install the package
+
+```bash
+yarn add @codenameryuu/adonis-lucid-filter
+```
+
+* Configure the package
+
+```bash
+node ace configure @codenameryuu/adonis-lucid-filter
+```
+
+* Make sure to register the provider inside `adonisrc.ts` file.
+
+```typescript
+providers: [
+  // ...
+  () => import('@codenameryuu/adonis-lucid-filter/provider'),
+],
+commands: [
+  // ...
+  () => import('@codenameryuu/adonis-lucid-filter/commands')
+]
+```
+
+## Usage
+
+You can create a model filter with the following ace command:
+
+```bash
+node ace make:filter product
+```
+
+Where `product` is the Lucid Model you are creating the filter for. This will create `app/models/filters/product_filter.ts`
+
+### Defining The Filter Logic
+
+Define the filter logic based on the camel cased input key passed to the `filter()` method.
+
+* Empty strings are ignored
+* `setup()` will be called regardless of input
+* `_id` is dropped from the end of the input to define the method so filtering `product_id` would use the `product()` method
+* Input without a corresponding filter method are ignored
+* The value of the key is injected into the method
+* All values are accessible through the `this.$input` a property
+* All QueryBuilder methods are accessible in `this.$query` object in the model filter class.
+
+To define methods for the following input:
+
+```json
+{
+  "productCategoryId": 1,
+  "name": "Car",
+  "price": 100000
+}
+```
+
+You would use the following methods:
+
+```typescript
+import { BaseModelFilter } from '@codenameryuu/adonis-lucid-filter'
+import type { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model'
+import Product from '#models/product'
+
+export default class ProductFilter extends BaseModelFilter {
+  declare $query: ModelQueryBuilderContract<typeof Product>
+
+  // Blacklisted methods
+  static blacklist: string[] = ['secretMethod']
+
+  // Dropped `_id` from the end of the input
+  // Doing this would allow you to have a `company()` filter method as well as a `companyId()` filter method.
+  static dropId: boolean = true
+
+  // Doing this would allow you to have a mobile_phone() filter method instead of mobilePhone().
+  // By default, mobilePhone() filter method can be called thanks to one of the following input key:
+  // mobile_phone, mobilePhone, mobile_phone_id, mobilePhoneId
+  static camelCase: boolean = true
+
+  // This will filter 'productCategoryId', 'product_category_id' OR 'productCategory'
+  productCategory(id: number) {
+    this.$query.where('product_category_id', id)
+  }
+
+  name(name: string) {
+    this.$query.where('name', 'LIKE', `%${name}%`)
+  }
+
+  price(price: number) {
+    this.$query.where('price', price)
+  }
+
+  secretMethod(secretParameter: any) {
+    this.$query.where('some_column', true)
+  }
+}
+```
+
+#### Blacklist
+
+Any methods defined in the `blacklist` array will not be called by the filter.
+Those methods are normally used for internal filter logic.
+
+The `whitelistMethod()` methods can be used to dynamically blacklist methods.
+
+Example:
+
+```typescript
+setup($query) {
+  this.whitelistMethod('secretMethod')
+  this.$query.where('is_admin', true)
+}
+```
+
+> `setup()` not may be async
+
+> **Note:** All methods inside `setup()` will be called every time `filter()` is called on the model
+
+In the example above `secretMethod()` will not be called, even if there is a `secret_method` key in the input object.
+In order to call this method it would need to be whitelisted dynamically:
+
+### Applying The Filter To A Model
+
+```typescript
+import { compose } from '@adonisjs/core/helpers'
+import { Filterable } from '@codenameryuu/adonis-lucid-filter'
+
+import ProductFilter from '#models/filters/product_filter'
+
+export default class Product extends compose(BaseModel, Filterable) {
+  static $filter = () => ProductFilter
+
+  // ...columns and props
+}
+```
+
+This gives you access to the `filter()` method that accepts an object of input:
+
+```typescript
+import type { HttpContext } from '@adonisjs/core/http'
+import Product from '#models/product'
+
+export default class ProductsController {
+  async index({ request }: HttpContext): Promise<Product[]> {
+    return Product.filter(request.all()).orderBy('created_at', 'desc')
+  }
+
+  // or with paginate method
+
+  async index({ request }: HttpContext): Promise<ModelPaginatorContract<Product>> {
+    return Product.filter(request.all()).paginate(1, 10)
+  }
+}
+```
+
+### Dynamic Filters
+
+You can define the filter dynamically by passing the filter to use as the second parameter of the filter() method.
+Defining a filter dynamically will take precedent over any other filters defined for the model.
+
+```typescript
+import type { HttpContext } from '@adonisjs/core/http'
+import ProductFilter from '#models/filters/product_filter'
+import ProductExclusiveFilter from '#models/filters/product_exclusive_filter'
+
+export default class ProductsController {
+  async index({ request, auth }: HttpContext): Promise<Product[]> {
+    const filter = auth.user.isAdmin() ? ProductFilter : ProductExclusiveFilter
+    return Product.filter(request.all(), filter).orderBy('created_at', 'desc')
+  }
+}
+```
+
+### Filtering relations
+
+For filtering relations of model may be use `.query().filter()` or scope `filtration` , example:
+
+```typescript
+import type { HttpContext } from '@adonisjs/core/http'
+import ProductCategory from '#models/product_category'
+
+export default class ProductCategoriesController {
+  /**
+   * Get a list products of product category
+   * GET /product-categories/:product_category_id/products
+   */
+  async index({ params, request }: HttpContext): Promise<Product[]> {
+    const productCategory: ProductCategory = await ProductCategory.findOrFail(
+      params.product_category_id
+    )
+
+    return productCategory
+      .related('products')
+      .query()
+      .filter(request.all())
+      .orderBy('created_at', 'desc')
+  }
+}
+```
+
+Documentation by [Query Scopes](https://lucid.adonisjs.com/docs/model-query-scopes)
+
+**Note:** The relation model must be `Filterable` and `$filter` must be defined in it
+
+## License
+
+This project is [MIT](https://github.com/codenameryuu/adonis-lucid-filter/blob/master/LICENSE.md) licensed.

package/build/commands/commands.json

@@ -1 +1 @@
-{"commands":[],"version":1}
+{"commands":[{"commandName":"make:filter","description":"Make a new Lucid filter","help":"","namespace":"make","aliases":[],"flags":[],"args":[{"name":"name","argumentName":"name","required":true,"description":"Name of the model file","type":"string"}],"options":{},"filePath":"make_filter.js"}],"version":1}

package/build/commands/make_filter.d.ts

@@ -1,4 +1,4 @@
-import { BaseCommand } from '@adonisjs/core/ace';
+import { BaseCommand } from "@adonisjs/core/ace";
 export default class MakeFilter extends BaseCommand {
     static commandName: string;
     static description: string;

package/build/commands/make_filter.js

@@ -0,0 +1,24 @@
+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 { BaseCommand, args } from "@adonisjs/core/ace";
+import { stubsRoot } from "../stubs/main.js";
+export default class MakeFilter extends BaseCommand {
+    static commandName = "make:filter";
+    static description = "Make a new Lucid filter";
+    /**
+     * Run command
+     */
+    async run() {
+        const codemods = await this.createCodemods();
+        await codemods.makeUsingStub(stubsRoot, "make/filter/main.stub", {
+            name: this.name,
+        });
+    }
+}
+__decorate([
+    args.string({ description: "Name of the model file" })
+], MakeFilter.prototype, "name", void 0);

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

@@ -0,0 +1,7 @@
+export async function configure(command) {
+    const codemods = await command.createCodemods();
+    await codemods.updateRcFile((rcFile) => {
+        rcFile.addProvider("@codenameryuu/adonis-lucid-filter/provider");
+        rcFile.addCommand("@codenameryuu/adonis-lucid-filter/commands");
+    });
+}

package/build/index.d.ts

@@ -1,4 +1,4 @@
-export { configure } from './configure.js';
-export { stubsRoot } from './stubs/main.js';
-export { BaseModelFilter } from './src/base_model.js';
-export { Filterable } from './src/mixin.js';
+export { configure } from "./configure.js";
+export { stubsRoot } from "./stubs/main.js";
+export { BaseModelFilter } from "./src/base_model.js";
+export { Filterable } from "./src/mixin.js";

package/build/index.js

@@ -0,0 +1,4 @@
+export { configure } from "./configure.js";
+export { stubsRoot } from "./stubs/main.js";
+export { BaseModelFilter } from "./src/base_model.js";
+export { Filterable } from "./src/mixin.js";

package/build/make/filter/main.stub

@@ -7,7 +7,7 @@
   exports({ to: app.modelsPath('filters', entity.path, modelFilterFileName) })
 }}}
 
-import { BaseModelFilter } from 'adonis-lucid-filter'
+import { BaseModelFilter } from '@codenameryuu/adonis-lucid-filter'
 import type { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model'
 import {{ modelName }} from '#models/{{ modelFileName }}'
 

package/build/providers/lucid_filter_provider.d.ts

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

package/build/providers/lucid_filter_provider.js

@@ -0,0 +1,12 @@
+/// <reference path="../src/types/querybuilder.ts" />
+import { extendModelQueryBuilder } from "../src/bindings/model_query_builder.js";
+export default class LucidFilterProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async boot() {
+        const { ModelQueryBuilder } = await this.app.import("@adonisjs/lucid/orm");
+        extendModelQueryBuilder(ModelQueryBuilder);
+    }
+}

package/build/src/base_model.d.ts

@@ -1,4 +1,4 @@
-import type { LucidFilter } from './types/filter.js';
+import type { LucidFilter } from "./types/filter.js";
 /**
  * Class to filtering AdonisJS Lucid ORM
  *
@@ -8,7 +8,7 @@ import type { LucidFilter } from './types/filter.js';
 export declare class BaseModelFilter implements LucidFilter {
     $query: any;
     $input: object;
-    ['constructor']: typeof BaseModelFilter;
+    ["constructor"]: typeof BaseModelFilter;
     $blacklist: string[];
     static blacklist: string[];
     static dropId: boolean;

package/build/src/base_model.js

@@ -0,0 +1,82 @@
+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;
+};
+var BaseModelFilter_1;
+import camelCase from "lodash/camelCase.js";
+function StaticImplements() {
+    return (_t) => { };
+}
+/**
+ * Class to filtering AdonisJS Lucid ORM
+ *
+ * @class BaseModelFilter
+ * @constructor
+ */
+let BaseModelFilter = class BaseModelFilter {
+    static { BaseModelFilter_1 = this; }
+    $query;
+    $input;
+    static blacklist = [];
+    static dropId = true;
+    static camelCase = true;
+    constructor($query, $input) {
+        this.$query = $query;
+        this.$input = $input;
+        this.$input = BaseModelFilter_1.removeEmptyInput(this.$input);
+        this.$blacklist = this.constructor.blacklist;
+    }
+    handle() {
+        if (this.setup && typeof this.setup === "function") {
+            this.setup(this.$query);
+        }
+        this.$filterByInput();
+        return this.$query;
+    }
+    whitelistMethod(method) {
+        const index = this.$blacklist.indexOf(method);
+        const isBlacklisted = index !== -1;
+        if (isBlacklisted)
+            this.$blacklist.splice(index, 1);
+        return isBlacklisted;
+    }
+    $filterByInput() {
+        for (const key in this.$input) {
+            const method = this.$getFilterMethod(key);
+            const keyName = key;
+            const value = this.$input[keyName];
+            if (this.$methodIsCallable(method)) {
+                this[method](value);
+            }
+        }
+    }
+    $getFilterMethod(key) {
+        const methodName = this.constructor.dropId ? key.replace(/^(.*)(_id|Id)$/, "$1") : key;
+        return this.constructor.camelCase ? camelCase(methodName) : methodName;
+    }
+    static removeEmptyInput(input) {
+        const filteredInput = {};
+        for (const key in input) {
+            const keyName = key;
+            const value = input[keyName];
+            if (value !== "" && value !== null && value !== undefined) {
+                filteredInput[keyName] = value;
+            }
+        }
+        return filteredInput;
+    }
+    $methodIsCallable(method) {
+        const methodKey = method;
+        return !!this[methodKey] && typeof this[methodKey] === "function" && !this.$methodIsBlacklisted(method);
+    }
+    $methodIsBlacklisted(method) {
+        return this.$blacklist.includes(method);
+    }
+};
+BaseModelFilter = BaseModelFilter_1 = __decorate([
+    StaticImplements()
+], BaseModelFilter);
+export { BaseModelFilter };
+export default BaseModelFilter;

package/build/src/bindings/model_query_builder.js

@@ -0,0 +1,9 @@
+/**
+ * Define filter method to ModelQueryBuilder
+ */
+export function extendModelQueryBuilder(builder) {
+    builder.macro("filter", function (input, filter) {
+        const Filter = filter || this.model.$filter();
+        return new Filter(this, input).handle();
+    });
+}

package/build/src/mixin.d.ts

@@ -1,7 +1,7 @@
-import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
-import type { BaseModel } from '@adonisjs/lucid/orm';
-import type { InputObject, LucidFilterContract } from '@codenameryuu/adonis-lucid-filter/types/filter';
-import type { ModelQueryBuilderContract, QueryScope, QueryScopeCallback } from '@adonisjs/lucid/types/model';
+import type { NormalizeConstructor } from "@adonisjs/core/types/helpers";
+import type { BaseModel } from "@adonisjs/lucid/orm";
+import type { InputObject, LucidFilterContract } from "@codenameryuu/adonis-lucid-filter/types/filter";
+import type { ModelQueryBuilderContract, QueryScope, QueryScopeCallback } from "@adonisjs/lucid/types/model";
 export declare const Filterable: <Model extends NormalizeConstructor<typeof BaseModel>>(superclass: Model) => {
     new (...args: any[]): {
         $attributes: import("@adonisjs/lucid/types/model").ModelObject;

package/build/src/mixin.js

@@ -0,0 +1,19 @@
+export const Filterable = (superclass) => {
+    class FilterableModel extends superclass {
+        /**
+         * Filter method of filterable model
+         */
+        static filter(input, filter) {
+            const Filter = filter || this.$filter();
+            return new Filter(this.query(), input).handle();
+        }
+        /**
+         * Filtration scope of filterable model
+         */
+        static filtration = function (query, input, filter) {
+            const Filter = filter || this.$filter();
+            return new Filter(query, input).handle();
+        };
+    }
+    return FilterableModel;
+};

package/build/src/types/filter.d.ts

@@ -1,5 +1,5 @@
-import type { CamelCase, SnakeCase, Split } from 'type-fest';
-import type { LucidModel, LucidRow, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
+import type { CamelCase, SnakeCase, Split } from "type-fest";
+import type { LucidModel, LucidRow, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
 /**
  * Lucid filter instance
  */
@@ -26,13 +26,13 @@ export interface LucidFilterContract {
  * Pick keys from methods of filter with a type of first value
  */
 type PickKeys<Filter> = {
-    [Key in keyof Filter as SnakeCase<Exclude<Key, keyof LucidFilter | 'constructor'>>]: Filter[Key] extends (value: infer V, ...args: any) => any ? V : never;
+    [Key in keyof Filter as SnakeCase<Exclude<Key, keyof LucidFilter | "constructor">>]: Filter[Key] extends (value: infer V, ...args: any) => any ? V : never;
 };
 /**
  * Add `_id` to end of SnakeCase keys with number type
  */
 type KeysWithIds<SCKeys> = {
-    [Key in keyof SCKeys as Key extends string ? 'id' extends Split<Key, '_'>[number] ? never : SCKeys[Key] extends number ? `${string & Key}_id` : never : never]?: SCKeys[Key];
+    [Key in keyof SCKeys as Key extends string ? "id" extends Split<Key, "_">[number] ? never : SCKeys[Key] extends number ? `${string & Key}_id` : never : never]?: SCKeys[Key];
 };
 /**
  * Convert all keys to CamelCase

package/build/src/types/filter.js

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

package/build/src/types/querybuilder.d.ts

@@ -1,5 +1,5 @@
-import type { LucidFilterContract, InputObject } from '@codenameryuu/adonis-lucid-filter/types/filter';
-declare module '@adonisjs/lucid/types/model' {
+import type { LucidFilterContract, InputObject } from "@codenameryuu/adonis-lucid-filter/types/filter";
+declare module "@adonisjs/lucid/types/model" {
     type FilterableModel = LucidModel & {
         $filter: () => LucidFilterContract;
         filtration: QueryScope<LucidModel, QueryScopeCallback>;
@@ -8,7 +8,7 @@ declare module '@adonisjs/lucid/types/model' {
         [Method in keyof Methods]: Model extends FilterableModel ? Methods[Method] : never;
     };
     type FilterableMethods<Model extends LucidModel> = {
-        filter<Filter extends LucidFilterContract = ReturnType<(FilterableModel & Model)['$filter']>>(input: InputObject<InstanceType<Filter>>, filter?: Filter): ModelQueryBuilderContract<Model, InstanceType<Model>>;
+        filter<Filter extends LucidFilterContract = ReturnType<(FilterableModel & Model)["$filter"]>>(input: InputObject<InstanceType<Filter>>, filter?: Filter): ModelQueryBuilderContract<Model, InstanceType<Model>>;
     };
     interface ModelQueryBuilderContract<Model extends LucidModel, Result = InstanceType<Model>> extends ExcludeFilterableMethods<FilterableMethods<Model>, Model> {
     }

package/build/src/types/querybuilder.js

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

package/build/stubs/main.js

@@ -0,0 +1,3 @@
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+export const stubsRoot = dirname(fileURLToPath(import.meta.url));

package/package.json

@@ -1,114 +1,110 @@
-{
-  "name": "@codenameryuu/adonis-lucid-filter",
-  "description": "Addon for filtering Adonis JS 7 Lucid ORM",
-  "version": "3.1.0",
-  "author": "codenameryuu",
-  "license": "MIT",
-  "homepage": "https://github.com/codenameryuu/adonis-lucid-filter#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/codenameryuu/adonis-lucid-filter.git"
-  },
-  "engines": {
-    "node": ">=24.0.0"
-  },
-  "type": "module",
-  "files": [
-    "build",
-    "!build/bin",
-    "!build/tests"
-  ],
-  "exports": {
-    ".": "./build/index.js",
-    "./commands": "./build/commands/main.js",
-    "./types/*": "./build/src/types/*.js",
-    "./bindings": "./build/src/bindings/model_query_builder.js",
-    "./provider": "./build/providers/lucid_filter_provider.js"
-  },
-  "scripts": {
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "clean": "del-cli build",
-    "precompile": "npm run lint && npm run clean",
-    "postcompile": "npm run copy:stubs && npm run index:commands",
-    "compile": "tsc --emitDeclarationOnly --declaration",
-    "build": "npm run compile",
-    "copy:stubs": "copyfiles \"stubs/**/**/*.stub\" --up=\"1\" build",
-    "index:commands": "adonis-kit index build/commands",
-    "quick:test": "NODE_DEBUG=\"adonis-lucid-filter\" 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/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"
-  },
-  "dependencies": {
-    "type-fest": "^4.21.0"
-  },
-  "peerDependencies": {
-    "@adonisjs/core": "^7.0.0",
-    "@adonisjs/lucid": "^22.0.0"
-  },
-  "keywords": [
-    "adonisjs",
-    "adonisjs-filter",
-    "adonisjs-lucid",
-    "adonisjs-lucid-filter",
-    "adonis",
-    "adonis-lucid",
-    "adonis-filter",
-    "adonis-lucid-filter"
-  ],
-  "prettier": "@adonisjs/prettier-config",
-  "publishConfig": {
-    "access": "public",
-    "tag": "latest"
-  },
-  "np": {
-    "message": "chore(release): %s",
-    "tag": "latest",
-    "branch": "master",
-    "anyBranch": false
-  },
-  "c8": {
-    "reporter": [
-      "text",
-      "html"
-    ],
-    "exclude": [
-      "tests/**",
-      "bin/**"
-    ]
-  }
-}
+{
+  "name": "@codenameryuu/adonis-lucid-filter",
+  "description": "Addon for filtering Adonis JS with Lucid ORM",
+  "version": "3.2.1",
+  "author": "codenameryuu",
+  "license": "MIT",
+  "homepage": "https://github.com/codenameryuu/adonis-lucid-filter#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codenameryuu/adonis-lucid-filter.git"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "type": "module",
+  "files": [
+    "build",
+    "!build/bin",
+    "!build/tests"
+  ],
+  "exports": {
+    ".": "./build/index.js",
+    "./commands": "./build/commands/main.js",
+    "./types/*": "./build/src/types/*.js",
+    "./bindings": "./build/src/bindings/model_query_builder.js",
+    "./provider": "./build/providers/lucid_filter_provider.js"
+  },
+  "scripts": {
+    "format": "prettier --write .",
+    "clean": "del-cli build",
+    "precompile": "npm run clean",
+    "postcompile": "npm run copy:stubs && npm run index:commands",
+    "compile": "tsc",
+    "build": "npm run compile",
+    "copy:stubs": "copyfiles \"stubs/**/**/*.stub\" --up=\"1\" build",
+    "index:commands": "adonis-kit index build/commands",
+    "quick:test": "NODE_DEBUG=\"adonis-lucid-filter\" 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/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"
+  },
+  "dependencies": {
+    "type-fest": "^4.21.0"
+  },
+  "peerDependencies": {
+    "@adonisjs/core": "^7.0.0",
+    "@adonisjs/lucid": "^22.0.0"
+  },
+  "keywords": [
+    "adonisjs",
+    "adonisjs-filter",
+    "adonisjs-lucid",
+    "adonisjs-lucid-filter",
+    "adonis",
+    "adonis-lucid",
+    "adonis-filter",
+    "adonis-lucid-filter"
+  ],
+  "prettier": "@adonisjs/prettier-config",
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "np": {
+    "message": "chore(release): %s",
+    "tag": "latest",
+    "branch": "master",
+    "anyBranch": false
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**",
+      "bin/**"
+    ]
+  }
+}