@fibery/expression-utils 9.2.1 → 9.4.0

package/lib/src/types.d.ts

@@ -0,0 +1,35 @@
+import { $TSFixMe } from "./tsfixme";
+type NestedArray<T> = Array<T | NestedArray<T>>;
+export type Expression = NestedArray<string>;
+type SelectPart = Record<string, Expression>;
+export type Select = SelectPart | Record<string, SelectPart>;
+export type OrderBy = Array<[Expression, string]>;
+export type QueryLimit = number | "q/no-limit";
+export type Query = {
+    "q/from": string;
+    "q/select"?: Select;
+    "q/offset"?: number;
+    "q/order-by"?: OrderBy;
+    "q/limit"?: number | "q/no-limit";
+    "q/where"?: NestedArray<unknown>;
+};
+export type SubQuery = {
+    "q/from": Expression;
+    "q/select"?: Select;
+    "q/offset"?: number;
+    "q/order-by"?: OrderBy;
+    "q/limit"?: QueryLimit;
+    "q/where"?: Expression;
+};
+export type ExpressionVisitor = {
+    visitVariableExpression?: (expression: string, visitor?: ExpressionVisitor) => any;
+    visitFunctionCallExpression?: (expression: [string, ...Expression[]], visitor?: ExpressionVisitor) => any;
+    visitFromRootFieldExpression?: (expression: [string, ...Expression[]], visitor?: ExpressionVisitor) => any;
+    visitFieldExpression?: (expression: Expression, visitor?: ExpressionVisitor) => any;
+    visitOrderByExpression?: (orderByExpression: OrderBy, visitor?: ExpressionVisitor) => any;
+    visitQueryExpression?: (subQueryExpression: SubQuery, visitor?: ExpressionVisitor) => any;
+    visitExpression?: (expression: Expression, visitor?: ExpressionVisitor) => any;
+    [key: string]: $TSFixMe;
+};
+export type ExpressionVisitorWithDefault = Required<ExpressionVisitor>;
+export {};

package/lib/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/utils.d.ts

@@ -0,0 +1,42 @@
+import { ExpressionVisitorWithDefault, Expression, ExpressionVisitor, SubQuery } from "./types";
+import { FieldObject, TypeObject } from "@fibery/schema";
+export declare const assertIsValidExpression: (expression: Expression) => void;
+export declare const textTypes: string[];
+export declare const dateTypes: string[];
+export declare const dateRangeTypes: string[];
+export declare const convertableDateTypes: string[];
+export declare const numberTypes: string[];
+export declare const dateRangeFunctions: Set<string>;
+export declare const firstLastFunctions: Set<string>;
+export declare const logicalOperators: Set<string>;
+export declare const relationalOperators: Set<string>;
+export declare const mathOperators: Set<string>;
+export declare const isFunctionCallExpression: (expression: Expression) => boolean;
+export declare const fromRootKeyword = "q/from-root";
+export declare const isFromRootFieldExpression: (expression: Expression) => boolean;
+export declare const isDateRangeFunctionExpression: (expression: Expression) => boolean;
+export declare const isCollectionFunctionExpression: (expression: Expression) => boolean;
+export declare const isAccessFunctionExpression: (expresion: Expression) => boolean;
+export declare const isBinaryExpression: (expression: Expression) => boolean;
+export declare const isNaryExpression: (expression: Expression) => boolean;
+export declare const isVariableExpression: (expression: Expression | string | null) => boolean;
+export declare const isMultiFieldAccess: (expression: Expression | string) => boolean;
+export declare const isMultiFieldExpression: (expression: Expression) => boolean;
+export declare const isFieldExpression: (expression: string | Expression) => boolean;
+export declare const isQueryExpression: (expression: Expression | SubQuery | null) => boolean;
+export declare const getFieldObjectsByFieldExpression: ({ typeObject, expression, }: {
+    typeObject: TypeObject;
+    expression: Expression;
+}) => FieldObject[];
+export declare const getFieldObjectByFieldExpression: (x: {
+    typeObject: TypeObject;
+    expression: Expression;
+}) => FieldObject;
+export declare const getFieldObjects: (expression: Expression, typeObject: TypeObject) => FieldObject[];
+/** @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.
+ **/
+export declare const extractFieldExpressions: (expression: Expression) => Expression[];
+export declare const createExpressionVisitor: (visitor: ExpressionVisitor) => ExpressionVisitorWithDefault;

