@leyyo/query 1.0.1 → 1.0.2

package/dist/assets/icon.svg

@@ -1,7 +1,8 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 <svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
     <rect width="24" height="24" rx="4" fill="#03a56f" />
-    <g transform="scale(0.9)" transform-origin="12 12" stroke-width="1">
-        <path d="M21 6H19M21 12H16M21 18H16M7 20V13.5612C7 13.3532 7 13.2492 6.97958 13.1497C6.96147 13.0615 6.93151 12.9761 6.89052 12.8958C6.84431 12.8054 6.77934 12.7242 6.64939 12.5617L3.35061 8.43826C3.22066 8.27583 3.15569 8.19461 3.10948 8.10417C3.06849 8.02393 3.03853 7.93852 3.02042 7.85026C3 7.75078 3 7.64677 3 7.43875V5.6C3 5.03995 3 4.75992 3.10899 4.54601C3.20487 4.35785 3.35785 4.20487 3.54601 4.10899C3.75992 4 4.03995 4 4.6 4H13.4C13.9601 4 14.2401 4 14.454 4.10899C14.6422 4.20487 14.7951 4.35785 14.891 4.54601C15 4.75992 15 5.03995 15 5.6V7.43875C15 7.64677 15 7.75078 14.9796 7.85026C14.9615 7.93852 14.9315 8.02393 14.8905 8.10417C14.8443 8.19461 14.7793 8.27583 14.6494 8.43826L11.3506 12.5617C11.2207 12.7242 11.1557 12.8054 11.1095 12.8958C11.0685 12.9761 11.0385 13.0615 11.0204 13.1497C11 13.2492 11 13.3532 11 13.5612V17L7 20Z" stroke="#ffffff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+    <g transform="scale(0.9)" transform-origin="12 12" stroke-width="2">
+        <path stroke="#ffffff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"
+              d="M21 6H19M21 12H16M21 18H16M7 20V13.5612C7 13.3532 7 13.2492 6.97958 13.1497C6.96147 13.0615 6.93151 12.9761 6.89052 12.8958C6.84431 12.8054 6.77934 12.7242 6.64939 12.5617L3.35061 8.43826C3.22066 8.27583 3.15569 8.19461 3.10948 8.10417C3.06849 8.02393 3.03853 7.93852 3.02042 7.85026C3 7.75078 3 7.64677 3 7.43875V5.6C3 5.03995 3 4.75992 3.10899 4.54601C3.20487 4.35785 3.35785 4.20487 3.54601 4.10899C3.75992 4 4.03995 4 4.6 4H13.4C13.9601 4 14.2401 4 14.454 4.10899C14.6422 4.20487 14.7951 4.35785 14.891 4.54601C15 4.75992 15 5.03995 15 5.6V7.43875C15 7.64677 15 7.75078 14.9796 7.85026C14.9615 7.93852 14.9315 8.02393 14.8905 8.10417C14.8443 8.19461 14.7793 8.27583 14.6494 8.43826L11.3506 12.5617C11.2207 12.7242 11.1557 12.8054 11.1095 12.8958C11.0685 12.9761 11.0385 13.0615 11.0204 13.1497C11 13.2492 11 13.3532 11 13.5612V17L7 20Z"/>
     </g>
 </svg>

package/dist/field/index.d.ts

@@ -0,0 +1 @@
+export * from './index.types';

package/dist/field/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);

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

@@ -0,0 +1,10 @@
+import type { KeyOf } from "@leyyo/common";
+export interface FieldRegular<T> {
+    field: KeyOf<T>;
+}
+export interface FieldRaw {
+    raw: string;
+}
+export interface FieldAs {
+    as?: string;
+}

package/dist/field/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export * from './index.types';

package/dist/group-by/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);

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

@@ -0,0 +1,8 @@
+import type { KeyOf } from "@leyyo/common";
+import type { FieldRaw, FieldRegular } from "../field";
+export type GroupByAny<T> = Array<KeyOf<T> | GroupByGivenRegular<T> | GroupByGivenRaw>;
+export type GroupByGivenRegular<T> = FieldRegular<T>;
+export type GroupByGivenRaw = FieldRaw;
+export type GroupBy<T> = Array<GroupByItemRegular<T> | GroupByItemRaw>;
+export type GroupByItemRegular<T> = FieldRegular<T>;
+export type GroupByItemRaw = FieldRaw;

