serverless-simple-middleware 0.0.72 → 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,13 +78,18 @@ class ConnectionProxy {
             }
             resolve();
         });
-    });
+    })));
     clearConnection = () => {
-        if (this.connection) {
-            this.connection.end();
-            this.connection = undefined;
-            this.connectionInitOnce.reset();
-            logger.verbose('Connection is end');
+        const conn = this.connection;
+        this.connection = undefined;
+        this.connectionInitOnce.reset();
+        if (conn) {
+            try {
+                conn.end();
+            }
+            catch (error) {
+                logger.warn(`Error occurred while ending connection: ${error}`);
+            }
         }
     };
     /**
@@ -96,11 +97,16 @@ class ConnectionProxy {
      * This should be used only for special use cases!
      */
     destroyConnection = () => {
-        if (this.connection) {
-            this.connection.destroy();
-            this.connection = undefined;
-            this.connectionInitOnce.reset();
-            logger.verbose('Connection is destroyed');
+        const conn = this.connection;
+        this.connection = undefined;
+        this.connectionInitOnce.reset();
+        if (conn) {
+            try {
+                conn.destroy();
+            }
+            catch (error) {
+                logger.warn(`Error occurred while destroying connection: ${error}`);
+            }
         }
     };
     onPluginCreated = async () => this.tryToInitializeSchema(true);
@@ -110,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.d.ts

@@ -10,4 +10,4 @@ export declare class SQLClient<T = unknown> extends Kysely<T> {
      */
     destroyConnection: () => void;
 }
-export { expressionBuilder, sql, type DeleteQueryBuilder, type DeleteResult, type Expression, type ExpressionBuilder, type InferResult, type Insertable, type InsertQueryBuilder, type InsertResult, type NotNull, type RawBuilder, type Selectable, type SelectQueryBuilder, type SqlBool, type Transaction, type Updateable, type UpdateQueryBuilder, type UpdateResult, } from 'kysely';
+export { expressionBuilder, sql, type DeleteQueryBuilder, type DeleteResult, type Expression, type ExpressionBuilder, type InferResult, type Insertable, type InsertQueryBuilder, type InsertResult, type NotNull, type RawBuilder, type Selectable, type SelectQueryBuilder, type SqlBool, type Transaction, type Updateable, type UpdateQueryBuilder, type UpdateResult } from 'kysely';

package/dist/middleware/database/sqlClient.js

@@ -4,7 +4,9 @@ exports.sql = exports.expressionBuilder = exports.SQLClient = void 0;
 const kysely_1 = require("kysely");
 const mysql2_1 = require("mysql2");
 const oncePromise_1 = require("../../internal/oncePromise");
+const utils_1 = require("../../utils");
 const secretsManager_1 = require("../../utils/secretsManager");
+const logger = (0, utils_1.getLogger)(__filename);
 class LazyConnectionPool {
     options;
     connection = null;
@@ -12,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) {
@@ -42,27 +48,49 @@ 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) => {
-        if (this.connection) {
-            this.connection.end((err) => {
-                this.connection = null;
-                this.connectionInitOnce.reset();
+        const conn = this.connection;
+        this.connection = null;
+        this.connectionInitOnce.reset();
+        if (conn) {
+            conn.end((err) => {
                 callback(err);
             });
         }
@@ -71,10 +99,16 @@ class LazyConnectionPool {
         }
     };
     destroy = () => {
-        if (this.connection) {
-            this.connection.destroy();
-            this.connection = null;
-            this.connectionInitOnce.reset();
+        const conn = this.connection;
+        this.connection = null;
+        this.connectionInitOnce.reset();
+        if (conn) {
+            try {
+                conn.destroy();
+            }
+            catch (error) {
+                logger.warn(`Error occurred while destroying connection: ${error}`);
+            }
         }
     };
     _addRelease = (connection) => Object.assign(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.72",
+  "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,53 +78,64 @@ 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 = () => {
-    if (this.connection) {
-      this.connection.end();
-      this.connection = undefined;
-      this.connectionInitOnce.reset();
-      logger.verbose('Connection is end');
+    const conn = this.connection;
+    this.connection = undefined;
+    this.connectionInitOnce.reset();
+
+    if (conn) {
+      try {
+        conn.end();
+      } catch (error) {
+        logger.warn(`Error occurred while ending connection: ${error}`);
+      }
     }
   };
 
@@ -126,11 +144,16 @@ export class ConnectionProxy {
    * This should be used only for special use cases!
    */
   public destroyConnection = () => {
-    if (this.connection) {
-      this.connection.destroy();
-      this.connection = undefined;
-      this.connectionInitOnce.reset();
-      logger.verbose('Connection is destroyed');
+    const conn = this.connection;
+    this.connection = undefined;
+    this.connectionInitOnce.reset();
+
+    if (conn) {
+      try {
+        conn.destroy();
+      } catch (error) {
+        logger.warn(`Error occurred while destroying connection: ${error}`);
+      }
     }
   };
 
@@ -143,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

@@ -13,9 +13,12 @@ import {
   type QueryError,
 } from 'mysql2';
 import { OncePromise } from '../../internal/oncePromise';
+import { getLogger } from '../../utils';
 import { SecretsManagerCache } from '../../utils/secretsManager';
 import { MySQLPluginOptions } from '../mysql';
 
+const logger = getLogger(__filename);
+
 interface LazyMysqlPoolConnection extends Connection {
   release: () => void;
 }
@@ -27,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> => {
@@ -65,28 +73,57 @@ 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 => {
-    if (this.connection) {
-      this.connection.end((err: QueryError) => {
-        this.connection = null;
-        this.connectionInitOnce.reset();
+    const conn = this.connection;
+    this.connection = null;
+    this.connectionInitOnce.reset();
+
+    if (conn) {
+      conn.end((err: QueryError) => {
         callback(err);
       });
     } else {
@@ -95,10 +132,16 @@ class LazyConnectionPool implements MysqlPool {
   };
 
   public destroy = (): void => {
-    if (this.connection) {
-      this.connection.destroy();
-      this.connection = null;
-      this.connectionInitOnce.reset();
+    const conn = this.connection;
+    this.connection = null;
+    this.connectionInitOnce.reset();
+
+    if (conn) {
+      try {
+        conn.destroy();
+      } catch (error) {
+        logger.warn(`Error occurred while destroying connection: ${error}`);
+      }
     }
   };
 
@@ -160,5 +203,6 @@ export {
   type Transaction,
   type Updateable,
   type UpdateQueryBuilder,
-  type UpdateResult,
+  type UpdateResult
 } from 'kysely';
+

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__"]
 }