@fibery/expression-utils 1.1.11 → 1.1.12

package/lib/expression-utils.js

@@ -1,745 +0,0 @@
-var _ = require('lodash');
-var moment = require('moment');
-var trace = require('@fibery/helpers/utils/trace');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
-var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
-
-const serializeDate = momentDate => {
-  return momentDate.format("YYYY-MM-DD");
-};
-const serializeDateTime = momentDate => {
-  return momentDate.toISOString();
-};
-const formulaTodayDateParamPlaceholder = "$formula-today-date-placeholder";
-const formulaNowDateTimeParamPlaceholder = "$formula-now-date-time-placeholder";
-const todayDateParamPlaceholder = "$today-date";
-const tomorrowDateParamPlaceholder = "$tomorrow-date";
-const yesterdayDateParamPlaceholder = "$yesterday-date";
-const weekAgoDateParamPlaceholder = "$week-ago-date";
-const weekFromNowDateParamPlaceholder = "$week-from-now-date";
-const monthAgoDateParamPlaceholder = "$month-ago-date";
-const monthFromNowDateParamPlaceholder = "$month-from-now-date";
-const yearAgoDateParamPlaceholder = "$year-ago-date";
-const yearFromNowDateParamPlaceholder = "$year-from-now-date";
-const todayStartDateTimeParamPlaceholder = "$today-date-time-start";
-const todayEndDateTimeParamPlaceholder = "$today-date-time-end";
-const tomorrowStartDateTimeParamPlaceholder = "$tomorrow-date-time-start";
-const tomorrowEndDateTimeParamPlaceholder = "$tomorrow-date-time-end";
-const yesterdayStartDateTimeParamPlaceholder = "$yesterday-date-time-start";
-const yesterdayEndDateTimeParamPlaceholder = "$yesterday-date-time-end";
-const weekAgoStartDateTimeParamPlaceholder = "$week-ago-date-time-start";
-const weekAgoEndDateTimeParamPlaceholder = "$week-ago-date-time-end";
-const weekFromNowStartDateTimeParamPlaceholder = "$week-from-now-date-time-start";
-const weekFromNowEndDateTimeParamPlaceholder = "$week-from-now-date-time-end";
-const monthAgoStartDateTimeParamPlaceholder = "$month-ago-date-time-start";
-const monthAgoEndDateTimeParamPlaceholder = "$month-ago-date-time-end";
-const monthFromNowStartDateTimeParamPlaceholder = "$month-from-now-date-time-start";
-const monthFromNowEndDateTimeParamPlaceholder = "$month-from-now-date-time-end";
-const yearAgoStartDateTimeParamPlaceholder = "$year-ago-date-time-start";
-const yearAgoEndDateTimeParamPlaceholder = "$year-ago-date-time-end";
-const yearFromNowStartDateTimeParamPlaceholder = "$year-from-now-date-time-start";
-const yearFromNowEndDateTimeParamPlaceholder = "$year-from-now-date-time-end";
-const paramsPlaceholdersLookup = {
-  [todayDateParamPlaceholder]: () => serializeDate(moment__default["default"]()),
-  [formulaTodayDateParamPlaceholder]: () => serializeDate(moment__default["default"]()),
-  [formulaNowDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]()),
-  [tomorrowDateParamPlaceholder]: () => serializeDate(moment__default["default"]().add(1, "days")),
-  [yesterdayDateParamPlaceholder]: () => serializeDate(moment__default["default"]().subtract(1, "days")),
-  [weekAgoDateParamPlaceholder]: () => serializeDate(moment__default["default"]().subtract(7, "days")),
-  [weekFromNowDateParamPlaceholder]: () => serializeDate(moment__default["default"]().add(7, "days")),
-  [monthAgoDateParamPlaceholder]: () => serializeDate(moment__default["default"]().subtract(1, "months")),
-  [monthFromNowDateParamPlaceholder]: () => serializeDate(moment__default["default"]().add(1, "months")),
-  [yearAgoDateParamPlaceholder]: () => serializeDate(moment__default["default"]().subtract(1, "year")),
-  [yearFromNowDateParamPlaceholder]: () => serializeDate(moment__default["default"]().add(1, "year")),
-  [todayStartDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().startOf("day")),
-  [todayEndDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().endOf("day")),
-  [tomorrowStartDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().add(1, "days").startOf("day")),
-  [tomorrowEndDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().add(1, "days").endOf("day")),
-  [yesterdayStartDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().subtract(1, "days").startOf("day")),
-  [yesterdayEndDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().subtract(1, "days").endOf("day")),
-  [weekAgoStartDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().subtract(7, "days").startOf("day")),
-  [weekAgoEndDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().subtract(7, "days").endOf("day")),
-  [weekFromNowStartDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().add(7, "days").startOf("day")),
-  [weekFromNowEndDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().add(7, "days").endOf("day")),
-  [monthAgoStartDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().subtract(1, "months").startOf("day")),
-  [monthAgoEndDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().subtract(1, "months").endOf("day")),
-  [monthFromNowStartDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().add(1, "months").startOf("day")),
-  [monthFromNowEndDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().add(1, "months").endOf("day")),
-  [yearAgoStartDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().subtract(1, "year").startOf("day")),
-  [yearAgoEndDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().subtract(1, "year").endOf("day")),
-  [yearFromNowStartDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().add(1, "year").startOf("day")),
-  [yearFromNowEndDateTimeParamPlaceholder]: () => serializeDateTime(moment__default["default"]().add(1, "year").endOf("day"))
-};
-const dynamicFilterParamPrefix = `$dynamic_`;
-const isDynamicFilterParam = paramValue => paramValue.startsWith(dynamicFilterParamPrefix);
-const getFieldIdFromDynamicParam = paramValue => paramValue.substring(dynamicFilterParamPrefix.length);
-const mapDynamicParams = (params, onDynamicParam) => {
-  if (!params) {
-    return params;
-  }
-  return Object.fromEntries(Object.entries(params).map(([key, value]) => {
-    if (___default["default"].isArray(value)) {
-      return [key, value.map(v => {
-        return ___default["default"].isString(v) && isDynamicFilterParam(v) ? onDynamicParam(v) : v;
-      })];
-    } else {
-      return [key, ___default["default"].isString(value) && isDynamicFilterParam(value) ? onDynamicParam(value) : value];
-    }
-  }));
-};
-const replacePlaceholdersInParams = params => params && ___default["default"].mapValues(params, (value, key) => {
-  const replaceFn = paramsPlaceholdersLookup[key];
-  if (replaceFn) {
-    return replaceFn();
-  }
-  return value;
-});
-const dateToDateTimeIntervalLookup = {
-  [todayDateParamPlaceholder]: {
-    start: todayStartDateTimeParamPlaceholder,
-    end: todayEndDateTimeParamPlaceholder
-  },
-  [tomorrowDateParamPlaceholder]: {
-    start: tomorrowStartDateTimeParamPlaceholder,
-    end: tomorrowEndDateTimeParamPlaceholder
-  },
-  [yesterdayDateParamPlaceholder]: {
-    start: yesterdayStartDateTimeParamPlaceholder,
-    end: yesterdayEndDateTimeParamPlaceholder
-  },
-  [weekAgoDateParamPlaceholder]: {
-    start: weekAgoStartDateTimeParamPlaceholder,
-    end: weekAgoEndDateTimeParamPlaceholder
-  },
-  [weekFromNowDateParamPlaceholder]: {
-    start: weekFromNowStartDateTimeParamPlaceholder,
-    end: weekFromNowEndDateTimeParamPlaceholder
-  },
-  [monthAgoDateParamPlaceholder]: {
-    start: monthAgoStartDateTimeParamPlaceholder,
-    end: monthAgoEndDateTimeParamPlaceholder
-  },
-  [monthFromNowDateParamPlaceholder]: {
-    start: monthFromNowStartDateTimeParamPlaceholder,
-    end: monthFromNowEndDateTimeParamPlaceholder
-  },
-  [yearAgoDateParamPlaceholder]: {
-    start: yearAgoStartDateTimeParamPlaceholder,
-    end: yearAgoEndDateTimeParamPlaceholder
-  },
-  [yearFromNowDateParamPlaceholder]: {
-    start: yearFromNowStartDateTimeParamPlaceholder,
-    end: yearFromNowEndDateTimeParamPlaceholder
-  }
-};
-
-var paramsPlaceholders = {
-  __proto__: null,
-  formulaTodayDateParamPlaceholder: formulaTodayDateParamPlaceholder,
-  formulaNowDateTimeParamPlaceholder: formulaNowDateTimeParamPlaceholder,
-  todayDateParamPlaceholder: todayDateParamPlaceholder,
-  tomorrowDateParamPlaceholder: tomorrowDateParamPlaceholder,
-  yesterdayDateParamPlaceholder: yesterdayDateParamPlaceholder,
-  weekAgoDateParamPlaceholder: weekAgoDateParamPlaceholder,
-  weekFromNowDateParamPlaceholder: weekFromNowDateParamPlaceholder,
-  monthAgoDateParamPlaceholder: monthAgoDateParamPlaceholder,
-  monthFromNowDateParamPlaceholder: monthFromNowDateParamPlaceholder,
-  yearAgoDateParamPlaceholder: yearAgoDateParamPlaceholder,
-  yearFromNowDateParamPlaceholder: yearFromNowDateParamPlaceholder,
-  todayStartDateTimeParamPlaceholder: todayStartDateTimeParamPlaceholder,
-  todayEndDateTimeParamPlaceholder: todayEndDateTimeParamPlaceholder,
-  tomorrowStartDateTimeParamPlaceholder: tomorrowStartDateTimeParamPlaceholder,
-  tomorrowEndDateTimeParamPlaceholder: tomorrowEndDateTimeParamPlaceholder,
-  yesterdayStartDateTimeParamPlaceholder: yesterdayStartDateTimeParamPlaceholder,
-  yesterdayEndDateTimeParamPlaceholder: yesterdayEndDateTimeParamPlaceholder,
-  weekAgoStartDateTimeParamPlaceholder: weekAgoStartDateTimeParamPlaceholder,
-  weekAgoEndDateTimeParamPlaceholder: weekAgoEndDateTimeParamPlaceholder,
-  weekFromNowStartDateTimeParamPlaceholder: weekFromNowStartDateTimeParamPlaceholder,
-  weekFromNowEndDateTimeParamPlaceholder: weekFromNowEndDateTimeParamPlaceholder,
-  monthAgoStartDateTimeParamPlaceholder: monthAgoStartDateTimeParamPlaceholder,
-  monthAgoEndDateTimeParamPlaceholder: monthAgoEndDateTimeParamPlaceholder,
-  monthFromNowStartDateTimeParamPlaceholder: monthFromNowStartDateTimeParamPlaceholder,
-  monthFromNowEndDateTimeParamPlaceholder: monthFromNowEndDateTimeParamPlaceholder,
-  yearAgoStartDateTimeParamPlaceholder: yearAgoStartDateTimeParamPlaceholder,
-  yearAgoEndDateTimeParamPlaceholder: yearAgoEndDateTimeParamPlaceholder,
-  yearFromNowStartDateTimeParamPlaceholder: yearFromNowStartDateTimeParamPlaceholder,
-  yearFromNowEndDateTimeParamPlaceholder: yearFromNowEndDateTimeParamPlaceholder,
-  paramsPlaceholdersLookup: paramsPlaceholdersLookup,
-  dynamicFilterParamPrefix: dynamicFilterParamPrefix,
-  isDynamicFilterParam: isDynamicFilterParam,
-  getFieldIdFromDynamicParam: getFieldIdFromDynamicParam,
-  mapDynamicParams: mapDynamicParams,
-  replacePlaceholdersInParams: replacePlaceholdersInParams,
-  dateToDateTimeIntervalLookup: dateToDateTimeIntervalLookup
-};
-
-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;
-};
-
-var utils = {
-  __proto__: null,
-  assertIsValidExpression: assertIsValidExpression,
-  dateRangeFunctions: dateRangeFunctions,
-  firstLastFunctions: firstLastFunctions,
-  logicalOperators: logicalOperators,
-  relationalOperators: relationalOperators,
-  mathOperators: mathOperators,
-  isFunctionCallExpression: isFunctionCallExpression,
-  fromRootKeyword: fromRootKeyword,
-  isFromRootFieldExpression: isFromRootFieldExpression,
-  isDateRangeFunctionExpression: isDateRangeFunctionExpression,
-  isCollectionFunctionExpression: isCollectionFunctionExpression,
-  isAccessFunctionExpression: isAccessFunctionExpression,
-  isBinaryExpression: isBinaryExpression,
-  isNaryExpression: isNaryExpression,
-  isVariableExpression: isVariableExpression,
-  isFieldExpression: isFieldExpression,
-  isQueryExpression: isQueryExpression,
-  isFunctionExpression: isFunctionExpression,
-  extractFieldExpressions: extractFieldExpressions,
-  createExpressionVisitor: createExpressionVisitor
-};
-
-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
-  });
-};
-
-var visitors = {
-  __proto__: null,
-  replaceIdsWithNamesVisitor: replaceIdsWithNamesVisitor,
-  replaceNamesWithIdsVisitor: replaceNamesWithIdsVisitor,
-  deleteExpressionsWithNotFoundFieldsVisitor: deleteExpressionsWithNotFoundFieldsVisitor,
-  expressionContainsAggregation: expressionContainsAggregation,
-  UNKNOWN_EXPRESSION_TYPE: UNKNOWN_EXPRESSION_TYPE,
-  getExpressionType: getExpressionType
-};
-
-const getEntityQueryVariables = schema => {
-  const grouped = ___default["default"].groupBy(schema.typeObjects.filter(x => x.isDomain), typeObject => typeObject.pluralTitle);
-  return ___default["default"].flatten(Object.values(grouped).map(group => {
-    return group.map(typeObject => ({
-      typeObject,
-      id: `entityQuery_${typeObject.id}`,
-      title: group.length > 1 ? `${typeObject.pluralTitle} (${typeObject.nameParts.namespace})` : typeObject.pluralTitle,
-      isCollection: true,
-      description: `All Entities from "${typeObject.title}" Database`
-    }));
-  }));
-};
-
-var contextVariables = {
-  __proto__: null,
-  getEntityQueryVariables: getEntityQueryVariables
-};
-
-exports.contextVariables = contextVariables;
-exports.paramsPlaceholders = paramsPlaceholders;
-exports.utils = utils;
-exports.visitors = visitors;