@routier/core 0.2.0 → 0.2.1

package/dist/expressions/index.js

@@ -6,10 +6,20 @@ __webpack_require__.d(__webpack_exports__, {
   assertInstanceOf: () => (assertInstanceOf),
   assertIsArray: () => (assertIsArray),
   assertIsNotNull: () => (assertIsNotNull),
-  assertString: () => (assertString)
+  assertIsNumber: () => (assertIsNumber),
+  assertString: () => (assertString),
+  isComparatorExpression: () => (isComparatorExpression),
+  isEmptyExpression: () => (isEmptyExpression),
+  isExpression: () => (isExpression),
+  isNotParsableExpression: () => (isNotParsableExpression),
+  isOperatorExpression: () => (isOperatorExpression),
+  isPropertyExpression: () => (isPropertyExpression),
+  isValueExpression: () => (isValueExpression)
 });
+/* import */ var _expressions_constants__rspack_import_1 = __webpack_require__("./src/expressions/constants.ts");
 /* import */ var _utilities__rspack_import_0 = __webpack_require__("./src/utilities/dates.ts");
 
+
 function assertDate(data) {
     if ((0,_utilities__rspack_import_0.isDate)(data) === false) {
         throw new TypeError('Value is not a Date');
@@ -41,12 +51,78 @@ function assertInstanceOf(value, Instance) {
         return;
     }
     if (value != null && typeof value === "object" && "constructor" in value) {
-        throw new TypeError(`Value is not instance of type.  Type: ${value.constructor.name}`);
+        throw new TypeError(`value is not instance of type.  Type: ${value.constructor.name}`);
+    }
+    throw new TypeError(`value is not instance of type`);
+}
+function assertIsNumber(value) {
+    if (typeof value !== "number") {
+        throw new TypeError("value is not of type `number`");
     }
-    throw new TypeError(`Value is not instance of type`);
+}
+function isObjectWithType(value) {
+    return typeof value === "object" && value !== null && "type" in value;
+}
+/**
+ * Type guard: narrows `value` to `Expression` when it is an object with a valid `type` property.
+ */
+function isExpression(value) {
+    return isObjectWithType(value) && _expressions_constants__rspack_import_1.EXPRESSION_TYPES.includes(value.type);
+}
+/**
+ * Type guard: narrows `value` to `OperatorExpression` when it is an object with `type === "operator"`.
+ */
+function isOperatorExpression(value) {
+    return isObjectWithType(value) && value.type === "operator";
+}
+/**
+ * Type guard: narrows `value` to `ComparatorExpression` when it is an object with `type === "comparator"`.
+ */
+function isComparatorExpression(value) {
+    return isObjectWithType(value) && value.type === "comparator";
+}
+/**
+ * Type guard: narrows `value` to `PropertyExpression` when it is an object with `type === "property"`.
+ */
+function isPropertyExpression(value) {
+    return isObjectWithType(value) && value.type === "property";
+}
+/**
+ * Type guard: narrows `value` to `ValueExpression` when it is an object with `type === "value"`.
+ */
+function isValueExpression(value) {
+    return isObjectWithType(value) && value.type === "value";
+}
+/**
+ * Type guard: narrows `value` to `EmptyExpression` when it is an object with `type === "empty"`.
+ */
+function isEmptyExpression(value) {
+    return isObjectWithType(value) && value.type === "empty";
+}
+/**
+ * Type guard: narrows `value` to `NotParsableExpression` when it is an object with `type === "not-parsable"`.
+ */
+function isNotParsableExpression(value) {
+    return isObjectWithType(value) && value.type === "not-parsable";
 }
 
 
+},
+"./src/expressions/constants.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  EXPRESSION_TYPES: () => (EXPRESSION_TYPES)
+});
+const EXPRESSION_TYPES = [
+    "operator",
+    "comparator",
+    "property",
+    "value",
+    "empty",
+    "not-parsable",
+];
+
+
 },
 "./src/expressions/parser.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
