@eienjs/adonisjs-api-query 1.1.0 → 2.0.0

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

@@ -1,12 +1,16 @@
-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';
-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;
+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> {
+  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

@@ -0,0 +1,39 @@
+import { FiltersExact } from "./filters_exact.js";
+//#region 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)) {
+			if (value.every((item) => item.toString().length === 0)) return;
+			query.where((subQuery) => {
+				const subValues = value.filter((item) => item.toString().length > 0);
+				for (const partialValue of subValues) {
+					const [innerSql, innerBindings] = this.getWhereRawParameters(partialValue, this.parsePropertyToColumn(subQuery, property));
+					subQuery.orWhereRaw(innerSql, innerBindings);
+				}
+			});
+			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;
+	}
+	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`\\%`);
+	}
+};
+//#endregion
+export { FiltersPartial };

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

@@ -1,6 +1,10 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type StrictValuesWithoutRaw } from '@adonisjs/lucid/types/querybuilder';
-import { type Filter } from '../types.js';
-export declare class FiltersTrashed<Model extends LucidModel> implements Filter<Model> {
-    handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw, _property: string): void;
+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> {
+  handle(query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, _property: string): void;
 }
+//#endregion
+export { FiltersTrashed };

package/build/src/filters/filters_trashed.js

@@ -0,0 +1,14 @@
+//#region 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();
+	}
+};
+//#endregion
+export { FiltersTrashed };

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

@@ -1,8 +1,12 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type ModelRelations } from '@adonisjs/lucid/types/relations';
-import { type Include } from '../types.js';
-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;
+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> {
+  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

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

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

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

package/build/src/includes/included_count.js

@@ -0,0 +1,11 @@
+import app from "@adonisjs/core/services/app";
+//#region 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;
+		query.withCount(relation);
+	}
+};
+//#endregion
+export { IncludedCount };

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

@@ -1,9 +1,13 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { Collection } from 'collect.js';
-import { type Include } from '../types.js';
-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;
+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> {
+  getRequestedFieldsForRelatedTable?: (relationship: string) => string[];
+  handle(query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, relationship: string): void;
+  static getIndividualRelationshipPathsFromInclude(include: string): Collection<string>;
+  private buildNestedQuery;
 }
+//#endregion
+export { IncludedRelationship };

package/build/src/includes/included_relationship.js

@@ -0,0 +1,40 @@
+import { Collection } from "collect.js";
+//#region 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;
+		query.preload(relation, (subQuery) => {
+			if (this.getRequestedFieldsForRelatedTable !== void 0) {
+				const fields = this.getRequestedFieldsForRelatedTable(relation);
+				if (fields.length > 0) subQuery.select(fields);
+			}
+			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());
+	}
+	buildNestedQuery(relatedTables, subQuery, parent = "") {
+		if (relatedTables.length === 0) return;
+		const [relation, ...rest] = relatedTables;
+		if (!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.buildNestedQuery(rest, nestedQuery, fullRelationName);
+		});
+	}
+};
+//#endregion
+export { IncludedRelationship };

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

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

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

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

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

package/build/src/sorts/sorts_field.js

@@ -0,0 +1,8 @@
+//#region 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

@@ -0,0 +1,26 @@
+//#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("");
+};
+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);
+};
+//#endregion
+export { strAfterLast, strBeforeLast, substrReplace };

package/build/stubs/main.d.ts

@@ -1 +1,4 @@
-export declare const stubsRoot: string;
+//#region stubs/main.d.ts
+declare const stubsRoot: string;
+//#endregion
+export { stubsRoot };

package/build/stubs/main.js

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

package/build/types.d.ts

