@leyyo/query 1.0.3 → 1.2.1

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

@@ -1 +1 @@
-export type QueryErrorCode = 'xxx' | 'field:invalid' | 'field:empty' | 'field:raw-both' | 'field:raw-none' | 'as:invalid' | 'raw:invalid' | 'raw:empty' | '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';
+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/index.d.ts

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

package/dist/index.js

@@ -14,7 +14,7 @@ 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);

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/parser/query.parser.js

@@ -1,9 +1,9 @@
 "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(code, message, path) {
@@ -14,7 +14,7 @@ class QueryParser {
         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)) {
+        if ((0, type_1.isEmpty)(value)) {
             return this._error(empty, `It's empty`, path);
         }
         if (typeof value === 'string' && value.trim() === '') {
@@ -23,13 +23,13 @@ class QueryParser {
         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;
             }
@@ -41,41 +41,41 @@ class QueryParser {
         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._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._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._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('eq:invalid-key', `It should be [@see equalities], but it's value: ${value}`, path);
+            throw this._error('op:invalid-key', `It should be [@see operations], but it's value: ${value}`, path);
         }
-        throw this._invalid(value, path, 'string', 'eq:invalid-type');
+        throw this._invalid(value, path, 'string', 'op:invalid-type');
     }
     _value(value, path) {
         if (value === undefined) {
@@ -98,7 +98,7 @@ class QueryParser {
                 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)) {
+                        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++;
@@ -110,10 +110,10 @@ class QueryParser {
         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)) {
+        else if ((0, type_1.isIntegerValid)(value)) {
             if (value >= min) {
                 return value;
             }
@@ -132,27 +132,27 @@ class QueryParser {
     // endregion private
     // region parts
     _select(given, _availableFields, _name) {
-        if (common_1.$is.empty(given)) {
-            return true;
+        if ((0, type_1.isEmpty)(given)) {
+            return { all: true };
         }
         // Cases:
         // 1 - '*'
         // 2 - Array<K | [K, string] | SelectGiven<K> | SelectGivenRaw>
         // case 1: string as K
         if (given === '*') {
-            return true;
+            return { all: true };
         }
-        const newSelect = [];
+        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: K
-                if (common_1.$is.text(item)) {
-                    newSelect.push({
+                if ((0, type_1.isText)(item)) {
+                    newSelect.fields.push({
                         field: item,
                     });
                 }
@@ -161,27 +161,27 @@ class QueryParser {
                     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<K> | SelectGivenRaw
-                else if (common_1.$is.object(item)) {
+                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
@@ -197,7 +197,7 @@ class QueryParser {
         return newSelect;
     }
     _where(scope, given, _availableFields, _name) {
-        if (common_1.$is.empty(given)) {
+        if ((0, type_1.isEmpty)(given)) {
             return [];
         }
         // Cases:
@@ -205,12 +205,12 @@ class QueryParser {
         // 2 - Array<WhereGiven<K>|WhereGivenRaw|[K, unknown]>
         const newWhere = [];
         // case 1: WhereValue<K>
-        if (common_1.$is.object(given)) {
+        if ((0, type_1.isObjectBare)(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: '==' });
+                newWhere.push({ field, value, op: 'eq' });
                 index++;
             }
         }
@@ -222,31 +222,31 @@ class QueryParser {
             const arr = given;
             arr.forEach((item, index) => {
                 // Case 2A: WhereGiven<K>|WhereGivenRaw
-                if (common_1.$is.object(item)) {
+                if ((0, type_1.isObjectBare)(item)) {
                     let field;
                     let raw;
-                    let eq;
+                    let op;
                     let value;
                     let fullRaw;
                     const obj = item;
-                    if (!common_1.$is.empty(obj.raw)) {
+                    if (!(0, type_1.isEmpty)(obj.raw)) {
                         raw = this._raw(obj.raw, `${scope}[${index}].raw`);
                     }
-                    if (!common_1.$is.empty(obj.field)) {
+                    if (!(0, type_1.isEmpty)(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)) {
+                    if (raw && (0, type_1.isEmpty)(whereItem.op) && (0, type_1.isEmpty)(whereItem.value)) {
                         fullRaw = true;
                     }
-                    eq = this._condition(whereItem.eq, `${scope}[${index}].eq`);
+                    op = this._operation(whereItem.op, `${scope}[${index}].op`);
                     value = this._value(whereItem.value, `${scope}[${index}].value`);
                     if (field) {
-                        newWhere.push({ field, eq, value });
+                        newWhere.push({ field, op, value });
                     }
                     else {
-                        newWhere.push({ raw, eq, value, fullRaw });
+                        newWhere.push({ raw, op, value, fullRaw });
                     }
                 }
                 // Case 2B: |[K, unknown]
@@ -255,7 +255,7 @@ class QueryParser {
                     let value;
                     field = this._field(item[0], `${scope}[${index}][0]`);
                     value = this._value(item[1], `${scope}[${index}][1]`);
-                    newWhere.push({ field, value, eq: '==' });
+                    newWhere.push({ field, value, op: 'eq' });
                 }
                 else {
                     throw this._invalid(item, `${scope}[${index}]`, ['object', 'array'], (scope === 'where') ? 'where:item' : 'having:item');
@@ -269,7 +269,7 @@ class QueryParser {
         return newWhere;
     }
     _groupBy(given, _availableFields, _name) {
-        if (common_1.$is.empty(given)) {
+        if ((0, type_1.isEmpty)(given)) {
             return [];
         }
         // Cases:
@@ -283,14 +283,14 @@ class QueryParser {
             const arr = given;
             arr.forEach((item, index) => {
                 // Case 2A: GroupByGivenRegular<K> | GroupByGivenRaw
-                if (common_1.$is.object(item)) {
+                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`);
@@ -302,7 +302,7 @@ class QueryParser {
                     }
                 }
                 // Case 2B: K
-                else if (common_1.$is.text(item)) {
+                else if ((0, type_1.isText)(item)) {
                     newGroup.push({ field: item });
                 }
                 else {
@@ -317,7 +317,7 @@ class QueryParser {
         return newGroup;
     }
     _orderBy(given, _availableFields, _name) {
-        if (common_1.$is.empty(given)) {
+        if ((0, type_1.isEmpty)(given)) {
             return [];
         }
         // Cases:
@@ -326,7 +326,7 @@ class QueryParser {
         // 3 - OrderByValue<K>
         const newOrder = [];
         // case 1: string as K
-        if (common_1.$is.text(given)) {
+        if ((0, type_1.isText)(given)) {
             newOrder.push({ field: given, asc: true });
         }
         // case 2: array as Array<OrderByGiven<K>|K|OrderByGivenRaw>
@@ -337,15 +337,15 @@ class QueryParser {
             const arr = given;
             arr.forEach((item, index) => {
                 // Case 2A: OrderByGiven<K>|OrderByGivenRaw
-                if (common_1.$is.object(item)) {
+                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`);
@@ -358,7 +358,7 @@ class QueryParser {
                     }
                 }
                 // Case 2B: K
-                else if (common_1.$is.text(item)) {
+                else if ((0, type_1.isText)(item)) {
                     newOrder.push({ field: this._field(item, ''), asc: true });
                 }
                 // other
@@ -368,7 +368,7 @@ class QueryParser {
             });
         }
         // case 3: {'id': true, name: true, ...} as OrderByValue<K>
-        else if (common_1.$is.object(given)) {
+        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})`);
@@ -385,7 +385,7 @@ class QueryParser {
     }
     _pagination(given, _name) {
         var _a;
-        if (common_1.$is.empty(given)) {
+        if ((0, type_1.isEmpty)(given)) {
             return {};
         }
         // Case 1: PaginationLiteral
@@ -399,16 +399,16 @@ 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])) {
+                    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`);
                     }
                 });
@@ -417,9 +417,9 @@ class QueryParser {
                     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])) {
+                    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`);
                     }
                 });

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

@@ -2,6 +2,9 @@ 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 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,11 +1,11 @@
-import type { ConditionType } from "../condition";
+import type { OperationType } from "../operation";
 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;
+    op: string | OperationType;
     value?: unknown;
 }
 export type WhereGiven<K extends string> = FieldRegular<K> & WhereGivenCondition;
@@ -15,6 +15,6 @@ export type WhereItemRegular<K extends string> = FieldRegular<K> & WhereConditio
 export type WhereItemRaw = FieldRaw & WhereCondition;
 export interface WhereCondition {
     fullRaw?: true;
-    eq?: ConditionType;
+    op?: OperationType;
     value?: unknown;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leyyo/query",
-  "version": "1.0.3",
+  "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/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';