@leyyo/query 1.0.1 → 1.0.3

package/dist/error/index.d.ts

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

package/dist/error/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("./invalid-query-value.error"), exports);
+__exportStar(require("./index.types"), exports);

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

@@ -0,0 +1 @@
+export type QueryErrorCode = 'xxx' | 'field:invalid' | 'field:empty' | 'field:raw-both' | 'field:raw-none' | 'as:invalid' | 'raw:invalid' | 'raw:empty' | 'eq:invalid-key' | 'eq: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/error/invalid-query-value.error.d.ts

@@ -0,0 +1,6 @@
+import { QueryErrorCode } from "./index.types";
+export declare class InvalidQueryValueError extends Error {
+    readonly message: string;
+    readonly path: string;
+    constructor(code: QueryErrorCode, message: string, path: string);
+}

package/dist/error/invalid-query-value.error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidQueryValueError = void 0;
+class InvalidQueryValueError extends Error {
+    constructor(code, message, path) {
+        super(`[${code}] ${message} at ${path}`);
+        this.message = message;
+        this.path = path;
+    }
+}
+exports.InvalidQueryValueError = InvalidQueryValueError;

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,9 @@
+export interface FieldRegular<K extends string> {
+    field: K;
+}
+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,7 @@
+import type { FieldRaw, FieldRegular } from "../field";
+export type GroupByAny<K extends string> = Array<K | GroupByGivenRegular<K> | GroupByGivenRaw>;
+export type GroupByGivenRegular<K extends string> = FieldRegular<K>;
+export type GroupByGivenRaw = FieldRaw;
+export type GroupBy<K extends string> = Array<GroupByItemRegular<K> | GroupByItemRaw>;
+export type GroupByItemRegular<K extends string> = FieldRegular<K>;
+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,10 @@
-export * from './index.types';
 export * from './condition';
