fix(types): resolve wrong connection options

Author: naorpeled

index.d.ts

@@ -1,116 +1,118 @@
 // Type definitions for serverless-mysql
 
-import * as MySQL from 'mysql2'
+import * as MySQL from "mysql2";
 
 // https://github.com/microsoft/TypeScript/issues/8335#issuecomment-215194561
 declare namespace serverlessMysql {
   export type Config = {
     /**
      * Function mysql library
      */
-    library?: Function
+    library?: Function;
 
     /**
      * Function promise library
      */
-    promise?: Function
+    promise?: Function;
 
     /**
      * String or Function  Backoff algorithm to be used when retrying connections. Possible values are full and decorrelated, or you can also specify your own algorithm. See Connection Backoff for more information.  full
      */
-    backoff?: string | Function
+    backoff?: string | Function;
     /**
      * Integer  Number of milliseconds added to random backoff values.  2
      */
-    base?: number
+    base?: number;
     /**
      * Integer  Maximum number of milliseconds between connection retries.  100
      */
-    cap?: number
+    cap?: number;
     /**
-     * Object  A mysql configuration object as defined here  {}
+     * Object  A mysql configuration object as defined here or a connection string  {}
      */
-    config?: MySQL.ConnectionConfig
+    config?: MySQL.ConnectionOptions | string;
     /**
      * Number  The percentage of total connections to use when connecting to your MySQL server. A value of 0.75 would use 75% of your total available connections.  0.8
      */
-    connUtilization?: number
+    connUtilization?: number;
     /**
      * Boolean  Flag indicating whether or not you want serverless-mysql to manage MySQL connections for you.  true
      */
-    manageConns?: boolean
+    manageConns?: boolean;
     /**
      * Integer  The number of milliseconds to cache lookups of @@max_connections.  15000
      */
-    maxConnsFreq?: number
+    maxConnsFreq?: number;
     /**
      * Integer  Maximum number of times to retry a connection before throwing an error.  50
      */
-    maxRetries?: number
+    maxRetries?: number;
     /**
      * function  Event callback when the MySQL connection fires an error.
      */
-    onError?: Function
+    onError?: Function;
     /**
      * function  Event callback when MySQL connections are explicitly closed.
      */
-    onClose?: Function
+    onClose?: Function;
     /**
      * function  Event callback when connections are succesfully established.
      */
-    onConnect?: Function
+    onConnect?: Function;
     /**
      * function  Event callback when connection fails.
      */
-    onConnectError?: Function
+    onConnectError?: Function;
     /**
      * function  Event callback when connections are explicitly killed.
      */
-    onKill?: Function
+    onKill?: Function;
     /**
      * function  Event callback when a connection cannot be killed.
      */
-    onKillError?: Function
+    onKillError?: Function;
     /**
      * function  Event callback when connections are retried.
      */
-    onRetry?: Function
+    onRetry?: Function;
     /**
      * Integer  The number of milliseconds to cache lookups of current connection usage.  0
      */
-    usedConnsFreq?: number
+    usedConnsFreq?: number;
     /**
      * Integer  The maximum number of seconds that a connection can stay idle before being recycled.  900
      */
-    zombieMaxTimeout?: number
+    zombieMaxTimeout?: number;
     /**
      * Integer  The minimum number of seconds that a connection must be idle before the module will recycle it.  3
      */
-    zombieMinTimeout?: number
-  }
+    zombieMinTimeout?: number;
+  };
 
   class Transaction {
-    query(...args: any[]): this
-    rollback(fn: Function): this
-    commit<T = any>(): Promise<T[]>
+    query(...args: any[]): this;
+    rollback(fn: Function): this;
+    commit<T = any>(): Promise<T[]>;
   }
 
   export type ServerlessMysql = {
-    connect(wait?: number): Promise<void>
-    config(config?: string | MySQL.ConnectionConfig): MySQL.ConnectionConfig
-    query<T>(...args: any[]): Promise<T>
-    end(): Promise<void>
-    escape: typeof MySQL.escape
-    escapeId: typeof MySQL.escapeId
-    format: typeof MySQL.format
-    quit(): void
-    transaction(): Transaction
-    getCounter(): number
-    getClient(): MySQL.Connection
-    getConfig(): MySQL.ConnectionConfig
-    getErrorCount(): number
-  }
+    connect(wait?: number): Promise<void>;
+    config(config?: string | MySQL.ConnectionOptions): MySQL.ConnectionOptions;
+    query<T>(...args: any[]): Promise<T>;
+    end(): Promise<void>;
+    escape: typeof MySQL.escape;
+    escapeId: typeof MySQL.escapeId;
+    format: typeof MySQL.format;
+    quit(): void;
+    transaction(): Transaction;
+    getCounter(): number;
+    getClient(): MySQL.Connection;
+    getConfig(): MySQL.ConnectionOptions;
+    getErrorCount(): number;
+  };
 }
 
-declare function serverlessMysql (cfg?: string | serverlessMysql.Config): serverlessMysql.ServerlessMysql
-export = serverlessMysql
+declare function serverlessMysql(
+  cfg?: string | serverlessMysql.Config
+): serverlessMysql.ServerlessMysql;
+export = serverlessMysql;

index.js

