@fibery/expression-utils 9.4.1 → 9.5.0

package/lib/src/filter-expression/pattern-match.d.ts

@@ -0,0 +1,17 @@
+import { $TSFixMe } from "../tsfixme";
+import { TypeObject } from "@fibery/schema";
+import { Expression, Select, SubQuery } from "../types";
+type ExpressionToMatch = SubQuery | Select | Expression | string | undefined;
+export type PatternMatches = {
+    matchType: ":expression-match-type/param";
+    value: $TSFixMe;
+} | {
+    matchType: ":expression-match-type/expression";
+    value: Expression;
+};
+export type PatternMatchResult = {
+    matchSuccess: boolean;
+    matches: Array<PatternMatches>;
+};
+export declare const doPatternMatch: (expression: ExpressionToMatch, params: $TSFixMe, pattern: $TSFixMe, typeObject: TypeObject) => PatternMatchResult;
+export {};

package/lib/src/filter-expression/pattern-match.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doPatternMatch = void 0;
+const utils_1 = require("../utils");
+const lodash_1 = __importDefault(require("lodash"));
+const matchSelectClause = (selectExpression, params, selectPattern, typeObject) => {
+    if (selectExpression && lodash_1.default.isPlainObject(selectExpression) && lodash_1.default.isPlainObject(selectPattern)) {
+        if (Object.keys(selectExpression).length !== Object.keys(selectPattern).length) {
+            return { matchSuccess: false, matches: [] };
+        }
+        return Object.entries(selectExpression).reduce((acc, [key, value]) => {
+            const { matchSuccess, matches } = (0, exports.doPatternMatch)(value, params, selectPattern[key], typeObject);
+            return {
+                matchSuccess: acc.matchSuccess && matchSuccess,
+                matches: acc.matches.concat(matches),
+            };
+        }, { matchSuccess: true, matches: [] });
+    }
+    else {
+        return (0, exports.doPatternMatch)(selectExpression, params, selectPattern, typeObject);
+    }
+};
+const matchQuery = (expression, params, pattern, typeObject) => {
+    const fromExpression = expression["q/from"];
+    if (!(0, utils_1.isFieldExpressionValid)({ typeObject, expression: fromExpression })) {
+        return {
+            matchSuccess: false,
+            matches: [],
+        };
+    }
+    const fromTypeObject = (0, utils_1.getFieldObjectByFieldExpression)({
+        typeObject,
+        expression: fromExpression,
+    }).typeObject;
+    const { matchSuccess: fromMatchSuccess, matches: fromMatches } = (0, exports.doPatternMatch)(fromExpression, params, pattern["q/from"], typeObject);
+    const { matchSuccess: selectMatchSuccess, matches: selectMatches } = matchSelectClause(expression["q/select"], params, pattern["q/select"], fromTypeObject);
+    const limitMatchSuccess = pattern["q/limit"] === expression["q/limit"];
+    const { matchSuccess: whereMatchSuccess, matches: whereMatches } = (0, exports.doPatternMatch)(expression["q/where"], params, pattern["q/where"], fromTypeObject);
+    return {
+        matchSuccess: fromMatchSuccess && selectMatchSuccess && limitMatchSuccess && whereMatchSuccess,
+        matches: [...fromMatches, ...whereMatches, ...selectMatches],
+    };
+};
+const matchExpression = (expressionPlaceholder, expression, typeObject) => {
+    if (!lodash_1.default.isString(expression) && !lodash_1.default.isArray(expression)) {
+        return { matchSuccess: false, matches: [] };
+    }
+    return {
+        matchSuccess: Boolean(expressionPlaceholder.matchFn(expression, typeObject)),
+        matches: [
+            {
+                matchType: ":expression-match-type/expression",
+                value: lodash_1.default.isString(expression) ? [expression] : expression,
+            },
+        ],
+    };
+};
+const doPatternMatch = (expression, params, pattern, typeObject) => {
+    if (expression === pattern) {
+        return { matchSuccess: true, matches: [] };
+    }
+    if (pattern.id === ":expression-pattern/expression-placeholder") {
+        return matchExpression(pattern, expression, typeObject);
+    }
+    if (expression && !lodash_1.default.isString(expression) && Object.hasOwn(expression, "q/from") && pattern["q/from"]) {
+        return matchQuery(expression, params, pattern, typeObject);
+    }
+    if (!(lodash_1.default.isArray(expression) && lodash_1.default.isArray(pattern))) {
+        return { matchSuccess: false, matches: [] };
+    }
+    const zipped = lodash_1.default.zipWith(expression, pattern, (expressionNode, patternNode) => {
+        if (!patternNode) {
+            return { matchSuccess: false, matches: [] };
+        }
+        else if (lodash_1.default.isString(patternNode)) {
+            return { matchSuccess: expressionNode === patternNode, matches: [] };
+        }
+        else if (lodash_1.default.isArray(patternNode)) {
+            return (0, exports.doPatternMatch)(expressionNode, params, patternNode, typeObject);
+        }
+        else if (patternNode.id === ":expression-pattern/expression-placeholder") {
+            return matchExpression(patternNode, expressionNode, typeObject);
+        }
+        else if (patternNode.id === ":expression-pattern/param-placeholder" ||
+            patternNode.id === ":expression-pattern/constant-placeholder") {
+            const shouldReturnValue = patternNode.id === ":expression-pattern/param-placeholder";
+            if (lodash_1.default.isString(expressionNode) && (0, utils_1.isVariableExpression)(expressionNode)) {
+                return {
+                    matchSuccess: patternNode.matchFn(params[expressionNode]),
+                    matches: shouldReturnValue
+                        ? [
+                            {
+                                matchType: ":expression-match-type/param",
+                                value: params[expressionNode],
+                            },
+                        ]
+                        : [],
+                };
+            }
+            else {
+                return {
+                    matchSuccess: patternNode.matchFn(expressionNode),
+                    matches: shouldReturnValue
+                        ? [
+                            {
+                                matchType: ":expression-match-type/param",
+                                value: expressionNode,
+                            },
+                        ]
+                        : [],
+                };
+            }
+        }
+        else if (patternNode["q/from"] && lodash_1.default.isObject(expressionNode) && "q/from" in expressionNode) {
+            return matchQuery(expressionNode, params, patternNode, typeObject);
+        }
+        else {
+            return { matchSuccess: false, matches: [] };
+        }
+    });
+    return zipped.reduce(({ matchSuccess: accMatchSuccess, matches: accMatches }, { matchSuccess, matches }) => {
+        if (!matchSuccess || !accMatchSuccess) {
+            return { matchSuccess: false, matches: [] };
+        }
+        return {
+            matchSuccess: true,
+            matches: matches ? [...accMatches, ...matches] : accMatches,
+        };
+    }, { matchSuccess: true, matches: [] });
+};
+exports.doPatternMatch = doPatternMatch;

