@fibery/expression-utils 9.4.1 → 9.5.1

package/lib/index.d.ts

@@ -2,5 +2,21 @@ import * as paramsPlaceholders from "./src/params-placeholders";
 import * as utils from "./src/utils";
 import * as visitors from "./src/visitors";
 import * as contextVariables from "./src/context-variables";
-export { utils, visitors, paramsPlaceholders, contextVariables };
+import * as operators from "./src/filter-expression/operators";
+declare const filterExpression: {
+    findMatchedFilter: (filterExpression: import("./src/types").Expression, params: import("./src/tsfixme").$TSFixMe, operators: Array<import("./src/filter-expression/types").Operator>, schema: import("@fibery/schema").Schema | null, type: string) => {
+        operator: import("./src/filter-expression/types").Operator;
+        value: any;
+        expression: import("./src/types").Expression | undefined;
+        type: string;
+        id: string;
+    } | null;
+    operators: typeof operators;
+    convertToExpression: (pattern: any, filterExpression: any, value: any, getNextParamName: any) => {
+        expression: any;
+        params: {};
+    };
+};
+export { utils, visitors, paramsPlaceholders, contextVariables, filterExpression };
 export type { Expression, OrderBy, Query, Select, SubQuery, ExpressionVisitor, ExpressionVisitorWithDefault, } from "./src/types";
+export type { Operator, ExpressionToFilterBy } from "./src/filter-expression/types";

package/lib/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.contextVariables = exports.paramsPlaceholders = exports.visitors = exports.utils = void 0;
+exports.filterExpression = exports.contextVariables = exports.paramsPlaceholders = exports.visitors = exports.utils = void 0;
 const paramsPlaceholders = __importStar(require("./src/params-placeholders"));
 exports.paramsPlaceholders = paramsPlaceholders;
 const utils = __importStar(require("./src/utils"));
@@ -42,3 +42,8 @@ const visitors = __importStar(require("./src/visitors"));
 exports.visitors = visitors;
 const contextVariables = __importStar(require("./src/context-variables"));
 exports.contextVariables = contextVariables;
+const filter_expression_1 = require("./src/filter-expression");
+const patternToExpression_1 = require("./src/filter-expression/patternToExpression");
+const operators = __importStar(require("./src/filter-expression/operators"));
+const filterExpression = { findMatchedFilter: filter_expression_1.findMatchedFilter, operators, convertToExpression: patternToExpression_1.convertToExpression };
+exports.filterExpression = filterExpression;

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

@@ -0,0 +1,11 @@
+import { Expression } from "../types";
+import { Operator } from "./types";
+import { Schema } from "@fibery/schema";
+import { $TSFixMe } from "../tsfixme";
+export declare const findMatchedFilter: (filterExpression: Expression, params: $TSFixMe, operators: Array<Operator>, schema: Schema | null, type: string) => {
+    operator: Operator;
+    value: any;
+    expression: Expression | undefined;
+    type: string;
+    id: string;
+} | null;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMatchedFilter = void 0;
+const pattern_match_1 = require("./pattern-match");
+const uuid_1 = require("uuid");
+const errors_1 = require("../errors");
+const findMatchedFilter = (filterExpression, params, operators, schema, type) => {
+    if (!schema || !Object.hasOwn(schema.typeObjectsByName, type)) {
+        return null;
+    }
+    const typeObject = schema.typeObjectsByName[type];
+    for (const operator of operators) {
+        if (operator.customMatch) {
+            const { matchSuccess, value, expression } = operator.customMatch(filterExpression, params, typeObject);
+            if (matchSuccess) {
+                return { operator, value, expression, type, id: (0, uuid_1.v4)() };
+            }
+        }
+        else {
+            const { matchSuccess, matches } = (0, pattern_match_1.doPatternMatch)(filterExpression, params, operator.pattern, typeObject);
+            if (matchSuccess) {
+                const paramMatches = matches.filter((x) => x.matchType === ":expression-match-type/param");
+                const expressionMatches = matches.filter((x) => x.matchType === ":expression-match-type/expression");
+                if (paramMatches.length > 1) {
+                    throw new errors_1.NotImplementedError(`Operator pattern with several param placeholders`);
+                }
+                if (expressionMatches.length > 1) {
+                    throw new errors_1.NotImplementedError(`Operator pattern with several expression placeholders`);
+                }
+                return {
+                    operator,
+                    value: paramMatches[0] && paramMatches[0].value,
+                    expression: expressionMatches[0].value,
+                    type,
+                    id: (0, uuid_1.v4)(),
+                };
+            }
+        }
+    }
+    return null;
+};
+exports.findMatchedFilter = findMatchedFilter;

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

