@eienjs/adonisjs-api-query 2.0.0 → 3.0.1

package/build/src/bindings/includes_query.js

@@ -1,51 +1,50 @@
 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
+// 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 ensureAllIncludesExist = (self, requestedIncludes) => {
+		if (config.disableInvalidIncludesQueryException || requestedIncludes.length === 0) return;
+		const allowedIncludeNames = self._allowedIncludes.map((allowedInclude) => allowedInclude.getName());
+		const allowedSet = new Set(allowedIncludeNames);
+		const diff = requestedIncludes.filter((include) => !allowedSet.has(include));
+		if (diff.length > 0) throw InvalidIncludeQuery.includesNotAllowed(diff, allowedIncludeNames);
 	};
 	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));
+		return self._allowedIncludes.find((included) => included.isForInclude(include));
 	};
 	const addIncludesToQuery = (self, includes) => {
-		includes.each((include) => {
-			findInclude(self, include)?.include(self);
-		});
+		for (const include of includes) 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;
+		const reduced = [];
+		for (const include of arrayIncludes) {
+			if (typeof include === "string" && include.length === 0) continue;
+			if (Array.isArray(include)) {
+				reduced.push(...include);
+				continue;
+			}
+			if (include instanceof AllowedInclude) {
+				reduced.push(include);
+				continue;
 			}
 			if (include.endsWith(config.countSuffix)) {
-				for (const allowedInclude of AllowedInclude.count(include)) result = result.push(allowedInclude);
-				return result;
+				reduced.push(...AllowedInclude.count(include));
+				continue;
 			}
-			for (const allowedInclude of AllowedInclude.relationship(include)) result = result.push(allowedInclude);
-			return result;
-		}, new Collection()).unique((allowedInclude) => {
-			return allowedInclude.getName();
+			reduced.push(...AllowedInclude.relationship(include));
+		}
+		const seen = /* @__PURE__ */ new Set();
+		this._allowedIncludes = reduced.filter((allowedInclude) => {
+			const name = allowedInclude.getName();
+			if (seen.has(name)) return false;
+			seen.add(name);
+			return true;
 		});
-		ensureAllIncludesExist(this);
-		const resultIncludes = filterNonExistingIncludes(this);
-		addIncludesToQuery(this, resultIncludes);
+		const requestedIncludes = this.$apiQueryBuilderRequest.includes();
+		ensureAllIncludesExist(this, requestedIncludes);
+		addIncludesToQuery(this, requestedIncludes);
 		return this;
 	});
 };
-//#endregion
 export { extendModelQueryBuilderWithIncludesQuery };

package/build/src/bindings/sorts_query.js

@@ -1,45 +1,42 @@
 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
+// 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 ensureAllSortsExist = (self, requestedSorts) => {
+		if (config.disableInvalidSortQueryException || requestedSorts.length === 0) return;
+		const requestedSortNames = requestedSorts.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 allowedSet = new Set(allowedSortNames);
+		const unknownSort = requestedSortNames.filter((sort) => !allowedSet.has(sort));
+		if (unknownSort.length > 0) throw InvalidSortQuery.sortsNotAllowed(unknownSort, allowedSortNames);
 	};
 	const findSort = (self, property) => {
-		return self._allowedSorts.first((sort) => sort.isSort(property));
+		return self._allowedSorts.find((sort) => sort.isSort(property));
 	};
-	const addRequestedSortsToQuery = (self) => {
-		self.$apiQueryBuilderRequest.sorts().each((property) => {
+	const addRequestedSortsToQuery = (self, requestedSorts) => {
+		for (const property of requestedSorts) {
 			const isDescending = property.startsWith("-");
-			findSort(self, property.replace(DESCENDING_ORDER_PREFIX, ""))?.sort(self, isDescending);
-		});
+			const key = property.replace(DESCENDING_ORDER_PREFIX, "");
+			findSort(self, key)?.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) => {
+		this._allowedSorts = arraySorts.map((sort) => {
 			if (sort instanceof AllowedSort) return sort;
 			return AllowedSort.field(sort.replace(DESCENDING_ORDER_PREFIX, ""));
 		});
-		ensureAllSortsExist(this);
-		addRequestedSortsToQuery(this);
+		const requestedSorts = this.$apiQueryBuilderRequest.sorts();
+		ensureAllSortsExist(this, requestedSorts);
+		addRequestedSortsToQuery(this, requestedSorts);
 		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);
-		});
+		if (this.$apiQueryBuilderRequest.sorts().length > 0) return this;
+		const arraySorts = Array.isArray(sorts.at(0)) ? sorts.at(0) : sorts;
+		for (const rawSort of arraySorts) (rawSort instanceof AllowedSort ? rawSort : AllowedSort.field(rawSort)).sort(this);
 		return this;
 	});
 };
