@creator.co/wapi 1.8.8 → 1.9.1

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@creator.co/wapi",
-  "version": "1.8.8",
+  "version": "1.9.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "scripts": {
     "build": "task build",
     "clean": "task clean",
@@ -19,14 +23,14 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.651.1",
-    "@aws-sdk/client-kms": "^3.651.1",
-    "@aws-sdk/client-secrets-manager": "^3.651.1",
-    "@aws-sdk/client-sesv2": "^3.651.1",
-    "@aws-sdk/client-sns": "^3.651.1",
-    "@aws-sdk/client-ssm": "^3.651.1",
-    "@aws-sdk/credential-provider-node": "^3.651.1",
-    "@aws-sdk/util-dynamodb": "^3.651.1",
+    "@aws-sdk/client-dynamodb": "^3.730.0",
+    "@aws-sdk/client-kms": "^3.730.0",
+    "@aws-sdk/client-secrets-manager": "^3.730.0",
+    "@aws-sdk/client-sesv2": "^3.730.0",
+    "@aws-sdk/client-sns": "^3.730.0",
+    "@aws-sdk/client-ssm": "^3.730.0",
+    "@aws-sdk/credential-provider-node": "^3.730.0",
+    "@aws-sdk/util-dynamodb": "^3.730.0",
     "@smithy/node-http-handler": "^3.2.2",
     "@types/email-templates": "^10.0.4",
     "@types/nodemailer": "^6.4.10",
@@ -42,12 +46,12 @@
     "jsonwebtoken": "^9.0.2",
     "knex": "^3.0.1",
     "knex-stringcase": "^1.4.6",
-    "kysely": "^0.27.4",
+    "kysely": "^0.28.14",
     "node-cache": "^5.1.2",
-    "nodemailer": "^7.0.12",
+    "nodemailer": "^8.0.4",
     "object-hash": "^3.0.0",
     "parse-duration": "^2.1.3",
-    "path-to-regexp": "^8.1.0",
+    "path-to-regexp": "^8.4.0",
     "pg": "^8.11.3",
     "rate-limit-redis": "^4.2.0",
     "redis": "^4.7.0",

package/src/API/Request.ts

