@leyyo/query 1.3.5 → 1.3.6

package/dist/error/index.d.ts

@@ -1,2 +1,2 @@
-export * from './invalid-query-value.error.js';
-export * from './index.types.js';
+export * from "./invalid-query-value.error.js";
+export * from "./index.types.js";

package/dist/error/index.js

@@ -1,2 +1,2 @@
-export * from './invalid-query-value.error.js';
-export * from './index.types.js';
+export * from "./invalid-query-value.error.js";
+export * from "./index.types.js";

package/dist/error/index.types.d.ts

@@ -1 +1 @@
-export type QueryErrorCode = 'xxx' | 'field:invalid' | 'field:empty' | 'field:raw-both' | 'field:raw-none' | 'as:invalid' | 'raw:invalid' | 'raw:empty' | 'op:invalid-key' | 'op:invalid-type' | 'asc:invalid-key' | 'asc:invalid-type' | 'value:invalid-type' | 'value:invalid-item' | 'integer:invalid' | 'integer:min' | 'select:item' | 'select:body' | 'where:item' | 'where:body' | 'having:item' | 'having:body' | 'groupBy:item' | 'groupBy:body' | 'orderBy:item' | 'orderBy:body' | 'page:conflict' | 'limit:conflict' | 'pagination:invalid-key' | 'pagination:invalid-type';
+export type QueryErrorCode = "xxx" | "field:invalid" | "field:empty" | "field:raw-both" | "field:raw-none" | "as:invalid" | "raw:invalid" | "raw:empty" | "op:invalid-key" | "op:invalid-type" | "asc:invalid-key" | "asc:invalid-type" | "value:invalid-type" | "value:invalid-item" | "integer:invalid" | "integer:min" | "select:item" | "select:body" | "where:item" | "where:body" | "having:item" | "having:body" | "groupBy:item" | "groupBy:body" | "orderBy:item" | "orderBy:body" | "page:conflict" | "limit:conflict" | "pagination:invalid-key" | "pagination:invalid-type";

package/dist/field/index.d.ts

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/field/index.js

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/group-by/index.d.ts

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/group-by/index.js

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-export * from './operation/index.js';
-export * from './error/index.js';
-export * from './field/index.js';
-export * from './group-by/index.js';
-export * from './order-by/index.js';
-export * from './pagination/index.js';
-export * from './parser/index.js';
-export * from './query/index.js';
-export * from './select/index.js';
-export * from './where/index.js';
-export * from './index.foretell.js';
-export * from './index.loader.js';
+export * from "./operation/index.js";
+export * from "./error/index.js";
+export * from "./field/index.js";
+export * from "./group-by/index.js";
+export * from "./order-by/index.js";
+export * from "./pagination/index.js";
+export * from "./parser/index.js";
+export * from "./query/index.js";
+export * from "./select/index.js";
+export * from "./where/index.js";
+export * from "./index.foretell.js";
+export * from "./index.loader.js";

package/dist/index.foretell.js

@@ -5,13 +5,13 @@ export const foretell_leyyoQuery = [
     // dependencies
     ...foretell_leyyoCommon,
     // errors
-    () => errorPool.lazy(FQN, 'InvalidQueryValueError', import('./error/invalid-query-value.error.js').then(m => m.InvalidQueryValueError), { i18n: true, emit: true }),
+    () => errorPool.lazy(FQN, "InvalidQueryValueError", import("./error/invalid-query-value.error.js").then((m) => m.InvalidQueryValueError), { i18n: true, emit: true }),
     // enums
     () => literalPool.register({
-        name: 'OperationType',
+        name: "OperationType",
         fqn: FQN,
         i18n: true,
-        lazyTarget: import('./operation/operation-type.js').then(m => m.OperationTypeItems),
-        lazyAlt: import('./operation/operation-type.js').then(m => m.OperationTypeMap),
+        lazyTarget: import("./operation/operation-type.js").then((m) => m.OperationTypeItems),
+        lazyAlt: import("./operation/operation-type.js").then((m) => m.OperationTypeMap),
     }),
 ];

package/dist/index.js

