@eienjs/adonisjs-api-query 1.1.0 → 2.0.0

package/build/src/allowed_filter.js

@@ -0,0 +1,113 @@
+import { ApiQueryBuilderRequest } from "./api_query_builder_request.js";
+import { FiltersExact } from "./filters/filters_exact.js";
+import { FiltersPartial } from "./filters/filters_partial.js";
+import { FiltersBeginWithStrict } from "./filters/filters_begin_with_strict.js";
+import { FiltersCallback } from "./filters/filters_callback.js";
+import { FiltersEndsWithStrict } from "./filters/filters_ends_with_strict.js";
+import { FiltersOperator } from "./filters/filters_operator.js";
+import { FiltersTrashed } from "./filters/filters_trashed.js";
+import { Collection } from "collect.js";
+//#region src/allowed_filter.ts
+var AllowedFilter = class AllowedFilter {
+	name;
+	filterClass;
+	internalName;
+	ignored;
+	default;
+	$hasDefault = false;
+	nullable = false;
+	constructor(name, filterClass, internalName) {
+		this.name = name;
+		this.filterClass = filterClass;
+		this.ignored = new Collection();
+		this.internalName = internalName ?? this.name;
+	}
+	filter(query, value) {
+		const valueToFilter = this.resolveValueForFiltering(value);
+		if (!this.nullable && valueToFilter === null) return;
+		this.filterClass.handle(query, valueToFilter, this.internalName);
+	}
+	getFilterClass() {
+		return this.filterClass;
+	}
+	getName() {
+		return this.name;
+	}
+	isForFilter(filterName) {
+		return this.name === filterName;
+	}
+	ignore(...values) {
+		this.ignored = this.ignored.merge(values).flatten();
+		return this;
+	}
+	getIgnored() {
+		return this.ignored.toArray();
+	}
+	getInternalName() {
+		return this.internalName;
+	}
+	setDefault(defaultValue) {
+		this.default = defaultValue;
+		this.$hasDefault = true;
+		if (defaultValue === null) this.setNullable(true);
+		return this;
+	}
+	getDefault() {
+		return this.default;
+	}
+	hasDefault() {
+		return this.$hasDefault;
+	}
+	setNullable(isNullable = true) {
+		this.nullable = isNullable;
+		return this;
+	}
+	unsetDefault() {
+		this.$hasDefault = false;
+		this.default = void 0;
+		return this;
+	}
+	resolveValueForFiltering(value) {
+		if (Array.isArray(value)) {
+			const remainingProperties = value.map((subValue) => this.resolveValueForFiltering(subValue));
+			return remainingProperties.length === 0 ? null : remainingProperties;
+		}
+		return this.ignored.contains(value) ? null : value;
+	}
+	static setFilterArrayValueDelimiter(delimiter) {
+		if (delimiter) ApiQueryBuilderRequest.setFilterArrayValueDelimiter(delimiter);
+	}
+	static exact(name, internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersExact(shouldAddRelationConstraint), internalName);
+	}
+	static partial(name, internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersPartial(shouldAddRelationConstraint), internalName);
+	}
+	static beginsWithStrict(name, internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersBeginWithStrict(shouldAddRelationConstraint), internalName);
+	}
+	static endsWithStrict(name, internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersEndsWithStrict(shouldAddRelationConstraint), internalName);
+	}
+	static callback(name, callback, internalName, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersCallback(callback), internalName);
+	}
+	static trashed(name = "trashed", internalName) {
+		return new AllowedFilter(name, new FiltersTrashed(), internalName);
+	}
+	static custom(name, filterClass, internalName, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, filterClass, internalName);
+	}
+	static operator(name, filterOperator, boolean = "and", internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersOperator(shouldAddRelationConstraint, filterOperator, boolean), internalName);
+	}
+};
+//#endregion
+export { AllowedFilter };

package/build/src/allowed_include.d.ts

