@andrew_l/search-query-language 0.3.21 → 0.4.0

package/dist/index.cjs

@@ -1,727 +0,0 @@
-'use strict';
-
-const toolkit = require('@andrew_l/toolkit');
-const mongoose = require('mongoose');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const mongoose__default = /*#__PURE__*/_interopDefaultCompat(mongoose);
-
-class TokenType {
-  label;
-  keyword;
-  constructor(label, options) {
-    this.label = label;
-    this.keyword = options?.keyword;
-  }
-}
-
-const NODE = Object.freeze({
-  PROGRAM: "program",
-  IDENTIFIER: "identifier",
-  LITERAL: "literal",
-  LOGICAL_EXPRESSION: "logical-expression",
-  BINARY_EXPRESSION: "binary-expression"
-});
-const KEYWORDS = {};
-const TOKEN = Object.freeze({
-  /**
-   * Start of File token.
-   */
-  SOF: new TokenType("sof"),
-  /**
-   * End of File token.
-   */
-  EOF: new TokenType("eof"),
-  /**
-   * Number token.
-   */
-  NUM: new TokenType("num"),
-  /**
-   * String token.
-   */
-  STRING: new TokenType("string"),
-  /**
-   * Identifier token.
-   */
-  NAME: new TokenType("identifier"),
-  /**
-   * Parenthesis token.
-   */
-  PAREN_L: new TokenType("("),
-  /**
-   * Parenthesis token.
-   */
-  PAREN_R: new TokenType(")"),
-  /**
-   * Logical operator token.
-   */
-  LOGICAL_OR: kw("OR"),
-  /**
-   * Logical operator token.
-   */
-  LOGICAL_AND: kw("AND"),
-  /**
-   * Equality operator token.
-   */
-  EQUALITY: new TokenType("=/!="),
-  /**
-   * Relational operator token.
-   */
-  RELATIONAL: new TokenType("</>/<=/>="),
-  /**
-   * Minus operator token.
-   */
-  MINUS: new TokenType("-"),
-  /**
-   * Null literal token.
-   */
-  NULL: kw("null"),
-  /**
-   * True literal tokens.
-   */
-  TRUE: kw("true"),
-  /**
-   * False literal tokens.
-   */
-  FALSE: kw("false")
-});
-function kw(name, options = {}) {
-  options.keyword = name;
-  return KEYWORDS[name] = new TokenType(name, options);
-}
-
-class Token {
-  type;
-  value;
-  start;
-  end;
-  constructor(p) {
-    this.type = p.type;
-    this.value = p.value;
-    this.start = p.start;
-    this.end = p.end;
-  }
-}
-
-class Tokenizer {
-  input;
-  pos;
-  length;
-  state;
-  prev;
-  constructor(input) {
-    this.input = input;
-    this.length = input.length;
-    this.pos = 0;
-    this.state = {
-      start: 0,
-      end: 0,
-      type: TOKEN.SOF,
-      value: null
-    };
-    this.prev = { ...this.state };
-  }
-  [Symbol.iterator]() {
-    return {
-      next: () => {
-        let token = this.getToken();
-        return {
-          done: token.type === TOKEN.EOF,
-          value: token
-        };
-      }
-    };
-  }
-  /**
-   * Get the next token.
-   */
-  getToken() {
-    this.nextToken();
-    const token = new Token(this.state);
-    return token;
-  }
-  nextToken() {
-    this.skipSpace();
-    this.state.start = this.pos;
-    if (this.pos >= this.length) return this.finishToken(TOKEN.EOF);
-    this.readToken(this.charCodeAtPos());
-  }
-  skipSpace() {
-    let ch;
-    while (this.pos < this.length) {
-      ch = this.charCodeAtPos();
-      if (ch === 32 || ch === 160) {
-        this.pos++;
-      } else {
-        break;
-      }
-    }
-  }
-  finishToken(type, value) {
-    Object.assign(this.prev, this.state);
-    this.state.end = this.pos;
-    this.state.type = type;
-    this.state.value = value;
-  }
-  finishOp(type, size) {
-    let str = this.input.slice(this.pos, this.pos + size);
-    this.pos += size;
-    return this.finishToken(type, str);
-  }
-  readToken(code) {
-    if (isIdentifierStart(code)) {
-      return this.readWord();
-    }
-    return this.getTokenFromCode(code);
-  }
-  getTokenFromCode(code) {
-    switch (code) {
-      case 40:
-        ++this.pos;
-        return this.finishToken(TOKEN.PAREN_L);
-      case 41:
-        ++this.pos;
-        return this.finishToken(TOKEN.PAREN_R);
-      case 49:
-      case 50:
-      case 51:
-      case 52:
-      case 53:
-      case 54:
-      case 55:
-      case 56:
-      case 57:
-        return this.readNumber();
-      case 45:
-        ++this.pos;
-        return this.finishToken(TOKEN.MINUS);
-      case 61:
-      case 33:
-        return this.readEquality(code);
-      case 60:
-      case 62:
-        return this.readLtGt();
-      case 34:
-        return this.readString();
-    }
-    this.raise(
-      this.pos,
-      "Unexpected character '" + String.fromCharCode(code) + "'"
-    );
-  }
-  charCodeAtPos() {
-    return this.input.charCodeAt(this.pos);
-  }
-  readEquality(code) {
-    let next = this.input.charCodeAt(this.pos + 1);
-    if (code === 33) {
-      if (next === 61) return this.finishOp(TOKEN.EQUALITY, 2);
-    } else {
-      return this.finishOp(TOKEN.EQUALITY, 1);
-    }
-  }
-  readLtGt() {
-    let next = this.input.charCodeAt(this.pos + 1);
-    let size = 1;
-    if (next === 61) size = 2;
-    return this.finishOp(TOKEN.RELATIONAL, size);
-  }
-  readInt() {
-    const radix = 10;
-    let start = this.pos;
-    let code = 0;
-    let total = 0;
-    for (; ; ) {
-      code = this.input.charCodeAt(this.pos);
-      if (code >= 48 && code <= 57) {
-        total = total * radix + (code - 48);
-        this.pos++;
-      } else {
-        break;
-      }
-    }
-    if (this.pos === start) return null;
-    return total;
-  }
-  raise(pos, message) {
-    throw new SyntaxError(`${message} (${pos})`);
-  }
-  readString() {
-    let out = "";
-    let chunkStart = ++this.pos;
-    let ch;
-    for (; ; ) {
-      if (this.pos >= this.length) {
-        this.raise(this.state.start, "Unterminated string constant");
-      }
-      ch = this.input.charCodeAt(this.pos);
-      if (ch === 34) break;
-      if (ch === 92) {
-        out += this.input.slice(chunkStart, this.pos);
-        out += this.readEscapedChar();
-        chunkStart = this.pos;
-      }
-      ++this.pos;
-    }
-    out += this.input.slice(chunkStart, this.pos++);
-    return this.finishToken(TOKEN.STRING, out);
-  }
-  readWord() {
-    let chunkStart = this.pos;
-    let ch;
-    let cmp = isIdentifierStart;
-    while (this.pos < this.input.length) {
-      ch = this.charCodeAtPos();
-      if (!cmp(ch)) break;
-      cmp = isIdentifierChar;
-      this.pos++;
-    }
-    const word = this.input.slice(chunkStart, this.pos);
-    let type = TOKEN.NAME;
-    if (word in KEYWORDS) {
-      type = KEYWORDS[word];
-    }
-    return this.finishToken(type, word);
-  }
-  readEscapedChar() {
-    let ch = this.input.charCodeAt(++this.pos);
-    ++this.pos;
-    return String.fromCharCode(ch);
-  }
-  readNumber() {
-    let start = this.pos;
-    if (this.readInt() === null) this.raise(start, "Invalid number");
-    let next = this.input.charCodeAt(this.pos);
-    if (next === 46) {
-      ++this.pos;
-      this.readInt();
-      next = this.input.charCodeAt(this.pos);
-    }
-    let val = Number(this.input.slice(start, this.pos));
-    return this.finishToken(TOKEN.NUM, val);
-  }
-}
-function isIdentifierStart(code) {
-  if (code < 65) return false;
-  if (code < 91) return true;
-  if (code < 97) return code === 95;
-  if (code < 123) return true;
-  return false;
-}
-function isIdentifierChar(code) {
-  if (code < 48) return code === 46;
-  if (code < 58) return true;
-  if (code < 65) return false;
-  if (code < 91) return true;
-  if (code < 97) return code === 95;
-  if (code < 123) return true;
-  return false;
-}
-
-class Expression extends Tokenizer {
-  constructor(input) {
-    super(input);
-  }
-  /**
-   * Parse input into a program AST.
-   */
-  parse() {
-    let node = this.startNode(NODE.PROGRAM);
-    node.body = [];
-    this.nextToken();
-    return this.parseTopLevel(node);
-  }
-  finishNode(node) {
-    node.end = this.state.start;
-    return node;
-  }
-  parseTopLevel(node) {
-    while (this.state.type !== TOKEN.EOF) {
-      let stmt = this.parseExpression();
-      node.body.push(stmt);
-    }
-    this.nextToken();
-    return this.finishNode(node);
-  }
-  parseExpression() {
-    let left;
-    if (this.state.type === TOKEN.PAREN_L) {
-      this.nextToken();
-      left = this.parseExpression();
-      if (this.state.type !== TOKEN.PAREN_R) {
-        this.raise(this.pos, "Expected closing paren.");
-      }
-      this.nextToken();
-      if (this.state.type === TOKEN.EOF) {
-        return left;
-      }
-    } else {
-      left = this.parseExprAtom();
-    }
-    let node;
-    for (; ; ) {
-      node = this.parseExprOp(left);
-      node.start = left.start;
-      left = node;
-      if (this.state.type === TOKEN.EOF || this.state.type === TOKEN.PAREN_R)
-        break;
-    }
-    return node;
-  }
-  parseExprOp(left) {
-    const node = this.startNode(NODE.BINARY_EXPRESSION);
-    node.operator = this.state.value;
-    node.left = left;
-    switch (this.state.type) {
-      case TOKEN.LOGICAL_AND:
-      case TOKEN.LOGICAL_OR: {
-        if (!isNodeExpression(node.left)) {
-          this.raise(
-            node.left.start,
-            "Expected expression as left side of logical expression."
-          );
-        }
-        this.nextToken();
-        node.right = this.maybeLiteral() || this.parseExpression();
-        node.type = NODE.LOGICAL_EXPRESSION;
-        if (!isNodeExpression(node.right)) {
-          this.raise(
-            node.right.start,
-            `Unexpected ${node.right.type} as right side of logical expression.`
-          );
-        }
-        break;
-      }
-      case TOKEN.EQUALITY:
-      case TOKEN.RELATIONAL: {
-        this.nextToken();
-        if (node.left.type !== NODE.IDENTIFIER) {
-          this.raise(
-            node.start,
-            `Expected identifier as left side of binary expression.`
-          );
-        }
-        node.right = this.parseExprAtom();
-        if (node.right.type !== NODE.LITERAL) {
-          this.raise(
-            node.right.start,
-            "Expected literal as right side of binary expression."
-          );
-        }
-        break;
-      }
-      default: {
-        if (this.state.type === TOKEN.EOF) {
-          this.raise(
-            this.pos,
-            `Expected operator after ${this.prev.type.label}`
-          );
-        } else {
-          this.raise(this.pos, `Unexpected operator: ${this.state.type.label}`);
-        }
-      }
-    }
-    return this.finishNode(node);
-  }
-  maybeLiteral() {
-    switch (this.state.type) {
-      case TOKEN.MINUS: {
-        const start = this.state.start;
-        this.nextToken();
-        if (this.state.type !== TOKEN.NUM) {
-          this.raise(this.pos, `Expected number after minus operator`);
-        }
-        const node = this.maybeLiteral();
-        node.start = start;
-        node.raw = `-${node.raw}`;
-        node.value = node.value * -1;
-        return node;
-      }
-      case TOKEN.NUM:
-      case TOKEN.STRING: {
-        let node = this.startNode(NODE.LITERAL);
-        node.raw = this.input.slice(this.state.start, this.state.end);
-        node.value = this.state.value;
-        this.nextToken();
-        return this.finishNode(node);
-      }
-      case TOKEN.NULL:
-      case TOKEN.TRUE:
-      case TOKEN.FALSE: {
-        let node = this.startNode(NODE.LITERAL);
-        node.raw = this.state.type.keyword;
-        node.value = this.state.type === TOKEN.NULL ? null : this.state.type === TOKEN.TRUE;
-        this.nextToken();
-        return this.finishNode(node);
-      }
-      default: {
-        return null;
-      }
-    }
-  }
-  maybeIdentifier() {
-    switch (this.state.type) {
-      case TOKEN.NAME: {
-        let node = this.startNode(NODE.IDENTIFIER);
-        node.name = String(this.state.value);
-        this.nextToken();
-        return this.finishNode(node);
-      }
-      default:
-        return null;
-    }
-  }
-  parseExprAtom() {
-    const node = this.maybeIdentifier() || this.maybeLiteral();
-    if (!node) {
-      this.raise(this.pos, `Unexpected token ${this.state.type.label}.`);
-    }
-    return node;
-  }
-  startNode(type) {
-    const node = { type, start: this.state.start, end: 0 };
-    return node;
-  }
-}
-function isNodeExpression(node) {
-  return node.type === NODE.BINARY_EXPRESSION || node.type === NODE.LOGICAL_EXPRESSION;
-}
-
-function parseQuery(value) {
-  return new Expression(value).parse();
-}
-
-const OPERATOR_MAP = {
-  "=": "$eq",
-  "!=": "$ne",
-  ">": "$gt",
-  ">=": "$gte",
-  "<": "$lt",
-  "<=": "$lte"
-};
-const NOOP_TRANSFORM = [];
-function parseToMongo(input, options = {}) {
-  const opts = mergeOptions(options);
-  if (input.trim() === "") {
-    toolkit.assert.ok(opts.allowEmpty, "Search query cannot be empty.");
-    return {};
-  }
-  const result = {};
-  const ops = new OpsResource(opts.maxOps);
-  const exp = new Expression(input).parse();
-  for (const node of exp.body) {
-    Object.assign(result, reduceNode(node, opts, ops));
-  }
-  return result;
-}
-function reduceNode(node, options, opsResource) {
-  switch (node.type) {
-    case NODE.BINARY_EXPRESSION: {
-      opsResource.assert();
-      toolkit.assert.ok(
-        !options.allowedKeys || options.allowedKeys.has(node.left.name),
-        `The search key "${node.left.name}" is not allowed.`
-      );
-      const transform = options.transform?.[node.left.name] || options.transform?.["*"] || NOOP_TRANSFORM;
-      return {
-        [node.left.name]: node.operator === "=" ? callTransform(transform, node.right.value, node.left.name) : {
-          [OPERATOR_MAP[node.operator]]: callTransform(
-            transform,
-            node.right.value,
-            node.left.name
-          )
-        }
-      };
-    }
-    case NODE.LOGICAL_EXPRESSION: {
-      const op = node.operator === "AND" ? "$and" : "$or";
-      const right = reduceNode(node.right, options, opsResource);
-      if (node.right.type === NODE.LOGICAL_EXPRESSION && node.right.operator === node.operator) {
-        return {
-          [op]: [reduceNode(node.left, options, opsResource), ...right[op]]
-        };
-      }
-      return {
-        [op]: [reduceNode(node.left, options, opsResource), right]
-      };
-    }
-    default: {
-      toolkit.assert.ok(false, `Unexpected ast node: ${node.type}`);
-    }
-  }
-}
-function mergeOptions(...options) {
-  const optsTransform = {};
-  const result = {
-    transform: optsTransform,
-    allowEmpty: false,
-    maxOps: Infinity
-  };
-  for (const { transform, allowedKeys, ...rest } of options) {
-    Object.assign(result, rest);
-    if (allowedKeys?.length) {
-      result.allowedKeys = new Set(allowedKeys);
-    }
-    if (Array.isArray(transform) || toolkit.isFunction(transform)) {
-      optsTransform["*"] = optsTransform["*"] || [];
-      optsTransform["*"].push(...toolkit.arrayable(transform));
-    } else if (transform) {
-      for (const [key, value] of Object.entries(transform)) {
-        optsTransform[key] = optsTransform[key] || [];
-        optsTransform[key].push(...toolkit.arrayable(value));
-      }
-    }
-  }
-  return result;
-}
-class OpsResource {
-  constructor(max) {
-    this.max = max;
-    toolkit.assert.ok(
-      max === Infinity || toolkit.isNumber(max) && max > 0,
-      "maxOps must be a number greater than zero."
-    );
-    this.uses = 0;
-  }
-  uses;
-  assert() {
-    toolkit.assert.ok(
-      ++this.uses <= this.max,
-      `Maximum search operations reached: ${this.max}`
-    );
-  }
-}
-function callTransform(fns, value, key) {
-  for (const fn of fns) {
-    value = fn(value, key);
-  }
-  return value;
-}
-
-const MONGO_TRANSFORM = Object.freeze({
-  /**
-   * Ensures the value is not null.
-   * Throws an error if the value is null.
-   *
-   * @throws {Error} If the value is null.
-   */
-  NOT_NULLABLE: (value, key) => {
-    toolkit.assert.ok(value !== null, `The search key "${key}" cannot be null.`);
-    return value;
-  },
-  /**
-   * Validates that the value is a number.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid number.
-   */
-  NUMBER: (value, key) => {
-    if (value === null) return null;
-    toolkit.assert.number(value, `The search key "${key}" is not valid number.`);
-    return value;
-  },
-  /**
-   * Validates that the value is a string.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid string.
-   */
-  STRING: (value, key) => {
-    if (value === null) return null;
-    toolkit.assert.string(value, `The search key "${key}" is not valid string.`);
-    return value;
-  },
-  /**
-   * Validates that the value is a boolean.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid boolean.
-   */
-  BOOLEAN: (value, key) => {
-    if (value === null) return null;
-    toolkit.assert.boolean(value, `The search key "${key}" is not valid boolean.`);
-    return value;
-  },
-  /**
-   * Validates and converts the value to a MongoDB ObjectId.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid ObjectId.
-   */
-  OBJECT_ID: (value, key) => {
-    if (value === null) return null;
-    toolkit.assert.ok(
-      mongoose.isObjectIdOrHexString,
-      `The search key "${key}" is not valid object id.`
-    );
-    return new mongoose__default.Types.ObjectId(value);
-  },
-  /**
-   * Validates and converts the value to a Date.
-   * Supports string and number inputs for conversion.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid date.
-   */
-  DATE: (value, key) => {
-    if (value === null) return null;
-    const result = toolkit.isString(value) ? new Date(value) : toolkit.isNumber(value) ? new Date(value) : void 0;
-    toolkit.assert.date(result, `The search key "${key}" is not valid date.`);
-    return result;
-  }
-});
-const INSTANCE_TO_TRANSFORM = {
-  Number: [MONGO_TRANSFORM.NUMBER],
-  Decimal128: [MONGO_TRANSFORM.NUMBER],
-  String: [MONGO_TRANSFORM.STRING],
-  UUID: [MONGO_TRANSFORM.STRING],
-  ObjectId: [MONGO_TRANSFORM.OBJECT_ID],
-  Boolean: [MONGO_TRANSFORM.BOOLEAN],
-  Date: [MONGO_TRANSFORM.DATE]
-};
-function parseToMongoose(reference, input, options = {}) {
-  const opts = mergeOptions(
-    extractFromSchema("schema" in reference ? reference.schema : reference),
-    options
-  );
-  const result = {};
-  const ops = new OpsResource(opts.maxOps);
-  const exp = new Expression(input).parse();
-  for (const node of exp.body) {
-    Object.assign(result, reduceNode(node, opts, ops));
-  }
-  return result;
-}
-const extractFromSchema = toolkit.withCache(
-  { objectStrategy: "ref" },
-  (schema) => {
-    const allowedKeys = [];
-    const transform = {};
-    eachPath(schema, (path, type) => {
-      transform[path] = INSTANCE_TO_TRANSFORM[type.instance];
-      allowedKeys.push(path);
-    });
-    return { allowedKeys, transform };
-  }
-);
-function eachPath(schema, fn, prefix = "") {
-  schema.eachPath((path, type) => {
-    if (type.schema) {
-      eachPath(type.schema, fn, `${path}.`);
-    } else {
-      fn(`${prefix}${path}`, type);
-    }
-  });
-}
-
-exports.Expression = Expression;
-exports.KEYWORDS = KEYWORDS;
-exports.MONGO_TRANSFORM = MONGO_TRANSFORM;
-exports.NODE = NODE;
-exports.TOKEN = TOKEN;
-exports.Tokenizer = Tokenizer;
-exports.parseQuery = parseQuery;
-exports.parseToMongo = parseToMongo;
-exports.parseToMongoose = parseToMongoose;
-//# sourceMappingURL=index.cjs.map