@eienjs/adonisjs-api-query 1.1.1 → 3.0.0

package/build/src/filters/filters_operator.js

@@ -0,0 +1,52 @@
+import { FiltersExact } from "./filters_exact.js";
+import { FilterOperator } from "../enums/filter_operator.js";
+// src/filters/filters_operator.ts
+const SORTED_OPERATORS = Object.values(FilterOperator).filter((op) => op !== FilterOperator.Dynamic).toSorted((a, b) => b.length - a.length);
+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 (typeof value === "object") return;
+		if (filterOperator === FilterOperator.Dynamic) {
+			const strValue = value.toString();
+			filterOperator = this.getDynamicFilterOperator(strValue);
+			value = this.removeDynamicFilterOperatorFromValue(strValue, filterOperator);
+		}
+		if (this.boolean === "and") {
+			query.where(this.qualifyColumn(query, property), filterOperator, value);
+			return;
+		}
+		query.orWhere(this.qualifyColumn(query, property), filterOperator, value);
+	}
+	getDynamicFilterOperator(value) {
+		for (const filterOperatorCase of SORTED_OPERATORS) if (value.startsWith(filterOperatorCase)) return filterOperatorCase;
+		return FilterOperator.Equal;
+	}
+	removeDynamicFilterOperatorFromValue(value, filterOperator) {
+		return value.startsWith(filterOperator) ? value.slice(filterOperator.length) : value;
+	}
+};
+export { FiltersOperator };

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

@@ -1,12 +1,10 @@
-import { type DialectContract } from '@adonisjs/lucid/types/database';
-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 { FiltersExact } from './filters_exact.js';
+import { 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 FiltersPartial<Model extends LucidModel> extends FiltersExact<Model> implements Filter<Model> {
-    handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, property: string): void;
-    protected parsePropertyToColumn(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, property: string): string;
-    protected getDatabaseDialect(query: ModelQueryBuilderContract<Model, InstanceType<Model>>): DialectContract['name'];
-    protected getWhereRawParameters(value: StrictValuesWithoutRaw | null, property: string): [string, string[]];
-    protected static escapeLike(value: string): string;
-}
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, property: string): void;
+  protected parsePropertyToColumn(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, property: string): string;
+  protected getWhereRawParameters(value: StrictValuesWithoutRaw | null, property: string): [string, string[]];
+  protected static escapeLike(value: string): string;
+}

package/build/src/filters/filters_partial.js

@@ -0,0 +1,37 @@
+import { FiltersExact } from "./filters_exact.js";
+// src/filters/filters_partial.ts
+var FiltersPartial = class FiltersPartial extends FiltersExact {
+	handle(query, value, property) {
+		if (this.shouldAddRelationConstraint && this.isRelationProperty(query, property)) {
+			this.withRelationConstraint(query, value, property);
+			return;
+		}
+		if (Array.isArray(value)) {
+			const subValues = value.flat(Infinity).filter((item) => item !== null && typeof item !== "object" && String(item).length > 0);
+			if (subValues.length === 0) return;
+			query.where((subQuery) => {
+				const column = this.parsePropertyToColumn(subQuery, property);
+				for (const partialValue of subValues) {
+					const [innerSql, innerBindings] = this.getWhereRawParameters(partialValue, column);
+					subQuery.orWhereRaw(innerSql, innerBindings);
+				}
+			});
+			return;
+		}
+		if (value === null || typeof value === "object") return;
+		const [sql, bindings] = this.getWhereRawParameters(value, this.parsePropertyToColumn(query, property));
+		query.whereRaw(sql, bindings);
+	}
+	parsePropertyToColumn(query, property) {
+		if (property.includes(".")) return property;
+		return query.model.$getColumn(property)?.columnName ?? property;
+	}
+	getWhereRawParameters(value, property) {
+		const resolvedValue = String(value).toLowerCase();
+		return ["LOWER(??) LIKE ?", [property, `%${FiltersPartial.escapeLike(resolvedValue)}%`]];
+	}
+	static escapeLike(value) {
+		return value.replaceAll("\\", String.raw`\\`).replaceAll("_", String.raw`\_`).replaceAll("%", String.raw`\%`);
+	}
+};
+export { FiltersPartial };

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

