fiql-query-builder/lib/utils.js

This module provides the utility to generate valid FIQL query strings by using a JSON objects or the custom classes provided.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.convertFromJson = exports.convertFromNode = undefined;

var _tree = require('./tree');

var _constants = require('./constants');

var _exception = require('./exception');

/**
 * Recursively traverse tree to build query parameter
 * @param {FiqlNode} node The root node
 */
var convertFromNode = exports.convertFromNode = function convertFromNode(node) {
  // If the node is a boolean or operator, traverse
  if (node instanceof _tree.OpNode || node instanceof _tree.ExpNode || node instanceof _tree.GroupNode) {
    return convertFromNode(node.build());
  }
  // We've hit the leaf
  return node;
};

/**
 * Recursively trave JSON object and convert to FiqlNode
 * @param {Object} json JSON representation of FIQL query
 */
var convertToNode = function convertToNode(json) {
  /**
   * Produce FiqlNode based on key of JSON object
   * @param {String} k The key of the JSON object
   * @param {Object} v The value of the JSON object
   */
  var handleKey = function handleKey(k, v) {
    switch (k.toLocaleLowerCase()) {
      case _constants.keyConstants.GROUP:
        return new _tree.GroupNode(convertToNode(v));
      case _constants.keyConstants.AND:
        return new _tree.AndNode(convertToNode(v));
      case _constants.keyConstants.OR:
        return new _tree.OrNode(convertToNode(v));
      case _constants.keyConstants.EQUALS:
        return new _tree.EqNode(convertToNode(v.selector), convertToNode(v.args));
      case _constants.keyConstants.NOT_EQUALS:
        return new _tree.NeqNode(convertToNode(v.selector), convertToNode(v.args));
      case _constants.keyConstants.LESS_THAN_OR_EQUAL:
        return new _tree.LeNode(convertToNode(v.selector), convertToNode(v.args));
      case _constants.keyConstants.LESS_THAN:
        return new _tree.LtNode(convertToNode(v.selector), convertToNode(v.args));
      case _constants.keyConstants.GREATER_THAN:
        return new _tree.GtNode(convertToNode(v.selector), convertToNode(v.args));
      case _constants.keyConstants.GREATER_THAN_OR_EQUAL:
        return new _tree.GeNode(convertToNode(v.selector), convertToNode(v.args));
      case _constants.keyConstants.IN:
        return new _tree.InNode(convertToNode(v.selector), convertToNode(v.args));
      case _constants.keyConstants.OUT:
        return new _tree.NotInNode(convertToNode(v.selector), convertToNode(v.args));
      case _constants.keyConstants.CUSTOM_OPERATOR:
        return new _tree.OpNode(convertToNode(v.selector), v.operator, convertToNode(v.args));
      case _constants.keyConstants.CUSTOM_EXPRESSION:
        return new _tree.ExpNode(v.operator, convertToNode(v.children));
      default:
        return v;
    }
  };

  // We get an array when we traverse an expression
  if (Array.isArray(json)) {
    return json.map(function (child) {
      return convertToNode(child);
    });
  }

  // Recursively traverse object until value hit, then
  // produce a leaf node
  if (json instanceof Object) {
    var children = Object.keys(json).map(function (k) {
      return handleKey(k, json[k]);
    });
    if (children.length === 1) {
      return children[0];
    }
    return children;
  }
  return new _tree.LeafNode(json);
};

/**
 * Converts a JSON object to a FiqlNode then to a query string
 * @param {Object} json JSON Object to convert
 */
var convertFromJson = exports.convertFromJson = function convertFromJson(json) {
  if (json instanceof Object && !Array.isArray(json)) {
    return convertFromNode(convertToNode(json));
  }
  throw new _exception.InvalidRootError('Root must be JSON Object.');
};