package/lib/src/filter-expression/patternMatchPlaceholders.d.ts

@@ -0,0 +1,59 @@
+export namespace anyExpressionPlaceholder {
+    let id: string;
+    function matchFn(): boolean;
+}
+export namespace idFieldPlaceholder {
+    let id_1: string;
+    export { id_1 as id };
+    export { matchFn };
+}
+export namespace basicFieldPlaceholder { }
+export namespace textFieldPlaceholder {
+    let id_2: string;
+    export { id_2 as id };
+    export function matchFn_2(expression: any, typeObject: any): any;
+    export { matchFn_2 as matchFn };
+}
+export namespace numberFieldPlaceholder { }
+export namespace dateFieldPlaceholder { }
+export namespace dateTimeFieldPlaceholder { }
+export namespace boolFieldPlaceholder { }
+export namespace locationFieldPlaceholder { }
+export namespace referenceCollectionFieldPlaceholder { }
+export namespace referenceExpressionPlaceholder {
+    let id_3: string;
+    export { id_3 as id };
+    export { matchFn };
+}
+export namespace referenceCollectionExpressionPlaceholder { }
+export namespace dateOrDateRangeExpressionPlaceholder {
+    let id_4: string;
+    export { id_4 as id };
+    export function matchFn_4(expression: any, typeObject: any): any;
+    export { matchFn_4 as matchFn };
+}
+export namespace dateTimeOrDateTimeRangeExpressionPlaceholder { }
+export namespace anyDateExpressionPlaceholder {
+    let id_5: string;
+    export { id_5 as id };
+    export function matchFn_5(expression: any, typeObject: any): any;
+    export { matchFn_5 as matchFn };
+}
+export function getParamPlaceholder(matchFn?: (_x: any) => boolean): {
+    id: string;
+    matchFn: (_x: any) => boolean;
+};
+export function getConstantPlaceholder(value: any): {
+    id: string;
+    value: any;
+    matchFn: (x: any) => boolean;
+};
+export namespace referenceTitleOrRankExpressionPlaceholder {
+    let id_6: string;
+    export { id_6 as id };
+    export function matchFn_6(expression: any, typeObject: any): boolean;
+    export { matchFn_6 as matchFn };
+}
+declare function matchFn_1(expression: any, typeObject: any): any;
+declare function matchFn_3(expression: any, typeObject: any): boolean;
+export {};

