@fibery/expression-utils 1.1.12 → 1.1.13

package/lib/paramsPlaceholders.js

@@ -9,11 +9,9 @@ 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";
@@ -74,13 +72,28 @@ const paramsPlaceholdersLookup = {
   [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 = {
@@ -123,8 +136,12 @@ const dateToDateTimeIntervalLookup = {
 };
 
 exports.dateToDateTimeIntervalLookup = dateToDateTimeIntervalLookup;
+exports.dynamicFilterParamPrefix = dynamicFilterParamPrefix;
 exports.formulaNowDateTimeParamPlaceholder = formulaNowDateTimeParamPlaceholder;
 exports.formulaTodayDateParamPlaceholder = formulaTodayDateParamPlaceholder;
+exports.getFieldIdFromDynamicParam = getFieldIdFromDynamicParam;
+exports.isDynamicFilterParam = isDynamicFilterParam;
+exports.mapDynamicParams = mapDynamicParams;
 exports.monthAgoDateParamPlaceholder = monthAgoDateParamPlaceholder;
 exports.monthAgoEndDateTimeParamPlaceholder = monthAgoEndDateTimeParamPlaceholder;
 exports.monthAgoStartDateTimeParamPlaceholder = monthAgoStartDateTimeParamPlaceholder;

package/lib/utils.js

@@ -0,0 +1,193 @@
+var trace = require('@fibery/helpers/utils/trace');
+var _ = require('lodash');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+const stringify = x => {
+  if (x === undefined) {
+    return "undefined";
+  }
+  return JSON.stringify(x);
+};
+class NotImplementedError extends Error {
+  constructor(value, itemType = undefined) {
+    super([`"${stringify(value)}"`, itemType, "is not implemented"].filter(x => x !== undefined).join(" "));
+  }
+}
+
+const assertIsValidExpression = expression => {
+  trace.assert(Array.isArray(expression), "expression must be array", {
+    expression
+  });
+  trace.assert(expression.length > 0, "empty expression does not make any sense");
+};
+const dateRangeFunctions = new Set(["q/start", "q/end"]);
+const firstLastFunctions = new Set(["q/first", "q/last"]);
+const collectionOps = new Set(["q/count", "q/count-distinct", "q/sum", "q/min", "q/max", "q/avg", "q/join", "q/first", "q/last"]);
+// [op, left, right]
+// [=, $true, $false]
+// [=, $my-id, ["fibery/id"]]
+const binaryOperations = new Set(["=", "!=", "<", ">", "<=", ">=", "in",
+//asc: obsolete,use q/in
+"q/contains", "q/not-contains", "+", "-", "q/+", "q/-", "*", "/", "and", "or",
+//asc: obsolete. use q/and, q/or
+"q/and", "q/or", "q/in", "q/not-in"]);
+
+// TODO: get rid of this. Use visitors everywhere
+const naryOperations = new Set(["and", "or", "q/and", "q/or"]);
+const logicalOperators = new Set(["and", "or", "q/and", "q/or"]);
+const relationalOperators = new Set(["=", "!=", "<", ">", "<=", ">="]);
+const mathOperators = new Set(["+", "-", "*", "/", "q/+", "q/-", "q/concat"]);
+const isFunctionCallExpression = expression => expression.length > 1 && ___default["default"].isString(expression[0]) && (expression[0].startsWith("q/") || ["=", "!=", "<", ">", "<=", ">=", "+", "-", "*", "/", "in", "and", "or", "not-in"].includes(expression[0]));
+const fromRootKeyword = "q/from-root";
+const isFromRootFieldExpression = expression => ___default["default"].isArray(expression) && expression[0] === fromRootKeyword;
+const isDateRangeFunctionExpression = expression => (expression.length === 2 || expression.length === 3) && dateRangeFunctions.has(expression[0]) && isFieldExpression(expression[1]);
+const isCollectionFunctionExpression = expression =>
+//expression has length 3 in case of q/join
+(expression.length === 2 || expression.length === 3) && collectionOps.has(expression[0]);
+const isAccessFunctionExpression = expresion => expresion.length === 2 && expresion[0] === "q/access?" && isFieldExpression(expresion[1]);
+const isBinaryExpression = expression => expression.length === 3 && binaryOperations.has(expression[0]);
+const isNaryExpression = expression => expression.length > 1 && naryOperations.has(expression[0]);
+const isVariableExpression = expression => ___default["default"].isString(expression) && expression.startsWith("$");
+const isFieldExpression = expression => Array.isArray(expression) && expression.every(x => !isVariableExpression(x) && !binaryOperations.has(x) && ___default["default"].isString(x));
+const isQueryExpression = expression => {
+  if (___default["default"].isObject(expression) && "q/from" in expression) {
+    const fromExpression = expression["q/from"];
+    //asc: fromExpression === null for denormalizeSelect for reference collection case
+    return fromExpression === null || isFieldExpression(fromExpression);
+  }
+  return false;
+};
+// [q/count, [..., collection]]
+// [q/start, [..., range]]
+// [q/end, [..., range]]
+// [q/access?, [..., field-expr]]
+const isFunctionExpression = expression => {
+  if (!Array.isArray(expression)) {
+    return false;
+  }
+  if (isFieldExpression(expression)) {
+    return false;
+  } else if (isDateRangeFunctionExpression(expression) || isCollectionFunctionExpression(expression) || isAccessFunctionExpression(expression)) {
+    return true;
+  }
+  throw new Error("invalid expression:" + JSON.stringify(expression));
+};
+const collectFieldExpressions = (memo, expression) => {
+  if (isVariableExpression(expression)) ; else if (isFunctionCallExpression(expression)) {
+    for (const part of expression.slice(1)) {
+      if (isVariableExpression(part) || part === null) ; else {
+        if (___default["default"].isString(part)) {
+          // field path shortcut
+          memo.push([part]);
+        } else {
+          collectFieldExpressions(memo, part);
+        }
+      }
+    }
+  } else if (isFieldExpression(expression)) {
+    memo.push(expression);
+  } else if (expression["q/from"] && isFieldExpression(expression["q/from"])) {
+    const innerMemo = [];
+    expression["q/select"] && collectFieldExpressions(innerMemo, expression["q/select"]);
+    expression["q/where"] && collectFieldExpressions(innerMemo, expression["q/where"]);
+    for (const fieldExpression of innerMemo) {
+      memo.push([...expression["q/from"], ...fieldExpression]);
+    }
+  } else {
+    throw new NotImplementedError(expression, "expression");
+  }
+};
+const extractFieldExpressions = expression => {
+  const memo = [];
+  collectFieldExpressions(memo, expression);
+  return ___default["default"].uniqBy(memo, x => x.join(","));
+};
+const createExpressionVisitor = visitor => {
+  let visitorWithDefault = null;
+  const visitorDefault = {
+    visitVariableExpression: expression => expression,
+    visitFunctionCallExpression: ([fnName, ...args]) => [fnName, ...args.map(x => visitorWithDefault.visitExpression(x))],
+    visitFromRootFieldExpression: ([fromRootKeyword, ...rest]) => [fromRootKeyword, ...rest.map(x => visitorWithDefault.visitExpression(x))],
+    visitFieldExpression: expression => expression,
+    visitOrderByExpression: orderByExpression => orderByExpression.map(x => {
+      const [fieldExpression, orderDir] = x;
+      const fieldExpressionNew = visitorWithDefault.visitExpression(fieldExpression);
+      return [fieldExpressionNew, orderDir];
+    }),
+    visitQueryExpression: subQueryExpression => {
+      const {
+        "q/from": fromExpression,
+        "q/select": selectExpression,
+        "q/where": whereExpression,
+        "q/order-by": orderByExpression
+      } = subQueryExpression;
+      return _extends({}, subQueryExpression, fromExpression ? {
+        "q/from": visitorWithDefault.visitFieldExpression(fromExpression)
+      } : null, selectExpression ? {
+        "q/select": ___default["default"].isPlainObject(selectExpression) ? ___default["default"].mapValues(selectExpression, val => visitorWithDefault.visitExpression(val)) : visitorWithDefault.visitExpression(selectExpression)
+      } : null, whereExpression ? {
+        "q/where": visitorWithDefault.visitExpression(whereExpression)
+      } : null, orderByExpression ? {
+        "q/order-by": visitorWithDefault.visitOrderByExpression(orderByExpression)
+      } : null);
+    },
+    visitExpression: expression => {
+      if (expression === null) {
+        throw new NotImplementedError(expression, "expression");
+      } else if (isVariableExpression(expression)) {
+        return visitorWithDefault.visitVariableExpression(expression, visitorDefault);
+      } else if (isFromRootFieldExpression(expression)) {
+        return visitorWithDefault.visitFromRootFieldExpression(expression, visitorDefault);
+      } else if (isFunctionCallExpression(expression)) {
+        return visitorWithDefault.visitFunctionCallExpression(expression, visitorDefault);
+      } else if (isFieldExpression(expression)) {
+        return visitorWithDefault.visitFieldExpression(expression, visitorDefault);
+      } else if (isQueryExpression(expression)) {
+        return visitorWithDefault.visitQueryExpression(expression, visitorDefault);
+      } else {
+        throw new NotImplementedError(expression, "expression");
+      }
+    }
+  };
+  visitorWithDefault = _extends({}, visitorDefault, visitor);
+  return visitorWithDefault;
+};
+
+exports.assertIsValidExpression = assertIsValidExpression;
+exports.createExpressionVisitor = createExpressionVisitor;
+exports.dateRangeFunctions = dateRangeFunctions;
+exports.extractFieldExpressions = extractFieldExpressions;
+exports.firstLastFunctions = firstLastFunctions;
+exports.fromRootKeyword = fromRootKeyword;
+exports.isAccessFunctionExpression = isAccessFunctionExpression;
+exports.isBinaryExpression = isBinaryExpression;
+exports.isCollectionFunctionExpression = isCollectionFunctionExpression;
+exports.isDateRangeFunctionExpression = isDateRangeFunctionExpression;
+exports.isFieldExpression = isFieldExpression;
+exports.isFromRootFieldExpression = isFromRootFieldExpression;
+exports.isFunctionCallExpression = isFunctionCallExpression;
+exports.isFunctionExpression = isFunctionExpression;
+exports.isNaryExpression = isNaryExpression;
+exports.isQueryExpression = isQueryExpression;
+exports.isVariableExpression = isVariableExpression;
+exports.logicalOperators = logicalOperators;
+exports.mathOperators = mathOperators;
+exports.relationalOperators = relationalOperators;