@@ -1,12 +1,12 @@
-export * from './operation/index.js';
-export * from './error/index.js';
-export * from './field/index.js';
-export * from './group-by/index.js';
-export * from './order-by/index.js';
-export * from './pagination/index.js';
-export * from './parser/index.js';
-export * from './query/index.js';
-export * from './select/index.js';
-export * from './where/index.js';
-export * from './index.foretell.js';
-export * from './index.loader.js';
+export * from "./operation/index.js";
+export * from "./error/index.js";
+export * from "./field/index.js";
+export * from "./group-by/index.js";
+export * from "./order-by/index.js";
+export * from "./pagination/index.js";
+export * from "./parser/index.js";
+export * from "./query/index.js";
+export * from "./select/index.js";
+export * from "./where/index.js";
+export * from "./index.foretell.js";
+export * from "./index.loader.js";

package/dist/index.loader.js

@@ -5,8 +5,8 @@ export const loader_leyyoQuery = defineLoader(FQN,
 // dependencies
 ...loader_leyyoCommon, 
 // errors
-() => import('./error/invalid-query-value.error.js').then(m => m.InvalidQueryValueError), 
+() => import("./error/invalid-query-value.error.js").then((m) => m.InvalidQueryValueError), 
 // enums
-() => import('./operation/operation-type.js').then(m => m.OperationTypeItems), 
+() => import("./operation/operation-type.js").then((m) => m.OperationTypeItems), 
 // classes
-() => import('./parser/query.parser.js').then(m => m.queryParser));
+() => import("./parser/query.parser.js").then((m) => m.queryParser));

package/dist/operation/index.d.ts

@@ -1 +1 @@
-export * from './operation-type.js';
+export * from "./operation-type.js";

package/dist/operation/index.js

@@ -1 +1 @@
-export * from './operation-type.js';
+export * from "./operation-type.js";

package/dist/operation/operation-type.d.ts

