@eienjs/adonisjs-api-query 1.1.1 → 3.0.0

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

package/build/src/define_config.js

@@ -0,0 +1,25 @@
+import { configProvider } from "@adonisjs/core";
+// 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,
+			autoValidate: config.autoValidate ?? true
+		};
+	});
+};
+export { defineConfig };

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

@@ -1,10 +1,9 @@
 export 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];
+  readonly Dynamic: "";
+  readonly Equal: "=";
+  readonly LessThan: "<";
+  readonly GreaterThan: ">";
+  readonly LessThanOrEqual: "<=";
+  readonly GreaterThanOrEqual: ">=";
+  readonly NotEqual: "<>";
+};

package/build/src/enums/filter_operator.js

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

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

@@ -1,5 +1,4 @@
 export declare const SortDirection: {
-    readonly Ascending: "asc";
-    readonly Descending: "desc";
-};
-export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
+  readonly Ascending: "asc";
+  readonly Descending: "desc";
+};

package/build/src/enums/sort_direction.js

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

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

@@ -1,6 +1,6 @@
-import { Exception } from '@adonisjs/core/exceptions';
+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();
-}
+  static readonly code = "E_BAD_METHOD_CALL_EXCEPTION";
+  static readonly status = 500;
+  constructor();
+}

package/build/src/exceptions/allowed_fields_must_be_called_before_allowed_includes.js

@@ -0,0 +1,10 @@
+import { Exception } from "@adonisjs/core/exceptions";
+// src/exceptions/allowed_fields_must_be_called_before_allowed_includes.ts
+var AllowedFieldsMustBeCalledBeforeAllowedIncludes = class extends Exception {
+	static code = "E_BAD_METHOD_CALL_EXCEPTION";
+	static status = 500;
+	constructor() {
+		super("The QueryBuilder's `allowedFields` method must be called before the `allowedIncludes` method");
+	}
+};
+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,5 +1,7 @@
-import { InvalidQuery } from './invalid_query.js';
+import { InvalidQuery } from "./invalid_query.js";
 export declare class InvalidAppendQuery extends InvalidQuery {
-    constructor(appendsNotAllowed: string[], allowedAppends: string[]);
-    static appendsNotAllowed(appendsNotAllowed: string[], allowedAppends: string[]): InvalidAppendQuery;
-}
+  readonly appendsNotAllowed: string[];
+  readonly allowedAppends: string[];
+  constructor(appendsNotAllowed: string[], allowedAppends: string[]);
+  static appendsNotAllowed(appendsNotAllowed: string[], allowedAppends: string[]): InvalidAppendQuery;
+}

package/build/src/exceptions/invalid_append_query.js

@@ -0,0 +1,17 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+// 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);
+	}
+};
+export { InvalidAppendQuery };

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

@@ -1,4 +1,4 @@
-import { Exception } from '@adonisjs/core/exceptions';
+import { Exception } from "@adonisjs/core/exceptions";
 export declare class InvalidDirection extends Exception {
-    static make(sort: string): InvalidDirection;
-}
+  static make(sort: string): InvalidDirection;
+}

package/build/src/exceptions/invalid_direction.js

@@ -0,0 +1,9 @@
+import { SortDirection } from "../enums/sort_direction.js";
+import { Exception } from "@adonisjs/core/exceptions";
+// 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`);
+	}
+};
+export { InvalidDirection };

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

@@ -1,5 +1,7 @@
-import { InvalidQuery } from './invalid_query.js';
+import { InvalidQuery } from "./invalid_query.js";
 export declare class InvalidFieldQuery extends InvalidQuery {
-    constructor(unknownFields: string[], allowedFields: string[]);
-    static fieldsNotAllowed(unknownFields: string[], allowedFields: string[]): InvalidFieldQuery;
-}
+  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,7 +1,7 @@
-import { InvalidQuery } from './invalid_query.js';
+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;
-}
+  readonly unknownFilters: string[];
+  readonly allowedFilters: string[];
+  constructor(unknownFilters: string[], allowedFilters: string[]);
+  static filtersNotAllowed(unknownFilters: string[], allowedFilters: string[]): InvalidFilterQuery;
+}

package/build/src/exceptions/invalid_filter_query.js

@@ -0,0 +1,17 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+// 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);
+	}
+};
+export { InvalidFilterQuery };

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

@@ -1,4 +1,4 @@
-import { Exception } from '@adonisjs/core/exceptions';
+import { Exception } from "@adonisjs/core/exceptions";
 export declare class InvalidFilterValue extends Exception {
-    static make(value: unknown): InvalidFilterValue;
-}
+  static make(value: unknown): InvalidFilterValue;
+}

package/build/src/exceptions/invalid_filter_value.js

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

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

@@ -1,7 +1,7 @@
-import { InvalidQuery } from './invalid_query.js';
+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;
-}
+  readonly unknownIncludes: string[];
+  readonly allowedIncludes: string[];
+  constructor(unknownIncludes: string[], allowedIncludes: string[]);
+  static includesNotAllowed(unknownIncludes: string[], allowedIncludes: string[]): InvalidIncludeQuery;
+}

package/build/src/exceptions/invalid_include_query.js

@@ -0,0 +1,21 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+// 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);
+	}
+};
+export { InvalidIncludeQuery };

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

