@powersync/service-core 1.20.3 → 1.20.5

package/test/src/ReplicationLagTracker.test.ts

@@ -0,0 +1,53 @@
+import { ReplicationLagTracker } from '@/replication/ReplicationLagTracker.js';
+import { describe, expect, it } from 'vitest';
+
+describe('ReplicationLagTracker', () => {
+  it('returns undefined before replication has started', () => {
+    const tracker = new ReplicationLagTracker();
+
+    expect(tracker.getLagMillis(0)).toBeUndefined();
+  });
+
+  it('tracks the oldest in-flight change and returns current lag', () => {
+    const tracker = new ReplicationLagTracker();
+
+    tracker.trackUncommittedChange(new Date(1_000));
+    tracker.trackUncommittedChange(new Date(2_000));
+
+    expect(tracker.oldestUncommittedChange?.getTime()).toBe(1_000);
+    expect(tracker.getCurrentLagMillis(4_000)).toBe(3_000);
+    expect(tracker.getLagMillis(4_000)).toBe(3_000);
+  });
+
+  it('records commit lag into the rolling window and clears in-flight state', () => {
+    const tracker = new ReplicationLagTracker();
+
+    tracker.trackUncommittedChange(new Date(0));
+    tracker.markCommitted(5_000);
+
+    expect(tracker.oldestUncommittedChange).toBeNull();
+    expect(tracker.isStartingReplication).toBe(false);
+    expect(tracker.getLagMillis(5_000)).toBe(5_000);
+    expect(tracker.getLagMillis(35_000)).toBe(0);
+  });
+
+  it('can clear in-flight state without changing started state', () => {
+    const tracker = new ReplicationLagTracker();
+
+    tracker.trackUncommittedChange(new Date(0));
+    tracker.clearUncommittedChange();
+
+    expect(tracker.oldestUncommittedChange).toBeNull();
+    expect(tracker.isStartingReplication).toBe(true);
+    expect(tracker.getLagMillis(5_000)).toBeUndefined();
+  });
+
+  it('can mark replication as started without a committed transaction', () => {
+    const tracker = new ReplicationLagTracker();
+
+    tracker.markStarted();
+
+    expect(tracker.isStartingReplication).toBe(false);
+    expect(tracker.getLagMillis(0)).toBe(0);
+  });
+});

package/test/src/RollingBucketMax.test.ts

@@ -0,0 +1,106 @@
+import { RollingBucketMax } from '@/metrics/RollingBucketMax.js';
+import { describe, expect, it } from 'vitest';
+
+describe('RollingBucketMax', () => {
+  it('returns undefined before any values are reported', () => {
+    const tracker = new RollingBucketMax();
+
+    expect(tracker.getRollingMax(0)).toBeUndefined();
+  });
+
+  it('tracks the maximum value within a single bucket', () => {
+    const tracker = new RollingBucketMax();
+
+    tracker.report(3, 100);
+    tracker.report(9, 1_000);
+    tracker.report(5, 4_999);
+
+    expect(tracker.getRollingMax(4_999)).toBe(9);
+  });
+
+  it('keeps the rolling max across the last six 5s buckets', () => {
+    const tracker = new RollingBucketMax();
+
+    tracker.report(20, 0);
+    tracker.report(11, 5_000);
+    tracker.report(12, 10_000);
+    tracker.report(13, 15_000);
+    tracker.report(14, 20_000);
+    tracker.report(15, 25_000);
+
+    expect(tracker.getRollingMax(29_999)).toBe(20);
+    expect(tracker.getRollingMax(30_000)).toBe(15);
+  });
+
+  it('slides the rolling max forward as older buckets age out', () => {
+    const tracker = new RollingBucketMax();
+
+    tracker.report(20, 0);
+    expect(tracker.getRollingMax(0)).toBe(20);
+
+    tracker.report(18, 5_000);
+    expect(tracker.getRollingMax(5_000)).toBe(20);
+
+    tracker.report(16, 10_000);
+    expect(tracker.getRollingMax(10_000)).toBe(20);
+
+    tracker.report(14, 15_000);
+    expect(tracker.getRollingMax(15_000)).toBe(20);
+
+    tracker.report(12, 20_000);
+    expect(tracker.getRollingMax(20_000)).toBe(20);
+
+    tracker.report(10, 25_000);
+    expect(tracker.getRollingMax(29_999)).toBe(20);
+
+    tracker.report(8, 30_000);
+    expect(tracker.getRollingMax(30_000)).toBe(18);
+
+    tracker.report(6, 35_000);
+    expect(tracker.getRollingMax(35_000)).toBe(16);
+
+    tracker.report(4, 40_000);
+    expect(tracker.getRollingMax(40_000)).toBe(14);
+  });
+
+  it('keeps newer buckets in the rolling window while older peaks fall out', () => {
+    const tracker = new RollingBucketMax();
+
+    tracker.report(50, 0);
+    tracker.report(11, 5_000);
+    tracker.report(12, 10_000);
+    tracker.report(13, 15_000);
+    tracker.report(14, 20_000);
+    tracker.report(15, 25_000);
+
+    expect(tracker.getRollingMax(29_999)).toBe(50);
+
+    tracker.report(40, 30_000);
+    expect(tracker.getRollingMax(30_000)).toBe(40);
+    expect(tracker.getRollingMax(34_999)).toBe(40);
+  });
+
+  it('expires values after the rolling window passes with no new reports', () => {
+    const tracker = new RollingBucketMax();
+
+    tracker.report(7, 0);
+
+    expect(tracker.getRollingMax(29_999)).toBe(7);
+    expect(tracker.getRollingMax(30_000)).toBeUndefined();
+  });
+
+  it('supports custom bucket and window sizes', () => {
+    const tracker = new RollingBucketMax({
+      bucketSizeMs: 1_000,
+      windowSizeMs: 3_000
+    });
+
+    tracker.report(4, 0);
+    tracker.report(6, 1_000);
+    tracker.report(5, 2_000);
+
+    expect(tracker.getRollingMax(2_999)).toBe(6);
+    expect(tracker.getRollingMax(3_000)).toBe(6);
+    expect(tracker.getRollingMax(4_000)).toBe(5);
+  });
+});