@@ -1,17 +1,21 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type ModelRelations } from '@adonisjs/lucid/types/relations';
-import { Collection } from 'collect.js';
-import { type Include } from './types.js';
-export declare class AllowedInclude<Model extends LucidModel> {
-    static relationship<ParentModel extends LucidModel>(name: string, internalName?: string): Collection<AllowedInclude<ParentModel>>;
-    static count<ParentModel extends LucidModel>(name: string, internalName?: string): Collection<AllowedInclude<ParentModel>>;
-    static callback<ParentModel extends LucidModel, RelatedModel extends LucidModel>(name: string, callback: (query: ModelRelations<RelatedModel, ParentModel>['builder'] | ModelRelations<RelatedModel, ParentModel>['subQuery']) => void, internalName?: string): Collection<AllowedInclude<ParentModel>>;
-    static custom<ParentModel extends LucidModel>(name: string, includeClass: Include<ParentModel>, internalName?: string): Collection<AllowedInclude<ParentModel>>;
-    protected internalName: string;
-    protected name: string;
-    protected includeClass: Include<Model>;
-    constructor(name: string, includeClass: Include<Model>, internalName?: string);
-    include(query: ModelQueryBuilderContract<Model>): void;
-    getName(): string;
-    isForInclude(includeName: string): boolean;
+import { Include } from "../types.js";
+import { Collection } from "collect.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { ModelRelations } from "@adonisjs/lucid/types/relations";
+
+//#region src/allowed_include.d.ts
+declare class AllowedInclude<Model extends LucidModel> {
+  protected internalName: string;
+  protected name: string;
+  protected includeClass: Include<Model>;
+  constructor(name: string, includeClass: Include<Model>, internalName?: string);
+  include(query: ModelQueryBuilderContract<Model>): void;
+  getName(): string;
+  isForInclude(includeName: string): boolean;
+  static relationship<ParentModel extends LucidModel>(name: string, internalName?: string): Collection<AllowedInclude<ParentModel>>;
+  static count<ParentModel extends LucidModel>(name: string, internalName?: string): Collection<AllowedInclude<ParentModel>>;
+  static callback<ParentModel extends LucidModel, RelatedModel extends LucidModel>(name: string, callback: (query: ModelRelations<RelatedModel, ParentModel>['builder'] | ModelRelations<RelatedModel, ParentModel>['subQuery']) => void, internalName?: string): Collection<AllowedInclude<ParentModel>>;
+  static custom<ParentModel extends LucidModel>(name: string, includeClass: Include<ParentModel>, internalName?: string): Collection<AllowedInclude<ParentModel>>;
 }
+//#endregion
+export { AllowedInclude };

package/build/src/allowed_include.js

@@ -0,0 +1,48 @@
+import { IncludedCallback } from "./includes/included_callback.js";
+import { IncludedCount } from "./includes/included_count.js";
+import { IncludedRelationship } from "./includes/included_relationship.js";
+import { Collection } from "collect.js";
+import app from "@adonisjs/core/services/app";
+//#region src/allowed_include.ts
+var AllowedInclude = class AllowedInclude {
+	internalName;
+	name;
+	includeClass;
+	constructor(name, includeClass, internalName) {
+		this.name = name;
+		this.includeClass = includeClass;
+		this.internalName = internalName ?? this.name;
+	}
+	include(query) {
+		this.includeClass.handle(query, this.internalName);
+	}
+	getName() {
+		return this.name;
+	}
+	isForInclude(includeName) {
+		return this.name === includeName;
+	}
+	static relationship(name, internalName) {
+		internalName ??= name;
+		return IncludedRelationship.getIndividualRelationshipPathsFromInclude(internalName).zip(IncludedRelationship.getIndividualRelationshipPathsFromInclude(name).toArray()).reduce((includes, args) => {
+			const [relationship, alias] = args;
+			includes = includes.push(new AllowedInclude(alias, new IncludedRelationship(), relationship));
+			if (!relationship.includes(".")) {
+				const countSuffix = app.config.get("apiquery.countSuffix", "Count");
+				for (const countAllowedInclude of this.count(`${alias}${countSuffix}`, `${relationship}${countSuffix}`)) includes = includes.push(countAllowedInclude);
+			}
+			return includes;
+		}, new Collection());
+	}
+	static count(name, internalName) {
+		return new Collection([new AllowedInclude(name, new IncludedCount(), internalName)]);
+	}
+	static callback(name, callback, internalName) {
+		return new Collection([new AllowedInclude(name, new IncludedCallback(callback), internalName)]);
+	}
+	static custom(name, includeClass, internalName) {
+		return new Collection([new AllowedInclude(name, includeClass, internalName)]);
+	}
+};
+//#endregion
+export { AllowedInclude };

package/build/src/allowed_sort.d.ts

@@ -1,18 +1,22 @@
-import { type LucidModel, type ModelAttributes, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type ExtractKeys, type Sort } from './types.js';
-export declare class AllowedSort<Model extends LucidModel> {
-    static parseSortDirection(name: string): string;
-    static field<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
-    static custom<Model extends LucidModel>(name: string, sortClass: Sort<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
-    static callback<Model extends LucidModel>(name: string, callback: (query: ModelQueryBuilderContract<Model>, descending: boolean, property: string) => void, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
-    protected defaultDirection: string;
-    protected internalName: string;
-    protected name: string;
-    protected sortClass: Sort<Model>;
-    constructor(name: string, sortClass: Sort<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>);
-    sort(query: ModelQueryBuilderContract<Model>, descending?: boolean): void;
-    getName(): string;
-    isSort(sortName: string): boolean;
-    getInternalName(): string;
-    setDefaultDirection(defaultDirection: string): this;
+import { ExtractKeys, Sort } from "../types.js";
+import { LucidModel, ModelAttributes, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+
+//#region src/allowed_sort.d.ts
+declare class AllowedSort<Model extends LucidModel> {
+  protected defaultDirection: string;
+  protected internalName: string;
+  protected name: string;
+  protected sortClass: Sort<Model>;
+  constructor(name: string, sortClass: Sort<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>);
+  sort(query: ModelQueryBuilderContract<Model>, isDescending?: boolean): void;
+  getName(): string;
+  isSort(sortName: string): boolean;
+  getInternalName(): string;
+  setDefaultDirection(defaultDirection: string): this;
+  static parseSortDirection(name: string): string;
+  static field<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
+  static custom<Model extends LucidModel>(name: string, sortClass: Sort<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
+  static callback<Model extends LucidModel>(name: string, callback: (query: ModelQueryBuilderContract<Model>, isDescending: boolean, property: string) => void, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
 }
+//#endregion
+export { AllowedSort };

package/build/src/allowed_sort.js

@@ -0,0 +1,50 @@
+import { SortDirection } from "./enums/sort_direction.js";
+import { InvalidDirection } from "./exceptions/invalid_direction.js";
+import { SortsCallback } from "./sorts/sorts_callback.js";
+import { SortsField } from "./sorts/sorts_field.js";
+//#region src/allowed_sort.ts
+const REMOVE_HYPHEN_STARTING_IN_ANY_POSITION = /^-+/;
+var AllowedSort = class AllowedSort {
+	defaultDirection;
+	internalName;
+	name;
+	sortClass;
+	constructor(name, sortClass, internalName) {
+		this.name = name.replace(REMOVE_HYPHEN_STARTING_IN_ANY_POSITION, "");
+		this.defaultDirection = AllowedSort.parseSortDirection(name);
+		this.sortClass = sortClass;
+		this.internalName = internalName ?? this.name;
+	}
+	sort(query, isDescending) {
+		isDescending ??= this.defaultDirection === SortDirection.Descending;
+		this.sortClass.handle(query, isDescending, this.internalName);
+	}
+	getName() {
+		return this.name;
+	}
+	isSort(sortName) {
+		return this.name === sortName;
+	}
+	getInternalName() {
+		return this.internalName;
+	}
+	setDefaultDirection(defaultDirection) {
+		if (![SortDirection.Ascending, SortDirection.Descending].includes(defaultDirection)) throw InvalidDirection.make(defaultDirection);
+		this.defaultDirection = defaultDirection;
+		return this;
+	}
+	static parseSortDirection(name) {
+		return name.startsWith("-") ? SortDirection.Descending : SortDirection.Ascending;
+	}
+	static field(name, internalName) {
+		return new AllowedSort(name, new SortsField(), internalName);
+	}
+	static custom(name, sortClass, internalName) {
+		return new AllowedSort(name, sortClass, internalName);
+	}
+	static callback(name, callback, internalName) {
+		return new AllowedSort(name, new SortsCallback(callback), internalName);
+	}
+};
+//#endregion
+export { AllowedSort };

package/build/src/api_query_builder_request.d.ts

@@ -1,31 +1,35 @@
-import { type Request } from '@adonisjs/core/http';
-import { Collection } from 'collect.js';
-export declare class ApiQueryBuilderRequest {
-    protected static includesArrayValueDelimiter: string;
-    protected static appendsArrayValueDelimiter: string;
-    protected static fieldsArrayValueDelimiter: string;
-    protected static sortsArrayValueDelimiter: string;
-    protected static filterArrayValueDelimiter: string;
-    static setArrayValueDelimiter(delimiter: string): void;
-    static setIncludesArrayValueDelimiter(includesArrayValueDelimiter: string): void;
-    static setAppendsArrayValueDelimiter(appendsArrayValueDelimiter: string): void;
-    static setFieldsArrayValueDelimiter(fieldsArrayValueDelimiter: string): void;
-    static setSortsArrayValueDelimiter(sortsArrayValueDelimiter: string): void;
-    static setFilterArrayValueDelimiter(filterArrayValueDelimiter: string): void;
-    static getIncludesArrayValueDelimiter(): string;
-    static getAppendsArrayValueDelimiter(): string;
-    static getFieldsArrayValueDelimiter(): string;
-    static getSortsArrayValueDelimiter(): string;
-    static getFilterArrayValueDelimiter(): string;
-    static resetDelimiters(): void;
-    static fromRequest(request: Request): ApiQueryBuilderRequest;
-    private readonly _request;
-    constructor(request?: Request);
-    includes(): Collection<string>;
-    appends(): Collection<unknown>;
-    fields(): Collection<unknown>;
-    sorts(): Collection<string>;
-    filters(): Collection<unknown>;
-    protected getFilterValue(value: unknown): unknown;
-    protected getRequestData<T = unknown>(key: string, defaultValue?: T): T;
+import { Collection } from "collect.js";
+import { HttpRequest } from "@adonisjs/core/http";
+
+//#region src/api_query_builder_request.d.ts
+declare class ApiQueryBuilderRequest {
+  protected static includesArrayValueDelimiter: string;
+  protected static appendsArrayValueDelimiter: string;
+  protected static fieldsArrayValueDelimiter: string;
+  protected static sortsArrayValueDelimiter: string;
+  protected static filterArrayValueDelimiter: string;
+  private readonly _request;
+  constructor(request?: HttpRequest);
+  includes(): Collection<string>;
+  appends(): Collection<unknown>;
+  fields(): Collection<unknown>;
+  sorts(): Collection<string>;
+  filters(): Collection<unknown>;
+  protected getFilterValue(value: unknown): unknown;
+  protected getRequestData<T = unknown>(key: string, defaultValue?: T): T;
+  static setArrayValueDelimiter(delimiter: string): void;
+  static setIncludesArrayValueDelimiter(includesArrayValueDelimiter: string): void;
+  static setAppendsArrayValueDelimiter(appendsArrayValueDelimiter: string): void;
+  static setFieldsArrayValueDelimiter(fieldsArrayValueDelimiter: string): void;
+  static setSortsArrayValueDelimiter(sortsArrayValueDelimiter: string): void;
+  static setFilterArrayValueDelimiter(filterArrayValueDelimiter: string): void;
+  static getIncludesArrayValueDelimiter(): string;
+  static getAppendsArrayValueDelimiter(): string;
+  static getFieldsArrayValueDelimiter(): string;
+  static getSortsArrayValueDelimiter(): string;
+  static getFilterArrayValueDelimiter(): string;
+  static resetDelimiters(): void;
+  static fromRequest(request: HttpRequest): ApiQueryBuilderRequest;
 }
+//#endregion
+export { ApiQueryBuilderRequest };

package/build/src/api_query_builder_request.js

@@ -0,0 +1,122 @@
+import { strAfterLast, strBeforeLast } from "./utils/helpers.js";
+import { Collection } from "collect.js";
+import { HttpContext } from "@adonisjs/core/http";
+import app from "@adonisjs/core/services/app";
+//#region src/api_query_builder_request.ts
+var ApiQueryBuilderRequest = class ApiQueryBuilderRequest {
+	static includesArrayValueDelimiter = ",";
+	static appendsArrayValueDelimiter = ",";
+	static fieldsArrayValueDelimiter = ",";
+	static sortsArrayValueDelimiter = ",";
+	static filterArrayValueDelimiter = ",";
+	_request;
+	constructor(request) {
+		if (!request) request = HttpContext.getOrFail().request;
+		this._request = request;
+	}
+	includes() {
+		const includeParameterName = app.config.get("apiquery.parameters.include", "include");
+		let includeParts = this.getRequestData(includeParameterName, []);
+		if (typeof includeParts === "string") includeParts = includeParts.split(ApiQueryBuilderRequest.getIncludesArrayValueDelimiter());
+		return new Collection(includeParts).filter();
+	}
+	appends() {
+		const appendParameterName = app.config.get("apiquery.parameters.append", "append");
+		let appendParts = this.getRequestData(appendParameterName, {});
+		if (typeof appendParts === "string") appendParts = appendParts.split(ApiQueryBuilderRequest.getAppendsArrayValueDelimiter());
+		return new Collection(appendParts).filter();
+	}
+	fields() {
+		const fieldsParameterName = app.config.get("apiquery.parameters.fields", "fields");
+		const fieldsData = this.getRequestData(fieldsParameterName, {});
+		const fieldsPerTable = new Collection(typeof fieldsData === "string" ? fieldsData.split(ApiQueryBuilderRequest.getFieldsArrayValueDelimiter()) : fieldsData);
+		if (fieldsPerTable.isEmpty()) return new Collection();
+		const fields = {};
+		fieldsPerTable.each((tableFields, model) => {
+			if (!model || typeof model === "number") model = typeof tableFields === "string" && tableFields.includes(".") ? strBeforeLast(tableFields, ".") : "_";
+			if (!Object.hasOwn(fields, model)) fields[model] = [];
+			if (typeof tableFields === "string") tableFields = tableFields.split(ApiQueryBuilderRequest.getFieldsArrayValueDelimiter()).map((field) => {
+				return strAfterLast(field, ".");
+			});
+			fields[model] = [...fields[model], ...tableFields];
+		});
+		return new Collection(fields);
+	}
+	sorts() {
+		const sortParameterName = app.config.get("apiquery.parameters.sort", "sort");
+		let sortParts = this.getRequestData(sortParameterName, []);
+		if (typeof sortParts === "string") sortParts = sortParts.split(ApiQueryBuilderRequest.getSortsArrayValueDelimiter());
+		return new Collection(sortParts).filter();
+	}
+	filters() {
+		const filterParameterName = app.config.get("apiquery.parameters.filter", "filter");
+		const filterParts = this.getRequestData(filterParameterName, []);
+		if (typeof filterParts === "string") return new Collection();
+		return new Collection(filterParts).map((value) => {
+			return this.getFilterValue(value);
+		});
+	}
+	getFilterValue(value) {
+		if (value === void 0 || value === null) return null;
+		if (value === "" || Array.isArray(value) && value.length === 0 || typeof value === "object" && Object.keys(value).length === 0) return typeof value === "object" ? [] : value;
+		if (Array.isArray(value) || typeof value === "object") return new Collection(value).map((valueValue) => {
+			return this.getFilterValue(valueValue);
+		}).all();
+		if (typeof value === "string" && value.includes(ApiQueryBuilderRequest.getFilterArrayValueDelimiter())) return value.split(ApiQueryBuilderRequest.getFilterArrayValueDelimiter());
+		if (value === "true") return true;
+		if (value === "false") return false;
+		return value;
+	}
+	getRequestData(key, defaultValue) {
+		return this._request.input(key, defaultValue);
+	}
+	static setArrayValueDelimiter(delimiter) {
+		this.includesArrayValueDelimiter = delimiter;
+		this.appendsArrayValueDelimiter = delimiter;
+		this.fieldsArrayValueDelimiter = delimiter;
+		this.sortsArrayValueDelimiter = delimiter;
+		this.filterArrayValueDelimiter = delimiter;
+	}
+	static setIncludesArrayValueDelimiter(includesArrayValueDelimiter) {
+		this.includesArrayValueDelimiter = includesArrayValueDelimiter;
+	}
+	static setAppendsArrayValueDelimiter(appendsArrayValueDelimiter) {
+		this.appendsArrayValueDelimiter = appendsArrayValueDelimiter;
+	}
+	static setFieldsArrayValueDelimiter(fieldsArrayValueDelimiter) {
+		this.fieldsArrayValueDelimiter = fieldsArrayValueDelimiter;
+	}
+	static setSortsArrayValueDelimiter(sortsArrayValueDelimiter) {
+		this.sortsArrayValueDelimiter = sortsArrayValueDelimiter;
+	}
+	static setFilterArrayValueDelimiter(filterArrayValueDelimiter) {
+		this.filterArrayValueDelimiter = filterArrayValueDelimiter;
+	}
+	static getIncludesArrayValueDelimiter() {
+		return this.includesArrayValueDelimiter;
+	}
+	static getAppendsArrayValueDelimiter() {
+		return this.appendsArrayValueDelimiter;
+	}
+	static getFieldsArrayValueDelimiter() {
+		return this.fieldsArrayValueDelimiter;
+	}
+	static getSortsArrayValueDelimiter() {
+		return this.sortsArrayValueDelimiter;
+	}
+	static getFilterArrayValueDelimiter() {
+		return this.filterArrayValueDelimiter;
+	}
+	static resetDelimiters() {
+		this.includesArrayValueDelimiter = ",";
+		this.appendsArrayValueDelimiter = ",";
+		this.fieldsArrayValueDelimiter = ",";
+		this.sortsArrayValueDelimiter = ",";
+		this.filterArrayValueDelimiter = ",";
+	}
+	static fromRequest(request) {
+		return new ApiQueryBuilderRequest(request);
+	}
+};
+//#endregion
+export { ApiQueryBuilderRequest };

package/build/src/bindings/api_query_request.js

@@ -0,0 +1,13 @@
+import { ApiQueryBuilderRequest } from "../api_query_builder_request.js";
+//#region src/bindings/api_query_request.ts
+const extendModelQueryBuilderWithRequest = function(builder) {
+	builder.macro("withRequest", function(request) {
+		this.$queryBuilderRequest = ApiQueryBuilderRequest.fromRequest(request);
+		return this;
+	});
+	builder.getter("$apiQueryBuilderRequest", function() {
+		return this.$queryBuilderRequest ?? new ApiQueryBuilderRequest();
+	});
+};
+//#endregion
+export { extendModelQueryBuilderWithRequest };

package/build/src/bindings/filters_query.js

@@ -0,0 +1,40 @@
+import { AllowedFilter } from "../allowed_filter.js";
+import { InvalidFilterQuery } from "../exceptions/invalid_filter_query.js";
+import collect$1 from "collect.js";
+//#region src/bindings/filters_query.ts
+const extendModelQueryBuilderWithFiltersQuery = function(builder, config) {
+	const ensureAllFiltersExist = (self) => {
+		if (config.disableInvalidFilterQueryException) return;
+		const filterNames = self.$apiQueryBuilderRequest.filters().keys();
+		const allowedFilterNames = self._allowedFilters.map((allowedFilter) => {
+			return allowedFilter.getName();
+		});
+		const diff = filterNames.diff(allowedFilterNames);
+		if (diff.isNotEmpty()) throw InvalidFilterQuery.filtersNotAllowed(diff.all(), allowedFilterNames.all());
+	};
+	const isFilterRequested = (self, allowedFilter) => {
+		return self.$apiQueryBuilderRequest.filters().has(allowedFilter.getName());
+	};
+	const addRequestedFiltersToQuery = (query) => {
+		query._allowedFilters.each((allowedFilter) => {
+			if (isFilterRequested(query, allowedFilter)) {
+				const value = query.$apiQueryBuilderRequest.filters().get(allowedFilter.getName());
+				allowedFilter.filter(query, value);
+				return;
+			}
+			if (allowedFilter.hasDefault()) allowedFilter.filter(query, allowedFilter.getDefault());
+		});
+	};
+	builder.macro("allowedFilters", function(...filters) {
+		const arrayFilters = Array.isArray(filters.at(0)) ? filters.at(0) : filters;
+		this._allowedFilters = collect$1(arrayFilters).map((filter) => {
+			if (filter instanceof AllowedFilter) return filter;
+			return AllowedFilter.partial(filter);
+		});
+		ensureAllFiltersExist(this);
+		addRequestedFiltersToQuery(this);
+		return this;
+	});
+};
+//#endregion
+export { extendModelQueryBuilderWithFiltersQuery };

package/build/src/bindings/includes_query.js

@@ -0,0 +1,51 @@
+import { AllowedInclude } from "../allowed_include.js";
+import { InvalidIncludeQuery } from "../exceptions/invalid_include_query.js";
+import { Collection } from "collect.js";
+//#region src/bindings/includes_query.ts
+const extendModelQueryBuilderWithIncludesQuery = function(builder, config) {
+	const ensureAllIncludesExist = (self) => {
+		if (config.disableInvalidIncludesQueryException) return;
+		const includes = self.$apiQueryBuilderRequest.includes();
+		const allowedIncludeNames = self._allowedIncludes.map((allowedInclude) => {
+			return allowedInclude.getName();
+		});
+		const diff = includes.diff(allowedIncludeNames);
+		if (diff.isNotEmpty()) throw InvalidIncludeQuery.includesNotAllowed(diff.all(), allowedIncludeNames.all());
+	};
+	const findInclude = (self, include) => {
+		return self._allowedIncludes.first((included) => included.isForInclude(include));
+	};
+	const filterNonExistingIncludes = (self) => {
+		const includes = self.$apiQueryBuilderRequest.includes();
+		if (!config.disableInvalidIncludesQueryException) return includes;
+		return includes.filter((include) => !findInclude(self, include));
+	};
+	const addIncludesToQuery = (self, includes) => {
+		includes.each((include) => {
+			findInclude(self, include)?.include(self);
+		});
+	};
+	builder.macro("allowedIncludes", function(...includes) {
+		const arrayIncludes = Array.isArray(includes.at(0)) ? includes.at(0) : includes;
+		this._allowedIncludes = new Collection(arrayIncludes).reject((include) => typeof include === "string" && include.length === 0).reduce((result, include) => {
+			if (include instanceof Collection) {
+				for (const allowedInclude of include) result = result.push(allowedInclude);
+				return result;
+			}
+			if (include.endsWith(config.countSuffix)) {
+				for (const allowedInclude of AllowedInclude.count(include)) result = result.push(allowedInclude);
+				return result;
+			}
+			for (const allowedInclude of AllowedInclude.relationship(include)) result = result.push(allowedInclude);
+			return result;
+		}, new Collection()).unique((allowedInclude) => {
+			return allowedInclude.getName();
+		});
+		ensureAllIncludesExist(this);
+		const resultIncludes = filterNonExistingIncludes(this);
+		addIncludesToQuery(this, resultIncludes);
+		return this;
+	});
+};
+//#endregion
+export { extendModelQueryBuilderWithIncludesQuery };

package/build/src/bindings/sorts_query.js

@@ -0,0 +1,45 @@
+import { AllowedSort } from "../allowed_sort.js";
+import { InvalidSortQuery } from "../exceptions/invalid_sort_query.js";
+import { collect } from "collect.js";
+//#region src/bindings/sorts_query.ts
+const DESCENDING_ORDER_PREFIX = /^-+/;
+const extendModelQueryBuilderWithSortsQuery = function(builder, config) {
+	const ensureAllSortsExist = (self) => {
+		if (config.disableInvalidSortQueryException) return;
+		const requestedSortNames = self.$apiQueryBuilderRequest.sorts().map((sort) => sort.replace(DESCENDING_ORDER_PREFIX, ""));
+		const allowedSortNames = self._allowedSorts.map((sort) => sort.getName());
+		const unknownSort = requestedSortNames.diff(allowedSortNames);
+		if (unknownSort.isNotEmpty()) throw InvalidSortQuery.sortsNotAllowed(unknownSort.all(), allowedSortNames.all());
+	};
+	const findSort = (self, property) => {
+		return self._allowedSorts.first((sort) => sort.isSort(property));
+	};
+	const addRequestedSortsToQuery = (self) => {
+		self.$apiQueryBuilderRequest.sorts().each((property) => {
+			const isDescending = property.startsWith("-");
+			findSort(self, property.replace(DESCENDING_ORDER_PREFIX, ""))?.sort(self, isDescending);
+		});
+	};
+	builder.macro("allowedSorts", function(...sorts) {
+		const arraySorts = Array.isArray(sorts.at(0)) ? sorts.at(0) : sorts;
+		this._allowedSorts = collect(arraySorts).map((sort) => {
+			if (sort instanceof AllowedSort) return sort;
+			return AllowedSort.field(sort.replace(DESCENDING_ORDER_PREFIX, ""));
+		});
+		ensureAllSortsExist(this);
+		addRequestedSortsToQuery(this);
+		return this;
+	});
+	builder.macro("defaultSort", function(...sorts) {
+		if (this.$apiQueryBuilderRequest.sorts().isNotEmpty()) return this;
+		collect(Array.isArray(sorts.at(0)) ? sorts.at(0) : sorts).map((sort) => {
+			if (sort instanceof AllowedSort) return sort;
+			return AllowedSort.field(sort);
+		}).each((sort) => {
+			sort.sort(this);
+		});
+		return this;
+	});
+};
+//#endregion
+export { extendModelQueryBuilderWithSortsQuery };

package/build/src/define_config.d.ts

@@ -1,3 +1,7 @@
-import { type ConfigProvider } from '@adonisjs/core/types';
-import { type ApiQueryConfig, type ResolvedApiQueryConfig } from './types.js';
-export declare const defineConfig: (config: ApiQueryConfig) => ConfigProvider<ResolvedApiQueryConfig>;
+import { ApiQueryConfig, ResolvedApiQueryConfig } from "../types.js";
+import { ConfigProvider } from "@adonisjs/core/types";
+
+//#region src/define_config.d.ts
+declare const defineConfig: (config: ApiQueryConfig) => ConfigProvider<ResolvedApiQueryConfig>;
+//#endregion
+export { defineConfig };