@pc-nexus/storage 0.5.0-next.24 → 0.5.0-next.25

package/lib/ces/condition-builder/condition.builder.d.ts

@@ -12,7 +12,7 @@ export interface LogicalConditionBuilder<Schema = Document, FieldChains extends
 type LimitComparisonConditionBuilder<Schema = Document, FieldChains extends KeyChains<Schema> = KeyChains<Schema>, CurrentLevel extends CurrentLevelType<Schema> = RootLevelType<Schema>, V = TypeAtKeyChain<Schema, FieldChains>, FieldType = TypeAtKeyChain<Schema, FieldChains>> = FieldType extends number ? Pick<ComparisonConditionBuilder<Schema, FieldChains, CurrentLevel, V>, "eq" | "ne" | "exists" | "gt" | "gte" | "lt" | "lte"> : FieldType extends string ? Pick<ComparisonConditionBuilder<Schema, FieldChains, CurrentLevel, V>, "eq" | "ne" | "exists" | "contains" | "notContains"> : FieldType extends boolean ? Pick<ComparisonConditionBuilder<Schema, FieldChains, CurrentLevel, V>, "eq" | "ne" | "exists"> : FieldType extends any[] ? Pick<ComparisonConditionBuilder<Schema, FieldChains, CurrentLevel, V>, "contains" | "notContains" | "eq" | "ne" | "exists"> : FieldType extends Document ? Pick<ComparisonConditionBuilder<Schema, FieldChains, CurrentLevel, V>, "eq" | "ne" | "exists"> : never;
 export type ComparisonConditionBuilderReturnType<Schema = Document, FieldChains extends KeyChains<Schema> = KeyChains<Schema>, CurrentLevel extends CurrentLevelType<Schema> = RootLevelType<Schema>, V = TypeAtKeyChain<Schema, FieldChains>> = LogicalConditionBuilder<Schema, never, CurrentLevel, V> & LimitComparisonConditionBuilder<Schema, FieldChains, CurrentLevel, V>;
 export interface ComparisonConditionBuilder<Schema = Document, FieldChains extends KeyChains<Schema> = KeyChains<Schema>, CurrentLevel extends CurrentLevelType<Schema> = RootLevelType<Schema>, V = TypeAtKeyChain<Schema, FieldChains>> {
-    eq(value: ValueAlternativeType<V>, options?: EqOptions<QueryOperator.eq>): ComparisonConditionBuilderReturnType<Schema, FieldChains, CurrentLevel, V>;
+    eq(value: ValueAlternativeType<V>, options?: EqOptions<QueryOperator.EQ>): ComparisonConditionBuilderReturnType<Schema, FieldChains, CurrentLevel, V>;
     ne(value: ValueAlternativeType<V>, options?: Omit<EqOptions, "queryOperator">): ComparisonConditionBuilderReturnType<Schema, FieldChains, CurrentLevel, V>;
     gt(value: ValueAlternativeType<V>, options?: RangeOptions): ComparisonConditionBuilderReturnType<Schema, FieldChains, CurrentLevel, V>;
     gte(value: ValueAlternativeType<V>, options?: RangeOptions): ComparisonConditionBuilderReturnType<Schema, FieldChains, CurrentLevel, V>;

package/lib/ces/condition-builder/inner-condition.builder.d.ts

@@ -26,7 +26,7 @@ export declare class InnerConditionBuilder<Schema = Record<string, any>, FieldCh
     private updateQuery;
     field<TFieldChains extends FieldChains>(field: TFieldChains): InnerConditionBuilder<Schema, TFieldChains, CurrentLevel>;
     resetFieldConditions(): this;
-    eq<OP extends QueryOperator.eq | QueryOperator.ne | QueryOperator.gt | QueryOperator.gte | QueryOperator.lte | QueryOperator.lt | QueryOperator.contains | QueryOperator.notContains = QueryOperator.eq>(value: ValueAlternativeType<V>, { queryOperator, ...options }?: EqOptions<OP>): this;
+    eq<OP extends QueryOperator.EQ | QueryOperator.NE | QueryOperator.GT | QueryOperator.GTE | QueryOperator.LTE | QueryOperator.LT | QueryOperator.Contains | QueryOperator.NotContains = QueryOperator.EQ>(value: ValueAlternativeType<V>, { queryOperator, ...options }?: EqOptions<OP>): this;
     ne(value: ValueAlternativeType<V>, options?: Omit<EqOptions, "queryOperator">): this;
     gte(value: ValueAlternativeType<V>, { ...options }?: RangeOptions): this;
     gt(value: ValueAlternativeType<V>, { ...options }?: RangeOptions): this;

package/lib/ces/condition-builder/inner-condition.builder.js

@@ -6,7 +6,7 @@ export class InnerConditionBuilder {
     baseOptions = { ignoreUndefined: false, keepNaN: false };
     get currentField() {
         if (!this._field) {
-            throw new NexusInnerError(NexusCode.invalidInput, NexusInnerErrorType.storageConditionBuilder, `No field specified for condition`);
+            throw new NexusInnerError(NexusCode.InvalidInput, NexusInnerErrorType.StorageConditionBuilder, `No field specified for condition`);
         }
         return this._field;
     }
@@ -76,7 +76,7 @@ export class InnerConditionBuilder {
     assertAtRootLevel() {
         if (!this.isAtRootLevel()) {
             const logicalOp = this.currentLevel[logicalOpSymbol];
-            throw new NexusInnerError(NexusCode.invalidInput, NexusInnerErrorType.storageConditionBuilder, `there is still remaining "${logicalOp}" logical operator opened`);
+            throw new NexusInnerError(NexusCode.InvalidInput, NexusInnerErrorType.StorageConditionBuilder, `there is still remaining "${logicalOp}" logical operator opened`);
         }
     }
     assertAtLogicalLevel(expect) {
@@ -84,11 +84,11 @@ export class InnerConditionBuilder {
         const isRootLevel = _.isNil(logicalOp);
         if (expect) {
             if (logicalOp !== expect) {
-                throw new NexusInnerError(NexusCode.invalidInput, NexusInnerErrorType.storageConditionBuilder, `there is no "${expect}" logical operator opened`);
+                throw new NexusInnerError(NexusCode.InvalidInput, NexusInnerErrorType.StorageConditionBuilder, `there is no "${expect}" logical operator opened`);
             }
         }
         else if (isRootLevel) {
-            throw new NexusInnerError(NexusCode.invalidInput, NexusInnerErrorType.storageConditionBuilder, `there is no any logical operator opened`);
+            throw new NexusInnerError(NexusCode.InvalidInput, NexusInnerErrorType.StorageConditionBuilder, `there is no any logical operator opened`);
         }
     }
     logicalClosure(logicalOp, closure) {
@@ -125,10 +125,10 @@ export class InnerConditionBuilder {
         return that;
     }
     and(closure) {
-        return this.logicalClosure(LogicalOperator.and, closure);
+        return this.logicalClosure(LogicalOperator.And, closure);
     }
     or(closure) {
-        return this.logicalClosure(LogicalOperator.or, closure);
+        return this.logicalClosure(LogicalOperator.Or, closure);
     }
     shouldReserveValue(value, options) {
         options = { ...this.baseOptions, ...options };
@@ -186,7 +186,7 @@ export class InnerConditionBuilder {
         }
         return this;
     }
-    eq(value, { queryOperator = QueryOperator.eq, ...options } = {}) {
+    eq(value, { queryOperator = QueryOperator.EQ, ...options } = {}) {
         const field = this.currentField;
         if (!this.shouldReserveValue(value, options)) {
             return this;
@@ -195,35 +195,35 @@ export class InnerConditionBuilder {
         return this;
     }
     ne(value, options = {}) {
-        return this.eq(value, { ...options, queryOperator: QueryOperator.ne });
+        return this.eq(value, { ...options, queryOperator: QueryOperator.NE });
     }
     gte(value, { ...options } = {}) {
-        this.eq(value, { queryOperator: QueryOperator.gte, ...options });
+        this.eq(value, { queryOperator: QueryOperator.GTE, ...options });
         return this;
     }
     gt(value, { ...options } = {}) {
-        this.eq(value, { queryOperator: QueryOperator.gt, ...options });
+        this.eq(value, { queryOperator: QueryOperator.GT, ...options });
         return this;
     }
     lte(value, { ...options } = {}) {
-        this.eq(value, { queryOperator: QueryOperator.lte, ...options });
+        this.eq(value, { queryOperator: QueryOperator.LTE, ...options });
         return this;
     }
     lt(value, { ...options } = {}) {
-        this.eq(value, { queryOperator: QueryOperator.lt, ...options });
+        this.eq(value, { queryOperator: QueryOperator.LT, ...options });
         return this;
     }
     contains(value, { ...options } = {}) {
-        this.eq(value, { queryOperator: QueryOperator.contains, ...options });
+        this.eq(value, { queryOperator: QueryOperator.Contains, ...options });
         return this;
     }
     notContains(value, { ...options } = {}) {
-        this.eq(value, { queryOperator: QueryOperator.notContains, ...options });
+        this.eq(value, { queryOperator: QueryOperator.NotContains, ...options });
         return this;
     }
     exists(exists = true) {
         const field = this.currentField;
-        this.updateQuery(field, { [QueryOperator.exists]: !!exists });
+        this.updateQuery(field, { [QueryOperator.Exists]: !!exists });
         return this;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pc-nexus/storage",
-  "version": "0.5.0-next.24",
+  "version": "0.5.0-next.25",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -30,7 +30,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@pc-nexus/internal": "0.5.0-next.24",
+    "@pc-nexus/internal": "0.5.0-next.25",
     "lodash": "^4.17.21"
   },
   "devDependencies": {},