@travetto/model-query-language 7.0.0-rc.1 → 7.0.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query-language",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "Datastore query language.",
   "keywords": [
     "datastore",
@@ -26,12 +26,12 @@
     "directory": "module/model-query"
   },
   "dependencies": {
-    "@travetto/model": "^7.0.0-rc.1",
-    "@travetto/model-query": "^7.0.0-rc.1",
-    "@travetto/schema": "^7.0.0-rc.1"
+    "@travetto/model": "^7.0.0-rc.3",
+    "@travetto/model-query": "^7.0.0-rc.3",
+    "@travetto/schema": "^7.0.0-rc.3"
   },
   "peerDependencies": {
-    "@travetto/test": "^7.0.0-rc.1"
+    "@travetto/test": "^7.0.0-rc.3"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/model-query.ts

@@ -1,9 +1,10 @@
 import { Schema } from '@travetto/schema';
 import { PageableModelQuery } from '@travetto/model-query';
+import { JSONUtil } from '@travetto/runtime';
 
 import { QueryLanguageParser } from './parser.ts';
 
-const parse = <T>(k: string): T | undefined => !k || typeof k !== 'string' || !/^[\{\[]/.test(k) ? undefined : JSON.parse(k);
+const parse = <T>(key: string): T | undefined => !key || typeof key !== 'string' || !/^[\{\[]/.test(key) ? undefined : JSONUtil.parseSafe(key);
 
 @Schema()
 export class QueryLanguageModelQuery {

package/src/parser.ts

@@ -2,13 +2,13 @@ import { castTo } from '@travetto/runtime';
 import { WhereClauseRaw } from '@travetto/model-query';
 
 import { QueryLanguageTokenizer } from './tokenizer.ts';
-import { Token, Literal, GroupNode, OP_TRANSLATION, ArrayNode, AllNode } from './types.ts';
+import { Token, Literal, GroupNode, OPERATOR_TRANSLATION, ArrayNode, AllNode } from './types.ts';
 
 /**
  * Determine if a token is boolean
  */
-function isBoolean(o: unknown): o is Token & { type: 'boolean' } {
-  return !!o && typeof o === 'object' && 'type' in o && o.type === 'boolean';
+function isBoolean(value: unknown): value is Token & { type: 'boolean' } {
+  return !!value && typeof value === 'object' && 'type' in value && value.type === 'boolean';
 }
 
 /**
@@ -20,32 +20,32 @@ export class QueryLanguageParser {
    * Handle all clauses
    */
   static handleClause(nodes: (AllNode | Token)[]): void {
-    const val: Token | ArrayNode = castTo(nodes.pop());
-    const op: Token & { value: string } = castTo(nodes.pop());
-    const ident: Token & { value: string } = castTo(nodes.pop());
+    const value: Token | ArrayNode = castTo(nodes.pop());
+    const operator: Token & { value: string } = castTo(nodes.pop());
+    const identifier: Token & { value: string } = castTo(nodes.pop());
 
     // value isn't a literal or a list, bail
-    if (val.type !== 'literal' && val.type !== 'list') {
-      throw new Error(`Unexpected token: ${val.value}`);
+    if (value.type !== 'literal' && value.type !== 'list') {
+      throw new Error(`Unexpected token: ${value.value}`);
     }
 
     // If operator is not an operator, bail
-    if (op.type !== 'operator') {
-      throw new Error(`Unexpected token: ${op.value}`);
+    if (operator.type !== 'operator') {
+      throw new Error(`Unexpected token: ${operator.value}`);
     }
 
     // If operator is not known, bail
-    const finalOp = OP_TRANSLATION[op.value];
+    const finalOperation = OPERATOR_TRANSLATION[operator.value];
 
-    if (!finalOp) {
-      throw new Error(`Unexpected operator: ${op.value}`);
+    if (!finalOperation) {
+      throw new Error(`Unexpected operator: ${operator.value}`);
     }
 
     nodes.push({
       type: 'clause',
-      field: ident.value,
-      op: finalOp,
-      value: val.value
+      field: identifier.value,
+      operator: finalOperation,
+      value: value.value
     });
 
     // Handle unary support
@@ -58,21 +58,21 @@ export class QueryLanguageParser {
    * Condense nodes to remove unnecessary groupings
    * (a AND (b AND (c AND d))) => (a AND b AND c)
    */
-  static condense(nodes: (AllNode | Token)[], op: 'and' | 'or'): void {
+  static condense(nodes: (AllNode | Token)[], operator: 'and' | 'or'): void {
     let second = nodes[nodes.length - 2];
 
-    while (isBoolean(second) && second.value === op) {
+    while (isBoolean(second) && second.value === operator) {
       const right: AllNode = castTo(nodes.pop());
       nodes.pop()!;
       const left: AllNode = castTo(nodes.pop());
-      const rg: GroupNode = castTo(right);
-      if (rg.type === 'group' && rg.op === op) {
-        rg.value.unshift(left);
-        nodes.push(rg);
+      const rightGroup: GroupNode = castTo(right);
+      if (rightGroup.type === 'group' && rightGroup.operator === operator) {
+        rightGroup.value.unshift(left);
+        nodes.push(rightGroup);
       } else {
         nodes.push({
           type: 'group',
-          op,
+          operator,
           value: [left, right]
         });
       }
@@ -91,7 +91,7 @@ export class QueryLanguageParser {
       nodes.pop(); // This is second
       nodes.push({
         type: 'unary',
-        op: 'not',
+        operator: 'not',
         value: castTo<AllNode>(node)
       });
     }
@@ -100,13 +100,13 @@ export class QueryLanguageParser {
   /**
    * Parse all tokens
    */
-  static parse(tokens: Token[], pos: number = 0): AllNode {
+  static parse(tokens: Token[], position: number = 0): AllNode {
 
     let top: (AllNode | Token)[] = [];
     const stack: (typeof top)[] = [top];
-    let arr: Literal[] | undefined;
+    let list: Literal[] | undefined;
 
-    let token = tokens[pos];
+    let token = tokens[position];
     while (token) {
       switch (token.type) {
         case 'grouping':
@@ -123,31 +123,31 @@ export class QueryLanguageParser {
           break;
         case 'array':
           if (token.value === 'start') {
-            arr = [];
+            list = [];
           } else {
-            const arrNode: ArrayNode = { type: 'list', value: arr! };
+            const arrNode: ArrayNode = { type: 'list', value: list! };
             top.push(arrNode);
-            arr = undefined;
+            list = undefined;
             this.handleClause(top);
           }
           break;
         case 'literal':
-          if (arr !== undefined) {
-            arr.push(token.value);
+          if (list !== undefined) {
+            list.push(token.value);
           } else {
             top.push(token);
             this.handleClause(top);
           }
           break;
         case 'punctuation':
-          if (!arr) {
+          if (!list) {
             throw new Error(`Invalid token: ${token.value}`);
           }
           break;
         default:
           top.push(token);
       }
-      token = tokens[++pos];
+      token = tokens[++position];
     }
 
     this.condense(top, 'or');
@@ -161,26 +161,26 @@ export class QueryLanguageParser {
   static convert<T = unknown>(node: AllNode): WhereClauseRaw<T> {
     switch (node.type) {
       case 'unary': {
-        return castTo({ [`$${node.op!}`]: this.convert(node.value) });
+        return castTo({ [`$${node.operator!}`]: this.convert(node.value) });
       }
       case 'group': {
-        return castTo({ [`$${node.op!}`]: node.value.map(x => this.convert(x)) });
+        return castTo({ [`$${node.operator!}`]: node.value.map(value => this.convert(value)) });
       }
       case 'clause': {
         const parts = node.field!.split('.');
         const top: WhereClauseRaw<T> = {};
         let sub: Record<string, unknown> = top;
-        for (const p of parts) {
-          sub = sub[p] = {};
+        for (const part of parts) {
+          sub = sub[part] = {};
         }
-        if (node.op === '$regex' && typeof node.value === 'string') {
-          sub[node.op!] = new RegExp(`^${node.value}`);
-        } else if ((node.op === '$eq' || node.op === '$ne') && node.value === null) {
-          sub.$exists = node.op !== '$eq';
-        } else if ((node.op === '$in' || node.op === '$nin') && !Array.isArray(node.value)) {
-          throw new Error(`Expected array literal for ${node.op}`);
+        if (node.operator === '$regex' && typeof node.value === 'string') {
+          sub[node.operator!] = new RegExp(`^${node.value}`);
+        } else if ((node.operator === '$eq' || node.operator === '$ne') && node.value === null) {
+          sub.$exists = node.operator !== '$eq';
+        } else if ((node.operator === '$in' || node.operator === '$nin') && !Array.isArray(node.value)) {
+          throw new Error(`Expected array literal for ${node.operator}`);
         } else {
-          sub[node.op!] = node.value;
+          sub[node.operator!] = node.value;
         }
         return top;
       }

package/src/tokenizer.ts

@@ -46,10 +46,10 @@ export class QueryLanguageTokenizer {
    * Process the next token.  Can specify expected type as needed
    */
   static #processToken(state: TokenizeState, mode?: TokenType): Token {
-    const text = state.text.substring(state.start, state.pos);
-    const res = TOKEN_MAPPING[text.toLowerCase()];
+    const text = state.text.substring(state.start, state.position);
+    const result = TOKEN_MAPPING[text.toLowerCase()];
     let value: unknown = text;
-    if (!res && state.mode === 'literal') {
+    if (!result && state.mode === 'literal') {
       if (/^["']/.test(text)) {
         value = text.substring(1, text.length - 1)
           .replace(/\\[.]/g, (a, b) => ESCAPE[a] || b);
@@ -67,18 +67,18 @@ export class QueryLanguageTokenizer {
         state.mode = 'identifier';
       }
     }
-    return res ?? { value, type: state.mode || mode };
+    return result ?? { value, type: state.mode || mode };
   }
 
   /**
    * Flush state to output
    */
   static #flush(state: TokenizeState, mode?: TokenType): void {
-    if ((!mode || !state.mode || mode !== state.mode) && state.start !== state.pos) {
+    if ((!mode || !state.mode || mode !== state.mode) && state.start !== state.position) {
       if (state.mode !== 'whitespace') {
         state.out.push(this.#processToken(state, mode));
       }
-      state.start = state.pos;
+      state.start = state.position;
     }
     state.mode = mode || state.mode;
   }
@@ -106,23 +106,22 @@ export class QueryLanguageTokenizer {
   /**
    * Read string until quote
    */
-  static readString(text: string, pos: number): number {
-    const len = text.length;
-    const ch = text.charCodeAt(pos);
-    const q = ch;
-    pos += 1;
-    while (pos < len) {
-      if (text.charCodeAt(pos) === q) {
+  static readString(text: string, position: number): number {
+    const length = text.length;
+    const ch = text.charCodeAt(position);
+    position += 1;
+    while (position < length) {
+      if (text.charCodeAt(position) === ch) {
         break;
-      } else if (text.charCodeAt(pos) === BACKSLASH) {
-        pos += 1;
+      } else if (text.charCodeAt(position) === BACKSLASH) {
+        position += 1;
       }
-      pos += 1;
+      position += 1;
     }
-    if (pos === len && text.charCodeAt(pos) !== q) {
+    if (position === length && text.charCodeAt(position) !== ch) {
       throw new Error('Unterminated string literal');
     }
-    return pos;
+    return position;
   }
 
   /**
@@ -131,16 +130,16 @@ export class QueryLanguageTokenizer {
   static tokenize(text: string): Token[] {
     const state: TokenizeState = {
       out: [],
-      pos: 0,
+      position: 0,
       start: 0,
       text,
       mode: undefined!
     };
     const len = text.length;
     // Loop through each char
-    while (state.pos < len) {
+    while (state.position < len) {
       // Read code as a number, more efficient
-      const ch = text.charCodeAt(state.pos);
+      const ch = text.charCodeAt(state.position);
       switch (ch) {
         // Handle punctuation
         case OPEN_PARENS: case CLOSE_PARENS: case OPEN_BRACKET: case CLOSE_BRACKET: case COMMA:
@@ -160,10 +159,10 @@ export class QueryLanguageTokenizer {
         case DBL_QUOTE: case SGL_QUOTE: case FORWARD_SLASH:
           this.#flush(state);
           state.mode = 'literal';
-          state.pos = this.readString(text, state.pos) + 1;
+          state.position = this.readString(text, state.position) + 1;
           if (ch === FORWARD_SLASH) { // Read modifiers, not used by all, but useful in general
-            while (this.#isValidRegexFlag(text.charCodeAt(state.pos))) {
-              state.pos += 1;
+            while (this.#isValidRegexFlag(text.charCodeAt(state.position))) {
+              state.position += 1;
             }
           }
           this.#flush(state);
@@ -173,10 +172,10 @@ export class QueryLanguageTokenizer {
           if (this.#isValidIdentToken(ch)) {
             this.#flush(state, 'literal');
           } else {
-            throw new Error(`Invalid character: ${text.substring(Math.max(0, state.pos - 10), state.pos + 1)}`);
+            throw new Error(`Invalid character: ${text.substring(Math.max(0, state.position - 10), state.position + 1)}`);
           }
       }
-      state.pos += 1;
+      state.position += 1;
     }
 
     this.#flush(state);

package/src/types.ts

@@ -11,7 +11,7 @@ export type TokenType =
  */
 export interface TokenizeState {
   out: Token[];
-  pos: number;
+  position: number;
   start: number;
   text: string;
   mode: TokenType;
@@ -42,7 +42,7 @@ export interface Node<T extends string = string> {
  */
 export interface ClauseNode extends Node<'clause'> {
   field?: string;
-  op?: string;
+  operator?: string;
   value?: Literal | Literal[];
 }
 
@@ -50,7 +50,7 @@ export interface ClauseNode extends Node<'clause'> {
  * Grouping
  */
 export interface GroupNode extends Node<'group'> {
-  op?: 'and' | 'or';
+  operator?: 'and' | 'or';
   value: AllNode[];
 }
 
@@ -58,7 +58,7 @@ export interface GroupNode extends Node<'group'> {
  * Unary node
  */
 export interface UnaryNode extends Node<'unary'> {
-  op?: 'not';
+  operator?: 'not';
   value: AllNode;
 }
 
@@ -66,7 +66,7 @@ export interface UnaryNode extends Node<'unary'> {
  * Array node
  */
 export interface ArrayNode extends Node<'list'> {
-  op?: 'not';
+  operator?: 'not';
   value: Literal[];
 }
 
@@ -75,7 +75,7 @@ export type AllNode = ArrayNode | UnaryNode | GroupNode | ClauseNode;
 /**
  * Translation of operators to model query keys
  */
-export const OP_TRANSLATION: Record<string, string> = {
+export const OPERATOR_TRANSLATION: Record<string, string> = {
   '<': '$lt', '<=': '$lte',
   '>': '$gt', '>=': '$gte',
   '!=': '$ne', '==': '$eq',
@@ -83,4 +83,4 @@ export const OP_TRANSLATION: Record<string, string> = {
   in: '$in', 'not-in': '$nin'
 };
 
-export const VALID_OPS = new Set(Object.keys(OP_TRANSLATION));
+export const VALID_OPERATORS = new Set(Object.keys(OPERATOR_TRANSLATION));