@powersync/service-core 1.20.0 → 1.20.2

package/src/storage/BucketStorageBatch.ts

@@ -12,6 +12,16 @@ export const DEFAULT_BUCKET_BATCH_COMMIT_OPTIONS: ResolvedBucketBatchCommitOptio
 };
 
 export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageListener>, AsyncDisposable {
+  /**
+   * Alias for [Symbol.asyncDispose]
+   */
+  dispose(): Promise<void>;
+
+  /**
+   * Last written op, if any. This may not reflect a consistent checkpoint.
+   */
+  last_flushed_op: InternalOpId | null;
+
   /**
    * Save an op, and potentially flush.
    *
@@ -45,19 +55,15 @@ export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageLis
    * Flush and commit any saved ops. This creates a new checkpoint by default.
    *
    * Only call this after a transaction.
-   *
-   * Returns true if either (1) a new checkpoint was created, or (2) there are no changes to commit.
    */
-  commit(lsn: string, options?: BucketBatchCommitOptions): Promise<boolean>;
+  commit(lsn: string, options?: BucketBatchCommitOptions): Promise<CheckpointResult>;
 
   /**
    * Advance the checkpoint LSN position, without any associated op.
    *
    * This must only be called when not inside a transaction.
-   *
-   * @returns true if the checkpoint was advanced, false if this was a no-op
    */
-  keepalive(lsn: string): Promise<boolean>;
+  keepalive(lsn: string): Promise<CheckpointResult>;
 
   /**
    * Set the LSN that replication should resume from.
@@ -83,9 +89,9 @@ export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageLis
    */
   resumeFromLsn: string | null;
 
-  noCheckpointBeforeLsn: string;
-
-  markSnapshotDone(tables: SourceTable[], no_checkpoint_before_lsn: string): Promise<SourceTable[]>;
+  markTableSnapshotDone(tables: SourceTable[], no_checkpoint_before_lsn?: string): Promise<SourceTable[]>;
+  markTableSnapshotRequired(table: SourceTable): Promise<void>;
+  markAllSnapshotDone(no_checkpoint_before_lsn: string): Promise<void>;
 
   updateTableProgress(table: SourceTable, progress: Partial<TableSnapshotStatus>): Promise<SourceTable>;
 
@@ -166,6 +172,24 @@ export interface SaveDelete {
   afterReplicaId?: undefined;
 }
 
+export interface CheckpointResult {
+  /**
+   * True if any of these are true:
+   * 1. A snapshot is in progress.
+   * 2. The last checkpoint is older than "no_checkpoint_before" (if provided).
+   * 3. Replication was restarted with a lower LSN, and has not caught up yet.
+   */
+  checkpointBlocked: boolean;
+
+  /**
+   * True if a checkpoint was actually created by this operation. This can be false even if checkpointBlocked is false,
+   * if the checkpoint was empty.
+   *
+   * This is primarily used for testing.
+   */
+  checkpointCreated: boolean;
+}
+
 export interface BucketBatchStorageListener {
   replicationEvent: (payload: ReplicationEventPayload) => void;
 }

package/src/storage/BucketStorageFactory.ts

@@ -257,3 +257,9 @@ export interface TestStorageOptions {
 }
 export type TestStorageFactory = (options?: TestStorageOptions) => Promise<BucketStorageFactory>;
 export type TestReportStorageFactory = (options?: TestStorageOptions) => Promise<ReportStorage>;
+
+export interface TestStorageConfig {
+  factory: TestStorageFactory;
+  tableIdStrings: boolean;
+  storageVersion?: number;
+}

package/src/storage/ChecksumCache.ts

@@ -1,7 +1,9 @@
 import { OrderedSet } from '@js-sdsl/ordered-set';
 import { LRUCache } from 'lru-cache/min';
+import { BucketDataSource } from '@powersync/service-sync-rules';
 import { BucketChecksum } from '../util/protocol-types.js';
 import { addBucketChecksums, ChecksumMap, InternalOpId, PartialChecksum } from '../util/utils.js';
+import { BucketChecksumRequest } from './SyncRulesBucketStorage.js';
 
 interface ChecksumFetchContext {
   fetch(bucket: string): Promise<BucketChecksum>;
@@ -10,6 +12,7 @@ interface ChecksumFetchContext {
 
 export interface FetchPartialBucketChecksum {
   bucket: string;
+  source: BucketDataSource;
   start?: InternalOpId;
   end: InternalOpId;
 }
@@ -113,10 +116,10 @@ export class ChecksumCache {
     this.bucketCheckpoints.clear();
   }
 
-  async getChecksums(checkpoint: InternalOpId, buckets: string[]): Promise<BucketChecksum[]> {
+  async getChecksums(checkpoint: InternalOpId, buckets: BucketChecksumRequest[]): Promise<BucketChecksum[]> {
     const checksums = await this.getChecksumMap(checkpoint, buckets);
     // Return results in the same order as the request
-    return buckets.map((bucket) => checksums.get(bucket)!);
+    return buckets.map((bucket) => checksums.get(bucket.bucket)!);
   }
 
   /**
@@ -126,7 +129,7 @@ export class ChecksumCache {
    *
    * @returns a Map with exactly one entry for each bucket requested
    */
-  async getChecksumMap(checkpoint: InternalOpId, buckets: string[]): Promise<ChecksumMap> {
+  async getChecksumMap(checkpoint: InternalOpId, buckets: BucketChecksumRequest[]): Promise<ChecksumMap> {
     // Buckets that don't have a cached checksum for this checkpoint yet
     let toFetch = new Set<string>();
 
@@ -164,19 +167,21 @@ export class ChecksumCache {
     // One promise to await to ensure all fetch requests completed.
     let settledPromise: Promise<PromiseSettledResult<void>[]> | null = null;
 
+    const sourceMap = new Map<string, BucketDataSource>();
+
     try {
       // Individual cache fetch promises
       let cacheFetchPromises: Promise<void>[] = [];
 
       for (let bucket of buckets) {
-        const cacheKey = makeCacheKey(checkpoint, bucket);
+        const cacheKey = makeCacheKey(checkpoint, bucket.bucket);
         let status: LRUCache.Status<BucketChecksum> = {};
         const p = this.cache.fetch(cacheKey, { context: context, status: status }).then((checksums) => {
           if (checksums == null) {
             // Should never happen
             throw new Error(`Failed to get checksums for ${cacheKey}`);
           }
-          finalResults.set(bucket, checksums);
+          finalResults.set(bucket.bucket, checksums);
         });
         cacheFetchPromises.push(p);
         if (status.fetch == 'hit' || status.fetch == 'inflight') {
@@ -185,7 +190,8 @@ export class ChecksumCache {
           // In either case, we don't need to fetch a new checksum.
         } else {
           // We need a new request for this checksum.
-          toFetch.add(bucket);
+          toFetch.add(bucket.bucket);
+          sourceMap.set(bucket.bucket, bucket.source);
         }
       }
       // We do this directly after creating the promises, otherwise
@@ -220,6 +226,7 @@ export class ChecksumCache {
                 // Partial checksum found - make a partial checksum request
                 bucketRequest = {
                   bucket,
+                  source: sourceMap.get(bucket)!,
                   start: cp,
                   end: checkpoint
                 };
@@ -240,6 +247,7 @@ export class ChecksumCache {
             // No partial checksum found - make a new full checksum request
             bucketRequest = {
               bucket,
+              source: sourceMap.get(bucket)!,
               end: checkpoint
             };
             add.set(bucket, {

package/src/storage/PersistedSyncRulesContent.ts

@@ -1,3 +1,4 @@
+import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
 import {
   CompatibilityContext,
   CompatibilityOption,
@@ -12,10 +13,9 @@ import {
   SyncConfigWithErrors,
   versionedHydrationState
 } from '@powersync/service-sync-rules';
+import { SerializedSyncPlan, UpdateSyncRulesOptions } from './BucketStorageFactory.js';
 import { ReplicationLock } from './ReplicationLock.js';
 import { STORAGE_VERSION_CONFIG, StorageVersionConfig } from './StorageVersionConfig.js';
-import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
-import { SerializedSyncPlan, UpdateSyncRulesOptions } from './BucketStorageFactory.js';
 
 export interface ParseSyncRulesOptions {
   defaultSchema: string;
@@ -120,6 +120,7 @@ export abstract class PersistedSyncRulesContent implements PersistedSyncRulesCon
       id: this.id,
       slot_name: this.slot_name,
       sync_rules: config,
+      hydrationState,
       hydratedSyncRules: () => {
         return config.config.hydrate({ hydrationState });
       }
@@ -140,6 +141,10 @@ export interface PersistedSyncRules {
   readonly id: number;
   readonly sync_rules: SyncConfigWithErrors;
   readonly slot_name: string;
+  /**
+   * For testing only.
+   */
+  readonly hydrationState: HydrationState;
 
   hydratedSyncRules(): HydratedSyncRules;
 }

package/src/storage/SourceTable.ts

@@ -1,9 +1,15 @@
 import { DEFAULT_TAG } from '@powersync/service-sync-rules';
 import * as util from '../util/util-index.js';
 import { ColumnDescriptor, SourceEntityDescriptor } from './SourceEntity.js';
+import { bson } from '../index.js';
+
+/**
+ * Format of the id depends on the bucket storage module. It should be consistent within the module.
+ */
+export type SourceTableId = string | bson.ObjectId;
 
 export interface SourceTableOptions {
-  id: any;
+  id: SourceTableId;
   connectionTag: string;
   objectId: number | string | undefined;
   schema: string;

package/src/storage/StorageVersionConfig.ts

@@ -1,30 +1,78 @@
 export interface StorageVersionConfig {
+  version: number;
+
   /**
    * Whether versioned bucket names are automatically enabled.
    *
    * If this is false, bucket names may still be versioned depending on the sync config.
+   *
+   * Introduced in STORAGE_VERSION_2.
    */
   versionedBuckets: boolean;
+
+  /**
+   * Whether to use soft deletes for current_data, improving replication concurrency support.
+   *
+   * Introduced in STORAGE_VERSION_3.
+   */
+  softDeleteCurrentData: boolean;
 }
 
+/**
+ * Corresponds to the storage version initially used, before we started explicitly versioning storage.
+ */
+export const STORAGE_VERSION_1 = 1;
+
+/**
+ * First new storage version.
+ *
+ * Uses versioned bucket names.
+ *
+ * On MongoDB storage, this always uses Long for checksums.
+ */
+export const STORAGE_VERSION_2 = 2;
+
+/**
+ * This version is currently unstable, and not enabled by default yet.
+ *
+ * This is used to build towards incremental reprocessing.
+ */
+export const STORAGE_VERSION_3 = 3;
+
 /**
  * Oldest supported storage version.
  */
-export const LEGACY_STORAGE_VERSION = 1;
+export const LEGACY_STORAGE_VERSION = STORAGE_VERSION_1;
 
 /**
  * Default storage version for newly persisted sync rules.
  */
-export const CURRENT_STORAGE_VERSION = 2;
+export const CURRENT_STORAGE_VERSION = STORAGE_VERSION_2;
+
+/**
+ * All versions that can be loaded.
+ *
+ * This includes unstable versions.
+ */
+export const SUPPORTED_STORAGE_VERSIONS = [STORAGE_VERSION_1, STORAGE_VERSION_2, STORAGE_VERSION_3];
 
 /**
  * Shared storage-version behavior across storage implementations.
  */
 export const STORAGE_VERSION_CONFIG: Record<number, StorageVersionConfig | undefined> = {
-  [LEGACY_STORAGE_VERSION]: {
-    versionedBuckets: false
+  [STORAGE_VERSION_1]: {
+    version: STORAGE_VERSION_1,
+    versionedBuckets: false,
+    softDeleteCurrentData: false
+  },
+  [STORAGE_VERSION_2]: {
+    version: STORAGE_VERSION_2,
+    versionedBuckets: true,
+    softDeleteCurrentData: false
   },
-  [CURRENT_STORAGE_VERSION]: {
-    versionedBuckets: true
+  [STORAGE_VERSION_3]: {
+    version: STORAGE_VERSION_3,
+    versionedBuckets: true,
+    softDeleteCurrentData: true
   }
 };

package/src/storage/SyncRulesBucketStorage.ts

@@ -1,5 +1,10 @@
 import { Logger, ObserverClient } from '@powersync/lib-services-framework';
-import { HydratedSyncRules, ScopedParameterLookup, SqliteJsonRow } from '@powersync/service-sync-rules';
+import {
+  BucketDataSource,
+  HydratedSyncRules,
+  ScopedParameterLookup,
+  SqliteJsonRow
+} from '@powersync/service-sync-rules';
 import * as util from '../util/util-index.js';
 import { BucketStorageBatch, FlushedResult, SaveUpdate } from './BucketStorageBatch.js';
 import { BucketStorageFactory } from './BucketStorageFactory.js';
@@ -25,10 +30,17 @@ export interface SyncRulesBucketStorage
   resolveTable(options: ResolveTableOptions): Promise<ResolveTableResult>;
 
   /**
-   * Use this to get access to update storage data.
+   * Create a new writer.
+   *
+   * The writer must be flushed and disposed when done.
+   */
+  createWriter(options: CreateWriterOptions): Promise<BucketStorageBatch>;
+
+  /**
+   * @deprecated Use `createWriter()` with `await using` instead.
    */
   startBatch(
-    options: StartBatchOptions,
+    options: CreateWriterOptions,
     callback: (batch: BucketStorageBatch) => Promise<void>
   ): Promise<FlushedResult | null>;
 
@@ -103,7 +115,7 @@ export interface SyncRulesBucketStorage
    */
   getBucketDataBatch(
     checkpoint: util.InternalOpId,
-    dataBuckets: Map<string, util.InternalOpId>,
+    dataBuckets: BucketDataRequest[],
     options?: BucketDataBatchOptions
   ): AsyncIterable<SyncBucketDataChunk>;
 
@@ -115,7 +127,7 @@ export interface SyncRulesBucketStorage
    * This may be slow, depending on the size of the buckets.
    * The checksums are cached internally to compensate for this, but does not cover all cases.
    */
-  getChecksums(checkpoint: util.InternalOpId, buckets: string[]): Promise<util.ChecksumMap>;
+  getChecksums(checkpoint: util.InternalOpId, buckets: BucketChecksumRequest[]): Promise<util.ChecksumMap>;
 
   /**
    * Clear checksum cache. Primarily intended for tests.
@@ -127,6 +139,16 @@ export interface SyncRulesBucketStorageListener {
   batchStarted: (batch: BucketStorageBatch) => void;
 }
 
+export interface BucketDataRequest {
+  bucket: string;
+  start: util.InternalOpId;
+  source: BucketDataSource;
+}
+export interface BucketChecksumRequest {
+  bucket: string;
+  source: BucketDataSource;
+}
+
 export interface SyncRuleStatus {
   checkpoint_lsn: string | null;
   active: boolean;
@@ -147,7 +169,7 @@ export interface ResolveTableResult {
   dropTables: SourceTable[];
 }
 
-export interface StartBatchOptions extends ParseSyncRulesOptions {
+export interface CreateWriterOptions extends ParseSyncRulesOptions {
   zeroLSN: string;
   /**
    * Whether or not to store a copy of the current data.
@@ -177,6 +199,11 @@ export interface StartBatchOptions extends ParseSyncRulesOptions {
   logger?: Logger;
 }
 
+/**
+ * @deprecated Use `CreateWriterOptions`.
+ */
+export interface StartBatchOptions extends CreateWriterOptions {}
+
 export interface CompactOptions {
   /**
    * Heap memory limit for the compact process.

package/src/sync/BucketChecksumState.ts

@@ -7,7 +7,8 @@ import {
   QuerierError,
   RequestedStream,
   RequestParameters,
-  ResolvedBucket
+  ResolvedBucket,
+  mergeBuckets
 } from '@powersync/service-sync-rules';
 
 import * as storage from '../storage/storage-index.js';
@@ -137,20 +138,20 @@ export class BucketChecksumState {
       }
 
       // Re-check updated buckets only
-      let checksumLookups: string[] = [];
+      let checksumLookups: storage.BucketChecksumRequest[] = [];
 
       let newChecksums = new Map<string, util.BucketChecksum>();
-      for (let bucket of bucketDescriptionMap.keys()) {
-        if (!updatedBuckets.has(bucket)) {
-          const existing = this.lastChecksums.get(bucket);
+      for (let desc of bucketDescriptionMap.values()) {
+        if (!updatedBuckets.has(desc.bucket)) {
+          const existing = this.lastChecksums.get(desc.bucket);
           if (existing == null) {
             // If this happens, it means updatedBuckets did not correctly include all new buckets
-            throw new ServiceAssertionError(`Existing checksum not found for bucket ${bucket}`);
+            throw new ServiceAssertionError(`Existing checksum not found for bucket ${desc.bucket}`);
           }
           // Bucket is not specifically updated, and we have a previous checksum
-          newChecksums.set(bucket, existing);
+          newChecksums.set(desc.bucket, existing);
         } else {
-          checksumLookups.push(bucket);
+          checksumLookups.push({ bucket: desc.bucket, source: desc.source });
         }
       }
 
@@ -163,12 +164,12 @@ export class BucketChecksumState {
       checksumMap = newChecksums;
     } else {
       // Re-check all buckets
-      const bucketList = [...bucketDescriptionMap.keys()];
+      const bucketList = [...bucketDescriptionMap.values()].map((b) => ({ bucket: b.bucket, source: b.source }));
       checksumMap = await storage.getChecksums(base.checkpoint, bucketList);
     }
 
     // Subset of buckets for which there may be new data in this batch.
-    let bucketsToFetch: BucketDescription[];
+    let bucketsToFetch: ResolvedBucket[];
 
     let checkpointLine: util.StreamingSyncCheckpointDiff | util.StreamingSyncCheckpoint;
 
@@ -207,10 +208,7 @@ export class BucketChecksumState {
         ...this.parameterState.translateResolvedBucket(bucketDescriptionMap.get(e.bucket)!, streamNameToIndex)
       }));
       bucketsToFetch = [...generateBucketsToFetch].map((b) => {
-        return {
-          priority: bucketDescriptionMap.get(b)!.priority,
-          bucket: b
-        };
+        return bucketDescriptionMap.get(b)!;
       });
 
       deferredLog = () => {
@@ -265,7 +263,7 @@ export class BucketChecksumState {
           totalParamResults
         );
       };
-      bucketsToFetch = allBuckets.map((b) => ({ bucket: b.bucket, priority: b.priority }));
+      bucketsToFetch = allBuckets;
 
       const subscriptions: util.StreamDescription[] = [];
       const streamNameToIndex = new Map<string, number>();
@@ -342,17 +340,17 @@ export class BucketChecksumState {
         deferredLog();
       },
 
-      getFilteredBucketPositions: (buckets?: BucketDescription[]): Map<string, util.InternalOpId> => {
+      getFilteredBucketPositions: (buckets?: ResolvedBucket[]): storage.BucketDataRequest[] => {
         if (!hasAdvanced) {
           throw new ServiceAssertionError('Call line.advance() before getFilteredBucketPositions()');
         }
         buckets ??= bucketsToFetch;
-        const filtered = new Map<string, util.InternalOpId>();
+        const filtered: storage.BucketDataRequest[] = [];
 
         for (let bucket of buckets) {
           const state = this.bucketDataPositions.get(bucket.bucket);
           if (state) {
-            filtered.set(bucket.bucket, state.start_op_id);
+            filtered.push({ bucket: bucket.bucket, start: state.start_op_id, source: bucket.source });
           }
         }
         return filtered;
@@ -660,7 +658,7 @@ export class BucketParameterState {
 
 export interface CheckpointLine {
   checkpointLine: util.StreamingSyncCheckpointDiff | util.StreamingSyncCheckpoint;
-  bucketsToFetch: BucketDescription[];
+  bucketsToFetch: ResolvedBucket[];
 
   /**
    * Call when a checkpoint line is being sent to a client, to update the internal state.
@@ -672,7 +670,7 @@ export interface CheckpointLine {
    *
    * @param bucketsToFetch List of buckets to fetch - either this.bucketsToFetch, or a subset of it. Defaults to this.bucketsToFetch.
    */
-  getFilteredBucketPositions(bucketsToFetch?: BucketDescription[]): Map<string, util.InternalOpId>;
+  getFilteredBucketPositions(bucketsToFetch?: ResolvedBucket[]): storage.BucketDataRequest[];
 
   /**
    * Update the position of bucket data the client has, after it was sent to the client.
@@ -762,32 +760,3 @@ function limitedBuckets(buckets: string[] | { bucket: string }[], limit: number)
   const limited = buckets.slice(0, limit);
   return `${JSON.stringify(limited)}...`;
 }
-
-/**
- * Resolves duplicate buckets in the given array, merging the inclusion reasons for duplicate.
- *
- * It's possible for duplicates to occur when a stream has multiple subscriptions, consider e.g.
- *
- * ```
- * sync_streams:
- *  assets_by_category:
- *    query: select * from assets where category in (request.parameters() -> 'categories')
- * ```
- *
- * Here, a client might subscribe once with `{"categories": [1]}` and once with `{"categories": [1, 2]}`. Since each
- * subscription is evaluated independently, this would lead to three buckets, with a duplicate `assets_by_category[1]`
- * bucket.
- */
-function mergeBuckets(buckets: ResolvedBucket[]): ResolvedBucket[] {
-  const byBucketId: Record<string, ResolvedBucket> = {};
-
-  for (const bucket of buckets) {
-    if (Object.hasOwn(byBucketId, bucket.bucket)) {
-      byBucketId[bucket.bucket].inclusion_reasons.push(...bucket.inclusion_reasons);
-    } else {
-      byBucketId[bucket.bucket] = structuredClone(bucket);
-    }
-  }
-
-  return Object.values(byBucketId);
-}

package/src/sync/sync.ts

@@ -1,5 +1,11 @@
 import { JSONBig, JsonContainer } from '@powersync/service-jsonbig';
-import { BucketDescription, BucketPriority, HydratedSyncRules, SqliteJsonValue } from '@powersync/service-sync-rules';
+import {
+  BucketDescription,
+  BucketPriority,
+  HydratedSyncRules,
+  ResolvedBucket,
+  SqliteJsonValue
+} from '@powersync/service-sync-rules';
 
 import { AbortError } from 'ix/aborterror.js';
 
@@ -179,7 +185,7 @@ async function* streamResponseInner(
       // receive a sync complete message after the synchronization is done (which happens in the last
       // bucketDataInBatches iteration). Without any batch, the line is missing and clients might not complete their
       // sync properly.
-      const priorityBatches: [BucketPriority | null, BucketDescription[]][] = bucketsByPriority;
+      const priorityBatches: [BucketPriority | null, ResolvedBucket[]][] = bucketsByPriority;
       if (priorityBatches.length == 0) {
         priorityBatches.push([null, []]);
       }
@@ -257,7 +263,7 @@ interface BucketDataRequest {
   /** Contains current bucket state. Modified by the request as data is sent. */
   checkpointLine: CheckpointLine;
   /** Subset of checkpointLine.bucketsToFetch, filtered by priority. */
-  bucketsToFetch: BucketDescription[];
+  bucketsToFetch: ResolvedBucket[];
   /** Whether data lines should be encoded in a legacy format where {@link util.OplogEntry.data} is a nested object. */
   legacyDataLines: boolean;
   /** Signals that the connection was aborted and that streaming should stop ASAP. */

package/src/sync/util.ts

@@ -183,6 +183,16 @@ export function settledPromise<T>(promise: Promise<T>): Promise<PromiseSettledRe
   );
 }
 
+export function unsettledPromise<T>(settled: Promise<PromiseSettledResult<T>>): Promise<T> {
+  return settled.then((result) => {
+    if (result.status === 'fulfilled') {
+      return Promise.resolve(result.value);
+    } else {
+      return Promise.reject(result.reason);
+    }
+  });
+}
+
 export type MapOrSet<T> = Map<T, any> | Set<T>;
 
 /**

package/test/src/auth.test.ts

@@ -7,7 +7,7 @@ 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 } from '../../src/auth/utils.js';
+import { debugKeyNotFound, getSupabaseJwksUrl } from '../../src/auth/utils.js';
 
 const publicKeyRSA: jose.JWK = {
   use: 'sig',
@@ -496,6 +496,25 @@ describe('JWT Auth', () => {
     expect(verified.parsedPayload.claim).toEqual('test-claim-2');
   });
 
+  test('Supabase connection parsing', () => {
+    const details = getSupabaseJwksUrl({
+      type: 'postgresql',
+      uri: 'postgresql://db.abc123.supabase.co:5432/postgres'
+    });
+    expect(details).toEqual({
+      hostname: 'db.abc123.supabase.co',
+      projectId: 'abc123',
+      url: 'https://abc123.supabase.co/auth/v1/.well-known/jwks.json'
+    });
+
+    // supabase.com is not a supabase URI
+    const other = getSupabaseJwksUrl({
+      type: 'postgresql',
+      uri: 'postgresql://db.abc123.supabase.com:5432/postgres'
+    });
+    expect(other).toEqual(null);
+  });
+
   describe('debugKeyNotFound', () => {
     test('Supabase token with legacy auth not configured', async () => {
       const keys = await StaticSupabaseKeyCollector.importKeys([]);