@leyyo/query 1.0.2 → 1.2.1

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' | '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/error/index.types.js

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

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.types.d.ts

@@ -1,6 +1,5 @@
-import type { KeyOf } from "@leyyo/common";
-export interface FieldRegular<T> {
-    field: KeyOf<T>;
+export interface FieldRegular<K extends string> {
+    field: K;
 }
 export interface FieldRaw {
     raw: string;

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

@@ -1,8 +1,7 @@
-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 GroupByAny<K extends string> = Array<K | GroupByGivenRegular<K> | GroupByGivenRaw>;
+export type GroupByGivenRegular<K extends string> = FieldRegular<K>;
 export type GroupByGivenRaw = FieldRaw;
-export type GroupBy<T> = Array<GroupByItemRegular<T> | GroupByItemRaw>;
-export type GroupByItemRegular<T> = FieldRegular<T>;
+export type GroupBy<K extends string> = Array<GroupByItemRegular<K> | GroupByItemRaw>;
+export type GroupByItemRegular<K extends string> = FieldRegular<K>;
 export type GroupByItemRaw = FieldRaw;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export * from './condition';
+export * from './operation';
+export * from './error';
 export * from './field';
 export * from './group-by';
 export * from './order-by';

package/dist/index.js

@@ -14,7 +14,8 @@ 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("./condition"), exports);
+__exportStar(require("./operation"), exports);
+__exportStar(require("./error"), exports);
 __exportStar(require("./field"), exports);
 __exportStar(require("./group-by"), exports);
 __exportStar(require("./order-by"), exports);

package/dist/operation/index.d.ts

@@ -0,0 +1 @@
+export * from './operation-type';

package/dist/{condition → operation}/index.js

@@ -14,4 +14,4 @@ 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("./condition-type"), exports);
+__exportStar(require("./operation-type"), exports);

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

@@ -0,0 +1,3 @@
+export declare const ConditionTypeItems: readonly ["eq", "ne", "null", "!null", "missing", "!missing", "gt", "gte", "lt", "lte", "between", "!between", "in", "!in", "starts", "!starts", "ends", "!ends", "matches", "!matches", "contains", "!contains", "contained", "!contained", "true", "false", "includes", "!includes", "intersects", "!intersects", "exists", "!exists"];
+export type OperationType = typeof ConditionTypeItems[number];
+export declare const OperationTypeMap: Record<string, OperationType>;

package/dist/{condition/condition-type.js → operation/operation-type.js}

