@fibery/expression-utils 9.2.1 → 9.4.0

package/lib/expression-utils.js

@@ -1,1035 +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 whereParamPrefix = "$where";
-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 relativeDatePlaceholderRegex = /\$(?:start-|end-|start-of-day-|end-of-day-)?(\d+)-(second|minute|hour|day|week|month|quarter|year)-(before-now|after-now)-(date-time|date)/;
-const getRelativeDateValue = ({
-  isStartOfInterval,
-  unitForStart,
-  amount,
-  unit,
-  isBeforeNow,
-  isDateTime
-}) => {
-  const result = isBeforeNow ? moment__default["default"]().subtract(amount, unit) : moment__default["default"]().add(amount, unit);
-  if (isStartOfInterval === undefined) {
-    return isDateTime ? serializeDateTime(result) : serializeDate(result);
-  } else {
-    const resultByStartEnd = isStartOfInterval ? result.startOf(unitForStart) : result.endOf(unitForStart);
-    return isDateTime ? serializeDateTime(resultByStartEnd) : serializeDate(resultByStartEnd);
-  }
-};
-const toRelativeDatePlaceholder = ({
-  isStartOfInterval,
-  unitForStart,
-  amount,
-  unit,
-  isBeforeNow,
-  isDateTime
-}) => {
-  return `$${isStartOfInterval === undefined ? "" : isStartOfInterval ? `start-of-${unitForStart}-` : `end-of-${unitForStart}-`}${amount}-${unit}-${isBeforeNow ? "before-now" : "after-now"}-${isDateTime ? "date-time" : "date"}`;
-};
-const parseRelativeDatePlaceholder = placeholder => {
-  if (typeof placeholder === "string") {
-    const relativeDatePlaceholderMatch = placeholder.match(relativeDatePlaceholderRegex);
-    if (relativeDatePlaceholderMatch) {
-      const fullMatch = relativeDatePlaceholderMatch[0];
-      const isStartOfInterval = fullMatch.startsWith("$start") ? true : fullMatch.startsWith("$end") ? false : undefined;
-      let unit = relativeDatePlaceholderMatch[2];
-      return {
-        isStartOfInterval,
-        unitForStart:
-        // Usually the "start" unit is the same as the unit for relative date calculation.
-        // e.g. when we calculate the date "1 week ago", we want the beginning of the previous week.
-        // But sometimes they are different. We have hardcoded "day" for now, but this can be extended to any unit.
-        fullMatch.startsWith("$start-of-day") || fullMatch.startsWith("$end-of-day") ? "day" : isStartOfInterval !== undefined ? unit : undefined,
-        amount: Number.parseInt(relativeDatePlaceholderMatch[1]),
-        unit,
-        isBeforeNow: relativeDatePlaceholderMatch[3] === "before-now",
-        isDateTime: relativeDatePlaceholderMatch[4] === "date-time"
-      };
-    }
-  }
-  return null;
-};
-const replacePlaceholdersInParams = params => params && ___default["default"].mapValues(params, (value, key) => {
-  const replaceFn = paramsPlaceholdersLookup[key];
-  if (replaceFn) {
-    return replaceFn();
-  }
-  const relativeDateInfo = parseRelativeDatePlaceholder(key);
-  if (relativeDateInfo) {
-    return getRelativeDateValue(relativeDateInfo);
-  }
-  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,
-  whereParamPrefix: whereParamPrefix,
-  mapDynamicParams: mapDynamicParams,
-  getRelativeDateValue: getRelativeDateValue,
-  toRelativeDatePlaceholder: toRelativeDatePlaceholder,
-  parseRelativeDatePlaceholder: parseRelativeDatePlaceholder,
-  replacePlaceholdersInParams: replacePlaceholdersInParams,
-  dateToDateTimeIntervalLookup: dateToDateTimeIntervalLookup
-};
-
-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 textTypes = ["fibery/text", "fibery/email", "fibery/url", "fibery/emoji"];
-const dateTypes = ["fibery/date", "fibery/date-time"];
-const dateRangeTypes = ["fibery/date-range", "fibery/date-time-range"];
-const convertableDateTypes = ["fibery/date", "fibery/date-range"];
-const numberTypes = ["fibery/int", "fibery/decimal"];
-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"]);
-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 && logicalOperators.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 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) || isMultiFieldExpression(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 getFieldObjectsByFieldExpression = ({
-  typeObject,
-  expression
-}) => {
-  assertIsValidExpression(expression);
-  const fieldObjects = [];
-  let currentTypeObject = typeObject;
-  for (const fieldOrMultiFieldAccess of expression) {
-    if (isMultiFieldAccess(fieldOrMultiFieldAccess)) {
-      const [multiField, type] = fieldOrMultiFieldAccess;
-      const fieldObject = currentTypeObject.fieldObjectsByName[multiField];
-      fieldObjects.push(fieldObject);
-      const foundField = fieldObject.multiRelatedFieldObjects.find(f => f.holderType === type);
-      trace.assert(foundField, "incorrect expression for multi-field");
-      currentTypeObject = foundField.holderTypeObject;
-    } else {
-      const fieldObject = currentTypeObject.fieldObjectsByName[fieldOrMultiFieldAccess];
-      fieldObjects.push(fieldObject);
-      currentTypeObject = fieldObject.typeObject;
-    }
-  }
-  return fieldObjects;
-};
-const getFieldObjectByFieldExpression = (x // TODO: review types. using type assertion now to avoid rewriting half of app
-) => ___default["default"].last(getFieldObjectsByFieldExpression(x));
-const getFieldObjects = (expression, typeObject) => {
-  const fieldExpression = extractFieldExpressions(expression)[0];
-  return getFieldObjectsByFieldExpression({
-    typeObject,
-    expression: fieldExpression
-  });
-};
-
-/** @deprecated
- * This method checks few expression forms, that we do not generate on frontend anymore(field-access shortcut, direct value as parameter).
- * I'm afraid to replace it with implementation based on visitor everywhere, as visitors don't allow such expression forms and I don't want to extend visitor with those forms.
- * If you need this method in new places, consider implementing same logic on visitors and use it.
- **/
-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 {
-        ...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;
-};
-
-var utils = {
-  __proto__: null,
-  assertIsValidExpression: assertIsValidExpression,
-  textTypes: textTypes,
-  dateTypes: dateTypes,
-  dateRangeTypes: dateRangeTypes,
-  convertableDateTypes: convertableDateTypes,
-  numberTypes: numberTypes,
-  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,
-  isMultiFieldAccess: isMultiFieldAccess,
-  isMultiFieldExpression: isMultiFieldExpression,
-  isFieldExpression: isFieldExpression,
-  isQueryExpression: isQueryExpression,
-  getFieldObjectsByFieldExpression: getFieldObjectsByFieldExpression,
-  getFieldObjectByFieldExpression: getFieldObjectByFieldExpression,
-  getFieldObjects: getFieldObjects,
-  extractFieldExpressions: extractFieldExpressions,
-  createExpressionVisitor: createExpressionVisitor
-};
-
-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
-  });
-};
-
-var visitors = {
-  __proto__: null,
-  replaceIdsWithNamesVisitor: replaceIdsWithNamesVisitor,
-  replaceNamesWithIdsVisitor: replaceNamesWithIdsVisitor,
-  deleteExpressionsWithNotFoundFieldsVisitor: deleteExpressionsWithNotFoundFieldsVisitor,
-  expressionContainsAggregation: expressionContainsAggregation,
-  UNKNOWN_EXPRESSION_TYPE: UNKNOWN_EXPRESSION_TYPE,
-  getExpressionType: getExpressionType,
-  fieldAccessVisitorTypeAware: fieldAccessVisitorTypeAware
-};
-
-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;