@powersync/service-sync-rules 0.17.10 → 0.18.0

package/dist/sql_filters.js

@@ -1,8 +1,10 @@
+import { ExpressionType, TYPE_NONE } from './ExpressionType.js';
 import { SqlRuleError } from './errors.js';
-import { BASIC_OPERATORS, cast, CAST_TYPES, jsonExtract, SQL_FUNCTIONS, sqliteTypeOf } from './sql_functions.js';
+import { BASIC_OPERATORS, OPERATOR_IS_NOT_NULL, OPERATOR_IS_NULL, OPERATOR_JSON_EXTRACT_JSON, OPERATOR_JSON_EXTRACT_SQL, OPERATOR_NOT, SQL_FUNCTIONS, castOperator, sqliteTypeOf } from './sql_functions.js';
+import { SQLITE_FALSE, SQLITE_TRUE, andFilters, compileStaticOperator, getOperatorFunction, isClauseError, isParameterMatchClause, isParameterValueClause, isRowValueClause, isStaticValueClause, orFilters, toBooleanParameterSetClause } from './sql_support.js';
 import { isJsonValue } from './utils.js';
-import { andFilters, compileStaticOperator, isClauseError, isParameterMatchClause, isParameterValueClause, isStaticRowValueClause, orFilters, SQLITE_FALSE, SQLITE_TRUE, sqliteNot, toBooleanParameterSetClause } from './sql_support.js';
-import { ExpressionType, TYPE_NONE } from './ExpressionType.js';
+import { JSONBig } from '@powersync/service-jsonbig';
+import { REQUEST_FUNCTIONS } from './request_functions.js';
 export const MATCH_CONST_FALSE = [];
 export const MATCH_CONST_TRUE = [{}];
 Object.freeze(MATCH_CONST_TRUE);