package/dist/group-by/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,2 +1,9 @@
-export * from './index.types';
 export * from './condition';
+export * from './field';
+export * from './group-by';
+export * from './order-by';
+export * from './pagination';
+export * from './parser';
+export * from './query';
+export * from './select';
+export * from './where';

package/dist/index.js

@@ -14,5 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./index.types"), exports);
 __exportStar(require("./condition"), exports);
+__exportStar(require("./field"), exports);
+__exportStar(require("./group-by"), exports);
+__exportStar(require("./order-by"), exports);
+__exportStar(require("./pagination"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./query"), exports);
+__exportStar(require("./select"), exports);
+__exportStar(require("./where"), exports);

package/dist/index.types.d.ts

@@ -1,37 +0,0 @@
-import { ConditionType } from "./condition";
-import { KeyOf, Keys } from "@leyyo/common";
-export type OrderType = 'asc' | 'desc';
-export type OrderByAny<T> = KeyOf<T> | Keys<T> | Array<OrderBy<T>>;
-export interface OrderBy<T> {
-    field: KeyOf<T>;
-    asc: boolean | OrderType;
-}
-export type PaginationAny = PaginationPage | PaginationLimit | PaginationLiteral;
-export interface PaginationPage {
-    page?: number;
-    size?: number;
-}
-export interface PaginationLimit {
-    limit?: number;
-    offset?: number;
-}
-export type PaginationLiteral = [number?, number?];
-export type WhereValue<T, K extends keyof T = keyof T> = {
-    [P in K]: T[P];
-};
-export type WhereAny<T> = WhereValue<T> | Array<Where<T>>;
-export interface Where<T> {
-    field: KeyOf<T>;
-    condition?: string | ConditionType;
-    value: unknown;
-    lambda?: string;
-}
-export type SelectAny<T> = '*' | string | Keys<T>;
-export type GroupByAny<T> = Keys<T>;
-export interface QueryAny<T = Record<string, unknown>> {
-    select: SelectAny<T>;
-    where?: WhereAny<T>;
-    groupBy?: GroupByAny<T>;
-    orderBy?: OrderByAny<T>;
-    pagination?: PaginationAny;
-}

package/dist/index.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export * from './index.types';

package/dist/order-by/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);

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

@@ -0,0 +1,18 @@
+import type { KeyOf } from "@leyyo/common";
+import type { FieldRaw, FieldRegular } from "../field";
+export type OrderType = 'asc' | 'desc';
+export type OrderByAny<T> = KeyOf<T> | Array<OrderByGiven<T> | KeyOf<T> | OrderByGivenRaw> | OrderByValue<T>;
+export type OrderByValue<T, K extends keyof T = keyof T> = {
+    [P in K]: boolean;
+};
+export interface OrderByGivenAsc {
+    asc?: boolean | OrderType;
+}
+export interface OrderAscRegular {
+    asc: boolean;
+}
+export type OrderByGiven<T> = FieldRegular<T> & OrderByGivenAsc;
+export type OrderByGivenRaw = FieldRaw & OrderByGivenAsc;
+export type OrderByItem<T> = FieldRegular<T> & OrderAscRegular;
+export type OrderByRaw = FieldRaw & OrderAscRegular;
+export type OrderBy<T> = Array<OrderByItem<T> | OrderByRaw>;

package/dist/order-by/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/pagination/index.d.ts

@@ -0,0 +1 @@
+export * from './index.types';

package/dist/pagination/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);

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

@@ -0,0 +1,10 @@
+export type PaginationAny = PaginationPage | PaginationLimit | PaginationLiteral;
+export interface PaginationPage {
+    page?: number;
+    size?: number;
+}
+export interface PaginationLimit {
+    limit?: number;
+    offset?: number;
+}
+export type PaginationLiteral = [number?, number?];

package/dist/pagination/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parser/index.d.ts

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

package/dist/parser/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);
+__exportStar(require("./query.parser"), exports);

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

@@ -0,0 +1,5 @@
+import type { KeyOf } from "@leyyo/common";
+import type { QueryAny, QueryRegular } from "../query";
+export interface QueryParserLike {
+    exec<T>(query: QueryAny<T>, availableFields: Array<KeyOf<T> | string>, name?: string): QueryRegular<T>;
+}

package/dist/parser/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parser/query.parser.d.ts

@@ -0,0 +1,2 @@
+import type { QueryParserLike } from "./index.types";
+export declare const queryParser: QueryParserLike;