@@ -1,26 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConditionTypeMap = exports.ConditionTypeItems = void 0;
+exports.OperationTypeMap = exports.ConditionTypeItems = void 0;
 exports.ConditionTypeItems = [
     // all
-    '==',
-    '!=',
+    'eq',
+    'ne',
     'null',
     '!null',
+    'missing',
+    '!missing',
     // string, number
-    '>',
-    '>=',
-    '<',
-    '<=',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
     'between',
     '!between',
     'in',
     '!in',
     // string
-    '^',
-    '!^',
-    '$',
-    '!$',
+    'starts',
+    '!starts',
+    'ends',
+    '!ends',
     'matches',
     '!matches',
     'contains', // left includes right
@@ -40,32 +42,41 @@ exports.ConditionTypeItems = [
     '!exists',
 ];
 // noinspection JSUnusedGlobalSymbols
-exports.ConditionTypeMap = {
+exports.OperationTypeMap = {
     // all
-    'eq': '==',
-    '=': '==',
-    'equals': '==',
-    'equal': '==',
-    'ne': '!=',
-    '<>': '!=',
-    'not-equals': '!=',
-    'not-equal': '!=',
+    '=': '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': '>',
-    'greater-than-or-equals': '>=',
-    'gte': '>=',
-    '=>': '>=',
-    'less-than': '<',
-    'lt': '<',
-    'less-than-or-equals': '<=',
-    '=<': '<=',
-    'lte': '<=',
+    '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',
@@ -73,30 +84,29 @@ exports.ConditionTypeMap = {
     '][': '!in',
     'not-in': '!in',
     // string
-    'starts-with': '^',
-    'start-with': '^',
-    'starts': '^',
-    'start': '^',
-    'not-starts-with': '!^',
-    'not-start-with': '!^',
-    'not-starts': '!^',
-    'not-start': '!^',
-    '!starts-with': '!^',
-    '!start-with': '!^',
-    '!starts': '!^',
-    '!start': '!^',
-    'ends-with': '$',
-    'end-with': '$',
-    'ends': '$',
-    'end': '$',
-    'not-end-with': '!$',
-    'not-ends': '!$',
-    'not-end': '!$',
-    '!$': '!$',
-    '!ends-with': '!$',
-    '!end-with': '!$',
-    '!ends': '!$',
-    '!end': '!$',
+    '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',
@@ -114,10 +124,10 @@ exports.ConditionTypeMap = {
     '!like': '!contains',
     // boolean
     'yes': 'true',
-    'on': 'true',
-    'ok': 'true',
     'no': 'false',
+    'on': 'true',
     'off': 'false',
+    'ok': 'true',
     'none': 'false',
     // array object
     'include': 'includes',

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

@@ -1,9 +1,8 @@
-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 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;
@@ -11,8 +10,8 @@ export interface OrderByGivenAsc {
 export interface OrderAscRegular {
     asc: boolean;
 }
-export type OrderByGiven<T> = FieldRegular<T> & OrderByGivenAsc;
+export type OrderByGiven<K extends string> = FieldRegular<K> & OrderByGivenAsc;
 export type OrderByGivenRaw = FieldRaw & OrderByGivenAsc;
-export type OrderByItem<T> = FieldRegular<T> & OrderAscRegular;
+export type OrderByItem<K extends string> = FieldRegular<K> & OrderAscRegular;
 export type OrderByRaw = FieldRaw & OrderAscRegular;
-export type OrderBy<T> = Array<OrderByItem<T> | OrderByRaw>;
+export type OrderBy<K extends string> = Array<OrderByItem<K> | OrderByRaw>;

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

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

@@ -1,75 +1,93 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryParser = void 0;
-const common_1 = require("@leyyo/common");
-const condition_1 = require("../condition");
+const operation_1 = require("../operation");
+const error_1 = require("../error");
+const type_1 = require("@leyyo/type");
 class QueryParser {
     // region private
-    _error(message, path) {
-        return new Error(message + ', ' + path);
+    _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 ((0, type_1.isEmpty)(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)) {
+        if ((0, type_1.isEmpty)(value)) {
             return true;
         }
-        if (common_1.$is.boolean(value)) {
+        if (typeof value === 'boolean') {
             return value;
         }
-        else if (common_1.$is.text(value)) {
+        else if ((0, type_1.isText)(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('asc:invalid-key', `It should be [asc, desc], but it's value: ${value}`, path);
         }
-        throw this._error('Order asc error: invalid string', path);
+        throw this._invalid(value, path, ['boolean', 'string'], 'asc:invalid-type');
     }
     _field(value, path) {
-        if (common_1.$is.text(value)) {
+        if ((0, type_1.isText)(value)) {
             return value;
         }
-        throw this._error('Order asc error: invalid string', path);
+        throw this._emptyOrInvalid(value, path, 'string', 'field:empty', 'field:invalid');
     }
     _raw(value, path) {
-        if (common_1.$is.text(value)) {
+        if ((0, type_1.isText)(value)) {
             return value;
         }
-        throw this._error('Order asc error: invalid string', path);
+        throw this._emptyOrInvalid(value, path, 'string', 'raw:empty', 'raw:invalid');
     }
     _as(value, path) {
-        if (common_1.$is.empty(value)) {
+        if ((0, type_1.isEmpty)(value)) {
             return undefined;
         }
-        else if (common_1.$is.text(value)) {
+        else if ((0, type_1.isText)(value)) {
             return value;
         }
-        throw this._error('Order asc error: invalid string', path);
+        throw this._invalid(value, path, 'string', 'as:invalid');
     }
-    _condition(value, path) {
-        if (common_1.$is.empty(value)) {
-            return '==';
+    _operation(value, path) {
+        if ((0, type_1.isEmpty)(value)) {
+            return 'eq';
         }
-        else if (common_1.$is.text(value)) {
+        else if ((0, type_1.isText)(value)) {
             const key = value;
-            if (common_1.$is.literal(key, condition_1.ConditionTypeItems)) {
+            if ((0, type_1.isLiteral)(key, operation_1.ConditionTypeItems)) {
                 return key;
             }
-            if (condition_1.ConditionTypeMap[key] !== undefined) {
-                return condition_1.ConditionTypeMap[key];
+            if (operation_1.OperationTypeMap[key] !== undefined) {
+                return operation_1.OperationTypeMap[key];
             }
-            throw this._error('Order asc error: invalid string', path);
+            throw this._error('op:invalid-key', `It should be [@see operations], but it's value: ${value}`, path);
         }
-        throw this._error('Order asc error: invalid string', path);
+        throw this._invalid(value, path, 'string', 'op:invalid-type');
     }
     _value(value, path) {
         if (value === undefined) {
-            return [undefined];
+            return [];
         }
         switch (typeof value) {
             case "string":
-                return [];
+                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];
@@ -77,193 +95,202 @@ class QueryParser {
                 if (value === null) {
                     return [null];
                 }
-                if (Array.isArray(value) && value.length > 0) {
+                if (Array.isArray(value)) {
+                    let index = 0;
+                    for (const item of value) {
+                        if (!(0, type_1.isText)(item) && !(0, type_1.isNumberValid)(item) && typeof value !== 'boolean') {
+                            throw this._invalid(item, `${path}[${index}]`, ['string', 'number', 'boolean', 'array', 'number'], 'value:invalid-item');
+                        }
+                        index++;
+                    }
                     return value;
                 }
                 break;
         }
-        throw this._error('Order asc error: invalid string', path);
+        throw this._invalid(value, path, ['string', 'number', 'boolean', 'array', 'number'], 'value:invalid-type');
     }
     _num(value, path, min) {
-        if (common_1.$is.empty(value)) {
+        if ((0, type_1.isEmpty)(value)) {
             return undefined;
         }
-        else if (common_1.$is.integer(value) && value >= min) {
-            return value;
+        else if ((0, type_1.isIntegerValid)(value)) {
+            if (value >= min) {
+                return value;
+            }
+            throw this._error('integer:min', `It should be gte ${min}`, path);
         }
-        throw this._error('Order asc error: invalid string', path);
+        throw this._invalid(value, path, ['integer'], 'integer:invalid');
     }
     _fieldXorRaw(field, raw, path) {
         if (!raw && !field) {
-            throw this._error('Order asc error: invalid string', 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('Order asc error: invalid string', 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
     // region parts
-    _select(given, _availableFields, name) {
-        if (common_1.$is.empty(given)) {
-            return true;
+    _select(given, _availableFields, _name) {
+        if ((0, type_1.isEmpty)(given)) {
+            return { all: true };
         }
         // Cases:
         // 1 - '*'
-        // 2 - Array<KeyOf<T> | [KeyOf<T>, string] | SelectGiven<T> | SelectGivenRaw>
-        // case 1: string as KeyOf<T>
+        // 2 - Array<K | [K, string] | SelectGiven<K> | SelectGivenRaw>
+        // case 1: string as K
         if (given === '*') {
-            return true;
+            return { all: true };
         }
-        const newSelect = [];
-        // case 2: Array<KeyOf<T> | [KeyOf<T>, string] | SelectGiven<T> | SelectGivenRaw>
+        const newSelect = { fields: [] };
+        // case 2: Array<K | [K, string] | SelectGiven<K> | SelectGivenRaw>
         if (Array.isArray(given)) {
             if (given.length < 1) {
-                return true;
+                return { all: true };
             }
             const arr = given;
             arr.forEach((item, index) => {
-                // Case 2A: KeyOf<T>
-                if (common_1.$is.text(item)) {
-                    newSelect.push({
+                // Case 2A: K
+                if ((0, type_1.isText)(item)) {
+                    newSelect.fields.push({
                         field: item,
                     });
                 }
-                // Case 2B: [KeyOf<T>, string]
+                // 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, });
+                    newSelect.fields.push({ field, as, });
                 }
-                // Case 2C: SelectGiven<T> | SelectGivenRaw
-                else if (common_1.$is.object(item)) {
+                // Case 2C: SelectGiven<K> | SelectGivenRaw
+                else if ((0, type_1.isObjectBare)(item)) {
                     let as;
                     let field;
                     let raw;
                     const obj = item;
-                    if (!common_1.$is.empty(obj.raw)) {
+                    if (!(0, type_1.isEmpty)(obj.raw)) {
                         raw = this._raw(obj.raw, `select[${index}].raw`);
                     }
-                    if (!common_1.$is.empty(obj.field)) {
+                    if (!(0, type_1.isEmpty)(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 });
+                        newSelect.fields.push({ field, as });
                     }
                     else {
-                        newSelect.push({ raw, as });
+                        newSelect.fields.push({ raw, as });
                     }
                 }
                 // other
                 else {
-                    throw this._error('Invalid select item', name);
+                    throw this._invalid(item, `select[${index}]`, ['string', 'array', 'object'], 'select:item');
                 }
             });
         }
         // case: other
         else {
-            throw this._error('Invalid select item', name);
+            throw this._invalid(given, `select`, ['*', 'array'], 'select:body');
         }
         return newSelect;
     }
-    _where(scope, given, _availableFields, name) {
-        if (common_1.$is.empty(given)) {
+    _where(scope, given, _availableFields, _name) {
+        if ((0, type_1.isEmpty)(given)) {
             return [];
         }
         // Cases:
-        // 1 - WhereValue<T>
-        // 2 - Array<WhereGiven<T>|WhereGivenRaw|[KeyOf<T>, unknown]>
+        // 1 - WhereValue<K>
+        // 2 - Array<WhereGiven<K>|WhereGivenRaw|[K, unknown]>
         const newWhere = [];
-        // case 1: WhereValue<T>
-        if (common_1.$is.object(given)) {
+        // case 1: WhereValue<K>
+        if ((0, type_1.isObjectBare)(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: '==' });
+                const field = this._field(k, `${scope}(key=${index})`);
+                const value = this._value(v, `${scope}.${field}`);
+                newWhere.push({ field, value, op: 'eq' });
                 index++;
             }
         }
-        // case 2: array as Array<WhereGiven<T>|WhereGivenRaw|[KeyOf<T>, unknown]>
+        // 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) => {
-                var _a, _b;
-                // Case 2A: WhereGiven<T>|WhereGivenRaw
-                if (common_1.$is.object(item)) {
+                // Case 2A: WhereGiven<K>|WhereGivenRaw
+                if ((0, type_1.isObjectBare)(item)) {
                     let field;
                     let raw;
-                    let condition;
+                    let op;
                     let value;
                     let fullRaw;
                     const obj = item;
-                    if (!common_1.$is.empty(obj.raw)) {
-                        raw = this._raw(obj.raw, `select[${index}].raw`);
+                    if (!(0, type_1.isEmpty)(obj.raw)) {
+                        raw = this._raw(obj.raw, `${scope}[${index}].raw`);
                     }
-                    if (!common_1.$is.empty(obj.field)) {
-                        field = this._field(obj.field, `select[${index}].field`);
+                    if (!(0, type_1.isEmpty)(obj.field)) {
+                        field = this._field(obj.field, `${scope}[${index}].field`);
                     }
-                    this._fieldXorRaw(field, raw, `where[${index}].field`);
+                    this._fieldXorRaw(field, raw, `${scope}[${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)) {
+                    if (raw && (0, type_1.isEmpty)(whereItem.op) && (0, type_1.isEmpty)(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`);
+                    op = this._operation(whereItem.op, `${scope}[${index}].op`);
+                    value = this._value(whereItem.value, `${scope}[${index}].value`);
                     if (field) {
-                        newWhere.push({ field, condition, value });
+                        newWhere.push({ field, op, value });
                     }
                     else {
-                        newWhere.push({ raw, condition, value, fullRaw });
+                        newWhere.push({ raw, op, value, fullRaw });
                     }
                 }
-                // Case 2B: |[KeyOf<T>, unknown]
+                // Case 2B: |[K, 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: '==' });
+                    field = this._field(item[0], `${scope}[${index}][0]`);
+                    value = this._value(item[1], `${scope}[${index}][1]`);
+                    newWhere.push({ field, value, op: 'eq' });
                 }
                 else {
-                    throw this._error('Invalid select item', name);
+                    throw this._invalid(item, `${scope}[${index}]`, ['object', 'array'], (scope === 'where') ? 'where:item' : 'having:item');
                 }
             });
         }
         // case: other
         else {
-            throw this._error('Invalid select item', name);
+            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)) {
+    _groupBy(given, _availableFields, _name) {
+        if ((0, type_1.isEmpty)(given)) {
             return [];
         }
         // Cases:
-        // 1 - Array<KeyOf<T> | GroupByGivenRegular<T> | GroupByGivenRaw>
+        // 1 - Array<K | GroupByGivenRegular<K> | GroupByGivenRaw>
         const newGroup = [];
-        // case 1: Array<KeyOf<T> | GroupByGivenRegular<T> | GroupByGivenRaw>
+        // 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<T> | GroupByGivenRaw
-                if (common_1.$is.object(item)) {
+                // Case 2A: GroupByGivenRegular<K> | GroupByGivenRaw
+                if ((0, type_1.isObjectBare)(item)) {
                     let field;
                     let raw;
                     const obj = item;
-                    if (!common_1.$is.empty(obj.raw)) {
+                    if (!(0, type_1.isEmpty)(obj.raw)) {
                         raw = this._raw(obj.raw, `groupBy[${index}].raw`);
                     }
-                    if (!common_1.$is.empty(obj.field)) {
+                    if (!(0, type_1.isEmpty)(obj.field)) {
                         field = this._field(obj.field, `groupBy[${index}].field`);
                     }
                     this._fieldXorRaw(field, raw, `groupBy[${index}].field`);
@@ -274,51 +301,51 @@ class QueryParser {
                         newGroup.push({ raw });
                     }
                 }
-                // Case 2B: KeyOf<T>
-                else if (common_1.$is.text(item)) {
+                // Case 2B: K
+                else if ((0, type_1.isText)(item)) {
                     newGroup.push({ field: item });
                 }
                 else {
-                    throw this._error('Invalid select item', name);
+                    throw this._invalid(item, `groupBy[${index}]`, ['string', 'object'], 'groupBy:item');
                 }
             });
         }
         // case: other
         else {
-            throw this._error('Invalid select item', name);
+            throw this._invalid(given, `groupBy`, ['array'], 'groupBy:body');
         }
         return newGroup;
     }
-    _orderBy(given, _availableFields, name) {
-        if (common_1.$is.empty(given)) {
+    _orderBy(given, _availableFields, _name) {
+        if ((0, type_1.isEmpty)(given)) {
             return [];
         }
         // Cases:
-        // 1 - KeyOf<T>
-        // 2 - Array<OrderByGiven<T>|KeyOf<T>|OrderByGivenRaw>
-        // 3 - OrderByValue<T>
+        // 1 - K
+        // 2 - Array<OrderByGiven<K>|K|OrderByGivenRaw>
+        // 3 - OrderByValue<K>
         const newOrder = [];
-        // case 1: string as KeyOf<T>
-        if (common_1.$is.text(given)) {
+        // case 1: string as K
+        if ((0, type_1.isText)(given)) {
             newOrder.push({ field: given, asc: true });
         }
-        // case 2: array as Array<OrderByGiven<T>|KeyOf<T>|OrderByGivenRaw>
+        // 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<T>|OrderByGivenRaw
-                if (common_1.$is.object(item)) {
+                // Case 2A: OrderByGiven<K>|OrderByGivenRaw
+                if ((0, type_1.isObjectBare)(item)) {
                     let asc;
                     let field;
                     let raw;
                     const obj = item;
-                    if (!common_1.$is.empty(obj.raw)) {
+                    if (!(0, type_1.isEmpty)(obj.raw)) {
                         raw = this._raw(obj.raw, `orderBy[${index}].raw`);
                     }
-                    if (!common_1.$is.empty(obj.field)) {
+                    if (!(0, type_1.isEmpty)(obj.field)) {
                         field = this._field(obj.field, `orderBy[${index}].field`);
                     }
                     this._fieldXorRaw(field, raw, `orderBy[${index}].field`);
@@ -330,18 +357,18 @@ class QueryParser {
                         newOrder.push({ raw, asc });
                     }
                 }
-                // Case 2B: KeyOf<T>
-                else if (common_1.$is.text(item)) {
+                // Case 2B: K
+                else if ((0, type_1.isText)(item)) {
                     newOrder.push({ field: this._field(item, ''), asc: true });
                 }
                 // other
                 else {
-                    throw this._error('Invalid select item', name);
+                    throw this._invalid(item, `orderBy[${index}]`, ['string', 'object'], 'orderBy:item');
                 }
             });
         }
-        // case 3: {'id': true, name: true, ...} as OrderByValue<T>
-        else if (common_1.$is.object(given)) {
+        // case 3: {'id': true, name: true, ...} as OrderByValue<K>
+        else if ((0, type_1.isObjectBare)(given)) {
             let index = 0;
             for (let [k, v] of Object.entries(given)) {
                 const field = this._field(k, `orderBy(key=${index})`);
@@ -352,13 +379,13 @@ class QueryParser {
         }
         // case: other
         else {
-            throw this._error('Invalid select item', name);
+            throw this._invalid(given, `orderBy`, ['string', 'array', 'object'], 'orderBy:body');
         }
         return newOrder;
     }
-    _pagination(given, name) {
+    _pagination(given, _name) {
         var _a;
-        if (common_1.$is.empty(given)) {
+        if ((0, type_1.isEmpty)(given)) {
             return {};
         }
         // Case 1: PaginationLiteral
@@ -372,28 +399,28 @@ class QueryParser {
             };
         }
         // Case 2: PaginationPage | PaginationLimit
-        else if (common_1.$is.object(given)) {
+        else if ((0, type_1.isObjectBare)(given)) {
             if (Object.keys(given).length < 1) {
                 return {};
             }
             const obj = given;
-            if (!common_1.$is.empty(obj.page)) {
+            if (!(0, type_1.isEmpty)(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('Invalid select item', name);
+                    if (!(0, type_1.isEmpty)(given[f])) {
+                        throw this._error('page:conflict', 'If you give page; limit and offset can not be used anymore', `pagination.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;
                 return {
                     limit: size,
                     offset: (page - 1) * size
                 };
             }
-            if (!common_1.$is.empty(obj.limit)) {
+            if (!(0, type_1.isEmpty)(obj.limit)) {
                 ['page', 'size'].forEach(f => {
-                    if (!common_1.$is.empty(obj[f])) {
-                        throw this._error('Invalid select item', name);
+                    if (!(0, type_1.isEmpty)(obj[f])) {
+                        throw this._error('limit:conflict', 'If you give limit; page and size can not be used anymore', `pagination.limit`);
                     }
                 });
                 return {
@@ -401,9 +428,9 @@ class QueryParser {
                     offset: this._num(obj.offset, `pagination.offset`, 0)
                 };
             }
-            throw this._error('Invalid select item', name);
+            throw this._error('pagination:invalid-key', 'Pagination should have limit/offset or page/size keys', 'pagination');
         }
-        throw this._error('Invalid select item', name);
+        throw this._invalid(given, 'pagination', ['array', 'object'], 'pagination:invalid-type');
     }
     // endregion parts
     exec(query, availableFields, name) {

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

@@ -3,19 +3,19 @@ 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>;
+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<T = Record<string, unknown>> {
-    select: Select<T>;
-    where: Where<T>;
-    having: Where<T>;
-    groupBy: GroupBy<T>;
-    orderBy: OrderBy<T>;
+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/select/index.types.d.ts

@@ -1,8 +1,10 @@
-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 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<T> = true | Array<SelectItemRegular<T> | SelectItemRaw>;
-export type SelectItemRegular<T> = FieldRegular<T> & FieldAs;
+export interface Select<K extends string> {
+    all?: true;
+    fields?: Array<SelectItemRegular<K> | SelectItemRaw>;
+}
+export type SelectItemRegular<K extends string> = FieldRegular<K> & FieldAs;
 export type SelectItemRaw = FieldRaw & FieldAs;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leyyo/query",
-  "version": "1.0.2",
+  "version": "1.2.1",
   "description": "Query common component",
   "keywords": [
     "Query"
@@ -66,6 +66,7 @@
     }
   },
   "dependencies": {
-    "@leyyo/common": "^1.0.13"
+    "@leyyo/common": "^1.2.1",
+    "@leyyo/type": "^1.1.1"
   }
 }

package/dist/assets/icon.svg

@@ -1,8 +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="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/condition/condition-type.d.ts

@@ -1,3 +0,0 @@
-export declare const ConditionTypeItems: readonly ["==", "!=", "null", "!null", ">", ">=", "<", "<=", "between", "!between", "in", "!in", "^", "!^", "$", "!$", "matches", "!matches", "contains", "!contains", "contained", "!contained", "true", "false", "includes", "!includes", "intersects", "!intersects", "exists", "!exists"];
-export type ConditionType = typeof ConditionTypeItems[number];
-export declare const ConditionTypeMap: Record<string, ConditionType>;

package/dist/condition/index.d.ts

@@ -1 +0,0 @@
-export * from './condition-type';