@@ -0,0 +1,12 @@
+import { Filter } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+export declare class FiltersScope<Model extends LucidModel> implements Filter<Model> {
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: unknown, property: string): void;
+  protected applyScope(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: unknown, property: string): void;
+  protected getModelScopeFunction(model: LucidModel, candidate: string): ((...args: unknown[]) => void) | undefined;
+  protected resolveScopeMethod(model: Model, property: string): string;
+  protected extractParametersString(fn: (...args: unknown[]) => void): string | null;
+  protected hasParameters(fn: (...args: unknown[]) => void): boolean;
+  protected countParameters(fn: (...args: unknown[]) => void): number;
+  protected resolveArguments(scopeFn: ((...args: unknown[]) => void) | undefined, value: unknown, resolvedParamCount?: number): unknown[];
+}

package/build/src/filters/filters_scope.js

@@ -0,0 +1,98 @@
+import string from "@adonisjs/core/helpers/string";
+import { BaseModel } from "@adonisjs/lucid/orm";
+// src/filters/filters_scope.ts
+const FN_PARAMS_REGEX = /^(?:async\s*)?(?:function[^(]*\(([^)]*)\)|\(([^)]*)\)\s*=>|([^\s(=>]+)\s*=>)/;
+const RESERVED_MODEL_METHODS = /* @__PURE__ */ new Set([
+	"boot",
+	"before",
+	"after",
+	"saving",
+	"creating",
+	"updating",
+	"deleting",
+	"finding",
+	"fetching",
+	"paginating",
+	"constructor",
+	"prototype"
+]);
+var FiltersScope = class {
+	handle(query, value, property) {
+		const dotIndex = property.indexOf(".");
+		if (dotIndex !== -1) {
+			const firstRelation = property.slice(0, dotIndex);
+			if (query.model.$relationsDefinitions.has(firstRelation)) {
+				const remainingProperty = property.slice(dotIndex + 1);
+				query.whereHas(firstRelation, (subQuery) => {
+					this.handle(subQuery, value, remainingProperty);
+				});
+				return;
+			}
+		}
+		this.applyScope(query, value, property);
+	}
+	applyScope(query, value, property) {
+		const scopeMethod = this.resolveScopeMethod(query.model, property);
+		const scopeFn = this.getModelScopeFunction(query.model, scopeMethod);
+		if (!scopeFn) throw new Error(`"${scopeMethod}" is not defined as a query scope on "${query.model.name}" model`);
+		const paramCount = this.countParameters(scopeFn);
+		if (paramCount <= 1) {
+			if (value === false) return;
+			query.withScopes((scopes) => {
+				scopes[scopeMethod]();
+			});
+			return;
+		}
+		const args = this.resolveArguments(scopeFn, value, paramCount);
+		query.withScopes((scopes) => {
+			scopes[scopeMethod](...args);
+		});
+	}
+	getModelScopeFunction(model, candidate) {
+		if (!candidate || candidate.startsWith("$") || candidate.startsWith("_") || RESERVED_MODEL_METHODS.has(candidate)) return;
+		let current = model;
+		while (typeof current === "function" && current !== BaseModel && current !== Function.prototype && current !== Object.prototype) {
+			if (Object.hasOwn(current, candidate)) {
+				const fn = current[candidate];
+				return typeof fn === "function" ? fn : void 0;
+			}
+			current = Object.getPrototypeOf(current);
+		}
+	}
+	resolveScopeMethod(model, property) {
+		const camelCased = string.camelCase(property);
+		const propertyWithScope = `${property}Scope`;
+		const camelCasedWithScope = `${camelCased}Scope`;
+		const candidates = property === camelCased ? [property, propertyWithScope] : [
+			property,
+			camelCased,
+			propertyWithScope,
+			camelCasedWithScope
+		];
+		for (const candidate of candidates) if (this.getModelScopeFunction(model, candidate)) return candidate;
+		return camelCased;
+	}
+	extractParametersString(fn) {
+		const match = FN_PARAMS_REGEX.exec(fn.toString());
+		if (!match) return null;
+		return (match.at(1) ?? match.at(2) ?? match.at(3) ?? "").trim();
+	}
+	hasParameters(fn) {
+		return this.countParameters(fn) > 1;
+	}
+	countParameters(fn) {
+		if (fn.length > 1) return fn.length;
+		const params = this.extractParametersString(fn);
+		if (!params) return fn.length;
+		return params.split(",").length;
+	}
+	resolveArguments(scopeFn, value, resolvedParamCount) {
+		if (Array.isArray(value)) return value;
+		if (typeof value === "object" && value !== null) {
+			if ((resolvedParamCount ?? (scopeFn ? this.countParameters(scopeFn) : 0)) > 2) return Object.values(value);
+			return [value];
+		}
+		return [value];
+	}
+};
+export { FiltersScope };

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

