@powersync/service-core 1.19.2 → 1.20.0

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 config 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/routes/stream.test.ts

@@ -8,6 +8,7 @@ import winston from 'winston';
 import { syncStreamed } from '../../../src/routes/endpoints/sync-stream.js';
 import { DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS, limitParamsForLogging } from '../../../src/util/param-logging.js';
 import { mockServiceContext } from './mocks.js';
+import { DEFAULT_HYDRATION_STATE } from '@powersync/service-sync-rules';
 
 describe('Stream Route', () => {
   describe('compressed stream', () => {
@@ -45,7 +46,7 @@ describe('Stream Route', () => {
 
       const storage = {
         getParsedSyncRules() {
-          return new SqlSyncRules('bucket_definitions: {}').hydrate();
+          return new SqlSyncRules('bucket_definitions: {}').hydrate({ hydrationState: DEFAULT_HYDRATION_STATE });
         },
         watchCheckpointChanges: async function* (options) {
           throw new Error('Simulated storage error');
@@ -83,7 +84,7 @@ describe('Stream Route', () => {
     it('logs the application metadata', async () => {
       const storage = {
         getParsedSyncRules() {
-          return new SqlSyncRules('bucket_definitions: {}').hydrate();
+          return new SqlSyncRules('bucket_definitions: {}').hydrate({ hydrationState: DEFAULT_HYDRATION_STATE });
         },
         watchCheckpointChanges: async function* (options) {
           throw new Error('Simulated storage error');