serverless-simple-middleware 0.0.73 → 0.0.74

package/dist/middleware/base.d.ts

@@ -9,12 +9,16 @@ export declare class HandlerRequest {
     private lazyBody?;
     constructor(event: any, context: any);
     get body(): any;
+    set body(value: any);
     get path(): {
         [key: string]: string | undefined;
     };
     get query(): {
         [key: string]: string | undefined;
     };
+    set query(value: {
+        [key: string]: any;
+    });
     header(key: string): string | undefined;
     records<T, U>(selector?: (each: T) => U): T[] | U[];
 }

package/dist/middleware/base.js

@@ -29,12 +29,18 @@ class HandlerRequest {
         }
         return this.lazyBody || {};
     }
+    set body(value) {
+        this.lazyBody = value;
+    }
     get path() {
         return this.event.pathParameters || {};
     }
     get query() {
         return this.event.queryStringParameters || {};
     }
+    set query(value) {
+        this.event.queryStringParameters = value;
+    }
     header(key) {
         return this.event.headers[key.toLowerCase()];
     }

package/dist/middleware/build.d.ts

@@ -1,3 +1,31 @@
-import { Handler, HandlerAuxBase, HandlerPluginBase } from './base';
-declare const build: <Aux extends HandlerAuxBase>(plugins: Array<HandlerPluginBase<any>>) => (handler: Handler<Aux>) => (event: any, context: any, callback: any) => void;
+import { type ZodError, type ZodSchema } from 'zod';
+import { Handler, HandlerAuxBase, HandlerPluginBase, HandlerRequest, HandlerResponse } from './base';
+declare const build: <Aux extends HandlerAuxBase>(plugins: Array<HandlerPluginBase<any>>) => ((handler: Handler<Aux>) => (event: any, context: any, callback: any) => void) & {
+    withBody: <S>(schema: ZodSchema<S>, handler: (context: {
+        request: Omit<HandlerRequest, "body"> & {
+            body: S;
+        };
+        response: HandlerResponse;
+        aux: Aux;
+    }) => any, onInvalid?: (error: ZodError) => {
+        statusCode: number;
+        body: any;
+    } | Promise<{
+        statusCode: number;
+        body: any;
+    } | void> | void) => (event: any, context: any, callback: any) => void;
+    withQuery: <Q>(schema: ZodSchema<Q>, handler: (context: {
+        request: Omit<HandlerRequest, "query"> & {
+            query: Q;
+        };
+        response: HandlerResponse;
+        aux: Aux;
+    }) => any, onInvalid?: (error: ZodError<Q>) => {
+        statusCode: number;
+        body: any;
+    } | Promise<{
+        statusCode: number;
+        body: any;
+    } | void> | void) => (event: any, context: any, callback: any) => void;
+};
 export default build;

package/dist/middleware/build.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = require("../utils/logger");
+const zod_1 = require("zod");
 const utils_1 = require("../utils");
 const base_1 = require("./base");
 const logger = (0, logger_1.getLogger)(__filename);