package/dist/parser/query.parser.js

@@ -0,0 +1,421 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryParser = void 0;
+const common_1 = require("@leyyo/common");
+const condition_1 = require("../condition");
+class QueryParser {
+    // region private
+    _error(message, path) {
+        return new Error(message + ', ' + path);
+    }
+    _asc(value, path) {
+        if (common_1.$is.empty(value)) {
+            return true;
+        }
+        if (common_1.$is.boolean(value)) {
+            return value;
+        }
+        else if (common_1.$is.text(value)) {
+            if (value.toLowerCase() === 'asc') {
+                return true;
+            }
+            else if (value.toLowerCase() === 'desc') {
+                return false;
+            }
+            throw this._error('Order asc error: invalid string', path);
+        }
+        throw this._error('Order asc error: invalid string', path);
+    }
+    _field(value, path) {
+        if (common_1.$is.text(value)) {
+            return value;
+        }
+        throw this._error('Order asc error: invalid string', path);
+    }
+    _raw(value, path) {
+        if (common_1.$is.text(value)) {
+            return value;
+        }
+        throw this._error('Order asc error: invalid string', path);
+    }
+    _as(value, path) {
+        if (common_1.$is.empty(value)) {
+            return undefined;
+        }
+        else if (common_1.$is.text(value)) {
+            return value;
+        }
+        throw this._error('Order asc error: invalid string', path);
+    }
+    _condition(value, path) {
+        if (common_1.$is.empty(value)) {
+            return '==';
+        }
+        else if (common_1.$is.text(value)) {
+            const key = value;
+            if (common_1.$is.literal(key, condition_1.ConditionTypeItems)) {
+                return key;
+            }
+            if (condition_1.ConditionTypeMap[key] !== undefined) {
+                return condition_1.ConditionTypeMap[key];
+            }
+            throw this._error('Order asc error: invalid string', path);
+        }
+        throw this._error('Order asc error: invalid string', path);
+    }
+    _value(value, path) {
+        if (value === undefined) {
+            return [undefined];
+        }
+        switch (typeof value) {
+            case "string":
+                return [];
+            case "number":
+            case "boolean":
+                return [value];
+            case "object":
+                if (value === null) {
+                    return [null];
+                }
+                if (Array.isArray(value) && value.length > 0) {
+                    return value;
+                }
+                break;
+        }
+        throw this._error('Order asc error: invalid string', path);
+    }
+    _num(value, path, min) {
+        if (common_1.$is.empty(value)) {
+            return undefined;
+        }
+        else if (common_1.$is.integer(value) && value >= min) {
+            return value;
+        }
+        throw this._error('Order asc error: invalid string', path);
+    }
+    _fieldXorRaw(field, raw, path) {
+        if (!raw && !field) {
+            throw this._error('Order asc error: invalid string', path);
+        }
+        else if (raw && field) {
+            throw this._error('Order asc error: invalid string', path);
+        }
+    }
+    // endregion private
+    // region parts
+    _select(given, _availableFields, name) {
+        if (common_1.$is.empty(given)) {
+            return true;
+        }
+        // Cases:
+        // 1 - '*'
+        // 2 - Array<KeyOf<T> | [KeyOf<T>, string] | SelectGiven<T> | SelectGivenRaw>
+        // case 1: string as KeyOf<T>
+        if (given === '*') {
+            return true;
+        }
+        const newSelect = [];
+        // case 2: Array<KeyOf<T> | [KeyOf<T>, string] | SelectGiven<T> | SelectGivenRaw>
+        if (Array.isArray(given)) {
+            if (given.length < 1) {
+                return true;
+            }
+            const arr = given;
+            arr.forEach((item, index) => {
+                // Case 2A: KeyOf<T>
+                if (common_1.$is.text(item)) {
+                    newSelect.push({
+                        field: item,
+                    });
+                }
+                // Case 2B: [KeyOf<T>, string]
+                else if (Array.isArray(item)) {
+                    let [field, as] = item;
+                    field = this._field(field, `select[${index}][0]`);
+                    as = this._as(as, `select[${index}][1]`);
+                    newSelect.push({ field, as, });
+                }
+                // Case 2C: SelectGiven<T> | SelectGivenRaw
+                else if (common_1.$is.object(item)) {
+                    let as;
+                    let field;
+                    let raw;
+                    const obj = item;
+                    if (!common_1.$is.empty(obj.raw)) {
+                        raw = this._raw(obj.raw, `select[${index}].raw`);
+                    }
+                    if (!common_1.$is.empty(obj.field)) {
+                        field = this._field(obj.field, `select[${index}].field`);
+                    }
+                    this._fieldXorRaw(field, raw, `select[${index}].field`);
+                    as = this._as(obj.as, `select[${index}].as`);
+                    if (field) {
+                        newSelect.push({ field, as });
+                    }
+                    else {
+                        newSelect.push({ raw, as });
+                    }
+                }
+                // other
+                else {
+                    throw this._error('Invalid select item', name);
+                }
+            });
+        }
+        // case: other
+        else {
+            throw this._error('Invalid select item', name);
+        }
+        return newSelect;
+    }
+    _where(scope, given, _availableFields, name) {
+        if (common_1.$is.empty(given)) {
+            return [];
+        }
+        // Cases:
+        // 1 - WhereValue<T>
+        // 2 - Array<WhereGiven<T>|WhereGivenRaw|[KeyOf<T>, unknown]>
+        const newWhere = [];
+        // case 1: WhereValue<T>
+        if (common_1.$is.object(given)) {
+            let index = 0;
+            for (let [k, v] of Object.entries(given)) {
+                const field = this._field(k, `where(key=${index})`);
+                const value = this._value(v, `where.${field}`);
+                newWhere.push({ field, value, condition: '==' });
+                index++;
+            }
+        }
+        // case 2: array as Array<WhereGiven<T>|WhereGivenRaw|[KeyOf<T>, unknown]>
+        else if (Array.isArray(given)) {
+            if (given.length < 1) {
+                return [];
+            }
+            const arr = given;
+            arr.forEach((item, index) => {
+                var _a, _b;
+                // Case 2A: WhereGiven<T>|WhereGivenRaw
+                if (common_1.$is.object(item)) {
+                    let field;
+                    let raw;
+                    let condition;
+                    let value;
+                    let fullRaw;
+                    const obj = item;
+                    if (!common_1.$is.empty(obj.raw)) {
+                        raw = this._raw(obj.raw, `select[${index}].raw`);
+                    }
+                    if (!common_1.$is.empty(obj.field)) {
+                        field = this._field(obj.field, `select[${index}].field`);
+                    }
+                    this._fieldXorRaw(field, raw, `where[${index}].field`);
+                    const whereItem = obj;
+                    if (raw && common_1.$is.empty((_a = whereItem.eq) !== null && _a !== void 0 ? _a : whereItem.condition) && common_1.$is.empty(whereItem.value)) {
+                        fullRaw = true;
+                    }
+                    condition = this._condition((_b = whereItem.eq) !== null && _b !== void 0 ? _b : whereItem.condition, `select[${index}].condition`);
+                    value = this._value(whereItem.value, `select[${index}].value`);
+                    if (field) {
+                        newWhere.push({ field, condition, value });
+                    }
+                    else {
+                        newWhere.push({ raw, condition, value, fullRaw });
+                    }
+                }
+                // Case 2B: |[KeyOf<T>, unknown]
+                else if (Array.isArray(item) && item.length > 0) {
+                    let field;
+                    let value;
+                    field = this._field(item[0], `select[${index}][0]`);
+                    value = this._value(item[1], `select[${index}][1]`);
+                    newWhere.push({ field, value, condition: '==' });
+                }
+                else {
+                    throw this._error('Invalid select item', name);
+                }
+            });
+        }
+        // case: other
+        else {
+            throw this._error('Invalid select item', name);
+        }
+        return newWhere;
+    }
+    _groupBy(given, _availableFields, name) {
+        if (common_1.$is.empty(given)) {
+            return [];
+        }
+        // Cases:
+        // 1 - Array<KeyOf<T> | GroupByGivenRegular<T> | GroupByGivenRaw>
+        const newGroup = [];
+        // case 1: Array<KeyOf<T> | GroupByGivenRegular<T> | GroupByGivenRaw>
+        if (Array.isArray(given)) {
+            if (given.length < 1) {
+                return [];
+            }
+            const arr = given;
+            arr.forEach((item, index) => {
+                // Case 2A: GroupByGivenRegular<T> | GroupByGivenRaw
+                if (common_1.$is.object(item)) {
+                    let field;
+                    let raw;
+                    const obj = item;
+                    if (!common_1.$is.empty(obj.raw)) {
+                        raw = this._raw(obj.raw, `groupBy[${index}].raw`);
+                    }
+                    if (!common_1.$is.empty(obj.field)) {
+                        field = this._field(obj.field, `groupBy[${index}].field`);
+                    }
+                    this._fieldXorRaw(field, raw, `groupBy[${index}].field`);
+                    if (field) {
+                        newGroup.push({ field });
+                    }
+                    else {
+                        newGroup.push({ raw });
+                    }
+                }
+                // Case 2B: KeyOf<T>
+                else if (common_1.$is.text(item)) {
+                    newGroup.push({ field: item });
+                }
+                else {
+                    throw this._error('Invalid select item', name);
+                }
+            });
+        }
+        // case: other
+        else {
+            throw this._error('Invalid select item', name);
+        }
+        return newGroup;
+    }
+    _orderBy(given, _availableFields, name) {
+        if (common_1.$is.empty(given)) {
+            return [];
+        }
+        // Cases:
+        // 1 - KeyOf<T>
+        // 2 - Array<OrderByGiven<T>|KeyOf<T>|OrderByGivenRaw>
+        // 3 - OrderByValue<T>
+        const newOrder = [];
+        // case 1: string as KeyOf<T>
+        if (common_1.$is.text(given)) {
+            newOrder.push({ field: given, asc: true });
+        }
+        // case 2: array as Array<OrderByGiven<T>|KeyOf<T>|OrderByGivenRaw>
+        else if (Array.isArray(given)) {
+            if (given.length < 1) {
+                return [];
+            }
+            const arr = given;
+            arr.forEach((item, index) => {
+                // Case 2A: OrderByGiven<T>|OrderByGivenRaw
+                if (common_1.$is.object(item)) {
+                    let asc;
+                    let field;
+                    let raw;
+                    const obj = item;
+                    if (!common_1.$is.empty(obj.raw)) {
+                        raw = this._raw(obj.raw, `orderBy[${index}].raw`);
+                    }
+                    if (!common_1.$is.empty(obj.field)) {
+                        field = this._field(obj.field, `orderBy[${index}].field`);
+                    }
+                    this._fieldXorRaw(field, raw, `orderBy[${index}].field`);
+                    asc = this._asc(obj.asc, `orderBy[${index}].asc`);
+                    if (field) {
+                        newOrder.push({ field, asc });
+                    }
+                    else {
+                        newOrder.push({ raw, asc });
+                    }
+                }
+                // Case 2B: KeyOf<T>
+                else if (common_1.$is.text(item)) {
+                    newOrder.push({ field: this._field(item, ''), asc: true });
+                }
+                // other
+                else {
+                    throw this._error('Invalid select item', name);
+                }
+            });
+        }
+        // case 3: {'id': true, name: true, ...} as OrderByValue<T>
+        else if (common_1.$is.object(given)) {
+            let index = 0;
+            for (let [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 });
+                index++;
+            }
+        }
+        // case: other
+        else {
+            throw this._error('Invalid select item', name);
+        }
+        return newOrder;
+    }
+    _pagination(given, name) {
+        var _a;
+        if (common_1.$is.empty(given)) {
+            return {};
+        }
+        // Case 1: PaginationLiteral
+        if (Array.isArray(given)) {
+            if (given.length < 1) {
+                return {};
+            }
+            return {
+                limit: this._num(given[0], `pagination[0]`, 1),
+                offset: this._num(given[1], `pagination[1]`, 0)
+            };
+        }
+        // Case 2: PaginationPage | PaginationLimit
+        else if (common_1.$is.object(given)) {
+            if (Object.keys(given).length < 1) {
+                return {};
+            }
+            const obj = given;
+            if (!common_1.$is.empty(obj.page)) {
+                ['limit', 'offset'].forEach(f => {
+                    if (!common_1.$is.empty(given[f])) {
+                        throw this._error('Invalid select item', name);
+                    }
+                });
+                const page = this._num(obj.page, `pagination.page`, 1);
+                const size = (_a = this._num(obj.size, `pagination.size`, 1)) !== null && _a !== void 0 ? _a : 50;
+                return {
+                    limit: size,
+                    offset: (page - 1) * size
+                };
+            }
+            if (!common_1.$is.empty(obj.limit)) {
+                ['page', 'size'].forEach(f => {
+                    if (!common_1.$is.empty(obj[f])) {
+                        throw this._error('Invalid select item', name);
+                    }
+                });
+                return {
+                    limit: this._num(obj.limit, `pagination.limit`, 1),
+                    offset: this._num(obj.offset, `pagination.offset`, 0)
+                };
+            }
+            throw this._error('Invalid select item', name);
+        }
+        throw this._error('Invalid select item', name);
+    }
+    // endregion parts
+    exec(query, availableFields, name) {
+        return {
+            select: this._select(query === null || query === void 0 ? void 0 : query.select, availableFields, name),
+            where: this._where('where', query === null || query === void 0 ? void 0 : query.where, availableFields, name),
+            having: this._where('having', query === null || query === void 0 ? void 0 : query.having, availableFields, name),
+            groupBy: this._groupBy(query === null || query === void 0 ? void 0 : query.groupBy, availableFields, name),
+            orderBy: this._orderBy(query === null || query === void 0 ? void 0 : query.orderBy, availableFields, name),
+            pagination: this._pagination(query === null || query === void 0 ? void 0 : query.pagination, name),
+        };
+    }
+}
+// noinspection JSUnusedGlobalSymbols
+exports.queryParser = new QueryParser();

