@powersync/service-core 0.0.0-dev-20250317122913 → 0.0.0-dev-20250326092547

package/src/sync/util.ts

@@ -1,8 +1,8 @@
 import * as timers from 'timers/promises';
 
+import { SemaphoreInterface } from 'async-mutex';
 import * as util from '../util/util-index.js';
 import { RequestTracker } from './RequestTracker.js';
-import { SemaphoreInterface } from 'async-mutex';
 
 export type TokenStreamOptions = {
   /**
@@ -154,14 +154,35 @@ export function settledPromise<T>(promise: Promise<T>): Promise<PromiseSettledRe
   );
 }
 
-export function hasIntersection<T>(a: Set<T>, b: Set<T>) {
-  if (a.size > b.size) {
-    [a, b] = [b, a];
+export type MapOrSet<T> = Map<T, any> | Set<T>;
+
+/**
+ * Check if two sets have any element(s) in common.
+ */
+export function hasIntersection<T>(a: MapOrSet<T>, b: MapOrSet<T>) {
+  for (let _ of getIntersection(a, b)) {
+    return true;
   }
-  // Now, a is always smaller than b, so iterate over a
-  for (let value of a) {
-    if (b.has(value)) {
-      return true;
+  return false;
+}
+
+/**
+ * Return the intersection of two sets or maps.
+ */
+export function* getIntersection<T>(a: MapOrSet<T>, b: MapOrSet<T>): IterableIterator<T> {
+  // Iterate over the smaller set to reduce the number of lookups
+  if (a.size < b.size) {
+    for (let key of a.keys()) {
+      if (b.has(key)) {
+        yield key;
+      }
+    }
+    return false;
+  } else {
+    for (let key of b.keys()) {
+      if (a.has(key)) {
+        yield key;
+      }
     }
   }
 }

package/src/system/ServiceContext.ts

@@ -1,7 +1,7 @@
 import { LifeCycledSystem, MigrationManager, ServiceIdentifier, container } from '@powersync/lib-services-framework';
 
 import { framework } from '../index.js';
-import * as metrics from '../metrics/Metrics.js';
+import * as metrics from '../metrics/MetricsEngine.js';
 import { PowerSyncMigrationManager } from '../migrations/PowerSyncMigrationManager.js';
 import * as replication from '../replication/replication-index.js';
 import * as routes from '../routes/routes-index.js';
@@ -12,7 +12,7 @@ import { SyncContext } from '../sync/SyncContext.js';
 export interface ServiceContext {
   configuration: utils.ResolvedPowerSyncConfig;
   lifeCycleEngine: LifeCycledSystem;
-  metrics: metrics.Metrics | null;
+  metricsEngine: metrics.MetricsEngine;
   replicationEngine: replication.ReplicationEngine | null;
   routerEngine: routes.RouterEngine | null;
   storageEngine: storage.StorageEngine;
@@ -37,6 +37,11 @@ export class ServiceContextContainer implements ServiceContext {
       configuration
     });
 
+    this.lifeCycleEngine.withLifecycle(this.storageEngine, {
+      start: (storageEngine) => storageEngine.start(),
+      stop: (storageEngine) => storageEngine.shutDown()
+    });
+
     this.syncContext = new SyncContext({
       maxDataFetchConcurrency: configuration.api_parameters.max_data_fetch_concurrency,
       maxBuckets: configuration.api_parameters.max_buckets_per_connection,
@@ -65,8 +70,8 @@ export class ServiceContextContainer implements ServiceContext {
     return container.getOptional(routes.RouterEngine);
   }
 
-  get metrics(): metrics.Metrics | null {
-    return container.getOptional(metrics.Metrics);
+  get metricsEngine(): metrics.MetricsEngine {
+    return container.getImplementation(metrics.MetricsEngine);
   }
 
   get migrations(): PowerSyncMigrationManager {

package/test/src/routes/probes.integration.test.ts

@@ -1,10 +1,10 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import Fastify, { FastifyInstance } from 'fastify';
 import { container } from '@powersync/lib-services-framework';
-import * as auth from '../../../src/routes/auth.js';
-import * as system from '../../../src/system/system-index.js';
+import Fastify, { FastifyInstance } from 'fastify';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { configureFastifyServer } from '../../../src/index.js';
+import * as auth from '../../../src/routes/auth.js';
 import { ProbeRoutes } from '../../../src/routes/endpoints/probes.js';
+import * as system from '../../../src/system/system-index.js';
 
 vi.mock('@powersync/lib-services-framework', async () => {
   const actual = (await vi.importActual('@powersync/lib-services-framework')) as any;
@@ -25,7 +25,7 @@ describe('Probe Routes Integration', () => {
 
   beforeEach(async () => {
     app = Fastify();
-    mockSystem = { routerEngine: {} } as system.ServiceContext;
+    mockSystem = { routerEngine: {}, replicationEngine: {} } as system.ServiceContext;
     await configureFastifyServer(app, { service_context: mockSystem });
     await app.ready();
   });

package/test/src/routes/probes.test.ts

@@ -1,6 +1,6 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { container } from '@powersync/lib-services-framework';
-import { startupCheck, livenessCheck, readinessCheck } from '../../../src/routes/endpoints/probes.js';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { livenessCheck, readinessCheck, startupCheck } from '../../../src/routes/endpoints/probes.js';
 
 // Mock the container
 vi.mock('@powersync/lib-services-framework', () => ({
@@ -83,6 +83,7 @@ describe('Probe Routes', () => {
   });
 
   describe('livenessCheck', () => {
+    const mockedContext = { context: { service_context: { replicationEngine: {} } } } as any;
     it('has the correct route definitions', () => {
       expect(livenessCheck.path).toBe('/probes/liveness');
       expect(livenessCheck.method).toBe('GET');
@@ -97,7 +98,7 @@ describe('Probe Routes', () => {
 
       vi.mocked(container.probes.state).mockReturnValue(mockState);
 
-      const response = await livenessCheck.handler();
+      const response = await livenessCheck.handler(mockedContext);
 
       expect(response.status).toBe(200);
       expect(response.data).toEqual(mockState);
@@ -112,7 +113,7 @@ describe('Probe Routes', () => {
 
       vi.mocked(container.probes.state).mockReturnValue(mockState);
 
-      const response = await livenessCheck.handler();
+      const response = await livenessCheck.handler(mockedContext);
 
       expect(response.status).toBe(400);
       expect(response.data).toEqual(mockState);

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

@@ -98,7 +98,7 @@ bucket_definitions:
       base: { checkpoint: 2n, lsn: '2' },
       writeCheckpoint: null,
       update: {
-        updatedDataBuckets: ['global[]'],
+        updatedDataBuckets: new Set(['global[]']),
         invalidateDataBuckets: false,
         updatedParameterLookups: new Set(),
         invalidateParameterBuckets: false
@@ -201,7 +201,7 @@ bucket_definitions:
       writeCheckpoint: null,
       update: {
         ...CHECKPOINT_INVALIDATE_ALL,
-        updatedDataBuckets: ['global[1]', 'global[2]'],
+        updatedDataBuckets: new Set(['global[1]', 'global[2]']),
         invalidateDataBuckets: false
       }
     }))!;
@@ -294,7 +294,7 @@ bucket_definitions:
         // Invalidate the state for global[1] - will only re-check the single bucket.
         // This is essentially inconsistent state, but is the simplest way to test that
         // the filter is working.
-        updatedDataBuckets: ['global[1]'],
+        updatedDataBuckets: new Set(['global[1]']),
         invalidateDataBuckets: false
       }
     }))!;
@@ -421,7 +421,7 @@ bucket_definitions:
       update: {
         ...CHECKPOINT_INVALIDATE_ALL,
         invalidateDataBuckets: false,
-        updatedDataBuckets: ['global[1]']
+        updatedDataBuckets: new Set(['global[1]'])
       }
     }))!;
     expect(line2.checkpointLine).toEqual({
@@ -533,7 +533,7 @@ bucket_definitions:
       writeCheckpoint: null,
       update: {
         invalidateDataBuckets: false,
-        updatedDataBuckets: [],
+        updatedDataBuckets: new Set(),
         updatedParameterLookups: new Set([JSONBig.stringify(['by_project', '1', 'u1'])]),
         invalidateParameterBuckets: false
       }

package/test/src/util.test.ts

@@ -0,0 +1,48 @@
+import { getIntersection, hasIntersection } from '@/index.js';
+import { describe, expect, test } from 'vitest';
+
+describe('utils', () => {
+  function testInstersection(a: Set<any>, b: Set<any>, expected: boolean) {
+    expect(hasIntersection(a, b)).toBe(expected);
+    expect(hasIntersection(b, a)).toBe(expected);
+    const mapA = new Map([...a].map((v) => [v, 1]));
+    const mapB = new Map([...b].map((v) => [v, 1]));
+    expect(hasIntersection(mapA, b)).toBe(expected);
+    expect(hasIntersection(mapB, a)).toBe(expected);
+    expect(hasIntersection(mapA, mapB)).toBe(expected);
+  }
+
+  test('hasIntersection', async () => {
+    testInstersection(new Set(['a']), new Set(['a']), true);
+    testInstersection(new Set(['a', 'b', 'c']), new Set(['a', 'b', 'c']), true);
+    testInstersection(new Set(['a', 'b', 'c']), new Set(['d', 'e']), false);
+    testInstersection(new Set(['a', 'b', 'c']), new Set(['d', 'c', 'e']), true);
+    testInstersection(new Set(['a', 'b', 'c']), new Set(['c', 'e']), true);
+    testInstersection(new Set(['a', 'b', 'c', 2]), new Set([1, 2, 3]), true);
+    testInstersection(new Set(['a', 'b', 'c', 4]), new Set([1, 2, 3]), false);
+    testInstersection(new Set([]), new Set([1, 2, 3]), false);
+    testInstersection(new Set([]), new Set([]), false);
+  });
+
+  function testGetIntersection(a: Set<any>, b: Set<any>, expected: any[]) {
+    expect([...getIntersection(a, b)]).toEqual(expected);
+    expect([...getIntersection(b, a)]).toEqual(expected);
+    const mapA = new Map([...a].map((v) => [v, 1]));
+    const mapB = new Map([...b].map((v) => [v, 1]));
+    expect([...getIntersection(mapA, b)]).toEqual(expected);
+    expect([...getIntersection(mapB, a)]).toEqual(expected);
+    expect([...getIntersection(mapA, mapB)]).toEqual(expected);
+  }
+
+  test('getIntersection', async () => {
+    testGetIntersection(new Set(['a']), new Set(['a']), ['a']);
+    testGetIntersection(new Set(['a', 'b', 'c']), new Set(['a', 'b', 'c']), ['a', 'b', 'c']);
+    testGetIntersection(new Set(['a', 'b', 'c']), new Set(['d', 'e']), []);
+    testGetIntersection(new Set(['a', 'b', 'c']), new Set(['d', 'c', 'e']), ['c']);
+    testGetIntersection(new Set(['a', 'b', 'c']), new Set(['c', 'e']), ['c']);
+    testGetIntersection(new Set(['a', 'b', 'c', 2]), new Set([1, 2, 3]), [2]);
+    testGetIntersection(new Set(['a', 'b', 'c', 4]), new Set([1, 2, 3]), []);
+    testGetIntersection(new Set([]), new Set([1, 2, 3]), []);
+    testGetIntersection(new Set([]), new Set([]), []);
+  });
+});