Revert more sync-rule changes

Author: simolus3

packages/sync-rules/src/json_schema.ts

@@ -49,37 +49,6 @@ export const syncRulesSchema: ajvModule.Schema = {
         }
       }
     },
-    streams: {
-      type: 'object',
-      description: 'Stream definitions',
-      patternProperties: {
-        '.*': {
-          type: 'object',
-          required: ['query'],
-          examples: [{ query: ['select * from mytable'] }],
-          properties: {
-            accept_potentially_dangerous_queries: {
-              description: 'If true, disables warnings on potentially dangerous queries',
-              type: 'boolean'
-            },
-            priority: {
-              description:
-                'Default priority for the stream (lower values indicate higher priority). Clients can override the priority when subscribing.',
-              type: 'integer'
-            },
-            default: {
-              type: 'boolean',
-              description: 'Whether the stream should be subscribed to by default.'
-            },
-            query: {
-              description: 'The SQL query to sync to clients.',
-              type: 'string'
-            }
-          },
-          additionalProperties: false
-        }
-      }
-    },
     event_definitions: {
       type: 'object',
       description: 'Record of sync replication event definitions',
@@ -110,7 +79,7 @@ export const syncRulesSchema: ajvModule.Schema = {
       }
     }
   },
-  //  required: ['bucket_definitions'],
+  required: ['bucket_definitions'],
   additionalProperties: false
 } as const;
 

packages/sync-rules/src/request_functions.ts

@@ -56,25 +56,10 @@ const request_user_id: SqlParameterFunction = {
   usesUnauthenticatedRequestParameters: false
 };
 
