@powersync/service-module-mssql 0.9.0 → 0.10.1

package/test/src/CDCStream.test.ts

@@ -110,14 +110,16 @@ function defineCDCStreamTests(config: storage.TestStorageConfig) {
     expect(data).toMatchObject([putOp('test_data', testData), removeOp('test_data', testData.id)]);
   });
 
-  test('Replicate matched wild card tables in sync rules', async () => {
+  test('Replicate multiple tables in sync rules', async () => {
     await using context = await CDCStreamTestContext.open(factory);
     const { connectionManager } = context;
+    // Table wildcards are not supported - each table is listed explicitly.
     await context.updateSyncRules(`
   bucket_definitions:
     global:
       data:
-        - SELECT id, description FROM "test_data_%"`);
+        - SELECT id, description FROM "test_data_1"
+        - SELECT id, description FROM "test_data_2"`);
 
     await createTestTable(connectionManager, 'test_data_1');
     await createTestTable(connectionManager, 'test_data_2');
@@ -148,6 +150,8 @@ function defineCDCStreamTests(config: storage.TestStorageConfig) {
     const { connectionManager } = context;
     await context.updateSyncRules(BASIC_SYNC_RULES);
 
+    // test_data is in the sync config and must exist for replication to start; test_donotsync is not.
+    await createTestTable(connectionManager, 'test_data');
     await createTestTable(connectionManager, 'test_donotsync');
 
     await context.replicateSnapshot();

package/test/src/CDCStreamTestContext.ts

@@ -74,6 +74,13 @@ export class CDCStreamTestContext implements AsyncDisposable {
     return this.connectionManager.connectionTag;
   }
 
+  /**
+   * Resolves when streaming stops, or rejects with the failure that stopped it.
+   */
+  get streamingPromise() {
+    return this.streamPromise;
+  }
+
   async updateSyncRules(content: string) {
     const replicationStream = await this.factory.updateSyncRules(
       updateSyncRulesFromYaml(content, { validate: true, storageVersion: LEGACY_STORAGE_VERSION })

package/test/src/CaptureReconciler.test.ts

@@ -0,0 +1,171 @@
+import { CaptureInstance } from '@module/common/CaptureInstance.js';
+import { createCaptureReconciler, readCaptureMetadata } from '@module/replication/CaptureReconciler.js';
+import type { MSSQLTableReconciliationContext } from '@module/replication/MSSQLTableReconciliationContext.js';
+import { MSSQLTableReconciliationState } from '@module/replication/MSSQLTableReconciliationContext.js';
+import { SourceEntityDescriptor, SourceTable } from '@powersync/service-core';
+import { describe, expect, it } from 'vitest';
+import { createCaptureInstance, createSourceDescriptor, createSourceTableCandidate } from './util.js';
+
+function reconcile(context: MSSQLTableReconciliationContext, candidates: SourceTable[]) {
+  return createCaptureReconciler(context)({ source: context.source, candidates });
+}
+
+describe('readCaptureMetadata', () => {
+  it('parses a valid metadata object', () => {
+    expect(readCaptureMetadata({ captureTableObjectId: 7 })).toEqual({ captureTableObjectId: 7 });
+  });
+
+  it('returns null for legacy metadata', () => {
+    expect(readCaptureMetadata(null)).toBeNull();
+  });
+
+  it('rejects malformed metadata', () => {
+    expect(() => readCaptureMetadata([1, 2] as any)).toThrow();
+    expect(() => readCaptureMetadata({ foo: 1 } as any)).toThrow();
+  });
+});
+
+describe('createCaptureReconciler', () => {
+  it('pins a new binding to the newest available capture instance', () => {
+    const resolution = reconcile(readyContext([createCaptureInstance(50), createCaptureInstance(40)]), []);
+    expect(resolution.compatibleTables).toEqual([]);
+    expect(resolution.incompatibleTables).toEqual([]);
+    expect(resolution.newTableValues).toEqual({ sourceMetadata: { captureTableObjectId: 50 } });
+  });
+
+  it('reports a missing table with no persisted binding as not ready', () => {
+    expect(() =>
+      reconcile(
+        unavailableContext(
+          MSSQLTableReconciliationState.TABLE_MISSING,
+          createSourceDescriptor({ objectId: undefined, replicaIdColumns: [] })
+        ),
+        []
+      )
+    ).toThrow(/does not exist/);
+  });
+
+  it('reports a missing table with a persisted binding as unavailable', () => {
+    expect(() =>
+      reconcile(
+        unavailableContext(
+          MSSQLTableReconciliationState.TABLE_MISSING,
+          createSourceDescriptor({ objectId: undefined, replicaIdColumns: [] })
+        ),
+        [createSourceTableCandidate('old', { captureTableObjectId: 40 })]
+      )
+    ).toThrow(/no longer matches the source table binding/);
+  });
+
+  it('fails a new binding when CDC is disabled', () => {
+    expect(() => reconcile(unavailableContext(MSSQLTableReconciliationState.CDC_DISABLED), [])).toThrow(
+      /CDC is not enabled/
+    );
+  });
+
+  it('updates legacy metadata-free candidates to the newest capture instance', () => {
+    const resolution = reconcile(readyContext([createCaptureInstance(50)]), [
+      createSourceTableCandidate('a'),
+      createSourceTableCandidate('b')
+    ]);
+    expect(
+      resolution.compatibleTables.map((table) => ({ id: table.id, sourceMetadata: table.sourceMetadata }))
+    ).toEqual([
+      { id: 'a', sourceMetadata: { captureTableObjectId: 50 } },
+      { id: 'b', sourceMetadata: { captureTableObjectId: 50 } }
+    ]);
+    expect(resolution.incompatibleTables).toEqual([]);
+    expect(resolution.newTableValues).toEqual({ sourceMetadata: { captureTableObjectId: 50 } });
+  });
+
+  it('fails an existing binding when CDC is disabled', () => {
+    expect(() =>
+      reconcile(unavailableContext(MSSQLTableReconciliationState.CDC_DISABLED), [createSourceTableCandidate('a')])
+    ).toThrow(/CDC is no longer enabled/);
+  });
+
+  it('reports a changed source identity as unavailable when CDC is disabled', () => {
+    const changedSource = createSourceDescriptor({ objectId: 200 });
+    expect(() =>
+      reconcile(unavailableContext(MSSQLTableReconciliationState.CDC_DISABLED, changedSource), [
+        createSourceTableCandidate('old')
+      ])
+    ).toThrow(/no longer matches the source table binding/);
+  });
+
+  it('preserves a pinned capture identity that is still available', () => {
+    const resolution = reconcile(readyContext([createCaptureInstance(50), createCaptureInstance(40)]), [
+      createSourceTableCandidate('a', { captureTableObjectId: 40 })
+    ]);
+    expect(resolution.compatibleTables.map((table) => table.id)).toEqual(['a']);
+    expect(resolution.compatibleTables[0].sourceMetadata).toEqual({ captureTableObjectId: 40 });
+    expect(resolution.incompatibleTables).toEqual([]);
+    expect(resolution.newTableValues).toEqual({ sourceMetadata: { captureTableObjectId: 40 } });
+  });
+
+  it('fails when the pinned capture instance was dropped, even with a replacement available', () => {
+    expect(() =>
+      reconcile(readyContext([createCaptureInstance(50)]), [
+        createSourceTableCandidate('a', { captureTableObjectId: 40 })
+      ])
+    ).toThrow(/no longer available/);
+  });
+
+  it('fails on a mixture of metadata-free and pinned candidates', () => {
+    expect(() =>
+      reconcile(readyContext([createCaptureInstance(40)]), [
+        createSourceTableCandidate('a'),
+        createSourceTableCandidate('b', { captureTableObjectId: 40 })
+      ])
+    ).toThrow(/mixture/);
+  });
+
+  it('fails on multiple distinct pinned identities', () => {
+    expect(() =>
+      reconcile(readyContext([createCaptureInstance(40), createCaptureInstance(41)]), [
+        createSourceTableCandidate('a', { captureTableObjectId: 40 }),
+        createSourceTableCandidate('b', { captureTableObjectId: 41 })
+      ])
+    ).toThrow(/multiple persisted capture identities/);
+  });
+
+  it('does not replace an existing binding when the source identity changed', () => {
+    const changedSource = createSourceDescriptor({ objectId: 200 });
+    expect(() =>
+      reconcile(readyContext([createCaptureInstance(50)], changedSource), [
+        createSourceTableCandidate('old', { captureTableObjectId: 40 })
+      ])
+    ).toThrow(/Table \[dbo]\.\[users] no longer matches the source table binding.*already-replicated data is retained/);
+  });
+
+  it('drops stale incompatible candidates when a compatible candidate anchors the binding', () => {
+    const resolution = reconcile(readyContext([createCaptureInstance(50)]), [
+      createSourceTableCandidate('a'),
+      createSourceTableCandidate('mismatch', undefined, {
+        replicaIdColumns: [{ name: 'id', type: 'bigint', typeId: 127 }]
+      })
+    ]);
+    expect(
+      resolution.compatibleTables.map((table) => ({ id: table.id, sourceMetadata: table.sourceMetadata }))
+    ).toEqual([{ id: 'a', sourceMetadata: { captureTableObjectId: 50 } }]);
+    expect(resolution.incompatibleTables.map((table) => table.id)).toEqual(['mismatch']);
+  });
+});
+
+function readyContext(
+  captureInstances: CaptureInstance[],
+  sourceDescriptor: SourceEntityDescriptor = createSourceDescriptor()
+): MSSQLTableReconciliationContext {
+  return {
+    state: MSSQLTableReconciliationState.READY,
+    source: sourceDescriptor,
+    captureInstances
+  };
+}
+
+function unavailableContext(
+  state: MSSQLTableReconciliationState.TABLE_MISSING | MSSQLTableReconciliationState.CDC_DISABLED,
+  sourceDescriptor: SourceEntityDescriptor = createSourceDescriptor()
+): MSSQLTableReconciliationContext {
+  return { state, source: sourceDescriptor };
+}

package/test/src/MSSQLSourceTable.test.ts

@@ -0,0 +1,30 @@
+import { MSSQLSourceTable } from '@module/common/MSSQLSourceTable.js';
+import { describe, expect, it } from 'vitest';
+import { createCaptureInstance, createSourceDescriptor, createSourceTableCandidate } from './util.js';
+
+describe('MSSQLSourceTable.setCaptureInstance', () => {
+  it('sets the instance matching the persisted capture-table object id', () => {
+    const table = new MSSQLSourceTable(createSourceDescriptor(), [
+      createSourceTableCandidate('a', { captureTableObjectId: 40 })
+    ]);
+    const expected = createCaptureInstance(40);
+
+    table.setCaptureInstance([createCaptureInstance(50), expected]);
+
+    expect(table.captureInstance).toBe(expected);
+  });
+
+  it('sets null when the binding is legacy or the pinned instance is unavailable', () => {
+    const legacy = new MSSQLSourceTable(createSourceDescriptor(), [createSourceTableCandidate('legacy')]);
+    const pinned = new MSSQLSourceTable(createSourceDescriptor(), [
+      createSourceTableCandidate('pinned', { captureTableObjectId: 40 })
+    ]);
+
+    legacy.setCaptureInstance([createCaptureInstance(40)]);
+    pinned.setCaptureInstance([createCaptureInstance(40)]);
+    pinned.setCaptureInstance([createCaptureInstance(50)]);
+
+    expect(legacy.captureInstance).toBeNull();
+    expect(pinned.captureInstance).toBeNull();
+  });
+});

package/test/src/config.test.ts

@@ -1,3 +1,4 @@
+import { createConnectionPoolConfig } from '@module/replication/MSSQLConnectionManager.js';
 import { normalizeConnectionConfig } from '@module/types/types.js';
 import { describe, expect, test } from 'vitest';
 
@@ -7,6 +8,42 @@ const BASE_CONFIG = {
 };
 
 describe('SQL Server connection config', () => {
+  test('passes a custom CA to the SQL Server TLS configuration', () => {
+    const cacert = `-----BEGIN CERTIFICATE-----
+test certificate
+-----END CERTIFICATE-----`;
+    const normalized = normalizeConnectionConfig({ ...BASE_CONFIG, cacert });
+
+    expect(normalized.cacert).toBe(cacert);
+    expect(createConnectionPoolConfig(normalized, {}).options).toMatchObject({
+      encrypt: true,
+      trustServerCertificate: false,
+      cryptoCredentialsDetails: { ca: cacert }
+    });
+  });
+
+  test('passes a custom TLS server name to the SQL Server TLS configuration', () => {
+    const normalized = normalizeConnectionConfig({ ...BASE_CONFIG, tls_servername: 'sql.internal.example' });
+
+    expect(createConnectionPoolConfig(normalized, {}).options?.serverName).toBe('sql.internal.example');
+  });
+
+  test('rejects a custom CA when server certificate validation is disabled', () => {
+    expect(() =>
+      normalizeConnectionConfig({
+        ...BASE_CONFIG,
+        cacert: 'certificate',
+        additionalConfig: { trustServerCertificate: true }
+      })
+    ).toThrow(/cacert cannot be used with trustServerCertificate/);
+  });
+
+  test('does not configure a custom TLS context without a custom CA', () => {
+    const normalized = normalizeConnectionConfig(BASE_CONFIG);
+
+    expect(createConnectionPoolConfig(normalized, {}).options?.cryptoCredentialsDetails).toBeUndefined();
+  });
+
   test('defaults heartbeat_interval_seconds to 60 seconds', () => {
     expect(normalizeConnectionConfig(BASE_CONFIG).heartbeat_interval_seconds).toBe(60);
   });