rollun-ts-datastore-test/dist/utils/QueryNodeHandlerFactory.js

rollun-datastore written in TS

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.queryNodeHandlerFactory = exports.logicalNodesHandlersFactory = void 0;

var _lodash = _interopRequireDefault(require("lodash"));

var _AbstractScalarNode = _interopRequireDefault(require("rollun-ts-rql-test/dist/nodes/scalarNodes/AbstractScalarNode"));

var _AbstractArrayNode = _interopRequireDefault(require("rollun-ts-rql-test/dist/nodes/arrayNodes/AbstractArrayNode"));

var _And = _interopRequireDefault(require("rollun-ts-rql-test/dist/nodes/logicalNodes/And"));

var _Or = _interopRequireDefault(require("rollun-ts-rql-test/dist/nodes/logicalNodes/Or"));

var _AggregateFunctionNode = _interopRequireDefault(require("rollun-ts-rql-test/dist/nodes/aggregateNodes/AggregateFunctionNode"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var logicalNodesHandlersFactory = function logicalNodesHandlersFactory(node) {
  if (node instanceof _And["default"]) {
    console.log('logicalNodesHandlersFactory if', node);
    return function (handlers) {
      return function (item) {
        return handlers.every(function (handler) {
          return handler(item);
        });
      };
    };
  } else if (node instanceof _Or["default"]) {
    console.log('logicalNodesHandlersFactory else if', node);
    return function (handlers) {
      return function (item) {
        return handlers.some(function (handler) {
          return handler(item);
        });
      };
    };
  } else {
    console.log('logicalNodesHandlersFactory not', node);
    return function () {
      return function () {
        return true;
      };
    };
  }
};

exports.logicalNodesHandlersFactory = logicalNodesHandlersFactory;
var nodesMap = {
  eq: function eq(a, b) {
    return a === b;
  },
  ne: function ne(a, b) {
    return a !== b;
  },
  le: function le(a, b) {
    return a <= b;
  },
  lt: function lt(a, b) {
    return a < b;
  },
  ge: function ge(a, b) {
    return a >= b;
  },
  gt: function gt(a, b) {
    return a > b;
  },
  like: function like(a, b) {
    var aType = _typeof(a);

    var bType = _typeof(b);

    if (aType === 'string' && bType === 'string') {
      return a.includes(b);
    }

    if (aType === 'number' && bType === 'number') {
      return a === b;
    }

    return +a === +b;
  },
  alike: function alike(a, b) {
    return _lodash["default"].isString(a) && _lodash["default"].isString(b) ? a.toLowerCase().includes(b.toLowerCase()) : false;
  },
  contains: function contains(a, b) {
    return _lodash["default"].isString(a) && _lodash["default"].isString(b) ? a.toLowerCase().indexOf(b.toLowerCase()) > -1 : false;
  },
  on: function on(item, values) {
    return values.includes(item);
  },
  out: function out(item, values) {
    return !values.includes(item);
  }
};
var nodesMapStr = JSON.stringify(nodesMap);

var queryNodeHandlerFactory = function queryNodeHandlerFactory(node) {
  if (node instanceof _AbstractScalarNode["default"]) {
    console.log('queryNodeHandlerFactory if', node);
    return function (item) {
      if (!item.hasOwnProperty(node.field)) {
        throw new Error("There is not ".concat(node.field, " field in list"));
      }

      console.log('node.constructor.name', node.constructor.name);
      console.log('nodesMap', nodesMap);
      var handler = nodesMap[node.name];
      console.log('handler', {
        handler: handler,
        nodesMap: nodesMap,
        item: item,
        nodesMapStr: nodesMapStr
      });
      console.log('handler(item[node.field], node.value)', handler(item[node.field], node.value));
      return handler ? handler(item[node.field], node.value) : true;
    };
  } else if (node instanceof _AbstractArrayNode["default"]) {
    console.log('queryNodeHandlerFactory else if', {
      node: node,
      nodesMap: nodesMap
    });
    return function (item) {
      if (!item.hasOwnProperty(node.field)) {
        throw new Error("There is not ".concat(node.field, " field in list"));
      }

      var handler = nodesMap[node.name];
      return handler ? handler(item[node.field], node.values) : true;
    };
  } else if (node instanceof _AggregateFunctionNode["default"]) {
    console.log('queryNodeHandlerFactory else if 2', node);
    console.log('f node', node);
  }

  return function () {
    return true;
  };
};

exports.queryNodeHandlerFactory = queryNodeHandlerFactory;