@@ -1,6 +1,6 @@
-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 FiltersTrashed<Model extends LucidModel> implements Filter<Model> {
-    handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw, _property: string): void;
-}
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, _property: string): void;
+}

package/build/src/filters/filters_trashed.js

@@ -0,0 +1,13 @@
+// src/filters/filters_trashed.ts
+var FiltersTrashed = class {
+	handle(query, value, _property) {
+		if (!("withTrashed" in query && "onlyTrashed" in query)) return;
+		const queryWithSoftDeletes = query;
+		if (value === "with") {
+			queryWithSoftDeletes.withTrashed();
+			return;
+		}
+		if (value === "only") queryWithSoftDeletes.onlyTrashed();
+	}
+};
+export { FiltersTrashed };

package/build/src/includes/included_callback.d.ts

@@ -1,8 +1,8 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type ModelRelations } from '@adonisjs/lucid/types/relations';
-import { type Include } from '../types.js';
+import { Include } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { ModelRelations } from "@adonisjs/lucid/types/relations";
 export declare class IncludedCallback<ParentModel extends LucidModel, RelatedModel extends LucidModel> implements Include<ParentModel> {
-    readonly callback: (query: ModelRelations<RelatedModel, ParentModel>['builder'] | ModelRelations<RelatedModel, ParentModel>['subQuery']) => void;
-    constructor(callback: (query: ModelRelations<RelatedModel, ParentModel>['builder'] | ModelRelations<RelatedModel, ParentModel>['subQuery']) => void);
-    handle(query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, include: string): void;
-}
+  readonly callback: (query: ModelRelations<RelatedModel, ParentModel>['builder'] | ModelRelations<RelatedModel, ParentModel>['subQuery']) => void;
+  constructor(callback: (query: ModelRelations<RelatedModel, ParentModel>['builder'] | ModelRelations<RelatedModel, ParentModel>['subQuery']) => void);
+  handle(query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, include: string): void;
+}

package/build/src/includes/included_callback.js

@@ -0,0 +1,11 @@
+// src/includes/included_callback.ts
+var IncludedCallback = class {
+	callback;
+	constructor(callback) {
+		this.callback = callback;
+	}
+	handle(query, include) {
+		query.preload(include, this.callback);
+	}
+};
+export { IncludedCallback };

package/build/src/includes/included_count.d.ts

@@ -1,5 +1,5 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type Include } from '../types.js';
+import { Include } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
 export declare class IncludedCount<ParentModel extends LucidModel> implements Include<ParentModel> {
-    handle(query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, count: string): void;
-}
+  handle(query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, count: string): void;
+}

package/build/src/includes/included_count.js

@@ -0,0 +1,11 @@
+import app from "@adonisjs/core/services/app";
+// src/includes/included_count.ts
+var IncludedCount = class {
+	handle(query, count) {
+		const suffix = app.config.get("apiquery.countSuffix", "Count");
+		const relation = count.endsWith(suffix) ? count.slice(0, -suffix.length) : count;
+		if (!query.model.$hasRelation(relation)) return;
+		query.withCount(relation);
+	}
+};
+export { IncludedCount };

package/build/src/includes/included_relationship.d.ts

@@ -1,9 +1,9 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { Collection } from 'collect.js';
-import { type Include } from '../types.js';
+import { Include } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
 export declare class IncludedRelationship<ParentModel extends LucidModel> implements Include<ParentModel> {
-    static getIndividualRelationshipPathsFromInclude(include: string): Collection<string>;
-    getRequestedFieldsForRelatedTable?: (relationship: string) => string[];
-    handle(query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, relationship: string): void;
-    private buildNestedQuery;
-}
+  getRequestedFieldsForRelatedTable?: (relationship: string) => string[];
+  handle(query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, relationship: string): void;
+  static getIndividualRelationshipPathsFromInclude(include: string): string[];
+  private applyRequestedFields;
+  private buildNestedQuery;
+}

package/build/src/includes/included_relationship.js

