@powersync/service-sync-rules 0.17.10 → 0.18.1

package/dist/request_functions.d.ts

@@ -0,0 +1,19 @@
+import { ExpressionType } from './ExpressionType.js';
+import { RequestParameters, SqliteValue } from './types.js';
+export interface SqlParameterFunction {
+    readonly debugName: string;
+    call: (parameters: RequestParameters) => SqliteValue;
+    getReturnType(): ExpressionType;
+    /** request.user_id(), request.jwt(), token_parameters.* */
+    usesAuthenticatedRequestParameters: boolean;
+    /** request.parameters(), user_parameters.* */
+    usesUnauthenticatedRequestParameters: boolean;
+    detail: string;
+    documentation: string;
+}
+export declare const REQUEST_FUNCTIONS_NAMED: {
+    parameters: SqlParameterFunction;
+    jwt: SqlParameterFunction;
+    user_id: SqlParameterFunction;
+};
+export declare const REQUEST_FUNCTIONS: Record<string, SqlParameterFunction>;

package/dist/request_functions.js

@@ -0,0 +1,47 @@
+import { ExpressionType } from './ExpressionType.js';
+const request_parameters = {
+    debugName: 'request.parameters',
+    call(parameters) {
+        return parameters.raw_user_parameters;
+    },
+    getReturnType() {
+        return ExpressionType.TEXT;
+    },
+    detail: 'Unauthenticated request parameters as JSON',
+    documentation: 'Returns parameters passed by the client as a JSON string. These parameters are not authenticated - any value can be passed in by the client.',
+    usesAuthenticatedRequestParameters: false,
+    usesUnauthenticatedRequestParameters: true
+};
+const request_jwt = {
+    debugName: 'request.jwt',
+    call(parameters) {
+        return parameters.raw_token_payload;
+    },
+    getReturnType() {
+        return ExpressionType.TEXT;
+    },
+    detail: 'JWT payload as JSON',
+    documentation: 'The JWT payload as a JSON string. This is always validated against trusted keys.',
+    usesAuthenticatedRequestParameters: true,
+    usesUnauthenticatedRequestParameters: false
+};
+const request_user_id = {
+    debugName: 'request.user_id',
+    call(parameters) {
+        return parameters.user_id;
+    },
+    getReturnType() {
+        return ExpressionType.TEXT;
+    },
+    detail: 'Authenticated user id',
+    documentation: "The id of the authenticated user.\nSame as `request.jwt() ->> 'sub'`.",
+    usesAuthenticatedRequestParameters: true,
+    usesUnauthenticatedRequestParameters: false
+};
+export const REQUEST_FUNCTIONS_NAMED = {
+    parameters: request_parameters,
+    jwt: request_jwt,
+    user_id: request_user_id
+};
+export const REQUEST_FUNCTIONS = REQUEST_FUNCTIONS_NAMED;
+//# sourceMappingURL=request_functions.js.map

package/dist/request_functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request_functions.js","sourceRoot":"","sources":["../src/request_functions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAerD,MAAM,kBAAkB,GAAyB;IAC/C,SAAS,EAAE,oBAAoB;IAC/B,IAAI,CAAC,UAA6B;QAChC,OAAO,UAAU,CAAC,mBAAmB,CAAC;IACxC,CAAC;IACD,aAAa;QACX,OAAO,cAAc,CAAC,IAAI,CAAC;IAC7B,CAAC;IACD,MAAM,EAAE,4CAA4C;IACpD,aAAa,EACX,8IAA8I;IAChJ,kCAAkC,EAAE,KAAK;IACzC,oCAAoC,EAAE,IAAI;CAC3C,CAAC;AAEF,MAAM,WAAW,GAAyB;IACxC,SAAS,EAAE,aAAa;IACxB,IAAI,CAAC,UAA6B;QAChC,OAAO,UAAU,CAAC,iBAAiB,CAAC;IACtC,CAAC;IACD,aAAa;QACX,OAAO,cAAc,CAAC,IAAI,CAAC;IAC7B,CAAC;IACD,MAAM,EAAE,qBAAqB;IAC7B,aAAa,EAAE,kFAAkF;IACjG,kCAAkC,EAAE,IAAI;IACxC,oCAAoC,EAAE,KAAK;CAC5C,CAAC;AAEF,MAAM,eAAe,GAAyB;IAC5C,SAAS,EAAE,iBAAiB;IAC5B,IAAI,CAAC,UAA6B;QAChC,OAAO,UAAU,CAAC,OAAO,CAAC;IAC5B,CAAC;IACD,aAAa;QACX,OAAO,cAAc,CAAC,IAAI,CAAC;IAC7B,CAAC;IACD,MAAM,EAAE,uBAAuB;IAC/B,aAAa,EAAE,uEAAuE;IACtF,kCAAkC,EAAE,IAAI;IACxC,oCAAoC,EAAE,KAAK;CAC5C,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,UAAU,EAAE,kBAAkB;IAC9B,GAAG,EAAE,WAAW;IAChB,OAAO,EAAE,eAAe;CACzB,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAyC,uBAAuB,CAAC"}

