@fibery/expression-utils 9.1.5 → 9.2.1

package/lib/expression-utils.js

@@ -127,7 +127,11 @@ const parseRelativeDatePlaceholder = placeholder => {
       let unit = relativeDatePlaceholderMatch[2];
       return {
         isStartOfInterval,
-        unitForStart: fullMatch.startsWith("$start-of-day") || fullMatch.startsWith("$end-of-day") ? "day" : isStartOfInterval !== undefined ? unit : undefined,
+        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",
@@ -249,6 +253,11 @@ const assertIsValidExpression = 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"]);
@@ -260,9 +269,6 @@ const binaryOperations = new Set(["=", "!=", "<", ">", "<=", ">=", "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"]);
@@ -275,7 +281,7 @@ const isCollectionFunctionExpression = expression =>
 (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 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)));
@@ -313,6 +319,38 @@ const collectFieldExpressions = (memo, expression) => {
     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).
@@ -387,6 +425,11 @@ const createExpressionVisitor = visitor => {
 var utils = {
   __proto__: null,
   assertIsValidExpression: assertIsValidExpression,
+  textTypes: textTypes,
+  dateTypes: dateTypes,
+  dateRangeTypes: dateRangeTypes,
+  convertableDateTypes: convertableDateTypes,
+  numberTypes: numberTypes,
   dateRangeFunctions: dateRangeFunctions,
   firstLastFunctions: firstLastFunctions,
   logicalOperators: logicalOperators,
@@ -405,6 +448,9 @@ var utils = {
   isMultiFieldExpression: isMultiFieldExpression,
   isFieldExpression: isFieldExpression,
   isQueryExpression: isQueryExpression,
+  getFieldObjectsByFieldExpression: getFieldObjectsByFieldExpression,
+  getFieldObjectByFieldExpression: getFieldObjectByFieldExpression,
+  getFieldObjects: getFieldObjects,
   extractFieldExpressions: extractFieldExpressions,
   createExpressionVisitor: createExpressionVisitor
 };

package/lib/paramsPlaceholders.js

@@ -126,7 +126,11 @@ const parseRelativeDatePlaceholder = placeholder => {
       let unit = relativeDatePlaceholderMatch[2];
       return {
         isStartOfInterval,
-        unitForStart: fullMatch.startsWith("$start-of-day") || fullMatch.startsWith("$end-of-day") ? "day" : isStartOfInterval !== undefined ? unit : undefined,
+        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",

package/lib/utils.js

@@ -23,6 +23,11 @@ const assertIsValidExpression = 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"]);
@@ -34,9 +39,6 @@ const binaryOperations = new Set(["=", "!=", "<", ">", "<=", ">=", "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"]);
@@ -49,7 +51,7 @@ const isCollectionFunctionExpression = expression =>
 (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 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)));
@@ -87,6 +89,38 @@ const collectFieldExpressions = (memo, expression) => {
     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).
@@ -159,11 +193,17 @@ const createExpressionVisitor = visitor => {
 };
 
 exports.assertIsValidExpression = assertIsValidExpression;
+exports.convertableDateTypes = convertableDateTypes;
 exports.createExpressionVisitor = createExpressionVisitor;
 exports.dateRangeFunctions = dateRangeFunctions;
+exports.dateRangeTypes = dateRangeTypes;
+exports.dateTypes = dateTypes;
 exports.extractFieldExpressions = extractFieldExpressions;
 exports.firstLastFunctions = firstLastFunctions;
 exports.fromRootKeyword = fromRootKeyword;
+exports.getFieldObjectByFieldExpression = getFieldObjectByFieldExpression;
+exports.getFieldObjects = getFieldObjects;
+exports.getFieldObjectsByFieldExpression = getFieldObjectsByFieldExpression;
 exports.isAccessFunctionExpression = isAccessFunctionExpression;
 exports.isBinaryExpression = isBinaryExpression;
 exports.isCollectionFunctionExpression = isCollectionFunctionExpression;
@@ -178,4 +218,6 @@ exports.isQueryExpression = isQueryExpression;
 exports.isVariableExpression = isVariableExpression;
 exports.logicalOperators = logicalOperators;
 exports.mathOperators = mathOperators;
+exports.numberTypes = numberTypes;
 exports.relationalOperators = relationalOperators;
+exports.textTypes = textTypes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fibery/expression-utils",
-  "version": "9.1.5",
+  "version": "9.2.1",
   "description": "utils for working with fibery api expressions",
   "exports": {
     ".": "./lib/expression-utils.js",
@@ -26,7 +26,7 @@
   "dependencies": {
     "lodash": "4.17.21",
     "moment": "2.29.4",
-    "@fibery/helpers": "1.3.1"
+    "@fibery/helpers": "1.3.3"
   },
   "devDependencies": {
     "@babel/core": "7.23.9",
@@ -38,7 +38,7 @@
     "@fibery/eslint-config": "8.6.1"
   },
   "peerDependencies": {
-    "@fibery/schema": "10.2.6"
+    "@fibery/schema": "10.2.8"
   },
   "jest": {
     "testEnvironment": "node",

package/types.d.ts

@@ -1,5 +1,5 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
-import {Schema, TypeObject, FieldObject} from "@fibery/schema";
+import {FieldObject, Schema, TypeObject} from "@fibery/schema";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type $TSFixMe = any;
@@ -61,6 +61,14 @@ declare module "@fibery/expression-utils" {
     firstLastFunctions: Set<string>;
     isQueryExpression: (expression: $TSFixMe) => boolean;
     isVariableExpression: (expression: $TSFixMe) => boolean;
+    isFunctionCallExpression: (expression: $TSFixMe) => boolean;
+    getFieldObjectByFieldExpression: (x: {typeObject: TypeObject; expression: Expression}) => FieldObject | undefined;
+    isFieldExpression: (expression: $TSFixMe) => boolean;
+    isBinaryExpression: (expression: $TSFixMe) => boolean;
+    isMultiFieldAccess: (expression: $TSFixMe) => boolean;
+    logicalOperators: Set<string>;
+    relationalOperators: Set<string>;
+    mathOperators: Set<string>;
   };
   export const contextVariables: {
     getEntityQueryVariables: (
@@ -69,6 +77,7 @@ declare module "@fibery/expression-utils" {
   };
   export const paramsPlaceholders: {
     formulaTodayDateParamPlaceholder: string;
+    formulaNowDateTimeParamPlaceholder: string;
     dynamicFilterParamPrefix: string;
 
     isDynamicFilterParam(paramValue: string): boolean;