-export const REQUEST_FUNCTIONS: Record<string, SqlParameterFunction> = {
+export const REQUEST_FUNCTIONS_NAMED = {
   parameters: request_parameters,
   jwt: request_jwt,
   user_id: request_user_id
 };
 
-export const QUERY_FUNCTIONS: Record<string, SqlParameterFunction> = {
-  params: {
-    debugName: 'stream.params',
-    call(parameters: ParameterValueSet) {
-      return parameters.rawUserParameters;
-    },
-    getReturnType() {
-      return ExpressionType.TEXT;
-    },
-    detail: 'Unauthenticated stream parameters as JSON',
-    documentation:
-      'Returns stream passed by the client when opening the stream. These parameters are not authenticated - any value can be passed in by the client.',
-    usesAuthenticatedRequestParameters: false,
-    usesUnauthenticatedRequestParameters: true
-  }
-};
+export const REQUEST_FUNCTIONS: Record<string, SqlParameterFunction> = REQUEST_FUNCTIONS_NAMED;

packages/sync-rules/src/sql_filters.ts

@@ -4,7 +4,7 @@ import { nil } from 'pgsql-ast-parser/src/utils.js';
 import { BucketPriority, isValidPriority } from './BucketDescription.js';
 import { ExpressionType } from './ExpressionType.js';
 import { SqlRuleError } from './errors.js';
-import { QUERY_FUNCTIONS, REQUEST_FUNCTIONS } from './request_functions.js';
+import { REQUEST_FUNCTIONS } from './request_functions.js';
 import {
   BASIC_OPERATORS,
   OPERATOR_IN,
@@ -94,11 +94,6 @@ export interface SqlToolsOptions {
    */
   supportsParameterExpressions?: boolean;
 
-  /**
-   * true if expressions on stream parameters are supported.
-   */
-  supportsStreamInputs?: boolean;
-
   /**
    * Schema for validations.
    */
@@ -118,9 +113,6 @@ export class SqlTools {
 
   readonly supportsExpandingParameters: boolean;
   readonly supportsParameterExpressions: boolean;
-  readonly supportsStreamInputs: boolean;
-
-  private inferredStaticParameters: Map<string, InferredBucketParameter> = new Map();
 
   schema?: QuerySchema;
 
@@ -139,7 +131,6 @@ export class SqlTools {
     this.sql = options.sql;
     this.supportsExpandingParameters = options.supportsExpandingParameters ?? false;
     this.supportsParameterExpressions = options.supportsParameterExpressions ?? false;
-    this.supportsStreamInputs = options.supportsStreamInputs ?? false;
   }
 
   error(message: string, expr: NodeLocation | Expr | undefined): ClauseError {
@@ -280,7 +271,7 @@ export class SqlTools {
           return compileStaticOperator(op, leftFilter as RowValueClause, rightFilter as RowValueClause);
         } else if (isParameterValueClause(otherFilter)) {
           // 2. row value = parameter value
-          const inputParam = this.basicInputParameter(otherFilter);
+          const inputParam = basicInputParameter(otherFilter);
 
           return {
             error: false,
@@ -327,7 +318,7 @@ export class SqlTools {
         } else if (isParameterValueClause(leftFilter) && isRowValueClause(rightFilter)) {
           // token_parameters.value IN table.some_array
           // bucket.param IN table.some_array
-          const inputParam = this.basicInputParameter(leftFilter);
+          const inputParam = basicInputParameter(leftFilter);
 
           return {
             error: false,
@@ -434,25 +425,7 @@ export class SqlTools {
         if (fn in REQUEST_FUNCTIONS) {
           const fnImpl = REQUEST_FUNCTIONS[fn];
           return {
-            key: `stream.${fn}()`,
-            lookupParameterValue(parameters) {
-              return fnImpl.call(parameters);
-            },
-            usesAuthenticatedRequestParameters: fnImpl.usesAuthenticatedRequestParameters,
-            usesUnauthenticatedRequestParameters: fnImpl.usesUnauthenticatedRequestParameters
-          } satisfies ParameterValueClause;
-        } else {
-          return this.error(`Function '${schema}.${fn}' is not defined`, expr);
-        }
-      } else if (schema == 'stream') {
-        if (!this.supportsStreamInputs) {
-          return this.error(`${schema} schema is only available in stream definitions`, expr);
-        }
-
-        if (fn in QUERY_FUNCTIONS) {
-          const fnImpl = QUERY_FUNCTIONS[fn];
-          return {
-            key: `stream.${fn}()`,
+            key: 'request.parameters()',
             lookupParameterValue(parameters) {
               return fnImpl.call(parameters);
             },
@@ -784,58 +757,8 @@ export class SqlTools {
 
     return value as BucketPriority;
   }
-
-  private basicInputParameter(clause: ParameterValueClause): InputParameter {
-    if (this.supportsStreamInputs) {
-      let key = this.inferredStaticParameters.get(clause.key)?.name;
-      if (key == null) {
-        key = this.newInferredBucketParameterName();
-        this.inferredStaticParameters.set(clause.key, {
-          name: key,
-          variant: 'static',
-          clause
-        });
-      }
-
-      return {
-        key,
-        expands: false,
-        filteredRowToLookupValue: () => {
-          return SQLITE_FALSE; // Only relevant for parameter queries, but this is a stream query.
-        },
-        parametersToLookupValue: () => {
-          return SQLITE_FALSE;
-        }
-      };
-    }
-
-    return {
-      key: clause.key,
-      expands: false,
-      filteredRowToLookupValue: (filterParameters) => {
-        return filterParameters[clause.key];
-      },
-      parametersToLookupValue: (parameters) => {
-        return clause.lookupParameterValue(parameters);
-      }
-    };
-  }
-
-  public get inferredParameters(): InferredBucketParameter[] {
-    return [...this.inferredStaticParameters.values()];
-  }
-
-  private newInferredBucketParameterName() {
-    return `p${this.inferredStaticParameters.size}`;
-  }
 }
 
-export type InferredBucketParameter = {
-  name: string;
-} & StaticBucketParameter;
-
-export type StaticBucketParameter = { variant: 'static'; clause: ParameterValueClause };
-
 function isStatic(expr: Expr) {
   return ['integer', 'string', 'numeric', 'boolean', 'null'].includes(expr.type);
 }
@@ -872,3 +795,16 @@ function staticValueClause(value: SqliteValue): StaticValueClause {
     usesUnauthenticatedRequestParameters: false
   };
 }
+
+function basicInputParameter(clause: ParameterValueClause): InputParameter {
+  return {
+    key: clause.key,
+    expands: false,
+    filteredRowToLookupValue: (filterParameters) => {
+      return filterParameters[clause.key];
+    },
+    parametersToLookupValue: (parameters) => {
+      return clause.lookupParameterValue(parameters);
+    }
+  };
+}