@powersync/service-core 0.0.0-dev-20240718134716 → 0.0.0-dev-20240918082156

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

@@ -1,18 +1,15 @@
-import * as t from 'ts-codec';
-import { configFile, normalizeConnection } from '@powersync/service-types';
-import { ConfigCollector } from './collectors/config-collector.js';
-import { ResolvedConnection, ResolvedPowerSyncConfig, RunnerConfig, SyncRulesConfig } from './types.js';
+import { logger } from '@powersync/lib-services-framework';
+import { configFile } from '@powersync/service-types';
 import * as auth from '../../auth/auth-index.js';
-import { SyncRulesCollector } from './sync-rules/sync-collector.js';
+import { ConfigCollector } from './collectors/config-collector.js';
 import { Base64ConfigCollector } from './collectors/impl/base64-config-collector.js';
+import { FallbackConfigCollector } from './collectors/impl/fallback-config-collector.js';
 import { FileSystemConfigCollector } from './collectors/impl/filesystem-config-collector.js';
 import { Base64SyncRulesCollector } from './sync-rules/impl/base64-sync-rules-collector.js';
-import { InlineSyncRulesCollector } from './sync-rules/impl/inline-sync-rules-collector.js';
 import { FileSystemSyncRulesCollector } from './sync-rules/impl/filesystem-sync-rules-collector.js';