package/lib/src/filter-expression/patternMatchPlaceholders.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referenceTitleOrRankExpressionPlaceholder = exports.getConstantPlaceholder = exports.getParamPlaceholder = exports.anyDateExpressionPlaceholder = exports.dateTimeOrDateTimeRangeExpressionPlaceholder = exports.dateOrDateRangeExpressionPlaceholder = exports.referenceCollectionExpressionPlaceholder = exports.referenceExpressionPlaceholder = exports.referenceCollectionFieldPlaceholder = exports.locationFieldPlaceholder = exports.boolFieldPlaceholder = exports.dateTimeFieldPlaceholder = exports.dateFieldPlaceholder = exports.numberFieldPlaceholder = exports.textFieldPlaceholder = exports.basicFieldPlaceholder = exports.idFieldPlaceholder = exports.anyExpressionPlaceholder = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const utils_1 = require("../utils");
+const getFieldPlaceholder = (fieldObjectMatchFn) => {
+    const matchFn = (expression, typeObject) => {
+        if (lodash_1.default.isString(expression)) {
+            return typeObject.fieldObjectsByName.hasOwnProperty(expression)
+                ? fieldObjectMatchFn(typeObject.fieldObjectsByName[expression], [typeObject.fieldObjectsByName[expression]])
+                : false;
+        }
+        if (!(0, utils_1.isFieldExpression)(expression)) {
+            return false;
+        }
+        if (!(0, utils_1.isFieldExpressionValid)({ typeObject, expression })) {
+            return false;
+        }
+        if (expression.length === 0) {
+            return false;
+        }
+        const fieldObjects = (0, utils_1.getFieldObjectsByFieldExpression)({
+            typeObject,
+            expression,
+        });
+        if (fieldObjects.length > 1 && fieldObjects[fieldObjects.length - 2].type === "Collaboration~Documents/Document") {
+            return fieldObjectMatchFn(fieldObjects[fieldObjects.length - 1], fieldObjects);
+        }
+        return fieldObjectMatchFn(fieldObjects[fieldObjects.length - 1], fieldObjects);
+    };
+    return { id: ":expression-pattern/expression-placeholder", matchFn };
+};
+const getReferenceExpressionPlaceholder = (isReferenceCollection) => {
+    const matchFn = (expression, typeObject) => {
+        if (!(0, utils_1.isFieldExpression)(expression)) {
+            return false;
+        }
+        if (!(0, utils_1.isFieldExpressionValid)({ typeObject, expression })) {
+            return false;
+        }
+        if (expression.length < 2) {
+            return false;
+        }
+        const fieldObjects = (0, utils_1.getFieldObjectsByFieldExpression)({
+            typeObject,
+            expression,
+        });
+        if (fieldObjects.length < 2) {
+            return false;
+        }
+        const matchesReferenceKind = isReferenceCollection
+            ? fieldObjects[fieldObjects.length - 2].isCollection
+            : !fieldObjects[fieldObjects.length - 2].isCollection;
+        return (!fieldObjects[fieldObjects.length - 2].typeObject.isPrimitive &&
+            matchesReferenceKind &&
+            fieldObjects[fieldObjects.length - 1].isId);
+    };
+    return { id: ":expression-pattern/expression-placeholder", matchFn };
+};
+const getDateExpressionPlaceholder = (dateFieldMatchFn) => ({
+    id: ":expression-pattern/expression-placeholder",
+    matchFn: (expression, typeObject) => {
+        return (0, utils_1.isDateRangeFunctionExpression)(expression)
+            ? dateFieldMatchFn(expression[1], typeObject)
+            : dateFieldMatchFn(expression, typeObject);
+    },
+});
+exports.anyExpressionPlaceholder = {
+    id: ":expression-pattern/expression-placeholder",
+    matchFn: () => true,
+};
+exports.idFieldPlaceholder = getFieldPlaceholder((fieldObject, fieldObjects) => fieldObjects.length === 1 && fieldObject.isId);
+exports.basicFieldPlaceholder = getFieldPlaceholder((fieldObject) => {
+    return fieldObject.typeObject.isPrimitive === true;
+});
+exports.textFieldPlaceholder = {
+    id: ":expression-pattern/expression-placeholder",
+    matchFn: (expression, typeObject) => {
+        const isTextFieldObjectExpression = getFieldPlaceholder((fieldObject) => fieldObject.type === "fibery/text" || fieldObject.type === "fibery/email" || fieldObject.type === "fibery/url").matchFn(expression, typeObject);
+        const isSnippetExpression = lodash_1.default.last(expression) === "Collaboration~Documents/Snippet";
+        return isTextFieldObjectExpression || isSnippetExpression;
+    },
+};
+exports.numberFieldPlaceholder = getFieldPlaceholder((fieldObject) => fieldObject.type === "fibery/int" || fieldObject.type === "fibery/decimal");
+exports.dateFieldPlaceholder = getFieldPlaceholder((fieldObject) => {
+    return (0, utils_1.isDateType)(fieldObject.type);
+});
+exports.dateTimeFieldPlaceholder = getFieldPlaceholder((fieldObject) => {
+    return (0, utils_1.isDateTimeType)(fieldObject.type);
+});
+exports.boolFieldPlaceholder = getFieldPlaceholder((fieldObject) => fieldObject.type === "fibery/bool");
+exports.locationFieldPlaceholder = getFieldPlaceholder((fieldObject) => fieldObject.type === "fibery/location");
+exports.referenceCollectionFieldPlaceholder = getFieldPlaceholder((fieldObject) => {
+    return !fieldObject.typeObject.isPrimitive && fieldObject.isCollection;
+});
+exports.referenceExpressionPlaceholder = getReferenceExpressionPlaceholder(false);
+exports.referenceCollectionExpressionPlaceholder = getReferenceExpressionPlaceholder(true);
+exports.dateOrDateRangeExpressionPlaceholder = getDateExpressionPlaceholder(exports.dateFieldPlaceholder.matchFn);
+exports.dateTimeOrDateTimeRangeExpressionPlaceholder = getDateExpressionPlaceholder(exports.dateTimeFieldPlaceholder.matchFn);
+exports.anyDateExpressionPlaceholder = {
+    id: ":expression-pattern/expression-placeholder",
+    matchFn: (expression, typeObject) => exports.dateOrDateRangeExpressionPlaceholder.matchFn(expression, typeObject) ||
+        exports.dateTimeOrDateTimeRangeExpressionPlaceholder.matchFn(expression, typeObject),
+};
+const getParamPlaceholder = (matchFn = (_x) => true) => ({
+    id: ":expression-pattern/param-placeholder",
+    matchFn,
+});
+exports.getParamPlaceholder = getParamPlaceholder;
+const getConstantPlaceholder = (value) => ({
+    id: ":expression-pattern/constant-placeholder",
+    value,
+    matchFn: (x) => x === value,
+});
+exports.getConstantPlaceholder = getConstantPlaceholder;
+// Infinite relation path not supported for Sorts right now.
+exports.referenceTitleOrRankExpressionPlaceholder = {
+    id: ":expression-pattern/expression-placeholder",
+    matchFn: (expression, typeObject) => {
+        if (!(0, utils_1.isFieldExpression)(expression)) {
+            return false;
+        }
+        if (!(0, utils_1.isFieldExpressionValid)({ typeObject, expression })) {
+            return false;
+        }
+        if (expression.length !== 2) {
+            return false;
+        }
+        const fieldObjects = (0, utils_1.getFieldObjectsByFieldExpression)({
+            typeObject,
+            expression,
+        });
+        if (fieldObjects.length !== 2) {
+            return false;
+        }
+        return (!fieldObjects[0].typeObject.isPrimitive &&
+            !fieldObjects[0].isCollection &&
+            (fieldObjects[1].isTitle || fieldObjects[1] === fieldObjects[1].holderTypeObject.rankFieldObject));
+    },
+};

