Add debug representation

Author: simolus3

packages/service-core/src/routes/endpoints/sync-rules.ts

@@ -1,5 +1,5 @@
 import { ErrorCode, errors, router, schema } from '@powersync/lib-services-framework';
-import { SqlBucketDescriptor, SqlSyncRules, SyncRulesErrors } from '@powersync/service-sync-rules';
+import { SqlSyncRules, SyncRulesErrors } from '@powersync/service-sync-rules';
 import type { FastifyPluginAsync } from 'fastify';
 import * as t from 'ts-codec';
 

packages/sync-rules/src/BaseSqlDataQuery.ts

@@ -163,6 +163,18 @@ export class BaseSqlDataQuery {
     return result;
   }
 
+  resolveResultSets(schema: SourceSchema, tables: Record<string, Record<string, ColumnDefinition>>) {
+    const outTables = this.getColumnOutputs(schema);
+    for (let table of outTables) {
+      tables[table.name] ??= {};
+      for (let column of table.columns) {
+        if (column.name != 'id') {
+          tables[table.name][column.name] ??= column;
+        }
+      }
+    }
+  }
+
   evaluateRowWithOptions(options: EvaluateRowOptions): EvaluationResult[] {
     try {
       const { table, row, bucketIds } = options;

packages/sync-rules/src/SqlBucketDescriptor.ts

@@ -201,15 +201,7 @@ export class SqlBucketDescriptor implements BucketSource {
 
   resolveResultSets(schema: SourceSchema, tables: Record<string, Record<string, ColumnDefinition>>) {
     for (let query of this.dataQueries) {
-      const outTables = query.getColumnOutputs(schema);
-      for (let table of outTables) {
-        tables[table.name] ??= {};
-        for (let column of table.columns) {
-          if (column.name != 'id') {
-            tables[table.name][column.name] ??= column;
-          }
-        }
-      }
+      query.resolveResultSets(schema, tables);
     }
   }
 

packages/sync-rules/src/streams/parameter.ts

@@ -21,7 +21,6 @@ import {
  */
 export interface BucketParameter {
   lookup: StaticLookup | EqualsRowInSubqueryLookup | OverlapsSubqueryLookup;
-
   /**
    * Given a row in the table the stream is selecting from, return all possible instantiations of this parameter that
    * would match the row.

packages/sync-rules/src/streams/stream.ts

@@ -2,6 +2,7 @@ import { BaseSqlDataQuery } from '../BaseSqlDataQuery.js';
 import { BucketInclusionReason, BucketPriority, DEFAULT_BUCKET_PRIORITY } from '../BucketDescription.js';
 import { BucketParameterQuerier, PendingQueriers } from '../BucketParameterQuerier.js';
 import { BucketSource, BucketSourceType, ResultSetDescription } from '../BucketSource.js';
+import { ColumnDefinition } from '../ExpressionType.js';
 import { SourceTableInterface } from '../SourceTableInterface.js';
 import { GetQuerierOptions, RequestedStream } from '../SqlSyncRules.js';
 import { TablePattern } from '../TablePattern.js';
@@ -88,7 +89,7 @@ export class SyncStream implements BucketSource {
   }
 
   hasDynamicBucketQueries(): boolean {
-    throw new Error('Method not implemented.');
+    return this.variants.some((v) => v.hasDynamicBucketQueries);
   }
 
   tableSyncsData(table: SourceTableInterface): boolean {
@@ -108,19 +109,44 @@ export class SyncStream implements BucketSource {
   }
 
   getSourceTables(): Set<TablePattern> {
-    throw new Error('Method not implemented.');
+    let result = new Set<TablePattern>();
+    result.add(this.data.sourceTable);
+    for (let variant of this.variants) {
+      for (const subquery of variant.subqueries) {
+        result.add(subquery.parameterTable);
+      }
+    }
+
+    // Note: No physical tables for global_parameter_queries
+
+    return result;
   }
 
-  resolveResultSets(schema: SourceSchema): ResultSetDescription[] {
-    throw new Error('Method not implemented.');
+  resolveResultSets(schema: SourceSchema, tables: Record<string, Record<string, ColumnDefinition>>) {
+    this.data.resolveResultSets(schema, tables);
   }
 
   debugRepresentation() {
+    return {
+      name: this.name,
+      type: this.type.toString(),
+      variants: this.variants.map((v) => v.debugRepresentation()),
+      data: {
+        table: this.data.sourceTable,
+        columns: this.data.columnOutputNames()
+      }
+    };
+
     throw new Error('Method not implemented.');
   }
 
   debugWriteOutputTables(result: Record<string, { query: string }[]>): void {
-    throw new Error('Method not implemented.');
+    result[this.data.table!] ??= [];
+    const r = {
+      query: this.data.sql
+    };
+
+    result[this.data.table!].push(r);
   }
 
   evaluateParameterRow(sourceTable: SourceTableInterface, row: SqliteRow): EvaluatedParametersResult[] {

packages/sync-rules/src/streams/variant.ts

@@ -112,6 +112,10 @@ export class StreamVariant {
     return [...cartesianProduct(...instantiations)];
   }
 
+  get hasDynamicBucketQueries(): boolean {
+    return this.requestFilters.some((f) => f.type == 'dynamic');
+  }
+
   querier(stream: SyncStream, reason: BucketInclusionReason, params: RequestParameters): BucketParameterQuerier | null {
     const instantiation = this.partiallyEvaluateParameters(params);
     if (instantiation == null) {
@@ -242,6 +246,20 @@ export class StreamVariant {
     }
   }
 
+  debugRepresentation(): any {
+    return {
+      id: this.id,
+      parameters: this.parameters.map((p) => ({
+        type: p.lookup.type
+      })),
+      subqueries: this.subqueries.map((s) => ({
+        table: s.parameterTable
+      })),
+      additional_row_filters: this.additionalRowFilters.length,
+      request_filters: this.requestFilters.map((f) => f.type)
+    };
+  }
+
   /**
    * Replaces {@link StreamVariant.parameters} with static values looked up in request parameters.
    *