@powersync/service-module-mysql 0.10.2 → 0.12.0

package/src/types/types.ts

@@ -6,6 +6,18 @@ import * as urijs from 'uri-js';
 
 export const MYSQL_CONNECTION_TYPE = 'mysql' as const;
 
+/**
+ * Connection parameters that can be parsed from the MySQL URI query string.
+ *
+ * All values are in milliseconds (for timeouts) or counts (for limits).
+ * MySQL uses camelCase naming convention.
+ */
+export interface MySQLConnectionParams {
+  connectTimeout?: number;
+  connectionLimit?: number;
+  queueLimit?: number;
+}
+
 export interface NormalizedMySQLConnectionConfig {
   id: string;
   tag: string;
@@ -25,6 +37,8 @@ export interface NormalizedMySQLConnectionConfig {
   lookup?: LookupFunction;
 
   binlog_queue_memory_limit: number;
+
+  connectionParams: MySQLConnectionParams;
 }
 
 export const MySQLConnectionConfig = service_types.configFile.DataSourceConfig.and(
@@ -105,6 +119,10 @@ export function normalizeConnectionConfig(options: MySQLConnectionConfig): Norma
 
   const lookup = makeHostnameLookupFunction(hostname, { reject_ip_ranges: options.reject_ip_ranges ?? [] });
 
+  // Parse connection parameters from URL query string
+  const uriQuery = uri.query ? new URLSearchParams(uri.query) : undefined;
+  const connectionParams = parseMySQLConnectionParams(uriQuery);
+
   return {
     id: options.id ?? 'default',
     tag: options.tag ?? 'default',
@@ -121,6 +139,55 @@ export function normalizeConnectionConfig(options: MySQLConnectionConfig): Norma
     // Binlog processing queue memory limit before throttling is applied.
     binlog_queue_memory_limit: options.binlog_queue_memory_limit ?? 50,
 
-    lookup
+    lookup,
+
+    connectionParams
   };
 }
+
+/**
+ * Parse a single numeric connection parameter from a URI query string value.
+ *
+ * Returns undefined if the value is missing, not a valid number, NaN, negative, zero, or Infinity.
+ */
+export function parseMySQLConnectionParam(value: string | null | undefined): number | undefined {
+  if (value == null) {
+    return undefined;
+  }
+  const parsed = Number(value);
+  if (isFinite(parsed) && parsed > 0) {
+    return parsed;
+  }
+  return undefined;
+}
+
+/**
+ * Parse connection parameters from a MySQL URI's query string.
+ *
+ * MySQL uses camelCase naming convention.
+ * Invalid values (NaN, negative, non-numeric) are silently ignored.
+ */
+export function parseMySQLConnectionParams(searchParams: URLSearchParams | undefined): MySQLConnectionParams {
+  const params: MySQLConnectionParams = {};
+
+  if (searchParams == null) {
+    return params;
+  }
+
+  const connectTimeout = parseMySQLConnectionParam(searchParams.get('connectTimeout'));
+  if (connectTimeout != null) {
+    params.connectTimeout = connectTimeout;
+  }
+
+  const connectionLimit = parseMySQLConnectionParam(searchParams.get('connectionLimit'));
+  if (connectionLimit != null) {
+    params.connectionLimit = connectionLimit;
+  }
+
+  const queueLimit = parseMySQLConnectionParam(searchParams.get('queueLimit'));
+  if (queueLimit != null) {
+    params.queueLimit = queueLimit;
+  }
+
+  return params;
+}

package/src/utils/mysql-utils.ts

@@ -37,6 +37,10 @@ export function createPool(config: types.NormalizedMySQLConnectionConfig, option
     cert: config.client_certificate
   };
   const hasSSLOptions = Object.values(sslOptions).some((v) => !!v);
+
+  // URL connection parameters provide defaults; explicit options take precedence
+  const params = config.connectionParams;
+
   // TODO: Use config.lookup for DNS resolution
   return mysql.createPool({
     host: config.hostname,
@@ -50,6 +54,10 @@ export function createPool(config: types.NormalizedMySQLConnectionConfig, option
     timezone: 'Z', // Ensure no auto timezone manipulation of the dates occur
     jsonStrings: true, // Return JSON columns as strings
     dateStrings: true, // We parse and format them ourselves
+    // Apply URL connection parameters (explicit options override these via spread below)
+    ...(params.connectTimeout != null ? { connectTimeout: params.connectTimeout } : {}),
+    ...(params.connectionLimit != null ? { connectionLimit: params.connectionLimit } : {}),
+    ...(params.queueLimit != null ? { queueLimit: params.queueLimit } : {}),
     ...(options || {})
   });
 }

package/test/src/BinLogStream.test.ts

@@ -18,7 +18,9 @@ describe('BinLogStream tests', () => {
   describeWithStorage({ timeout: 20_000 }, defineBinlogStreamTests);
 });
 
-function defineBinlogStreamTests(factory: storage.TestStorageFactory) {
+function defineBinlogStreamTests(config: storage.TestStorageConfig) {
+  const factory = config.factory;
+
   test('Replicate basic values', async () => {
     await using context = await BinlogStreamTestContext.open(factory);
     const { connectionManager } = context;

package/test/src/BinlogStreamUtils.ts

@@ -7,13 +7,15 @@ import {
   createCoreReplicationMetrics,
   initializeCoreReplicationMetrics,
   InternalOpId,
+  LEGACY_STORAGE_VERSION,
   OplogEntry,
   ProtocolOpId,
   ReplicationCheckpoint,
   storage,
-  SyncRulesBucketStorage
+  SyncRulesBucketStorage,
+  updateSyncRulesFromYaml
 } from '@powersync/service-core';
-import { METRICS_HELPER, test_utils } from '@powersync/service-core-tests';
+import { bucketRequest, METRICS_HELPER, test_utils } from '@powersync/service-core-tests';
 import mysqlPromise from 'mysql2/promise';
 import { clearTestDb, TEST_CONNECTION_OPTIONS } from './util.js';
 import timers from 'timers/promises';
@@ -31,6 +33,7 @@ export class BinlogStreamTestContext {
   private streamPromise?: Promise<void>;
   public storage?: SyncRulesBucketStorage;
   private replicationDone = false;
+  private syncRulesContent?: storage.PersistedSyncRulesContent;
 
   static async open(factory: storage.TestStorageFactory, options?: { doNotClear?: boolean }) {
     const f = await factory({ doNotClear: options?.doNotClear });
@@ -68,7 +71,10 @@ export class BinlogStreamTestContext {
   }
 
   async updateSyncRules(content: string): Promise<SyncRulesBucketStorage> {
-    const syncRules = await this.factory.updateSyncRules({ content: content, validate: true });
+    const syncRules = await this.factory.updateSyncRules(
+      updateSyncRulesFromYaml(content, { validate: true, storageVersion: LEGACY_STORAGE_VERSION })
+    );
+    this.syncRulesContent = syncRules;
     this.storage = this.factory.getInstance(syncRules);
     return this.storage!;
   }
@@ -79,6 +85,7 @@ export class BinlogStreamTestContext {
       throw new Error(`Next sync rules not available`);
     }
 
+    this.syncRulesContent = syncRules;
     this.storage = this.factory.getInstance(syncRules);
     return this.storage!;
   }
@@ -89,11 +96,19 @@ export class BinlogStreamTestContext {
       throw new Error(`Active sync rules not available`);
     }
 
+    this.syncRulesContent = syncRules;
     this.storage = this.factory.getInstance(syncRules);
     this.replicationDone = true;
     return this.storage!;
   }
 
+  private getSyncRulesContent(): storage.PersistedSyncRulesContent {
+    if (this.syncRulesContent == null) {
+      throw new Error('Sync rules not configured - call updateSyncRules() first');
+    }
+    return this.syncRulesContent;
+  }
+
   get binlogStream(): BinLogStream {
     if (this.storage == null) {
       throw new Error('updateSyncRules() first');
@@ -150,7 +165,8 @@ export class BinlogStreamTestContext {
 
   async getBucketsDataBatch(buckets: Record<string, InternalOpId>, options?: { timeout?: number }) {
     const checkpoint = await this.getCheckpoint(options);
-    const map = new Map<string, InternalOpId>(Object.entries(buckets));
+    const syncRules = this.getSyncRulesContent();
+    const map = Object.entries(buckets).map(([bucket, start]) => bucketRequest(syncRules, bucket, start));
     return test_utils.fromAsync(this.storage!.getBucketDataBatch(checkpoint, map));
   }
 
@@ -163,8 +179,9 @@ export class BinlogStreamTestContext {
     if (typeof start == 'string') {
       start = BigInt(start);
     }
+    const syncRules = this.getSyncRulesContent();
     const checkpoint = await this.getCheckpoint(options);
-    const map = new Map<string, InternalOpId>([[bucket, start]]);
+    const map = [bucketRequest(syncRules, bucket, start)];
     const batch = this.storage!.getBucketDataBatch(checkpoint, map);
     const batches = await test_utils.fromAsync(batch);
     return batches[0]?.chunkData.data ?? [];

package/test/src/config.test.ts

@@ -0,0 +1,165 @@
+import { describe, expect, test } from 'vitest';
+import {
+  normalizeConnectionConfig,
+  parseMySQLConnectionParam,
+  parseMySQLConnectionParams
+} from '@module/types/types.js';
+
+describe('config', () => {
+  test('Should resolve database', () => {
+    const normalized = normalizeConnectionConfig({
+      type: 'mysql',
+      uri: 'mysql://user:pass@localhost:3306/mydb'
+    });
+    expect(normalized.database).equals('mydb');
+  });
+
+  describe('connection parameters', () => {
+    test('parses all connection parameters from URL query string', () => {
+      const normalized = normalizeConnectionConfig({
+        type: 'mysql',
+        uri: 'mysql://user:pass@localhost:3306/mydb?connectTimeout=5000&connectionLimit=20&queueLimit=100'
+      });
+      expect(normalized.connectionParams.connectTimeout).equals(5000);
+      expect(normalized.connectionParams.connectionLimit).equals(20);
+      expect(normalized.connectionParams.queueLimit).equals(100);
+    });
+
+    test('URL without connection parameters returns empty connectionParams', () => {
+      const normalized = normalizeConnectionConfig({
+        type: 'mysql',
+        uri: 'mysql://user:pass@localhost:3306/mydb'
+      });
+      expect(normalized.connectionParams).toEqual({});
+    });
+
+    test('parameters can be partially specified', () => {
+      const normalized = normalizeConnectionConfig({
+        type: 'mysql',
+        uri: 'mysql://user:pass@localhost:3306/mydb?connectTimeout=5000&queueLimit=50'
+      });
+      expect(normalized.connectionParams.connectTimeout).equals(5000);
+      expect(normalized.connectionParams.queueLimit).equals(50);
+      expect(normalized.connectionParams.connectionLimit).toBeUndefined();
+    });
+
+    test('ignores invalid (non-numeric) connection parameter values', () => {
+      const normalized = normalizeConnectionConfig({
+        type: 'mysql',
+        uri: 'mysql://user:pass@localhost:3306/mydb?connectTimeout=abc&connectionLimit=xyz'
+      });
+      expect(normalized.connectionParams.connectTimeout).toBeUndefined();
+      expect(normalized.connectionParams.connectionLimit).toBeUndefined();
+    });
+
+    test('ignores negative connection parameter values', () => {
+      const normalized = normalizeConnectionConfig({
+        type: 'mysql',
+        uri: 'mysql://user:pass@localhost:3306/mydb?connectTimeout=-5000&connectionLimit=-10'
+      });
+      expect(normalized.connectionParams.connectTimeout).toBeUndefined();
+      expect(normalized.connectionParams.connectionLimit).toBeUndefined();
+    });
+
+    test('ignores zero connection parameter values', () => {
+      const normalized = normalizeConnectionConfig({
+        type: 'mysql',
+        uri: 'mysql://user:pass@localhost:3306/mydb?connectTimeout=0&connectionLimit=0&queueLimit=0'
+      });
+      expect(normalized.connectionParams.connectTimeout).toBeUndefined();
+      expect(normalized.connectionParams.connectionLimit).toBeUndefined();
+      expect(normalized.connectionParams.queueLimit).toBeUndefined();
+    });
+
+    test('works without URI (config-only)', () => {
+      const normalized = normalizeConnectionConfig({
+        type: 'mysql',
+        hostname: 'localhost',
+        port: 3306,
+        database: 'mydb',
+        username: 'user',
+        password: 'pass'
+      });
+      expect(normalized.connectionParams).toEqual({});
+    });
+  });
+});
+
+describe('parseMySQLConnectionParam', () => {
+  test('returns undefined when no value provided', () => {
+    expect(parseMySQLConnectionParam(undefined)).toBeUndefined();
+    expect(parseMySQLConnectionParam(null)).toBeUndefined();
+  });
+
+  test('parses valid numeric string', () => {
+    expect(parseMySQLConnectionParam('5000')).equals(5000);
+  });
+
+  test('parses fractional values', () => {
+    expect(parseMySQLConnectionParam('1500.5')).equals(1500.5);
+  });
+
+  test('ignores non-numeric string', () => {
+    expect(parseMySQLConnectionParam('abc')).toBeUndefined();
+  });
+
+  test('ignores empty string', () => {
+    expect(parseMySQLConnectionParam('')).toBeUndefined();
+  });
+
+  test('ignores negative value', () => {
+    expect(parseMySQLConnectionParam('-5000')).toBeUndefined();
+  });
+
+  test('ignores zero', () => {
+    expect(parseMySQLConnectionParam('0')).toBeUndefined();
+  });
+
+  test('ignores Infinity', () => {
+    expect(parseMySQLConnectionParam('Infinity')).toBeUndefined();
+  });
+
+  test('ignores NaN', () => {
+    expect(parseMySQLConnectionParam('NaN')).toBeUndefined();
+  });
+});
+
+describe('parseMySQLConnectionParams', () => {
+  test('parses all supported parameters', () => {
+    const params = new URLSearchParams('connectTimeout=5000&connectionLimit=20&queueLimit=100');
+    const result = parseMySQLConnectionParams(params);
+    expect(result).toEqual({
+      connectTimeout: 5000,
+      connectionLimit: 20,
+      queueLimit: 100
+    });
+  });
+
+  test('returns empty object when no connection params present', () => {
+    const params = new URLSearchParams('someOther=value');
+    const result = parseMySQLConnectionParams(params);
+    expect(result).toEqual({});
+  });
+
+  test('returns empty object for undefined searchParams', () => {
+    const result = parseMySQLConnectionParams(undefined);
+    expect(result).toEqual({});
+  });
+
+  test('ignores invalid values and only includes valid ones', () => {
+    const params = new URLSearchParams('connectTimeout=5000&connectionLimit=abc&queueLimit=-10');
+    const result = parseMySQLConnectionParams(params);
+    expect(result).toEqual({
+      connectTimeout: 5000
+    });
+  });
+
+  test('handles partial parameter specification', () => {
+    const params = new URLSearchParams('connectTimeout=5000&queueLimit=100');
+    const result = parseMySQLConnectionParams(params);
+    expect(result).toEqual({
+      connectTimeout: 5000,
+      queueLimit: 100
+    });
+  });
+});

package/test/src/schema-changes.test.ts

@@ -26,7 +26,8 @@ const PUT_T3 = test_utils.putOp('test_data', { id: 't3', description: 'test3' })
 const REMOVE_T1 = test_utils.removeOp('test_data', 't1');
 const REMOVE_T2 = test_utils.removeOp('test_data', 't2');
 
-function defineTests(factory: storage.TestStorageFactory) {
+function defineTests(config: storage.TestStorageConfig) {
+  const factory = config.factory;
   let isMySQL57: boolean = false;
 
   beforeAll(async () => {

package/test/src/util.ts

@@ -1,16 +1,16 @@
+import * as common from '@module/common/common-index.js';
+import { MySQLConnectionManager } from '@module/replication/MySQLConnectionManager.js';
+import { BinLogEventHandler, BinLogListener, Row, SchemaChange } from '@module/replication/zongji/BinLogListener.js';
 import * as types from '@module/types/types.js';
 import { createRandomServerId, getMySQLVersion, isVersionAtLeast } from '@module/utils/mysql-utils.js';
+import { TableMapEntry } from '@powersync/mysql-zongji';
+import { TestStorageConfig } from '@powersync/service-core';
 import * as mongo_storage from '@powersync/service-module-mongodb-storage';
 import * as postgres_storage from '@powersync/service-module-postgres-storage';
+import { TablePattern } from '@powersync/service-sync-rules';
 import mysqlPromise from 'mysql2/promise';
-import { env } from './env.js';
 import { describe, TestOptions } from 'vitest';
-import { TestStorageFactory } from '@powersync/service-core';
-import { MySQLConnectionManager } from '@module/replication/MySQLConnectionManager.js';
-import { BinLogEventHandler, BinLogListener, Row, SchemaChange } from '@module/replication/zongji/BinLogListener.js';
-import { TableMapEntry } from '@powersync/mysql-zongji';
-import * as common from '@module/common/common-index.js';
-import { TablePattern } from '@powersync/service-sync-rules';
+import { env } from './env.js';
 
 export const TEST_URI = env.MYSQL_TEST_URI;
 
@@ -24,11 +24,11 @@ export const INITIALIZED_MONGO_STORAGE_FACTORY = mongo_storage.test_utils.mongoT
   isCI: env.CI
 });
 
-export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.postgresTestStorageFactoryGenerator({
+export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.postgresTestSetup({
   url: env.PG_STORAGE_TEST_URL
 });
 
-export function describeWithStorage(options: TestOptions, fn: (factory: TestStorageFactory) => void) {
+export function describeWithStorage(options: TestOptions, fn: (factory: TestStorageConfig) => void) {
   describe.skipIf(!env.TEST_MONGO_STORAGE)(`mongodb storage`, options, function () {
     fn(INITIALIZED_MONGO_STORAGE_FACTORY);
   });