-//#endregion
 export { extendModelQueryBuilderWithSortsQuery };

package/build/src/bindings/validation_query.js

@@ -0,0 +1,27 @@
+// src/bindings/validation_query.ts
+let isPatched = false;
+const extendModelQueryBuilderWithValidation = function(builder) {
+	builder.macro("validate", async function() {
+		return this.$apiQueryBuilderRequest.validate();
+	});
+	if (isPatched) return;
+	const proto = builder.prototype;
+	const originalExecQuery = proto.execQuery;
+	proto.execQuery = async function(...args) {
+		const query = this;
+		if (query.$queryBuilderRequest) {
+			const apiRequest = query.$queryBuilderRequest;
+			if (apiRequest.shouldAutoValidate() && apiRequest.hasValidation()) await apiRequest.validate();
+		}
+		return originalExecQuery.apply(this, args);
+	};
+	const originalClone = proto.clone;
+	proto.clone = function() {
+		const cloned = originalClone.call(this);
+		const query = this;
+		if (query.$queryBuilderRequest) cloned.$queryBuilderRequest = query.$queryBuilderRequest;
+		return cloned;
+	};
+	isPatched = true;
+};
+export { extendModelQueryBuilderWithValidation };

package/build/src/decorators/filterable.d.ts

@@ -0,0 +1,20 @@
+import { ApiQueryBuilderRequest } from "../api_query_builder_request.js";
+import { BaseFilterable } from "../base_filterable.js";
+import { FilterableConstructor, FilterableTarget } from "../../types.js";
+import { HttpRequest } from "@adonisjs/core/http";
+import { BaseModel } from "@adonisjs/lucid/orm";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { NormalizeConstructor } from "@adonisjs/core/types/helpers";
+export type FilterableModel<T extends NormalizeConstructor<typeof BaseModel>> = (new (...args: unknown[]) => InstanceType<T>) & { [K in keyof T]: T[K]; } & {
+  $filterable?: FilterableTarget;
+  $filter<Model extends LucidModel>(this: Model, request?: HttpRequest | ApiQueryBuilderRequest): ModelQueryBuilderContract<Model, InstanceType<Model>>;
+  $filter<Model extends LucidModel>(this: Model, filterable: FilterableConstructor<Model> | BaseFilterable<Model>, request?: HttpRequest | ApiQueryBuilderRequest): ModelQueryBuilderContract<Model, InstanceType<Model>>;
+};
+/**
+ * Decorator to assign a filterable class to a Lucid Model
+ */
+export declare function filterable<Model extends LucidModel = LucidModel>(target: FilterableTarget<Model>): (model: unknown) => void;
+/**
+ * Mixin that adds filterable capabilities to a Lucid Model
+ */
+export declare function Filterable<T extends NormalizeConstructor<typeof BaseModel>, Model extends LucidModel = LucidModel>(filterableTarget?: FilterableTarget<Model>): (superclass: T) => FilterableModel<T>;

package/build/src/decorators/filterable.js

@@ -0,0 +1,24 @@
+// src/decorators/filterable.ts
+/**
+* Decorator to assign a filterable class to a Lucid Model
+*/
+function filterable(target) {
+	return function(model) {
+		model.$filterable = target;
+	};
+}
+/**
+* Mixin that adds filterable capabilities to a Lucid Model
+*/
+function Filterable(filterableTarget) {
+	return function(superclass) {
+		class ModelWithFilterable extends superclass {
+			static $filterable = filterableTarget ?? superclass.$filterable;
+			static $filter(filterableOrRequest, maybeRequest) {
+				return this.query().filter(filterableOrRequest, maybeRequest);
+			}
+		}
+		return ModelWithFilterable;
+	};
+}
+export { Filterable, filterable };

package/build/src/define_config.d.ts

@@ -1,7 +1,3 @@
 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 };
+export declare const defineConfig: (config: ApiQueryConfig) => ConfigProvider<ResolvedApiQueryConfig>;

package/build/src/define_config.js

@@ -1,5 +1,5 @@
 import { configProvider } from "@adonisjs/core";
