@fibery/expression-utils 9.3.0 → 9.4.0

package/lib/visitors.js

@@ -1,660 +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(_);
-
-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 isMultiFieldAccess = expression => ___default["default"].isArray(expression) && expression.length === 2 && !isFunctionCallExpression(expression) && expression.every(x => ___default["default"].isString(x));
-const isMultiFieldExpression = expression => Array.isArray(expression) && !isFunctionCallExpression(expression) && expression.some(x => isMultiFieldAccess(x)) && expression.every(x => !isVariableExpression(x) && !binaryOperations.has(x) && (___default["default"].isString(x) || isMultiFieldAccess(x)));
-const isFieldExpression = expression => Array.isArray(expression) && !isFunctionCallExpression(expression) && expression.every(x => !isVariableExpression(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) || isFromRootFieldExpression(fromExpression) || isMultiFieldExpression(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 {
-        ...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) || isMultiFieldExpression(expression)) {
-        return visitorWithDefault.visitFieldExpression(expression, visitorDefault);
-      } else if (isQueryExpression(expression)) {
-        return visitorWithDefault.visitQueryExpression(expression, visitorDefault);
-      } else {
-        throw new NotImplementedError(expression, "expression");
-      }
-    }
-  };
-  visitorWithDefault = {
-    ...visitorDefault,
-    ...visitor
-  };
-  return visitorWithDefault;
-};
-
-const visitFieldExpression = ({
-  expression: fieldExpression,
-  typeObject: initialTypeObject,
-  onField,
-  onFieldNotFound
-}) => fieldExpression.reduce(({
-  typeObject,
-  expression
-}, fieldAccess) => {
-  if (typeObject && isMultiFieldAccess(fieldAccess) && typeObject.fieldObjectsById.hasOwnProperty(fieldAccess[0])) {
-    var _fieldObject$multiRel;
-    const typeId = fieldAccess[1];
-    const fieldObject = typeObject.fieldObjectsById[fieldAccess[0]];
-    const nextTypeObject = (_fieldObject$multiRel = fieldObject.multiRelatedFieldObjects.find(f => f.holderTypeObject.id === typeId)) == null ? void 0 : _fieldObject$multiRel.holderTypeObject;
-    if (!nextTypeObject) {
-      const notFoundResult = onFieldNotFound({
-        currentTypeObject: typeObject,
-        expression: fieldExpression,
-        fieldAccess
-      });
-      return notFoundResult ? {
-        typeObject: notFoundResult.typeObject,
-        expression: [...expression, notFoundResult.fieldAccess]
-      } : {
-        typeObject,
-        expression
-      };
-    }
-    const onFieldResult = onField({
-      fieldAccess,
-      fieldObject,
-      typeObject: nextTypeObject
-    });
-    return onFieldResult ? {
-      typeObject: onFieldResult.typeObject,
-      expression: [...expression, onFieldResult.fieldAccess]
-    } : {
-      typeObject,
-      expression
-    };
-  } else if (typeObject && typeObject.fieldObjectsById.hasOwnProperty(fieldAccess)) {
-    const fieldObject = typeObject.fieldObjectsById[fieldAccess];
-    const onFieldResult = onField({
-      fieldAccess,
-      fieldObject,
-      typeObject: fieldObject.typeObject
-    });
-    return onFieldResult ? {
-      typeObject: onFieldResult.typeObject,
-      expression: [...expression, onFieldResult.fieldAccess]
-    } : {
-      typeObject,
-      expression
-    };
-  } else {
-    const notFoundResult = onFieldNotFound({
-      currentTypeObject: typeObject,
-      expression: fieldExpression,
-      fieldAccess
-    });
-    return notFoundResult ? {
-      typeObject: notFoundResult.typeObject,
-      expression: [...expression, notFoundResult.fieldAccess]
-    } : {
-      typeObject,
-      expression
-    };
-  }
-}, {
-  typeObject: initialTypeObject,
-  expression: []
-});
-const defaultOnFieldNotFound = () => undefined;
-const defaultOnField = () => undefined;
-const fieldAccessVisitorTypeAwareInternal = ({
-  typeObject,
-  rootTypeObject,
-  onField = defaultOnField,
-  onFieldNotFound = defaultOnFieldNotFound
-}) => {
-  return createExpressionVisitor({
-    visitFieldExpression: expression => visitFieldExpression({
-      typeObject,
-      expression,
-      onField,
-      onFieldNotFound
-    }).expression,
-    visitFromRootFieldExpression: ([fromRootKeyword, ...rest]) => [fromRootKeyword, ...rest.map(x => fieldAccessVisitorTypeAwareInternal({
-      typeObject: rootTypeObject,
-      rootTypeObject,
-      onField,
-      onFieldNotFound
-    }).visitExpression(x))],
-    visitQueryExpression: subQueryExpression => {
-      const {
-        "q/from": fromExpression,
-        "q/select": selectExpression,
-        "q/where": whereExpression,
-        "q/order-by": orderByExpression
-      } = subQueryExpression;
-      const fromVisitResult = visitFieldExpression({
-        typeObject,
-        expression: fromExpression,
-        onField,
-        onFieldNotFound
-      });
-      if (fromVisitResult != null && fromVisitResult.typeObject) {
-        const subQueryVisitor = fieldAccessVisitorTypeAwareInternal({
-          typeObject: fromVisitResult == null ? void 0 : fromVisitResult.typeObject,
-          rootTypeObject,
-          onField,
-          onFieldNotFound
-        });
-        return {
-          ...subQueryExpression,
-          ...{
-            "q/from": fromVisitResult.expression,
-            "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;
-    }
-  });
-};
-const fieldAccessVisitorTypeAware = ({
-  typeObject,
-  onField = defaultOnField,
-  onFieldNotFound = defaultOnFieldNotFound
-}) => {
-  return fieldAccessVisitorTypeAwareInternal({
-    typeObject,
-    rootTypeObject: typeObject,
-    onField,
-    onFieldNotFound
-  });
-};
-
-const defaultIdsWithNamesOnFieldNotFound = ({
-  fieldExpressionInNamesTerms,
-  fieldId
-}) => {
-  return {
-    currentTypeObject: null,
-    fieldExpressionInNamesTerms: [...fieldExpressionInNamesTerms, fieldId]
-  };
-};
-const visitFieldExpressionForReplaceIdsWithNamesVisitor = ({
-  expression,
-  typeObject,
-  onFieldNotFound
-}) => expression.reduce(({
-  currentTypeObject,
-  fieldExpressionInNamesTerms
-}, fieldId) => {
-  if (currentTypeObject && isMultiFieldAccess(fieldId) && currentTypeObject.fieldObjectsById.hasOwnProperty(fieldId[0])) {
-    var _fieldObject$multiRel;
-    const typeId = fieldId[1];
-    const fieldObject = currentTypeObject.fieldObjectsById[fieldId[0]];
-    const nextTypeObject = (_fieldObject$multiRel = fieldObject.multiRelatedFieldObjects.find(f => f.holderTypeObject.id === typeId)) == null ? void 0 : _fieldObject$multiRel.holderTypeObject;
-    if (!nextTypeObject) {
-      return onFieldNotFound({
-        currentTypeObject,
-        fieldExpressionInNamesTerms,
-        fieldId: fieldId,
-        expression
-      });
-    }
-    return {
-      currentTypeObject: nextTypeObject,
-      fieldExpressionInNamesTerms: [...fieldExpressionInNamesTerms, [fieldObject.name, nextTypeObject.name]]
-    };
-  } else 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 fieldExpressionVisitor = (typeObject, visitFieldExpression, replacedExpressionKey = "replacedExpression") => {
-  const visitor = createExpressionVisitor({
-    visitFieldExpression: expression => visitFieldExpression(typeObject, expression)[replacedExpressionKey],
-    visitQueryExpression: subQueryExpression => {
-      const {
-        "q/from": fromExpression,
-        "q/select": selectExpression,
-        "q/where": whereExpression,
-        "q/order-by": orderByExpression
-      } = subQueryExpression;
-      const subQueryTypeObject = visitFieldExpression(typeObject, fromExpression).currentTypeObject;
-      if (subQueryTypeObject) {
-        const subQueryVisitor = fieldExpressionVisitor(subQueryTypeObject, visitFieldExpression, replacedExpressionKey);
-        return {
-          ...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 replaceIdsWithNamesVisitor = (typeObject, onFieldNotFound = defaultIdsWithNamesOnFieldNotFound) => {
-  return fieldExpressionVisitor(typeObject, (typeObject, expression) => visitFieldExpressionForReplaceIdsWithNamesVisitor({
-    expression,
-    typeObject,
-    onFieldNotFound
-  }), "fieldExpressionInNamesTerms");
-};
-const defaultNamesWithIdsOnFieldNotFound = ({
-  fieldExpressionInIdsTerms,
-  field
-}) => {
-  return {
-    currentTypeObject: null,
-    fieldExpressionInIdsTerms: [...fieldExpressionInIdsTerms, field]
-  };
-};
-const visitFieldExpressionForReplaceNamesWithIdsVisitor = ({
-  expression,
-  typeObject,
-  onFieldNotFound
-}) => expression.reduce(({
-  currentTypeObject,
-  fieldExpressionInIdsTerms
-}, field) => {
-  if (currentTypeObject && isMultiFieldAccess(field) && currentTypeObject.fieldObjectsByName.hasOwnProperty(field[0])) {
-    var _fieldObject$multiRel2;
-    const type = field[1];
-    const fieldObject = currentTypeObject.fieldObjectsByName[field[0]];
-    const nextTypeObject = (_fieldObject$multiRel2 = fieldObject.multiRelatedFieldObjects.find(f => f.holderType === type)) == null ? void 0 : _fieldObject$multiRel2.holderTypeObject;
-    if (!nextTypeObject) {
-      return onFieldNotFound({
-        currentTypeObject,
-        fieldExpressionInIdsTerms,
-        field,
-        expression
-      });
-    }
-    return {
-      currentTypeObject: nextTypeObject,
-      fieldExpressionInIdsTerms: [...fieldExpressionInIdsTerms, [fieldObject.id, nextTypeObject.id]]
-    };
-  } else 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) => {
-  return fieldExpressionVisitor(typeObject, (typeObject, expression) => visitFieldExpressionForReplaceNamesWithIdsVisitor({
-    expression,
-    typeObject,
-    onFieldNotFound
-  }), "fieldExpressionInIdsTerms");
-};
-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) => {
-        if (holderTypeObject && isMultiFieldAccess(field) && holderTypeObject.fieldObjectsByName.hasOwnProperty(field[0])) {
-          var _fieldObject$multiRel3;
-          const type = field[1];
-          const fieldObject = holderTypeObject.fieldObjectsByName[field[0]];
-          const nextTypeObject = (_fieldObject$multiRel3 = fieldObject.multiRelatedFieldObjects.find(f => f.holderType === type)) == null ? void 0 : _fieldObject$multiRel3.holderTypeObject;
-          if (!nextTypeObject) {
-            return null;
-          }
-          return nextTypeObject;
-        } else if (holderTypeObject && holderTypeObject.fieldObjectsByName.hasOwnProperty(field)) {
-          return holderTypeObject.fieldObjectsByName[field].typeObject;
-        } else {
-          return 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({
-          ...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) => {
-    if (currentTypeObject && isMultiFieldAccess(fieldId) && currentTypeObject.fieldObjectsById.hasOwnProperty(fieldId[0])) {
-      var _fieldObject$multiRel4;
-      const typeId = fieldId[1];
-      const fieldObject = currentTypeObject.fieldObjectsById[fieldId[0]];
-      const nextTypeObject = (_fieldObject$multiRel4 = fieldObject.multiRelatedFieldObjects.find(f => f.holderTypeObject.id === typeId)) == null ? void 0 : _fieldObject$multiRel4.holderTypeObject;
-      if (!nextTypeObject) {
-        return onFieldNotFound({
-          currentTypeObject,
-          fieldId
-        });
-      }
-      return {
-        currentTypeObject: nextTypeObject
-      };
-    } else if (currentTypeObject && currentTypeObject.fieldObjectsById.hasOwnProperty(fieldId)) {
-      const fieldObject = currentTypeObject.fieldObjectsById[fieldId];
-      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) || fnName === "q/if" || fnName === "q/if-null" ? 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 if (fnName === "q/if") {
-        //we need this trick to support 'returnRefTypeInsteadOfId' behavior for q/if.
-        result = argTypes[1];
-      } else if (fnName === "q/if-null" && argTypes.some(x => !x.isPrimitive)) {
-        //we need this trick to support 'returnRefTypeInsteadOfId' behavior for q/if.
-        result = argTypes[0];
-      } else {
-        const overload = fnMeta.overloads.find(o => o["arg-types"].every((argType, index) => argTypes[index] === UNKNOWN_EXPRESSION_TYPE || argTypes[index] === argType || ["fibery/email", "fibery/url", "fibery/emoji", "fibery/color"].includes(argTypes[index]) && argType === "fibery/text"));
-        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(`Can't 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.fieldAccessVisitorTypeAware = fieldAccessVisitorTypeAware;
-exports.getExpressionType = getExpressionType;
-exports.replaceIdsWithNamesVisitor = replaceIdsWithNamesVisitor;
-exports.replaceNamesWithIdsVisitor = replaceNamesWithIdsVisitor;