package/lib/src/filter-expression/patternToExpression.d.ts

@@ -0,0 +1,4 @@
+export function convertToExpression(pattern: any, filterExpression: any, value: any, getNextParamName: any): {
+    expression: any;
+    params: {};
+};

package/lib/src/filter-expression/patternToExpression.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToExpression = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const params_placeholders_1 = require("../params-placeholders");
+const convertToExpression = (pattern, filterExpression, value, getNextParamName) => {
+    let params = {};
+    const expression = pattern.map((patternNode) => {
+        if (patternNode.id === ":expression-pattern/expression-placeholder") {
+            return filterExpression;
+        }
+        else if (patternNode.id === ":expression-pattern/param-placeholder") {
+            const isPlaceholder = params_placeholders_1.paramsPlaceholdersLookup[value] || (0, params_placeholders_1.parseRelativeDatePlaceholder)(value) !== null;
+            const paramName = isPlaceholder ? value : getNextParamName();
+            params[paramName] = value;
+            return paramName;
+        }
+        else if (patternNode.id === ":expression-pattern/constant-placeholder") {
+            const paramName = getNextParamName();
+            params[paramName] = patternNode.value;
+            return paramName;
+        }
+        else if (lodash_1.default.isArray(patternNode)) {
+            const { expression, params: innerParams } = (0, exports.convertToExpression)(patternNode, filterExpression, value, getNextParamName);
+            params = { ...params, ...innerParams };
+            return expression;
+        }
+        else if (patternNode["q/from"]) {
+            // Note: very naive implementation here
+            const { expression: selectExpression, params: selectParams } = (0, exports.convertToExpression)(patternNode["q/select"], filterExpression, value, getNextParamName);
+            const { expression: whereExpression, params: whereParams } = (0, exports.convertToExpression)(patternNode["q/where"], filterExpression, value, getNextParamName);
+            params = { ...params, ...selectParams, ...whereParams };
+            return {
+                "q/from": filterExpression,
+                "q/select": selectExpression,
+                "q/where": whereExpression,
+                "q/limit": patternNode["q/limit"],
+            };
+        }
+        else {
+            return patternNode;
+        }
+    });
+    return { expression, params };
+};
+exports.convertToExpression = convertToExpression;