-//#region src/define_config.ts
+// src/define_config.ts
 const defineConfig = function(config) {
 	return configProvider.create(async (_) => {
 		return {
@@ -17,9 +17,9 @@ const defineConfig = function(config) {
 			disableInvalidIncludesQueryException: config.disableInvalidIncludesQueryException ?? false,
 			convertRelationNamesToSnakeCasePlural: config.convertRelationNamesToSnakeCasePlural ?? false,
 			convertRelationTableNameStrategy: config.convertRelationTableNameStrategy ?? false,
-			convertFieldNamesToSnakeCase: config.convertFieldNamesToSnakeCase ?? false
+			convertFieldNamesToSnakeCase: config.convertFieldNamesToSnakeCase ?? false,
+			autoValidate: config.autoValidate ?? true
 		};
 	});
 };
-//#endregion
 export { defineConfig };

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

@@ -1,5 +1,4 @@
-//#region src/enums/filter_operator.d.ts
-declare const FilterOperator: {
+export declare const FilterOperator: {
   readonly Dynamic: "";
   readonly Equal: "=";
   readonly LessThan: "<";
@@ -7,6 +6,4 @@ declare const FilterOperator: {
   readonly LessThanOrEqual: "<=";
   readonly GreaterThanOrEqual: ">=";
   readonly NotEqual: "<>";
-};
-//#endregion
-export { FilterOperator };
+};

package/build/src/enums/filter_operator.js

@@ -1,4 +1,4 @@
-//#region src/enums/filter_operator.ts
+// src/enums/filter_operator.ts
 const FilterOperator = {
 	Dynamic: "",
 	Equal: "=",
@@ -8,5 +8,4 @@ const FilterOperator = {
 	GreaterThanOrEqual: ">=",
 	NotEqual: "<>"
 };
-//#endregion
 export { FilterOperator };

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

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

package/build/src/enums/sort_direction.js

@@ -1,7 +1,6 @@
-//#region src/enums/sort_direction.ts
+// 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,10 +1,6 @@
 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;
+export 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

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

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

@@ -0,0 +1,5 @@
+import { Exception } from "@adonisjs/core/exceptions";
+export declare class FilterableNotConfigured extends Exception {
+  static readonly code = "E_FILTERABLE_NOT_CONFIGURED";
+  constructor(modelName: string);
+}

package/build/src/exceptions/filterable_not_configured.js

@@ -0,0 +1,12 @@
+import { Exception } from "@adonisjs/core/exceptions";
+// src/exceptions/filterable_not_configured.ts
+var FilterableNotConfigured = class FilterableNotConfigured extends Exception {
+	static code = "E_FILTERABLE_NOT_CONFIGURED";
+	constructor(modelName) {
+		super(`No filterable class is configured for model "${modelName}". Define "static \$filterable = UserFilterable" or use "@filterable(UserFilterable)", or pass a filterable class directly to "\$filter()".`, {
+			status: 500,
+			code: FilterableNotConfigured.code
+		});
+	}
+};
+export { FilterableNotConfigured };

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

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

package/build/src/exceptions/invalid_append_query.js

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

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

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

package/build/src/exceptions/invalid_direction.js

@@ -1,10 +1,9 @@
 import { SortDirection } from "../enums/sort_direction.js";
 import { Exception } from "@adonisjs/core/exceptions";
-//#region src/exceptions/invalid_direction.ts
+// 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_field_query.d.ts

@@ -0,0 +1,7 @@
+import { InvalidQuery } from "./invalid_query.js";
+export declare class InvalidFieldQuery extends InvalidQuery {
+  readonly unknownFields: string[];
+  readonly allowedFields: string[];
+  constructor(unknownFields: string[], allowedFields: string[]);
+  static fieldsNotAllowed(unknownFields: string[], allowedFields: string[]): InvalidFieldQuery;
+}

package/build/src/exceptions/invalid_field_query.js

@@ -0,0 +1,17 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+// src/exceptions/invalid_field_query.ts
+var InvalidFieldQuery = class InvalidFieldQuery extends InvalidQuery {
+	unknownFields;
+	allowedFields;
+	constructor(unknownFields, allowedFields) {
+		const message = `Requested field(s) \`${unknownFields.join(", ")}\` are not allowed. Allowed field(s) are \`${allowedFields.join(", ")}\``;
+		super(message, { status: ResponseStatus.BadRequest });
+		this.unknownFields = unknownFields;
+		this.allowedFields = allowedFields;
+	}
+	static fieldsNotAllowed(unknownFields, allowedFields) {
+		return new InvalidFieldQuery(unknownFields, allowedFields);
+	}
+};
+export { InvalidFieldQuery };

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

@@ -1,11 +1,7 @@
 import { InvalidQuery } from "./invalid_query.js";
-
-//#region src/exceptions/invalid_filter_query.d.ts
-declare class InvalidFilterQuery extends InvalidQuery {
+export 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

@@ -1,6 +1,6 @@
 import { InvalidQuery } from "./invalid_query.js";
 import { ResponseStatus } from "@adonisjs/core/http";
-//#region src/exceptions/invalid_filter_query.ts
+// src/exceptions/invalid_filter_query.ts
 var InvalidFilterQuery = class InvalidFilterQuery extends InvalidQuery {
 	unknownFilters;
 	allowedFilters;
@@ -14,5 +14,4 @@ var InvalidFilterQuery = class InvalidFilterQuery extends InvalidQuery {
 		return new InvalidFilterQuery(unknownFilters, allowedFilters);
 	}
 };
-//#endregion
 export { InvalidFilterQuery };

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

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

package/build/src/exceptions/invalid_filter_value.js

@@ -1,9 +1,8 @@
 import { Exception } from "@adonisjs/core/exceptions";
-//#region src/exceptions/invalid_filter_value.ts
+// 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,11 +1,7 @@
 import { InvalidQuery } from "./invalid_query.js";
-
-//#region src/exceptions/invalid_include_query.d.ts
-declare class InvalidIncludeQuery extends InvalidQuery {
+export 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

@@ -1,6 +1,6 @@
 import { InvalidQuery } from "./invalid_query.js";
 import { ResponseStatus } from "@adonisjs/core/http";
-//#region src/exceptions/invalid_include_query.ts
+// src/exceptions/invalid_include_query.ts
 var InvalidIncludeQuery = class InvalidIncludeQuery extends InvalidQuery {
 	unknownIncludes;
 	allowedIncludes;
@@ -18,5 +18,4 @@ var InvalidIncludeQuery = class InvalidIncludeQuery extends InvalidQuery {
 		return new InvalidIncludeQuery(unknownIncludes, allowedIncludes);
 	}
 };
-//#endregion
 export { InvalidIncludeQuery };

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

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

package/build/src/exceptions/invalid_query.js

@@ -1,7 +1,6 @@
 import { Exception } from "@adonisjs/core/exceptions";
-//#region src/exceptions/invalid_query.ts
+// 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,11 +1,7 @@
 import { InvalidQuery } from "./invalid_query.js";
-
-//#region src/exceptions/invalid_sort_query.d.ts
-declare class InvalidSortQuery extends InvalidQuery {
+export 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

@@ -1,6 +1,6 @@
 import { InvalidQuery } from "./invalid_query.js";
 import { ResponseStatus } from "@adonisjs/core/http";
-//#region src/exceptions/invalid_sort_query.ts
+// src/exceptions/invalid_sort_query.ts
 var InvalidSortQuery = class InvalidSortQuery extends InvalidQuery {
 	unknownSorts;
 	allowedSorts;
@@ -14,5 +14,4 @@ var InvalidSortQuery = class InvalidSortQuery extends InvalidQuery {
 		return new InvalidSortQuery(unknownSorts, allowedSorts);
 	}
 };
-//#endregion
 export { InvalidSortQuery };

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

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

package/build/src/exceptions/unknown_included_fields_query.js

@@ -1,6 +1,6 @@
 import { InvalidQuery } from "./invalid_query.js";
 import { ResponseStatus } from "@adonisjs/core/http";
-//#region src/exceptions/unknown_included_fields_query.ts
+// src/exceptions/unknown_included_fields_query.ts
 var UnknownIncludedFieldsQuery = class extends InvalidQuery {
 	unknownFields;
 	constructor(unknownFields) {
@@ -9,5 +9,4 @@ var UnknownIncludedFieldsQuery = class extends InvalidQuery {
 		this.unknownFields = unknownFields;
 	}
 };
-//#endregion
 export { UnknownIncludedFieldsQuery };

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

@@ -0,0 +1,5 @@
+import { Exception } from "@adonisjs/core/exceptions";
+export declare class VineNotInstalledException extends Exception {
+  static readonly code = "E_VINE_NOT_INSTALLED";
+  constructor();
+}

package/build/src/exceptions/vine_not_installed.js

@@ -0,0 +1,12 @@
+import { Exception } from "@adonisjs/core/exceptions";
+// src/exceptions/vine_not_installed.ts
+var VineNotInstalledException = class VineNotInstalledException extends Exception {
+	static code = "E_VINE_NOT_INSTALLED";
+	constructor() {
+		super("To use validation in \"@eienjs/adonisjs-api-query\", you must install \"@vinejs/vine\". Run: \"pnpm add @vinejs/vine\" or \"npm install @vinejs/vine\".", {
+			status: 500,
+			code: VineNotInstalledException.code
+		});
+	}
+};
+export { VineNotInstalledException };