@codenameryuu/adonis-lucid-filter 2.0.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,312 @@
+# Adonis Lucid Filter
+> Works with AdonisJS v6
+
+[![npm-image]][npm-url] [![license-image]][license-url] [![typescript-image]][typescript-url]
+
+This addon adds the functionality to filter Lucid Models
+> Inspired by [EloquentFilter](https://github.com/Tucker-Eric/EloquentFilter)
+
+## Versions
+
+> **Note**: Check before install :point_down:
+
+| adonis-lucid-filter                 | @adonisjs/lucid     |
+|-------------------------------------|---------------------|
+| ^5.\*.*                             | ^20.\*.*            |
+| ^4.\*.*                             | <=18.\*.*           |
+| ^3.\*.* (`@filterable()` decorator) | ^15.\*.*            |
+| ^2.\*.*                             | 14.\*.*             |
+
+- Docs [for **Adonis v5**](https://github.com/lookinlab/adonis-lucid-filter/tree/v4)
+- Docs [for **Adonis v4**](https://github.com/lookinlab/adonis-lucid-filter/tree/v1)
+- Docs [for `@filterable()` decorator](https://github.com/lookinlab/adonis-lucid-filter/tree/v3)
+
+## Introduction
+Example, we want to return a list of users filtered by multiple parameters. When we navigate to:
+
+`/users?name=Tony&lastName=&companyId=2&industry=5`
+
+`request.all()` or `request.qs()` will return:
+
+```json
+{
+  "name": "Tony",
+  "lastName": "",
+  "companyId": 2,
+  "industry": 5
+}
+```
+
+To filter by all those parameters we would need to do something like:
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import User from '#models/user'
+
+export default class UsersController {
+  async index({ request }: HttpContext): Promise<User[]> {
+    const { companyId, lastName, name, industry } = request.qs()
+  
+    const query = User.query().where('company_id', +companyId)
+
+    if (lastName) {
+      query.where('last_name', 'LIKE', `%${lastName}%`)
+    }
+    if (name) {
+      query.where(function () {
+        this.where('first_name', 'LIKE', `%${name}%`)
+          .orWhere('last_name', 'LIKE', `%${name}%`)
+      })
+    }
+    return query.exec()
+  }
+
+}
+```
+
+To filter that same input with Lucid Filters:
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import User from '#models/user'
+
+export default class UsersController {
+  async index({ request }: HttpContext): Promise<User[]> {
+    return User.filter(request.qs()).exec()
+  }
+}
+```
+
+## Installation
+
+Make sure to install it using `npm`, `yarn` or `pnpm`.
+
+```bash
+# npm
+npm i adonis-lucid-filter
+
+# yarn
+yarn add adonis-lucid-filter
+
+# pnpm
+pnpm add adonis-lucid-filter
+```
+
+After install call `configure`:
+
+```bash
+node ace configure adonis-lucid-filter
+```
+
+## Usage
+
+Make sure to register the provider and commands inside `adonisrc.ts` file.
+
+```ts
+providers: [
+  // ...
+  () => import('adonis-lucid-filter/provider'),
+],
+commands: [
+  // ...
+  () => import('adonis-lucid-filter/commands')
+]
+```
+
+### Generating The Filter
+> Only available if you have added `adonis-lucid-filter/commands` in `commands` array in your `adonisrc.ts'
+
+You can create a model filter with the following ace command:
+
+```bash
+node ace make:filter user
+```
+
+Where `user` is the Lucid Model you are creating the filter for. This will create `app/models/filters/user_filter.js`
+
+### 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 `user_id` would use the `user()` 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
+{
+  "companyId": 5,
+  "name": "Tony",
+  "mobilePhone": "888555"
+}
+```
+
+You would use the following methods:
+
+```ts
+import { BaseModelFilter } from 'adonis-lucid-filter'
+import type { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model'
+import User from '#models/user'
+
+export default class UserFilter extends BaseModelFilter {
+  declare $query: ModelQueryBuilderContract<typeof User>
+  
+  static blacklist: string[] = ['secretMethod']
+
+  // This will filter 'companyId', 'company_id' OR 'company'
+  company(id: number) {
+    this.$query.where('company_id', id)
+  }
+
+  name(name: string) {
+    this.$query.where((builder) => {
+      builder
+        .where('first_name', 'LIKE', `%${name}%`)
+        .orWhere('last_name', 'LIKE', `%${name}%`)
+    })
+  }
+
+  mobilePhone(phone: string) {
+    this.$query.where('mobile_phone', 'LIKE', `${phone}%`)
+  }
+
+  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:
+```ts
+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:
+
+#### Static properties
+
+```ts
+export default class UserFilter extends BaseModelFilter {
+  // Blacklisted methods
+  static blacklist: string[] = []
+  
+  // 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
+}
+```
+
+### Applying The Filter To A Model
+
+```ts
+import UserFilter from '#models/filters/user_filter'
+import { compose } from '@adonisjs/core/helpers'
+import { Filterable } from 'adonis-lucid-filter'
+
+export default class User extends compose(BaseModel, Filterable) {
+  static $filter = () => UserFilter
+
+  // ...columns and props
+}
+```
+
+This gives you access to the `filter()` method that accepts an object of input:
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import User from '#models/user'
+
+export default class UsersController {
+  async index({ request }: HttpContext): Promise<User[]> {
+    return User.filter(request.qs()).exec()
+  }
+
+  // or with paginate method
+
+  async index({ request }: HttpContext): Promise<ModelPaginatorContract<User>> {
+    const { page = 1, ...input } = request.qs()
+    return User.filter(input).paginate(page, 15)
+  }
+}
+```
+
+### 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.
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import AdminFilter from '#models/filters/admin_filter'
+import UserFilter from '#models/filters/user_filter'
+
+export default class UsersController {
+  async index({ request, auth }: HttpContext): Promise<User[]> {
+    const filter = auth.user.isAdmin() ? AdminFilter : UserFilter
+    return User.filter(request.qs(), filter).exec()
+  } 
+}
+```
+
+### Filtering relations
+
+For filtering relations of model may be use `.query().filter()` or scope `filtration`, example:
+
+```ts
+import type { HttpContext } from '@adonisjs/core/http'
+import User from '#models/user'
+
+export default class UserPostsController {
+  /**
+   * Get a list posts of user
+   * GET /users/:user_id/posts
+   */
+  async index({ params, request }: HttpContext): Promise<Post[]> {
+    const user: User = await User.findOrFail(params.user_id)
+    
+    return user.related('posts').query()
+      .apply(scopes => scopes.filtration(request.qs()))
+      .exec()
+
+    // or
+
+    return user.related('posts').query().filter(request.qs()).exec()
+  }
+}
+```
+
+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
+
+[npm-image]: https://img.shields.io/npm/v/adonis-lucid-filter?logo=npm&style=for-the-badge
+[npm-url]: https://www.npmjs.com/package/adonis-lucid-filter
+
+[license-image]: https://img.shields.io/npm/l/adonis-lucid-filter?style=for-the-badge&color=blueviolet
+[license-url]: https://github.com/lookinlab/adonis-lucid-filter/blob/develop/LICENSE.md
+
+[typescript-image]: https://img.shields.io/npm/types/adonis-lucid-filter?color=294E80&label=%20&logo=typescript&style=for-the-badge
+[typescript-url]: https://github.com/lookinlab

package/build/chunk-FZT5JNRL.js

@@ -0,0 +1,15 @@
+// src/bindings/model_query_builder.ts
+function extendModelQueryBuilder(builder) {
+  builder.macro(
+    "filter",
+    function(input, filter) {
+      const Filter = filter || this.model.$filter();
+      return new Filter(this, input).handle();
+    }
+  );
+}
+
+export {
+  extendModelQueryBuilder
+};
+//# sourceMappingURL=chunk-FZT5JNRL.js.map

package/build/chunk-FZT5JNRL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bindings/model_query_builder.ts"],"sourcesContent":["/*\r\n * adonis-lucid-filter\r\n *\r\n * (c) Lookin Anton <alf@lookinlab.ru>\r\n *\r\n * For the full copyright and license information, please view the LICENSE\r\n * file that was distributed with this source code.\r\n */\r\n\r\nimport type { ModelQueryBuilder } from '@adonisjs/lucid/orm'\r\nimport type { LucidFilterContract } from '@codenameryuu/adonis-lucid-filter/types/filter'\r\n\r\n/**\r\n * Define filter method to ModelQueryBuilder\r\n */\r\nexport function extendModelQueryBuilder(builder: any) {\r\n  builder.macro(\r\n    'filter',\r\n    function (this: ModelQueryBuilder, input: any, filter?: LucidFilterContract) {\r\n      const Filter = filter || (this.model as any).$filter()\r\n      return new Filter(this, input).handle()\r\n    }\r\n  )\r\n}\r\n"],"mappings":";AAeO,SAAS,wBAAwB,SAAc;AACpD,UAAQ;AAAA,IACN;AAAA,IACA,SAAmC,OAAY,QAA8B;AAC3E,YAAM,SAAS,UAAW,KAAK,MAAc,QAAQ;AACrD,aAAO,IAAI,OAAO,MAAM,KAAK,EAAE,OAAO;AAAA,IACxC;AAAA,EACF;AACF;","names":[]}

package/build/chunk-NBGNVIUM.js

@@ -0,0 +1,9 @@
+// stubs/main.ts
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+var stubsRoot = dirname(fileURLToPath(import.meta.url));
+
+export {
+  stubsRoot
+};
+//# sourceMappingURL=chunk-NBGNVIUM.js.map

package/build/chunk-NBGNVIUM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../stubs/main.ts"],"sourcesContent":["/*\r\n * adonis-lucid-filter\r\n *\r\n * (c) Lookin Anton <alf@lookinlab.ru>\r\n *\r\n * For the full copyright and license information, please view the LICENSE\r\n * file that was distributed with this source code.\r\n */\r\n\r\nimport { fileURLToPath } from 'node:url'\r\nimport { dirname } from 'node:path'\r\n\r\nexport const stubsRoot = dirname(fileURLToPath(import.meta.url))\r\n"],"mappings":";AASA,SAAS,qBAAqB;AAC9B,SAAS,eAAe;AAEjB,IAAM,YAAY,QAAQ,cAAc,YAAY,GAAG,CAAC;","names":[]}

package/build/chunk-XUS63JTZ.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __decorateClass,
+  __publicField
+};
+//# sourceMappingURL=chunk-XUS63JTZ.js.map

package/build/chunk-XUS63JTZ.js.map

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

package/build/commands/commands.json

@@ -0,0 +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/main.d.ts

@@ -0,0 +1,4 @@
+import { CommandMetaData, Command } from '@adonisjs/ace/types';
+
+export function getMetaData(): Promise<CommandMetaData[]>
+export function getCommand(metaData: CommandMetaData): Promise<Command | null>

package/build/commands/main.js

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises'
+
+/**
+ * In-memory cache of commands after they have been loaded
+ */
+let commandsMetaData
+
+/**
+ * Reads the commands from the "./commands.json" file. Since, the commands.json
+ * file is generated automatically, we do not have to validate its contents
+ */
+export async function getMetaData() {
+  if (commandsMetaData) {
+    return commandsMetaData
+  }
+
+  const commandsIndex = await readFile(new URL('./commands.json', import.meta.url), 'utf-8')
+  commandsMetaData = JSON.parse(commandsIndex).commands
+
+  return commandsMetaData
+}
+
+/**
+ * Imports the command by lookingup its path from the commands
+ * metadata
+ */
+export async function getCommand(metaData) {
+  const commands = await getMetaData()
+  const command = commands.find(({ commandName }) => metaData.commandName === commandName)
+  if (!command) {
+    return null
+  }
+
+  const { default: commandConstructor } = await import(new URL(command.filePath, import.meta.url).href)
+  return commandConstructor
+}

package/build/commands/make_filter.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+export default class MakeFilter extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    /**
+     * The name of the model file.
+     */
+    name: string;
+    /**
+     * Run command
+     */
+    run(): Promise<void>;
+}

package/build/commands/make_filter.js

@@ -0,0 +1,29 @@
+import {
+  stubsRoot
+} from "../chunk-NBGNVIUM.js";
+import {
+  __decorateClass
+} from "../chunk-XUS63JTZ.js";
+
+// commands/make_filter.ts
+import { BaseCommand, args } from "@adonisjs/core/ace";
+var MakeFilter = class 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
+    });
+  }
+};
+__decorateClass([
+  args.string({ description: "Name of the model file" })
+], MakeFilter.prototype, "name", 2);
+export {
+  MakeFilter as default
+};
+//# sourceMappingURL=make_filter.js.map