package/lib/src/filter-expression/types.d.ts

@@ -0,0 +1,24 @@
+import { $TSFixMe } from "../tsfixme";
+import { TypeObject } from "@fibery/schema";
+import { Expression } from "../types";
+export type Operator = {
+    id: string;
+    type: string;
+    title: string;
+    pattern?: $TSFixMe;
+    customMatch?: (where: Expression, params: $TSFixMe, typeObject: TypeObject) => {
+        matchSuccess: boolean;
+        value?: $TSFixMe;
+        expression?: Expression;
+    };
+    customConvertToWhereExpression?: (expression: $TSFixMe, value: $TSFixMe, getNextParamName: $TSFixMe) => $TSFixMe;
+};
+export type ExpressionToFilterBy = {
+    title?: string;
+    icon?: string;
+    itemExpressions: Array<{
+        expression: Expression;
+        type: string;
+    }>;
+    calculateRelationFieldExpressions?: () => ExpressionToFilterBy[];
+};

package/lib/src/filter-expression/types.js

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

package/lib/src/utils.d.ts

@@ -11,6 +11,8 @@ 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 isDateType: (type: string) => type is "fibery/date" | "fibery/date-range";
+export declare const isDateTimeType: (type: string) => type is "fibery/date-time" | "fibery/date-time-range";
 export declare const isFunctionCallExpression: (expression: Expression | SubQuery | OrderBy | string) => boolean;
 export declare const fromRootKeyword = "q/from-root";
 export declare const isFromRootFieldExpression: (expression: Expression | SubQuery | OrderBy | string) => boolean;
@@ -28,6 +30,10 @@ export declare const getFieldObjectsByFieldExpression: ({ typeObject, expression
     typeObject: TypeObject;
     expression: Expression;
 }) => FieldObject[];