package/test/src/auth.test.ts

@@ -1,13 +1,13 @@
-import { describe, expect, test } from 'vitest';
-import { StaticKeyCollector } from '../../src/auth/StaticKeyCollector.js';
+import { StaticSupabaseKeyCollector } from '@/index.js';
 import * as jose from 'jose';
-import { KeyStore } from '../../src/auth/KeyStore.js';
+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 { KeyStore } from '../../src/auth/KeyStore.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',

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.

package/test/src/routes/stream.test.ts

@@ -1,6 +1,6 @@
 import { BasicRouterRequest, Context, JwtPayload, SyncRulesBucketStorage } from '@/index.js';
 import { RouterResponse, ServiceError, logger } from '@powersync/lib-services-framework';
-import { SqlSyncRules } from '@powersync/service-sync-rules';
+import { DEFAULT_HYDRATION_STATE, SqlSyncRules } from '@powersync/service-sync-rules';
 import { Readable, Writable } from 'stream';
 import { pipeline } from 'stream/promises';
 import { describe, expect, it } from 'vitest';
@@ -8,7 +8,6 @@ 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', () => {

package/test/src/sync/BucketChecksumState.test.ts

@@ -15,13 +15,12 @@ import {
 import { JSONBig } from '@powersync/service-jsonbig';
 import {
   ParameterIndexLookupCreator,
-  RequestJwtPayload,
   ScopedParameterLookup,
+  SourceTableInterface,
   SqliteJsonRow,
   SqliteRow,
   SqlSyncRules,
   TablePattern,
-  SourceTableInterface,
   versionedHydrationState
 } from '@powersync/service-sync-rules';
 import { ParameterLookupScope } from '@powersync/service-sync-rules/src/HydrationState.js';
@@ -986,6 +985,7 @@ bucket_definitions:
       expect(errorMessages[0]).toContain('tasks: 20');
       expect(errorMessages[0]).toContain('comments: 10');
 
+      expect(errorData[0].checkpoint).toEqual(1n);
       expect(errorData[0].parameter_query_results).toBe(60);
       expect(errorData[0].parameter_query_results_by_definition).toEqual({
         projects: 30,

package/test/src/util/protocol_types.test.ts

@@ -1,6 +1,6 @@
 import { StreamingSyncRequest } from '@/index.js';
 import { schema } from '@powersync/lib-services-framework';
-import { describe, test, expect, it } from 'vitest';
+import { describe, expect, test } from 'vitest';
 
 describe('protocol types', () => {
   describe('StreamingSyncRequest', () => {