@@ -600,9 +676,9 @@ const getComparator = (value) => {
 };
 const getValue = (value, params) => {
     // Early return for string literals
-    if (value.startsWith("\'") || value.startsWith("\"")) {
+    if (value.startsWith("'") || value.startsWith("\"")) {
         return new _types__rspack_import_0.ValueExpression({
-            value: value.replace(/\"|\'/g, "")
+            value: value.replace(/"|'/g, "")
         });
     }
     // Early return for null/undefined
@@ -635,7 +711,7 @@ const getValue = (value, params) => {
                     const paramValue = getValueFromParams(`${params.name}.${potentialParamPath}`, params);
                     return new _types__rspack_import_0.ValueExpression({ value: paramValue });
                 }
-                catch (e) {
+                catch {
                     // Not a parameter path, continue with normal parsing
                 }
             }
@@ -722,7 +798,7 @@ const getProperty = (schema, value, params) => {
                             throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
                         }
                     }
-                    catch (e) {
+                    catch {
                         // Not a valid parameter path, continue to error
                         throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
                     }
@@ -760,6 +836,282 @@ const getProperty = (schema, value, params) => {
 };
 
 
+},
+"./src/expressions/sql.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  getDialect: () => (getDialect),
+  toSql: () => (toSql)
+});
+/* import */ var _assertions__rspack_import_0 = __webpack_require__("./src/assertions/index.ts");
+
+const DIALECTS = {
+    sqlite: {
+        quoteIdentifier(name) {
+            return `"${name.replace(/"/g, '""')}"`;
+        },
+        getPlaceholder(_i) {
+            return "?";
+        },
+        stringMatchKind: "GLOB",
+        likeEscapeClause() {
+            return "";
+        },
+    },
+    postgresql: {
+        quoteIdentifier(name) {
+            return `"${name.replace(/"/g, '""')}"`;
+        },
+        getPlaceholder(i) {
+            return `$${i + 1}`;
+        },
+        stringMatchKind: "LIKE",
+        likeEscapeClause() {
+            return " ESCAPE E'\\\\'";
+        },
+    },
+    mysql: {
+        quoteIdentifier(name) {
+            return "`" + name.replace(/`/g, "``") + "`";
+        },
+        getPlaceholder(_i) {
+            return "?";
+        },
+        stringMatchKind: "LIKE",
+        likeEscapeClause() {
+            return " ESCAPE '\\\\'";
+        },
+    },
+    mssql: {
+        quoteIdentifier(name) {
+            return "[" + name.replace(/]/g, "]]") + "]";
+        },
+        getPlaceholder(i) {
+            return `@p${i + 1}`;
+        },
+        stringMatchKind: "LIKE",
+        likeEscapeClause() {
+            return " ESCAPE '\\\\'";
+        },
+    },
+};
+function getDialect(name) {
+    const d = DIALECTS[name];
+    if (!d)
+        throw new Error(`Unknown SQL dialect: ${name}`);
+    return d;
+}
+function escapeLikeLiteral(value) {
+    return value.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function escapeGlobLiteral(value) {
+    return value.replace(/\\/g, "\\\\").replace(/\*/g, "\\*").replace(/\?/g, "\\?");
+}
+function escapeForPattern(value, kind) {
+    return kind === "LIKE" ? escapeLikeLiteral(value) : escapeGlobLiteral(value);
+}
+function buildPattern(escapedValue, match, kind) {
+    if (kind === "LIKE") {
+        switch (match) {
+            case "contains":
+                return `%${escapedValue}%`;
+            case "starts-with":
+                return `${escapedValue}%`;
+            case "ends-with":
+                return `%${escapedValue}`;
+        }
+    }
+    switch (match) {
+        case "contains":
+            return `*${escapedValue}*`;
+        case "starts-with":
+            return `${escapedValue}*`;
+        case "ends-with":
+            return `*${escapedValue}`;
+    }
+}
+function getPropertyValueSides(cmp) {
+    const propLeft = cmp.left && (0,_assertions__rspack_import_0.isPropertyExpression)(cmp.left) ? cmp.left : null;
+    const propRight = cmp.right && (0,_assertions__rspack_import_0.isPropertyExpression)(cmp.right) ? cmp.right : null;
+    const valLeft = cmp.left && (0,_assertions__rspack_import_0.isValueExpression)(cmp.left) ? cmp.left.value : null;
+    const valRight = cmp.right && (0,_assertions__rspack_import_0.isValueExpression)(cmp.right) ? cmp.right.value : null;
+    return { propLeft, propRight, valLeft, valRight };
+}
+function getEqualsCase(value, columnOnLeft, columnOnRight) {
+    if (value === null && columnOnLeft)
+        return "null-column-left";
+    if (value === null && columnOnRight)
+        return "null-column-right";
+    if (value !== null && columnOnLeft)
+        return "value-column-left";
+    if (value !== null && columnOnRight)
+        return "value-column-right";
+    return null;
+}
+function equalsNullColumnLeft(ctx) {
+    return ctx.negated ? `${ctx.col} IS NOT NULL` : `${ctx.col} IS NULL`;
+}
+function equalsNullColumnRight(ctx) {
+    ctx.params.push(null);
+    const ph = ctx.placeholder();
+    return ctx.negated ? `${ph} IS NOT NULL` : `${ph} IS NULL`;
+}
+function equalsValueColumnLeft(ctx) {
+    ctx.params.push(ctx.value);
+    const ph = ctx.placeholder();
+    return ctx.negated ? `${ctx.col} != ${ph}` : `${ctx.col} = ${ph}`;
+}
+function equalsValueColumnRight(ctx) {
+    ctx.params.push(ctx.value);
+    const ph = ctx.placeholder();
+    return ctx.negated ? `${ph} != ${ctx.col}` : `${ph} = ${ctx.col}`;
+}
+const EQUALS_STRATEGIES = {
+    "null-column-left": equalsNullColumnLeft,
+    "null-column-right": equalsNullColumnRight,
+    "value-column-left": equalsValueColumnLeft,
+    "value-column-right": equalsValueColumnRight,
+};
+// --- String-pattern comparison (includes / starts-with / ends-with) ---
+function renderStringPatternComparison(cmp, d, params, placeholder) {
+    const { propLeft, propRight, valLeft, valRight } = getPropertyValueSides(cmp);
+    const kind = d.stringMatchKind;
+    if (cmp.comparator === "includes") {
+        const col = propLeft && valRight !== null
+            ? d.quoteIdentifier(propLeft.property.name)
+            : propRight && valLeft !== null
+                ? d.quoteIdentifier(propRight.property.name)
+                : null;
+        const value = valRight !== null ? valRight : valLeft;
+        if (col === null) {
+            throw new Error("Complex expressions not supported for includes operations");
+        }
+        if (Array.isArray(value)) {
+            const placeholders = value.map(() => placeholder()).join(", ");
+            params.push(...value);
+            return cmp.negated ? `${col} NOT IN (${placeholders})` : `${col} IN (${placeholders})`;
+        }
+        const escaped = escapeForPattern(String(value), kind);
+        const pattern = buildPattern(escaped, "contains", kind);
+        params.push(pattern);
+        const ph = placeholder();
+        const op = kind === "GLOB" ? "GLOB" : "LIKE";
+        const escape = kind === "LIKE" ? d.likeEscapeClause() : "";
+        if (propLeft && valRight !== null) {
+            return cmp.negated ? `${col} NOT ${op} ${ph}${escape}` : `${col} ${op} ${ph}${escape}`;
+        }
+        return cmp.negated ? `${ph} NOT ${op} ${col}${escape}` : `${ph} ${op} ${col}${escape}`;
+    }
+    const col = propLeft && valRight !== null
+        ? d.quoteIdentifier(propLeft.property.name)
+        : propRight && valLeft !== null
+            ? d.quoteIdentifier(propRight.property.name)
+            : null;
+    const value = valRight !== null ? String(valRight) : valLeft !== null ? String(valLeft) : null;
+    if (col === null || value === null) {
+        throw new Error(`Complex expressions not supported for ${cmp.comparator} operations`);
+    }
+    const escaped = escapeForPattern(value, kind);
+    const pattern = buildPattern(escaped, cmp.comparator === "starts-with" ? "starts-with" : "ends-with", kind);
+    params.push(pattern);
+    const ph = placeholder();
+    const op = kind === "GLOB" ? "GLOB" : "LIKE";
+    const escape = kind === "LIKE" ? d.likeEscapeClause() : "";
+    if (propLeft && valRight !== null) {
+        return cmp.negated ? `${col} NOT ${op} ${ph}${escape}` : `${col} ${op} ${ph}${escape}`;
+    }
+    return cmp.negated ? `${ph} NOT ${op} ${col}${escape}` : `${ph} ${op} ${col}${escape}`;
+}
+// --- Generic comparison ---
+function renderGenericComparison(cmp, walk) {
+    const leftExpr = walk(cmp.left);
+    const rightExpr = walk(cmp.right);
+    switch (cmp.comparator) {
+        case "equals":
+            return cmp.negated ? `${leftExpr} != ${rightExpr}` : `${leftExpr} = ${rightExpr}`;
+        case "greater-than":
+            return cmp.negated ? `${leftExpr} <= ${rightExpr}` : `${leftExpr} > ${rightExpr}`;
+        case "greater-than-equals":
+            return cmp.negated ? `${leftExpr} < ${rightExpr}` : `${leftExpr} >= ${rightExpr}`;
+        case "less-than":
+            return cmp.negated ? `${leftExpr} >= ${rightExpr}` : `${leftExpr} < ${rightExpr}`;
+        case "less-than-equals":
+            return cmp.negated ? `${leftExpr} > ${rightExpr}` : `${leftExpr} <= ${rightExpr}`;
+        default:
+            throw new Error(`Unsupported comparator: ${cmp.comparator}`);
+    }
+}
+/**
+ * Converts an Expression to a SQL WHERE clause and bound parameters for the given dialect.
+ */
+function toSql(expr, dialect) {
+    const d = typeof dialect === "string" ? getDialect(dialect) : dialect;
+    const params = [];
+    let paramIndex = 0;
+    function placeholder() {
+        const p = d.getPlaceholder(paramIndex);
+        paramIndex += 1;
+        return p;
+    }
+    /** Visitor: map each expression node type to a SQL fragment. */
+    function walk(e) {
+        if ((0,_assertions__rspack_import_0.isOperatorExpression)(e)) {
+            const left = e.left ? walk(e.left) : "";
+            const right = e.right ? walk(e.right) : "";
+            const sqlOp = e.operator === "&&" ? "AND" : e.operator === "||" ? "OR" : e.operator;
+            return `(${left} ${sqlOp} ${right})`;
+        }
+        if ((0,_assertions__rspack_import_0.isComparatorExpression)(e)) {
+            const cmp = e;
+            const isStringPattern = cmp.comparator === "starts-with" ||
+                cmp.comparator === "ends-with" ||
+                cmp.comparator === "includes";
+            if (isStringPattern) {
+                /* String pattern: includes / starts-with / ends-with → one renderer. */
+                return renderStringPatternComparison(cmp, d, params, placeholder);
+            }
+            if (cmp.comparator === "equals") {
+                /* Equals: Strategy per (column-side, null vs value) case. */
+                const { propLeft, propRight, valLeft, valRight } = getPropertyValueSides(cmp);
+                const col = propLeft && (valRight !== undefined || propRight)
+                    ? d.quoteIdentifier(propLeft.property.name)
+                    : propRight && (valLeft !== undefined || propLeft)
+                        ? d.quoteIdentifier(propRight.property.name)
+                        : null;
+                const value = valRight !== undefined ? valRight : valLeft;
+                const columnOnLeft = Boolean(propLeft && cmp.right && (0,_assertions__rspack_import_0.isValueExpression)(cmp.right));
+                const columnOnRight = Boolean(propRight && cmp.left && (0,_assertions__rspack_import_0.isValueExpression)(cmp.left));
+                if (col !== null && value !== undefined) {
+                    const caseKey = getEqualsCase(value, columnOnLeft, columnOnRight);
+                    if (caseKey !== null) {
+                        const strategy = EQUALS_STRATEGIES[caseKey];
+                        return strategy({
+                            col,
+                            value,
+                            negated: cmp.negated,
+                            params,
+                            placeholder,
+                        });
+                    }
+                }
+            }
+            /* Generic: walk both sides and emit comparison operator. */
+            return renderGenericComparison(cmp, walk);
+        }
+        if ((0,_assertions__rspack_import_0.isPropertyExpression)(e)) {
+            return d.quoteIdentifier(e.property.name);
+        }
+        if ((0,_assertions__rspack_import_0.isValueExpression)(e)) {
+            params.push(e.value);
+            return placeholder();
+        }
+        throw new Error(`Unknown expression type: ${e.type}`);
+    }
+    const where = walk(expr);
+    return { where, params };
+}
+
+
 },
 "./src/expressions/types.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
@@ -872,8 +1224,7 @@ class ValueExpression extends Expression {
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
   forEach: () => (forEach),
-  getProperties: () => (getProperties),
-  isPropertyExpression: () => (isPropertyExpression)
+  getProperties: () => (getProperties)
 });
 /**
  * Extracts all properties referenced in an expression
@@ -898,9 +1249,6 @@ function getProperties(expression) {
     traverse(expression);
     return properties;
 }
-function isPropertyExpression(expression) {
-    return expression.type === "property";
-}
 function forEach(expression, callback) {
     function traverse(expr) {
         // Call the callback for this expression
@@ -948,16 +1296,27 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
   logger: () => (logger)
 });
-const isDevelopment = () => {
-    if (typeof process === 'undefined' || process.env == null) {
-        return false;
+/**
+ * Enable logging by setting `globalThis.__ROUTIER_DEBUG__ = true` before any routier code runs.
+ */
+const shouldLog = () => {
+    if (typeof globalThis !== 'undefined') {
+        const g = globalThis;
+        if (g.__ROUTIER_DEBUG__ === true)
+            return true;
+    }
+    if (typeof process !== 'undefined' && process.env != null) {
+        const debug = process.env.DEBUG;
+        if (debug === 'routier' || debug === '*')
+            return true;
+        const env = "development"?.toLowerCase();
+        if (env === 'dev' || env === 'development' || env === 'test')
+            return true;
     }
-    const env = "development"?.toLowerCase();
-    return env === 'dev' || env === 'development' || env === 'test';
+    return false;
 };
