@fibery/expression-utils 9.2.1 → 9.4.0

package/lib/src/visitors.js

@@ -0,0 +1,382 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldAccessVisitorTypeAware = exports.getExpressionType = exports.UNKNOWN_EXPRESSION_TYPE = exports.expressionContainsAggregation = exports.deleteExpressionsWithNotFoundFieldsVisitor = exports.replaceNamesWithIdsVisitor = exports.replaceIdsWithNamesVisitor = void 0;
+/* eslint-disable max-lines */
+const lodash_1 = __importDefault(require("lodash"));
+const fieldExpressionVisitorTypeAware_1 = require("./fieldExpressionVisitorTypeAware");
+Object.defineProperty(exports, "fieldAccessVisitorTypeAware", { enumerable: true, get: function () { return fieldExpressionVisitorTypeAware_1.fieldAccessVisitorTypeAware; } });
+const utils_1 = require("./utils");
+const defaultIdsWithNamesOnFieldNotFound = ({ fieldExpressionInNamesTerms, fieldId, }) => {
+    return {
+        currentTypeObject: null,
+        fieldExpressionInNamesTerms: [...fieldExpressionInNamesTerms, fieldId],
+    };
+};
+const visitFieldExpressionForReplaceIdsWithNamesVisitor = ({ expression, typeObject, onFieldNotFound, }) => expression.reduce(({ currentTypeObject, fieldExpressionInNamesTerms }, fieldId) => {
+    if (currentTypeObject &&
+        (0, utils_1.isMultiFieldAccess)(fieldId) &&
+        Object.hasOwn(currentTypeObject.fieldObjectsById, fieldId[0])) {
+        const typeId = fieldId[1];
+        const fieldObject = currentTypeObject.fieldObjectsById[fieldId[0]];
+        const nextTypeObject = fieldObject.multiRelatedFieldObjects.find((f) => f.holderTypeObject.id === typeId)?.holderTypeObject;
+        if (!nextTypeObject) {
+            return onFieldNotFound({
+                currentTypeObject,
+                fieldExpressionInNamesTerms,
+                fieldId: fieldId,
+                expression,
+            });
+        }
+        return {
+            currentTypeObject: nextTypeObject,
+            fieldExpressionInNamesTerms: [
+                ...fieldExpressionInNamesTerms,
+                [fieldObject.name, nextTypeObject.name],
+            ],
+        };
+    }
+    else if (currentTypeObject && Object.hasOwn(currentTypeObject.fieldObjectsById, fieldId)) {
+        const fieldObject = currentTypeObject.fieldObjectsById[fieldId];
+        return {
+            currentTypeObject: fieldObject.typeObject,
+            fieldExpressionInNamesTerms: [...fieldExpressionInNamesTerms, fieldObject.name],
+        };
+    }
+    else {
+        return onFieldNotFound({
+            currentTypeObject,
+            fieldExpressionInNamesTerms,
+            fieldId: fieldId,
+            expression,
+        });
+    }
+}, {
+    currentTypeObject: typeObject,
+    fieldExpressionInNamesTerms: [],
+});
+const fieldExpressionVisitor = (typeObject, visitFieldExpression, replacedExpressionKey = "replacedExpression") => {
+    const visitor = (0, utils_1.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" can be in vector shape, it's not reflected in types right now.
+                        "q/select": lodash_1.default.isPlainObject(selectExpression)
+                            ? lodash_1.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");
+};
+exports.replaceIdsWithNamesVisitor = replaceIdsWithNamesVisitor;
+const defaultNamesWithIdsOnFieldNotFound = ({ fieldExpressionInIdsTerms, field, }) => {
+    return {
+        currentTypeObject: null,
+        fieldExpressionInIdsTerms: [...fieldExpressionInIdsTerms, field],
+    };
+};
+const visitFieldExpressionForReplaceNamesWithIdsVisitor = ({ expression, typeObject, onFieldNotFound, }) => expression.reduce(({ currentTypeObject, fieldExpressionInIdsTerms }, field) => {
+    if (currentTypeObject &&
+        (0, utils_1.isMultiFieldAccess)(field) &&
+        Object.hasOwn(currentTypeObject.fieldObjectsByName, field[0])) {
+        const type = field[1];
+        const fieldObject = currentTypeObject.fieldObjectsByName[field[0]];
+        const nextTypeObject = fieldObject.multiRelatedFieldObjects.find((f) => f.holderType === type)?.holderTypeObject;
+        if (!nextTypeObject) {
+            return onFieldNotFound({
+                currentTypeObject,
+                fieldExpressionInIdsTerms,
+                field: field,
+                expression,
+            });
+        }
+        return {
+            currentTypeObject: nextTypeObject,
+            fieldExpressionInIdsTerms: [...fieldExpressionInIdsTerms, [fieldObject.id, nextTypeObject.id]],
+        };
+    }
+    else if (currentTypeObject && Object.hasOwn(currentTypeObject.fieldObjectsByName, field)) {
+        const fieldObject = currentTypeObject.fieldObjectsByName[field];
+        return {
+            currentTypeObject: fieldObject.typeObject,
+            fieldExpressionInIdsTerms: [...fieldExpressionInIdsTerms, fieldObject.id],
+        };
+    }
+    else {
+        return onFieldNotFound({ currentTypeObject, fieldExpressionInIdsTerms, field: field, expression });
+    }
+}, {
+    currentTypeObject: typeObject,
+    fieldExpressionInIdsTerms: [],
+});
+const replaceNamesWithIdsVisitor = (typeObject, onFieldNotFound = defaultNamesWithIdsOnFieldNotFound) => {
+    return fieldExpressionVisitor(typeObject, (typeObject, expression) => visitFieldExpressionForReplaceNamesWithIdsVisitor({
+        expression,
+        typeObject,
+        onFieldNotFound,
+    }), "fieldExpressionInIdsTerms");
+};
+exports.replaceNamesWithIdsVisitor = replaceNamesWithIdsVisitor;
+const deleteExpressionsWithNotFoundFieldsVisitor = (typeObject) => {
+    const visitor = (0, utils_1.createExpressionVisitor)({
+        visitFunctionCallExpression: ([fnName, ...args]) => {
+            const argsNew = args.map((x) => visitor.visitExpression(x)).filter(Boolean);
+            if (utils_1.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 &&
+                    (0, utils_1.isMultiFieldAccess)(field) &&
+                    Object.hasOwn(holderTypeObject.fieldObjectsByName, field[0])) {
+                    const type = field[1];
+                    const fieldObject = holderTypeObject.fieldObjectsByName[field[0]];
+                    const nextTypeObject = fieldObject.multiRelatedFieldObjects.find((f) => f.holderType === type)?.holderTypeObject;
+                    if (!nextTypeObject) {
+                        return null;
+                    }
+                    return nextTypeObject;
+                }
+                else if (holderTypeObject && Object.hasOwn(holderTypeObject.fieldObjectsByName, 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 && Object.hasOwn(typeObject.fieldObjectsByName, field)
+                ? typeObject.fieldObjectsByName[field].typeObject
+                : null, typeObject);
+            if (subQueryTypeObject) {
+                const subQueryVisitor = (0, exports.deleteExpressionsWithNotFoundFieldsVisitor)(subQueryTypeObject);
+                const subQueryExpressionNew = lodash_1.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;
+};
+exports.deleteExpressionsWithNotFoundFieldsVisitor = deleteExpressionsWithNotFoundFieldsVisitor;
+const expressionContainsAggregation = (expression) => {
+    let result = false;
+    const visitor = (0, utils_1.createExpressionVisitor)({
+        visitQueryExpression: (queryExpression) => {
+            const { "q/select": selectExpression } = queryExpression;
+            //"select" can have a non-object form, which is not reflected in types right now.
+            if ((0, utils_1.isCollectionFunctionExpression)(selectExpression)) {
+                result = true;
+            }
+        },
+        visitFunctionCallExpression: (expression, visitorDefault) => {
+            if (utils_1.firstLastFunctions.has(expression[0])) {
+                result = true;
+            }
+            else {
+                visitorDefault.visitFunctionCallExpression(expression);
+            }
+        },
+    });
+    visitor.visitExpression(expression);
+    return result;
+};
+exports.expressionContainsAggregation = expressionContainsAggregation;
+const defaultGetExpressionTypeOnFieldNotFound = () => {
+    return { currentTypeObject: null };
+};
+const getFieldAccessExpressionTypeObject = ({ expression, typeObject, onFieldNotFound, returnRefTypeInsteadOfId, }) => {
+    const reduced = expression.reduce(({ currentTypeObject }, fieldId, index) => {
+        if (currentTypeObject &&
+            (0, utils_1.isMultiFieldAccess)(fieldId) &&
+            Object.hasOwn(currentTypeObject.fieldObjectsById, fieldId[0])) {
+            const typeId = fieldId[1];
+            const fieldObject = currentTypeObject.fieldObjectsById[fieldId[0]];
+            const nextTypeObject = fieldObject.multiRelatedFieldObjects.find((f) => f.holderTypeObject.id === typeId)?.holderTypeObject;
+            if (!nextTypeObject) {
+                return onFieldNotFound({ currentTypeObject, fieldId: fieldId });
+            }
+            return {
+                currentTypeObject: nextTypeObject,
+            };
+        }
+        else if (currentTypeObject && Object.hasOwn(currentTypeObject.fieldObjectsById, 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: fieldId });
+        }
+    }, { currentTypeObject: typeObject });
+    return reduced.currentTypeObject;
+};
+exports.UNKNOWN_EXPRESSION_TYPE = "unknown";
+const getExpressionTypeInternal = ({ expression, typeObject, functionsMeta, onFieldNotFound, returnRefTypeInsteadOfId, }) => {
+    let result = null;
+    const visitor = (0, utils_1.createExpressionVisitor)({
+        visitVariableExpression: function () {
+            result = exports.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: utils_1.firstLastFunctions.has(fnName) || fnName === "q/if" || fnName === "q/if-null"
+                    ? returnRefTypeInsteadOfId
+                    : false,
+            }));
+            if (utils_1.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) => {
+                    // We want to check that the type is not primitive here. Should be improved!
+                    return !x?.startsWith("fibery");
+                })) {
+                //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] === exports.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 (lodash_1.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,
+    });
+};
+exports.getExpressionType = getExpressionType;