@eienjs/adonisjs-api-query 2.0.0 → 3.0.1

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

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

package/build/src/filters/filters_begin_with_strict.js

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

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

@@ -1,11 +1,7 @@
 import { Filter } from "../../types.js";
 import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
-
-//#region src/filters/filters_callback.d.ts
-declare class FiltersCallback<Model extends LucidModel> implements Filter<Model> {
+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;
-}
-//#endregion
-export { FiltersCallback };
+}

package/build/src/filters/filters_callback.js

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

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

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

package/build/src/filters/filters_ends_with_strict.js

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

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

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

package/build/src/filters/filters_exact.js

@@ -1,5 +1,4 @@
-import collect$1 from "collect.js";
-//#region src/filters/filters_exact.ts
+// src/filters/filters_exact.ts
 var FiltersExact = class {
 	shouldAddRelationConstraint;
 	relationConstraints = [];
@@ -12,36 +11,40 @@ var FiltersExact = class {
 			return;
 		}
 		if (Array.isArray(value)) {
-			query.whereIn(this.qualifyColumn(query, property), 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}`;
+		return `${query.model.table}.${query.model.$getColumn(column)?.columnName ?? column}`;
 	}
 	isRelationProperty(query, property) {
-		if (!property.includes(".")) return false;
-		if (this.relationConstraints.includes(property)) return false;
+		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 [relation, relationProperty] = collect$1(property.split(".")).pipe((parts) => {
-			const rProperty = parts.pop();
-			return [parts.implode("."), rProperty];
-		});
+		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);
-			this.handle(subQuery, value, columnName);
+			try {
+				this.handle(subQuery, value, columnName);
+			} finally {
+				this.relationConstraints.pop();
+			}
 		});
 	}
 };
-//#endregion
 export { FiltersExact };

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

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

package/build/src/filters/filters_operator.js

@@ -1,7 +1,7 @@
-import { substrReplace } from "../utils/helpers.js";
-import { FiltersExact } from "./filters_exact.js";
 import { FilterOperator } from "../enums/filter_operator.js";
-//#region src/filters/filters_operator.ts
+import { FiltersExact } from "./filters_exact.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;
@@ -29,9 +29,11 @@ var FiltersOperator = class extends FiltersExact {
 			query.whereNull(this.qualifyColumn(query, property));
 			return;
 		}
+		if (typeof value === "object") return;
 		if (filterOperator === FilterOperator.Dynamic) {
-			filterOperator = this.getDynamicFilterOperator(value.toString());
-			value = this.removeDynamicFilterOperatorFromValue(value.toString(), filterOperator);
+			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);
@@ -40,14 +42,11 @@ var FiltersOperator = class extends FiltersExact {
 		query.orWhere(this.qualifyColumn(query, property), filterOperator, value);
 	}
 	getDynamicFilterOperator(value) {
-		let filterOperator = FilterOperator.Equal;
-		for (const filterOperatorCase of Object.values(FilterOperator)) if (value.startsWith(filterOperatorCase) && filterOperatorCase !== FilterOperator.Dynamic) filterOperator = filterOperatorCase;
-		return filterOperator;
+		for (const filterOperatorCase of SORTED_OPERATORS) if (value.startsWith(filterOperatorCase)) return filterOperatorCase;
+		return FilterOperator.Equal;
 	}
 	removeDynamicFilterOperatorFromValue(value, filterOperator) {
-		if (value.includes(filterOperator)) value = substrReplace(value, "", 0, filterOperator.length);
-		return value;
+		return value.startsWith(filterOperator) ? value.slice(filterOperator.length) : value;
 	}
 };
-//#endregion
 export { FiltersOperator };

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

@@ -2,15 +2,9 @@ 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";
-import { DialectContract } from "@adonisjs/lucid/types/database";
-
-//#region src/filters/filters_partial.d.ts
-declare class FiltersPartial<Model extends LucidModel> extends FiltersExact<Model> implements Filter<Model> {
+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;
-}
-//#endregion
-export { FiltersPartial };
+}

package/build/src/filters/filters_partial.js

@@ -1,5 +1,5 @@
 import { FiltersExact } from "./filters_exact.js";
-//#region src/filters/filters_partial.ts
+// src/filters/filters_partial.ts
 var FiltersPartial = class FiltersPartial extends FiltersExact {
 	handle(query, value, property) {
 		if (this.shouldAddRelationConstraint && this.isRelationProperty(query, property)) {
@@ -7,16 +7,18 @@ var FiltersPartial = class FiltersPartial extends FiltersExact {
 			return;
 		}
 		if (Array.isArray(value)) {
-			if (value.every((item) => item.toString().length === 0)) return;
+			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 subValues = value.filter((item) => item.toString().length > 0);
+				const column = this.parsePropertyToColumn(subQuery, property);
 				for (const partialValue of subValues) {
-					const [innerSql, innerBindings] = this.getWhereRawParameters(partialValue, this.parsePropertyToColumn(subQuery, property));
+					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);
 	}
@@ -24,16 +26,12 @@ var FiltersPartial = class FiltersPartial extends FiltersExact {
 		if (property.includes(".")) return property;
 		return query.model.$getColumn(property)?.columnName ?? property;
 	}
-	getDatabaseDialect(query) {
-		return query.client.dialect.name;
-	}
 	getWhereRawParameters(value, property) {
 		const resolvedValue = String(value).toLowerCase();
 		return ["LOWER(??) LIKE ?", [property, `%${FiltersPartial.escapeLike(resolvedValue)}%`]];
 	}
 	static escapeLike(value) {
-		return value.replaceAll("\\", "\\\\").replaceAll("_", String.raw`\\_`).replaceAll("%", String.raw`\\%`);
+		return value.replaceAll("\\", String.raw`\\`).replaceAll("_", String.raw`\_`).replaceAll("%", String.raw`\%`);
 	}
 };
-//#endregion
 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,10 +1,6 @@
 import { Filter } from "../../types.js";
 import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
 import { StrictValuesWithoutRaw } from "@adonisjs/lucid/types/querybuilder";
-
-//#region src/filters/filters_trashed.d.ts
-declare class FiltersTrashed<Model extends LucidModel> implements Filter<Model> {
+export declare class FiltersTrashed<Model extends LucidModel> implements Filter<Model> {
   handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, _property: string): void;
-}
-//#endregion
-export { FiltersTrashed };
+}

package/build/src/filters/filters_trashed.js

@@ -1,4 +1,4 @@
-//#region src/filters/filters_trashed.ts
+// src/filters/filters_trashed.ts
 var FiltersTrashed = class {
 	handle(query, value, _property) {
 		if (!("withTrashed" in query && "onlyTrashed" in query)) return;
@@ -10,5 +10,4 @@ var FiltersTrashed = class {
 		if (value === "only") queryWithSoftDeletes.onlyTrashed();
 	}
 };
-//#endregion
 export { FiltersTrashed };

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

@@ -1,12 +1,8 @@
 import { Include } from "../../types.js";
 import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
 import { ModelRelations } from "@adonisjs/lucid/types/relations";
-
-//#region src/includes/included_callback.d.ts
-declare class IncludedCallback<ParentModel extends LucidModel, RelatedModel extends LucidModel> implements Include<ParentModel> {
+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;
-}
-//#endregion
-export { IncludedCallback };
+}

package/build/src/includes/included_callback.js

@@ -1,4 +1,4 @@
-//#region src/includes/included_callback.ts
+// src/includes/included_callback.ts
 var IncludedCallback = class {
 	callback;
 	constructor(callback) {
@@ -8,5 +8,4 @@ var IncludedCallback = class {
 		query.preload(include, this.callback);
 	}
 };
-//#endregion
 export { IncludedCallback };

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

@@ -1,9 +1,5 @@
 import { Include } from "../../types.js";
 import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
-
-//#region src/includes/included_count.d.ts
-declare class IncludedCount<ParentModel extends LucidModel> implements Include<ParentModel> {
+export declare class IncludedCount<ParentModel extends LucidModel> implements Include<ParentModel> {
   handle(query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, count: string): void;
-}
-//#endregion
-export { IncludedCount };
+}

package/build/src/includes/included_count.js

@@ -1,11 +1,11 @@
 import app from "@adonisjs/core/services/app";
-//#region src/includes/included_count.ts
+// 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);
 	}
 };
-//#endregion
 export { IncludedCount };

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

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

package/build/src/includes/included_relationship.js

@@ -1,40 +1,37 @@
-import { Collection } from "collect.js";
-//#region src/includes/included_relationship.ts
+// src/includes/included_relationship.ts
 var IncludedRelationship = class {
 	getRequestedFieldsForRelatedTable;
 	handle(query, relationship) {
-		const relatedTables = relationship.split(".");
-		if (relatedTables.length === 0) return;
-		const [relation, ...rest] = relatedTables;
-		if (!query.model.$hasRelation(relation)) return;
+		const [relation, ...rest] = relationship.split(".");
+		if (!relation || !query.model.$hasRelation(relation)) return;
 		query.preload(relation, (subQuery) => {
-			if (this.getRequestedFieldsForRelatedTable !== void 0) {
-				const fields = this.getRequestedFieldsForRelatedTable(relation);
-				if (fields.length > 0) subQuery.select(fields);
-			}
+			this.applyRequestedFields(subQuery, relation);
 			this.buildNestedQuery(rest, subQuery, relation);
 		});
 	}
 	static getIndividualRelationshipPathsFromInclude(include) {
-		return new Collection(include.split(".")).reduce((includes, relationship) => {
-			const includesArray = includes ?? new Collection();
-			if (includesArray.isEmpty()) return includesArray.push(relationship);
-			return includesArray.push(`${includes.last()}.${relationship}`);
-		}, new Collection());
+		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 = "") {
-		if (relatedTables.length === 0) return;
 		const [relation, ...rest] = relatedTables;
-		if (!subQuery.model.$hasRelation(relation)) return;
+		if (!relation || !subQuery.model.$hasRelation(relation)) return;
 		subQuery.preload(relation, (nestedQuery) => {
 			const fullRelationName = parent === "" ? relation : `${parent}.${relation}`;
-			if (this.getRequestedFieldsForRelatedTable !== void 0) {
-				const fields = this.getRequestedFieldsForRelatedTable(fullRelationName);
-				if (fields.length > 0) nestedQuery.select(fields);
-			}
+			this.applyRequestedFields(nestedQuery, fullRelationName);
 			this.buildNestedQuery(rest, nestedQuery, fullRelationName);
 		});
 	}
 };
-//#endregion
 export { IncludedRelationship };

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

@@ -1,11 +1,7 @@
 import { Sort } from "../../types.js";
 import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
-
-//#region src/sorts/sorts_callback.d.ts
-declare class SortsCallback<Model extends LucidModel> implements Sort<Model> {
+export declare class SortsCallback<Model extends LucidModel> implements Sort<Model> {
   private readonly _callback;
   constructor(_callback: (query: ModelQueryBuilderContract<Model>, isDescending: boolean, property: string) => void);
   handle(query: ModelQueryBuilderContract<Model>, isDescending: boolean, property: string): void;
-}
-//#endregion
-export { SortsCallback };
+}

package/build/src/sorts/sorts_callback.js

@@ -1,4 +1,4 @@
-//#region src/sorts/sorts_callback.ts
+// src/sorts/sorts_callback.ts
 var SortsCallback = class {
 	_callback;
 	constructor(_callback) {
@@ -8,5 +8,4 @@ var SortsCallback = class {
 		this._callback(query, isDescending, property);
 	}
 };
-//#endregion
 export { SortsCallback };

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

@@ -1,9 +1,5 @@
 import { Sort } from "../../types.js";
 import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
-
-//#region src/sorts/sorts_field.d.ts
-declare class SortsField<Model extends LucidModel> implements Sort<Model> {
+export declare class SortsField<Model extends LucidModel> implements Sort<Model> {
   handle(query: ModelQueryBuilderContract<Model>, isDescending: boolean, property: string): void;
-}
-//#endregion
-export { SortsField };
+}

package/build/src/sorts/sorts_field.js

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

package/build/src/utils/helpers.js

@@ -1,15 +1,4 @@
-//#region src/utils/helpers.ts
-const substrReplace = (str, replace, start, length) => {
-	if (start < 0) start += str.length;
-	length ??= str.length;
-	if (length < 0) length = length + str.length - start;
-	return [
-		str.slice(0, start),
-		replace.slice(0, Math.max(0, length)),
-		replace.slice(length),
-		str.slice(start + length)
-	].join("");
-};
+// src/utils/helpers.ts
 const strBeforeLast = (subject, search) => {
 	if (search === "") return subject;
 	const pos = subject.lastIndexOf(search);
@@ -22,5 +11,4 @@ const strAfterLast = (subject, search) => {
 	if (pos === -1) return subject;
 	return subject.slice(pos + search.length);
 };
-//#endregion
-export { strAfterLast, strBeforeLast, substrReplace };
+export { strAfterLast, strBeforeLast };