package/dist/query/index.d.ts

@@ -0,0 +1 @@
+export * from './index.types';

package/dist/query/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);

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

@@ -0,0 +1,21 @@
+import type { Select, SelectAny } from "../select";
+import type { Where, WhereAny } from "../where";
+import type { GroupBy, GroupByAny } from "../group-by";
+import type { OrderBy, OrderByAny } from "../order-by";
+import type { PaginationAny, PaginationLimit } from "../pagination";
+export interface QueryAny<T = Record<string, unknown>> {
+    select?: SelectAny<T>;
+    where?: WhereAny<T>;
+    having?: WhereAny<T>;
+    groupBy?: GroupByAny<T>;
+    orderBy?: OrderByAny<T>;
+    pagination?: PaginationAny;
+}
+export interface QueryRegular<T = Record<string, unknown>> {
+    select: Select<T>;
+    where: Where<T>;
+    having: Where<T>;
+    groupBy: GroupBy<T>;
+    orderBy: OrderBy<T>;
+    pagination: PaginationLimit;
+}

package/dist/query/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/select/index.d.ts

@@ -0,0 +1 @@
+export * from './index.types';

package/dist/select/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);

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

@@ -0,0 +1,8 @@
+import type { KeyOf } from "@leyyo/common";
+import type { FieldAs, FieldRaw, FieldRegular } from "../field";
+export type SelectAny<T> = '*' | Array<KeyOf<T> | [KeyOf<T>, string] | SelectGiven<T> | SelectGivenRaw>;
+export type SelectGiven<T> = FieldRegular<T> & FieldAs;
+export type SelectGivenRaw = FieldRaw & FieldAs;
+export type Select<T> = true | Array<SelectItemRegular<T> | SelectItemRaw>;
+export type SelectItemRegular<T> = FieldRegular<T> & FieldAs;
+export type SelectItemRaw = FieldRaw & FieldAs;