@@ -1,4 +1,4 @@
-import { Exception } from '@adonisjs/core/exceptions';
+import { Exception } from "@adonisjs/core/exceptions";
 export declare abstract class InvalidQuery extends Exception {
-    static readonly code = "E_INVALID_QUERY_EXCEPTION";
-}
+  static readonly code = "E_INVALID_QUERY_EXCEPTION";
+}

package/build/{chunk-XIRHVLVQ.js → src/exceptions/invalid_query.js}

@@ -1,10 +1,6 @@
-// src/exceptions/invalid_query.ts
 import { Exception } from "@adonisjs/core/exceptions";
+// src/exceptions/invalid_query.ts
 var InvalidQuery = class extends Exception {
-  static code = "E_INVALID_QUERY_EXCEPTION";
-};
-
-export {
-  InvalidQuery
+	static code = "E_INVALID_QUERY_EXCEPTION";
 };
-//# sourceMappingURL=chunk-XIRHVLVQ.js.map
+export { InvalidQuery };

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

@@ -1,7 +1,7 @@
-import { InvalidQuery } from './invalid_query.js';
+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;
-}
+  readonly unknownSorts: string[];
+  readonly allowedSorts: string[];
+  constructor(unknownSorts: string[], allowedSorts: string[]);
+  static sortsNotAllowed(unknownSorts: string[], allowedSorts: string[]): InvalidSortQuery;
+}

package/build/src/exceptions/invalid_sort_query.js

@@ -0,0 +1,17 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+// 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);
+	}
+};
+export { InvalidSortQuery };

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

@@ -1,5 +1,5 @@
-import { InvalidQuery } from './invalid_query.js';
+import { InvalidQuery } from "./invalid_query.js";
 export declare class UnknownIncludedFieldsQuery extends InvalidQuery {
-    readonly unknownFields: string[];
-    constructor(unknownFields: string[]);
-}
+  readonly unknownFields: string[];
+  constructor(unknownFields: string[]);
+}

package/build/src/exceptions/unknown_included_fields_query.js

@@ -0,0 +1,12 @@
+import { InvalidQuery } from "./invalid_query.js";
+import { ResponseStatus } from "@adonisjs/core/http";
+// 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;
+	}
+};
+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 };

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

@@ -1,7 +1,7 @@
-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';
+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";
 export declare class FiltersBeginWithStrict<Model extends LucidModel> extends FiltersPartial<Model> implements Filter<Model> {
-    protected getWhereRawParameters(value: StrictValuesWithoutRaw, property: string): [string, string[]];
-}
+  protected getWhereRawParameters(value: StrictValuesWithoutRaw, property: string): [string, string[]];
+}

package/build/src/filters/filters_begin_with_strict.js

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

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

@@ -1,7 +1,7 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type Filter } from '../types.js';
+import { Filter } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
 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;
-}
+  private callback;
+  constructor(callback: (query: ModelQueryBuilderContract<Model>, value: unknown, property: string) => void);
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: unknown, property: string): void;
+}

package/build/src/filters/filters_callback.js

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

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

@@ -1,7 +1,7 @@
-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';
+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";
 export declare class FiltersEndsWithStrict<Model extends LucidModel> extends FiltersPartial<Model> implements Filter<Model> {
-    protected getWhereRawParameters(value: StrictValuesWithoutRaw, property: string): [string, string[]];
-}
+  protected getWhereRawParameters(value: StrictValuesWithoutRaw, property: string): [string, string[]];
+}

package/build/src/filters/filters_ends_with_strict.js

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

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

@@ -1,12 +1,12 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type StrictValuesWithoutRaw } from '@adonisjs/lucid/types/querybuilder';
-import { type Filter } from '../types.js';
+import { Filter } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { StrictValuesWithoutRaw } from "@adonisjs/lucid/types/querybuilder";
 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;
-}
+  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;
+}

package/build/src/filters/filters_exact.js

@@ -0,0 +1,50 @@
+// 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)) {
+			const flatValues = value.flat(Infinity).filter((item) => typeof item !== "object" || item === null);
+			if (flatValues.length === 0) return;
+			query.whereIn(this.qualifyColumn(query, property), flatValues);
+			return;
+		}
+		if (value === null) {
+			query.whereNull(this.qualifyColumn(query, property));
+			return;
+		}
+		if (typeof value === "object") 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 ?? column}`;
+	}
+	isRelationProperty(query, property) {
+		if (!property.includes(".") || this.relationConstraints.includes(property)) return false;
+		const firstRelationShip = property.split(".", 1)[0];
+		return query.model.$relationsDefinitions.has(firstRelationShip);
+	}
+	withRelationConstraint(query, value, property) {
+		const parts = property.split(".");
+		const relationProperty = parts.pop();
+		const relation = parts.join(".");
+		query.whereHas(relation, (subQuery) => {
+			const columnName = this.qualifyColumn(subQuery, relationProperty);
+			this.relationConstraints.push(columnName);
+			try {
+				this.handle(subQuery, value, columnName);
+			} finally {
+				this.relationConstraints.pop();
+			}
+		});
+	}
+};
+export { FiltersExact };

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

@@ -1,14 +1,14 @@
-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';
+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";
 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;
-}
+  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;
+}