@fibery/expression-utils 1.1.15 → 1.1.16

package/lib/expression-utils.js

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