@fibery/expression-utils 1.1.15 → 1.1.16

package/lib/visitors.js

@@ -0,0 +1,469 @@
+var _ = require('lodash');
+require('@fibery/helpers/utils/trace');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+const stringify = x => {
+  if (x === undefined) {
+    return "undefined";
+  }
+  return JSON.stringify(x);
+};
+class NotImplementedError extends Error {
+  constructor(value, itemType = undefined) {
+    super([`"${stringify(value)}"`, itemType, "is not implemented"].filter(x => x !== undefined).join(" "));
+  }
+}
+
+const firstLastFunctions = new Set(["q/first", "q/last"]);
+const collectionOps = new Set(["q/count", "q/count-distinct", "q/sum", "q/min", "q/max", "q/avg", "q/join", "q/first", "q/last"]);
+// [op, left, right]
+// [=, $true, $false]
+// [=, $my-id, ["fibery/id"]]
+const binaryOperations = new Set(["=", "!=", "<", ">", "<=", ">=", "in",
+//asc: obsolete,use q/in
+"q/contains", "q/not-contains", "+", "-", "q/+", "q/-", "*", "/", "and", "or",
+//asc: obsolete. use q/and, q/or
+"q/and", "q/or", "q/in", "q/not-in"]);
+const logicalOperators = new Set(["and", "or", "q/and", "q/or"]);
+const isFunctionCallExpression = expression => expression.length > 1 && ___default["default"].isString(expression[0]) && (expression[0].startsWith("q/") || ["=", "!=", "<", ">", "<=", ">=", "+", "-", "*", "/", "in", "and", "or", "not-in"].includes(expression[0]));
+const fromRootKeyword = "q/from-root";
+const isFromRootFieldExpression = expression => ___default["default"].isArray(expression) && expression[0] === fromRootKeyword;
+const isCollectionFunctionExpression = expression =>
+//expression has length 3 in case of q/join
+(expression.length === 2 || expression.length === 3) && collectionOps.has(expression[0]);
+const isVariableExpression = expression => ___default["default"].isString(expression) && expression.startsWith("$");
+const isFieldExpression = expression => Array.isArray(expression) && expression.every(x => !isVariableExpression(x) && !binaryOperations.has(x) && ___default["default"].isString(x));
+const isQueryExpression = expression => {
+  if (___default["default"].isObject(expression) && "q/from" in expression) {
+    const fromExpression = expression["q/from"];
+    //asc: fromExpression === null for denormalizeSelect for reference collection case
+    return fromExpression === null || isFieldExpression(fromExpression);
+  }
+  return false;
+};
+const createExpressionVisitor = visitor => {
+  let visitorWithDefault = null;
+  const visitorDefault = {
+    visitVariableExpression: expression => expression,
+    visitFunctionCallExpression: ([fnName, ...args]) => [fnName, ...args.map(x => visitorWithDefault.visitExpression(x))],
+    visitFromRootFieldExpression: ([fromRootKeyword, ...rest]) => [fromRootKeyword, ...rest.map(x => visitorWithDefault.visitExpression(x))],
+    visitFieldExpression: expression => expression,
+    visitOrderByExpression: orderByExpression => orderByExpression.map(x => {
+      const [fieldExpression, orderDir] = x;
+      const fieldExpressionNew = visitorWithDefault.visitExpression(fieldExpression);
+      return [fieldExpressionNew, orderDir];
+    }),
+    visitQueryExpression: subQueryExpression => {
+      const {
+        "q/from": fromExpression,
+        "q/select": selectExpression,
+        "q/where": whereExpression,
+        "q/order-by": orderByExpression
+      } = subQueryExpression;
+      return _extends({}, subQueryExpression, fromExpression ? {
+        "q/from": visitorWithDefault.visitFieldExpression(fromExpression)
+      } : null, selectExpression ? {
+        "q/select": ___default["default"].isPlainObject(selectExpression) ? ___default["default"].mapValues(selectExpression, val => visitorWithDefault.visitExpression(val)) : visitorWithDefault.visitExpression(selectExpression)
+      } : null, whereExpression ? {
+        "q/where": visitorWithDefault.visitExpression(whereExpression)
+      } : null, orderByExpression ? {
+        "q/order-by": visitorWithDefault.visitOrderByExpression(orderByExpression)
+      } : null);
+    },
+    visitExpression: expression => {
+      if (expression === null) {
+        throw new NotImplementedError(expression, "expression");
+      } else if (isVariableExpression(expression)) {
+        return visitorWithDefault.visitVariableExpression(expression, visitorDefault);
+      } else if (isFromRootFieldExpression(expression)) {
+        return visitorWithDefault.visitFromRootFieldExpression(expression, visitorDefault);
+      } else if (isFunctionCallExpression(expression)) {
+        return visitorWithDefault.visitFunctionCallExpression(expression, visitorDefault);
+      } else if (isFieldExpression(expression)) {
+        return visitorWithDefault.visitFieldExpression(expression, visitorDefault);
+      } else if (isQueryExpression(expression)) {
+        return visitorWithDefault.visitQueryExpression(expression, visitorDefault);
+      } else {
+        throw new NotImplementedError(expression, "expression");
+      }
+    }
+  };
+  visitorWithDefault = _extends({}, visitorDefault, visitor);
+  return visitorWithDefault;
+};
+
+const defaultIdsWithNamesOnFieldNotFound = ({
+  fieldExpressionInNamesTerms,
+  fieldId
+}) => {
+  return {
+    currentTypeObject: null,
+    fieldExpressionInNamesTerms: [...fieldExpressionInNamesTerms, fieldId]
+  };
+};
+const visitFieldExpressionForReplaceIdsWithNamesVisitor = ({
+  expression,
+  typeObject,
+  onFieldNotFound
+}) => expression.reduce(({
+  currentTypeObject,
+  fieldExpressionInNamesTerms
+}, fieldId) => {
+  if (currentTypeObject && currentTypeObject.fieldObjectsById.hasOwnProperty(fieldId)) {
+    const fieldObject = currentTypeObject.fieldObjectsById[fieldId];
+    return {
+      currentTypeObject: fieldObject.typeObject,
+      fieldExpressionInNamesTerms: [...fieldExpressionInNamesTerms, fieldObject.name]
+    };
+  } else {
+    return onFieldNotFound({
+      currentTypeObject,
+      fieldExpressionInNamesTerms,
+      fieldId,
+      expression
+    });
+  }
+}, {
+  currentTypeObject: typeObject,
+  fieldExpressionInNamesTerms: []
+});
+const replaceIdsWithNamesVisitor = (typeObject, onFieldNotFound = defaultIdsWithNamesOnFieldNotFound) => {
+  const visitor = createExpressionVisitor({
+    visitFieldExpression: expression => visitFieldExpressionForReplaceIdsWithNamesVisitor({
+      expression,
+      typeObject,
+      onFieldNotFound
+    }).fieldExpressionInNamesTerms,
+    visitQueryExpression: subQueryExpression => {
+      const {
+        "q/from": fromExpression,
+        "q/select": selectExpression,
+        "q/where": whereExpression,
+        "q/order-by": orderByExpression
+      } = subQueryExpression;
+      const subQueryTypeObject = visitFieldExpressionForReplaceIdsWithNamesVisitor({
+        expression: fromExpression,
+        onFieldNotFound,
+        typeObject
+      }).currentTypeObject;
+      if (subQueryTypeObject) {
+        const subQueryVisitor = replaceIdsWithNamesVisitor(subQueryTypeObject, onFieldNotFound);
+        return _extends({}, subQueryExpression, {
+          "q/from": visitor.visitFieldExpression(fromExpression),
+          "q/select": ___default["default"].isPlainObject(selectExpression) ? ___default["default"].mapValues(selectExpression, val => subQueryVisitor.visitExpression(val)) : subQueryVisitor.visitExpression(selectExpression)
+        }, whereExpression ? {
+          "q/where": subQueryVisitor.visitExpression(whereExpression)
+        } : null, orderByExpression ? {
+          "q/order-by": subQueryVisitor.visitOrderByExpression(orderByExpression)
+        } : null);
+      }
+      return subQueryExpression;
+    }
+  });
+  return visitor;
+};
+const defaultNamesWithIdsOnFieldNotFound = ({
+  fieldExpressionInIdsTerms,
+  field
+}) => {
+  return {
+    currentTypeObject: null,
+    fieldExpressionInIdsTerms: [...fieldExpressionInIdsTerms, field]
+  };
+};
+const visitFieldExpressionForReplaceNamesWithIdsVisitor = ({
+  expression,
+  onFieldNotFound,
+  typeObject
+}) => expression.reduce(({
+  currentTypeObject,
+  fieldExpressionInIdsTerms
+}, field) => {
+  if (currentTypeObject && currentTypeObject.fieldObjectsByName.hasOwnProperty(field)) {
+    const fieldObject = currentTypeObject.fieldObjectsByName[field];
+    return {
+      currentTypeObject: fieldObject.typeObject,
+      fieldExpressionInIdsTerms: [...fieldExpressionInIdsTerms, fieldObject.id]
+    };
+  } else {
+    return onFieldNotFound({
+      currentTypeObject,
+      fieldExpressionInIdsTerms,
+      field,
+      expression
+    });
+  }
+}, {
+  currentTypeObject: typeObject,
+  fieldExpressionInIdsTerms: []
+});
+const replaceNamesWithIdsVisitor = (typeObject, onFieldNotFound = defaultNamesWithIdsOnFieldNotFound) => {
+  const visitor = createExpressionVisitor({
+    visitFieldExpression: expression => visitFieldExpressionForReplaceNamesWithIdsVisitor({
+      expression,
+      onFieldNotFound,
+      typeObject
+    }).fieldExpressionInIdsTerms,
+    visitQueryExpression: subQueryExpression => {
+      const {
+        "q/from": fromExpression,
+        "q/select": selectExpression,
+        "q/where": whereExpression,
+        "q/order-by": orderByExpression
+      } = subQueryExpression;
+      const subQueryTypeObject = visitFieldExpressionForReplaceNamesWithIdsVisitor({
+        expression: fromExpression,
+        onFieldNotFound,
+        typeObject
+      }).currentTypeObject;
+      if (subQueryTypeObject) {
+        const subQueryVisitor = replaceNamesWithIdsVisitor(subQueryTypeObject, onFieldNotFound);
+        return _extends({}, subQueryExpression, {
+          "q/from": visitor.visitFieldExpression(fromExpression),
+          "q/select": ___default["default"].isPlainObject(selectExpression) ? ___default["default"].mapValues(selectExpression, val => subQueryVisitor.visitExpression(val)) : subQueryVisitor.visitExpression(selectExpression)
+        }, whereExpression ? {
+          "q/where": subQueryVisitor.visitExpression(whereExpression)
+        } : null, orderByExpression ? {
+          "q/order-by": subQueryVisitor.visitOrderByExpression(orderByExpression)
+        } : null);
+      }
+      return subQueryExpression;
+    }
+  });
+  return visitor;
+};
+const deleteExpressionsWithNotFoundFieldsVisitor = typeObject => {
+  const visitor = createExpressionVisitor({
+    visitFunctionCallExpression: ([fnName, ...args]) => {
+      const argsNew = args.map(x => visitor.visitExpression(x)).filter(Boolean);
+      if (logicalOperators.has(fnName)) {
+        if (argsNew.length > 0) {
+          return argsNew.length === 1 ? argsNew[0] : [fnName, ...argsNew];
+        }
+        return null;
+      } else {
+        return argsNew.length === args.length ? [fnName, ...argsNew] : null;
+      }
+    },
+    visitFieldExpression: expression => {
+      const fieldTypeObject = expression.reduce((holderTypeObject, field) => holderTypeObject && holderTypeObject.fieldObjectsByName.hasOwnProperty(field) ? holderTypeObject.fieldObjectsByName[field].typeObject : null, typeObject);
+      return fieldTypeObject && expression;
+    },
+    visitOrderByExpression: orderByExpression => {
+      return orderByExpression.map(x => {
+        const [fieldExpression, orderDir] = x;
+        const fieldExpressionNew = visitor.visitExpression(fieldExpression);
+        return fieldExpressionNew && [fieldExpressionNew, orderDir];
+      }).filter(Boolean);
+    },
+    visitQueryExpression: subQueryExpression => {
+      const {
+        "q/from": fromExpression,
+        "q/select": selectExpression,
+        "q/where": whereExpression,
+        "q/order-by": orderByExpression
+      } = subQueryExpression;
+      const subQueryTypeObject = fromExpression.reduce((typeObject, field) => typeObject && typeObject.fieldObjectsByName.hasOwnProperty(field) ? typeObject.fieldObjectsByName[field].typeObject : null, typeObject);
+      if (subQueryTypeObject) {
+        const subQueryVisitor = deleteExpressionsWithNotFoundFieldsVisitor(subQueryTypeObject);
+        const subQueryExpressionNew = ___default["default"].pickBy(_extends({}, subQueryExpression, {
+          "q/from": visitor.visitFieldExpression(fromExpression),
+          "q/select": subQueryVisitor.visitExpression(selectExpression)
+        }, whereExpression ? {
+          "q/where": subQueryVisitor.visitExpression(whereExpression)
+        } : null, orderByExpression ? {
+          "q/order-by": subQueryVisitor.visitOrderByExpression(orderByExpression)
+        } : null));
+        const {
+          "q/select": selectExpressionNew
+        } = subQueryExpressionNew;
+        return selectExpressionNew ? subQueryExpressionNew : null;
+      } else {
+        return null;
+      }
+    }
+  });
+  return visitor;
+};
+const expressionContainsAggregation = expression => {
+  let result = false;
+  const visitor = createExpressionVisitor({
+    visitQueryExpression: queryExpression => {
+      const {
+        "q/select": selectExpression
+      } = queryExpression;
+      if (isCollectionFunctionExpression(selectExpression)) {
+        result = true;
+      }
+    },
+    visitFunctionCallExpression: (expression, visitorDefault) => {
+      if (firstLastFunctions.has(expression[0])) {
+        result = true;
+      } else {
+        visitorDefault.visitFunctionCallExpression(expression);
+      }
+    }
+  });
+  visitor.visitExpression(expression);
+  return result;
+};
+const defaultGetExpressionTypeOnFieldNotFound = () => {
+  return {
+    currentTypeObject: null
+  };
+};
+const getFieldAccessExpressionTypeObject = ({
+  expression,
+  typeObject,
+  onFieldNotFound,
+  returnRefTypeInsteadOfId
+}) => {
+  const reduced = expression.reduce(({
+    currentTypeObject
+  }, fieldId, index) => {
+    const fieldObject = currentTypeObject && currentTypeObject.fieldObjects.find(f => f.id === fieldId);
+    if (fieldObject) {
+      if (returnRefTypeInsteadOfId && index === expression.length - 1 && fieldObject.isId) {
+        return {
+          currentTypeObject
+        };
+      }
+      return {
+        currentTypeObject: fieldObject.typeObject
+      };
+    } else {
+      return onFieldNotFound({
+        currentTypeObject,
+        fieldId
+      });
+    }
+  }, {
+    currentTypeObject: typeObject
+  });
+  return reduced.currentTypeObject;
+};
+const UNKNOWN_EXPRESSION_TYPE = "unknown";
+const getExpressionTypeInternal = ({
+  expression,
+  typeObject,
+  functionsMeta,
+  onFieldNotFound,
+  returnRefTypeInsteadOfId
+}) => {
+  let result = null;
+  const visitor = createExpressionVisitor({
+    visitVariableExpression: function () {
+      result = UNKNOWN_EXPRESSION_TYPE;
+    },
+    visitFunctionCallExpression: function ([fnName, ...args]) {
+      const fnMeta = functionsMeta[fnName];
+      if (!fnMeta) {
+        throw new Error(`Function meta for "${fnName}" was not provided`);
+      }
+      const argTypes = args.map(arg => getExpressionTypeInternal({
+        expression: arg,
+        typeObject,
+        functionsMeta,
+        onFieldNotFound,
+        returnRefTypeInsteadOfId: firstLastFunctions.has(fnName) ? returnRefTypeInsteadOfId : false
+      }));
+      if (firstLastFunctions.has(fnName)) {
+        //assuming q/first has one argument and result type equals arg type.
+        //we need this trick to support 'returnRefTypeInsteadOfId' behavior for q/first and q/last.
+        result = argTypes[0];
+      } else {
+        const overload = fnMeta.overloads.find(o => o["arg-types"].every((argType, index) => argTypes[index] === UNKNOWN_EXPRESSION_TYPE || argTypes[index] === argType));
+        if (!overload) {
+          throw new Error(`No overload with args ${argTypes.join(",")} found for "${fnName}" in meta`);
+        }
+        result = overload["result-type"];
+      }
+    },
+    visitQueryExpression: expression => {
+      const {
+        "q/from": fromExpression,
+        "q/select": selectExpression
+      } = expression;
+      const fromTypeObject = getFieldAccessExpressionTypeObject({
+        expression: fromExpression,
+        typeObject,
+        onFieldNotFound,
+        returnRefTypeInsteadOfId
+      });
+      if (!fromTypeObject) {
+        result = null;
+      }
+      if (___default["default"].isPlainObject(selectExpression)) {
+        if (Object.values(selectExpression).length !== 1) {
+          throw new Error(`Cannot determine type of query expression ${JSON.stringify(expression)}`);
+        }
+        result = getExpressionTypeInternal({
+          expression: Object.values(selectExpression)[0],
+          typeObject: fromTypeObject,
+          functionsMeta,
+          onFieldNotFound,
+          returnRefTypeInsteadOfId
+        });
+      } else {
+        result = getExpressionTypeInternal({
+          expression: selectExpression,
+          typeObject: fromTypeObject,
+          functionsMeta,
+          onFieldNotFound,
+          returnRefTypeInsteadOfId
+        });
+      }
+    },
+    visitFieldExpression(expression) {
+      const fieldAccessExpressionTypeObject = getFieldAccessExpressionTypeObject({
+        expression,
+        typeObject,
+        onFieldNotFound,
+        returnRefTypeInsteadOfId
+      });
+      result = fieldAccessExpressionTypeObject && fieldAccessExpressionTypeObject.name;
+    }
+  });
+  visitor.visitExpression(expression);
+  return result;
+};
+const getExpressionType = ({
+  expression,
+  typeObject,
+  functionsMeta,
+  onFieldNotFound = defaultGetExpressionTypeOnFieldNotFound,
+  returnRefTypeInsteadOfId = true
+}) => {
+  return getExpressionTypeInternal({
+    expression,
+    typeObject,
+    functionsMeta,
+    onFieldNotFound,
+    returnRefTypeInsteadOfId
+  });
+};
+
+exports.UNKNOWN_EXPRESSION_TYPE = UNKNOWN_EXPRESSION_TYPE;
+exports.deleteExpressionsWithNotFoundFieldsVisitor = deleteExpressionsWithNotFoundFieldsVisitor;
+exports.expressionContainsAggregation = expressionContainsAggregation;
+exports.getExpressionType = getExpressionType;
+exports.replaceIdsWithNamesVisitor = replaceIdsWithNamesVisitor;
+exports.replaceNamesWithIdsVisitor = replaceNamesWithIdsVisitor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fibery/expression-utils",
-  "version": "1.1.15",
+  "version": "1.1.16",
   "description": "utils for working with fibery api expressions",
   "exports": {
     ".": "./lib/expression-utils.js",