@@ -411,7 +411,10 @@ module.exports = (params) => {
 
   let connCfg = {}
 
-  if (typeof cfg.config === 'object' && !Array.isArray(cfg.config)) {
+  const isConfigAnObject = typeof cfg.config === 'object' && !Array.isArray(cfg.config)
+  const isConfigAString = typeof cfg.config === 'string'
+
+  if (isConfigAnObject || isConfigAString) {
     connCfg = cfg.config
   } else if (typeof params === 'string') {
     connCfg = params

test/integration/connection-string.spec.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const { expect } = require('chai');
+const mysql = require('../../index');
+const { closeConnection, createTestConnection, createTestConnectionString } = require('./helpers/setup');
+
+describe('Connection String Integration Tests', function () {
+    this.timeout(10000);
+
+    let db;
+
+    afterEach(async function () {
+        try {
+            if (db) {
+                await db.end({ timeout: 5000 });
+                await closeConnection(db);
+                db = null;
+            }
+        } catch (err) {
+            console.error('Error closing connection:', err);
+        }
+    });
+
+    it('should connect using a valid connection string', async function () {
+        const connectionString = createTestConnectionString();
+        db = createTestConnection(connectionString);
+
+        try {
+            const result = await db.query('SELECT 1 AS value');
+            expect(result).to.be.an('array');
+            expect(result).to.have.lengthOf(1);
+            expect(result[0]).to.have.property('value', 1);
+        } catch (error) {
+            console.error('Connection error:', error);
+            throw error;
+        }
+    });
+
+    it('should connect using a connection string with additional parameters', async function () {
+        const connectionString = createTestConnectionString({
+            connectTimeout: 10000,
+            dateStrings: 'true'
+        });
+
+        db = createTestConnection(connectionString);
+
+        try {
+            const result = await db.query('SELECT 1 AS value');
+            expect(result).to.be.an('array');
+            expect(result).to.have.lengthOf(1);
+            expect(result[0]).to.have.property('value', 1);
+        } catch (error) {
+            console.error('Connection error:', error);
+            throw error;
+        }
+    });
+
+    it('should connect using a connection string as part of sls-mysql.config property', async function () {
+        const connectionString = createTestConnectionString();
+        db = mysql({
+            config: connectionString
+        })
+
+        try {
+            const result = await db.query('SELECT 1 AS value');
+            expect(result).to.be.an('array');
+            expect(result).to.have.lengthOf(1);
+            expect(result[0]).to.have.property('value', 1);
+        } catch (error) {
+            console.error('Connection error:', error);
+            throw error;
+        }
+    });
+}); 

test/integration/helpers/setup.js

@@ -4,10 +4,14 @@ const mysql = require('../../../index');
 
 /**
  * Creates a MySQL connection for testing
- * @param {Object} options - Additional options for the MySQL connection
+ * @param {Object|string} options - Additional options for the MySQL connection or a connection string
  * @returns {Object} The MySQL connection object
  */
 function createTestConnection(options = {}) {
+    if (typeof options === 'string') {
+        return mysql(options);
+    }
+
     const config = {
         host: process.env.MYSQL_HOST || '127.0.0.1',
         database: process.env.MYSQL_DATABASE || 'serverless_mysql_test',
@@ -22,6 +26,30 @@ function createTestConnection(options = {}) {
     });
 }
 
+/**
+ * Creates a connection string from environment variables or defaults
+ * @param {Object} additionalParams - Additional URL parameters to include
+ * @returns {string} The connection string
+ */
+function createTestConnectionString(additionalParams = {}) {
+    const host = process.env.MYSQL_HOST || '127.0.0.1';
+    const database = process.env.MYSQL_DATABASE || 'serverless_mysql_test';
+    const user = process.env.MYSQL_USER || 'root';
+    const password = process.env.MYSQL_PASSWORD || 'password';
+    const port = process.env.MYSQL_PORT || 3306;
+
+    let connectionString = `mysql://${user}:${password}@${host}:${port}/${database}`;
+
+    if (Object.keys(additionalParams).length > 0) {
+        connectionString += '?';
+        connectionString += Object.entries(additionalParams)
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+    }
+
+    return connectionString;
+}
+
 /**
  * Sets up a test table
  * @param {Object} db - The MySQL connection
@@ -106,6 +134,7 @@ async function closeConnection(db) {
 
 module.exports = {
     createTestConnection,
+    createTestConnectionString,
     setupTestTable,
     cleanupTestTable,
     closeConnection

test/unit/connection-config.spec.js

@@ -1,5 +1,4 @@
 const assert = require("assert");
-
 const mysql = require("../../index");
 
 describe("Test a connection config", () => {
@@ -43,7 +42,7 @@ describe("Test a connection config", () => {
         database: "database",
         user: "user",
         password: "password",
-        port: "3306",
+        port: 3306,
       });
     });
   });
@@ -52,4 +51,37 @@ describe("Test a connection config", () => {
     assert.throws(() => mysql("mysql://:3306/database").getConfig());
     assert.throws(() => mysql("mysql://:3306").getConfig());
   });
+
+  it("Should throw an error with an invalid connection string format", () => {
+    assert.throws(() => {
+      mysql("invalid-connection-string");
+    }, /Invalid data source URL provided/);
+  });
+
+  it("Should throw an error with a malformed connection string", () => {
+    assert.throws(() => {
+      mysql("mysql://user:password@");
+    }, /Invalid data source URL provided/);
+  });
+
+  it("Should handle connection string with missing credentials gracefully", () => {
+    const db = mysql("mysql://localhost:3306/");
+    const config = db.getConfig();
+
+    assert.strictEqual(config.host, "localhost");
+    assert.strictEqual(config.port, 3306);
+  });
+
+  it("Should parse additional parameters from connection string", () => {
+    const db = mysql("mysql://user:password@localhost:3306/database?connectTimeout=10000&dateStrings=true");
+    const config = db.getConfig();
+
+    assert.strictEqual(config.host, "localhost");
+    assert.strictEqual(config.database, "database");
+    assert.strictEqual(config.user, "user");
+    assert.strictEqual(config.password, "password");
+    assert.strictEqual(config.port, 3306);
+    assert.strictEqual(config.connectTimeout, "10000");
+    assert.strictEqual(config.dateStrings, "true");
+  });
 });