@@ -24,6 +26,7 @@ export class SqlTools {
         this.parameter_tables = options.parameter_tables ?? [];
         this.sql = options.sql;
         this.supports_expanding_parameters = options.supports_expanding_parameters ?? false;
+        this.supports_parameter_expressions = options.supports_parameter_expressions ?? false;
     }
     error(message, expr) {
         this.errors.push(new SqlRuleError(message, this.sql, expr));
@@ -44,33 +47,30 @@ export class SqlTools {
         const base = this.compileClause(where);
         return toBooleanParameterSetClause(base);
     }
-    compileStaticExtractor(expr) {
+    compileRowValueExtractor(expr) {
         const clause = this.compileClause(expr);
-        if (!isStaticRowValueClause(clause) && !isClauseError(clause)) {
-            throw new SqlRuleError('Bucket parameters are not allowed here', this.sql, expr ?? undefined);
+        if (!isRowValueClause(clause) && !isClauseError(clause)) {
+            return this.error('Parameter match expression is not allowed here', expr ?? undefined);
         }
         return clause;
     }
+    compileParameterValueExtractor(expr) {
+        const clause = this.compileClause(expr);
+        if (isClauseError(clause) || isStaticValueClause(clause) || isParameterValueClause(clause)) {
+            return clause;
+        }
+        return this.error('Parameter match expression is not allowed here', expr ?? undefined);
+    }
     /**
      * Given an expression, return a compiled clause.
      */
     compileClause(expr) {
         if (expr == null) {
-            return {
-                evaluate: () => SQLITE_TRUE,
-                getType() {
-                    return ExpressionType.INTEGER;
-                }
-            };
+            return staticValueClause(SQLITE_TRUE);
         }
         else if (isStatic(expr)) {
             const value = staticValue(expr);
-            return {
-                evaluate: () => value,
-                getType() {
-                    return ExpressionType.fromTypeText(sqliteTypeOf(value));
-                }
-            };
+            return staticValueClause(value);
         }
         else if (expr.type == 'ref') {
             const column = expr.name;
@@ -81,8 +81,7 @@ export class SqlTools {
                 return this.error(`Schema is not supported in column references`, expr);
             }
             if (this.isParameterRef(expr)) {
-                const param = this.getParameterRef(expr);
-                return { bucketParameter: param };
+                return this.getParameterRefClause(expr);
             }
             else if (this.isTableRef(expr)) {
                 const table = this.getTableName(expr);
@@ -128,15 +127,27 @@ export class SqlTools {
             }
             else if (op == '=') {
                 // Options:
-                //  1. static, static
-                //  2. static, parameterValue
+                //  1. row value, row value
+                //  2. row value, parameter value
                 //  3. static true, parameterMatch - not supported yet
+                //  4. parameter value, parameter value
                 let staticFilter1;
                 let otherFilter1;
-                if (!isStaticRowValueClause(leftFilter) && !isStaticRowValueClause(rightFilter)) {
+                if (this.supports_parameter_expressions &&
+                    isParameterValueClause(leftFilter) &&
+                    isParameterValueClause(rightFilter)) {
+                    // 4. parameterValue, parameterValue
+                    // This includes (static value, parameter value)
+                    // Not applicable to data queries (composeFunction will error).
+                    // Some of those cases can still be handled with case (2),
+                    // so we filter for supports_parameter_expressions above.
+                    const fnImpl = getOperatorFunction('=');
+                    return this.composeFunction(fnImpl, [leftFilter, rightFilter], [left, right]);
+                }
+                if (!isRowValueClause(leftFilter) && !isRowValueClause(rightFilter)) {
                     return this.error(`Cannot have bucket parameters on both sides of = operator`, expr);
                 }
-                else if (isStaticRowValueClause(leftFilter)) {
+                else if (isRowValueClause(leftFilter)) {
                     staticFilter1 = leftFilter;
                     otherFilter1 = rightFilter;
                 }
@@ -146,17 +157,18 @@ export class SqlTools {
                 }
                 const staticFilter = staticFilter1;
                 const otherFilter = otherFilter1;
-                if (isStaticRowValueClause(otherFilter)) {
-                    // 1. static, static
+                if (isRowValueClause(otherFilter)) {
+                    // 1. row value = row value
                     return compileStaticOperator(op, leftFilter, rightFilter);
                 }
                 else if (isParameterValueClause(otherFilter)) {
-                    // 2. static, parameterValue
+                    // 2. row value = parameter value
+                    const inputParam = basicInputParameter(otherFilter);
                     return {
                         error: false,
-                        bucketParameters: [otherFilter.bucketParameter],
+                        inputParameters: [inputParam],
                         unbounded: false,
-                        filter(tables) {
+                        filterRow(tables) {
                             const value = staticFilter.evaluate(tables);
                             if (value == null) {
                                 // null never matches on =
@@ -167,15 +179,17 @@ export class SqlTools {
                                 // Cannot persist this, e.g. BLOB
                                 return MATCH_CONST_FALSE;
                             }
-                            return [{ [otherFilter.bucketParameter]: value }];
-                        }
+                            return [{ [inputParam.key]: value }];
+                        },
+                        usesAuthenticatedRequestParameters: otherFilter.usesAuthenticatedRequestParameters,
+                        usesUnauthenticatedRequestParameters: otherFilter.usesUnauthenticatedRequestParameters
                     };
                 }
                 else if (isParameterMatchClause(otherFilter)) {
-                    // 3. static, parameterMatch
+                    // 3. row value = parameterMatch
                     // (bucket.param = 'something') = staticValue
                     // To implement this, we need to ensure the static value here can only be true.
-                    return this.error(`Bucket parameter clauses cannot currently be combined with other operators`, expr);
+                    return this.error(`Parameter match clauses cannot be used here`, expr);
                 }
                 else {
                     throw new Error('Unexpected');
@@ -185,16 +199,19 @@ export class SqlTools {
                 // Options:
                 //  static IN static
                 //  parameterValue IN static
-                if (isStaticRowValueClause(leftFilter) && isStaticRowValueClause(rightFilter)) {
+                if (isRowValueClause(leftFilter) && isRowValueClause(rightFilter)) {
+                    // static1 IN static2
                     return compileStaticOperator(op, leftFilter, rightFilter);
                 }
-                else if (isParameterValueClause(leftFilter) && isStaticRowValueClause(rightFilter)) {
-                    const param = leftFilter.bucketParameter;
+                else if (isParameterValueClause(leftFilter) && isRowValueClause(rightFilter)) {
+                    // token_parameters.value IN table.some_array
+                    // bucket.param IN table.some_array
+                    const inputParam = basicInputParameter(leftFilter);
                     return {
                         error: false,
-                        bucketParameters: [param],
+                        inputParameters: [inputParam],
                         unbounded: true,
-                        filter(tables) {
+                        filterRow(tables) {
                             const aValue = rightFilter.evaluate(tables);
                             if (aValue == null) {
                                 return MATCH_CONST_FALSE;
@@ -204,27 +221,44 @@ export class SqlTools {
                                 throw new Error('Not an array');
                             }
                             return values.map((value) => {
-                                return { [param]: value };
+                                return { [inputParam.key]: value };
                             });
-                        }
+                        },
+                        usesAuthenticatedRequestParameters: leftFilter.usesAuthenticatedRequestParameters,
+                        usesUnauthenticatedRequestParameters: leftFilter.usesUnauthenticatedRequestParameters
                     };
                 }
                 else if (this.supports_expanding_parameters &&
-                    isStaticRowValueClause(leftFilter) &&
+                    isRowValueClause(leftFilter) &&
                     isParameterValueClause(rightFilter)) {
-                    const param = `${rightFilter.bucketParameter}[*]`;
+                    // table.some_value IN token_parameters.some_array
+                    // This expands into "table_some_value = <value>" for each value of the array.
+                    // We only support one such filter per query
+                    const key = `${rightFilter.key}[*]`;
+                    const inputParam = {
+                        key: key,
+                        expands: true,
+                        filteredRowToLookupValue: (filterParameters) => {
+                            return filterParameters[key];
+                        },
+                        parametersToLookupValue: (parameters) => {
+                            return rightFilter.lookupParameterValue(parameters);
+                        }
+                    };
                     return {
                         error: false,
-                        bucketParameters: [param],
+                        inputParameters: [inputParam],
                         unbounded: false,
-                        filter(tables) {
+                        filterRow(tables) {
                             const value = leftFilter.evaluate(tables);
                             if (!isJsonValue(value)) {
                                 // Cannot persist, e.g. BLOB
                                 return MATCH_CONST_FALSE;
                             }
-                            return [{ [param]: value }];
-                        }
+                            return [{ [inputParam.key]: value }];
+                        },
+                        usesAuthenticatedRequestParameters: rightFilter.usesAuthenticatedRequestParameters,
+                        usesUnauthenticatedRequestParameters: rightFilter.usesUnauthenticatedRequestParameters
                     };
                 }
                 else {
@@ -232,10 +266,8 @@ export class SqlTools {
                 }
             }
             else if (BASIC_OPERATORS.has(op)) {
-                if (!isStaticRowValueClause(leftFilter) || !isStaticRowValueClause(rightFilter)) {
-                    return this.error(`Operator ${op} is not supported on bucket parameters`, expr);
-                }
-                return compileStaticOperator(op, leftFilter, rightFilter);
+                const fnImpl = getOperatorFunction(op);
+                return this.composeFunction(fnImpl, [leftFilter, rightFilter], [left, right]);
             }
             else {
                 return this.error(`Operator not supported: ${op}`, expr);
@@ -243,157 +275,84 @@ export class SqlTools {
         }
         else if (expr.type == 'unary') {
             if (expr.op == 'NOT') {
-                const filter = this.compileClause(expr.operand);
-                if (isClauseError(filter)) {
-                    return filter;
-                }
-                else if (!isStaticRowValueClause(filter)) {
-                    return this.error('Cannot use NOT on bucket parameter filters', expr);
-                }
-                return {
-                    evaluate: (tables) => {
-                        const value = filter.evaluate(tables);
-                        return sqliteNot(value);
-                    },
-                    getType() {
-                        return ExpressionType.INTEGER;
-                    }
-                };
+                const clause = this.compileClause(expr.operand);
+                return this.composeFunction(OPERATOR_NOT, [clause], [expr.operand]);
             }
             else if (expr.op == 'IS NULL') {
-                const leftFilter = this.compileClause(expr.operand);
-                if (isClauseError(leftFilter)) {
-                    return leftFilter;
-                }
-                else if (isStaticRowValueClause(leftFilter)) {
-                    //  1. static IS NULL
-                    const nullValue = {
-                        evaluate: () => null,
-                        getType() {
-                            return ExpressionType.INTEGER;
-                        }
-                    };
-                    return compileStaticOperator('IS', leftFilter, nullValue);
-                }
-                else if (isParameterValueClause(leftFilter)) {
-                    //  2. param IS NULL
-                    return {
-                        error: false,
-                        bucketParameters: [leftFilter.bucketParameter],
-                        unbounded: false,
-                        filter(tables) {
-                            return [{ [leftFilter.bucketParameter]: null }];
-                        }
-                    };
-                }
-                else {
-                    return this.error(`Cannot use IS NULL here`, expr);
-                }
+                const clause = this.compileClause(expr.operand);
+                return this.composeFunction(OPERATOR_IS_NULL, [clause], [expr.operand]);
             }
             else if (expr.op == 'IS NOT NULL') {
-                const leftFilter = this.compileClause(expr.operand);
-                if (isClauseError(leftFilter)) {
-                    return leftFilter;
-                }
-                else if (isStaticRowValueClause(leftFilter)) {
-                    //  1. static IS NULL
-                    const nullValue = {
-                        evaluate: () => null,
-                        getType() {
-                            return ExpressionType.INTEGER;
-                        }
-                    };
-                    return compileStaticOperator('IS NOT', leftFilter, nullValue);
-                }
-                else {
-                    return this.error(`Cannot use IS NOT NULL here`, expr);
-                }
+                const clause = this.compileClause(expr.operand);
+                return this.composeFunction(OPERATOR_IS_NOT_NULL, [clause], [expr.operand]);
             }
             else {
                 return this.error(`Operator ${expr.op} is not supported`, expr);
             }
         }
         else if (expr.type == 'call' && expr.function?.name != null) {
+            const schema = expr.function.schema; // schema.function()
             const fn = expr.function.name;
-            const fnImpl = SQL_FUNCTIONS[fn];
-            if (fnImpl == null) {
-                return this.error(`Function '${fn}' is not defined`, expr);
+            if (schema == null) {
+                // Just fn()
+                const fnImpl = SQL_FUNCTIONS[fn];
+                if (fnImpl == null) {
+                    return this.error(`Function '${fn}' is not defined`, expr);
+                }
+                const argClauses = expr.args.map((arg) => this.compileClause(arg));
+                const composed = this.composeFunction(fnImpl, argClauses, expr.args);
+                return composed;
             }
-            let error = false;
-            const argExtractors = expr.args.map((arg) => {
-                const clause = this.compileClause(arg);
-                if (isClauseError(clause)) {
-                    error = true;
+            else if (schema == 'request') {
+                // Special function
+                if (!this.supports_parameter_expressions) {
+                    return this.error(`${schema} schema is not available in data queries`, expr);
                 }
-                else if (!isStaticRowValueClause(clause)) {
-                    error = true;
-                    return this.error(`Bucket parameters are not supported in function call arguments`, arg);
+                if (expr.args.length > 0) {
+                    return this.error(`Function '${schema}.${fn}' does not take arguments`, expr);
                 }
-                return clause;
-            });
-            if (error) {
-                return { error: true };
-            }
-            return {
-                evaluate: (tables) => {
-                    const args = argExtractors.map((e) => e.evaluate(tables));
-                    return fnImpl.call(...args);
-                },
-                getType(schema) {
-                    const argTypes = argExtractors.map((e) => e.getType(schema));
-                    return fnImpl.getReturnType(argTypes);
+                if (fn in REQUEST_FUNCTIONS) {
+                    const fnImpl = REQUEST_FUNCTIONS[fn];
+                    return {
+                        key: 'request.parameters()',
+                        lookupParameterValue(parameters) {
+                            return fnImpl.call(parameters);
+                        },
+                        usesAuthenticatedRequestParameters: fnImpl.usesAuthenticatedRequestParameters,
+                        usesUnauthenticatedRequestParameters: fnImpl.usesUnauthenticatedRequestParameters
+                    };
                 }
-            };
+                else {
+                    return this.error(`Function '${schema}.${fn}' is not defined`, expr);
+                }
+            }
+            else {
+                // Unknown function with schema
+                return this.error(`Function '${schema}.${fn}' is not defined`, expr);
+            }
         }
         else if (expr.type == 'member') {
             const operand = this.compileClause(expr.operand);
-            if (isClauseError(operand)) {
-                return operand;
-            }
-            else if (!isStaticRowValueClause(operand)) {
-                return this.error(`Bucket parameters are not supported in member lookups`, expr.operand);
+            if (!(typeof expr.member == 'string' && (expr.op == '->>' || expr.op == '->'))) {
+                return this.error(`Unsupported member operation ${expr.op}`, expr);
             }
-            if (typeof expr.member == 'string' && (expr.op == '->>' || expr.op == '->')) {
-                return {
-                    evaluate: (tables) => {
-                        const containerString = operand.evaluate(tables);
-                        return jsonExtract(containerString, expr.member, expr.op);
-                    },
-                    getType() {
-                        return ExpressionType.ANY_JSON;
-                    }
-                };
+            const debugArgs = [expr.operand, expr];
+            const args = [operand, staticValueClause(expr.member)];
+            if (expr.op == '->') {
+                return this.composeFunction(OPERATOR_JSON_EXTRACT_JSON, args, debugArgs);
             }
             else {
-                return this.error(`Unsupported member operation ${expr.op}`, expr);
+                return this.composeFunction(OPERATOR_JSON_EXTRACT_SQL, args, debugArgs);
             }
         }
         else if (expr.type == 'cast') {
             const operand = this.compileClause(expr.operand);
-            if (isClauseError(operand)) {
-                return operand;
-            }
-            else if (!isStaticRowValueClause(operand)) {
-                return this.error(`Bucket parameters are not supported in cast expressions`, expr.operand);
-            }
             const to = expr.to?.name?.toLowerCase();
-            if (CAST_TYPES.has(to)) {
-                return {
-                    evaluate: (tables) => {
-                        const value = operand.evaluate(tables);
-                        if (value == null) {
-                            return null;
-                        }
-                        return cast(value, to);
-                    },
-                    getType() {
-                        return ExpressionType.fromTypeText(to);
-                    }
-                };
-            }
-            else {
+            const castFn = castOperator(to);
+            if (castFn == null) {
                 return this.error(`CAST not supported for '${to}'`, expr);
             }
+            return this.composeFunction(castFn, [operand], [expr.operand]);
         }
         else {
             return this.error(`${expr.type} not supported here`, expr);
@@ -458,10 +417,18 @@ export class SqlTools {
             }
         }
     }
-    getParameterRef(expr) {
-        if (this.isParameterRef(expr)) {
-            return `${expr.table.name}.${expr.name}`;
-        }
+    getParameterRefClause(expr) {
+        const table = expr.table.name;
+        const column = expr.name;
+        return {
+            key: `${table}.${column}`,
+            lookupParameterValue: (parameters) => {
+                const pt = parameters[table];
+                return pt?.[column] ?? null;
+            },
+            usesAuthenticatedRequestParameters: table == 'token_parameters',
+            usesUnauthenticatedRequestParameters: table == 'user_parameters'
+        };
     }
     refHasSchema(ref) {
         return ref.table?.schema != null;
@@ -488,6 +455,103 @@ export class SqlTools {
             throw new SqlRuleError(`Undefined table ${ref.table?.name}`, this.sql, ref);
         }
     }
+    /**
+     * Given a function, compile a clause with the function over compiled arguments.
+     *
+     * For functions with multiple arguments, the following combinations are supported:
+     * fn(StaticValueClause, StaticValueClause) => StaticValueClause
+     * fn(ParameterValueClause, ParameterValueClause) => ParameterValueClause
+     * fn(RowValueClause, RowValueClause) => RowValueClause
+     * fn(ParameterValueClause, StaticValueClause) => ParameterValueClause
+     * fn(RowValueClause, StaticValueClause) => RowValueClause
+     *
+     * This is not supported, and will likely never be supported:
+     * fn(ParameterValueClause, RowValueClause) => error
+     *
+     * @param fnImpl The function or operator implementation
+     * @param argClauses The compiled argument clauses
+     * @param debugArgExpressions The original parsed expressions, for debug info only
+     * @returns a compiled function clause
+     */
+    composeFunction(fnImpl, argClauses, debugArgExpressions) {
+        let argsType = 'static';
+        for (let i = 0; i < argClauses.length; i++) {
+            const debugArg = debugArgExpressions[i];
+            const clause = argClauses[i];
+            if (isClauseError(clause)) {
+                // Return immediately on error
+                return clause;
+            }
+            else if (isStaticValueClause(clause)) {
+                // argsType unchanged
+            }
+            else if (isParameterValueClause(clause)) {
+                if (!this.supports_parameter_expressions) {
+                    return this.error(`Cannot use bucket parameters in expressions`, debugArg);
+                }
+                if (argsType == 'static' || argsType == 'param') {
+                    argsType = 'param';
+                }
+                else {
+                    return this.error(`Cannot use table values and parameters in the same clauses`, debugArg);
+                }
+            }
+            else if (isRowValueClause(clause)) {
+                if (argsType == 'static' || argsType == 'row') {
+                    argsType = 'row';
+                }
+                else {
+                    return this.error(`Cannot use table values and parameters in the same clauses`, debugArg);
+                }
+            }
+            else {
+                return this.error(`Parameter match clauses cannot be used here`, debugArg);
+            }
+        }
+        if (argsType == 'row' || argsType == 'static') {
+            return {
+                evaluate: (tables) => {
+                    const args = argClauses.map((e) => e.evaluate(tables));
+                    return fnImpl.call(...args);
+                },
+                getType(schema) {
+                    const argTypes = argClauses.map((e) => e.getType(schema));
+                    return fnImpl.getReturnType(argTypes);
+                }
+            };
+        }
+        else if (argsType == 'param') {
+            const argStrings = argClauses.map((e) => e.key);
+            const name = `${fnImpl.debugName}(${argStrings.join(',')})`;
+            const usesAuthenticatedRequestParameters = argClauses.find((clause) => isParameterValueClause(clause) && clause.usesAuthenticatedRequestParameters) !=
+                null;
+            const usesUnauthenticatedRequestParameters = argClauses.find((clause) => isParameterValueClause(clause) && clause.usesUnauthenticatedRequestParameters) !=
+                null;
+            return {
+                key: name,
+                lookupParameterValue: (parameters) => {
+                    const args = argClauses.map((e) => {
+                        if (isParameterValueClause(e)) {
+                            return e.lookupParameterValue(parameters);
+                        }
+                        else if (isStaticValueClause(e)) {
+                            return e.value;
+                        }
+                        else {
+                            throw new Error('unreachable condition');
+                        }
+                    });
+                    return fnImpl.call(...args);
+                },
+                usesAuthenticatedRequestParameters,
+                usesUnauthenticatedRequestParameters
+            };
+        }
+        else {
+            throw new Error('unreachable condition');
+        }
+    }
+    parameterFunction() { }
 }
 function isStatic(expr) {
     return ['integer', 'string', 'numeric', 'boolean', 'null'].includes(expr.type);
@@ -503,4 +567,33 @@ function staticValue(expr) {
         return expr.value;
     }
 }
+function staticValueClause(value) {
+    return {
+        value: value,
+        // RowValueClause compatibility
+        evaluate: () => value,
+        getType() {
+            return ExpressionType.fromTypeText(sqliteTypeOf(value));
+        },
+        // ParamterValueClause compatibility
+        key: JSONBig.stringify(value),
+        lookupParameterValue(_parameters) {
+            return value;
+        },
+        usesAuthenticatedRequestParameters: false,
+        usesUnauthenticatedRequestParameters: false
+    };
+}
+function basicInputParameter(clause) {
+    return {
+        key: clause.key,
+        expands: false,
+        filteredRowToLookupValue: (filterParameters) => {
+            return filterParameters[clause.key];
+        },
+        parametersToLookupValue: (parameters) => {
+            return clause.lookupParameterValue(parameters);
+        }
+    };
+}
 //# sourceMappingURL=sql_filters.js.map