@powersync/service-core 0.0.0-dev-20260223082111 → 0.0.0-dev-20260225093637

package/src/util/config/sync-rules/impl/base64-sync-rules-collector.ts

@@ -1,6 +1,6 @@
+import { configFile } from '@powersync/service-types';
 import { RunnerConfig, SyncRulesConfig } from '../../types.js';
 import { SyncRulesCollector } from '../sync-collector.js';
-import { configFile } from '@powersync/service-types';
 
 export class Base64SyncRulesCollector extends SyncRulesCollector {
   get name(): string {
@@ -8,15 +8,15 @@ export class Base64SyncRulesCollector extends SyncRulesCollector {
   }
 
   async collect(baseConfig: configFile.PowerSyncConfig, runnerConfig: RunnerConfig): Promise<SyncRulesConfig | null> {
-    const { sync_rules_base64 } = runnerConfig;
-    if (!sync_rules_base64) {
+    const { sync_config_base64 } = runnerConfig;
+    if (!sync_config_base64) {
       return null;
     }
 
     return {
       present: true,
-      exit_on_error: baseConfig.sync_rules?.exit_on_error ?? true,
-      content: Buffer.from(sync_rules_base64, 'base64').toString()
+      exit_on_error: baseConfig.sync_config?.exit_on_error ?? true,
+      content: Buffer.from(sync_config_base64, 'base64').toString()
     };
   }
 }

package/src/util/config/sync-rules/impl/filesystem-sync-rules-collector.ts

@@ -1,7 +1,7 @@
+import { configFile } from '@powersync/service-types';
 import * as path from 'path';
 import { RunnerConfig, SyncRulesConfig } from '../../types.js';
 import { SyncRulesCollector } from '../sync-collector.js';
-import { configFile } from '@powersync/service-types';
 
 export class FileSystemSyncRulesCollector extends SyncRulesCollector {
   get name(): string {
@@ -9,7 +9,7 @@ export class FileSystemSyncRulesCollector extends SyncRulesCollector {
   }
 
   async collect(baseConfig: configFile.PowerSyncConfig, runnerConfig: RunnerConfig): Promise<SyncRulesConfig | null> {
-    const sync_path = baseConfig.sync_rules?.path;
+    const sync_path = baseConfig.sync_config?.path;
     if (!sync_path) {
       return null;
     }
@@ -20,7 +20,7 @@ export class FileSystemSyncRulesCollector extends SyncRulesCollector {
     // Only persist the path here, and load on demand using `loadSyncRules()`.
     return {
       present: true,
-      exit_on_error: baseConfig.sync_rules?.exit_on_error ?? true,
+      exit_on_error: baseConfig.sync_config?.exit_on_error ?? true,
       path: config_path ? path.resolve(path.dirname(config_path), sync_path) : sync_path
     };
   }

package/src/util/config/sync-rules/impl/inline-sync-rules-collector.ts

@@ -1,6 +1,6 @@
+import { configFile } from '@powersync/service-types';
 import { SyncRulesConfig } from '../../types.js';
 import { SyncRulesCollector } from '../sync-collector.js';
-import { configFile } from '@powersync/service-types';
 
 export class InlineSyncRulesCollector extends SyncRulesCollector {
   get name(): string {
@@ -8,15 +8,15 @@ export class InlineSyncRulesCollector extends SyncRulesCollector {
   }
 
   async collect(baseConfig: configFile.PowerSyncConfig): Promise<SyncRulesConfig | null> {
-    const content = baseConfig.sync_rules?.content;
+    const content = baseConfig?.sync_config?.content;
     if (!content) {
       return null;
     }
 
     return {
       present: true,
-      exit_on_error: true,
-      ...baseConfig.sync_rules
+      exit_on_error: baseConfig.sync_config?.exit_on_error ?? true,
+      ...baseConfig.sync_config
     };
   }
 }

package/src/util/config/types.ts

@@ -1,6 +1,5 @@
 import { configFile } from '@powersync/service-types';
 import { CompoundKeyCollector } from '../../auth/CompoundKeyCollector.js';
-import { KeySpec } from '../../auth/KeySpec.js';
 import { KeyStore } from '../../auth/KeyStore.js';
 
 export enum ServiceRunner {
@@ -12,7 +11,7 @@ export enum ServiceRunner {
 export type RunnerConfig = {
   config_path?: string;
   config_base64?: string;
-  sync_rules_base64?: string;
+  sync_config_base64?: string;
 };
 
 export type MigrationContext = {

package/src/util/env.ts

@@ -12,9 +12,14 @@ export const env = utils.collectEnvironmentVariables({
    */
   POWERSYNC_CONFIG_B64: utils.type.string.optional(),
   /**
+   * @deprecated use POWERSYNC_SYNC_CONFIG_B64 instead.
    * Base64 encoded contents of sync rules YAML
    */
   POWERSYNC_SYNC_RULES_B64: utils.type.string.optional(),
+  /**
+   * Base64 encoded contents of sync rules YAML
+   */
+  POWERSYNC_SYNC_CONFIG_B64: utils.type.string.optional(),
   /**
    * Runner to be started in this process
    */

package/test/src/config.test.ts

@@ -69,6 +69,7 @@ describe('Config', () => {
 
     expect(config.api_parameters.max_buckets_per_connection).toBe(1);
   });
+
   it('should throw YAML validation error for invalid base64 config', {}, async () => {
     const yamlConfig = /* yaml */ `
       # PowerSync config
@@ -86,4 +87,118 @@ describe('Config', () => {
       })
     ).rejects.toThrow(/YAML Error:[\s\S]*Attempting to substitute environment variable INVALID_VAR/);
   });
+
+  it('should resolve inline sync config', async () => {
+    const yamlConfig = /* yaml */ `
+      # PowerSync config
+      replication:
+        connections: []
+      storage:
+        type: mongodb
+      sync_config:
+        content: |
+          config:
+            edition: 2
+          streams:
+            a:
+              query: SELECT * FROM users
+    `;
+
+    const collector = new CompoundConfigCollector();
+
+    const result = await collector.collectConfig({
+      config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64')
+    });
+
+    expect(result.sync_rules).toEqual({
+      present: true,
+      exit_on_error: true,
+      content: expect.stringContaining('edition: 2')
+    });
+  });
+
+  it('should still resolve inline sync rules', async () => {
+    const yamlConfig = /* yaml */ `
+      # PowerSync config
+      replication:
+        connections: []
+      storage:
+        type: mongodb
+      sync_rules:
+        content: |
+          config:
+            edition: 2
+          streams:
+            a:
+              query: SELECT * FROM users
+    `;
+
+    const collector = new CompoundConfigCollector();
+
+    const result = await collector.collectConfig({
+      config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64')
+    });
+
+    expect(result.sync_rules).toEqual({
+      present: true,
+      exit_on_error: true,
+      content: expect.stringContaining('edition: 2')
+    });
+  });
+
+  it('should resolve base64 sync config', async () => {
+    const yamlConfig = /* yaml */ `
+      # PowerSync config
+      replication:
+        connections: []
+      storage:
+        type: mongodb
+    `;
+    const yamlSyncConfig = /* yaml */ `
+      config:
+        edition: 2
+      streams:
+        a:
+          query: SELECT * FROM users
+    `;
+
+    const collector = new CompoundConfigCollector();
+
+    const result = await collector.collectConfig({
+      config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64'),
+      sync_config_base64: Buffer.from(yamlSyncConfig, 'utf-8').toString('base64')
+    });
+
+    expect(result.sync_rules).toEqual({
+      present: true,
+      exit_on_error: true,
+      content: expect.stringContaining('edition: 2')
+    });
+  });
+
+  it('should not allow both sync_config and sync_rules', async () => {
+    const yamlConfig = /* yaml */ `
+      # PowerSync config
+      replication:
+        connections: []
+      storage:
+        type: mongodb
+      sync_config:
+        content: |
+          config:
+            edition: 2
+      sync_rules:
+        content: |
+          config:
+            edition: 2
+    `;
+
+    const collector = new CompoundConfigCollector();
+
+    await expect(
+      collector.collectConfig({
+        config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64')
+      })
+    ).rejects.toThrow(/Both `sync_config` and `sync_rules` are present/);
+  });
 });

package/test/src/routes/admin.test.ts

@@ -0,0 +1,48 @@
+import { BasicRouterRequest, Context, JwtPayload } from '@/index.js';
+import { logger } from '@powersync/lib-services-framework';
+import { describe, expect, it } from 'vitest';
+import { validate } from '../../../src/routes/endpoints/admin.js';
+import { mockServiceContext } from './mocks.js';
+
+describe('admin routes', () => {
+  describe('validate', () => {
+    it('reports errors with source location', async () => {
+      const context: Context = {
+        logger: logger,
+        service_context: mockServiceContext(null),
+        token_payload: new JwtPayload({
+          sub: '',
+          exp: 0,
+          iat: 0
+        })
+      };
+
+      const request: BasicRouterRequest = {
+        headers: {},
+        hostname: '',
+        protocol: 'http'
+      };
+
+      const response = await validate.handler({
+        context,
+        params: {
+          sync_rules: `
+bucket_definitions:
+  missing_table:
+    data:
+      - SELECT * FROM missing_table
+`
+        },
+        request
+      });
+
+      expect(response.errors).toEqual([
+        expect.objectContaining({
+          level: 'warning',
+          location: { start_offset: 70, end_offset: 83 },
+          message: 'Table public.missing_table not found'
+        })
+      ]);
+    });
+  });
+});

package/test/src/routes/mocks.ts

@@ -41,8 +41,29 @@ export function mockServiceContext(storage: Partial<SyncRulesBucketStorage> | nu
         return {
           getParseSyncRulesOptions() {
             return { defaultSchema: 'public' };
+          },
+          async getSourceConfig() {
+            return {
+              tag: 'test_tag',
+              id: 'test_id',
+              type: 'test_type'
+            };
+          },
+          async getConnectionSchema() {
+            return [];
+          },
+          async getConnectionStatus() {
+            return {
+              id: 'test_id',
+              uri: 'http://example.org/',
+              connected: true,
+              errors: []
+            };
+          },
+          async getDebugTablesInfo() {
+            return [];
           }
-        } as Partial<RouteAPI>;
+        } satisfies Partial<RouteAPI> as unknown as RouteAPI;
       },
       addStopHandler() {
         return () => {};

package/test/src/sync/BucketChecksumState.test.ts

@@ -827,6 +827,206 @@ config:
       });
     });
   });
+
+  describe('parameter query result logging', () => {
+    test('logs parameter query results for dynamic buckets', async () => {
+      const storage = new MockBucketChecksumStateStorage();
+      storage.updateTestChecksum({ bucket: 'by_project[1]', checksum: 1, count: 1 });
+      storage.updateTestChecksum({ bucket: 'by_project[2]', checksum: 1, count: 1 });
+      storage.updateTestChecksum({ bucket: 'by_project[3]', checksum: 1, count: 1 });
+
+      const logMessages: string[] = [];
+      const logData: any[] = [];
+      const mockLogger = {
+        info: (message: string, data: any) => {
+          logMessages.push(message);
+          logData.push(data);
+        },
+        error: () => {},
+        warn: () => {},
+        debug: () => {}
+      };
+
+      const state = new BucketChecksumState({
+        syncContext,
+        tokenPayload: new JwtPayload({ sub: 'u1' }),
+        syncRequest,
+        syncRules: SYNC_RULES_DYNAMIC,
+        bucketStorage: storage,
+        logger: mockLogger as any
+      });
+
+      const line = (await state.buildNextCheckpointLine({
+        base: storage.makeCheckpoint(1n, (lookups) => {
+          return [{ id: 1 }, { id: 2 }, { id: 3 }];
+        }),
+        writeCheckpoint: null,
+        update: CHECKPOINT_INVALIDATE_ALL
+      }))!;
+      line.advance();
+
+      expect(logMessages[0]).toContain('param_results: 3');
+      expect(logData[0].parameter_query_results).toBe(3);
+    });
+
+    test('throws error with breakdown when parameter query limit is exceeded', async () => {
+      const SYNC_RULES_MULTI = SqlSyncRules.fromYaml(
+        `
+bucket_definitions:
+  projects:
+    parameters: select id from projects where user_id = request.user_id()
+    data: []
+  tasks:
+    parameters: select id from tasks where user_id = request.user_id()
+    data: []
+  comments:
+    parameters: select id from comments where user_id = request.user_id()
+    data: []
+    `,
+        { defaultSchema: 'public' }
+      ).config.hydrate({ hydrationState: versionedHydrationState(4) });
+
+      const storage = new MockBucketChecksumStateStorage();
+
+      const errorMessages: string[] = [];
+      const errorData: any[] = [];
+      const mockLogger = {
+        info: () => {},
+        error: (message: string, data: any) => {
+          errorMessages.push(message);
+          errorData.push(data);
+        },
+        warn: () => {},
+        debug: () => {}
+      };
+
+      const smallContext = new SyncContext({
+        maxBuckets: 100,
+        maxParameterQueryResults: 50,
+        maxDataFetchConcurrency: 10
+      });
+
+      const state = new BucketChecksumState({
+        syncContext: smallContext,
+        tokenPayload: new JwtPayload({ sub: 'u1' }),
+        syncRequest,
+        syncRules: SYNC_RULES_MULTI,
+        bucketStorage: storage,
+        logger: mockLogger as any
+      });
+
+      // Create 60 total results: 30 projects + 20 tasks + 10 comments
+      const projectIds = Array.from({ length: 30 }, (_, i) => ({ id: i + 1 }));
+      const taskIds = Array.from({ length: 20 }, (_, i) => ({ id: i + 1 }));
+      const commentIds = Array.from({ length: 10 }, (_, i) => ({ id: i + 1 }));
+
+      for (let i = 1; i <= 30; i++) {
+        storage.updateTestChecksum({ bucket: `projects[${i}]`, checksum: 1, count: 1 });
+      }
+      for (let i = 1; i <= 20; i++) {
+        storage.updateTestChecksum({ bucket: `tasks[${i}]`, checksum: 1, count: 1 });
+      }
+      for (let i = 1; i <= 10; i++) {
+        storage.updateTestChecksum({ bucket: `comments[${i}]`, checksum: 1, count: 1 });
+      }
+
+      await expect(
+        state.buildNextCheckpointLine({
+          base: storage.makeCheckpoint(1n, (lookups) => {
+            const lookup = lookups[0];
+            const lookupName = lookup.values[0];
+            if (lookupName === 'projects') {
+              return projectIds;
+            } else if (lookupName === 'tasks') {
+              return taskIds;
+            } else {
+              return commentIds;
+            }
+          }),
+          writeCheckpoint: null,
+          update: CHECKPOINT_INVALIDATE_ALL
+        })
+      ).rejects.toThrow('Too many parameter query results: 60 (limit of 50)');
+
+      // Verify error log includes breakdown
+      expect(errorMessages[0]).toContain('Parameter query results by definition:');
+      expect(errorMessages[0]).toContain('projects: 30');
+      expect(errorMessages[0]).toContain('tasks: 20');
+      expect(errorMessages[0]).toContain('comments: 10');
+
+      expect(errorData[0].parameter_query_results).toBe(60);
+      expect(errorData[0].parameter_query_results_by_definition).toEqual({
+        projects: 30,
+        tasks: 20,
+        comments: 10
+      });
+    });
+
+    test('limits breakdown to top 10 definitions', async () => {
+      // Create sync rules with 15 different definitions with dynamic parameters
+      let yamlDefinitions = 'bucket_definitions:\n';
+      for (let i = 1; i <= 15; i++) {
+        yamlDefinitions += `  def${i}:\n`;
+        yamlDefinitions += `    parameters: select id from def${i}_table where user_id = request.user_id()\n`;
+        yamlDefinitions += `    data: []\n`;
+      }
+
+      const SYNC_RULES_MANY = SqlSyncRules.fromYaml(yamlDefinitions, { defaultSchema: 'public' }).config.hydrate({
+        hydrationState: versionedHydrationState(5)
+      });
+
+      const storage = new MockBucketChecksumStateStorage();
+
+      const errorMessages: string[] = [];
+      const mockLogger = {
+        info: () => {},
+        error: (message: string) => {
+          errorMessages.push(message);
+        },
+        warn: () => {},
+        debug: () => {}
+      };
+
+      const smallContext = new SyncContext({
+        maxBuckets: 100,
+        maxParameterQueryResults: 10,
+        maxDataFetchConcurrency: 10
+      });
+
+      const state = new BucketChecksumState({
+        syncContext: smallContext,
+        tokenPayload: new JwtPayload({ sub: 'u1' }),
+        syncRequest,
+        syncRules: SYNC_RULES_MANY,
+        bucketStorage: storage,
+        logger: mockLogger as any
+      });
+
+      // Each definition creates one bucket, total 15 buckets
+      for (let i = 1; i <= 15; i++) {
+        storage.updateTestChecksum({ bucket: `def${i}[${i}]`, checksum: 1, count: 1 });
+      }
+
+      await expect(
+        state.buildNextCheckpointLine({
+          base: storage.makeCheckpoint(1n, (lookups) => {
+            // Return one result for each definition
+            return [{ id: 1 }];
+          }),
+          writeCheckpoint: null,
+          update: CHECKPOINT_INVALIDATE_ALL
+        })
+      ).rejects.toThrow('Too many parameter query results: 15 (limit of 10)');
+
+      // Verify only top 10 are shown
+      const errorMessage = errorMessages[0];
+      expect(errorMessage).toContain('... and 5 more results from 5 definitions');
+
+      // Count how many definitions are listed (should be exactly 10)
+      const defMatches = errorMessage.match(/def\d+:/g);
+      expect(defMatches?.length).toBe(10);
+    });
+  });
 });
 
 class MockBucketChecksumStateStorage implements BucketChecksumStateStorage {