@@ -0,0 +1,39 @@
+export function isDateTime(dateString: any): boolean;
+export function getCompareOperatorForDateTime(id: any, title: any, operator: any, compareByStartInterval: any): {
+    id: any;
+    title: any;
+    customMatch: (where: any, params: any, typeObject: any) => {
+        matchSuccess: true;
+        expression: any;
+        value: any;
+    } | {
+        matchSuccess: boolean;
+        expression?: undefined;
+        value?: undefined;
+    };
+    customConvertToWhereExpression: (expression: any, value: any, getNextParamName: any) => {
+        expression: any[];
+        params: {
+            [x: number]: any;
+        };
+    };
+    type: string;
+};
+export function getWithinOperatorCustomConvertFn(leftPartExcluded: any): (expression: any, value: any, getNextParamName: any) => {
+    expression: (string | any[])[];
+    params: {
+        [x: number]: any;
+    };
+};
+export function getWithinOperatorCustomMatchFn(fieldPlaceholder: any, leftPartExcluded: any): (where: any, params: any, typeObject: any) => {
+    matchSuccess: true;
+    expression: any;
+    value: {
+        withinRangeStart: any;
+        withinRangeEnd: any;
+    };
+} | {
+    matchSuccess: boolean;
+    expression?: undefined;
+    value?: undefined;
+};

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

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWithinOperatorCustomMatchFn = exports.getWithinOperatorCustomConvertFn = exports.getCompareOperatorForDateTime = exports.isDateTime = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const params_placeholders_1 = require("../params-placeholders");
+const pattern_match_1 = require("./pattern-match");
+const patternMatchPlaceholders_1 = require("./patternMatchPlaceholders");
+const isoDateTimeSample = "2018-05-30T07:57:45.190Z";
+const isoDateSample = "2018-05-30";
+// we're considering date as date-time here because of field-convert
+// from date to date-time, it changes field type but not touches constants in query-params
+// so to keep filters and color-coding working we treat date as date-time here
+// and later moment.js parses date string as date-time
+const isDateTime = (dateString) => dateString.length === isoDateTimeSample.length || dateString.length === isoDateSample.length;
+exports.isDateTime = isDateTime;
+const getCompareOperatorForDateTime = (id, title, operator, compareByStartInterval) => ({
+    id,
+    title,
+    customMatch: (where, params, typeObject) => {
+        const { matchSuccess, matches: [fieldMatch, paramMatch], } = (0, pattern_match_1.doPatternMatch)(where, params, [
+            operator,
+            patternMatchPlaceholders_1.dateTimeOrDateTimeRangeExpressionPlaceholder,
+            (0, patternMatchPlaceholders_1.getParamPlaceholder)((x) => {
+                return params_placeholders_1.paramsPlaceholdersLookup[x] || (lodash_1.default.isString(x) && (0, exports.isDateTime)(x)) || (0, params_placeholders_1.parseRelativeDatePlaceholder)(x);
+            }),
+        ], typeObject);
+        if (matchSuccess) {
+            const relativeDateInfo = (0, params_placeholders_1.parseRelativeDatePlaceholder)(paramMatch.value);
+            if (relativeDateInfo && relativeDateInfo.isStartOfInterval === compareByStartInterval) {
+                const value = (0, params_placeholders_1.toRelativeDatePlaceholder)({ ...relativeDateInfo, isStartOfInterval: undefined });
+                return { matchSuccess, expression: fieldMatch.value, value };
+            }
+            else if (params_placeholders_1.paramsPlaceholdersLookup[paramMatch.value]) {
+                const value = lodash_1.default.findKey(params_placeholders_1.dateToDateTimeIntervalLookup, (val) => compareByStartInterval ? val.start === paramMatch.value : val.end === paramMatch.value);
+                return { matchSuccess, expression: fieldMatch.value, value };
+            }
+            else {
+                return {
+                    matchSuccess,
+                    expression: fieldMatch.value,
+                    value: paramMatch.value,
+                };
+            }
+        }
+        return { matchSuccess: false };
+    },
+    customConvertToWhereExpression: (expression, value, getNextParamName) => {
+        const dateTimePlaceholders = params_placeholders_1.dateToDateTimeIntervalLookup[value];
+        let relativeDateInfo = null;
+        if (dateTimePlaceholders) {
+            const { start, end } = dateTimePlaceholders;
+            const intervalParamName = compareByStartInterval ? start : end;
+            return {
+                expression: [operator, expression, intervalParamName],
+                params: { [intervalParamName]: intervalParamName },
+            };
+        }
+        else if ((relativeDateInfo = (0, params_placeholders_1.parseRelativeDatePlaceholder)(value))) {
+            const paramName = (0, params_placeholders_1.toRelativeDatePlaceholder)({
+                ...relativeDateInfo,
+                isStartOfInterval: compareByStartInterval,
+                unitForStart: "day",
+            });
+            return {
+                expression: [operator, expression, paramName],
+                params: { [paramName]: paramName },
+            };
+        }
+        else {
+            const dateParamName = getNextParamName();
+            return {
+                expression: [operator, expression, dateParamName],
+                params: { [dateParamName]: value },
+            };
+        }
+    },
+    type: ":operator-type/binary",
+});
+exports.getCompareOperatorForDateTime = getCompareOperatorForDateTime;
+const getWithinRangeParam = ({ withinRangeValue, getNextParamName }) => {
+    // check that it's a relative date.
+    const withinRangeDateInfo = (0, params_placeholders_1.parseRelativeDatePlaceholder)(withinRangeValue);
+    if (withinRangeValue && withinRangeDateInfo) {
+        return { key: withinRangeValue, value: withinRangeValue };
+    }
+    else {
+        return { key: getNextParamName(), value: withinRangeValue };
+    }
+};
+const getWithinOperatorCustomConvertFn = (leftPartExcluded) => {
+    return (expression, value, getNextParamName) => {
+        const { key: startParamKey, value: startParamValue } = getWithinRangeParam({
+            withinRangeValue: value.withinRangeStart,
+            getNextParamName,
+            compareByStartInterval: true,
+        });
+        const { key: endParamKey, value: endParamValue } = getWithinRangeParam({
+            withinRangeValue: value.withinRangeEnd,
+            getNextParamName,
+            compareByStartInterval: false,
+        });
+        return {
+            // See https://the.fibery.io/SoftDev/bug/The-left-part-of-'is-within'-condition-is-not-included-into-filter-12264
+            expression: ["and", [leftPartExcluded ? ">" : ">=", expression, startParamKey], ["<=", expression, endParamKey]],
+            params: {
+                [startParamKey]: startParamValue,
+                [endParamKey]: endParamValue,
+            },
+        };
+    };
+};
+exports.getWithinOperatorCustomConvertFn = getWithinOperatorCustomConvertFn;
+const oldWithinPlaceholderToRelativeDateLookup = {
+    // we don't need $start-of-day at all for date. We can omit it, but it won't hurt in general.
+    [params_placeholders_1.weekAgoDateParamPlaceholder]: "$start-of-day-1-week-before-now-date",
+    [params_placeholders_1.monthAgoDateParamPlaceholder]: "$start-of-day-1-month-before-now-date",
+    [params_placeholders_1.yearAgoDateParamPlaceholder]: "$start-of-day-1-year-before-now-date",
+    [params_placeholders_1.weekFromNowDateParamPlaceholder]: "$start-of-day-1-week-after-now-date",
+    [params_placeholders_1.monthFromNowDateParamPlaceholder]: "$start-of-day-1-month-after-now-date",
+    [params_placeholders_1.yearFromNowDateParamPlaceholder]: "$start-of-day-1-year-after-now-date",
+    [params_placeholders_1.todayDateParamPlaceholder]: "$end-of-day-0-day-before-now-date",
+    [params_placeholders_1.weekAgoStartDateTimeParamPlaceholder]: "$start-of-day-1-week-before-now-date-time",
+    [params_placeholders_1.monthAgoStartDateTimeParamPlaceholder]: "$start-of-day-1-month-before-now-date-time",
+    [params_placeholders_1.yearAgoStartDateTimeParamPlaceholder]: "$start-of-day-1-year-before-now-date-time",
+    [params_placeholders_1.weekFromNowEndDateTimeParamPlaceholder]: "$start-of-day-1-week-after-now-date-time",
+    [params_placeholders_1.monthFromNowEndDateTimeParamPlaceholder]: "$start-of-day-1-month-after-now-date-time",
+    [params_placeholders_1.yearFromNowEndDateTimeParamPlaceholder]: "$start-of-day-1-year-after-now-date-time",
+    [params_placeholders_1.todayEndDateTimeParamPlaceholder]: "$end-of-day-0-day-before-now-date-time",
+};
+const getWithinRangeValue = (paramMatchValue) => {
+    if (Object.hasOwn(oldWithinPlaceholderToRelativeDateLookup, paramMatchValue)) {
+        return oldWithinPlaceholderToRelativeDateLookup[paramMatchValue];
+    }
+    else {
+        return paramMatchValue;
+    }
+};
+const matchWithinOperator = (pattern, where, params, typeObject) => {
+    const { matchSuccess, matches: [firstFieldMatch, firstParamMatch, secondFieldMatch, secondParamMatch], } = (0, pattern_match_1.doPatternMatch)(where, params, pattern, typeObject);
+    if (matchSuccess && lodash_1.default.isEqual(firstFieldMatch.value, secondFieldMatch.value)) {
+        return {
+            matchSuccess,
+            expression: firstFieldMatch.value,
+            value: {
+                withinRangeStart: getWithinRangeValue(firstParamMatch.value),
+                withinRangeEnd: getWithinRangeValue(secondParamMatch.value),
+            },
+        };
+    }
+    return { matchSuccess: false };
+};
+const getWithinOperatorCustomMatchFn = (fieldPlaceholder, leftPartExcluded) => {
+    return (where, params, typeObject) => {
+        const match = matchWithinOperator([
+            "and",
+            [">", fieldPlaceholder, (0, patternMatchPlaceholders_1.getParamPlaceholder)((x) => x !== null)],
+            ["<=", fieldPlaceholder, (0, patternMatchPlaceholders_1.getParamPlaceholder)((x) => x !== null)],
+        ], where, params, typeObject);
+        if (!match.matchSuccess && !leftPartExcluded) {
+            // see https://the.fibery.io/SoftDev/bug/The-left-part-of-'is-within'-condition-is-not-included-into-filter-12264
+            // we probably want to have the same for date-time, but then we will intersect with the "match" function of "operatorDateTimeIs".
+            return matchWithinOperator([
+                "and",
+                [">=", fieldPlaceholder, (0, patternMatchPlaceholders_1.getParamPlaceholder)((x) => x !== null)],
+                ["<=", fieldPlaceholder, (0, patternMatchPlaceholders_1.getParamPlaceholder)((x) => x !== null)],
+            ], where, params, typeObject);
+        }
+        return match;
+    };
+};
+exports.getWithinOperatorCustomMatchFn = getWithinOperatorCustomMatchFn;