@@ -2,7 +2,7 @@ declare const literals: readonly ["eq", "ne", "null", "!null", "missing", "!miss
 /**
  * Operation Type
  * */
-export type OperationType = typeof literals[number];
+export type OperationType = (typeof literals)[number];
 export declare const OperationTypeItems: ReadonlyArray<OperationType>;
 export declare const OperationTypeMap: Record<string, OperationType>;
 export {};

package/dist/operation/operation-type.js

@@ -1,147 +1,147 @@
 const literals = [
     // all
-    'eq',
-    'ne',
-    'null',
-    '!null',
-    'missing',
-    '!missing',
+    "eq",
+    "ne",
+    "null",
+    "!null",
+    "missing",
+    "!missing",
     // string, number
-    'gt',
-    'gte',
-    'lt',
-    'lte',
-    'between',
-    '!between',
-    'in',
-    '!in',
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "between",
+    "!between",
+    "in",
+    "!in",
     // string
-    'starts',
-    '!starts',
-    'ends',
-    '!ends',
-    'matches',
-    '!matches',
-    'contains', // left includes right
-    '!contains', // left does not include right
-    'contained', // right includes left
-    '!contained', // right does not include left
+    "starts",
+    "!starts",
+    "ends",
+    "!ends",
+    "matches",
+    "!matches",
+    "contains", // left includes right
+    "!contains", // left does not include right
+    "contained", // right includes left
+    "!contained", // right does not include left
     // boolean
-    'true',
-    'false',
+    "true",
+    "false",
     // array object
-    'includes',
-    '!includes',
-    'intersects',
-    '!intersects',
+    "includes",
+    "!includes",
+    "intersects",
+    "!intersects",
     // json object
-    'exists',
-    '!exists',
+    "exists",
+    "!exists",
 ];
 export const OperationTypeItems = literals;
 // noinspection JSUnusedGlobalSymbols
 export const OperationTypeMap = {
     // all
-    '=': 'eq',
-    '==': 'eq',
-    'equals': 'eq',
-    'equal': 'eq',
-    '!equals': 'ne',
-    '!equal': 'ne',
-    '!=': 'ne',
-    '<>': 'ne',
-    'not-equals': 'ne',
-    'not-equal': 'ne',
-    'is-null': 'null',
-    '!': 'null',
-    'nil': 'null',
-    '!!': '!null',
-    'not-null': '!null',
-    'is-missing': 'missing',
-    'is-undefined': 'missing',
-    'undefined': 'missing',
-    'not-missing': '!missing',
-    'not-undefined': '!missing',
-    'defined': '!missing',
+    "=": "eq",
+    "==": "eq",
+    equals: "eq",
+    equal: "eq",
+    "!equals": "ne",
+    "!equal": "ne",
+    "!=": "ne",
+    "<>": "ne",
+    "not-equals": "ne",
+    "not-equal": "ne",
+    "is-null": "null",
+    "!": "null",
+    nil: "null",
+    "!!": "!null",
+    "not-null": "!null",
+    "is-missing": "missing",
+    "is-undefined": "missing",
+    undefined: "missing",
+    "not-missing": "!missing",
+    "not-undefined": "!missing",
+    defined: "!missing",
     // string, number
-    'greater-than': 'gt',
-    '>': 'gt',
-    'greater-than-or-equals': 'gte',
-    '>=': 'gte',
-    '=>': 'gte',
-    'less-than': 'lt',
-    'less': 'lt',
-    '<': 'lt',
-    'less-than-or-equals': 'lte',
-    '=<': 'lte',
-    '<=': 'lte',
-    '()': 'between',
-    'not-between': '!between',
-    ')(': '!between',
-    '[]': 'in',
-    '][': '!in',
-    'not-in': '!in',
+    "greater-than": "gt",
+    ">": "gt",
+    "greater-than-or-equals": "gte",
+    ">=": "gte",
+    "=>": "gte",
+    "less-than": "lt",
+    less: "lt",
+    "<": "lt",
+    "less-than-or-equals": "lte",
+    "=<": "lte",
+    "<=": "lte",
+    "()": "between",
+    "not-between": "!between",
+    ")(": "!between",
+    "[]": "in",
+    "][": "!in",
+    "not-in": "!in",
     // string
-    'starts-with': 'starts',
-    'start-with': 'starts',
-    '^': 'starts',
-    'start': 'starts',
-    'not-starts-with': '!starts',
-    'not-start-with': '!starts',
-    'not-starts': '!starts',
-    'not-start': '!starts',
-    '!starts-with': '!starts',
-    '!start-with': '!starts',
-    '!^': '!starts',
-    '!start': '!starts',
-    'ends-with': 'ends',
-    'end-with': 'ends',
-    '$': 'ends',
-    'end': 'ends',
-    'not-end-with': '!ends',
-    'not-ends': '!ends',
-    'not-end': '!ends',
-    '!$': '!ends',
-    '!ends-with': '!ends',
-    '!end-with': '!ends',
-    '!end': '!ends',
-    'match': 'matches',
-    'not-matches': '!matches',
-    'not-match': '!matches',
-    '!match': '!matches',
-    '!matches': '!matches',
-    'like': 'contains',
-    'likes': 'contains',
-    'contain': 'contains',
-    'not-contains': '!contains',
-    'not-contain': '!contains',
-    '!contain': '!contains',
-    'not-likes': '!contains',
-    'not-like': '!contains',
-    '!likes': '!contains',
-    '!like': '!contains',
+    "starts-with": "starts",
+    "start-with": "starts",
+    "^": "starts",
+    start: "starts",
+    "not-starts-with": "!starts",
+    "not-start-with": "!starts",
+    "not-starts": "!starts",
+    "not-start": "!starts",
+    "!starts-with": "!starts",
+    "!start-with": "!starts",
+    "!^": "!starts",
+    "!start": "!starts",
+    "ends-with": "ends",
+    "end-with": "ends",
+    $: "ends",
+    end: "ends",
+    "not-end-with": "!ends",
+    "not-ends": "!ends",
+    "not-end": "!ends",
+    "!$": "!ends",
+    "!ends-with": "!ends",
+    "!end-with": "!ends",
+    "!end": "!ends",
+    match: "matches",
+    "not-matches": "!matches",
+    "not-match": "!matches",
+    "!match": "!matches",
+    "!matches": "!matches",
+    like: "contains",
+    likes: "contains",
+    contain: "contains",
+    "not-contains": "!contains",
+    "not-contain": "!contains",
+    "!contain": "!contains",
+    "not-likes": "!contains",
+    "not-like": "!contains",
+    "!likes": "!contains",
+    "!like": "!contains",
     // boolean
-    'yes': 'true',
-    'no': 'false',
-    'on': 'true',
-    'off': 'false',
-    'ok': 'true',
-    'none': 'false',
+    yes: "true",
+    no: "false",
+    on: "true",
+    off: "false",
+    ok: "true",
+    none: "false",
     // array object
-    'include': 'includes',
-    'not-includes': '!includes',
-    'not-include': '!includes',
-    '!include': '!includes',
-    'intersect': 'intersects',
-    'not-intersects': '!intersects',
-    'not-intersect': '!intersects',
-    '!intersect': '!intersects',
-    'exist': 'exists',
-    '?': 'exists',
-    '??': 'exists',
-    'not-exists': '!exists',
-    'not-exist': '!exists',
-    '!?': '!exists',
-    '!??': '!exists',
-    '!exist': '!exists',
+    include: "includes",
+    "not-includes": "!includes",
+    "not-include": "!includes",
+    "!include": "!includes",
+    intersect: "intersects",
+    "not-intersects": "!intersects",
+    "not-intersect": "!intersects",
+    "!intersect": "!intersects",
+    exist: "exists",
+    "?": "exists",
+    "??": "exists",
+    "not-exists": "!exists",
+    "not-exist": "!exists",
+    "!?": "!exists",
+    "!??": "!exists",
+    "!exist": "!exists",
 };

package/dist/order-by/index.d.ts

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/order-by/index.js

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/order-type/index.d.ts

@@ -1 +1 @@
-export * from './order-type.js';
+export * from "./order-type.js";

package/dist/order-type/index.js

@@ -1 +1 @@
-export * from './order-type.js';
+export * from "./order-type.js";

package/dist/order-type/order-type.d.ts

@@ -2,6 +2,6 @@ declare const literals: readonly ["asc", "desc"];
 /**
  * Order Type
  * */
-export type OrderType = typeof literals[number];
+export type OrderType = (typeof literals)[number];
 export declare const OrderTypeItems: ReadonlyArray<OrderType>;
 export {};

package/dist/order-type/order-type.js

@@ -1,2 +1,2 @@
-const literals = ['asc', 'desc'];
+const literals = ["asc", "desc"];
 export const OrderTypeItems = literals;

package/dist/pagination/index.d.ts

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/pagination/index.js

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/parser/index.d.ts

@@ -1,2 +1,2 @@
-export * from './index.types.js';
-export * from './query.parser.js';
+export * from "./index.types.js";
+export * from "./query.parser.js";

package/dist/parser/index.js

@@ -1,2 +1,2 @@
-export * from './index.types.js';
-export * from './query.parser.js';
+export * from "./index.types.js";
+export * from "./query.parser.js";

package/dist/parser/index.types.d.ts

@@ -3,4 +3,4 @@ import { BasicType } from "@leyyo/common";
 export interface QueryParserLike {
     exec<K extends string>(query: QueryAny<K>, availableFields: Array<K | string>, name?: string): QueryRegular<K>;
 }
-export type QueryValueType = BasicType | 'array' | 'null' | 'integer' | '*';
+export type QueryValueType = BasicType | "array" | "null" | "integer" | "*";

package/dist/parser/query.parser.js

@@ -8,14 +8,14 @@ class QueryParser {
         return new InvalidQueryValueError(code, message, path);
     }
     _invalid(value, path, expected, code) {
-        const ex = Array.isArray(expected) ? `[${expected.join(', ')}]` : expected;
+        const ex = Array.isArray(expected) ? `[${expected.join(", ")}]` : expected;
         return this._error(code, `It's expected as ${ex}, but it's type: ${typeof value}`, path);
     }
     _emptyOrInvalid(value, path, expected, empty, invalid) {
         if (isEmpty(value)) {
             return this._error(empty, `It's empty`, path);
         }
-        if (typeof value === 'string' && value.trim() === '') {
+        if (typeof value === "string" && value.trim() === "") {
             return this._error(empty, `It's empty`, path);
         }
         return this._invalid(value, path, expected, invalid);
@@ -24,31 +24,31 @@ class QueryParser {
         if (isEmpty(value)) {
             return true;
         }
-        if (typeof value === 'boolean') {
+        if (typeof value === "boolean") {
             return value;
         }
         else if (isText(value)) {
-            if (value.toLowerCase() === 'asc') {
+            if (value.toLowerCase() === "asc") {
                 return true;
             }
-            else if (value.toLowerCase() === 'desc') {
+            else if (value.toLowerCase() === "desc") {
                 return false;
             }
-            throw this._error('asc:invalid-key', `It should be [asc, desc], but it's value: ${value}`, path);
+            throw this._error("asc:invalid-key", `It should be [asc, desc], but it's value: ${value}`, path);
         }
-        throw this._invalid(value, path, ['boolean', 'string'], 'asc:invalid-type');
+        throw this._invalid(value, path, ["boolean", "string"], "asc:invalid-type");
     }
     _field(value, path) {
         if (isText(value)) {
             return value;
         }
-        throw this._emptyOrInvalid(value, path, 'string', 'field:empty', 'field:invalid');
+        throw this._emptyOrInvalid(value, path, "string", "field:empty", "field:invalid");
     }
     _raw(value, path) {
         if (isText(value)) {
             return value;
         }
-        throw this._emptyOrInvalid(value, path, 'string', 'raw:empty', 'raw:invalid');
+        throw this._emptyOrInvalid(value, path, "string", "raw:empty", "raw:invalid");
     }
     _as(value, path) {
         if (isEmpty(value)) {
@@ -57,11 +57,11 @@ class QueryParser {
         else if (isText(value)) {
             return value;
         }
-        throw this._invalid(value, path, 'string', 'as:invalid');
+        throw this._invalid(value, path, "string", "as:invalid");
     }
     _operation(value, path) {
         if (isEmpty(value)) {
-            return 'eq';
+            return "eq";
         }
         else if (isText(value)) {
             const key = value;
@@ -71,9 +71,9 @@ class QueryParser {
             if (OperationTypeMap[key] !== undefined) {
                 return OperationTypeMap[key];
             }
-            throw this._error('op:invalid-key', `It should be [@see operations], but it's value: ${value}`, path);
+            throw this._error("op:invalid-key", `It should be [@see operations], but it's value: ${value}`, path);
         }
-        throw this._invalid(value, path, 'string', 'op:invalid-type');
+        throw this._invalid(value, path, "string", "op:invalid-type");
     }
     _value(value, path) {
         if (value === undefined) {
@@ -83,7 +83,7 @@ class QueryParser {
             case "string":
                 value = value.trim();
                 if (!value) {
-                    throw this._error('value:invalid-type', `It should not be empty string`, path);
+                    throw this._error("value:invalid-type", `It should not be empty string`, path);
                 }
                 return [value];
             case "number":
@@ -96,8 +96,8 @@ class QueryParser {
                 if (Array.isArray(value)) {
                     let index = 0;
                     for (const item of value) {
-                        if (!isText(item) && typeof value !== 'number' && typeof value !== 'boolean') {
-                            throw this._invalid(item, `${path}[${index}]`, ['string', 'number', 'boolean', 'array', 'number'], 'value:invalid-item');
+                        if (!isText(item) && typeof value !== "number" && typeof value !== "boolean") {
+                            throw this._invalid(item, `${path}[${index}]`, ["string", "number", "boolean", "array", "number"], "value:invalid-item");
                         }
                         index++;
                     }
@@ -105,7 +105,7 @@ class QueryParser {
                 }
                 break;
         }
-        throw this._invalid(value, path, ['string', 'number', 'boolean', 'array', 'number'], 'value:invalid-type');
+        throw this._invalid(value, path, ["string", "number", "boolean", "array", "number"], "value:invalid-type");
     }
     _num(value, path, min) {
         if (isEmpty(value)) {
@@ -115,16 +115,16 @@ class QueryParser {
             if (value >= min) {
                 return value;
             }
-            throw this._error('integer:min', `It should be gte ${min}`, path);
+            throw this._error("integer:min", `It should be gte ${min}`, path);
         }
-        throw this._invalid(value, path, ['integer'], 'integer:invalid');
+        throw this._invalid(value, path, ["integer"], "integer:invalid");
     }
     _fieldXorRaw(field, raw, path) {
         if (!raw && !field) {
-            throw this._error('field:raw-none', `Field or raw are not provided, one of them should be`, path);
+            throw this._error("field:raw-none", `Field or raw are not provided, one of them should be`, path);
         }
         else if (raw && field) {
-            throw this._error('field:raw-both', `Field and raw are provided together, Field or raw are not provided, only one of them should be`, path);
+            throw this._error("field:raw-both", `Field and raw are provided together, Field or raw are not provided, only one of them should be`, path);
         }
     }
     // endregion private
@@ -137,7 +137,7 @@ class QueryParser {
         // 1 - '*'
         // 2 - Array<K | [K, string] | SelectGiven<K> | SelectGivenRaw>
         // case 1: string as K
-        if (given === '*') {
+        if (given === "*") {
             return { all: true };
         }
         const newSelect = { fields: [] };
@@ -159,11 +159,10 @@ class QueryParser {
                     let [field, as] = item;
                     field = this._field(field, `select[${index}][0]`);
                     as = this._as(as, `select[${index}][1]`);
-                    newSelect.fields.push({ field, as, });
+                    newSelect.fields.push({ field, as });
                 }
                 // Case 2C: SelectGiven<K> | SelectGivenRaw
                 else if (isFilledObj(item)) {
-                    let as;
                     let field;
                     let raw;
                     const obj = item;
@@ -174,7 +173,7 @@ class QueryParser {
                         field = this._field(obj.field, `select[${index}].field`);
                     }
                     this._fieldXorRaw(field, raw, `select[${index}].field`);
-                    as = this._as(obj.as, `select[${index}].as`);
+                    const as = this._as(obj.as, `select[${index}].as`);
                     if (field) {
                         newSelect.fields.push({ field, as });
                     }
@@ -184,13 +183,13 @@ class QueryParser {
                 }
                 // other
                 else {
-                    throw this._invalid(item, `select[${index}]`, ['string', 'array', 'object'], 'select:item');
+                    throw this._invalid(item, `select[${index}]`, ["string", "array", "object"], "select:item");
                 }
             });
         }
         // case: other
         else {
-            throw this._invalid(given, `select`, ['*', 'array'], 'select:body');
+            throw this._invalid(given, `select`, ["*", "array"], "select:body");
         }
         return newSelect;
     }
@@ -205,10 +204,10 @@ class QueryParser {
         // case 1: WhereValue<K>
         if (isFilledObj(given)) {
             let index = 0;
-            for (let [k, v] of Object.entries(given)) {
+            for (const [k, v] of Object.entries(given)) {
                 const field = this._field(k, `${scope}(key=${index})`);
                 const value = this._value(v, `${scope}.${field}`);
-                newWhere.push({ field, value, op: 'eq' });
+                newWhere.push({ field, value, op: "eq" });
                 index++;
             }
         }
@@ -223,8 +222,6 @@ class QueryParser {
                 if (isFilledObj(item)) {
                     let field;
                     let raw;
-                    let op;
-                    let value;
                     let fullRaw;
                     const obj = item;
                     if (!isEmpty(obj.raw)) {
@@ -238,8 +235,8 @@ class QueryParser {
                     if (raw && isEmpty(whereItem.op) && isEmpty(whereItem.value)) {
                         fullRaw = true;
                     }
-                    op = this._operation(whereItem.op, `${scope}[${index}].op`);
-                    value = this._value(whereItem.value, `${scope}[${index}].value`);
+                    const op = this._operation(whereItem.op, `${scope}[${index}].op`);
+                    const value = this._value(whereItem.value, `${scope}[${index}].value`);
                     if (field) {
                         newWhere.push({ field, op, value });
                     }
@@ -249,20 +246,18 @@ class QueryParser {
                 }
                 // Case 2B: |[K, unknown]
                 else if (Array.isArray(item) && item.length > 0) {
-                    let field;
-                    let value;
-                    field = this._field(item[0], `${scope}[${index}][0]`);
-                    value = this._value(item[1], `${scope}[${index}][1]`);
-                    newWhere.push({ field, value, op: 'eq' });
+                    const field = this._field(item[0], `${scope}[${index}][0]`);
+                    const value = this._value(item[1], `${scope}[${index}][1]`);
+                    newWhere.push({ field, value, op: "eq" });
                 }
                 else {
-                    throw this._invalid(item, `${scope}[${index}]`, ['object', 'array'], (scope === 'where') ? 'where:item' : 'having:item');
+                    throw this._invalid(item, `${scope}[${index}]`, ["object", "array"], scope === "where" ? "where:item" : "having:item");
                 }
             });
         }
         // case: other
         else {
-            throw this._invalid(given, scope, ['object', 'array'], (scope === 'where') ? 'where:body' : 'having:body');
+            throw this._invalid(given, scope, ["object", "array"], scope === "where" ? "where:body" : "having:body");
         }
         return newWhere;
     }
@@ -304,13 +299,13 @@ class QueryParser {
                     newGroup.push({ field: item });
                 }
                 else {
-                    throw this._invalid(item, `groupBy[${index}]`, ['string', 'object'], 'groupBy:item');
+                    throw this._invalid(item, `groupBy[${index}]`, ["string", "object"], "groupBy:item");
                 }
             });
         }
         // case: other
         else {
-            throw this._invalid(given, `groupBy`, ['array'], 'groupBy:body');
+            throw this._invalid(given, `groupBy`, ["array"], "groupBy:body");
         }
         return newGroup;
     }
@@ -336,7 +331,6 @@ class QueryParser {
             arr.forEach((item, index) => {
                 // Case 2A: OrderByGiven<K>|OrderByGivenRaw
                 if (isFilledObj(item)) {
-                    let asc;
                     let field;
                     let raw;
                     const obj = item;
@@ -347,7 +341,7 @@ class QueryParser {
                         field = this._field(obj.field, `orderBy[${index}].field`);
                     }
                     this._fieldXorRaw(field, raw, `orderBy[${index}].field`);
-                    asc = this._asc(obj.asc, `orderBy[${index}].asc`);
+                    const asc = this._asc(obj.asc, `orderBy[${index}].asc`);
                     if (field) {
                         newOrder.push({ field, asc });
                     }
@@ -357,18 +351,18 @@ class QueryParser {
                 }
                 // Case 2B: K
                 else if (isText(item)) {
-                    newOrder.push({ field: this._field(item, ''), asc: true });
+                    newOrder.push({ field: this._field(item, ""), asc: true });
                 }
                 // other
                 else {
-                    throw this._invalid(item, `orderBy[${index}]`, ['string', 'object'], 'orderBy:item');
+                    throw this._invalid(item, `orderBy[${index}]`, ["string", "object"], "orderBy:item");
                 }
             });
         }
         // case 3: {'id': true, name: true, ...} as OrderByValue<K>
         else if (isFilledObj(given)) {
             let index = 0;
-            for (let [k, v] of Object.entries(given)) {
+            for (const [k, v] of Object.entries(given)) {
                 const field = this._field(k, `orderBy(key=${index})`);
                 const asc = this._asc(v, `orderBy.${field}`);
                 newOrder.push({ field, asc });
@@ -377,7 +371,7 @@ class QueryParser {
         }
         // case: other
         else {
-            throw this._invalid(given, `orderBy`, ['string', 'array', 'object'], 'orderBy:body');
+            throw this._invalid(given, `orderBy`, ["string", "array", "object"], "orderBy:body");
         }
         return newOrder;
     }
@@ -392,7 +386,7 @@ class QueryParser {
             }
             return {
                 limit: this._num(given[0], `pagination[0]`, 1),
-                offset: this._num(given[1], `pagination[1]`, 0)
+                offset: this._num(given[1], `pagination[1]`, 0),
             };
         }
         // Case 2: PaginationPage | PaginationLimit
@@ -404,37 +398,37 @@ class QueryParser {
             if (!isEmpty(obj.page)) {
                 const page = this._num(obj.page, `pagination.page`, 1);
                 const size = this._num(obj.size, `pagination.size`, 1) ?? 50;
-                ['limit', 'offset'].forEach(f => {
+                ["limit", "offset"].forEach((f) => {
                     if (!isEmpty(given[f])) {
-                        throw this._error('page:conflict', 'If you give page; limit and offset can not be used anymore', `pagination.page`);
+                        throw this._error("page:conflict", "If you give page; limit and offset can not be used anymore", `pagination.page`);
                     }
                 });
                 return {
                     limit: size,
-                    offset: (page - 1) * size
+                    offset: (page - 1) * size,
                 };
             }
             if (!isEmpty(obj.limit)) {
-                ['page', 'size'].forEach(f => {
+                ["page", "size"].forEach((f) => {
                     if (!isEmpty(obj[f])) {
-                        throw this._error('limit:conflict', 'If you give limit; page and size can not be used anymore', `pagination.limit`);
+                        throw this._error("limit:conflict", "If you give limit; page and size can not be used anymore", `pagination.limit`);
                     }
                 });
                 return {
                     limit: this._num(obj.limit, `pagination.limit`, 1),
-                    offset: this._num(obj.offset, `pagination.offset`, 0)
+                    offset: this._num(obj.offset, `pagination.offset`, 0),
                 };
             }
-            throw this._error('pagination:invalid-key', 'Pagination should have limit/offset or page/size keys', 'pagination');
+            throw this._error("pagination:invalid-key", "Pagination should have limit/offset or page/size keys", "pagination");
         }
-        throw this._invalid(given, 'pagination', ['array', 'object'], 'pagination:invalid-type');
+        throw this._invalid(given, "pagination", ["array", "object"], "pagination:invalid-type");
     }
     // endregion parts
     exec(query, availableFields, name) {
         return {
             select: this._select(query?.select, availableFields, name),
-            where: this._where('where', query?.where, availableFields, name),
-            having: this._where('having', query?.having, availableFields, name),
+            where: this._where("where", query?.where, availableFields, name),
+            having: this._where("having", query?.having, availableFields, name),
             groupBy: this._groupBy(query?.groupBy, availableFields, name),
             orderBy: this._orderBy(query?.orderBy, availableFields, name),
             pagination: this._pagination(query?.pagination, name),

package/dist/query/index.d.ts

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/query/index.js

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/select/index.d.ts

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/select/index.js

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/select/index.types.d.ts

@@ -1,5 +1,5 @@
 import { FieldAs, FieldRaw, FieldRegular } from "../field/index.js";
-export type SelectAny<K extends string> = '*' | Array<K | [K, string] | SelectGiven<K> | SelectGivenRaw>;
+export type SelectAny<K extends string> = "*" | Array<K | [K, string] | SelectGiven<K> | SelectGivenRaw>;
 export type SelectGiven<K extends string> = FieldRegular<K> & FieldAs;
 export type SelectGivenRaw = FieldRaw & FieldAs;
 export interface Select<K extends string> {

package/dist/where/index.d.ts

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/dist/where/index.js

@@ -1 +1 @@
-export * from './index.types.js';
+export * from "./index.types.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leyyo/query",
-  "version": "1.3.5",
+  "version": "1.3.6",
   "description": "Query common component",
   "keywords": [
     "Query"
@@ -21,51 +21,37 @@
   "main": "dist/index.js",
   "type": "module",
   "scripts": {
-    "clear": "rimraf dist && rimraf coverage",
-    "clear:nm": "rimraf node_modules && npm run clear",
-    "lint": "eslint src/**/*.ts --quiet",
-    "lint:verbose": "eslint src/**/*.ts",
+    "clear": "rimraf dist",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "format": "prettier --check \"{src,test}/**/*.{ts,tsx,js}\"",
+    "format:force": "prettier --write \"{src,test}/**/*.{ts,tsx,js}\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "asset": "node -r ts-node/register commands/assets.js",
     "build": "npm run clear && tsc && npm run asset",
-    "test": "jest --config=jest.json --detectOpenHandles",
-    "coverage": "rimraf coverage && jest --config=jest.json --coverage --coverageDirectory=coverage",
-    "sample": "node -r ts-node/register src/sample.ts",
-    "publish:public": "npm run build && npm publish -access=public"
+    "publish:public": "npm run lint && npm run format:force && npm run test && npm run build && npm publish --access=public"
   },
   "files": [
     "dist/*"
   ],
   "license": "ISC",
   "devDependencies": {
-    "@babel/preset-env": "^7.28.0",
-    "@babel/preset-typescript": "^7.27.1",
-    "@eslint/js": "^9.33.0",
-    "@types/jest": "^30.0.0",
+    "@eslint/js": "^9.0.0",
     "@types/node": "^24.2.1",
-    "@typescript-eslint/eslint-plugin": "^8.39.1",
-    "@typescript-eslint/parser": "^8.39.1",
-    "eslint": "^9.33.0",
+    "@vitest/coverage-istanbul": "^4.0.18",
+    "eslint": "^9.0.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^54.0.0",
-    "eslint-plugin-node": "^11.1.0",
-    "husky": "^9.1.7",
-    "jest": "^29.7.0",
-    "prettier": "^3.6.2",
+    "eslint-plugin-n": "^17.24.0",
+    "prettier": "^3.8.1",
     "rimraf": "^6.0.1",
-    "test": "^3.3.0",
-    "ts-jest": "^29.4.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.39.1"
-  },
-  "overrides": {
-    "eslint-config-standard": {
-      "eslint": "^9.33.0"
-    }
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@leyyo/common": "^1.3.18"
+    "@leyyo/common": "^1.3.21"
   }
 }