-const shouldLog = isDevelopment();
 const tryLog = (type, ...args) => {
-    if (shouldLog) {
+    if (shouldLog()) {
         console[type](...args);
     }
 };
@@ -1038,22 +1397,28 @@ var __webpack_exports__ = {};
 (() => {
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-  ComparatorExpression: () => (/* reexport safe */ _types__rspack_import_1.ComparatorExpression),
-  EmptyExpression: () => (/* reexport safe */ _types__rspack_import_1.EmptyExpression),
-  Expression: () => (/* reexport safe */ _types__rspack_import_1.Expression),
-  NotParsableExpression: () => (/* reexport safe */ _types__rspack_import_1.NotParsableExpression),
-  OperatorExpression: () => (/* reexport safe */ _types__rspack_import_1.OperatorExpression),
-  PropertyExpression: () => (/* reexport safe */ _types__rspack_import_1.PropertyExpression),
-  ValueExpression: () => (/* reexport safe */ _types__rspack_import_1.ValueExpression),
+  ComparatorExpression: () => (/* reexport safe */ _types__rspack_import_2.ComparatorExpression),
+  EXPRESSION_TYPES: () => (/* reexport safe */ _constants__rspack_import_4.EXPRESSION_TYPES),
+  EmptyExpression: () => (/* reexport safe */ _types__rspack_import_2.EmptyExpression),
+  Expression: () => (/* reexport safe */ _types__rspack_import_2.Expression),
+  NotParsableExpression: () => (/* reexport safe */ _types__rspack_import_2.NotParsableExpression),
+  OperatorExpression: () => (/* reexport safe */ _types__rspack_import_2.OperatorExpression),
+  PropertyExpression: () => (/* reexport safe */ _types__rspack_import_2.PropertyExpression),
+  ValueExpression: () => (/* reexport safe */ _types__rspack_import_2.ValueExpression),
   combineExpressions: () => (/* reexport safe */ _parser__rspack_import_0.combineExpressions),
-  forEach: () => (/* reexport safe */ _utils__rspack_import_2.forEach),
-  getProperties: () => (/* reexport safe */ _utils__rspack_import_2.getProperties),
-  isPropertyExpression: () => (/* reexport safe */ _utils__rspack_import_2.isPropertyExpression),
-  toExpression: () => (/* reexport safe */ _parser__rspack_import_0.toExpression)
+  forEach: () => (/* reexport safe */ _utils__rspack_import_3.forEach),
+  getDialect: () => (/* reexport safe */ _sql__rspack_import_1.getDialect),
+  getProperties: () => (/* reexport safe */ _utils__rspack_import_3.getProperties),
+  toExpression: () => (/* reexport safe */ _parser__rspack_import_0.toExpression),
+  toSql: () => (/* reexport safe */ _sql__rspack_import_1.toSql)
 });
 /* import */ var _parser__rspack_import_0 = __webpack_require__("./src/expressions/parser.ts");
-/* import */ var _types__rspack_import_1 = __webpack_require__("./src/expressions/types.ts");
-/* import */ var _utils__rspack_import_2 = __webpack_require__("./src/expressions/utils.ts");
+/* import */ var _sql__rspack_import_1 = __webpack_require__("./src/expressions/sql.ts");
+/* import */ var _types__rspack_import_2 = __webpack_require__("./src/expressions/types.ts");
+/* import */ var _utils__rspack_import_3 = __webpack_require__("./src/expressions/utils.ts");
+/* import */ var _constants__rspack_import_4 = __webpack_require__("./src/expressions/constants.ts");
+
+
 
 
 
@@ -1061,6 +1426,7 @@ __webpack_require__.d(__webpack_exports__, {
 })();
 
 var __webpack_exports__ComparatorExpression = __webpack_exports__.ComparatorExpression;
+var __webpack_exports__EXPRESSION_TYPES = __webpack_exports__.EXPRESSION_TYPES;
 var __webpack_exports__EmptyExpression = __webpack_exports__.EmptyExpression;
 var __webpack_exports__Expression = __webpack_exports__.Expression;
 var __webpack_exports__NotParsableExpression = __webpack_exports__.NotParsableExpression;
@@ -1069,9 +1435,10 @@ var __webpack_exports__PropertyExpression = __webpack_exports__.PropertyExpressi
 var __webpack_exports__ValueExpression = __webpack_exports__.ValueExpression;
 var __webpack_exports__combineExpressions = __webpack_exports__.combineExpressions;
 var __webpack_exports__forEach = __webpack_exports__.forEach;
+var __webpack_exports__getDialect = __webpack_exports__.getDialect;
 var __webpack_exports__getProperties = __webpack_exports__.getProperties;
-var __webpack_exports__isPropertyExpression = __webpack_exports__.isPropertyExpression;
 var __webpack_exports__toExpression = __webpack_exports__.toExpression;
-export { __webpack_exports__ComparatorExpression as ComparatorExpression, __webpack_exports__EmptyExpression as EmptyExpression, __webpack_exports__Expression as Expression, __webpack_exports__NotParsableExpression as NotParsableExpression, __webpack_exports__OperatorExpression as OperatorExpression, __webpack_exports__PropertyExpression as PropertyExpression, __webpack_exports__ValueExpression as ValueExpression, __webpack_exports__combineExpressions as combineExpressions, __webpack_exports__forEach as forEach, __webpack_exports__getProperties as getProperties, __webpack_exports__isPropertyExpression as isPropertyExpression, __webpack_exports__toExpression as toExpression };
+var __webpack_exports__toSql = __webpack_exports__.toSql;
+export { __webpack_exports__ComparatorExpression as ComparatorExpression, __webpack_exports__EXPRESSION_TYPES as EXPRESSION_TYPES, __webpack_exports__EmptyExpression as EmptyExpression, __webpack_exports__Expression as Expression, __webpack_exports__NotParsableExpression as NotParsableExpression, __webpack_exports__OperatorExpression as OperatorExpression, __webpack_exports__PropertyExpression as PropertyExpression, __webpack_exports__ValueExpression as ValueExpression, __webpack_exports__combineExpressions as combineExpressions, __webpack_exports__forEach as forEach, __webpack_exports__getDialect as getDialect, __webpack_exports__getProperties as getProperties, __webpack_exports__toExpression as toExpression, __webpack_exports__toSql as toSql };
 
 //# sourceMappingURL=index.js.map