@eienjs/adonisjs-api-query 1.1.1 → 2.0.0

package/build/src/define_config.js

@@ -0,0 +1,25 @@
+import { configProvider } from "@adonisjs/core";
+//#region src/define_config.ts
+const defineConfig = function(config) {
+	return configProvider.create(async (_) => {
+		return {
+			parameters: {
+				include: config.parameters?.include ?? "include",
+				filter: config.parameters?.filter ?? "filter",
+				sort: config.parameters?.sort ?? "sort",
+				fields: config.parameters?.fields ?? "fields",
+				append: config.parameters?.append ?? "append"
+			},
+			countSuffix: config.countSuffix ?? "Count",
+			existsSuffix: config.existsSuffix ?? "Exists",
+			disableInvalidFilterQueryException: config.disableInvalidFilterQueryException ?? false,
+			disableInvalidSortQueryException: config.disableInvalidSortQueryException ?? false,
+			disableInvalidIncludesQueryException: config.disableInvalidIncludesQueryException ?? false,
+			convertRelationNamesToSnakeCasePlural: config.convertRelationNamesToSnakeCasePlural ?? false,
+			convertRelationTableNameStrategy: config.convertRelationTableNameStrategy ?? false,
+			convertFieldNamesToSnakeCase: config.convertFieldNamesToSnakeCase ?? false
+		};
+	});
+};
+//#endregion
+export { defineConfig };

package/build/src/enums/filter_operator.d.ts

