@powersync/service-core 1.20.5 → 1.21.0

package/src/tracing/TraceWriter.ts

@@ -0,0 +1,67 @@
+import { Mutex } from 'async-mutex';
+import * as fs from 'node:fs/promises';
+
+/**
+ * Write traces in the Chrome JSON Trace Format.
+ *
+ * View at https://ui.perfetto.dev/
+ */
+class TraceWriter {
+  handle: fs.FileHandle | null = null;
+  length = 0;
+  queue: any[] = [];
+  private mutex = new Mutex();
+
+  constructor(public readonly path: string) {
+    this.open().catch((e) => {
+      console.error(`Failed to open trace file at ${path}`, e);
+    });
+  }
+
+  async open() {
+    await this.mutex.runExclusive(async () => {
+      this.handle = await fs.open(this.path, 'w+');
+      this.handle.truncate(0);
+      await this.handle.write('[]');
+      this.length = 2;
+    });
+  }
+
+  write(...traceEvents: any[]) {
+    this.writeAsync(...traceEvents).catch((e) => {
+      console.error(`Failed to write trace file`, e);
+    });
+  }
+
+  async writeAsync(...traceEvents: any[]) {
+    this.queue.push(...traceEvents);
+    await this.mutex.runExclusive(async () => {
+      if (this.queue.length > 0) {
+        // Write queued events.
+        // After each write, we end the file as a valid JSON array.
+        // On the next write, we overwrite the last character to extend the array.
+        const buffer = Buffer.from(JSON.stringify(this.queue));
+        await this.handle?.write(buffer, 1, buffer.length - 1, this.length - 1);
+        this.queue = [];
+        this.length += buffer.length - 2;
+      }
+    });
+  }
+}
+
+const traceFile = process.env.POWERSYNC_TRACE_FILE;
+/**
+ * traceWriter, only present if POWERSYNC_TRACE_FILE env var is configured.
+ */
+export const traceWriter = traceFile ? new TraceWriter(traceFile) : null;
+
+if (traceWriter) {
+  traceWriter.write({
+    ph: 'M',
+    cat: '__metadata',
+    name: 'process_name',
+    pid: process.pid,
+    tid: 1000,
+    args: { name: 'powersync' }
+  });
+}

package/src/util/checkpointing.ts