+export declare const isFieldExpressionValid: ({ typeObject, expression }: {
+    typeObject: TypeObject;
+    expression: Expression;
+}) => boolean;
 export declare const getFieldObjectByFieldExpression: (x: {
     typeObject: TypeObject;
     expression: Expression;

package/lib/src/utils.js

@@ -3,7 +3,7 @@ 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;
+exports.createExpressionVisitor = exports.extractFieldExpressions = exports.getFieldObjects = exports.getFieldObjectByFieldExpression = exports.isFieldExpressionValid = 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.isDateTimeType = exports.isDateType = 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");
@@ -59,6 +59,10 @@ const binaryOperations = new Set([
 exports.logicalOperators = new Set(["and", "or", "q/and", "q/or"]);
 exports.relationalOperators = new Set(["=", "!=", "<", ">", "<=", ">="]);
 exports.mathOperators = new Set(["+", "-", "*", "/", "q/+", "q/-", "q/concat"]);
+const isDateType = (type) => type === "fibery/date" || type === "fibery/date-range";
+exports.isDateType = isDateType;
+const isDateTimeType = (type) => type === "fibery/date-time" || type === "fibery/date-time-range";
+exports.isDateTimeType = isDateTimeType;
 const isFunctionCallExpression = (expression) => {
     if (!Array.isArray(expression)) {
         return false;
@@ -180,6 +184,35 @@ const getFieldObjectsByFieldExpression = ({ typeObject, expression, }) => {
     return fieldObjects;
 };
 exports.getFieldObjectsByFieldExpression = getFieldObjectsByFieldExpression;
+const isFieldExpressionValid = ({ typeObject, expression }) => {
+    (0, exports.assertIsValidExpression)(expression);
+    return Boolean(expression.reduce((typeObject, fieldOrMultiFieldAccess) => {
+        if (!typeObject) {
+            return false;
+        }
+        if ((0, exports.isMultiFieldAccess)(fieldOrMultiFieldAccess)) {
+            const [multiField, type] = fieldOrMultiFieldAccess;
+            if (!Object.hasOwn(typeObject.fieldObjectsByName, multiField)) {
+                return false;
+            }
+            const fieldObject = typeObject.fieldObjectsByName[multiField];
+            const foundField = fieldObject.multiRelatedFieldObjects.find((f) => f.holderType === type);
+            if (!foundField) {
+                return false;
+            }
+            return foundField.holderTypeObject;
+        }
+        else {
+            if (Object.hasOwn(typeObject.fieldObjectsByName, fieldOrMultiFieldAccess)) {
+                return typeObject.fieldObjectsByName[fieldOrMultiFieldAccess].typeObject;
+            }
+            else {
+                return false;
+            }
+        }
+    }, typeObject));
+};
+exports.isFieldExpressionValid = isFieldExpressionValid;
 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;

package/lib/src/visitors.d.ts

@@ -1,6 +1,6 @@
 import { fieldAccessVisitorTypeAware } from "./fieldExpressionVisitorTypeAware";
 import { TypeObject } from "@fibery/schema";
-import { Expression } from "./types";
+import { Expression, SubQuery } from "./types";
 type OnFieldNotFoundInNamesTerms = (params: {
     fieldExpressionInNamesTerms: Expression;
     fieldId: string;
@@ -25,7 +25,7 @@ export declare const deleteExpressionsWithNotFoundFieldsVisitor: (typeObject: Ty
 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;
+    expression: Expression | SubQuery;
     typeObject: TypeObject;
     functionsMeta: Record<string, {
         overloads: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fibery/expression-utils",
-  "version": "9.4.1",
+  "version": "9.5.0",
   "description": "utils for working with fibery api expressions",
   "main": "./lib/index.js",
   "files": [
@@ -17,12 +17,18 @@
     "./src/utils": "./src/utils.ts",
     "./src/visitors": "./src/visitors.ts",
     "./src/params-placeholders": "./src/params-placeholders.ts",
-    "./src/context-variables": "./src/context-variables.ts"
+    "./src/context-variables": "./src/context-variables.ts",
+    "./src/filter-expression": "./src/filter-expression/index.ts",
+    "./src/filter-expression/pattern-match": "./src/filter-expression/pattern-match.ts",
+    "./src/filter-expression/operators": "./src/filter-expression/operators.js",
+    "./src/filter-expression/patternMatchPlaceholders": "./src/filter-expression/patternMatchPlaceholders.js",
+    "./src/filter-expression/patternToExpression": "./src/filter-expression/patternToExpression.js"
   },
   "private": false,
   "dependencies": {
     "lodash": "4.17.21",
     "moment": "2.29.4",
+    "uuid": "11.1.0",
     "@fibery/helpers": "1.3.3"
   },
   "devDependencies": {