@@ -0,0 +1,91 @@
+import { LucidModel, ModelAttributes, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { StrictValuesWithoutRaw } from "@adonisjs/lucid/types/querybuilder";
+
+//#region src/types.d.ts
+interface ApiQueryConfigParameters {
+  include?: string;
+  filter?: string;
+  sort?: string;
+  fields?: string;
+  append?: string;
+}
+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;
+}
+type ResolvedApiQueryConfig = Required<ApiQueryConfig> & {
+  parameters: Required<ApiQueryConfigParameters>;
+};
+type EnumType<T> = T[keyof T];
+interface Sort<Model extends LucidModel> {
+  handle: (query: ModelQueryBuilderContract<Model, InstanceType<Model>>, isDescending: boolean, property: string) => void;
+}
+interface Filter<Model extends LucidModel> {
+  handle: (query: ModelQueryBuilderContract<Model, InstanceType<Model>>, value: StrictValuesWithoutRaw | null, property: string) => void;
+}
+interface Include<ParentModel extends LucidModel> {
+  handle: (query: ModelQueryBuilderContract<ParentModel, InstanceType<ParentModel>>, include: string) => void;
+}
+type ExtractKeys<T> = T extends object ? { [K in keyof T & string]: K }[keyof T & string] : never;
+type ExtractKeysWithSort<T> = T extends object ? { [K in keyof T & string]: `-${K}` }[keyof T & string] : never;
+type SortUnionKeyParams<Model extends LucidModel> = ExtractKeys<ModelAttributes<InstanceType<Model>>> | ExtractKeysWithSort<ModelAttributes<InstanceType<Model>>>;
+type HintedString<KnownValues> = KnownValues extends string ? (string & {}) | KnownValues : never;
+//#endregion
+export { ApiQueryConfig, ApiQueryConfigParameters, EnumType, ExtractKeys, ExtractKeysWithSort, Filter, HintedString, Include, ResolvedApiQueryConfig, Sort, SortUnionKeyParams };

package/build/types.js

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

package/package.json

@@ -1,60 +1,8 @@
 {
   "name": "@eienjs/adonisjs-api-query",
-  "description": "Easily build Lucid queries from API requests",
-  "version": "1.1.0",
   "type": "module",
-  "module": "./build/index.js",
-  "types": "./build/index.d.ts",
-  "files": [
-    "build",
-    "!build/bin",
-    "!build/tests"
-  ],
-  "exports": {
-    ".": "./build/index.js",
-    "./types": "./build/src/types.js",
-    "./api_query_provider": "./build/providers/api_query_provider.js"
-  },
-  "devDependencies": {
-    "@adonisjs/assembler": "^7.8.2",
-    "@adonisjs/core": "^6.17.2",
-    "@adonisjs/lucid": "^21.6.0",
-    "@commitlint/cli": "^19.8.1",
-    "@commitlint/config-conventional": "^19.8.1",
-    "@japa/assert": "^4.0.1",
-    "@japa/file-system": "^2.3.2",
-    "@japa/runner": "^4.2.0",
-    "@nodecfdi/eslint-config": "^3.2.1",
-    "@nodecfdi/prettier-config": "^1.4.1",
-    "@nodecfdi/tsconfig": "^1.7.4",
-    "@poppinss/hooks": "^7.2.5",
-    "@swc/core": "^1.11.24",
-    "@types/luxon": "^3.6.2",
-    "@types/node": "^22.15.17",
-    "adonis-lucid-soft-deletes": "^2.1.0",
-    "auto-changelog": "^2.5.0",
-    "better-sqlite3": "^11.10.0",
-    "c8": "^10.1.3",
-    "del-cli": "^6.0.0",
-    "enforce-unique": "^1.3.0",
-    "eslint": "^9.26.0",
-    "husky": "^9.1.7",
-    "is-in-ci": "^1.0.0",
-    "luxon": "^3.6.1",
-    "native-copyfiles": "^0.3.2",
-    "np": "^10.2.0",
-    "prettier": "^3.5.3",
-    "ts-node-maintained": "^10.9.5",
-    "tsup": "^8.4.0",
-    "typescript": "^5.8.3"
-  },
-  "dependencies": {
-    "collect.js": "^4.36.1"
-  },
-  "peerDependencies": {
-    "@adonisjs/core": "^6.17.2",
-    "@adonisjs/lucid": "^21.6.0"
-  },
+  "version": "2.0.0",
+  "description": "Easily build Lucid queries from API requests",
   "author": "Fernando Isidro <luffynando@gmail.com>",
   "license": "MIT",
   "homepage": "https://github.com/eienjs/adonisjs-api-query",
@@ -76,8 +24,62 @@
     "sort",
     "includes"
   ],