@@ -13,7 +13,7 @@ export async function createWriteCheckpoint(options: CreateWriteCheckpointOption
 
   const syncBucketStorage = await options.storage.getActiveStorage();
   if (!syncBucketStorage) {
-    throw new ServiceError(ErrorCode.PSYNC_S2302, `Cannot create Write Checkpoint since no sync rules are active.`);
+    throw new ServiceError(ErrorCode.PSYNC_S2302, `Cannot create Write Checkpoint since no sync config is active.`);
   }
 
   const { writeCheckpoint, currentCheckpoint } = await options.api.createReplicationHead(async (currentCheckpoint) => {

package/src/util/config/compound-config-collector.ts

@@ -26,7 +26,7 @@ export type CompoundConfigCollectorOptions = {
    */
   configCollectors: ConfigCollector[];
   /**
-   * Collectors for PowerSync sync rules content.
+   * Collectors for PowerSync sync config content.
    * The configuration from first collector to provide a configuration
    * is used. The order of the collectors specifies precedence
    */
@@ -236,11 +236,11 @@ export class CompoundConfigCollector {
           return config;
         }
         logger.debug(
-          `Could not collect sync rules with ${collector.name} method. Moving on to next method if available.`
+          `Could not collect sync config with ${collector.name} method. Moving on to next method if available.`
         );
       } catch (ex) {
         // An error in a collector is a hard stop
-        throw new Error(`Could not collect sync rules using ${collector.name} method. Caught exception: ${ex}`);
+        throw new Error(`Could not collect sync config using ${collector.name} method. Caught exception: ${ex}`);
       }
     }
     return {

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

@@ -16,7 +16,7 @@ export class FileSystemSyncRulesCollector extends SyncRulesCollector {
 
     const { config_path } = runnerConfig;
 
-    // Depending on the container, the sync rules may not actually be present.
+    // Depending on the container, the sync config may not actually be present.
     // Only persist the path here, and load on demand using `loadSyncRules()`.
     return {
       present: true,

package/src/util/env.ts

@@ -13,7 +13,7 @@ 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
+   * Base64 encoded contents of sync config YAML
    */
   POWERSYNC_SYNC_RULES_B64: utils.type.string.optional(),
   /**

package/src/util/protocol-types.ts

@@ -77,7 +77,7 @@ export const StreamingSyncRequest = t.object({
   raw_data: t.boolean.optional(),
 
   /**
-   * Client parameters to be passed to the sync rules.
+   * Client parameters to be passed to the sync config.
    */
   parameters: t.record(t.any).optional(),
 

package/test/src/auth.test.ts

@@ -1,9 +1,17 @@
 import { StaticSupabaseKeyCollector } from '@/index.js';
+import { configFile } from '@powersync/service-types';
 import * as jose from 'jose';
 import { describe, expect, test } from 'vitest';
 import { CachedKeyCollector } from '../../src/auth/CachedKeyCollector.js';
 import { KeyResult } from '../../src/auth/KeyCollector.js';
-import { KeySpec } from '../../src/auth/KeySpec.js';
+import {
+  EC_ALGORITHMS,
+  HS_ALGORITHMS,
+  KeySpec,
+  OKP_ALGORITHMS,
+  RSA_ALGORITHMS,
+  SUPPORTED_ALGORITHMS
+} from '../../src/auth/KeySpec.js';
 import { KeyStore } from '../../src/auth/KeyStore.js';
 import { RemoteJWKSCollector } from '../../src/auth/RemoteJWKSCollector.js';
 import { StaticKeyCollector } from '../../src/auth/StaticKeyCollector.js';
@@ -52,6 +60,47 @@ const privateKeyECDSA: jose.JWK = {
   alg: 'ES256'
 };
 
+const EC_ALGORITHM_CURVES = [
+  ['ES256', 'P-256'],
+  ['ES384', 'P-384'],
+  ['ES512', 'P-521']
+] satisfies [string, string][];
+
+const EDDSA_CURVES = ['Ed25519', 'Ed448'];
+
+function roundTripJwkThroughPowerSyncConfig(key: jose.JWK): jose.JWK {
+  const encoded = configFile.strictJwks.encode({
+    keys: [key as configFile.StrictJwk]
+  });
+
+  const decoded = configFile.strictJwks.decode(encoded);
+  return decoded.keys[0] as jose.JWK;
+}
+
+async function signAndVerifyWithKey(alg: string, key: jose.JWK, signKey: jose.KeyLike | Uint8Array) {
+  const parsedKey = roundTripJwkThroughPowerSyncConfig(key);
+  expect(parsedKey).toEqual(key);
+
+  const keys = await StaticKeyCollector.importKeys([parsedKey]);
+  const store = new KeyStore(keys);
+
+  const signedJwt = await new jose.SignJWT({ claim: alg })
+    .setProtectedHeader({ alg, kid: key.kid })
+    .setSubject('f1')
+    .setIssuedAt()
+    .setIssuer('tester')
+    .setAudience('tests')
+    .setExpirationTime('5m')
+    .sign(signKey);
+
+  const verified = await store.verifyJwt(signedJwt, {
+    defaultAudiences: ['tests'],
+    maxAge: '6m'
+  });
+
+  expect(verified.parsedPayload.claim).toEqual(alg);
+}
+
 describe('JWT Auth', () => {
   test('KeyStore basics', async () => {
     const keys = await StaticKeyCollector.importKeys([sharedKey]);
@@ -208,6 +257,65 @@ describe('JWT Auth', () => {
     ).rejects.toThrow('Unexpected token algorithm HS256');
   });
 
+  describe('supported JWT algorithms', () => {
+    test('covers every declared supported algorithm', () => {
+      const testedAlgorithms = new Set([
+        ...HS_ALGORITHMS,
+        ...RSA_ALGORITHMS,
+        ...EC_ALGORITHM_CURVES.map(([alg]) => alg),
+        ...OKP_ALGORITHMS
+      ]);
+
+      expect([...testedAlgorithms].sort()).toEqual([...SUPPORTED_ALGORITHMS].sort());
+    });
+
+    test.each(HS_ALGORITHMS)('verifies %s tokens', async (alg) => {
+      const secret = await jose.generateSecret(alg);
+      const key = await jose.exportJWK(secret);
+      key.kid = `test-${alg}`;
+      key.alg = alg;
+
+      await signAndVerifyWithKey(alg, key, secret);
+    });
+
+    test.each(RSA_ALGORITHMS)('verifies %s tokens', async (alg) => {
+      const { privateKey, publicKey } = await jose.generateKeyPair(alg);
+      const key = await jose.exportJWK(publicKey);
+      key.kid = `test-${alg}`;
+      key.alg = alg;
+      key.use = 'sig';
+
+      await signAndVerifyWithKey(alg, key, privateKey);
+    });
+
+    test.each(EC_ALGORITHM_CURVES)('verifies %s tokens with curve %s', async (alg, crv) => {
+      expect(EC_ALGORITHMS).toContain(alg);
+
+      const { privateKey, publicKey } = await jose.generateKeyPair(alg);
+      const key = await jose.exportJWK(publicKey);
+      key.kid = `test-${alg}`;
+      key.alg = alg;
+      key.use = 'sig';
+
+      expect(key.crv).toEqual(crv);
+      await signAndVerifyWithKey(alg, key, privateKey);
+    });
+
+    test.each(EDDSA_CURVES)('verifies EdDSA tokens with curve %s', async (crv) => {
+      const alg = 'EdDSA';
+      expect(OKP_ALGORITHMS).toContain(alg);
+
+      const { privateKey, publicKey } = await jose.generateKeyPair(alg, { crv });
+      const key = await jose.exportJWK(publicKey);
+      key.kid = `test-${alg}-${crv}`;
+      key.alg = alg;
+      key.use = 'sig';
+
+      expect(key.crv).toEqual(crv);
+      await signAndVerifyWithKey(alg, key, privateKey);
+    });
+  });
+
   test('key selection for key with kid', async () => {
     const keys = await StaticKeyCollector.importKeys([publicKeyRSA, sharedKey, sharedKey2]);
     const store = new KeyStore(keys);

package/test/src/diagnostics.test.ts

@@ -0,0 +1,151 @@
+import { DiagnosticsOptions, getSyncRulesStatus } from '@/api/diagnostics.js';
+import { RouteAPI, SlotWalBudgetInfo } from '@/api/RouteAPI.js';
+import { BucketStorageFactory } from '@/index.js';
+import { SqlSyncRules } from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
+
+const GB = 1024 * 1024 * 1024;
+
+const MINIMAL_SYNC_RULES = `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id FROM test_table
+`;
+
+function makeSyncRulesContent(overrides?: { slot_name?: string }) {
+  return {
+    id: 1,
+    slot_name: overrides?.slot_name ?? 'test_slot',
+    sync_rules_content: MINIMAL_SYNC_RULES,
+    compiled_plan: null,
+    active: true,
+    storageVersion: 1,
+    last_checkpoint_lsn: 'some_lsn',
+    last_fatal_error: null,
+    last_fatal_error_ts: null,
+    last_keepalive_ts: new Date(),
+    last_checkpoint_ts: new Date(),
+    parsed(options?: any) {
+      const syncRules = SqlSyncRules.fromYaml(MINIMAL_SYNC_RULES, {
+        ...options,
+        defaultSchema: 'public'
+      });
+      return {
+        sync_rules: syncRules
+      };
+    },
+    lock() {
+      throw new Error('Not implemented in mock');
+    },
+    current_lock: undefined
+  } as any;
+}
+
+function makeBucketStorage() {
+  return {
+    getInstance() {
+      return {
+        async getStatus() {
+          return {
+            snapshot_done: true,
+            checkpoint_lsn: 'some_lsn',
+            active: true
+          };
+        }
+      };
+    }
+  } as unknown as BucketStorageFactory;
+}
+
+function makeRouteAPI(walBudget?: SlotWalBudgetInfo | undefined): RouteAPI {
+  return {
+    getParseSyncRulesOptions() {
+      return { defaultSchema: 'public' };
+    },
+    async getSourceConfig() {
+      return { tag: 'test', id: 'test', type: 'postgresql' };
+    },
+    async getConnectionStatus() {
+      return { connected: true };
+    },
+    async getDebugTablesInfo() {
+      return [];
+    },
+    async getReplicationLagBytes() {
+      return 0;
+    },
+    ...(walBudget !== undefined
+      ? {
+          async getSlotWalBudget() {
+            return walBudget;
+          }
+        }
+      : {})
+  } as unknown as RouteAPI;
+}
+
+const OPTIONS: DiagnosticsOptions = {
+  live_status: true,
+  check_connection: true,
+  include_content: false
+};
+
+describe('getSyncRulesStatus WAL budget warnings', () => {
+  test('warns when WAL budget is at 40%', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'extended',
+      safe_wal_size: 4 * GB,
+      max_slot_wal_keep_size: 10 * GB
+    });
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
+    expect(walWarnings).toHaveLength(1);
+    expect(walWarnings[0].level).toBe('warning');
+    expect(walWarnings[0].message).toContain('40%');
+  });
+
+  test('no warning when WAL budget is at 80%', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'reserved',
+      safe_wal_size: 8 * GB,
+      max_slot_wal_keep_size: 10 * GB
+    });
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
+    expect(walWarnings).toHaveLength(0);
+  });
+
+  test('clamps negative safe_wal_size to 0%', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'unreserved',
+      safe_wal_size: -2.4 * GB,
+      max_slot_wal_keep_size: 1 * 1024 * 1024 // 1MB
+    });
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
+    expect(walWarnings).toHaveLength(1);
+    expect(walWarnings[0].message).toContain('0%');
+    expect(walWarnings[0].message).not.toMatch(/-\d+%/);
+  });
+
+  test('no WAL budget error when slot status is lost', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'lost'
+    });
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walErrors = result!.errors.filter(
+      (e) => e.message.includes('WAL budget') || e.message.includes('PSYNC_S1146')
+    );
+    expect(walErrors).toHaveLength(0);
+  });
+
+  test('no WAL error when getSlotWalBudget is not defined', async () => {
+    const api = makeRouteAPI();
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walErrors = result!.errors.filter(
+      (e) => e.message.includes('WAL budget') || e.message.includes('PSYNC_S1146')
+    );
+    expect(walErrors).toHaveLength(0);
+  });
+});