@mercury25/aggregator 1.0.0

package/dist/pipeline/filters/conditions.js

@@ -0,0 +1,673 @@
+import mongoose from "mongoose";
+import { dayOfWeekMap } from "../../util/dayOfWeekMap.js";
+import { monthMap } from "../../util/monthMap.js";
+import { AggregatorError } from "../../errors.js";
+import { isObject } from "../../util/isObject.js";
+import { isIsoDateString } from "../../util/isIsoDateString.js";
+import { isValidHour, isValidMinuteOrSecond, isValidYear, } from "../../util/numberValidators.js";
+const mappedValue = (fieldType, val, message) => {
+    if (fieldType === "date") {
+        if (!isIsoDateString(val))
+            throw new AggregatorError(message);
+        return new Date(val);
+    }
+    else if (fieldType === "number") {
+        if (typeof val !== "number")
+            throw new AggregatorError(message);
+        return val;
+    }
+    else if (fieldType === "boolean") {
+        if (typeof val !== "boolean")
+            throw new AggregatorError(message);
+        return val;
+    }
+    else if (fieldType === "string") {
+        if (typeof val !== "string")
+            throw new AggregatorError(message);
+        return val;
+    }
+    else if (fieldType === "oid") {
+        if (typeof val !== "string")
+            throw new AggregatorError(message);
+        return new mongoose.Types.ObjectId(val);
+    }
+    else
+        return null;
+};
+const fieldDisplay = (field) => {
+    if (typeof field === "string") {
+        return field;
+    }
+    else if ("$strLenCP" in field) {
+        return `Length of ${field.$strLenCP}`;
+    }
+    else if ("$size" in field) {
+        return `Size of ${field.$size}`;
+    }
+    return "Unknown Field";
+};
+const fieldTypeDisplay = (fieldType) => {
+    switch (fieldType) {
+        case "date":
+            return "ISO Date String";
+        case "number":
+            return "Number";
+        case "boolean":
+            return "Boolean";
+        case "string":
+            return "String";
+        case "oid":
+            return "ObjectId String";
+        case "array":
+            return "Array";
+        default:
+            return "Unknown";
+    }
+};
+const isValidCondition = (args) => {
+    if (args.validTypes.map((type) => fieldTypeDisplay(type)).includes(args.fieldType)) {
+        return;
+    }
+    throw new AggregatorError(`Cannot use the ${args.conditionName} condition on the field: ${args.field}. This field has a field type of: ${args.fieldType}.`);
+};
+const condition_exists = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "exists";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number", "boolean", "string", "array", "oid"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "boolean") {
+        throw new AggregatorError(`Invalid value for 'exists' in ${fieldDisplayText} filter. Expected boolean, received ${typeof value}.`);
+    }
+    return { $expr: { $ifNull: [field, value] } };
+};
+const condition_equals = (args) => {
+    let { field, fieldType, condition, value } = args;
+    const conditionName = "equals";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number", "boolean", "string", "oid"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    value = mappedValue(fieldType, value, `Invalid value for 'equals' in ${fieldDisplayText} filter. Expected ${fieldTypeDisplayText}, received ${typeof value}.`);
+    return { $expr: { $eq: [field, value] } };
+};
+const condition_notEquals = (args) => {
+    let { field, fieldType, condition, value } = args;
+    const conditionName = "notEquals";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number", "boolean", "string", "oid"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    value = mappedValue(fieldType, value, `Invalid value for 'notEquals' in ${fieldDisplayText} filter. Expected ${fieldTypeDisplayText}, received ${typeof value}.`);
+    return { $expr: { $ne: [field, value] } };
+};
+const condition_anyOf = (args) => {
+    let { field, fieldType, condition, value } = args;
+    const conditionName = "anyOf";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number", "string", "boolean", "oid"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (!Array.isArray(value)) {
+        throw new AggregatorError(`Invalid value for 'anyOf' in ${fieldDisplayText} filter. Expected array, received ${typeof value}.`);
+    }
+    value = value.map((val, index) => {
+        return mappedValue(fieldType, val, `Invalid value in array for 'anyOf' in ${fieldDisplayText} filter. Expected ${fieldTypeDisplayText}, received ${typeof val} at index ${index}.`);
+    });
+    return { $expr: { $in: [field, value] } };
+};
+const condition_day = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "day";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "string" || !(value in dayOfWeekMap)) {
+        throw new AggregatorError(`Invalid value for 'day' in ${fieldDisplayText} filter. Expected one of ${Object.keys(dayOfWeekMap).join(", ")}, received ${value}.`);
+    }
+    return {
+        $expr: {
+            $eq: [{ $dayOfWeek: field }, dayOfWeekMap[value]],
+        },
+    };
+};
+const condition_month = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "month";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "string" || !(value in monthMap)) {
+        throw new AggregatorError(`Invalid value for 'month' in ${fieldDisplayText} filter. Expected one of ${Object.keys(monthMap).join(", ")}, received ${value}.`);
+    }
+    return {
+        $expr: {
+            $eq: [{ $month: field }, monthMap[value]],
+        },
+    };
+};
+const condition_year = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "year";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "number" || !isValidYear(value)) {
+        throw new AggregatorError(`Invalid value for 'year' in ${fieldDisplayText} filter. Expected a number value between 1800 and ${new Date().getFullYear()}, received ${value}.`);
+    }
+    return {
+        $expr: { $eq: [{ $year: field }, value] },
+    };
+};
+const condition_hour = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "hour";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "number" || !isValidHour(value)) {
+        throw new AggregatorError(`Invalid value for 'hour' in ${fieldDisplayText} filter. Expected a number value between 0 and 23, received ${value}.`);
+    }
+    return {
+        $expr: { $eq: [{ $hour: field }, value] },
+    };
+};
+const condition_minute = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "minute";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "number" || !isValidMinuteOrSecond(value)) {
+        throw new AggregatorError(`Invalid value for 'minute' in ${fieldDisplayText} filter. Expected a number value between 0 and 59, received ${value}.`);
+    }
+    return {
+        $expr: { $eq: [{ $minute: field }, value] },
+    };
+};
+const condition_second = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "second";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "number" || !isValidMinuteOrSecond(value)) {
+        throw new AggregatorError(`Invalid value for 'second' in ${fieldDisplayText} filter. Expected a number value between 0 and 59, received ${value}.`);
+    }
+    return {
+        $expr: { $eq: [{ $second: field }, value] },
+    };
+};
+const condition_isWeekend = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "isWeekend";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "boolean") {
+        throw new AggregatorError(`Invalid value for 'isWeekend' in ${fieldDisplayText} filter. Expected boolean, received ${typeof value}.`);
+    }
+    return {
+        $or: [
+            { $eq: [{ $dayOfWeek: field }, 0] },
+            { $eq: [{ $dayOfWeek: field }, 6] },
+        ],
+    };
+};
+const condition_isWeekday = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "isWeekday";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "boolean") {
+        throw new AggregatorError(`Invalid value for 'isWeekday' in ${fieldDisplayText} filter. Expected boolean, received ${typeof value}.`);
+    }
+    return {
+        $and: [
+            { $ne: [{ $dayOfWeek: field }, 0] },
+            { $ne: [{ $dayOfWeek: field }, 6] },
+        ],
+    };
+};
+const condition_isLeapYear = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "isLeapYear";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "boolean") {
+        throw new AggregatorError(`Invalid value for 'isLeapYear' in ${fieldDisplayText} filter. Expected boolean, received ${typeof value}.`);
+    }
+    return {
+        $expr: {
+            $eq: [
+                { $year: field },
+                { $cond: [{ $eq: [{ $mod: [{ $year: field }, 4] }, 0] }, 1, 0] },
+            ],
+        },
+    };
+};
+const condition_greaterThan = (args) => {
+    let { field, fieldType, condition, value } = args;
+    const conditionName = "greaterThan";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    value = mappedValue(fieldType, value, `Invalid value for 'greaterThan' in ${fieldDisplayText} filter. Expected ${fieldTypeDisplayText}, received ${typeof value}.`);
+    return { $expr: { $gt: [field, value] } };
+};
+const condition_greaterThanOrEquals = (args) => {
+    let { field, fieldType, condition, value } = args;
+    const conditionName = "greaterThanOrEquals";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    value = mappedValue(fieldType, value, `Invalid value for 'greaterThanOrEquals' in ${fieldDisplayText} filter. Expected ${fieldTypeDisplayText}, received ${typeof value}.`);
+    return { $expr: { $gte: [field, value] } };
+};
+const condition_lessThan = (args) => {
+    let { field, fieldType, condition, value } = args;
+    const conditionName = "lessThan";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    value = mappedValue(fieldType, value, `Invalid value for 'lessThan' in ${fieldDisplayText} filter. Expected ${fieldTypeDisplayText}, received ${typeof value}.`);
+    return { $expr: { $lt: [field, value] } };
+};
+const condition_lessThanOrEquals = (args) => {
+    let { field, fieldType, condition, value } = args;
+    const conditionName = "lessThanOrEquals";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    value = mappedValue(fieldType, value, `Invalid value for 'lessThanOrEquals' in ${fieldDisplayText} filter. Expected ${fieldTypeDisplayText}, received ${typeof value}.`);
+    return { $expr: { $lte: [field, value] } };
+};
+const condition_betweenExclusive = (args) => {
+    let { field, fieldType, condition, value } = args;
+    const conditionName = "betweenExclusive";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (!Array.isArray(value) || value.length !== 2) {
+        throw new AggregatorError(`Invalid value for 'betweenExclusive' in ${fieldDisplayText} filter. Expected an array of two values, received ${JSON.stringify(value)}.`);
+    }
+    value = value.map((val, index) => {
+        return mappedValue(fieldType, val, `Invalid value in array for 'betweenExclusive' in ${fieldDisplayText} filter. Expected ${fieldTypeDisplayText}, received ${typeof val} at index ${index}.`);
+    });
+    const tuple = value;
+    return {
+        $expr: {
+            $and: [{ $gt: [field, tuple[0]] }, { $lt: [field, tuple[1]] }],
+        },
+    };
+};
+const condition_betweenInclusive = (args) => {
+    let { field, fieldType, condition, value } = args;
+    const conditionName = "betweenInclusive";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["date", "number"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (!Array.isArray(value) || value.length !== 2) {
+        throw new AggregatorError(`Invalid value for 'betweenInclusive' in ${fieldDisplayText} filter. Expected an array of two values, received ${JSON.stringify(value)}.`);
+    }
+    value = value.map((val, index) => {
+        return mappedValue(fieldType, val, `Invalid value in array for 'betweenInclusive' in ${fieldDisplayText} filter. Expected ${fieldTypeDisplayText}, received ${typeof val} at index ${index}.`);
+    });
+    const tuple = value;
+    return {
+        $expr: {
+            $and: [{ $gte: [field, tuple[0]] }, { $lte: [field, tuple[1]] }],
+        },
+    };
+};
+const condition_divisibleBy = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "divisibleBy";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["number"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "number" || value <= 0) {
+        throw new AggregatorError(`Invalid value for 'divisibleBy' in ${fieldDisplayText} filter. Expected a positive number, received ${value}.`);
+    }
+    return {
+        $expr: { $eq: [{ $mod: [field, value] }, 0] },
+    };
+};
+const condition_parity = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "parity";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["number"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "string" || (value !== "even" && value !== "odd")) {
+        throw new AggregatorError(`Invalid value for 'parity' in ${fieldDisplayText} filter. Expected 'even' or 'odd', received ${value}.`);
+    }
+    const parityValue = value === "even" ? 0 : 1;
+    return {
+        $expr: { $eq: [{ $mod: [field, 2] }, parityValue] },
+    };
+};
+const condition_contains = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "contains";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["string"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "string") {
+        throw new AggregatorError(`Invalid value for 'contains' in ${fieldDisplayText} filter. Expected a string, received ${typeof value}.`);
+    }
+    return {
+        $expr: {
+            $regexMatch: { input: field, regex: value, options: "i" },
+        },
+    };
+};
+const condition_startsWith = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "startsWith";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["string"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "string") {
+        throw new AggregatorError(`Invalid value for 'startsWith' in ${fieldDisplayText} filter. Expected a string, received ${typeof value}.`);
+    }
+    return {
+        $expr: {
+            $regexMatch: { input: field, regex: `^${value}`, options: "i" },
+        },
+    };
+};
+const condition_endsWith = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "endsWith";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["string"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "string") {
+        throw new AggregatorError(`Invalid value for 'endsWith' in ${fieldDisplayText} filter. Expected a string, received ${typeof value}.`);
+    }
+    return {
+        $expr: {
+            $regexMatch: { input: field, regex: `${value}$`, options: "i" },
+        },
+    };
+};
+const condition_regex = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "regex";
+    if (condition !== conditionName)
+        return;
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["string"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (typeof value !== "string") {
+        throw new AggregatorError(`Invalid value for 'regex' in ${fieldDisplayText} filter. Expected a string, received ${typeof value}.`);
+    }
+    return {
+        $expr: {
+            $regexMatch: { input: field, regex: value, options: "i" },
+        },
+    };
+};
+const condition_length = (args) => {
+    const { field, fieldType, condition, value } = args;
+    const conditionName = "length";
+    if (condition !== conditionName)
+        return [];
+    const fieldDisplayText = fieldDisplay(field);
+    const fieldTypeDisplayText = fieldTypeDisplay(fieldType);
+    const validTypes = ["string", "array"];
+    isValidCondition({
+        conditionName,
+        field: fieldDisplayText,
+        fieldType: fieldTypeDisplayText,
+        validTypes,
+    });
+    if (fieldType === "string") {
+        return [
+            { $eq: [{ $type: field }, "string"] },
+            ...condition_controller({ $strLenCP: field }, "number", value),
+        ];
+    }
+    else if (fieldType === "array") {
+        return [
+            { $expr: { $eq: [{ $type: field }, "array"] } },
+            ...condition_controller({ $size: field }, "number", value),
+        ];
+    }
+    else
+        return [];
+};
+export const condition_controller = (field, fieldType, conditions, exprs = []) => {
+    if (!isObject(conditions)) {
+        throw new AggregatorError("For the field: " + String(field) + ", the conditions must be an object.");
+    }
+    for (const [condition, value] of Object.entries(conditions)) {
+        const args = { field, fieldType, condition, value };
+        exprs.push(condition_exists(args));
+        exprs.push(condition_equals(args));
+        exprs.push(condition_notEquals(args));
+        exprs.push(condition_anyOf(args));
+        exprs.push(condition_day(args));
+        exprs.push(condition_month(args));
+        exprs.push(condition_year(args));
+        exprs.push(condition_hour(args));
+        exprs.push(condition_minute(args));
+        exprs.push(condition_second(args));
+        exprs.push(condition_isWeekend(args));
+        exprs.push(condition_isWeekday(args));
+        exprs.push(condition_isLeapYear(args));
+        exprs.push(condition_greaterThan(args));
+        exprs.push(condition_greaterThanOrEquals(args));
+        exprs.push(condition_lessThan(args));
+        exprs.push(condition_lessThanOrEquals(args));
+        exprs.push(condition_betweenExclusive(args));
+        exprs.push(condition_betweenInclusive(args));
+        exprs.push(condition_divisibleBy(args));
+        exprs.push(condition_parity(args));
+        exprs.push(condition_contains(args));
+        exprs.push(condition_startsWith(args));
+        exprs.push(condition_endsWith(args));
+        exprs.push(condition_regex(args));
+        exprs.push(...condition_length(args));
+    }
+    return exprs.filter(Boolean);
+};
+//# sourceMappingURL=conditions.js.map