package/dist/sql_filters.d.ts

@@ -1,7 +1,8 @@
 import { Expr, ExprRef, NodeLocation, SelectedColumn } from 'pgsql-ast-parser';
-import { SqlRuleError } from './errors.js';
-import { ClauseError, CompiledClause, ParameterMatchClause, QuerySchema, StaticRowValueClause, TrueIfParametersMatch } from './types.js';
 import { nil } from 'pgsql-ast-parser/src/utils.js';
+import { SqlRuleError } from './errors.js';
+import { SqlFunction } from './sql_functions.js';
+import { ClauseError, CompiledClause, ParameterMatchClause, ParameterValueClause, QuerySchema, RowValueClause, StaticValueClause, TrueIfParametersMatch } from './types.js';
 export declare const MATCH_CONST_FALSE: TrueIfParametersMatch;
 export declare const MATCH_CONST_TRUE: TrueIfParametersMatch;
 export interface SqlToolsOptions {
@@ -35,15 +36,27 @@ export interface SqlToolsOptions {
      * Only one parameter may be expanded.
      */
     supports_expanding_parameters?: boolean;
+    /**
+     * true if expressions on parameters are supported, e.g. upper(token_parameters.user_id)
+     */
+    supports_parameter_expressions?: boolean;
+    /**
+     * Schema for validations.
+     */
     schema?: QuerySchema;
 }
 export declare class SqlTools {
     default_table?: string;
     value_tables: string[];
+    /**
+     * ['bucket'] for data queries
+     * ['token_parameters', 'user_parameters'] for parameter queries
+     */
     parameter_tables: string[];
     sql: string;
     errors: SqlRuleError[];
     supports_expanding_parameters: boolean;
+    supports_parameter_expressions: boolean;
     schema?: QuerySchema;
     constructor(options: SqlToolsOptions);
     error(message: string, expr: NodeLocation | Expr | undefined): ClauseError;
@@ -55,7 +68,8 @@ export declare class SqlTools {
      * would make the expression true for the row.
      */
     compileWhereClause(where: Expr | nil): ParameterMatchClause;
-    compileStaticExtractor(expr: Expr | nil): StaticRowValueClause | ClauseError;
+    compileRowValueExtractor(expr: Expr | nil): RowValueClause | ClauseError;
+    compileParameterValueExtractor(expr: Expr | nil): ParameterValueClause | StaticValueClause | ClauseError;
     /**
      * Given an expression, return a compiled clause.
      */
@@ -80,7 +94,7 @@ export declare class SqlTools {
      */
     isTableRef(expr: Expr): expr is ExprRef;
     private checkRef;
-    getParameterRef(expr: Expr): string | undefined;
+    getParameterRefClause(expr: ExprRef): ParameterValueClause;
     refHasSchema(ref: ExprRef): boolean;
     /**
      * Get the table name from an expression.
@@ -88,4 +102,24 @@ export declare class SqlTools {
      * Only "value" tables are supported here, not parameter values.
      */
     getTableName(ref: ExprRef): string;
+    /**
+     * 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: SqlFunction, argClauses: CompiledClause[], debugArgExpressions: Expr[]): CompiledClause;
+    parameterFunction(): void;
 }