-import { FallbackConfigCollector } from './collectors/impl/fallback-config-collector.js';
-import { logger, schema } from '@powersync/lib-services-framework';
-
-const POWERSYNC_DEV_KID = 'powersync-dev';
+import { InlineSyncRulesCollector } from './sync-rules/impl/inline-sync-rules-collector.js';
+import { SyncRulesCollector } from './sync-rules/sync-collector.js';
+import { ResolvedPowerSyncConfig, RunnerConfig, SyncRulesConfig } from './types.js';
 
 export type CompoundConfigCollectorOptions = {
   /**
@@ -29,12 +26,17 @@ export type CompoundConfigCollectorOptions = {
   syncRulesCollectors: SyncRulesCollector[];
 };
 
-export type ConfigCollectorGenerics = {
-  SERIALIZED: configFile.SerializedPowerSyncConfig;
-  DESERIALIZED: configFile.PowerSyncConfig;
-  RESOLVED: ResolvedPowerSyncConfig;
+export type ConfigCollectedEvent = {
+  base_config: configFile.PowerSyncConfig;
+  resolved_config: ResolvedPowerSyncConfig;
+};
+
+export type ConfigCollectorListener = {
+  configCollected?: (event: ConfigCollectedEvent) => Promise<void>;
 };
 
+const POWERSYNC_DEV_KID = 'powersync-dev';
+
 const DEFAULT_COLLECTOR_OPTIONS: CompoundConfigCollectorOptions = {
   configCollectors: [new Base64ConfigCollector(), new FileSystemConfigCollector(), new FallbackConfigCollector()],
   syncRulesCollectors: [
@@ -44,71 +46,20 @@ const DEFAULT_COLLECTOR_OPTIONS: CompoundConfigCollectorOptions = {
   ]
 };
 
-export class CompoundConfigCollector<Generics extends ConfigCollectorGenerics = ConfigCollectorGenerics> {
+export class CompoundConfigCollector {
   constructor(protected options: CompoundConfigCollectorOptions = DEFAULT_COLLECTOR_OPTIONS) {}
 
-  /**
-   * The default ts-codec for validations and decoding
-   */
-  get codec(): t.AnyCodec {
-    return configFile.powerSyncConfig;
-  }
-
   /**
    * Collects and resolves base config
    */
-  async collectConfig(runnerConfig: RunnerConfig = {}): Promise<Generics['RESOLVED']> {
+  async collectConfig(runnerConfig: RunnerConfig = {}): Promise<ResolvedPowerSyncConfig> {
     const baseConfig = await this.collectBaseConfig(runnerConfig);
-    const baseResolvedConfig = await this.resolveBaseConfig(baseConfig, runnerConfig);
-    return this.resolveConfig(baseConfig, baseResolvedConfig, runnerConfig);
-  }
-
-  /**
-   * Collects the base PowerSyncConfig from various registered collectors.
-   * @throws if no collector could return a configuration.
-   */
-  protected async collectBaseConfig(runner_config: RunnerConfig): Promise<Generics['DESERIALIZED']> {
-    for (const collector of this.options.configCollectors) {
-      try {
-        const baseConfig = await collector.collectSerialized(runner_config);
-        if (baseConfig) {
-          const decoded = this.decode(baseConfig);
-          this.validate(decoded);
-          return decoded;
-        }
-        logger.debug(
-          `Could not collect PowerSync 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 config using ${collector.name} method. Caught exception: ${ex}`);
-      }
-    }
-    throw new Error('PowerSyncConfig could not be collected using any of the registered config collectors.');
-  }
 
-  /**
-   * Performs the resolving of the common (shared) base configuration
-   */
-  protected async resolveBaseConfig(
-    baseConfig: Generics['DESERIALIZED'],
-    runnerConfig: RunnerConfig = {}
-  ): Promise<ResolvedPowerSyncConfig> {
-    const connections = baseConfig.replication?.connections ?? [];
-    if (connections.length > 1) {
-      throw new Error('Only a single replication connection is supported currently');
+    const dataSources = baseConfig.replication?.connections ?? [];
+    if (dataSources.length > 1) {
+      throw new Error('Only a single replication data source is supported currently');
     }
 
-    const mapped = connections.map((c) => {
-      const conf: ResolvedConnection = {
-        type: 'postgresql' as const,
-        ...normalizeConnection(c),
-        debug_api: c.debug_api ?? false
-      };
-
-      return conf;
-    });
-
     const collectors = new auth.CompoundKeyCollector();
     const keyStore = new auth.KeyStore(collectors);
 
@@ -117,10 +68,6 @@ export class CompoundConfigCollector<Generics extends ConfigCollectorGenerics =
 
     collectors.add(staticCollector);
 
-    if (baseConfig.client_auth?.supabase && mapped.length > 0) {
-      collectors.add(new auth.CachedKeyCollector(new auth.SupabaseKeyCollector(mapped[0])));
-    }
-
     let jwks_uris = baseConfig.client_auth?.jwks_uri ?? [];
     if (typeof jwks_uris == 'string') {
       jwks_uris = [jwks_uris];
@@ -146,7 +93,8 @@ export class CompoundConfigCollector<Generics extends ConfigCollectorGenerics =
     let jwt_audiences: string[] = baseConfig.client_auth?.audience ?? [];
 
     let config: ResolvedPowerSyncConfig = {
-      connection: mapped[0],
+      base_config: baseConfig,
+      connections: baseConfig.replication?.connections || [],
       storage: baseConfig.storage,
       client_keystore: keyStore,
       // Dev tokens only use the static keys, no external key sources
@@ -172,23 +120,34 @@ export class CompoundConfigCollector<Generics extends ConfigCollectorGenerics =
         internal_service_endpoint:
           baseConfig.telemetry?.internal_service_endpoint ?? 'https://pulse.journeyapps.com/v1/metrics'
       },
-      slot_name_prefix: connections[0]?.slot_name_prefix ?? 'powersync_'
+      // TODO maybe move this out of the connection or something
+      // slot_name_prefix: connections[0]?.slot_name_prefix ?? 'powersync_'
+      slot_name_prefix: 'powersync_'
     };
+
     return config;
   }
 
   /**
-   * Perform any additional resolving from {@link ResolvedPowerSyncConfig}
-   * to the extended {@link Generics['RESOLVED']}
-   *
+   * Collects the base PowerSyncConfig from various registered collectors.
+   * @throws if no collector could return a configuration.
    */
-  protected async resolveConfig(
-    baseConfig: Generics['DESERIALIZED'],
-    resolvedBaseConfig: ResolvedPowerSyncConfig,
-    runnerConfig: RunnerConfig = {}
-  ): Promise<Generics['RESOLVED']> {
-    // The base version has ResolvedPowerSyncConfig == Generics['RESOLVED']
-    return resolvedBaseConfig;
+  protected async collectBaseConfig(runner_config: RunnerConfig): Promise<configFile.PowerSyncConfig> {
+    for (const collector of this.options.configCollectors) {
+      try {
+        const baseConfig = await collector.collect(runner_config);
+        if (baseConfig) {
+          return baseConfig;
+        }
+        logger.debug(
+          `Could not collect PowerSync 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 config using ${collector.name} method. Caught exception: ${ex}`);
+      }
+    }
+    throw new Error('PowerSyncConfig could not be collected using any of the registered config collectors.');
   }
 
   protected async collectSyncRules(
@@ -213,28 +172,4 @@ export class CompoundConfigCollector<Generics extends ConfigCollectorGenerics =
       present: false
     };
   }
-
-  /**
-   * Validates input config
-   * ts-codec itself doesn't give great validation errors, so we use json schema for that
-   */
-  protected validate(config: Generics['DESERIALIZED']) {
-    // ts-codec itself doesn't give great validation errors, so we use json schema for that
-    const validator = schema
-      .parseJSONSchema(t.generateJSONSchema(this.codec, { allowAdditional: true, parsers: [configFile.portParser] }))
-      .validator();
-
-    const valid = validator.validate(config);
-    if (!valid.valid) {
-      throw new Error(`Failed to validate PowerSync config: ${valid.errors.join(', ')}`);
-    }
-  }
-
-  protected decode(encoded: Generics['SERIALIZED']): Generics['DESERIALIZED'] {
-    try {
-      return this.codec.decode(encoded);
-    } catch (ex) {
-      throw new Error(`Failed to decode PowerSync config: ${ex}`);
-    }
-  }
 }

package/src/util/config/sync-rules/sync-rules-provider.ts

@@ -0,0 +1,18 @@
+import { SyncRulesConfig } from '../types.js';
+import fs from 'fs/promises';
+
+export interface SyncRulesProvider {
+  get(): Promise<string | undefined>;
+}
+
+export class ConfigurationFileSyncRulesProvider implements SyncRulesProvider {
+  constructor(private config: SyncRulesConfig) {}
+
+  async get(): Promise<string | undefined> {
+    if (this.config.content) {
+      return this.config.content;
+    } else if (this.config.path) {
+      return await fs.readFile(this.config.path, 'utf-8');
+    }
+  }
+}

package/src/util/config/types.ts

@@ -1,4 +1,6 @@
-import { NormalizedPostgresConnection, configFile } from '@powersync/service-types';
+import { configFile } from '@powersync/service-types';
+import { PowerSyncConfig } from '@powersync/service-types/src/config/PowerSyncConfig.js';
+import { CompoundKeyCollector } from '../../auth/CompoundKeyCollector.js';
 import { KeySpec } from '../../auth/KeySpec.js';
 import { KeyStore } from '../../auth/KeyStore.js';
 
@@ -20,8 +22,6 @@ export type MigrationContext = {
 
 export type Runner = (config: RunnerConfig) => Promise<void>;
 
-export type ResolvedConnection = configFile.PostgresConnection & NormalizedPostgresConnection;
-
 export type SyncRulesConfig = {
   present: boolean;
   content?: string;
@@ -29,7 +29,8 @@ export type SyncRulesConfig = {
 };
 
 export type ResolvedPowerSyncConfig = {
-  connection?: ResolvedConnection;
+  base_config: PowerSyncConfig;
+  connections?: configFile.DataSourceConfig[];
   storage: configFile.StorageConfig;
   dev: {
     demo_auth: boolean;
@@ -41,7 +42,7 @@ export type ResolvedPowerSyncConfig = {
      */
     dev_key?: KeySpec;
   };
-  client_keystore: KeyStore;
+  client_keystore: KeyStore<CompoundKeyCollector>;
   /**
    * Keystore for development tokens.
    */

package/src/util/config.ts

@@ -1,31 +1,14 @@
 import * as fs from 'fs/promises';
-import { baseUri } from '@powersync/service-types';
 
-import { ResolvedConnection, ResolvedPowerSyncConfig, RunnerConfig } from './config/types.js';
-import { CompoundConfigCollector } from './config/compound-config-collector.js';
+import { container } from '@powersync/lib-services-framework';
+import { ResolvedPowerSyncConfig, RunnerConfig } from './config/types.js';
+import { CompoundConfigCollector } from './util-index.js';
 
 /**
- * Build a single URI from full postgres credentials.
+ * Loads the resolved config using the registered config collector
  */
-export function buildDemoPgUri(options: ResolvedConnection): string {
-  if (!options.debug_api) {
-    throw new Error('Not supported');
-  }
-
-  const uri = new URL(baseUri(options));
-  uri.username = options.username;
-  uri.password = options.password;
-  if (options.sslmode != 'disable') {
-    // verify-full is tricky to actually use on a client, since they won't have the cert
-    // Just use "require" by default
-    // uri.searchParams.set('sslmode', options.sslmode);
-    uri.searchParams.set('sslmode', 'require');
-  }
-  return uri.toString();
-}
-
-export function loadConfig(runnerConfig: RunnerConfig = {}) {
-  const collector = new CompoundConfigCollector();
+export async function loadConfig(runnerConfig: RunnerConfig) {
+  const collector = container.getImplementation(CompoundConfigCollector);
   return collector.collectConfig(runnerConfig);
 }
 

package/src/util/protocol-types.ts

@@ -94,7 +94,12 @@ export const StreamingSyncRequest = t.object({
   /**
    * Client parameters to be passed to the sync rules.
    */
-  parameters: t.record(t.any).optional()
+  parameters: t.record(t.any).optional(),
+
+  /**
+   * Unique client id.
+   */
+  client_id: t.string.optional()
 });
 
 export type StreamingSyncRequest = t.Decoded<typeof StreamingSyncRequest>;

package/src/util/util-index.ts

@@ -1,25 +1,22 @@
 export * from './alerting.js';
 export * from './env.js';
 export * from './memory-tracking.js';
-export * from './migration_lib.js';
 export * from './Mutex.js';
-export * from './PgManager.js';
-export * from './pgwire_utils.js';
-export * from './populate_test_data.js';
 export * from './protocol-types.js';
 export * from './secs.js';
 export * from './utils.js';
 
 export * from './config.js';
-export * from './config/types.js';
 export * from './config/compound-config-collector.js';
+export * from './config/types.js';
 
 export * from './config/collectors/config-collector.js';
 export * from './config/collectors/impl/base64-config-collector.js';
 export * from './config/collectors/impl/fallback-config-collector.js';
 export * from './config/collectors/impl/filesystem-config-collector.js';
 
-export * from './config/sync-rules/sync-collector.js';
 export * from './config/sync-rules/impl/base64-sync-rules-collector.js';
 export * from './config/sync-rules/impl/filesystem-sync-rules-collector.js';
 export * from './config/sync-rules/impl/inline-sync-rules-collector.js';
+export * from './config/sync-rules/sync-collector.js';
+export * from './config/sync-rules/sync-rules-provider.js';

package/src/util/utils.ts

@@ -1,14 +1,19 @@
+import * as sync_rules from '@powersync/service-sync-rules';
+import * as bson from 'bson';
 import crypto from 'crypto';
-import * as pgwire from '@powersync/service-jpgwire';
-import { pgwireRows } from '@powersync/service-jpgwire';
+import * as uuid from 'uuid';
+import { BucketChecksum, OpId } from './protocol-types.js';
 
 import * as storage from '../storage/storage-index.js';
-import { BucketChecksum, OpId } from './protocol-types.js';
-import { retriedQuery } from './pgwire_utils.js';
-import { logger } from '@powersync/lib-services-framework';
 
 export type ChecksumMap = Map<string, BucketChecksum>;
 
+export const ID_NAMESPACE = 'a396dd91-09fc-4017-a28d-3df722f651e9';
+
+export function escapeIdentifier(identifier: string) {
+  return `"${identifier.replace(/"/g, '""').replace(/\./g, '"."')}"`;
+}
+
 export function hashData(type: string, id: string, data: string): number {
   const hash = crypto.createHash('sha256');
   hash.update(`put.${type}.${id}.${data}`);
@@ -76,47 +81,58 @@ export function addBucketChecksums(a: BucketChecksum, b: BucketChecksum | null):
   }
 }
 
-export async function getClientCheckpoint(
-  db: pgwire.PgClient,
-  bucketStorage: storage.BucketStorageFactory,
-  options?: { timeout?: number }
-): Promise<OpId> {
-  const start = Date.now();
+function getRawReplicaIdentity(
+  tuple: sync_rules.ToastableSqliteRow,
+  columns: storage.ColumnDescriptor[]
+): Record<string, any> {
+  let result: Record<string, any> = {};
+  for (let column of columns) {
+    const name = column.name;
+    result[name] = tuple[name];
+  }
+  return result;
+}
 
-  const [{ lsn }] = pgwireRows(await db.query(`SELECT pg_logical_emit_message(false, 'powersync', 'ping') as lsn`));
+export function getUuidReplicaIdentityBson(
+  tuple: sync_rules.ToastableSqliteRow,
+  columns: storage.ColumnDescriptor[]
+): bson.UUID {
+  if (columns.length == 0) {
+    // REPLICA IDENTITY NOTHING - generate random id
+    return new bson.UUID(uuid.v4());
+  }
+  const rawIdentity = getRawReplicaIdentity(tuple, columns);
 
-  // This old API needs a persisted checkpoint id.
-  // Since we don't use LSNs anymore, the only way to get that is to wait.
+  return uuidForRowBson(rawIdentity);
+}
 
-  const timeout = options?.timeout ?? 50_000;
+export function uuidForRowBson(row: sync_rules.SqliteRow): bson.UUID {
+  // Important: This must not change, since it will affect how ids are generated.
+  // Use BSON so that it's a well-defined format without encoding ambiguities.
+  const repr = bson.serialize(row);
+  const buffer = Buffer.alloc(16);
+  return new bson.UUID(uuid.v5(repr, ID_NAMESPACE, buffer));
+}
 
-  logger.info(`Waiting for LSN checkpoint: ${lsn}`);
-  while (Date.now() - start < timeout) {
-    const cp = await bucketStorage.getActiveCheckpoint();
-    if (!cp.hasSyncRules()) {
-      throw new Error('No sync rules available');
+export function hasToastedValues(row: sync_rules.ToastableSqliteRow) {
+  for (let key in row) {
+    if (typeof row[key] == 'undefined') {
+      return true;
     }
-    if (cp.lsn >= lsn) {
-      logger.info(`Got write checkpoint: ${lsn} : ${cp.checkpoint}`);
-      return cp.checkpoint;
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 30));
   }
+  return false;
+}
 
-  throw new Error('Timeout while waiting for checkpoint');
+export function isCompleteRow(row: sync_rules.ToastableSqliteRow): row is sync_rules.SqliteRow {
+  return !hasToastedValues(row);
 }
 
-export async function createWriteCheckpoint(
-  db: pgwire.PgClient,
-  bucketStorage: storage.BucketStorageFactory,
-  user_id: string
-): Promise<bigint> {
-  const [{ lsn }] = pgwireRows(
-    await retriedQuery(db, `SELECT pg_logical_emit_message(false, 'powersync', 'ping') as lsn`)
-  );
-
-  const id = await bucketStorage.createWriteCheckpoint(user_id, { '1': lsn });
-  logger.info(`Write checkpoint 2: ${JSON.stringify({ lsn, id: String(id) })}`);
-  return id;
+export function checkpointUserId(user_id: string | undefined, client_id: string | undefined) {
+  if (user_id == null) {
+    throw new Error('user_id is required');
+  }
+  if (client_id == null) {
+    return user_id;
+  }
+  return `${user_id}/${client_id}`;
 }

package/test/src/__snapshots__/sync.test.ts.snap

@@ -1,5 +1,90 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
+exports[`sync - mongodb > compacting data - invalidate checkpoint 1`] = `
+[
+  {
+    "checkpoint": {
+      "buckets": [
+        {
+          "bucket": "mybucket[]",
+          "checksum": -93886621,
+          "count": 2,
+        },
+      ],
+      "last_op_id": "2",
+      "write_checkpoint": undefined,
+    },
+  },
+]
+`;
+
+exports[`sync - mongodb > compacting data - invalidate checkpoint 2`] = `
+[
+  {
+    "data": {
+      "after": "0",
+      "bucket": "mybucket[]",
+      "data": [
+        {
+          "checksum": -93886621n,
+          "op": "CLEAR",
+          "op_id": "2",
+        },
+      ],
+      "has_more": false,
+      "next_after": "2",
+    },
+  },
+  {
+    "checkpoint_diff": {
+      "last_op_id": "4",
+      "removed_buckets": [],
+      "updated_buckets": [
+        {
+          "bucket": "mybucket[]",
+          "checksum": 499012468,
+          "count": 4,
+        },
+      ],
+      "write_checkpoint": undefined,
+    },
+  },
+  {
+    "data": {
+      "after": "2",
+      "bucket": "mybucket[]",
+      "data": [
+        {
+          "checksum": 1859363232n,
+          "data": "{\\"id\\":\\"t1\\",\\"description\\":\\"Test 1b\\"}",
+          "object_id": "t1",
+          "object_type": "test",
+          "op": "PUT",
+          "op_id": "3",
+          "subkey": "e5aa2ddc-1328-58fa-a000-0b5ed31eaf1a",
+        },
+        {
+          "checksum": 3028503153n,
+          "data": "{\\"id\\":\\"t2\\",\\"description\\":\\"Test 2b\\"}",
+          "object_id": "t2",
+          "object_type": "test",
+          "op": "PUT",
+          "op_id": "4",
+          "subkey": "13423353-9f27-59b4-baf0-64a5e09f1769",
+        },
+      ],
+      "has_more": false,
+      "next_after": "4",
+    },
+  },
+  {
+    "checkpoint_complete": {
+      "last_op_id": "4",
+    },
+  },
+]
+`;
+
 exports[`sync - mongodb > expired token 1`] = `
 [
   {
@@ -66,7 +151,7 @@ exports[`sync - mongodb > sync global data 1`] = `
           "object_type": "test",
           "op": "PUT",
           "op_id": "1",
-          "subkey": "6544e3899293153fa7b38331/117ab485-4b42-58a2-ab32-0053a22c3423",
+          "subkey": "e5aa2ddc-1328-58fa-a000-0b5ed31eaf1a",
         },
         {
           "checksum": 3280762209n,
@@ -75,7 +160,7 @@ exports[`sync - mongodb > sync global data 1`] = `
           "object_type": "test",
           "op": "PUT",
           "op_id": "2",
-          "subkey": "6544e3899293153fa7b38331/ec27c691-b47a-5d92-927a-9944feb89eee",
+          "subkey": "13423353-9f27-59b4-baf0-64a5e09f1769",
         },
       ],
       "has_more": false,
@@ -122,7 +207,7 @@ exports[`sync - mongodb > sync legacy non-raw data 1`] = `
           "object_type": "test",
           "op": "PUT",
           "op_id": "1",
-          "subkey": "6544e3899293153fa7b38331/117ab485-4b42-58a2-ab32-0053a22c3423",
+          "subkey": "e5aa2ddc-1328-58fa-a000-0b5ed31eaf1a",
         },
       ],
       "has_more": false,
@@ -188,7 +273,7 @@ exports[`sync - mongodb > sync updates to global data 2`] = `
           "object_type": "test",
           "op": "PUT",
           "op_id": "1",
-          "subkey": "6544e3899293153fa7b38331/117ab485-4b42-58a2-ab32-0053a22c3423",
+          "subkey": "e5aa2ddc-1328-58fa-a000-0b5ed31eaf1a",
         },
       ],
       "has_more": false,
@@ -231,7 +316,7 @@ exports[`sync - mongodb > sync updates to global data 3`] = `
           "object_type": "test",
           "op": "PUT",
           "op_id": "2",
-          "subkey": "6544e3899293153fa7b38331/ec27c691-b47a-5d92-927a-9944feb89eee",
+          "subkey": "13423353-9f27-59b4-baf0-64a5e09f1769",
         },
       ],
       "has_more": false,

package/test/src/auth.test.ts

@@ -1,11 +1,11 @@
-import { describe, expect, test } from 'vitest';
-import { StaticKeyCollector } from '../../src/auth/StaticKeyCollector.js';
+import { CachedKeyCollector } from '@/auth/CachedKeyCollector.js';
+import { KeyResult } from '@/auth/KeyCollector.js';
+import { KeySpec } from '@/auth/KeySpec.js';
+import { KeyStore } from '@/auth/KeyStore.js';
+import { RemoteJWKSCollector } from '@/auth/RemoteJWKSCollector.js';
+import { StaticKeyCollector } from '@/auth/StaticKeyCollector.js';
 import * as jose from 'jose';
-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 { describe, expect, test } from 'vitest';
 
 const publicKey: jose.JWK = {
   use: 'sig',

package/test/src/broadcast_iterable.test.ts

@@ -1,3 +1,4 @@
+import { BroadcastIterable, IterableSource } from '@/sync/BroadcastIterable.js';
 import { AsyncIterableX, interval } from 'ix/asynciterable/index.js';
 import { delayEach } from 'ix/asynciterable/operators/delayeach.js';
 import { take } from 'ix/asynciterable/operators/take.js';
@@ -5,7 +6,6 @@ import { wrapWithAbort } from 'ix/asynciterable/operators/withabort.js';
 import { toArray } from 'ix/asynciterable/toarray.js';
 import * as timers from 'timers/promises';
 import { describe, expect, test } from 'vitest';
-import { BroadcastIterable, IterableSource } from '../../src/sync/BroadcastIterable.js';
 
 describe('BroadcastIterable', () => {
   test('should iterate', async () => {