package/build/commands/make_filter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../commands/make_filter.ts"],"sourcesContent":["/*\r\n * adonis-lucid-filter\r\n *\r\n * (c) Lookin Anton <alf@lookinlab.ru>\r\n *\r\n * For the full copyright and license information, please view the LICENSE\r\n * file that was distributed with this source code.\r\n */\r\n\r\nimport { BaseCommand, args } from '@adonisjs/core/ace'\r\nimport { stubsRoot } from '../stubs/main.js'\r\n\r\nexport default class MakeFilter extends BaseCommand {\r\n  static commandName = 'make:filter'\r\n  static description = 'Make a new Lucid filter'\r\n\r\n  /**\r\n   * The name of the model file.\r\n   */\r\n  @args.string({ description: 'Name of the model file' })\r\n  declare name: string\r\n\r\n  /**\r\n   * Run command\r\n   */\r\n  async run(): Promise<void> {\r\n    const codemods = await this.createCodemods()\r\n\r\n    await codemods.makeUsingStub(stubsRoot, 'make/filter/main.stub', {\r\n      name: this.name,\r\n    })\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;AASA,SAAS,aAAa,YAAY;AAGlC,IAAqB,aAArB,cAAwC,YAAY;AAAA,EAClD,OAAO,cAAc;AAAA,EACrB,OAAO,cAAc;AAAA;AAAA;AAAA;AAAA,EAWrB,MAAM,MAAqB;AACzB,UAAM,WAAW,MAAM,KAAK,eAAe;AAE3C,UAAM,SAAS,cAAc,WAAW,yBAAyB;AAAA,MAC/D,MAAM,KAAK;AAAA,IACb,CAAC;AAAA,EACH;AACF;AAZU;AAAA,EADP,KAAK,OAAO,EAAE,aAAa,yBAAyB,CAAC;AAAA,GAPnC,WAQX;","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,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/index.js

@@ -0,0 +1,111 @@
+import {
+  stubsRoot
+} from "./chunk-NBGNVIUM.js";
+import {
+  __decorateClass,
+  __publicField
+} from "./chunk-XUS63JTZ.js";
+
+// configure.ts
+async function configure(command) {
+  const codemods = await command.createCodemods();
+  await codemods.updateRcFile((rcFile) => {
+    rcFile.addProvider("adonis-lucid-filter/provider");
+    rcFile.addCommand("adonis-lucid-filter/commands");
+  });
+}
+
+// src/base_model.ts
+import camelCase from "lodash/camelCase.js";
+function StaticImplements() {
+  return (_t) => {
+  };
+}
+var BaseModelFilter = class {
+  constructor($query, $input) {
+    this.$query = $query;
+    this.$input = $input;
+    this.$input = BaseModelFilter.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 !== void 0) {
+        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);
+  }
+};
+__publicField(BaseModelFilter, "blacklist", []);
+__publicField(BaseModelFilter, "dropId", true);
+__publicField(BaseModelFilter, "camelCase", true);
+BaseModelFilter = __decorateClass([
+  StaticImplements()
+], BaseModelFilter);
+
+// src/mixin.ts
+var 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;
+};
+export {
+  BaseModelFilter,
+  Filterable,
+  configure,
+  stubsRoot
+};
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../configure.ts","../src/base_model.ts","../src/mixin.ts"],"sourcesContent":["/*\r\n * adonis-lucid-filter\r\n *\r\n * (c) Lookin Anton <alf@lookinlab.ru>\r\n *\r\n * For the full copyright and license information, please view the LICENSE\r\n * file that was distributed with this source code.\r\n */\r\n\r\nimport type Configure from '@adonisjs/core/commands/configure'\r\n\r\nexport async function configure(command: Configure) {\r\n  const codemods = await command.createCodemods()\r\n\r\n  await codemods.updateRcFile((rcFile) => {\r\n    rcFile.addProvider('adonis-lucid-filter/provider')\r\n    rcFile.addCommand('adonis-lucid-filter/commands')\r\n  })\r\n}\r\n","/*\r\n * adonis-lucid-filter\r\n *\r\n * (c) Lookin Anton <alf@lookinlab.ru>\r\n *\r\n * For the full copyright and license information, please view the LICENSE\r\n * file that was distributed with this source code.\r\n */\r\n\r\nimport camelCase from 'lodash/camelCase.js'\r\nimport type { LucidFilter, LucidFilterContract } from './types/filter.js'\r\n\r\nfunction StaticImplements<T>() {\r\n  return (_t: T) => {}\r\n}\r\n\r\n/**\r\n * Class to filtering AdonisJS Lucid ORM\r\n *\r\n * @class BaseModelFilter\r\n * @constructor\r\n */\r\n@StaticImplements<LucidFilterContract>()\r\nexport class BaseModelFilter implements LucidFilter {\r\n  declare ['constructor']: typeof BaseModelFilter\r\n  declare $blacklist: string[]\r\n\r\n  static blacklist: string[] = []\r\n  static dropId: boolean = true\r\n  static camelCase: boolean = true\r\n\r\n  setup?($query: any): void\r\n\r\n  constructor(\r\n    public $query: any,\r\n    public $input: object\r\n  ) {\r\n    this.$input = BaseModelFilter.removeEmptyInput(this.$input)\r\n    this.$blacklist = this.constructor.blacklist\r\n  }\r\n\r\n  handle(): any {\r\n    if (this.setup && typeof this.setup === 'function') {\r\n      this.setup(this.$query)\r\n    }\r\n    this.$filterByInput()\r\n\r\n    return this.$query\r\n  }\r\n\r\n  whitelistMethod(method: string): boolean {\r\n    const index = this.$blacklist.indexOf(method)\r\n\r\n    const isBlacklisted = index !== -1\r\n    if (isBlacklisted) this.$blacklist.splice(index, 1)\r\n\r\n    return isBlacklisted\r\n  }\r\n\r\n  $filterByInput(): void {\r\n    for (const key in this.$input) {\r\n      const method = this.$getFilterMethod(key)\r\n\r\n      const keyName = key as keyof typeof this.$input\r\n      const value: unknown = this.$input[keyName]\r\n\r\n      if (this.$methodIsCallable(method)) {\r\n        ;(this[method as keyof this] as Function)(value)\r\n      }\r\n    }\r\n  }\r\n\r\n  $getFilterMethod(key: string): string {\r\n    const methodName = this.constructor.dropId ? key.replace(/^(.*)(_id|Id)$/, '$1') : key\r\n    return this.constructor.camelCase ? camelCase(methodName) : methodName\r\n  }\r\n\r\n  static removeEmptyInput(input: object): object {\r\n    const filteredInput = {}\r\n\r\n    for (const key in input) {\r\n      const keyName = key as keyof typeof input\r\n      const value = input[keyName]\r\n\r\n      if (value !== '' && value !== null && value !== undefined) {\r\n        filteredInput[keyName] = value\r\n      }\r\n    }\r\n    return filteredInput\r\n  }\r\n\r\n  $methodIsCallable(method: string): boolean {\r\n    const methodKey = method as keyof this\r\n\r\n    return (\r\n      !!this[methodKey] &&\r\n      typeof this[methodKey] === 'function' &&\r\n      !this.$methodIsBlacklisted(method)\r\n    )\r\n  }\r\n\r\n  $methodIsBlacklisted(method: string): boolean {\r\n    return this.$blacklist.includes(method)\r\n  }\r\n}\r\nexport default BaseModelFilter\r\n","/*\r\n * adonis-lucid-filter\r\n *\r\n * (c) Lookin Anton <alf@lookinlab.ru>\r\n *\r\n * For the full copyright and license information, please view the LICENSE\r\n * file that was distributed with this source code.\r\n */\r\n\r\nimport type { NormalizeConstructor } from '@adonisjs/core/types/helpers'\r\nimport type { BaseModel } from '@adonisjs/lucid/orm'\r\nimport type {\r\n  InputObject,\r\n  LucidFilterContract,\r\n} from '@codenameryuu/adonis-lucid-filter/types/filter'\r\nimport type {\r\n  ModelQueryBuilderContract,\r\n  QueryScope,\r\n  QueryScopeCallback,\r\n} from '@adonisjs/lucid/types/model'\r\n\r\nexport const Filterable = <Model extends NormalizeConstructor<typeof BaseModel>>(\r\n  superclass: Model\r\n) => {\r\n  class FilterableModel extends superclass {\r\n    declare static $filter: () => LucidFilterContract\r\n\r\n    /**\r\n     * Filter method of filterable model\r\n     */\r\n    static filter<\r\n      T extends typeof FilterableModel,\r\n      Filter extends LucidFilterContract = ReturnType<T['$filter']>,\r\n    >(\r\n      this: T,\r\n      input: InputObject<InstanceType<Filter>>,\r\n      filter?: Filter\r\n    ): ModelQueryBuilderContract<T> {\r\n      const Filter = filter || this.$filter()\r\n      return new Filter(this.query(), input).handle()\r\n    }\r\n\r\n    /**\r\n     * Filtration scope of filterable model\r\n     */\r\n    static filtration = function (\r\n      this: typeof FilterableModel,\r\n      query,\r\n      input,\r\n      filter?: LucidFilterContract\r\n    ) {\r\n      const Filter = filter || this.$filter()\r\n      return new Filter(query, input).handle()\r\n    } as QueryScope<Model, QueryScopeCallback>\r\n  }\r\n  return FilterableModel\r\n}\r\n"],"mappings":";;;;;;;;;AAWA,eAAsB,UAAU,SAAoB;AAClD,QAAM,WAAW,MAAM,QAAQ,eAAe;AAE9C,QAAM,SAAS,aAAa,CAAC,WAAW;AACtC,WAAO,YAAY,8BAA8B;AACjD,WAAO,WAAW,8BAA8B;AAAA,EAClD,CAAC;AACH;;;ACTA,OAAO,eAAe;AAGtB,SAAS,mBAAsB;AAC7B,SAAO,CAAC,OAAU;AAAA,EAAC;AACrB;AASO,IAAM,kBAAN,MAA6C;AAAA,EAUlD,YACS,QACA,QACP;AAFO;AACA;AAEP,SAAK,SAAS,gBAAgB,iBAAiB,KAAK,MAAM;AAC1D,SAAK,aAAa,KAAK,YAAY;AAAA,EACrC;AAAA,EAEA,SAAc;AACZ,QAAI,KAAK,SAAS,OAAO,KAAK,UAAU,YAAY;AAClD,WAAK,MAAM,KAAK,MAAM;AAAA,IACxB;AACA,SAAK,eAAe;AAEpB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,gBAAgB,QAAyB;AACvC,UAAM,QAAQ,KAAK,WAAW,QAAQ,MAAM;AAE5C,UAAM,gBAAgB,UAAU;AAChC,QAAI,cAAe,MAAK,WAAW,OAAO,OAAO,CAAC;AAElD,WAAO;AAAA,EACT;AAAA,EAEA,iBAAuB;AACrB,eAAW,OAAO,KAAK,QAAQ;AAC7B,YAAM,SAAS,KAAK,iBAAiB,GAAG;AAExC,YAAM,UAAU;AAChB,YAAM,QAAiB,KAAK,OAAO,OAAO;AAE1C,UAAI,KAAK,kBAAkB,MAAM,GAAG;AAClC;AAAC,QAAC,KAAK,MAAoB,EAAe,KAAK;AAAA,MACjD;AAAA,IACF;AAAA,EACF;AAAA,EAEA,iBAAiB,KAAqB;AACpC,UAAM,aAAa,KAAK,YAAY,SAAS,IAAI,QAAQ,kBAAkB,IAAI,IAAI;AACnF,WAAO,KAAK,YAAY,YAAY,UAAU,UAAU,IAAI;AAAA,EAC9D;AAAA,EAEA,OAAO,iBAAiB,OAAuB;AAC7C,UAAM,gBAAgB,CAAC;AAEvB,eAAW,OAAO,OAAO;AACvB,YAAM,UAAU;AAChB,YAAM,QAAQ,MAAM,OAAO;AAE3B,UAAI,UAAU,MAAM,UAAU,QAAQ,UAAU,QAAW;AACzD,sBAAc,OAAO,IAAI;AAAA,MAC3B;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAEA,kBAAkB,QAAyB;AACzC,UAAM,YAAY;AAElB,WACE,CAAC,CAAC,KAAK,SAAS,KAChB,OAAO,KAAK,SAAS,MAAM,cAC3B,CAAC,KAAK,qBAAqB,MAAM;AAAA,EAErC;AAAA,EAEA,qBAAqB,QAAyB;AAC5C,WAAO,KAAK,WAAW,SAAS,MAAM;AAAA,EACxC;AACF;AA7EE,cAJW,iBAIJ,aAAsB,CAAC;AAC9B,cALW,iBAKJ,UAAkB;AACzB,cANW,iBAMJ,aAAqB;AANjB,kBAAN;AAAA,EADN,iBAAsC;AAAA,GAC1B;;;ACFN,IAAM,aAAa,CACxB,eACG;AAAA,EACH,MAAM,wBAAwB,WAAW;AAAA;AAAA;AAAA;AAAA,IAMvC,OAAO,OAKL,OACA,QAC8B;AAC9B,YAAM,SAAS,UAAU,KAAK,QAAQ;AACtC,aAAO,IAAI,OAAO,KAAK,MAAM,GAAG,KAAK,EAAE,OAAO;AAAA,IAChD;AAAA;AAAA;AAAA;AAAA,IAKA,OAAO,aAAa,SAElB,OACA,OACA,QACA;AACA,YAAM,SAAS,UAAU,KAAK,QAAQ;AACtC,aAAO,IAAI,OAAO,OAAO,KAAK,EAAE,OAAO;AAAA,IACzC;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/build/make/filter/main.stub