@@ -0,0 +1,37 @@
+// src/includes/included_relationship.ts
+var IncludedRelationship = class {
+	getRequestedFieldsForRelatedTable;
+	handle(query, relationship) {
+		const [relation, ...rest] = relationship.split(".");
+		if (!relation || !query.model.$hasRelation(relation)) return;
+		query.preload(relation, (subQuery) => {
+			this.applyRequestedFields(subQuery, relation);
+			this.buildNestedQuery(rest, subQuery, relation);
+		});
+	}
+	static getIndividualRelationshipPathsFromInclude(include) {
+		const parts = include.split(".");
+		const includes = [];
+		let current = "";
+		for (const part of parts) {
+			current = current ? `${current}.${part}` : part;
+			includes.push(current);
+		}
+		return includes;
+	}
+	applyRequestedFields(query, relationshipName) {
+		if (this.getRequestedFieldsForRelatedTable === void 0) return;
+		const fields = this.getRequestedFieldsForRelatedTable(relationshipName);
+		if (fields.length > 0) query.select(fields);
+	}
+	buildNestedQuery(relatedTables, subQuery, parent = "") {
+		const [relation, ...rest] = relatedTables;
+		if (!relation || !subQuery.model.$hasRelation(relation)) return;
+		subQuery.preload(relation, (nestedQuery) => {
+			const fullRelationName = parent === "" ? relation : `${parent}.${relation}`;
+			this.applyRequestedFields(nestedQuery, fullRelationName);
+			this.buildNestedQuery(rest, nestedQuery, fullRelationName);
+		});
+	}
+};
+export { IncludedRelationship };

package/build/src/sorts/sorts_callback.d.ts

@@ -1,7 +1,7 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type Sort } from '../types.js';
+import { Sort } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
 export declare class SortsCallback<Model extends LucidModel> implements Sort<Model> {
-    private readonly _callback;
-    constructor(_callback: (query: ModelQueryBuilderContract<Model>, descending: boolean, property: string) => void);
-    handle(query: ModelQueryBuilderContract<Model>, descending: boolean, property: string): void;
-}
+  private readonly _callback;
+  constructor(_callback: (query: ModelQueryBuilderContract<Model>, isDescending: boolean, property: string) => void);
+  handle(query: ModelQueryBuilderContract<Model>, isDescending: boolean, property: string): void;
+}

package/build/src/sorts/sorts_callback.js

@@ -0,0 +1,11 @@
+// src/sorts/sorts_callback.ts
+var SortsCallback = class {
+	_callback;
+	constructor(_callback) {
+		this._callback = _callback;
+	}
+	handle(query, isDescending, property) {
+		this._callback(query, isDescending, property);
+	}
+};
+export { SortsCallback };

package/build/src/sorts/sorts_field.d.ts

@@ -1,5 +1,5 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type Sort } from '../types.js';
+import { Sort } from "../../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
 export declare class SortsField<Model extends LucidModel> implements Sort<Model> {
-    handle(query: ModelQueryBuilderContract<Model>, descending: boolean, property: string): void;
-}
+  handle(query: ModelQueryBuilderContract<Model>, isDescending: boolean, property: string): void;
+}

package/build/src/sorts/sorts_field.js

@@ -0,0 +1,7 @@
+// src/sorts/sorts_field.ts
+var SortsField = class {
+	handle(query, isDescending, property) {
+		query.orderBy(property, isDescending ? "desc" : "asc");
+	}
+};
+export { SortsField };

package/build/src/utils/helpers.js

@@ -0,0 +1,14 @@
+// src/utils/helpers.ts
+const strBeforeLast = (subject, search) => {
+	if (search === "") return subject;
+	const pos = subject.lastIndexOf(search);
+	if (pos === -1) return subject;
+	return subject.slice(0, Math.max(0, pos));
+};
+const strAfterLast = (subject, search) => {
+	if (search === "") return subject;
+	const pos = subject.lastIndexOf(search);
+	if (pos === -1) return subject;
+	return subject.slice(pos + search.length);
+};
+export { strAfterLast, strBeforeLast };

package/build/src/validation/schema_builder.d.ts

@@ -0,0 +1,3 @@
+import { QueryValidator, ValidationRules } from "../../types.js";
+import { SchemaTypes } from "@vinejs/vine/types";
+export declare const buildQueryValidator: (rules?: ValidationRules, filterRules?: Record<string, SchemaTypes>) => Promise<QueryValidator>;

package/build/src/validation/schema_builder.js

