feat(parser): adds possibility to pass additional field and document level context

Author: stalniy

packages/core/spec/ObjectQueryParser.spec.ts

@@ -43,6 +43,31 @@ describe('ObjectQueryParser', () => {
     expect(conditions.every(c => c instanceof FieldCondition && c.operator === 'eq')).to.be.true
   })
 
+  it('passes additional field context details during processing field level operators', () => {
+    const my = { type: 'field', parse: spy(defaultInstructionParsers.field) }
+    const parser = new ObjectQueryParser({ my }, {
+      fieldContext: { check: true }
+    })
+    parser.parse({ field: { my: 1 } })
+    const context = spy.calls(my.parse)[0][2] as { check: boolean }
+
+    expect(context.check).to.be.true
+  })
+
+  it('passes additional document context details during processing document level and compound operators', () => {
+    const document = { type: 'document', parse: spy(defaultInstructionParsers.document) }
+    const compound = { type: 'compound', parse: spy(defaultInstructionParsers.compound) }
+    const parser = new ObjectQueryParser({ document, compound }, {
+      documentContext: { check: true }
+    })
+    parser.parse({ document: true, compound: [] })
+    const documentContext = spy.calls(document.parse)[0][2] as { check: boolean }
+    const compoundContext = spy.calls(compound.parse)[0][2] as { check: boolean }
+
+    expect(documentContext.check).to.be.true
+    expect(compoundContext.check).to.be.true
+  })
+
   describe('when "field" level parsing instruction is specified', () => {
     it('parses it to `FieldCondition`', () => {
       const my = { type: 'field' }

packages/core/src/parsers/ObjectQueryParser.ts

@@ -7,7 +7,7 @@ import {
 } from '../types';
 import { buildAnd as and } from '../builder';
 import { parseInstruction } from './defaultInstructionParsers';
-import { identity, hasOperators } from '../utils';
+import { identity, hasOperators, object } from '../utils';
 
 export type FieldQueryOperators<T extends {}> = {
   [K in keyof T]: T[K] extends {} ? T[K] : never
@@ -18,46 +18,57 @@ type ParsingInstructions = Record<string, NamedInstruction>;
 export interface QueryOptions {
   operatorToConditionName?(name: string): string
   defaultOperatorName?: string
+  fieldContext?: Record<string, unknown>
+  documentContext?: Record<string, unknown>
 }
 
 export type ObjectQueryFieldParsingContext = ParsingContext<FieldParsingContext & {
-  query: unknown,
+  query: {},
   hasOperators<T>(value: unknown): value is T
 }>;
 
 export class ObjectQueryParser<
   T extends Record<any, any>,
   U extends FieldQueryOperators<T> = FieldQueryOperators<T>
 > {
-  protected readonly _instructions: ParsingInstructions;
-  protected _fieldInstructionContext: ObjectQueryFieldParsingContext;
-  protected readonly _options: Required<QueryOptions>;
-
-  constructor(instructions: Record<string, ParsingInstruction>, options?: QueryOptions) {
+  private readonly _instructions: ParsingInstructions;
+  private _fieldInstructionContext: ObjectQueryFieldParsingContext;
+  private _documentInstructionContext: ParsingContext<{ query: {} }>;
+  private readonly _options: Required<
+  Pick<QueryOptions, 'operatorToConditionName' | 'defaultOperatorName'>
+  >;
+
+  constructor(instructions: Record<string, ParsingInstruction>, options: QueryOptions = object()) {
     this.parse = this.parse.bind(this);
     this._options = {
-      operatorToConditionName: identity,
-      defaultOperatorName: 'eq',
-      ...options
+      operatorToConditionName: options.operatorToConditionName || identity,
+      defaultOperatorName: options.defaultOperatorName || 'eq',
     };
     this._instructions = Object.keys(instructions).reduce((all, name) => {
       all[name] = { name: this._options.operatorToConditionName(name), ...instructions[name] };
       return all;
     }, {} as ParsingInstructions);
     this._fieldInstructionContext = {
+      ...options.fieldContext,
       field: '',
       query: {},
       parse: this.parse,
       hasOperators: <T>(value: unknown): value is T => hasOperators(value, this._instructions),
     };
+    this._documentInstructionContext = {
+      ...options.documentContext,
+      parse: this.parse,
+      query: {}
+    };
   }
 
   setParse(parse: this['parse']) {
     this.parse = parse;
     this._fieldInstructionContext.parse = parse;
+    this._documentInstructionContext.parse = parse;
   }
 
-  protected parseField(field: string, operator: string, value: unknown, parentQuery: unknown) {
+  protected parseField(field: string, operator: string, value: unknown, parentQuery: {}) {
     const instruction = this._instructions[operator];
 
     if (!instruction) {
@@ -96,11 +107,12 @@ export class ObjectQueryParser<
     return conditions;
   }
 
-  parse<Q extends T, FQ extends U = U>(query: Q): Condition {
-    const defaultContext = { query, parse: this.parse };
+  parse<Q extends T>(query: Q): Condition {
     const conditions = [];
     const keys = Object.keys(query);
 
+    this._documentInstructionContext.query = query;
+
     for (let i = 0, length = keys.length; i < length; i++) {
       const key = keys[i];
       const value = query[key];
@@ -111,8 +123,8 @@ export class ObjectQueryParser<
           throw new Error(`Cannot use parsing instruction for operator "${key}" in "document" context as it is supposed to be used in  "${instruction.type}" context`);
         }
 
-        conditions.push(parseInstruction(instruction, value, defaultContext));
-      } else if (hasOperators<FQ>(value, this._instructions)) {
+        conditions.push(parseInstruction(instruction, value, this._documentInstructionContext));
+      } else if (hasOperators<U>(value, this._instructions)) {
         conditions.push(...this.parseFieldOperators(key, value));
       } else {
         conditions.push(this.parseField(key, this._options.defaultOperatorName, value, query));

packages/core/src/utils.ts

@@ -47,3 +47,5 @@ export function hasOperators<T>(value: any, instructions: Record<string, unknown
 
   return false;
 }
+
+export const object = () => Object.create(null);