package/lib/src/utils.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpressionVisitor = exports.extractFieldExpressions = exports.getFieldObjects = exports.getFieldObjectByFieldExpression = exports.getFieldObjectsByFieldExpression = exports.isQueryExpression = exports.isFieldExpression = exports.isMultiFieldExpression = exports.isMultiFieldAccess = exports.isVariableExpression = exports.isNaryExpression = exports.isBinaryExpression = exports.isAccessFunctionExpression = exports.isCollectionFunctionExpression = exports.isDateRangeFunctionExpression = exports.isFromRootFieldExpression = exports.fromRootKeyword = exports.isFunctionCallExpression = exports.mathOperators = exports.relationalOperators = exports.logicalOperators = exports.firstLastFunctions = exports.dateRangeFunctions = exports.numberTypes = exports.convertableDateTypes = exports.dateRangeTypes = exports.dateTypes = exports.textTypes = exports.assertIsValidExpression = void 0;
+const trace_1 = require("@fibery/helpers/utils/trace");
+const lodash_1 = __importDefault(require("lodash"));
+const errors_1 = require("./errors");
+const assertIsValidExpression = (expression) => {
+    (0, trace_1.assert)(Array.isArray(expression), "expression must be array", { expression });
+    (0, trace_1.assert)(expression.length > 0, "empty expression does not make any sense");
+};
+exports.assertIsValidExpression = assertIsValidExpression;
+exports.textTypes = ["fibery/text", "fibery/email", "fibery/url", "fibery/emoji"];
+exports.dateTypes = ["fibery/date", "fibery/date-time"];
+exports.dateRangeTypes = ["fibery/date-range", "fibery/date-time-range"];
+exports.convertableDateTypes = ["fibery/date", "fibery/date-range"];
+exports.numberTypes = ["fibery/int", "fibery/decimal"];
+exports.dateRangeFunctions = new Set(["q/start", "q/end"]);
+exports.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",
+]);
+exports.logicalOperators = new Set(["and", "or", "q/and", "q/or"]);
+exports.relationalOperators = new Set(["=", "!=", "<", ">", "<=", ">="]);
+exports.mathOperators = new Set(["+", "-", "*", "/", "q/+", "q/-", "q/concat"]);
+const isFunctionCallExpression = (expression) => expression.length > 1 &&
+    lodash_1.default.isString(expression[0]) &&
+    (expression[0].startsWith("q/") ||
+        ["=", "!=", "<", ">", "<=", ">=", "+", "-", "*", "/", "in", "and", "or", "not-in"].includes(expression[0]));
+exports.isFunctionCallExpression = isFunctionCallExpression;
+exports.fromRootKeyword = "q/from-root";
+const isFromRootFieldExpression = (expression) => lodash_1.default.isArray(expression) && expression[0] === exports.fromRootKeyword;
+exports.isFromRootFieldExpression = isFromRootFieldExpression;
+const isDateRangeFunctionExpression = (expression) => (expression.length === 2 || expression.length === 3) &&
+    exports.dateRangeFunctions.has(expression[0]) &&
+    (0, exports.isFieldExpression)(expression[1]);
+exports.isDateRangeFunctionExpression = isDateRangeFunctionExpression;
+const isCollectionFunctionExpression = (expression) => 
+//expression has length 3 in case of q/join
+(expression.length === 2 || expression.length === 3) && collectionOps.has(expression[0]);
+exports.isCollectionFunctionExpression = isCollectionFunctionExpression;
+const isAccessFunctionExpression = (expresion) => expresion.length === 2 && expresion[0] === "q/access?" && (0, exports.isFieldExpression)(expresion[1]);
+exports.isAccessFunctionExpression = isAccessFunctionExpression;
+const isBinaryExpression = (expression) => expression.length === 3 && binaryOperations.has(expression[0]);
+exports.isBinaryExpression = isBinaryExpression;
+const isNaryExpression = (expression) => expression.length > 1 && exports.logicalOperators.has(expression[0]);
+exports.isNaryExpression = isNaryExpression;
+const isVariableExpression = (expression) => lodash_1.default.isString(expression) && expression.startsWith("$");
+exports.isVariableExpression = isVariableExpression;
+const isMultiFieldAccess = (expression) => lodash_1.default.isArray(expression) &&
+    expression.length === 2 &&
+    !(0, exports.isFunctionCallExpression)(expression) &&
+    expression.every((x) => lodash_1.default.isString(x));
+exports.isMultiFieldAccess = isMultiFieldAccess;
+const isMultiFieldExpression = (expression) => Array.isArray(expression) &&
+    !(0, exports.isFunctionCallExpression)(expression) &&
+    expression.some((x) => (0, exports.isMultiFieldAccess)(x)) &&
+    expression.every((x) => !(0, exports.isVariableExpression)(x) &&
+        !binaryOperations.has(x) &&
+        (lodash_1.default.isString(x) || (0, exports.isMultiFieldAccess)(x)));
+exports.isMultiFieldExpression = isMultiFieldExpression;
+const isFieldExpression = (expression) => Array.isArray(expression) &&
+    !(0, exports.isFunctionCallExpression)(expression) &&
+    expression.every((x) => !(0, exports.isVariableExpression)(x) && lodash_1.default.isString(x));
+exports.isFieldExpression = isFieldExpression;
+const isQueryExpression = (expression) => {
+    if (lodash_1.default.isObject(expression) && "q/from" in expression) {
+        const fromExpression = expression["q/from"];
+        //asc: fromExpression === null for denormalizeSelect for reference collection case
+        return (fromExpression === null ||
+            (0, exports.isFieldExpression)(fromExpression) ||
+            (0, exports.isFromRootFieldExpression)(fromExpression) ||
+            (0, exports.isMultiFieldExpression)(fromExpression));
+    }
+    return false;
+};
+exports.isQueryExpression = isQueryExpression;
+const collectFieldExpressions = (memo, expression) => {
+    if ((0, exports.isVariableExpression)(expression)) {
+        /* empty */
+    }
+    else if ((0, exports.isFunctionCallExpression)(expression)) {
+        for (const part of expression.slice(1)) {
+            if ((0, exports.isVariableExpression)(part) || part === null) {
+                /* empty */
+            }
+            else {
+                if (lodash_1.default.isString(part)) {
+                    // field path shortcut
+                    memo.push([part]);
+                }
+                else {
+                    collectFieldExpressions(memo, part);
+                }
+            }
+        }
+    }
+    else if ((0, exports.isFieldExpression)(expression) || (0, exports.isMultiFieldExpression)(expression)) {
+        memo.push(expression);
+    }
+    else if (expression["q/from"] &&
+        (0, exports.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 errors_1.NotImplementedError(expression, "expression");
+    }
+};
+const getFieldObjectsByFieldExpression = ({ typeObject, expression, }) => {
+    (0, exports.assertIsValidExpression)(expression);
+    const fieldObjects = [];
+    let currentTypeObject = typeObject;
+    for (const fieldOrMultiFieldAccess of expression) {
+        if ((0, exports.isMultiFieldAccess)(fieldOrMultiFieldAccess)) {
+            const [multiField, type] = fieldOrMultiFieldAccess;
+            const fieldObject = currentTypeObject.fieldObjectsByName[multiField];
+            fieldObjects.push(fieldObject);
+            const foundField = fieldObject.multiRelatedFieldObjects.find((f) => f.holderType === type);
+            (0, trace_1.assert)(foundField, "incorrect expression for multi-field");
+            currentTypeObject = foundField.holderTypeObject;
+        }
+        else {
+            const fieldObject = currentTypeObject.fieldObjectsByName[fieldOrMultiFieldAccess];
+            fieldObjects.push(fieldObject);
+            currentTypeObject = fieldObject.typeObject;
+        }
+    }
+    return fieldObjects;
+};
+exports.getFieldObjectsByFieldExpression = getFieldObjectsByFieldExpression;
+const getFieldObjectByFieldExpression = (x // TODO: review types. using type assertion now to avoid rewriting half of app
+) => lodash_1.default.last((0, exports.getFieldObjectsByFieldExpression)(x));
+exports.getFieldObjectByFieldExpression = getFieldObjectByFieldExpression;
+const getFieldObjects = (expression, typeObject) => {
+    const fieldExpression = (0, exports.extractFieldExpressions)(expression)[0];
+    return (0, exports.getFieldObjectsByFieldExpression)({
+        typeObject,
+        expression: fieldExpression,
+    });
+};
+exports.getFieldObjects = getFieldObjects;
+/** @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 lodash_1.default.uniqBy(memo, (x) => x.join(","));
+};
+exports.extractFieldExpressions = extractFieldExpressions;
+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": lodash_1.default.isPlainObject(selectExpression)
+                            ? lodash_1.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 errors_1.NotImplementedError(expression, "expression");
+            }
+            else if ((0, exports.isVariableExpression)(expression)) {
+                return visitorWithDefault.visitVariableExpression(expression, visitorDefault);
+            }
+            else if ((0, exports.isFromRootFieldExpression)(expression)) {
+                return visitorWithDefault.visitFromRootFieldExpression(expression, visitorDefault);
+            }
+            else if ((0, exports.isFunctionCallExpression)(expression)) {
+                return visitorWithDefault.visitFunctionCallExpression(expression, visitorDefault);
+            }
+            else if ((0, exports.isFieldExpression)(expression) || (0, exports.isMultiFieldExpression)(expression)) {
+                return visitorWithDefault.visitFieldExpression(expression, visitorDefault);
+            }
+            else if ((0, exports.isQueryExpression)(expression)) {
+                return visitorWithDefault.visitQueryExpression(expression, visitorDefault);
+            }
+            else {
+                throw new errors_1.NotImplementedError(expression, "expression");
+            }
+        },
+    };
+    visitorWithDefault = { ...visitorDefault, ...visitor };
+    return visitorWithDefault;
+};
+exports.createExpressionVisitor = createExpressionVisitor;

package/lib/src/visitors.d.ts

@@ -0,0 +1,44 @@
+import { fieldAccessVisitorTypeAware } from "./fieldExpressionVisitorTypeAware";
+import { TypeObject } from "@fibery/schema";
+import { Expression } from "./types";
+type OnFieldNotFoundInNamesTerms = (params: {
+    fieldExpressionInNamesTerms: Expression;
+    fieldId: string;
+    currentTypeObject: TypeObject | null;
+    expression: Expression;
+}) => {
+    currentTypeObject: TypeObject | null;
+    fieldExpressionInNamesTerms: Expression;
+};
+type OnFieldNotFoundInIdsTerms = (params: {
+    fieldExpressionInIdsTerms: Expression;
+    field: string;
+    currentTypeObject: TypeObject | null;
+    expression: Expression;
+}) => {
+    currentTypeObject: TypeObject | null;
+    fieldExpressionInIdsTerms: Expression;
+};
+export declare const replaceIdsWithNamesVisitor: (typeObject: TypeObject, onFieldNotFound?: OnFieldNotFoundInNamesTerms) => Required<import("./types").ExpressionVisitor>;
+export declare const replaceNamesWithIdsVisitor: (typeObject: TypeObject, onFieldNotFound?: OnFieldNotFoundInIdsTerms) => Required<import("./types").ExpressionVisitor>;
+export declare const deleteExpressionsWithNotFoundFieldsVisitor: (typeObject: TypeObject) => Required<import("./types").ExpressionVisitor>;
+export declare const expressionContainsAggregation: (expression: Expression) => boolean;
+export declare const UNKNOWN_EXPRESSION_TYPE = "unknown";
+export declare const getExpressionType: ({ expression, typeObject, functionsMeta, onFieldNotFound, returnRefTypeInsteadOfId, }: {
+    expression: Expression;
+    typeObject: TypeObject;
+    functionsMeta: Record<string, {
+        overloads: {
+            "arg-types": string[];
+            "result-type": string;
+        }[];
+    }>;
+    onFieldNotFound: ({ currentTypeObject, fieldId }: {
+        currentTypeObject: TypeObject | null;
+        fieldId: string;
+    }) => {
+        currentTypeObject: TypeObject | null;
+    };
+    returnRefTypeInsteadOfId: boolean;
+}) => string | null;
+export { fieldAccessVisitorTypeAware };