@fibery/expression-utils 1.1.11 → 1.1.12

package/lib/utils.js

@@ -1,193 +0,0 @@
-var trace = require('@fibery/helpers/utils/trace');
-var _ = require('lodash');
-
-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 assertIsValidExpression = expression => {
-  trace.assert(Array.isArray(expression), "expression must be array", {
-    expression
-  });
-  trace.assert(expression.length > 0, "empty expression does not make any sense");
-};
-const dateRangeFunctions = new Set(["q/start", "q/end"]);
-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"]);
-
-// TODO: get rid of this. Use visitors everywhere
-const naryOperations = new Set(["and", "or", "q/and", "q/or"]);
-const logicalOperators = new Set(["and", "or", "q/and", "q/or"]);
-const relationalOperators = new Set(["=", "!=", "<", ">", "<=", ">="]);
-const mathOperators = new Set(["+", "-", "*", "/", "q/+", "q/-", "q/concat"]);
-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 isDateRangeFunctionExpression = expression => (expression.length === 2 || expression.length === 3) && dateRangeFunctions.has(expression[0]) && isFieldExpression(expression[1]);
-const isCollectionFunctionExpression = expression =>
-//expression has length 3 in case of q/join
-(expression.length === 2 || expression.length === 3) && collectionOps.has(expression[0]);
-const isAccessFunctionExpression = expresion => expresion.length === 2 && expresion[0] === "q/access?" && isFieldExpression(expresion[1]);
-const isBinaryExpression = expression => expression.length === 3 && binaryOperations.has(expression[0]);
-const isNaryExpression = expression => expression.length > 1 && naryOperations.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;
-};
-// [q/count, [..., collection]]
-// [q/start, [..., range]]
-// [q/end, [..., range]]
-// [q/access?, [..., field-expr]]
-const isFunctionExpression = expression => {
-  if (!Array.isArray(expression)) {
-    return false;
-  }
-  if (isFieldExpression(expression)) {
-    return false;
-  } else if (isDateRangeFunctionExpression(expression) || isCollectionFunctionExpression(expression) || isAccessFunctionExpression(expression)) {
-    return true;
-  }
-  throw new Error("invalid expression:" + JSON.stringify(expression));
-};
-const collectFieldExpressions = (memo, expression) => {
-  if (isVariableExpression(expression)) ; else if (isFunctionCallExpression(expression)) {
-    for (const part of expression.slice(1)) {
-      if (isVariableExpression(part) || part === null) ; else {
-        if (___default["default"].isString(part)) {
-          // field path shortcut
-          memo.push([part]);
-        } else {
-          collectFieldExpressions(memo, part);
-        }
-      }
-    }
-  } else if (isFieldExpression(expression)) {
-    memo.push(expression);
-  } else if (expression["q/from"] && isFieldExpression(expression["q/from"])) {
-    const innerMemo = [];
-    expression["q/select"] && collectFieldExpressions(innerMemo, expression["q/select"]);
-    expression["q/where"] && collectFieldExpressions(innerMemo, expression["q/where"]);
-    for (const fieldExpression of innerMemo) {
-      memo.push([...expression["q/from"], ...fieldExpression]);
-    }
-  } else {
-    throw new NotImplementedError(expression, "expression");
-  }
-};
-const extractFieldExpressions = expression => {
-  const memo = [];
-  collectFieldExpressions(memo, expression);
-  return ___default["default"].uniqBy(memo, x => x.join(","));
-};
-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;
-};
-
-exports.assertIsValidExpression = assertIsValidExpression;
-exports.createExpressionVisitor = createExpressionVisitor;
-exports.dateRangeFunctions = dateRangeFunctions;
-exports.extractFieldExpressions = extractFieldExpressions;
-exports.firstLastFunctions = firstLastFunctions;
-exports.fromRootKeyword = fromRootKeyword;
-exports.isAccessFunctionExpression = isAccessFunctionExpression;
-exports.isBinaryExpression = isBinaryExpression;
-exports.isCollectionFunctionExpression = isCollectionFunctionExpression;
-exports.isDateRangeFunctionExpression = isDateRangeFunctionExpression;
-exports.isFieldExpression = isFieldExpression;
-exports.isFromRootFieldExpression = isFromRootFieldExpression;
-exports.isFunctionCallExpression = isFunctionCallExpression;
-exports.isFunctionExpression = isFunctionExpression;
-exports.isNaryExpression = isNaryExpression;
-exports.isQueryExpression = isQueryExpression;
-exports.isVariableExpression = isVariableExpression;
-exports.logicalOperators = logicalOperators;
-exports.mathOperators = mathOperators;
-exports.relationalOperators = relationalOperators;

package/lib/visitors.js

@@ -1,463 +0,0 @@
-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: false
-      }));
-      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;