@@ -0,0 +1,20 @@
+{{#var entity = generators.createEntity(name)}}
+{{#var modelName = generators.modelName(entity.name)}}
+{{#var modelFileName = string(modelName).removeExtension().snakeCase().toString()}}
+{{#var modelFilterName = string(modelName).removeSuffix('filter').pascalCase().suffix(string.pascalCase('filter')).toString()}}
+{{#var modelFilterFileName = string(modelName).snakeCase().suffix('_filter').ext('.ts').toString()}}
+{{{
+  exports({ to: app.modelsPath('filters', entity.path, modelFilterFileName) })
+}}}
+
+import { BaseModelFilter } from 'adonis-lucid-filter'
+import type { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model'
+import {{ modelName }} from '#models/{{ modelFileName }}'
+
+export default class {{ modelFilterName }} extends BaseModelFilter {
+  declare $query: ModelQueryBuilderContract<typeof {{ modelName }}>
+
+  name(value: string): void {
+    this.$query.where('name', value)
+  }
+}

package/build/providers/lucid_filter_provider.d.ts

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

package/build/providers/lucid_filter_provider.js

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

package/build/providers/lucid_filter_provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../providers/lucid_filter_provider.ts"],"sourcesContent":["/*\r\n * adonis-lucid-filter\r\n *\r\n * (c) Lookin Anton <alf@lookinlab.ru>\r\n *\r\n * For the full copyright and license information, please view the LICENSE\r\n * file that was distributed with this source code.\r\n */\r\n\r\n/// <reference path=\"../src/types/querybuilder.ts\" />\r\n\r\nimport type { ApplicationService } from '@adonisjs/core/types'\r\nimport { extendModelQueryBuilder } from '../src/bindings/model_query_builder.js'\r\n\r\nexport default class LucidFilterProvider {\r\n  constructor(protected app: ApplicationService) {}\r\n\r\n  async boot() {\r\n    const { ModelQueryBuilder } = await this.app.import('@adonisjs/lucid/orm')\r\n    extendModelQueryBuilder(ModelQueryBuilder)\r\n  }\r\n}\r\n"],"mappings":";;;;;;AAcA,IAAqB,sBAArB,MAAyC;AAAA,EACvC,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/base_model.d.ts

@@ -0,0 +1,26 @@
+import type { LucidFilter } from './types/filter.js';
+/**
+ * Class to filtering AdonisJS Lucid ORM
+ *
+ * @class BaseModelFilter
+ * @constructor
+ */
+export declare class BaseModelFilter implements LucidFilter {
+    $query: any;
+    $input: object;
+    ['constructor']: typeof BaseModelFilter;
+    $blacklist: string[];
+    static blacklist: string[];
+    static dropId: boolean;
+    static camelCase: boolean;
+    setup?($query: any): void;
+    constructor($query: any, $input: object);
+    handle(): any;
+    whitelistMethod(method: string): boolean;
+    $filterByInput(): void;
+    $getFilterMethod(key: string): string;
+    static removeEmptyInput(input: object): object;
+    $methodIsCallable(method: string): boolean;
+    $methodIsBlacklisted(method: string): boolean;
+}
+export default BaseModelFilter;

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

@@ -0,0 +1,4 @@
+/**
+ * Define filter method 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-FZT5JNRL.js";
+import "../../chunk-XUS63JTZ.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,154 @@
+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;
+        $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;
+        $getQueryFor(action: "insert", client: import("@adonisjs/lucid/types/database").QueryClientContract): ReturnType<import("@adonisjs/lucid/types/database").QueryClientContract["insertQuery"]>;
+        $getQueryFor(action: "update" | "delete" | "refresh", client: import("@adonisjs/lucid/types/database").QueryClientContract): ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel>;
+        $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?: undefined[] | undefined): boolean;
+        enableForceUpdate(): /*elided*/ any;
+        save(): Promise</*elided*/ any>;
+        saveQuietly(): Promise</*elided*/ any>;
+        lockForUpdate<T>(callback: (user: /*elided*/ any) => T | Promise<T>): Promise<T>;
+        delete(): Promise<void>;
+        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<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? (import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        loadCount: <Self extends /*elided*/ any, Name_1 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder_1 = NonNullable<Self[Name_1]> extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? (import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> & Self[Name_1] & {})["subQuery"] : never>(name: Name_1, callback?: ((builder: RelatedBuilder_1) => 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_2 extends undefined>(relation: Name_2): NonNullable</*elided*/ any[Name_2]> extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? (import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> & /*elided*/ any[Name_2] & {})["client"] : never;
+    };
+    $filter: () => LucidFilterContract;
+    /**
+     * Filter method of filterable model
+     */
+    filter<T extends /*elided*/ any & Model, Filter extends LucidFilterContract = ReturnType<T["$filter"]>>(this: T, input: InputObject<InstanceType<Filter>>, filter?: Filter): ModelQueryBuilderContract<T>;
+    /**
+     * Filtration scope of filterable model
+     */
+    filtration: QueryScope<Model, QueryScopeCallback>;
+    find: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    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 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, result?: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => null | InstanceType<T>;
+    $createMultipleFromAdapterResult: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => InstanceType<T>[];
+    $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: () => import("@adonisjs/lucid/types/model").LucidModel, options: import("@adonisjs/lucid/types/model").ModelRelationOptions) => void;
+    $hasRelation: (name: string) => boolean;
+    $getRelation: {
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Name_2 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<InstanceType<Model_1>>>(this: Model_1, name: Name_2): NonNullable<InstanceType<Model_1>[Name_2]> extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? NonNullable<InstanceType<Model_1>[Name_2]>["client"]["relation"] : import("@adonisjs/lucid/types/relations").RelationshipsContract;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
+    };
+    $defineProperty: <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model_1>(this: Model_1, propertyName: Prop, defaultValue: Model_1[Prop], strategy: "inherit" | "define" | ((value: Model_1[Prop]) => Model_1[Prop])) => void;
+    boot: () => void;
+    before: {
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model_1, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<ModelQueryBuilderContract<Model_1>, Event>): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[ModelQueryBuilderContract<Model_1>, ModelQueryBuilderContract<Model_1>], "paginate">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_1>): void;
+    };
+    after: {
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>[], "fetch">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_1>>, "paginate">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): void;
+    };
+    create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    createQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    createManyQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    findOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
+    findBy: {
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
+    };
+    findByOrFail: {
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
+    };
+    findManyBy: {
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
+    };
+    first: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    firstOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
+    findMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
+    firstOrNew: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    firstOrCreate: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    updateOrCreate: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    fetchOrNewUpMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    fetchOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    updateOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    all: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
+    query: <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Result = InstanceType<Model_1>>(this: Model_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => ModelQueryBuilderContract<Model_1, Result>;
+    transaction: import("@adonisjs/lucid/types/database").TransactionFn;
+    truncate: (cascade?: boolean) => Promise<void>;
+} & Model;

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

@@ -0,0 +1,47 @@
+import type { CamelCase, SnakeCase, Split } from 'type-fest';
+import type { LucidModel, LucidRow, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
+/**
+ * Lucid filter instance
+ */
+export interface LucidFilter {
+    setup?($query: any): void;
+    whitelistMethod(method: string): boolean;
+    handle(): any;
+    $filterByInput(): void;
+    $getFilterMethod(key: string): string;
+    $methodIsCallable(method: string): boolean;
+    $methodIsBlacklisted(method: string): boolean;
+}
+/**
+ * Lucid filter static contract
+ */
+export interface LucidFilterContract {
+    blacklist: string[];
+    dropId: boolean;
+    camelCase: boolean;
+    removeEmptyInput(input: object): object;
+    new ($query: ModelQueryBuilderContract<LucidModel, LucidRow>, $input: object): LucidFilter;
+}
+/**
+ * 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;
+};
+/**
+ * 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];
+};
+/**
+ * Convert all keys to CamelCase
+ */
+type CamelCased<Keys> = {
+    [Key in keyof Keys as CamelCase<`${string & Key}`>]?: Keys[Key];
+};
+/**
+ * Input object of filter model
+ */
+export type InputObject<Instance extends InstanceType<LucidFilterContract>> = Partial<PickKeys<Instance>> & KeysWithIds<PickKeys<Instance>> & CamelCased<PickKeys<Instance>> & CamelCased<KeysWithIds<PickKeys<Instance>>>;
+export {};

package/build/src/types/filter.js

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

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

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

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

@@ -0,0 +1,15 @@
+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>;
+    };
+    type ExcludeFilterableMethods<Methods, 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>>;
+    };
+    interface ModelQueryBuilderContract<Model extends LucidModel, Result = InstanceType<Model>> extends ExcludeFilterableMethods<FilterableMethods<Model>, Model> {
+    }
+}

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/build/stubs/main.d.ts

@@ -0,0 +1 @@
+export declare const stubsRoot: string;

package/package.json

@@ -0,0 +1,134 @@
+{
+  "name": "@codenameryuu/adonis-lucid-filter",
+  "description": "Addon for filtering AdonisJS Lucid ORM",
+  "version": "2.0.0",
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "main": "./build/index.js",
+  "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 .",
+    "clean": "del-cli build",
+    "precompile": "npm run lint && npm run clean",
+    "postcompile": "npm run copy:stubs && npm run index:commands",
+    "compile": "tsup-node && 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": "^1.3.0",
+    "@adonisjs/lucid": "^22.0.0",
+    "@adonisjs/prettier-config": "^1.3.0",
+    "@adonisjs/tsconfig": "^1.3.0",
+    "@japa/assert": "^2.1.0",
+    "@japa/expect-type": "^2.0.2",
+    "@japa/file-system": "^2.3.0",
+    "@japa/runner": "^3.1.4",
+    "@japa/snapshot": "^2.0.5",
+    "@swc/core": "^1.6.7",
+    "@types/lodash": "^4.17.6",
+    "c8": "^9.1.0",
+    "copyfiles": "^2.4.1",
+    "del-cli": "^5.1.0",
+    "eslint": "^8.57.0",
+    "knex": "^3.1.0",
+    "lodash": "^4.17.21",
+    "luxon": "^3.4.4",
+    "np": "^9.2.0",
+    "reflect-metadata": "^0.2.2",
+    "sqlite3": "^5.1.7",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.1.0",
+    "typescript": "^5.5.3"
+  },
+  "dependencies": {
+    "type-fest": "^4.21.0"
+  },
+  "peerDependencies": {
+    "@adonisjs/core": "^6.2.3",
+    "@adonisjs/lucid": "^21.1.0",
+    "lodash": "^4.17.21"
+  },
+  "author": "LookinGit",
+  "license": "MIT",
+  "homepage": "https://github.com/lookinlab/adonis-lucid-filter#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/lookinlab/adonis-lucid-filter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lookinlab/adonis-lucid-filter/issues"
+  },
+  "keywords": [
+    "adonisjs",
+    "adonisjs-filter",
+    "adonisjs-lucid",
+    "adonisjs-lucid-filter",
+    "adonis",
+    "adonis-lucid",
+    "adonis-filter",
+    "adonis-lucid-filter"
+  ],
+  "eslintConfig": {
+    "extends": "@adonisjs/eslint-config/package"
+  },
+  "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/**"
+    ]
+  },
+  "tsup": {
+    "entry": [
+      "./index.ts",
+      "./src/types/*.ts",
+      "./src/bindings/model_query_builder.ts",
+      "./commands/make_filter.ts",
+      "./providers/lucid_filter_provider.ts"
+    ],
+    "outDir": "./build",
+    "clean": true,
+    "format": "esm",
+    "dts": false,
+    "sourcemap": true,
+    "target": "esnext"
+  }
+}