@@ -107,8 +108,66 @@ class HandlerProxy {
 // It will break type safety because there is no relation between Aux and Plugin.
 const build = (plugins) => {
     const middleware = new HandlerMiddleware(plugins);
-    return (handler) => (event, context, callback) => {
+    const invoke = (handler) => (event, context, callback) => {
         new HandlerProxy(event, context, callback).call(middleware, handler);
     };
+    /**
+     * @param schema - Zod schema to validate the request body.
+     * @param handler - Handler that receives the validated body.
+     * @param onInvalid - Optional callback to customize invalid responses. If it
+     *   returns `{ statusCode, body }`, that is sent instead of the default zod
+     *   error payload.
+     */
+    const withBody = (schema, handler, onInvalid) => invoke(async ({ request, response, aux }) => {
+        const parsed = schema.safeParse(request.body);
+        if (!parsed.success) {
+            logger.error(`Validation failed: ${(0, utils_1.stringifyError)((0, zod_1.treeifyError)(parsed.error))}`);
+            if (onInvalid) {
+                const result = await onInvalid(parsed.error);
+                if (result) {
+                    return response.fail(result.body, result.statusCode);
+                }
+            }
+            return response.fail((0, zod_1.treeifyError)(parsed.error), 400);
+        }
+        const typedRequest = request;
+        typedRequest.body = parsed.data;
+        return handler({
+            request: typedRequest,
+            response,
+            aux,
+        });
+    });
+    /**
+     * @param schema - Zod schema to validate the request query.
+     * @param handler - Handler that receives the validated query.
+     * @param onInvalid - Optional callback to customize invalid responses. If it
+     *   returns `{ statusCode, body }`, that is sent instead of the default zod
+     *   error payload.
+     */
+    const withQuery = (schema, handler, onInvalid) => invoke(async ({ request, response, aux }) => {
+        const parsed = schema.safeParse(request.query);
+        if (!parsed.success) {
+            logger.error(`Validation failed: ${(0, utils_1.stringifyError)((0, zod_1.treeifyError)(parsed.error))}`);
+            if (onInvalid) {
+                const result = await onInvalid(parsed.error);
+                if (result) {
+                    return response.fail(result.body, result.statusCode);
+                }
+            }
+            return response.fail((0, zod_1.treeifyError)(parsed.error), 400);
+        }
+        const typedRequest = request;
+        typedRequest.query = parsed.data;
+        return handler({
+            request: typedRequest,
+            response,
+            aux,
+        });
+    });
+    return Object.assign(invoke, {
+        withBody,
+        withQuery,
+    });
 };
 exports.default = build;

package/dist/middleware/database/connectionProxy.d.ts

@@ -8,6 +8,7 @@ export declare class ConnectionProxy {
     private connectionInitOnce;
     private initialized;
     private dbName?;
+    private readonly MAX_RETRIES;
     constructor(options: MySQLPluginOptions);
     query: <T>(sql: string, params?: any[]) => Promise<T | undefined>;
     fetch: <T>(sql: string, params?: any[]) => Promise<T[]>;
@@ -23,6 +24,7 @@ export declare class ConnectionProxy {
     destroyConnection: () => void;
     onPluginCreated: () => Promise<void>;
     private prepareConnection;
+    private createConnection;
     private ensureConnectionConfig;
     private changeDatabase;
     private tryToInitializeSchema;

package/dist/middleware/database/connectionProxy.js

@@ -15,6 +15,7 @@ class ConnectionProxy {
     connectionInitOnce = new oncePromise_1.OncePromise();
     initialized;
     dbName;
+    MAX_RETRIES = 1;
     constructor(options) {
         this.options = options;
         if (options.schema && options.schema.database) {
@@ -22,10 +23,11 @@ class ConnectionProxy {
             options.config.database = undefined;
         }
         this.secretsCache = secretsManager_1.SecretsManagerCache.getInstance();
+        if (options.secretsManagerConfig) {
+            this.secretsCache.configure(options.secretsManagerConfig);
+        }
     }
-    query = (sql, params) => new Promise(async (resolve, reject) => {
-        const connection = await this.prepareConnection();
-        await this.tryToInitializeSchema(false);
+    query = (sql, params) => this.prepareConnection().then((connection) => this.tryToInitializeSchema(false).then(() => new Promise((resolve, reject) => {
         if (process.env.NODE_ENV !== 'test') {
             logger.silly(`Execute query[${sql}] with params[${params}]`);
         }
@@ -41,7 +43,7 @@ class ConnectionProxy {
                 }
             }
         });
-    });
+    })));
     fetch = (sql, params) => this.query(sql, params).then((res) => res || []);
     fetchOne = (sql, params, defaultValue) => this.fetch(sql, params).then((res) => {
         if (res === undefined || res[0] === undefined) {
@@ -50,9 +52,7 @@ class ConnectionProxy {
         }
         return res[0];
     });
-    beginTransaction = () => new Promise(async (resolve, reject) => {
-        const connection = await this.prepareConnection();
-        await this.tryToInitializeSchema(false);
+    beginTransaction = () => this.prepareConnection().then((connection) => this.tryToInitializeSchema(false).then(() => new Promise((resolve, reject) => {
         connection.beginTransaction((err) => {
             if (err) {
                 reject(err);
@@ -60,10 +60,8 @@ class ConnectionProxy {
             }
             resolve();
         });
-    });
-    commit = () => new Promise(async (resolve, reject) => {
-        const connection = await this.prepareConnection();
-        await this.tryToInitializeSchema(false);
+    })));
+    commit = () => this.prepareConnection().then((connection) => this.tryToInitializeSchema(false).then(() => new Promise((resolve, reject) => {
         connection.commit((err) => {
             if (err) {
                 reject(err);
@@ -71,10 +69,8 @@ class ConnectionProxy {
             }
             resolve();
         });
-    });
-    rollback = () => new Promise(async (resolve, reject) => {
-        const connection = await this.prepareConnection();
-        await this.tryToInitializeSchema(false);
+    })));
+    rollback = () => this.prepareConnection().then((connection) => this.tryToInitializeSchema(false).then(() => new Promise((resolve, reject) => {
         connection.rollback((err) => {
             if (err) {
                 reject(err);
@@ -82,7 +78,7 @@ class ConnectionProxy {
             }
             resolve();
         });
-    });
+    })));
     clearConnection = () => {
         const conn = this.connection;
         this.connection = undefined;
@@ -120,12 +116,40 @@ class ConnectionProxy {
         }
         return await this.connectionInitOnce.run(async () => {
             await this.ensureConnectionConfig();
-            const conn = (0, mysql2_1.createConnection)(this.connectionConfig);
-            conn.connect();
-            this.connection = conn;
+            this.connection = await this.createConnection(this.MAX_RETRIES);
             return this.connection;
         });
     };
+    createConnection = async (remainingRetries) => {
+        const conn = (0, mysql2_1.createConnection)(this.connectionConfig);
+        return new Promise((resolve, reject) => {
+            conn.on('error', (err) => {
+                logger.error(`Connection error event: ${err.message}`);
+            });
+            conn.connect((err) => {
+                if (err) {
+                    logger.error(`Failed to connect to database: ${err.message}`);
+                    conn.destroy();
+                    if (remainingRetries > 0) {
+                        logger.warn(`Retrying database connection... (${remainingRetries} attempt(s) remaining)`);
+                        setTimeout(() => {
+                            this.createConnection(remainingRetries - 1)
+                                .then(resolve)
+                                .catch(reject);
+                        }, 100);
+                    }
+                    else {
+                        logger.error('Database connection failed after all retries. Giving up.');
+                        reject(err);
+                    }
+                }
+                else {
+                    logger.verbose('Database connection established successfully.');
+                    resolve(conn);
+                }
+            });
+        });
+    };
     ensureConnectionConfig = async () => {
         if (this.connectionConfig) {
             return;

package/dist/middleware/database/sqlClient.js

@@ -14,9 +14,13 @@ class LazyConnectionPool {
     secretsCache;
     configInitOnce = new oncePromise_1.OncePromise();
     connectionInitOnce = new oncePromise_1.OncePromise();
+    MAX_RETRIES = 1;
     constructor(options) {
         this.options = options;
         this.secretsCache = secretsManager_1.SecretsManagerCache.getInstance();
+        if (options.secretsManagerConfig) {
+            this.secretsCache.configure(options.secretsManagerConfig);
+        }
     }
     ensureConnectionConfig = async () => {
         if (this.connectionConfig) {
@@ -44,21 +48,42 @@ class LazyConnectionPool {
         this.connectionInitOnce
             .run(async () => {
             await this.ensureConnectionConfig();
-            const conn = (0, mysql2_1.createConnection)(this.connectionConfig);
-            return await new Promise((resolve, reject) => {
-                conn.connect((err) => {
-                    if (err) {
+            return await this.createConnection(this.MAX_RETRIES);
+        })
+            .then((conn) => callback(null, conn))
+            .catch((err) => callback(err, {}));
+    };
+    createConnection = async (remainingRetries) => {
+        const conn = (0, mysql2_1.createConnection)(this.connectionConfig);
+        return new Promise((resolve, reject) => {
+            conn.on('error', (err) => {
+                logger.error(`Database connection error occurred: ${err.message}`);
+            });
+            conn.connect((err) => {
+                if (err) {
+                    logger.error(`Failed to connect to database: ${err.message}`);
+                    conn.destroy();
+                    if (remainingRetries > 0) {
+                        logger.warn(`Retrying database connection... (${remainingRetries} attempt(s) remaining)`);
+                        setTimeout(() => {
+                            this.createConnection(remainingRetries - 1)
+                                .then(resolve)
+                                .catch(reject);
+                        }, 100);
+                    }
+                    else {
+                        logger.error('Database connection failed after all retries. Giving up.');
                         reject(err);
-                        return;
                     }
+                }
+                else {
+                    logger.verbose('Database connection established successfully.');
                     const wrapped = this._addRelease(conn);
                     this.connection = wrapped;
                     resolve(wrapped);
-                });
+                }
             });
-        })
-            .then((conn) => callback(null, conn))
-            .catch((err) => callback(err, {}));
+        });
     };
     end = (callback) => {
         const conn = this.connection;

package/dist/middleware/index.d.ts

@@ -1,5 +1,32 @@
 export declare const middleware: {
-    build: <Aux extends import("./base").HandlerAuxBase>(plugins: Array<import("./base").HandlerPluginBase<any>>) => (handler: import("./base").Handler<Aux>) => (event: any, context: any, callback: any) => void;
+    build: <Aux extends import("./base").HandlerAuxBase>(plugins: Array<import("./base").HandlerPluginBase<any>>) => ((handler: import("./base").Handler<Aux>) => (event: any, context: any, callback: any) => void) & {
+        withBody: <S>(schema: import("zod").ZodType<S>, handler: (context: {
+            request: Omit<import("./base").HandlerRequest, "body"> & {
+                body: S;
+            };
+            response: import("./base").HandlerResponse;
+            aux: Aux;
+        }) => any, onInvalid?: (error: import("zod").ZodError) => {
+            statusCode: number;
+            body: any;
+        } | Promise<{
+            statusCode: number;
+            body: any;
+        } | void> | void) => (event: any, context: any, callback: any) => void;
+        withQuery: <Q>(schema: import("zod").ZodType<Q>, handler: (context: {
+            request: Omit<import("./base").HandlerRequest, "query"> & {
+                query: Q;
+            };
+            response: import("./base").HandlerResponse;
+            aux: Aux;
+        }) => any, onInvalid?: (error: import("zod").ZodError<Q>) => {
+            statusCode: number;
+            body: any;
+        } | Promise<{
+            statusCode: number;
+            body: any;
+        } | void> | void) => (event: any, context: any, callback: any) => void;
+    };
     aws: (options?: import("./aws").AWSPluginOptions) => import("./aws").AWSPlugin;
     trace: (options: import("./trace").TracerPluginOptions) => import("./trace").TracerPlugin;
     logger: (options: import("./logger").LoggerPluginOptions) => import("./logger").LoggerPlugin;

package/dist/middleware/mysql.d.ts

@@ -1,3 +1,4 @@
+import type { SecretsManagerClientConfig } from '@aws-sdk/client-secrets-manager';
 import type { ConnectionOptions, PoolOptions } from 'mysql2';
 import { HandlerAuxBase, HandlerPluginBase } from './base';
 import { ConnectionProxy } from './database/connectionProxy';
@@ -12,6 +13,7 @@ export interface MySQLPluginOptions {
      * AWS Secrets Manager secret ID containing {@link DatabaseCredentials}
      */
     secretId?: string;
+    secretsManagerConfig?: SecretsManagerClientConfig;
     schema?: {
         eager?: boolean;
         ignoreError?: boolean;

package/dist/utils/secretsManager.d.ts

@@ -1,10 +1,13 @@
+import { SecretsManagerClientConfig } from '@aws-sdk/client-secrets-manager';
 import type { DatabaseCredentials } from '../middleware/mysql';
 export declare class SecretsManagerCache {
     private static instance;
     private client;
+    private clientConfig;
     private cache;
     private constructor();
     static getInstance(): SecretsManagerCache;
+    configure(config: SecretsManagerClientConfig): void;
     private getClient;
     getSecret<T = any>(secretId: string): Promise<T>;
     getDatabaseCredentials(secretId: string): Promise<DatabaseCredentials>;

package/dist/utils/secretsManager.js

@@ -8,6 +8,7 @@ const logger = (0, logger_1.getLogger)(__filename);
 class SecretsManagerCache {
     static instance;
     client;
+    clientConfig;
     cache = new Map();
     constructor() { }
     static getInstance() {
@@ -16,9 +17,17 @@ class SecretsManagerCache {
         }
         return SecretsManagerCache.instance;
     }
+    configure(config) {
+        if (this.client) {
+            logger.warn('SecretsManager client already initialized. Reconfiguring with new config.');
+            this.client = undefined;
+        }
+        this.clientConfig = config;
+        logger.debug('SecretsManager client config updated');
+    }
     getClient() {
         if (!this.client) {
-            this.client = new client_secrets_manager_1.SecretsManagerClient({});
+            this.client = new client_secrets_manager_1.SecretsManagerClient(this.clientConfig ?? {});
             logger.debug('SecretsManager client initialized');
         }
         return this.client;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "serverless-simple-middleware",
   "description": "Simple middleware to translate the interface of lambda's handler to request => response",
-  "version": "0.0.73",
+  "version": "0.0.74",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "VoyagerX",
@@ -45,7 +45,8 @@
     "nanoid": "4.0.2",
     "simple-staging": "^0.0.12",
     "ts-enum-util": "^3.1.0",
-    "uuid": "^3.3.2"
+    "uuid": "^3.3.2",
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@types/jest": "^23.3.1",

package/src/middleware/base.ts

@@ -40,6 +40,10 @@ export class HandlerRequest {
     return this.lazyBody || {};
   }
 
+  set body(value: any) {
+    this.lazyBody = value;
+  }
+
   get path(): { [key: string]: string | undefined } {
     return this.event.pathParameters || {};
   }
@@ -48,6 +52,10 @@ export class HandlerRequest {
     return this.event.queryStringParameters || {};
   }
 
+  set query(value: { [key: string]: any }) {
+    this.event.queryStringParameters = value;
+  }
+
   public header(key: string): string | undefined {
     return this.event.headers[key.toLowerCase()];
   }
@@ -93,7 +101,7 @@ export class HandlerResponse {
     if (this.crossOrigin) {
       headers['Access-Control-Allow-Origin'] = this.crossOrigin;
     }
-    let multiValueHeaders = undefined;
+    let multiValueHeaders: any = undefined;
     if (this.cookies.length > 0) {
       multiValueHeaders = { 'Set-Cookie': this.cookies };
     }

package/src/middleware/build.ts

@@ -1,5 +1,6 @@
 import { getLogger } from '../utils/logger';
 
+import { treeifyError, type ZodError, type ZodSchema } from 'zod';
 import { stringifyError } from '../utils';
 import {
   Handler,
@@ -165,9 +166,108 @@ const build = <Aux extends HandlerAuxBase>(
   plugins: Array<HandlerPluginBase<any>>,
 ) => {
   const middleware = new HandlerMiddleware<Aux>(plugins);
-  return (handler: Handler<Aux>) =>
-    (event: any, context: any, callback: any) => {
+  const invoke =
+    (handler: Handler<Aux>) => (event: any, context: any, callback: any) => {
       new HandlerProxy<Aux>(event, context, callback).call(middleware, handler);
     };
+
+  /**
+   * @param schema - Zod schema to validate the request body.
+   * @param handler - Handler that receives the validated body.
+   * @param onInvalid - Optional callback to customize invalid responses. If it
+   *   returns `{ statusCode, body }`, that is sent instead of the default zod
+   *   error payload.
+   */
+  const withBody = <S>(
+    schema: ZodSchema<S>,
+    handler: (context: {
+      request: Omit<HandlerRequest, 'body'> & { body: S };
+      response: HandlerResponse;
+      aux: Aux;
+    }) => any,
+    onInvalid?: (
+      error: ZodError,
+    ) =>
+      | { statusCode: number; body: any }
+      | Promise<{ statusCode: number; body: any } | void>
+      | void,
+  ) =>
+    invoke(async ({ request, response, aux }) => {
+      const parsed = schema.safeParse(request.body);
+      if (!parsed.success) {
+        logger.error(
+          `Validation failed: ${stringifyError(treeifyError(parsed.error))}`,
+        );
+        if (onInvalid) {
+          const result = await onInvalid(parsed.error);
+          if (result) {
+            return response.fail(result.body, result.statusCode);
+          }
+        }
+        return response.fail(treeifyError(parsed.error), 400);
+      }
+
+      const typedRequest = request as Omit<HandlerRequest, 'body'> & {
+        body: S;
+      };
+      typedRequest.body = parsed.data;
+      return handler({
+        request: typedRequest,
+        response,
+        aux,
+      });
+    });
+
+  /**
+   * @param schema - Zod schema to validate the request query.
+   * @param handler - Handler that receives the validated query.
+   * @param onInvalid - Optional callback to customize invalid responses. If it
+   *   returns `{ statusCode, body }`, that is sent instead of the default zod
+   *   error payload.
+   */
+  const withQuery = <Q>(
+    schema: ZodSchema<Q>,
+    handler: (context: {
+      request: Omit<HandlerRequest, 'query'> & { query: Q };
+      response: HandlerResponse;
+      aux: Aux;
+    }) => any,
+    onInvalid?: (
+      error: ZodError<Q>,
+    ) =>
+      | { statusCode: number; body: any }
+      | Promise<{ statusCode: number; body: any } | void>
+      | void,
+  ) =>
+    invoke(async ({ request, response, aux }) => {
+      const parsed = schema.safeParse(request.query);
+      if (!parsed.success) {
+        logger.error(
+          `Validation failed: ${stringifyError(treeifyError(parsed.error))}`,
+        );
+        if (onInvalid) {
+          const result = await onInvalid(parsed.error);
+          if (result) {
+            return response.fail(result.body, result.statusCode);
+          }
+        }
+        return response.fail(treeifyError(parsed.error), 400);
+      }
+
+      const typedRequest = request as Omit<HandlerRequest, 'query'> & {
+        query: Q;
+      };
+      typedRequest.query = parsed.data;
+      return handler({
+        request: typedRequest,
+        response,
+        aux,
+      });
+    });
+
+  return Object.assign(invoke, {
+    withBody,
+    withQuery,
+  });
 };
 export default build;

package/src/middleware/database/connectionProxy.ts

@@ -23,40 +23,47 @@ export class ConnectionProxy {
   private initialized: boolean;
   private dbName?: string;
 
+  private readonly MAX_RETRIES: number = 1;
+
   public constructor(private readonly options: MySQLPluginOptions) {
     if (options.schema && options.schema.database) {
       this.dbName = options.config.database;
       options.config.database = undefined;
     }
     this.secretsCache = SecretsManagerCache.getInstance();
+    if (options.secretsManagerConfig) {
+      this.secretsCache.configure(options.secretsManagerConfig);
+    }
   }
 
   public query = <T>(sql: string, params?: any[]) =>
-    new Promise<T | undefined>(async (resolve, reject) => {
-      const connection = await this.prepareConnection();
-      await this.tryToInitializeSchema(false);
-
-      if (process.env.NODE_ENV !== 'test') {
-        logger.silly(`Execute query[${sql}] with params[${params}]`);
-      }
-      connection.query(
-        sql,
-        params,
-        (err: QueryError, result: QueryResult, _fields?: FieldPacket[]) => {
-          if (err) {
-            logger.error(
-              `error occurred in database query=${sql}, error=${err}`,
-            );
-            reject(err);
-          } else {
-            resolve(result as T);
+    this.prepareConnection().then((connection) =>
+      this.tryToInitializeSchema(false).then(
+        () =>
+          new Promise<T | undefined>((resolve, reject) => {
             if (process.env.NODE_ENV !== 'test') {
-              logger.silly(`DB result is ${JSON.stringify(result)}`);
+              logger.silly(`Execute query[${sql}] with params[${params}]`);
             }
-          }
-        },
-      );
-    });
+            connection.query(
+              sql,
+              params,
+              (err: QueryError, result: QueryResult, _fields?: FieldPacket[]) => {
+                if (err) {
+                  logger.error(
+                    `error occurred in database query=${sql}, error=${err}`,
+                  );
+                  reject(err);
+                } else {
+                  resolve(result as T);
+                  if (process.env.NODE_ENV !== 'test') {
+                    logger.silly(`DB result is ${JSON.stringify(result)}`);
+                  }
+                }
+              },
+            );
+          }),
+      ),
+    );
 
   public fetch = <T>(sql: string, params?: any[]) =>
     this.query<T[]>(sql, params).then((res) => res || []);
@@ -71,46 +78,52 @@ export class ConnectionProxy {
     });
 
   public beginTransaction = () =>
-    new Promise<void>(async (resolve, reject) => {
-      const connection = await this.prepareConnection();
-      await this.tryToInitializeSchema(false);
-
-      connection.beginTransaction((err: QueryError) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    });
+    this.prepareConnection().then((connection) =>
+      this.tryToInitializeSchema(false).then(
+        () =>
+          new Promise<void>((resolve, reject) => {
+            connection.beginTransaction((err: QueryError) => {
+              if (err) {
+                reject(err);
+                return;
+              }
+              resolve();
+            });
+          }),
+      ),
+    );
 
   public commit = () =>
-    new Promise<void>(async (resolve, reject) => {
-      const connection = await this.prepareConnection();
-      await this.tryToInitializeSchema(false);
-
-      connection.commit((err: QueryError) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    });
+    this.prepareConnection().then((connection) =>
+      this.tryToInitializeSchema(false).then(
+        () =>
+          new Promise<void>((resolve, reject) => {
+            connection.commit((err: QueryError) => {
+              if (err) {
+                reject(err);
+                return;
+              }
+              resolve();
+            });
+          }),
+      ),
+    );
 
   public rollback = () =>
-    new Promise<void>(async (resolve, reject) => {
-      const connection = await this.prepareConnection();
-      await this.tryToInitializeSchema(false);
-
-      connection.rollback((err: QueryError) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    });
+    this.prepareConnection().then((connection) =>
+      this.tryToInitializeSchema(false).then(
+        () =>
+          new Promise<void>((resolve, reject) => {
+            connection.rollback((err: QueryError) => {
+              if (err) {
+                reject(err);
+                return;
+              }
+              resolve();
+            });
+          }),
+      ),
+    );
 
   public clearConnection = () => {
     const conn = this.connection;
@@ -153,13 +166,47 @@ export class ConnectionProxy {
 
     return await this.connectionInitOnce.run(async () => {
       await this.ensureConnectionConfig();
-      const conn = createConnection(this.connectionConfig);
-      conn.connect();
-      this.connection = conn;
+      this.connection = await this.createConnection(this.MAX_RETRIES);
       return this.connection;
     });
   };
 
+  private createConnection = async (
+    remainingRetries: number,
+  ): Promise<Connection> => {
+    const conn = createConnection(this.connectionConfig);
+
+    return new Promise((resolve, reject) => {
+      conn.on('error', (err) => {
+        logger.error(`Connection error event: ${err.message}`);
+      });
+
+      conn.connect((err) => {
+        if (err) {
+          logger.error(`Failed to connect to database: ${err.message}`);
+          conn.destroy();
+
+          if (remainingRetries > 0) {
+            logger.warn(
+              `Retrying database connection... (${remainingRetries} attempt(s) remaining)`,
+            );
+            setTimeout(() => {
+              this.createConnection(remainingRetries - 1)
+                .then(resolve)
+                .catch(reject);
+            }, 100);
+          } else {
+            logger.error('Database connection failed after all retries. Giving up.');
+            reject(err);
+          }
+        } else {
+          logger.verbose('Database connection established successfully.');
+          resolve(conn);
+        }
+      });
+    });
+  };
+
   private ensureConnectionConfig = async (): Promise<void> => {
     if (this.connectionConfig) {
       return;

package/src/middleware/database/sqlClient.ts

@@ -30,8 +30,13 @@ class LazyConnectionPool implements MysqlPool {
   private configInitOnce = new OncePromise<void>();
   private connectionInitOnce = new OncePromise<LazyMysqlPoolConnection>();
 
+  private readonly MAX_RETRIES: number = 1;
+
   constructor(private readonly options: MySQLPluginOptions) {
     this.secretsCache = SecretsManagerCache.getInstance();
+    if (options.secretsManagerConfig) {
+      this.secretsCache.configure(options.secretsManagerConfig);
+    }
   }
 
   private ensureConnectionConfig = async (): Promise<void> => {
@@ -68,23 +73,50 @@ class LazyConnectionPool implements MysqlPool {
     this.connectionInitOnce
       .run(async () => {
         await this.ensureConnectionConfig();
-        const conn = createConnection(this.connectionConfig);
-        return await new Promise<LazyMysqlPoolConnection>((resolve, reject) => {
-          conn.connect((err: QueryError) => {
-            if (err) {
-              reject(err);
-              return;
-            }
-            const wrapped = this._addRelease(conn);
-            this.connection = wrapped;
-            resolve(wrapped);
-          });
-        });
+        return await this.createConnection(this.MAX_RETRIES);
       })
       .then((conn) => callback(null, conn))
       .catch((err) => callback(err, {} as LazyMysqlPoolConnection));
   };
 
+  private createConnection = async (
+    remainingRetries: number,
+  ): Promise<LazyMysqlPoolConnection> => {
+    const conn = createConnection(this.connectionConfig);
+
+    return new Promise((resolve, reject) => {
+      conn.on('error', (err) => {
+        logger.error(`Database connection error occurred: ${err.message}`);
+      });
+
+      conn.connect((err: QueryError) => {
+        if (err) {
+          logger.error(`Failed to connect to database: ${err.message}`);
+          conn.destroy();
+
+          if (remainingRetries > 0) {
+            logger.warn(
+              `Retrying database connection... (${remainingRetries} attempt(s) remaining)`,
+            );
+            setTimeout(() => {
+              this.createConnection(remainingRetries - 1)
+                .then(resolve)
+                .catch(reject);
+            }, 100);
+          } else {
+            logger.error('Database connection failed after all retries. Giving up.');
+            reject(err);
+          }
+        } else {
+          logger.verbose('Database connection established successfully.');
+          const wrapped = this._addRelease(conn);
+          this.connection = wrapped;
+          resolve(wrapped);
+        }
+      });
+    });
+  };
+
   public end = (callback: (error: unknown) => void): void => {
     const conn = this.connection;
     this.connection = null;

package/src/middleware/mysql.ts

@@ -1,3 +1,4 @@
+import type { SecretsManagerClientConfig } from '@aws-sdk/client-secrets-manager';
 import type { ConnectionOptions, PoolOptions } from 'mysql2';
 import { HandlerAuxBase, HandlerPluginBase } from './base';
 import { ConnectionProxy } from './database/connectionProxy';
@@ -14,6 +15,7 @@ export interface MySQLPluginOptions {
    * AWS Secrets Manager secret ID containing {@link DatabaseCredentials}
    */
   secretId?: string;
+  secretsManagerConfig?: SecretsManagerClientConfig;
   schema?: {
     eager?: boolean;
     ignoreError?: boolean;

package/src/utils/secretsManager.ts

@@ -1,6 +1,7 @@
 import {
   GetSecretValueCommand,
   SecretsManagerClient,
+  SecretsManagerClientConfig,
 } from '@aws-sdk/client-secrets-manager';
 import type { DatabaseCredentials } from '../middleware/mysql';
 import { getLogger } from './logger';
@@ -11,6 +12,7 @@ const logger = getLogger(__filename);
 export class SecretsManagerCache {
   private static instance: SecretsManagerCache;
   private client: SecretsManagerClient | undefined;
+  private clientConfig: SecretsManagerClientConfig | undefined;
   private cache = new Map<string, any>();
 
   private constructor() {}
@@ -22,9 +24,20 @@ export class SecretsManagerCache {
     return SecretsManagerCache.instance;
   }
 
+  public configure(config: SecretsManagerClientConfig): void {
+    if (this.client) {
+      logger.warn(
+        'SecretsManager client already initialized. Reconfiguring with new config.',
+      );
+      this.client = undefined;
+    }
+    this.clientConfig = config;
+    logger.debug('SecretsManager client config updated');
+  }
+
   private getClient(): SecretsManagerClient {
     if (!this.client) {
-      this.client = new SecretsManagerClient({});
+      this.client = new SecretsManagerClient(this.clientConfig ?? {});
       logger.debug('SecretsManager client initialized');
     }
     return this.client;

package/tsconfig.json

@@ -9,7 +9,8 @@
     "noImplicitAny": true,
     "strictNullChecks": true,
     "noUnusedLocals": true,
-    "noUnusedParameters": true
+    "noUnusedParameters": true,
+    "skipLibCheck": true
   },
   "exclude": ["node_modules", "dist", "__tests__"]
 }