package/dist/select/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/where/index.d.ts

@@ -0,0 +1 @@
+export * from './index.types';

package/dist/where/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);

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

@@ -0,0 +1,22 @@
+import type { KeyOf } from "@leyyo/common";
+import type { ConditionType } from "../condition";
+import type { FieldRaw, FieldRegular } from "../field";
+export type WhereValue<T, K extends keyof T = keyof T> = {
+    [P in K]: T[P];
+};
+export type WhereAny<T> = WhereValue<T> | Array<WhereGiven<T> | WhereGivenRaw | [KeyOf<T>, unknown]>;
+export interface WhereGivenCondition {
+    eq?: string | ConditionType;
+    condition?: string | ConditionType;
+    value: unknown;
+}
+export type WhereGiven<T> = FieldRegular<T> & WhereGivenCondition;
+export type WhereGivenRaw = FieldRaw & WhereGivenCondition;
+export type Where<T> = Array<WhereItemRegular<T> | WhereItemRaw>;
+export type WhereItemRegular<T> = FieldRegular<T> & WhereCondition;
+export type WhereItemRaw = FieldRaw & WhereCondition;
+export interface WhereCondition {
+    fullRaw?: true;
+    condition?: ConditionType;
+    value?: unknown;
+}

package/dist/where/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leyyo/query",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Query common component",
   "keywords": [
     "Query"