@@ -0,0 +1,38 @@
+import { resolveVine } from "./vine_resolver.js";
+import app from "@adonisjs/core/services/app";
+import { RuntimeException } from "@adonisjs/core/exceptions";
+// src/validation/schema_builder.ts
+const isVineValidator = (rules) => {
+	return typeof rules?.validate === "function";
+};
+const isVineObject = (rules) => {
+	return typeof rules.getProperties === "function";
+};
+/**
+* Filters are omitted from the URL most of the time, so every filter rule is made
+* optional while keeping its type and constraints when the value is present.
+*/
+const toOptional = (rule) => {
+	const schema = rule;
+	return typeof schema.optional === "function" ? schema.optional() : rule;
+};
+const buildQueryValidator = async (rules, filterRules = {}) => {
+	if (isVineValidator(rules)) return rules;
+	const vine = await resolveVine();
+	const filterKey = app.config.get("apiquery.parameters.filter", "filter");
+	const filterProperties = Object.fromEntries(Object.entries(filterRules).map(([name, rule]) => [name, toOptional(rule)]));
+	const hasFilterRules = Object.keys(filterProperties).length > 0;
+	if (rules && isVineObject(rules)) {
+		const properties = rules.getProperties();
+		if (!hasFilterRules || Object.hasOwn(properties, filterKey)) return vine.create(rules);
+		return vine.create({
+			...properties,
+			[filterKey]: vine.object(filterProperties).optional()
+		});
+	}
+	const properties = { ...rules };
+	if (hasFilterRules && !Object.hasOwn(properties, filterKey)) properties[filterKey] = vine.object(filterProperties).optional();
+	if (Object.keys(properties).length === 0) throw new RuntimeException("No validation rules defined for the API query request");
+	return vine.create(properties);
+};
+export { buildQueryValidator };

package/build/src/validation/vine_resolver.js

@@ -0,0 +1,13 @@
+import { VineNotInstalledException } from "../exceptions/vine_not_installed.js";
+// src/validation/vine_resolver.ts
+let cachedVine;
+const resolveVine = async () => {
+	if (cachedVine) return cachedVine;
+	try {
+		cachedVine = (await import("@vinejs/vine")).default;
+		return cachedVine;
+	} catch {
+		throw new VineNotInstalledException();
+	}
+};
+export { resolveVine };

package/build/stubs/main.d.ts

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

package/build/stubs/main.js

@@ -0,0 +1,3 @@
+// stubs/main.ts
+const stubsRoot = import.meta.dirname;
+export { stubsRoot };

package/build/types.d.ts