@@ -11,6 +11,31 @@ import Utils from '../Util/Utils.js'
  * @template QueryParamsType - The type of the query parameters for the request.
  */
 export default class Request<InputType, PathParamsType, QueryParamsType> {
+  /**
+   * Default paths to exclude from verbose logging (health checks, monitoring, etc.)
+   */
+  private static readonly DEFAULT_NO_LOG_PATHS = [
+    '/health',
+    '/healthcheck',
+    '/health-check',
+    '/ping',
+    '/status',
+    '/ready',
+    '/readiness',
+    '/liveness',
+    '/metrics',
+    '/_health',
+    '/',
+  ]
+
+  /**
+   * Combined list of ignored paths, computed once at class-load time.
+   */
+  private static readonly IGNORED_PATHS: string[] = [
+    ...Request.DEFAULT_NO_LOG_PATHS,
+    ...(process.env.NO_LOG_PATHS ? process.env.NO_LOG_PATHS.split(',').map(p => p.trim()) : []),
+  ]
+
   /**
    * Represents an API Gateway event for a request.
    * @type {APIGatewayEvent}
@@ -20,6 +45,10 @@ export default class Request<InputType, PathParamsType, QueryParamsType> {
    * The context object for the current instance.
    */
   private context: Context
+  /**
+   * Cached result of whether this request is a health/monitoring endpoint.
+   */
+  private readonly _isHealthCheckPath: boolean
 
   /**
    * Constructs a new instance of the class.
@@ -31,8 +60,142 @@ export default class Request<InputType, PathParamsType, QueryParamsType> {
   constructor(requestEvent: APIGatewayEvent, context: Context, logger: Logger) {
     this.requestEvent = requestEvent
     this.context = context
-    logger.info('Request info:', requestEvent)
-    logger.debug('Request context:', context)
+
+    // Skip verbose logging for health check and monitoring endpoints
+    const path = requestEvent.path || ''
+    this._isHealthCheckPath = this.isHealthOrMonitoringPath(path)
+    if (!this._isHealthCheckPath) {
+      logger.info('Request:', this.getRelevantLogData(requestEvent, context))
+    }
+  }
+
+  /**
+   * Builds a concise, sanitized request summary for logging.
+   * Avoid logging the full event object, raw body, or sensitive header values.
+   */
+  private getRelevantLogData(requestEvent: APIGatewayEvent, context: Context): Record<string, any> {
+    if (this.isQueueEvent(requestEvent)) {
+      return this.getQueueEventLogData(requestEvent, context)
+    }
+
+    const headers = requestEvent.headers || {}
+    const queryParams = requestEvent.queryStringParameters || {}
+    const pathParams = requestEvent.pathParameters || {}
+    const body = this.getBody()
+
+    return {
+      method: requestEvent.httpMethod,
+      path: requestEvent.path,
+      stage: requestEvent.requestContext?.stage,
+      requestId: context.awsRequestId || requestEvent.requestContext?.requestId,
+      sourceIp: requestEvent.requestContext?.identity?.sourceIp || headers['x-forwarded-for'],
+      userAgent: headers['User-Agent'] || headers['user-agent'],
+      contentType: headers['Content-Type'] || headers['content-type'],
+      contentLength: headers['Content-Length'] || headers['content-length'],
+      ...(Object.keys(pathParams).length > 0 ? { pathParams } : {}),
+      ...(Object.keys(queryParams).length > 0 ? { queryParams } : {}),
+      ...this.getBodyLogData(body),
+    }
+  }
+
+  /**
+   * Detects queue-style event payloads such as SQS events.
+   */
+  private isQueueEvent(requestEvent: any): requestEvent is {
+    Records: Array<Record<string, any>>
+  } {
+    return Array.isArray(requestEvent?.Records)
+  }
+
+  /**
+   * Builds a concise log payload for SQS-style record batches.
+   */
+  private getQueueEventLogData(
+    requestEvent: { Records: Array<Record<string, any>> },
+    context: Context
+  ): Record<string, any> {
+    const records = requestEvent.Records || []
+    const eventSources = this.getUniqueRecordValues(records, 'eventSource')
+    const queueArns = this.getUniqueRecordValues(records, 'eventSourceARN')
+    const regions = this.getUniqueRecordValues(records, 'awsRegion')
+    const messageIds = records.map(record => record.messageId).filter(Boolean)
+    const messageGroupIds = records.map(record => record.attributes?.MessageGroupId).filter(Boolean)
+    const bodySummary = records.map(record =>
+      this.getBodySummary(this.parseRecordBody(record.body))
+    )
+
+    return {
+      eventType: eventSources.length === 1 ? eventSources[0] : eventSources,
+      recordCount: records.length,
+      requestId: context.awsRequestId,
+      ...(queueArns.length > 0
+        ? { queueArn: queueArns.length === 1 ? queueArns[0] : queueArns }
+        : {}),
+      ...(regions.length > 0 ? { region: regions.length === 1 ? regions[0] : regions } : {}),
+      ...(messageIds.length > 0 ? { messageIds } : {}),
+      ...(messageGroupIds.length > 0 ? { messageGroupIds: [...new Set(messageGroupIds)] } : {}),
+      body: records.length === 1 ? bodySummary[0] : bodySummary,
+    }
+  }
+
+  private getUniqueRecordValues(records: Array<Record<string, any>>, key: string): string[] {
+    return [...new Set(records.map(record => record[key]).filter(Boolean))]
+  }
+
+  /**
+   * Parses record bodies when they are JSON strings; otherwise returns the raw value.
+   */
+  private parseRecordBody(body: unknown): unknown {
+    if (typeof body !== 'string') return body
+
+    try {
+      return JSON.parse(body)
+    } catch {
+      return body
+    }
+  }
+
+  /**
+   * Logs body shape instead of full request payload to keep logs useful and safe.
+   */
+  private getBodyLogData(body: unknown): Record<string, any> {
+    if (body == null) return {}
+
+    return { body: this.getBodySummary(body) }
+  }
+
+  private getBodySummary(body: unknown): Record<string, any> {
+    if (body == null) return { type: 'null' }
+
+    if (Array.isArray(body)) {
+      return { type: 'array', size: body.length }
+    }
+
+    if (Buffer.isBuffer(body)) {
+      return { type: 'buffer', size: body.length }
+    }
+
+    if (typeof body === 'object') {
+      return { type: 'object', keys: Object.keys(body as Record<string, unknown>) }
+    }
+
+    if (typeof body === 'string') {
+      return { type: 'string', size: body.length }
+    }
+
+    return { type: typeof body }
+  }
+
+  /**
+   * Checks if the path is a health check or monitoring endpoint that should not be logged verbosely.
+   * @param {string} path - The request path
+   * @returns {boolean} - True if it's a health/monitoring endpoint
+   */
+  private isHealthOrMonitoringPath(path: string): boolean {
+    const lowerPath = path.toLowerCase()
+    return Request.IGNORED_PATHS.some(
+      ignored => lowerPath === ignored || lowerPath.startsWith(ignored + '/')
+    )
   }
 
   /**
@@ -122,6 +285,17 @@ export default class Request<InputType, PathParamsType, QueryParamsType> {
     return this.requestEvent.path
   }
 
+  public isHealthCheckPath(): boolean {
+    return this._isHealthCheckPath
+  }
+
+  public static isHealthCheckPath(path: string): boolean {
+    const lowerPath = (path || '').toLowerCase()
+    return Request.IGNORED_PATHS.some(
+      ignored => lowerPath === ignored || lowerPath.startsWith(ignored + '/')
+    )
+  }
+
   /**
    * Retrieves the HTTP method of the current request.
    * @returns {string} The HTTP method of the request.

package/src/BaseEvent/Transaction.ts

@@ -140,7 +140,11 @@ export default class Transaction<
     this.syncReturn = !!config?.syncReturn
     this.retrowErrors = !!config?.throwOnErrors /* retrow internal errors */
     // components
-    this.logger = new Logger(config?.logger, transactionId)
+    const isHealthCheck = Request.isHealthCheckPath((<APIGatewayEvent>event).path || '')
+    this.logger = new Logger(
+      { ...config?.logger, silent: isHealthCheck || !!config?.logger?.silent },
+      transactionId
+    )
     this.request = new Request<InputType, PathParamsType, QueryParamsType>(
       this.event,
       this.context,

package/src/Logger/Logger.ts

@@ -51,6 +51,8 @@ const blacklist = ['password', 'token', 'accounts', 'authorization', 'key'].map(
 export type LoggerConfig = {
   sensitiveFilteringKeywords?: boolean | Array<string>
   logLevel?: LOG_LEVELS | string
+  /** When true, all log output is suppressed (e.g. health check routes). */
+  silent?: boolean
 }
 
 type SupressableItem = {
@@ -113,8 +115,10 @@ export default class Logger {
     //
     this.setupBindings()
     //
-    this.log('Using logger with level: ' + this._LOG_LEVEL.toString())
-    this.debug('logger config: ', this.config)
+    if (!this.config.silent) {
+      this.log('Using logger with level: ' + this._LOG_LEVEL.toString())
+      this.debug('logger config: ', this.config)
+    }
   }
 
   /**
@@ -245,6 +249,7 @@ export default class Logger {
    * @returns None
    */
   private processLog(level: LOG_LEVELS, args: any): void {
+    if (this.config?.silent) return
     if (level < this._LOG_LEVEL) return
     //get args
     const msg: string[] = []

package/src/Server/Router.ts

@@ -195,6 +195,12 @@ export type RouterConfig = TransactionConfig & {
    * @type {string | undefined}
    */
   healthCheckRoute?: string
+  /**
+   * Paths that should not be logged (e.g., health checks, metrics).
+   * These requests will still be processed but won't create verbose logs.
+   * @type {string[] | undefined}
+   */
+  noLogPaths?: string[]
   /**
    * Global rate limiting configuration for all routes.
    * Individual routes can override this with their own rateLimit config.

package/src/Server/lib/ContainerServer.ts

@@ -40,7 +40,14 @@ export default class ContainerServer extends Server {
    * @returns {Promise<void>} - A promise that resolves when the proxy is loaded.
    */
   public async start() {
-    await this.proxy.load()
+    try {
+      console.log('[ContainerServer] Starting server...')
+      await this.proxy.load()
+      console.log('[ContainerServer] Server started successfully')
+    } catch (error) {
+      console.error('[ContainerServer] Failed to start server:', error)
+      throw error
+    }
   }
 
   /**
@@ -49,7 +56,15 @@ export default class ContainerServer extends Server {
    * @returns {Promise<void>} - A promise that resolves once the proxy is unloaded.
    */
   public async stop(err?: any) {
-    await this.proxy.unload(err)
+    try {
+      console.log('[ContainerServer] Stopping server...')
+      await this.proxy.unload(err)
+      console.log('[ContainerServer] Server stopped successfully')
+    } catch (stopError) {
+      console.error('[ContainerServer] Error during server shutdown:', stopError)
+      // Force exit if graceful shutdown fails
+      process.exit(1)
+    }
   }
 
   /**
@@ -58,8 +73,42 @@ export default class ContainerServer extends Server {
    * @returns None
    */
   private listenProcessEvents() {
-    // start process listeners
-    process.on('unhandledRejection', this.stop.bind(this)) // listen to exceptions
-    process.on('SIGINT', this.stop.bind(this)) // listen on SIGINT signal and gracefully stop the server
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', (reason, promise) => {
+      console.error('[ContainerServer] CRITICAL: Unhandled Promise Rejection')
+      console.error('[ContainerServer] Reason:', reason)
+      if (reason instanceof Error) {
+        console.error('[ContainerServer] Stack:', reason.stack)
+      }
+      console.error('[ContainerServer] Promise:', promise)
+      console.error('[ContainerServer] Shutting down server due to unhandled rejection...')
+      this.stop(reason)
+    })
+
+    // Handle uncaught exceptions
+    process.on('uncaughtException', error => {
+      console.error('[ContainerServer] CRITICAL: Uncaught Exception')
+      console.error('[ContainerServer] Error:', error)
+      console.error('[ContainerServer] Stack:', error.stack)
+      console.error('[ContainerServer] Shutting down server due to uncaught exception...')
+      this.stop(error)
+    })
+
+    // Handle SIGINT (Ctrl+C)
+    process.on('SIGINT', () => {
+      console.log('[ContainerServer] SIGINT received, shutting down gracefully...')
+      this.stop()
+    })
+
+    // Handle SIGTERM (Docker/ECS stop)
+    process.on('SIGTERM', () => {
+      console.log('[ContainerServer] SIGTERM received, shutting down gracefully...')
+      this.stop()
+    })
+
+    // Log when process is about to exit
+    process.on('exit', code => {
+      console.log(`[ContainerServer] 🚪 Process exiting with code: ${code}`)
+    })
   }
 }

package/src/Server/lib/container/GenericHandler.ts

@@ -1,10 +1,14 @@
 import { Request, Response } from 'express'
 
 import GenericHandlerEvent, { GenericHandlerEventResponse } from './GenericHandlerEvent.js'
+import WapiRequest from '../../../API/Request.js'
 import Globals from '../../../Globals.js'
+import Logger from '../../../Logger/Logger.js'
 import Utils from '../../../Util/Utils.js'
 import Server from '../Server.js'
 
+const logger = new Logger({ logLevel: 'INFO' }, 'proxy-container')
+
 /**
  * Creates an async function that handles serverless events and sends a response.
  * @param {Server['handleServerlessEvent']} serverlessHandler - The serverless handler function.
@@ -27,15 +31,17 @@ export default (serverlessHandler: Server['handleServerlessEvent']) => {
       // Respond
       processServerlessResponse(invokationResp, res)
     } catch (e) {
-      console.error('[Proxy] - Exception during execution!', e)
-      console.error(e.stack)
+      logger.error('[Proxy] - Exception during execution!', e)
+      logger.error(e.stack)
       res.status(Globals.Resp_STATUSCODE_EXCEPTION).json({
         ...e,
         err: Globals.Resp_MSG_EXCEPTION,
         errCode: Globals.Resp_CODE_EXCEPTION,
       })
     }
-    console.info(`[Proxy] - Request took ${Date.now() - startTime}ms`)
+    if (!WapiRequest.isHealthCheckPath(request.path)) {
+      logger.info(`[Proxy] - Request took ${Date.now() - startTime}ms`)
+    }
   }
 }
 

package/tests/AwsSdkTest.utils.ts

@@ -0,0 +1,13 @@
+import { mockClient } from 'aws-sdk-client-mock'
+
+export function mockAwsClient<TClient>(client: TClient) {
+  return mockClient(client as any) as any
+}
+
+export function mockAwsCommand<TCommand>(command: TCommand) {
+  return command as any
+}
+
+export function mockAwsResult<TResult>(result: TResult) {
+  return result as any
+}

package/tests/Config/Config.test.ts

@@ -1,11 +1,11 @@
 import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
-import { mockClient } from 'aws-sdk-client-mock'
 import { expect as c_expect } from 'chai'
 
 import Configuration from '../../src/Config/Configuration.js'
+import { mockAwsClient, mockAwsCommand, mockAwsResult } from '../AwsSdkTest.utils.js'
 import { SampleConfig } from '../Test.utils.js'
 
-const SSMMock = mockClient(SSMClient)
+const SSMMock = mockAwsClient(SSMClient)
 const config = new Configuration<typeof SampleConfig>(SampleConfig, 'my-prefix')
 describe(`Optional remote environment`, () => {
   // reset mock
@@ -27,35 +27,39 @@ describe(`Optional remote environment`, () => {
   })
 
   test('Optional value with null value', async () => {
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: undefined,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+    )
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     c_expect(token).is.undefined
   })
 
   test('Optional value with empty response', async () => {
-    SSMMock.on(GetParameterCommand).resolves({})
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(mockAwsResult({}))
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     c_expect(token).is.undefined
   })
 
   test('Optional value with valid response', async () => {
     const value = 'abc'
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: value,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: value,
+        },
+      })
+    )
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     c_expect(token).is.not.undefined
     c_expect(token).to.be.equals(value)
   })
 
   test('Optional value rejection', async () => {
-    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).rejects(new Error('failed!'))
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     c_expect(token).is.undefined
   })
@@ -81,11 +85,13 @@ describe(`Required remote environment`, () => {
   })
 
   test('Required value with null value', async () => {
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: undefined,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+    )
     let err = null
     try {
       await config.asyncGet('TOKEN_SECRET')
@@ -97,7 +103,7 @@ describe(`Required remote environment`, () => {
   })
 
   test('Required value with empty response', async () => {
-    SSMMock.on(GetParameterCommand).resolves({})
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(mockAwsResult({}))
     let err = null
     try {
       await config.asyncGet('TOKEN_SECRET')
@@ -110,18 +116,20 @@ describe(`Required remote environment`, () => {
 
   test('Required value with valid response', async () => {
     const value = 'abc'
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: value,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: value,
+        },
+      })
+    )
     const token = await config.asyncGet('TOKEN_SECRET')
     c_expect(token).is.not.undefined
     c_expect(token).to.be.equals(value)
   })
 
   test('Required value rejection', async () => {
-    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).rejects(new Error('failed!'))
     let err = null
     try {
       await config.asyncGet('TOKEN_SECRET')
@@ -185,17 +193,19 @@ describe(`Caching test`, () => {
     const value = '123'
     const key = 'TOKEN_SECRET'
     // initial fetch
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: value,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: value,
+        },
+      })
+    )
     const v = await config.asyncGet(key)
     c_expect(v).is.not.null
     c_expect(v).to.be.equals(value)
     // subsequent fetch
     SSMMock.reset()
-    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).rejects(new Error('failed!'))
     const v2 = await config.asyncGet(key)
     c_expect(v2).is.not.null
     c_expect(v2).to.be.equals(value)