@@ -1,10 +1,12 @@
-export declare const FilterOperator: {
-    readonly Dynamic: "";
-    readonly Equal: "=";
-    readonly LessThan: "<";
-    readonly GreaterThan: ">";
-    readonly LessThanOrEqual: "<=";
-    readonly GreaterThanOrEqual: ">=";
-    readonly NotEqual: "<>";
+//#region src/enums/filter_operator.d.ts
+declare const FilterOperator: {
+  readonly Dynamic: "";
+  readonly Equal: "=";
+  readonly LessThan: "<";
+  readonly GreaterThan: ">";
+  readonly LessThanOrEqual: "<=";
+  readonly GreaterThanOrEqual: ">=";
+  readonly NotEqual: "<>";
 };
-export type FilterOperator = (typeof FilterOperator)[keyof typeof FilterOperator];
+//#endregion
+export { FilterOperator };

package/build/src/enums/filter_operator.js

@@ -0,0 +1,12 @@
+//#region src/enums/filter_operator.ts
+const FilterOperator = {
+	Dynamic: "",
+	Equal: "=",
+	LessThan: "<",
+	GreaterThan: ">",
+	LessThanOrEqual: "<=",
+	GreaterThanOrEqual: ">=",
+	NotEqual: "<>"
+};
+//#endregion
+export { FilterOperator };

package/build/src/enums/sort_direction.d.ts

@@ -1,5 +1,7 @@
-export declare const SortDirection: {
-    readonly Ascending: "asc";
-    readonly Descending: "desc";
+//#region src/enums/sort_direction.d.ts
+declare const SortDirection: {
+  readonly Ascending: "asc";
+  readonly Descending: "desc";
 };
-export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
+//#endregion
+export { SortDirection };

package/build/src/enums/sort_direction.js

@@ -0,0 +1,7 @@
+//#region src/enums/sort_direction.ts
+const SortDirection = {
+	Ascending: "asc",
+	Descending: "desc"
+};
+//#endregion
+export { SortDirection };

package/build/src/exceptions/allowed_fields_must_be_called_before_allowed_includes.d.ts

@@ -1,6 +1,10 @@
-import { Exception } from '@adonisjs/core/exceptions';
-export declare class AllowedFieldsMustBeCalledBeforeAllowedIncludes extends Exception {
-    static readonly code: 'E_BAD_METHOD_CALL_EXCEPTION';
-    static readonly status: 500;
-    constructor();
+import { Exception } from "@adonisjs/core/exceptions";
+
+//#region src/exceptions/allowed_fields_must_be_called_before_allowed_includes.d.ts
+declare class AllowedFieldsMustBeCalledBeforeAllowedIncludes extends Exception {
+  static readonly code: 'E_BAD_METHOD_CALL_EXCEPTION';
+  static readonly status: 500;
+  constructor();
 }
+//#endregion
+export { AllowedFieldsMustBeCalledBeforeAllowedIncludes };

package/build/src/exceptions/allowed_fields_must_be_called_before_allowed_includes.js

@@ -0,0 +1,11 @@
+import { Exception } from "@adonisjs/core/exceptions";
+//#region src/exceptions/allowed_fields_must_be_called_before_allowed_includes.ts
+var AllowedFieldsMustBeCalledBeforeAllowedIncludes = class extends Exception {
+	static code;
+	static status;
+	constructor() {
+		super("The QueryBuilder's `allowedFields` method must be called before the `allowedIncludes` method");
+	}
+};
+//#endregion
+export { AllowedFieldsMustBeCalledBeforeAllowedIncludes };

package/build/src/exceptions/invalid_append_query.d.ts

@@ -1,5 +1,9 @@
-import { InvalidQuery } from './invalid_query.js';
-export declare class InvalidAppendQuery extends InvalidQuery {
-    constructor(appendsNotAllowed: string[], allowedAppends: string[]);
-    static appendsNotAllowed(appendsNotAllowed: string[], allowedAppends: string[]): InvalidAppendQuery;
+import { InvalidQuery } from "./invalid_query.js";
+
+//#region src/exceptions/invalid_append_query.d.ts
+declare class InvalidAppendQuery extends InvalidQuery {
+  constructor(appendsNotAllowed: string[], allowedAppends: string[]);
+  static appendsNotAllowed(appendsNotAllowed: string[], allowedAppends: string[]): InvalidAppendQuery;
 }
+//#endregion
+export { InvalidAppendQuery };

package/build/src/exceptions/invalid_append_query.js

@@ -0,0 +1,14 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+//#region src/exceptions/invalid_append_query.ts
+var InvalidAppendQuery = class InvalidAppendQuery extends InvalidQuery {
+	constructor(appendsNotAllowed, allowedAppends) {
+		const message = `Requested append(s) \`${appendsNotAllowed.join(", ")}\` are not allowed. Allowed append(s) are \`${allowedAppends.join(", ")}\``;
+		super(message, { status: ResponseStatus.BadRequest });
+	}
+	static appendsNotAllowed(appendsNotAllowed, allowedAppends) {
+		return new InvalidAppendQuery(appendsNotAllowed, allowedAppends);
+	}
+};
+//#endregion
+export { InvalidAppendQuery };

package/build/src/exceptions/invalid_direction.d.ts

@@ -1,4 +1,8 @@
-import { Exception } from '@adonisjs/core/exceptions';
-export declare class InvalidDirection extends Exception {
-    static make(sort: string): InvalidDirection;
+import { Exception } from "@adonisjs/core/exceptions";
+
+//#region src/exceptions/invalid_direction.d.ts
+declare class InvalidDirection extends Exception {
+  static make(sort: string): InvalidDirection;
 }
+//#endregion
+export { InvalidDirection };

package/build/src/exceptions/invalid_direction.js

@@ -0,0 +1,10 @@
+import { SortDirection } from "../enums/sort_direction.js";
+import { Exception } from "@adonisjs/core/exceptions";
+//#region src/exceptions/invalid_direction.ts
+var InvalidDirection = class InvalidDirection extends Exception {
+	static make(sort) {
+		return new InvalidDirection(`The direction should be either \`${SortDirection.Descending}\` or \`${SortDirection.Ascending}\` ${sort} given`);
+	}
+};
+//#endregion
+export { InvalidDirection };

package/build/src/exceptions/invalid_filter_query.d.ts

@@ -1,7 +1,11 @@
-import { InvalidQuery } from './invalid_query.js';
-export declare class InvalidFilterQuery extends InvalidQuery {
-    readonly unknownFilters: string[];
-    readonly allowedFilters: string[];
-    constructor(unknownFilters: string[], allowedFilters: string[]);
-    static filtersNotAllowed(unknownFilters: string[], allowedFilters: string[]): InvalidFilterQuery;
+import { InvalidQuery } from "./invalid_query.js";
+
+//#region src/exceptions/invalid_filter_query.d.ts
+declare class InvalidFilterQuery extends InvalidQuery {
+  readonly unknownFilters: string[];
+  readonly allowedFilters: string[];
+  constructor(unknownFilters: string[], allowedFilters: string[]);
+  static filtersNotAllowed(unknownFilters: string[], allowedFilters: string[]): InvalidFilterQuery;
 }
+//#endregion
+export { InvalidFilterQuery };

package/build/src/exceptions/invalid_filter_query.js

@@ -0,0 +1,18 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+//#region src/exceptions/invalid_filter_query.ts
+var InvalidFilterQuery = class InvalidFilterQuery extends InvalidQuery {
+	unknownFilters;
+	allowedFilters;
+	constructor(unknownFilters, allowedFilters) {
+		const message = `Requested filter(s) \`${unknownFilters.join(", ")}\` are not allowed. Allowed filter(s) are \`${allowedFilters.join(", ")}\``;
+		super(message, { status: ResponseStatus.BadRequest });
+		this.unknownFilters = unknownFilters;
+		this.allowedFilters = allowedFilters;
+	}
+	static filtersNotAllowed(unknownFilters, allowedFilters) {
+		return new InvalidFilterQuery(unknownFilters, allowedFilters);
+	}
+};
+//#endregion
+export { InvalidFilterQuery };

package/build/src/exceptions/invalid_filter_value.d.ts

@@ -1,4 +1,8 @@
-import { Exception } from '@adonisjs/core/exceptions';
-export declare class InvalidFilterValue extends Exception {
-    static make(value: unknown): InvalidFilterValue;
+import { Exception } from "@adonisjs/core/exceptions";
+
+//#region src/exceptions/invalid_filter_value.d.ts
+declare class InvalidFilterValue extends Exception {
+  static make(value: unknown): InvalidFilterValue;
 }
+//#endregion
+export { InvalidFilterValue };

package/build/src/exceptions/invalid_filter_value.js

@@ -0,0 +1,9 @@
+import { Exception } from "@adonisjs/core/exceptions";
+//#region src/exceptions/invalid_filter_value.ts
+var InvalidFilterValue = class InvalidFilterValue extends Exception {
+	static make(value) {
+		return new InvalidFilterValue(`Filter value \`${value}\` is invalid`);
+	}
+};
+//#endregion
+export { InvalidFilterValue };

package/build/src/exceptions/invalid_include_query.d.ts

@@ -1,7 +1,11 @@
-import { InvalidQuery } from './invalid_query.js';
-export declare class InvalidIncludeQuery extends InvalidQuery {
-    readonly unknownIncludes: string[];
-    readonly allowedIncludes: string[];
-    constructor(unknownIncludes: string[], allowedIncludes: string[]);
-    static includesNotAllowed(unknownIncludes: string[], allowedIncludes: string[]): InvalidIncludeQuery;
+import { InvalidQuery } from "./invalid_query.js";
+
+//#region src/exceptions/invalid_include_query.d.ts
+declare class InvalidIncludeQuery extends InvalidQuery {
+  readonly unknownIncludes: string[];
+  readonly allowedIncludes: string[];
+  constructor(unknownIncludes: string[], allowedIncludes: string[]);
+  static includesNotAllowed(unknownIncludes: string[], allowedIncludes: string[]): InvalidIncludeQuery;
 }
+//#endregion
+export { InvalidIncludeQuery };

package/build/src/exceptions/invalid_include_query.js

@@ -0,0 +1,22 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+//#region src/exceptions/invalid_include_query.ts
+var InvalidIncludeQuery = class InvalidIncludeQuery extends InvalidQuery {
+	unknownIncludes;
+	allowedIncludes;
+	constructor(unknownIncludes, allowedIncludes) {
+		let message = `Requested include(s) \`${unknownIncludes.join(", ")}\` are not allowed. `;
+		if (allowedIncludes.length > 0) {
+			const allowed = allowedIncludes.join(", ");
+			message += `Allowed include(s) are \`${allowed}\``;
+		} else message += "There are no allowed includes";
+		super(message, { status: ResponseStatus.BadRequest });
+		this.unknownIncludes = unknownIncludes;
+		this.allowedIncludes = allowedIncludes;
+	}
+	static includesNotAllowed(unknownIncludes, allowedIncludes) {
+		return new InvalidIncludeQuery(unknownIncludes, allowedIncludes);
+	}
+};
+//#endregion
+export { InvalidIncludeQuery };

package/build/src/exceptions/invalid_query.d.ts

@@ -1,4 +1,8 @@
-import { Exception } from '@adonisjs/core/exceptions';
-export declare abstract class InvalidQuery extends Exception {
-    static readonly code = "E_INVALID_QUERY_EXCEPTION";
+import { Exception } from "@adonisjs/core/exceptions";
+
+//#region src/exceptions/invalid_query.d.ts
+declare abstract class InvalidQuery extends Exception {
+  static readonly code = "E_INVALID_QUERY_EXCEPTION";
 }
+//#endregion
+export { InvalidQuery };

package/build/src/exceptions/invalid_query.js

@@ -0,0 +1,7 @@
+import { Exception } from "@adonisjs/core/exceptions";
+//#region src/exceptions/invalid_query.ts
+var InvalidQuery = class extends Exception {
+	static code = "E_INVALID_QUERY_EXCEPTION";
+};
+//#endregion
+export { InvalidQuery };

package/build/src/exceptions/invalid_sort_query.d.ts

@@ -1,7 +1,11 @@
-import { InvalidQuery } from './invalid_query.js';
-export declare class InvalidSortQuery extends InvalidQuery {
-    readonly unknownSorts: string[];
-    readonly allowedSorts: string[];
-    constructor(unknownSorts: string[], allowedSorts: string[]);
-    static sortsNotAllowed(unknownSorts: string[], allowedSorts: string[]): InvalidSortQuery;
+import { InvalidQuery } from "./invalid_query.js";
+
+//#region src/exceptions/invalid_sort_query.d.ts
+declare class InvalidSortQuery extends InvalidQuery {
+  readonly unknownSorts: string[];
+  readonly allowedSorts: string[];
+  constructor(unknownSorts: string[], allowedSorts: string[]);
+  static sortsNotAllowed(unknownSorts: string[], allowedSorts: string[]): InvalidSortQuery;
 }
+//#endregion
+export { InvalidSortQuery };

package/build/src/exceptions/invalid_sort_query.js

@@ -0,0 +1,18 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+//#region src/exceptions/invalid_sort_query.ts
+var InvalidSortQuery = class InvalidSortQuery extends InvalidQuery {
+	unknownSorts;
+	allowedSorts;
+	constructor(unknownSorts, allowedSorts) {
+		const message = `Requested sort(s) \`${unknownSorts.join(", ")}\` is not allowed. Allowed sort(s) are \`${allowedSorts.join(", ")}\``;
+		super(message, { status: ResponseStatus.BadRequest });
+		this.unknownSorts = unknownSorts;
+		this.allowedSorts = allowedSorts;
+	}
+	static sortsNotAllowed(unknownSorts, allowedSorts) {
+		return new InvalidSortQuery(unknownSorts, allowedSorts);
+	}
+};
+//#endregion
+export { InvalidSortQuery };

package/build/src/exceptions/unknown_included_fields_query.d.ts

@@ -1,5 +1,9 @@
-import { InvalidQuery } from './invalid_query.js';
-export declare class UnknownIncludedFieldsQuery extends InvalidQuery {
-    readonly unknownFields: string[];
-    constructor(unknownFields: string[]);
+import { InvalidQuery } from "./invalid_query.js";
+
+//#region src/exceptions/unknown_included_fields_query.d.ts
+declare class UnknownIncludedFieldsQuery extends InvalidQuery {
+  readonly unknownFields: string[];
+  constructor(unknownFields: string[]);
 }
+//#endregion
+export { UnknownIncludedFieldsQuery };

package/build/src/exceptions/unknown_included_fields_query.js

@@ -0,0 +1,13 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+//#region src/exceptions/unknown_included_fields_query.ts
+var UnknownIncludedFieldsQuery = class extends InvalidQuery {
+	unknownFields;
+	constructor(unknownFields) {
+		const message = [`Requested field(s) \`${unknownFields.join(", ")}\` are not allowed (yet). `, "If you want to allow these fields, please make sure to call the QueryBuilder's `allowedFields` method before the `allowedIncludes` method"].join("");
+		super(message, { status: ResponseStatus.BadRequest });
+		this.unknownFields = unknownFields;
+	}
+};
+//#endregion
+export { UnknownIncludedFieldsQuery };

package/build/src/filters/filters_begin_with_strict.d.ts

@@ -1,7 +1,11 @@
-import { type LucidModel } from '@adonisjs/lucid/types/model';
-import { type StrictValuesWithoutRaw } from '@adonisjs/lucid/types/querybuilder';
-import { type Filter } from '../types.js';
-import { FiltersPartial } from './filters_partial.js';
-export declare class FiltersBeginWithStrict<Model extends LucidModel> extends FiltersPartial<Model> implements Filter<Model> {
-    protected getWhereRawParameters(value: StrictValuesWithoutRaw, property: string): [string, string[]];
+import { Filter } from "../../types.js";
+import { FiltersPartial } from "./filters_partial.js";
+import { LucidModel } from "@adonisjs/lucid/types/model";
+import { StrictValuesWithoutRaw } from "@adonisjs/lucid/types/querybuilder";
+
+//#region src/filters/filters_begin_with_strict.d.ts
+declare class FiltersBeginWithStrict<Model extends LucidModel> extends FiltersPartial<Model> implements Filter<Model> {
+  protected getWhereRawParameters(value: StrictValuesWithoutRaw, property: string): [string, string[]];
 }
+//#endregion
+export { FiltersBeginWithStrict };

package/build/src/filters/filters_begin_with_strict.js

@@ -0,0 +1,9 @@
+import { FiltersPartial } from "./filters_partial.js";
+//#region src/filters/filters_begin_with_strict.ts
+var FiltersBeginWithStrict = class FiltersBeginWithStrict extends FiltersPartial {
+	getWhereRawParameters(value, property) {
+		return [`${property} LIKE ?`, [`${FiltersBeginWithStrict.escapeLike(value.toString())}%`]];
+	}
+};
+//#endregion
+export { FiltersBeginWithStrict };

package/build/src/filters/filters_callback.d.ts

@@ -1,7 +1,11 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type Filter } from '../types.js';
-export declare class FiltersCallback<Model extends LucidModel> implements Filter<Model> {
-    private callback;
-    constructor(callback: (query: ModelQueryBuilderContract<Model>, value: unknown, property: string) => void);
-    handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: unknown, property: string): void;
+import { Filter } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+
+//#region src/filters/filters_callback.d.ts
+declare class FiltersCallback<Model extends LucidModel> implements Filter<Model> {
+  private callback;
+  constructor(callback: (query: ModelQueryBuilderContract<Model>, value: unknown, property: string) => void);
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: unknown, property: string): void;
 }
+//#endregion
+export { FiltersCallback };

package/build/src/filters/filters_callback.js

@@ -0,0 +1,12 @@
+//#region src/filters/filters_callback.ts
+var FiltersCallback = class {
+	callback;
+	constructor(callback) {
+		this.callback = callback;
+	}
+	handle(query, value, property) {
+		this.callback(query, value, property);
+	}
+};
+//#endregion
+export { FiltersCallback };

package/build/src/filters/filters_ends_with_strict.d.ts

@@ -1,7 +1,11 @@
-import { type LucidModel } from '@adonisjs/lucid/types/model';
-import { type StrictValuesWithoutRaw } from '@adonisjs/lucid/types/querybuilder';
-import { type Filter } from '../types.js';
-import { FiltersPartial } from './filters_partial.js';
-export declare class FiltersEndsWithStrict<Model extends LucidModel> extends FiltersPartial<Model> implements Filter<Model> {
-    protected getWhereRawParameters(value: StrictValuesWithoutRaw, property: string): [string, string[]];
+import { Filter } from "../../types.js";
+import { FiltersPartial } from "./filters_partial.js";
+import { LucidModel } from "@adonisjs/lucid/types/model";
+import { StrictValuesWithoutRaw } from "@adonisjs/lucid/types/querybuilder";
+
+//#region src/filters/filters_ends_with_strict.d.ts
+declare class FiltersEndsWithStrict<Model extends LucidModel> extends FiltersPartial<Model> implements Filter<Model> {
+  protected getWhereRawParameters(value: StrictValuesWithoutRaw, property: string): [string, string[]];
 }
+//#endregion
+export { FiltersEndsWithStrict };

package/build/src/filters/filters_ends_with_strict.js

@@ -0,0 +1,9 @@
+import { FiltersPartial } from "./filters_partial.js";
+//#region src/filters/filters_ends_with_strict.ts
+var FiltersEndsWithStrict = class FiltersEndsWithStrict extends FiltersPartial {
+	getWhereRawParameters(value, property) {
+		return [`${property} LIKE ?`, [`%${FiltersEndsWithStrict.escapeLike(value.toString())}`]];
+	}
+};
+//#endregion
+export { FiltersEndsWithStrict };

package/build/src/filters/filters_exact.d.ts

@@ -1,12 +1,16 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type StrictValuesWithoutRaw } from '@adonisjs/lucid/types/querybuilder';
-import { type Filter } from '../types.js';
-export declare class FiltersExact<Model extends LucidModel> implements Filter<Model> {
-    protected addRelationConstraint: boolean;
-    protected relationConstraints: string[];
-    constructor(addRelationConstraint?: boolean);
-    handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, property: string): void;
-    protected qualifyColumn(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, column: string): string;
-    protected isRelationProperty(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, property: string): boolean;
-    protected withRelationConstraint(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, property: string): void;
+import { Filter } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { StrictValuesWithoutRaw } from "@adonisjs/lucid/types/querybuilder";
+
+//#region src/filters/filters_exact.d.ts
+declare class FiltersExact<Model extends LucidModel> implements Filter<Model> {
+  protected shouldAddRelationConstraint: boolean;
+  protected relationConstraints: string[];
+  constructor(shouldAddRelationConstraint?: boolean);
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, property: string): void;
+  protected qualifyColumn(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, column: string): string;
+  protected isRelationProperty(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, property: string): boolean;
+  protected withRelationConstraint(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, property: string): void;
 }
+//#endregion
+export { FiltersExact };

package/build/src/filters/filters_exact.js

@@ -0,0 +1,47 @@
+import collect$1 from "collect.js";
+//#region src/filters/filters_exact.ts
+var FiltersExact = class {
+	shouldAddRelationConstraint;
+	relationConstraints = [];
+	constructor(shouldAddRelationConstraint = true) {
+		this.shouldAddRelationConstraint = shouldAddRelationConstraint;
+	}
+	handle(query, value, property) {
+		if (this.shouldAddRelationConstraint && this.isRelationProperty(query, property)) {
+			this.withRelationConstraint(query, value, property);
+			return;
+		}
+		if (Array.isArray(value)) {
+			query.whereIn(this.qualifyColumn(query, property), value);
+			return;
+		}
+		if (value === null) {
+			query.whereNull(this.qualifyColumn(query, property));
+			return;
+		}
+		query.where(this.qualifyColumn(query, property), "=", value);
+	}
+	qualifyColumn(query, column) {
+		if (column.includes(".")) return column;
+		return `${query.model.table}.${query.model.$getColumn(column)?.columnName}`;
+	}
+	isRelationProperty(query, property) {
+		if (!property.includes(".")) return false;
+		if (this.relationConstraints.includes(property)) return false;
+		const firstRelationShip = property.split(".", 1)[0];
+		return query.model.$relationsDefinitions.has(firstRelationShip);
+	}
+	withRelationConstraint(query, value, property) {
+		const [relation, relationProperty] = collect$1(property.split(".")).pipe((parts) => {
+			const rProperty = parts.pop();
+			return [parts.implode("."), rProperty];
+		});
+		query.whereHas(relation, (subQuery) => {
+			const columnName = this.qualifyColumn(subQuery, relationProperty);
+			this.relationConstraints.push(columnName);
+			this.handle(subQuery, value, columnName);
+		});
+	}
+};
+//#endregion
+export { FiltersExact };

package/build/src/filters/filters_operator.d.ts

@@ -1,14 +1,18 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type StrictValuesWithoutRaw } from '@adonisjs/lucid/types/querybuilder';
-import { FilterOperator } from '../enums/filter_operator.js';
-import { type Filter } from '../types.js';
-import { FiltersExact } from './filters_exact.js';
-export declare class FiltersOperator<Model extends LucidModel> extends FiltersExact<Model> implements Filter<Model> {
-    protected $addRelationConstraint: boolean;
-    protected $filterOperator: FilterOperator;
-    protected $boolean: 'and' | 'or';
-    constructor($addRelationConstraint: boolean, $filterOperator: FilterOperator, $boolean: 'and' | 'or');
-    handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw, property: string): void;
-    protected getDynamicFilterOperator(value: string): FilterOperator;
-    protected removeDynamicFilterOperatorFromValue(value: string, filterOperator: FilterOperator): string;
+import { FilterOperator } from "../enums/filter_operator.js";
+import { EnumType, Filter } from "../../types.js";
+import { FiltersExact } from "./filters_exact.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { StrictValuesWithoutRaw } from "@adonisjs/lucid/types/querybuilder";
+
+//#region src/filters/filters_operator.d.ts
+declare class FiltersOperator<Model extends LucidModel> extends FiltersExact<Model> implements Filter<Model> {
+  protected shouldAddRelationConstraint: boolean;
+  protected filterOperator: EnumType<typeof FilterOperator>;
+  protected boolean: 'and' | 'or';
+  constructor(shouldAddRelationConstraint: boolean, filterOperator: EnumType<typeof FilterOperator>, boolean: 'and' | 'or');
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, property: string): void;
+  protected getDynamicFilterOperator(value: string): EnumType<typeof FilterOperator>;
+  protected removeDynamicFilterOperatorFromValue(value: string, filterOperator: EnumType<typeof FilterOperator>): string;
 }
+//#endregion
+export { FiltersOperator };

package/build/src/filters/filters_operator.js

@@ -0,0 +1,53 @@
+import { substrReplace } from "../utils/helpers.js";
+import { FiltersExact } from "./filters_exact.js";
+import { FilterOperator } from "../enums/filter_operator.js";
+//#region src/filters/filters_operator.ts
+var FiltersOperator = class extends FiltersExact {
+	shouldAddRelationConstraint;
+	filterOperator;
+	boolean;
+	constructor(shouldAddRelationConstraint, filterOperator, boolean) {
+		super(shouldAddRelationConstraint);
+		this.shouldAddRelationConstraint = shouldAddRelationConstraint;
+		this.filterOperator = filterOperator;
+		this.boolean = boolean;
+	}
+	handle(query, value, property) {
+		let { filterOperator } = this;
+		if (this.shouldAddRelationConstraint && this.isRelationProperty(query, property)) {
+			this.withRelationConstraint(query, value, property);
+			return;
+		}
+		if (Array.isArray(value)) {
+			const items = value;
+			query.where((subQuery) => {
+				for (const item of items) this.handle(subQuery, item, property);
+			});
+			return;
+		}
+		if (value === null) {
+			query.whereNull(this.qualifyColumn(query, property));
+			return;
+		}
+		if (filterOperator === FilterOperator.Dynamic) {
+			filterOperator = this.getDynamicFilterOperator(value.toString());
+			value = this.removeDynamicFilterOperatorFromValue(value.toString(), filterOperator);
+		}
+		if (this.boolean === "and") {
+			query.where(this.qualifyColumn(query, property), filterOperator, value);
+			return;
+		}
+		query.orWhere(this.qualifyColumn(query, property), filterOperator, value);
+	}
+	getDynamicFilterOperator(value) {
+		let filterOperator = FilterOperator.Equal;
+		for (const filterOperatorCase of Object.values(FilterOperator)) if (value.startsWith(filterOperatorCase) && filterOperatorCase !== FilterOperator.Dynamic) filterOperator = filterOperatorCase;
+		return filterOperator;
+	}
+	removeDynamicFilterOperatorFromValue(value, filterOperator) {
+		if (value.includes(filterOperator)) value = substrReplace(value, "", 0, filterOperator.length);
+		return value;
+	}
+};
+//#endregion
+export { FiltersOperator };