@@ -0,0 +1,116 @@
+import { AllowedInclude } from "./src/allowed_include.js";
+import { AllowedSort } from "./src/allowed_sort.js";
+import { ApiQueryBuilderRequest } from "./src/api_query_builder_request.js";
+import { BaseFilterable } from "./src/base_filterable.js";
+import { AllowedFilter } from "./src/allowed_filter.js";
+import { HttpRequest } from "@adonisjs/core/http";
+import { ExtractScopes, LucidModel, ModelAttributes, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { StrictValuesWithoutRaw } from "@adonisjs/lucid/types/querybuilder";
+import { SchemaTypes } from "@vinejs/vine/types";
+import { ExtractModelRelations } from "@adonisjs/lucid/types/relations";
+import { Vine, VineObject } from "@vinejs/vine";
+export type QueryValidator = ReturnType<Vine['create']>;
+/**
+ * Validation rules accepted for an API query request: a compiled `vine.create(...)`,
+ * a `vine.object(...)` schema, or a literal object of Vine schemas.
+ */
+export type ValidationRules = QueryValidator | VineObject<Record<string, SchemaTypes>, unknown, unknown, unknown> | Record<string, SchemaTypes>;
+export interface ApiQueryConfigParameters {
+  include?: string;
+  filter?: string;
+  sort?: string;
+  fields?: string;
+  append?: string;
+}
+export interface ApiQueryConfig {
+  /**
+   * By default the package will use the `include`, `filter`, `sort`
+   * and `fields` query parameters as described in the readme.
+   *
+   * You can customize these query string parameters here.
+   */
+  parameters?: ApiQueryConfigParameters;
+  /**
+   * Related model counts are included using the relationship name suffixed with this string.
+   * For example: GET /users?include=postsCount
+   */
+  countSuffix?: string;
+  /**
+   * Related model exists are included using the relationship name suffixed with this string.
+   * For example: GET /users?include=postsExists
+   */
+  existsSuffix?: string;
+  /**
+   * By default the package will throw an `InvalidFilterQuery` exception when a filter in the
+   * URL is not allowed in the `allowedFilters()` method.
+   */
+  disableInvalidFilterQueryException?: boolean;
+  /**
+   * By default the package will throw an `InvalidSortQuery` exception when a sort in the
+   * URL is not allowed in the `allowedSorts()` method.
+   */
+  disableInvalidSortQueryException?: boolean;
+  /**
+   * By default the package will throw an `InvalidIncludeQuery` exception when an include in the
+   * URL is not allowed in the `allowedIncludes()` method.
+   */
+  disableInvalidIncludesQueryException?: boolean;
+  /**
+   * By default, the package expects relationship names to be camel case plural when using fields[relationship].
+   * For example, fetching the id and name for a userOwner relation would look like this:
+   * GET /users?fields[userOwner]=id,name
+   *
+   * Set this to `true` if you don't want that and keep the requested relationship names as-is and allows you to
+   * request the fields using a snake case relationship name:
+   * GET /users?fields[user_owner]=id,name
+   */
+  convertRelationNamesToSnakeCasePlural?: boolean;
+  /**
+   * By default, the package expects relationship names to be camel case plural when using fields[relationship].
+   * For example, fetching the id and name for a userOwner relation would look like this:
+   * GET /users?fields[userOwner]=id,name
+   *
+   * Set this to one of `snake_case`, `camelCase` or `none` if you want to enable table name resolution in addition to the relation name resolution
+   * GET /users?include=top_orders&fields[orders]=id,name
+   */
+  convertRelationTableNameStrategy?: 'snake_case' | 'camelCase' | 'none' | false;
+  /**
+   * By default, the package expects the field names to match the database names
+   * For example, fetching the field named firstName would look like this:
+   * GET /users?fields=firstName
+   *
+   * Set this to `true` if you want to convert the firstName into first_name for the underlying query
+   */
+  convertFieldNamesToSnakeCase?: boolean;
+  /**
+   * By default, the package will automatically validate the request before query execution
+   * when validation rules are configured.
+   *
+   * Set this to `false` if you prefer manual validation via `validate()`.
+   */
+  autoValidate?: boolean;
+}
+export type ResolvedApiQueryConfig = Required<ApiQueryConfig> & {
+  parameters: Required<ApiQueryConfigParameters>;
+};
+export type EnumType<T> = T[keyof T];
+export interface Sort<Model extends LucidModel> {
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, isDescending: boolean, property: string): void;
+}
+export interface Filter<Model extends LucidModel> {
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, property: string): void;
+}
+export interface Include<ParentModel extends LucidModel> {
+  handle(query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, include: string): void;
+}
+export type ExtractKeys<T> = T extends object ? { [K in keyof T & string]: K; }[keyof T & string] : never;
+export type ExtractKeysWithSort<T> = T extends object ? { [K in keyof T & string]: `-${K}`; }[keyof T & string] : never;
+export type SortUnionKeyParams<Model extends LucidModel> = ExtractKeys<ModelAttributes<InstanceType<Model>>> | ExtractKeysWithSort<ModelAttributes<InstanceType<Model>>>;
+export type ScopeUnionKeyParams<Model extends LucidModel> = [keyof ExtractScopes<Model>] extends [never] ? string : HintedString<keyof ExtractScopes<Model>>;
+export type HintedString<KnownValues> = KnownValues extends string ? (string & {}) | KnownValues : never;
+export type FilterableConstructor<Model extends LucidModel = LucidModel> = new (request?: HttpRequest | ApiQueryBuilderRequest) => BaseFilterable<Model>;
+export type FilterableThunk<Model extends LucidModel = LucidModel> = () => FilterableConstructor<Model>;
+export type FilterableTarget<Model extends LucidModel = LucidModel> = FilterableConstructor<Model> | FilterableThunk<Model>;
+export type FilterItem<Model extends LucidModel = LucidModel> = AllowedFilter<Model> | HintedString<ExtractKeys<ModelAttributes<InstanceType<Model>>>> | (string & {});
+export type SortItem<Model extends LucidModel = LucidModel> = AllowedSort<Model> | HintedString<SortUnionKeyParams<Model>> | (string & {});
+export type IncludeItem<Model extends LucidModel = LucidModel> = AllowedInclude<Model> | AllowedInclude<Model>[] | HintedString<ExtractModelRelations<InstanceType<Model>>> | (string & {});

package/build/types.js

@@ -0,0 +1 @@
+export {};