+export * from './error';
+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,13 @@ 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("./error"), 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/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,17 @@
+import type { FieldRaw, FieldRegular } from "../field";
+export type OrderType = 'asc' | 'desc';
+export type OrderByAny<K extends string> = K | Array<OrderByGiven<K> | K | OrderByGivenRaw> | OrderByValue<K>;
+export type OrderByValue<K extends string> = {
+    [field in K]: boolean | OrderType;
+};
+export interface OrderByGivenAsc {
+    asc?: boolean | OrderType;
+}
+export interface OrderAscRegular {
+    asc: boolean;
+}
+export type OrderByGiven<K extends string> = FieldRegular<K> & OrderByGivenAsc;
+export type OrderByGivenRaw = FieldRaw & OrderByGivenAsc;
+export type OrderByItem<K extends string> = FieldRegular<K> & OrderAscRegular;
+export type OrderByRaw = FieldRaw & OrderAscRegular;
+export type OrderBy<K extends string> = Array<OrderByItem<K> | 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,6 @@
+import type { QueryAny, QueryRegular } from "../query";
+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' | '*';

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,448 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryParser = void 0;
+const common_1 = require("@leyyo/common");
+const condition_1 = require("../condition");
+const error_1 = require("../error");
+class QueryParser {
+    // region private
+    _error(code, message, path) {
+        return new error_1.InvalidQueryValueError(code, message, path);
+    }
+    _invalid(value, path, expected, code) {
+        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 (common_1.$is.empty(value)) {
+            return this._error(empty, `It's empty`, path);
+        }
+        if (typeof value === 'string' && value.trim() === '') {
+            return this._error(empty, `It's empty`, path);
+        }
+        return this._invalid(value, path, expected, invalid);
+    }
+    _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('asc:invalid-key', `It should be [asc, desc], but it's value: ${value}`, path);
+        }
+        throw this._invalid(value, path, ['boolean', 'string'], 'asc:invalid-type');
+    }
+    _field(value, path) {
+        if (common_1.$is.text(value)) {
+            return value;
+        }
+        throw this._emptyOrInvalid(value, path, 'string', 'field:empty', 'field:invalid');
+    }
+    _raw(value, path) {
+        if (common_1.$is.text(value)) {
+            return value;
+        }
+        throw this._emptyOrInvalid(value, path, 'string', 'raw:empty', 'raw:invalid');
+    }
+    _as(value, path) {
+        if (common_1.$is.empty(value)) {
+            return undefined;
+        }
+        else if (common_1.$is.text(value)) {
+            return value;
+        }
+        throw this._invalid(value, path, 'string', 'as:invalid');
+    }
+    _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('eq:invalid-key', `It should be [@see equalities], but it's value: ${value}`, path);
+        }
+        throw this._invalid(value, path, 'string', 'eq:invalid-type');
+    }
+    _value(value, path) {
+        if (value === undefined) {
+            return [];
+        }
+        switch (typeof value) {
+            case "string":
+                value = value.trim();
+                if (!value) {
+                    throw this._error('value:invalid-type', `It should not be empty string`, path);
+                }
+                return [value];
+            case "number":
+            case "boolean":
+                return [value];
+            case "object":
+                if (value === null) {
+                    return [null];
+                }
+                if (Array.isArray(value)) {
+                    let index = 0;
+                    for (const item of value) {
+                        if (!common_1.$is.text(item) && !common_1.$is.number(item) && !common_1.$is.boolean(value)) {
+                            throw this._invalid(item, `${path}[${index}]`, ['string', 'number', 'boolean', 'array', 'number'], 'value:invalid-item');
+                        }
+                        index++;
+                    }
+                    return value;
+                }
+                break;
+        }
+        throw this._invalid(value, path, ['string', 'number', 'boolean', 'array', 'number'], 'value:invalid-type');
+    }
+    _num(value, path, min) {
+        if (common_1.$is.empty(value)) {
+            return undefined;
+        }
+        else if (common_1.$is.integer(value)) {
+            if (value >= min) {
+                return value;
+            }
+            throw this._error('integer:min', `It should be gte ${min}`, path);
+        }
+        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);
+        }
+        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);
+        }
+    }
+    // endregion private
+    // region parts
+    _select(given, _availableFields, _name) {
+        if (common_1.$is.empty(given)) {
+            return true;
+        }
+        // Cases:
+        // 1 - '*'
+        // 2 - Array<K | [K, string] | SelectGiven<K> | SelectGivenRaw>
+        // case 1: string as K
+        if (given === '*') {
+            return true;
+        }
+        const newSelect = [];
+        // case 2: Array<K | [K, string] | SelectGiven<K> | SelectGivenRaw>
+        if (Array.isArray(given)) {
+            if (given.length < 1) {
+                return true;
+            }
+            const arr = given;
+            arr.forEach((item, index) => {
+                // Case 2A: K
+                if (common_1.$is.text(item)) {
+                    newSelect.push({
+                        field: item,
+                    });
+                }
+                // Case 2B: [K, 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<K> | 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._invalid(item, `select[${index}]`, ['string', 'array', 'object'], 'select:item');
+                }
+            });
+        }
+        // case: other
+        else {
+            throw this._invalid(given, `select`, ['*', 'array'], 'select:body');
+        }
+        return newSelect;
+    }
+    _where(scope, given, _availableFields, _name) {
+        if (common_1.$is.empty(given)) {
+            return [];
+        }
+        // Cases:
+        // 1 - WhereValue<K>
+        // 2 - Array<WhereGiven<K>|WhereGivenRaw|[K, unknown]>
+        const newWhere = [];
+        // case 1: WhereValue<K>
+        if (common_1.$is.object(given)) {
+            let index = 0;
+            for (let [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, eq: '==' });
+                index++;
+            }
+        }
+        // case 2: array as Array<WhereGiven<K>|WhereGivenRaw|[K, unknown]>
+        else if (Array.isArray(given)) {
+            if (given.length < 1) {
+                return [];
+            }
+            const arr = given;
+            arr.forEach((item, index) => {
+                // Case 2A: WhereGiven<K>|WhereGivenRaw
+                if (common_1.$is.object(item)) {
+                    let field;
+                    let raw;
+                    let eq;
+                    let value;
+                    let fullRaw;
+                    const obj = item;
+                    if (!common_1.$is.empty(obj.raw)) {
+                        raw = this._raw(obj.raw, `${scope}[${index}].raw`);
+                    }
+                    if (!common_1.$is.empty(obj.field)) {
+                        field = this._field(obj.field, `${scope}[${index}].field`);
+                    }
+                    this._fieldXorRaw(field, raw, `${scope}[${index}].field`);
+                    const whereItem = obj;
+                    if (raw && common_1.$is.empty(whereItem.eq) && common_1.$is.empty(whereItem.value)) {
+                        fullRaw = true;
+                    }
+                    eq = this._condition(whereItem.eq, `${scope}[${index}].eq`);
+                    value = this._value(whereItem.value, `${scope}[${index}].value`);
+                    if (field) {
+                        newWhere.push({ field, eq, value });
+                    }
+                    else {
+                        newWhere.push({ raw, eq, value, fullRaw });
+                    }
+                }
+                // 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, eq: '==' });
+                }
+                else {
+                    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');
+        }
+        return newWhere;
+    }
+    _groupBy(given, _availableFields, _name) {
+        if (common_1.$is.empty(given)) {
+            return [];
+        }
+        // Cases:
+        // 1 - Array<K | GroupByGivenRegular<K> | GroupByGivenRaw>
+        const newGroup = [];
+        // case 1: Array<K | GroupByGivenRegular<K> | GroupByGivenRaw>
+        if (Array.isArray(given)) {
+            if (given.length < 1) {
+                return [];
+            }
+            const arr = given;
+            arr.forEach((item, index) => {
+                // Case 2A: GroupByGivenRegular<K> | 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: K
+                else if (common_1.$is.text(item)) {
+                    newGroup.push({ field: item });
+                }
+                else {
+                    throw this._invalid(item, `groupBy[${index}]`, ['string', 'object'], 'groupBy:item');
+                }
+            });
+        }
+        // case: other
+        else {
+            throw this._invalid(given, `groupBy`, ['array'], 'groupBy:body');
+        }
+        return newGroup;
+    }
+    _orderBy(given, _availableFields, _name) {
+        if (common_1.$is.empty(given)) {
+            return [];
+        }
+        // Cases:
+        // 1 - K
+        // 2 - Array<OrderByGiven<K>|K|OrderByGivenRaw>
+        // 3 - OrderByValue<K>
+        const newOrder = [];
+        // case 1: string as K
+        if (common_1.$is.text(given)) {
+            newOrder.push({ field: given, asc: true });
+        }
+        // case 2: array as Array<OrderByGiven<K>|K|OrderByGivenRaw>
+        else if (Array.isArray(given)) {
+            if (given.length < 1) {
+                return [];
+            }
+            const arr = given;
+            arr.forEach((item, index) => {
+                // Case 2A: OrderByGiven<K>|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: K
+                else if (common_1.$is.text(item)) {
+                    newOrder.push({ field: this._field(item, ''), asc: true });
+                }
+                // other
+                else {
+                    throw this._invalid(item, `orderBy[${index}]`, ['string', 'object'], 'orderBy:item');
+                }
+            });
+        }
+        // case 3: {'id': true, name: true, ...} as OrderByValue<K>
+        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._invalid(given, `orderBy`, ['string', 'array', 'object'], 'orderBy:body');
+        }
+        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)) {
+                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;
+                ['limit', 'offset'].forEach(f => {
+                    if (!common_1.$is.empty(given[f])) {
+                        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
+                };
+            }
+            if (!common_1.$is.empty(obj.limit)) {
+                ['page', 'size'].forEach(f => {
+                    if (!common_1.$is.empty(obj[f])) {
+                        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)
+                };
+            }
+            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');
+    }
+    // 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<K extends string> {
+    select?: SelectAny<K>;
+    where?: WhereAny<K>;
+    having?: WhereAny<K>;
+    groupBy?: GroupByAny<K>;
+    orderBy?: OrderByAny<K>;
+    pagination?: PaginationAny;
+}
+export interface QueryRegular<K extends string> {
+    select: Select<K>;
+    where: Where<K>;
+    having: Where<K>;
+    groupBy: GroupBy<K>;
+    orderBy: OrderBy<K>;
+    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,7 @@
+import type { FieldAs, FieldRaw, FieldRegular } from "../field";
+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 type Select<K extends string> = true | Array<SelectItemRegular<K> | SelectItemRaw>;
+export type SelectItemRegular<K extends string> = FieldRegular<K> & 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,20 @@
+import type { ConditionType } from "../condition";
+import type { FieldRaw, FieldRegular } from "../field";
+export type WhereValue<K extends string> = {
+    [P in K]: unknown;
+};
+export type WhereAny<K extends string> = WhereValue<K> | Array<WhereGiven<K> | WhereGivenRaw | [K, unknown]>;
+export interface WhereGivenCondition {
+    eq: string | ConditionType;
+    value?: unknown;
+}
+export type WhereGiven<K extends string> = FieldRegular<K> & WhereGivenCondition;
+export type WhereGivenRaw = FieldRaw & WhereGivenCondition;
+export type Where<K extends string> = Array<WhereItemRegular<K> | WhereItemRaw>;
+export type WhereItemRegular<K extends string> = FieldRegular<K> & WhereCondition;
+export type WhereItemRaw = FieldRaw & WhereCondition;
+export interface WhereCondition {
+    fullRaw?: true;
+    eq?: 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.3",
   "description": "Query common component",
   "keywords": [
     "Query"

package/dist/assets/icon.svg

@@ -1,7 +0,0 @@
-<!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>
-</svg>

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;
-}