@powersync/service-core 1.20.4 → 1.21.0

package/src/system/ServiceContext.ts

@@ -1,5 +1,6 @@
 import { container, LifeCycledSystem, MigrationManager, ServiceIdentifier } from '@powersync/lib-services-framework';
 
+import { EventsEngine } from '../events/EventsEngine.js';
 import { framework } from '../index.js';
 import * as metrics from '../metrics/MetricsEngine.js';
 import { PowerSyncMigrationManager } from '../migrations/PowerSyncMigrationManager.js';
@@ -8,7 +9,6 @@ import * as routes from '../routes/routes-index.js';
 import * as storage from '../storage/storage-index.js';
 import { SyncContext } from '../sync/SyncContext.js';
 import * as utils from '../util/util-index.js';
-import { EventsEngine } from '../events/EventsEngine.js';
 
 export interface ServiceContext {
   configuration: utils.ResolvedPowerSyncConfig;

package/src/tracing/PerformanceTracer.ts

@@ -0,0 +1,126 @@
+import { traceWriter } from './TraceWriter.js';
+
+export interface Span extends Disposable {
+  name: string;
+  startAt: number;
+  endAt: number;
+  selfDuration: number;
+  nestedSince: number | undefined;
+  subtrackFromSelf: number;
+  nestedDurations: Record<string, number>;
+
+  /**
+   * End the span - same as [Symbol.dispose]().
+   *
+   * Safe to call multiple times. Any nested spans will automatically end as well.
+   *
+   * Returns an aggregate record of category -> "selfDuration".
+   */
+  end(): Record<string, number>;
+}
+
+function now() {
+  return Number(process.hrtime.bigint() / 1000n);
+}
+
+let nextThreadId = 1;
+
+/**
+ * Lightweight tracing helper, with two main goals:
+ * 1. Generate aggregate timing info with low overhead.
+ * 2. Optional support for generating trace files during development.
+ *
+ * This is only intended for a single "thread" - concurrent operations on the same instance have undefined behavior.
+ * To trace concurrent operations, use separate instances of PerformanceTracer.
+ *
+ * Spans cannot be overlapping: If a parent span is ended, all nested spans are automatically ended.
+ */
+export class PerformanceTracer<K extends string> {
+  stack: Span[] = [];
+  threadId: number;
+
+  constructor(traceName: string) {
+    this.threadId = nextThreadId;
+    nextThreadId += 1;
+    traceWriter?.write({
+      ph: 'M',
+      cat: '__metadata',
+      name: 'thread_name',
+      pid: process.pid,
+      tid: this.threadId,
+      args: { name: `PowerSync ${traceName}` }
+    });
+  }
+
+  /**
+   * Recommended usage:
+   *
+   *   using _ = tracer.span('cat', 'details');
+   *
+   * The above automatically ends the span when it goes out of scope. Alternatively, call
+   * .end() on the span to end it earlier.
+   *
+   * @param category one of the defined categories
+   * @param subcat optional subcategory. Not used for calculating "self" durations in the aggregate API.
+   */
+  span(category: K, subcat?: string): Span {
+    const stack = this.stack;
+    const index = this.stack.length;
+    const parent = this.stack[this.stack.length - 1];
+    const threadId = this.threadId;
+    const startAt = now();
+    if (parent != null) {
+      parent.nestedSince ??= startAt;
+    }
+    let name: string = category;
+    if (subcat) {
+      name += ':' + subcat;
+    }
+    const s: Span = {
+      name,
+      startAt: now(),
+      selfDuration: 0,
+      endAt: 0,
+      nestedSince: undefined,
+      subtrackFromSelf: 0,
+      nestedDurations: {},
+      end() {
+        if (this.endAt != 0) {
+          return this.nestedDurations;
+        }
+        while (stack.length - 1 > index) {
+          stack[stack.length - 1].end();
+        }
+        const endAt = now();
+        this.endAt = endAt;
+        const endTime = this.nestedSince ?? endAt;
+        this.selfDuration = endTime - startAt - this.subtrackFromSelf;
+        traceWriter?.write({
+          name,
+          cat: 'powersync',
+          ph: 'X',
+          ts: this.startAt,
+          dur: endAt - startAt,
+          pid: process.pid,
+          tid: threadId
+        });
+        stack.pop();
+        if (parent != null) {
+          parent.subtrackFromSelf += endAt - parent.nestedSince!;
+          for (let key in this.nestedDurations) {
+            parent.nestedDurations[key] = (parent.nestedDurations[key] ?? 0) + this.nestedDurations[key];
+          }
+          parent.nestedDurations[category] = (parent.nestedDurations[category] ?? 0) + this.selfDuration;
+          parent.nestedSince = undefined;
+        }
+        return this.nestedDurations;
+      },
+      [Symbol.dispose]() {
+        this.end();
+      }
+    };
+    this.stack.push(s);
+
+    return s;
+  }
+}

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/collectors/impl/base64-config-collector.ts

@@ -1,5 +1,5 @@
-import { ConfigCollector } from '../config-collector.js';
 import { RunnerConfig } from '../../types.js';
+import { ConfigCollector } from '../config-collector.js';
 
 export class Base64ConfigCollector extends ConfigCollector {
   get name(): string {

package/src/util/config/collectors/impl/filesystem-config-collector.ts

@@ -1,9 +1,9 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 
-import { ConfigCollector, ConfigFileFormat } from '../config-collector.js';
-import { RunnerConfig } from '../../types.js';
 import { logger } from '@powersync/lib-services-framework';
+import { RunnerConfig } from '../../types.js';
+import { ConfigCollector, ConfigFileFormat } from '../config-collector.js';
 
 export class FileSystemConfigCollector extends ConfigCollector {
   get name(): string {

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/config/sync-rules/sync-rules-provider.ts

@@ -1,5 +1,5 @@
-import { SyncRulesConfig } from '../types.js';
 import fs from 'fs/promises';
+import { SyncRulesConfig } from '../types.js';
 
 export interface SyncRulesProvider {
   get(): Promise<string | undefined>;

package/src/util/config.ts

@@ -1,7 +1,7 @@
 import * as fs from 'fs/promises';
 import winston from 'winston';
 
-import { container, logger, LogFormat, DEFAULT_LOG_LEVEL, DEFAULT_LOG_FORMAT } from '@powersync/lib-services-framework';
+import { container, DEFAULT_LOG_FORMAT, DEFAULT_LOG_LEVEL, LogFormat, logger } from '@powersync/lib-services-framework';
 import { configFile } from '@powersync/service-types';
 import { ResolvedPowerSyncConfig, RunnerConfig } from './config/types.js';
 import { CompoundConfigCollector } from './util-index.js';

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/errors.ts

@@ -0,0 +1,21 @@
+import { YamlError } from '@powersync/service-sync-rules';
+import { ReplicationError } from '@powersync/service-types';
+
+export function syncConfigYamlErrorToReplicationError(
+  { type, message, location }: YamlError,
+  ts?: string
+): ReplicationError {
+  const error: ReplicationError = {
+    level: type,
+    message,
+    ts
+  };
+  if (location != null) {
+    error.location = {
+      start_offset: location.start,
+      end_offset: location.end
+    };
+  }
+
+  return error;
+}

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/src/util/util-index.ts

@@ -1,4 +1,5 @@
 export * from './alerting.js';
+export * from './checkpointing.js';
 export * from './env.js';
 export * from './lsn.js';
 export * from './memory-tracking.js';
@@ -6,7 +7,6 @@ export * from './Mutex.js';
 export * from './protocol-types.js';
 export * from './secs.js';
 export * from './utils.js';
-export * from './checkpointing.js';
 export * from './version.js';
 
 export * from './config.js';

package/src/util/utils.ts

@@ -2,7 +2,7 @@ import * as sync_rules from '@powersync/service-sync-rules';
 import * as bson from 'bson';
 import crypto from 'crypto';
 import * as uuid from 'uuid';
-import { BucketChecksum, ProtocolOpId, OplogEntry } from './protocol-types.js';
+import { BucketChecksum, OplogEntry, ProtocolOpId } from './protocol-types.js';
 
 import * as storage from '../storage/storage-index.js';
 

package/test/src/auth.test.ts

@@ -1,13 +1,21 @@
-import { describe, expect, test } from 'vitest';
-import { StaticKeyCollector } from '../../src/auth/StaticKeyCollector.js';
+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 {
+  EC_ALGORITHMS,
+  HS_ALGORITHMS,
+  KeySpec,
+  OKP_ALGORITHMS,
+  RSA_ALGORITHMS,
+  SUPPORTED_ALGORITHMS
+} from '../../src/auth/KeySpec.js';
 import { KeyStore } from '../../src/auth/KeyStore.js';
-import { KeySpec } from '../../src/auth/KeySpec.js';
 import { RemoteJWKSCollector } from '../../src/auth/RemoteJWKSCollector.js';
-import { KeyResult } from '../../src/auth/KeyCollector.js';
-import { CachedKeyCollector } from '../../src/auth/CachedKeyCollector.js';
-import { JwtPayload, StaticSupabaseKeyCollector } from '@/index.js';
-import { debugKeyNotFound, getSupabaseJwksUrl } from '../../src/auth/utils.js';
+import { StaticKeyCollector } from '../../src/auth/StaticKeyCollector.js';
+import { getSupabaseJwksUrl } from '../../src/auth/utils.js';
 
 const publicKeyRSA: jose.JWK = {
   use: 'sig',
@@ -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);
+  });
+});

package/test/src/module-loader.test.ts

@@ -1,5 +1,5 @@
 import { AbstractModule, loadModules, ServiceContextContainer, TearDownOptions } from '@/index.js';
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it } from 'vitest';
 
 interface MockConfig {
   connections?: { type: string }[];

package/test/src/routes/mocks.ts

@@ -1,3 +1,4 @@
+import { EventsEngine } from '@/events/EventsEngine.js';
 import {
   BucketStorageFactory,
   createCoreAPIMetrics,
@@ -11,7 +12,6 @@ import {
   SyncRulesBucketStorage
 } from '@/index.js';
 import { MeterProvider } from '@opentelemetry/sdk-metrics';
-import { EventsEngine } from '@/events/EventsEngine.js';
 
 export function mockServiceContext(storage: Partial<SyncRulesBucketStorage> | null) {
   // This is very incomplete - just enough to get the current tests passing.