+  "exports": {
+    ".": "./build/index.js",
+    "./providers/api_query_provider": "./build/providers/api_query_provider.js",
+    "./types": "./build/types.js",
+    "./package.json": "./package.json"
+  },
+  "types": "build/index.d.ts",
+  "files": [
+    "build"
+  ],
   "engines": {
-    "node": ">=20.6.0"
+    "node": ">=24.0.0"
+  },
+  "peerDependencies": {
+    "@adonisjs/assembler": "^8.4.0",
+    "@adonisjs/core": "^7.3.4",
+    "@adonisjs/lucid": "^22.4.2"
+  },
+  "peerDependenciesMeta": {
+    "@adonisjs/assembler": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "collect.js": "^4.36.1"
+  },
+  "devDependencies": {
+    "@adonisjs/assembler": "^8.4.0",
+    "@adonisjs/core": "^7.3.4",
+    "@adonisjs/eslint-plugin": "^2.2.2",
+    "@adonisjs/lucid": "^22.4.2",
+    "@adonisjs/tsconfig": "^2.0.0",
+    "@codenameryuu/adonis-lucid-soft-deletes": "^2.0.3",
+    "@commitlint/cli": "^21.1.0",
+    "@commitlint/config-conventional": "^21.1.0",
+    "@eienjs/eslint-config": "^2.1.2",
+    "@japa/assert": "^4.2.0",
+    "@japa/file-system": "^3.0.0",
+    "@japa/runner": "^5.3.0",
+    "@poppinss/hooks": "^7.3.0",
+    "@poppinss/ts-exec": "^1.4.4",
+    "@types/luxon": "^3.7.2",
+    "@types/node": "^24.13.2",
+    "auto-changelog": "^2.6.0",
+    "better-sqlite3": "^12.11.1",
+    "c8": "^11.0.0",
+    "enforce-unique": "^1.3.0",
+    "eslint": "^10.6.0",
+    "eslint-plugin-erasable-syntax-only": "^0.4.2",
+    "husky": "^9.1.7",
+    "is-in-ci": "^2.0.0",
+    "luxon": "^3.7.2",
+    "release-it": "^20.2.1",
+    "tsdown": "^0.22.3",
+    "tsdown-stale-guard": "^0.1.2",
+    "typescript": "^6.0.3"
   },
   "c8": {
     "reporter": [
@@ -94,51 +96,60 @@
       "@commitlint/config-conventional"
     ]
   },
-  "prettier": "@nodecfdi/prettier-config/pkg",
   "publishConfig": {
     "access": "public",
     "tag": "latest"
   },
   "auto-changelog": {
     "template": "keepachangelog",
-    "hideCredit": true
+    "hideCredit": true,
+    "commitLimit": false
   },
-  "np": {
-    "message": "chore(release): :tada: %s",
-    "tag": "latest",
-    "branch": "main",
-    "testScript": "test"
-  },
-  "tsup": {
-    "entry": [
-      "index.ts",
-      "src/types.ts",
-      "providers/api_query_provider.ts"
-    ],
-    "outDir": "./build",
-    "clean": true,
-    "format": "esm",
-    "dts": false,
-    "sourcemap": true,
-    "target": "esnext"
+  "release-it": {
+    "git": {
+      "commit": true,
+      "tag": true,
+      "push": true,
+      "requireCleanWorkingDir": true,
+      "commitMessage": "chore(release): :tada: v${version}",
+      "tagAnnotation": "chore(release): :tada: v${version}"
+    },
+    "github": {
+      "release": true,
+      "web": true,
+      "releaseName": "Release v${version}"
+    },
+    "npm": {
+      "publish": true,
+      "publishPackageManager": "pnpm",
+      "publishArgs": [
+        "--no-git-checks"
+      ]
+    },
+    "hooks": {
+      "before:init": [
+        "pnpm run lint:check",
+        "pnpm run typecheck",
+        "pnpm test"
+      ],
+      "after:bump": [
+        "pnpm run build",
+        "pnpm run changelog"
+      ]
+    }
   },
   "scripts": {
-    "clean": "del-cli build",
-    "copy:templates": "copyfiles \"stubs/**/*.stub\" build --up 1",
-    "changelog": "auto-changelog -p && git add CHANGELOG.md",
-    "typecheck": "tsc --noEmit",
+    "changelog": "auto-changelog -u -p",
+    "commitlint": "commitlint --edit",
+    "index:commands": "adonis-kit index build/commands",
     "lint": "eslint . --fix",
     "lint:check": "eslint .",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "test": "node --import ts-node-maintained/register/esm --enable-source-maps bin/test.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts",
     "test:coverage": "c8 pnpm run test",
-    "tool:code": "pnpm run lint:check && pnpm run format:check && pnpm run typecheck",
+    "tool:code": "pnpm run lint:check && pnpm run typecheck",
     "tool:build": "pnpm run tool:code && pnpm run test",
-    "prebuild": "pnpm run tool:code && pnpm run clean",
-    "build": "tsup-node --metafile && tsc --emitDeclarationOnly --declaration",
-    "postbuild": "pnpm run copy:templates",
-    "release": "np",
-    "version": "pnpm run build && pnpm run changelog"
+    "build": "tsdown",
+    "release": "release-it"
   }
 }