@creator.co/wapi 1.2.1-beta6 → 1.2.3

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

@@ -1,41 +1,68 @@
-import type { APIGatewayProxyEvent, Context } from "aws-lambda"
-import * as cuid from "cuid"
-import { Request } from "express"
-import * as unflatten from "unflatten"
+import type { APIGatewayProxyEvent, Context } from 'aws-lambda'
+import * as cuid from 'cuid'
+import { Request } from 'express'
 
-import {
-  parseMultiValueHeaders,
-  parseMultiValueQueryStringParameters,
-  parseQueryStringParameters,
-  nullIfEmpty,
-} from "./Utils"
-import Globals from "../../../Globals"
-import Server from "../Server"
+import { parseMultiValueQueryStringParameters, parseQueryStringParameters } from './Utils'
+import Globals from '../../../Globals'
+import Server from '../Server'
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @typedef {GenericHandlerEventResponse}
+ */
 export type GenericHandlerEventResponse = { err?: Error | string; data?: any }
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class GenericHandlerEvent
+ * @typedef {GenericHandlerEvent}
+ */
 export default class GenericHandlerEvent {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @type {Request}
+   */
   public request: Request
-  public serverlessHandler: Server["handleServerlessEvent"]
-  constructor(
-    request: Request,
-    serverlessHandler: Server["handleServerlessEvent"],
-  ) {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @type {Server["handleServerlessEvent"]}
+   */
+  public serverlessHandler: Server['handleServerlessEvent']
+  /**
+   * Creates an instance of GenericHandlerEvent.
+   *
+   * @constructor
+   * @param {Request} request
+   * @param {Server["handleServerlessEvent"]} serverlessHandler
+   */
+  constructor(request: Request, serverlessHandler: Server['handleServerlessEvent']) {
     this.request = request
     this.serverlessHandler = serverlessHandler
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @returns {Promise<GenericHandlerEventResponse>}
+   */
   public async invoke(): Promise<GenericHandlerEventResponse> {
     // eslint-disable-next-line no-async-promise-executor
     return new Promise(async (resolve, reject) => {
       try {
         // Build event and context
         const event = this.buildEvent()
-        const context = this.buildContext(
-          event,
-          (err?: Error | string, data?: any) => {
-            resolve({ err, data })
-          },
-        )
+        const context = this.buildContext(event, (err?: Error | string, data?: any) => {
+          resolve({ err, data })
+        })
         // Invoke
         await this.serverlessHandler(event, context)
       } catch (e) {
@@ -44,24 +71,22 @@ export default class GenericHandlerEvent {
     })
   }
   /* private */
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @returns {APIGatewayProxyEvent}
+   */
   private buildEvent(): APIGatewayProxyEvent {
     return {
       body: this.request.body || null, //enforce key
-      headers: this.request.headers ? unflatten(this.request.headers, 2) : [],
-      httpMethod: this.request.method
-        ? this.request.method.toUpperCase()
-        : null,
+      headers: <any>(this.request.headers || {}),
+      httpMethod: this.request.method?.toUpperCase(),
       isBase64Encoded: false,
-      multiValueHeaders: parseMultiValueHeaders(
-        this.request.headers ? this.request.headers || [] : [],
-      ),
-      multiValueQueryStringParameters: parseMultiValueQueryStringParameters(
-        this.request.url,
-      ),
+      multiValueHeaders: <any>(this.request.headers || {}),
+      multiValueQueryStringParameters: parseMultiValueQueryStringParameters(this.request.url),
       path: this.request.path,
-      pathParameters: this.request.params
-        ? nullIfEmpty(this.request.params)
-        : null,
+      pathParameters: null,
       queryStringParameters: this.request.query
         ? parseQueryStringParameters(this.request.query)
         : null,
@@ -72,9 +97,7 @@ export default class GenericHandlerEvent {
         domainName: null,
         domainPrefix: null,
         extendedRequestId: cuid(),
-        httpMethod: this.request.method
-          ? this.request.method.toUpperCase()
-          : null,
+        httpMethod: this.request.method ? this.request.method.toUpperCase() : null,
         identity: {
           accessKey: null,
           accountId: process.env.AWS_ACCOUNT_ID || null,
@@ -88,16 +111,13 @@ export default class GenericHandlerEvent {
           cognitoIdentityPoolId: null,
           principalOrgId: null,
           sourceIp:
-            <string>this.request.headers?.["x-forwarded-for"] ||
-            this.request.socket.remoteAddress,
+            <string>this.request.headers?.['x-forwarded-for'] || this.request.socket?.remoteAddress,
           user: null,
-          userAgent: this.request.headers
-            ? this.request.headers["user-agent"]
-            : null,
+          userAgent: this.request.headers?.['user-agent'],
           userArn: null,
         },
         path: this.request.path,
-        protocol: "HTTP/1.1",
+        protocol: 'HTTP/1.1',
         requestId: `${cuid()}-${cuid()}`,
         requestTime: new Date().toISOString(),
         requestTimeEpoch: Date.now(),
@@ -109,9 +129,17 @@ export default class GenericHandlerEvent {
       stageVariables: null,
     }
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @param {APIGatewayProxyEvent} event
+   * @param {(err?: Error | string, data?: any) => void} callback
+   * @returns {Context}
+   */
   private buildContext(
     event: APIGatewayProxyEvent,
-    callback: (err?: Error | string, data?: any) => void,
+    callback: (err?: Error | string, data?: any) => void
   ): Context {
     return {
       awsRequestId: event.requestContext.requestId,
@@ -120,12 +148,12 @@ export default class GenericHandlerEvent {
         return 0
       },
       done: (err, data) => callback(err, data),
-      fail: (err) => callback(err),
-      succeed: (res) => callback(null, res),
+      fail: err => callback(err),
+      succeed: res => callback(null, res),
       functionName: null,
-      functionVersion: "LATEST",
+      functionVersion: 'LATEST',
       invokedFunctionArn: null,
-      memoryLimitInMB: "-1",
+      memoryLimitInMB: '-1',
       logGroupName: null,
       logStreamName: null,
     }

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

@@ -1,5 +1,5 @@
-import { Request, Response } from "express"
+import { Request, Response } from 'express'
 
 export default async (_request: Request, res: Response) => {
-  return res.send("Healthy!")
+  res.send('Healthy!')
 }

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

@@ -1,26 +1,70 @@
-import { Server as HTTPServer, createServer } from "http"
+import { Server as HTTPServer, createServer } from 'http'
 
-import * as cors from "cors"
-import * as express from "express"
+import * as cors from 'cors'
+import * as express from 'express'
 
-import Server from "./../Server"
-import GenericHandler from "./GenericHandler"
-import HealthHandler from "./HealthHandler"
-import { version as appVersion } from "../../../../package.json"
-import Utils from "../../../API/Utils"
-import Globals from "../../../Globals"
-import { RouterConfig } from "../../Router"
+import Server from './../Server'
+import GenericHandler from './GenericHandler'
+import HealthHandler from './HealthHandler'
+import { version as appVersion } from '../../../../package.json'
+import Utils from '../../../API/Utils'
+import Globals from '../../../Globals'
+import { RouterConfig } from '../../Router'
 
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Proxy
+ * @typedef {Proxy}
+ */
 export default class Proxy {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {boolean}
+   */
   private stopping: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {RouterConfig}
+   */
   private readonly config: RouterConfig
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {express.Express}
+   */
   private readonly app: express.Express
-  private readonly serverlessHandler: Server["handleServerlessEvent"]
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {Server["handleServerlessEvent"]}
+   */
+  private readonly serverlessHandler: Server['handleServerlessEvent']
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {HTTPServer}
+   */
   private listener: HTTPServer
-  constructor(
-    config: RouterConfig,
-    serverlessHandler: Server["handleServerlessEvent"],
-  ) {
+  /**
+   * Creates an instance of Proxy.
+   *
+   * @constructor
+   * @param {RouterConfig} config
+   * @param {Server["handleServerlessEvent"]} serverlessHandler
+   */
+  constructor(config: RouterConfig, serverlessHandler: Server['handleServerlessEvent']) {
     this.stopping = false
     this.config = config
     this.serverlessHandler = serverlessHandler
@@ -28,20 +72,17 @@ export default class Proxy {
     /* Opinionated Express configs */
     this.app.use(express.json())
     // apply cors config
-    const corsConfig =
-      this.config.cors || Utils.parseObjectNullIfEmpty(process.env.CORS)
+    const corsConfig = this.config.cors || Utils.parseObjectNullIfEmpty(process.env.CORS)
     this.app.use(
       cors(
         corsConfig
           ? {
-              options: {
-                origin: corsConfig?.origin,
-                allowedHeaders: corsConfig?.headers,
-                credentials: !!corsConfig?.allowCredentials,
-              },
+              origin: corsConfig.origin,
+              allowedHeaders: corsConfig.headers,
+              credentials: !!corsConfig.allowCredentials,
             }
-          : {},
-      ),
+          : {}
+      )
     )
 
     // //This supposedly fix some 502 codes where nodejs socket would hang during
@@ -52,24 +93,42 @@ export default class Proxy {
     // this.listener.listener.keepAliveTimeout = 120e3
     // this.listener.listener.headersTimeout = 120e3
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @returns {*}
+   */
   async load() {
     await this.startListeners()
     this.installRoutes()
   }
-  async unload(err) {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @param {?*} [err]
+   * @returns {*}
+   */
+  async unload(err?: any) {
     await this.stopListeners(err)
   }
   /* lifecycle */
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @async
+   * @returns {Promise<void>}
+   */
   private async startListeners(): Promise<void> {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       const port = this.config.port || Globals.Listener_HTTP_DefaultPort
       console.log(`[Proxy] - [STARTING] - v.${appVersion} - :${port}`)
       // Create Server
       this.listener = createServer(this.app)
       // Set defaults
-      this.listener.setTimeout(
-        this.config.timeout || Globals.Listener_HTTP_DefaultTimeout,
-      )
+      this.listener.setTimeout(this.config.timeout || Globals.Listener_HTTP_DefaultTimeout)
       // Start Server
       this.listener.listen(port, () => {
         console.log(`[Proxy] - [STARTED]`)
@@ -77,37 +136,47 @@ export default class Proxy {
       })
     })
   }
-  private async stopListeners(err) {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @async
+   * @param {?*} [err]
+   * @returns {unknown}
+   */
+  private async stopListeners(err?: any) {
     if (this.stopping) return
     this.stopping = true
-    console.debug("[Proxy] - [STOPPING]")
-    this.listener.close((_err) => {
-      if (err || _err) console.log("[Proxy] - exit output:", err || _err)
-      console.log("[Proxy] - [STOPPED]")
-      process.exit(err || _err ? 1 : 0)
+    console.debug('[Proxy] - [STOPPING]')
+    return new Promise(resolve => {
+      this.listener.close(_err => {
+        if (err || _err) console.log('[Proxy] - exit output:', err || _err)
+        console.log('[Proxy] - [STOPPED]')
+        process.exit(err || _err ? 1 : 0)
+        resolve(null)
+      })
     })
   }
   /* routing */
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   */
   private installRoutes() {
     //Health check route -- This is a bypass route to only check if
     //runtime proxy is working and responding to calls.
     console.log(
       `[Proxy] - [HEALTH-ROUTE] - ${
-        this.config.healthCheckRoute ||
-        Globals.Listener_HTTP_DefaultHealthCheckRoute
-      }`,
+        this.config.healthCheckRoute || Globals.Listener_HTTP_DefaultHealthCheckRoute
+      }`
     )
     this.app
-      .route(
-        this.config.healthCheckRoute ||
-          Globals.Listener_HTTP_DefaultHealthCheckRoute,
-      )
+      .route(this.config.healthCheckRoute || Globals.Listener_HTTP_DefaultHealthCheckRoute)
       .get(HealthHandler)
     //Main route -- We use a wildcard route because is not the job of the runtime and neither
     //the task to deny/constrain routes that invoked this task; all the job is done by the
     //load balancer and we just foward everything we have to the function.
-    this.app
-      .route(Globals.Listener_HTTP_ProxyRoute)
-      .all(GenericHandler(this.serverlessHandler))
+    this.app.route(Globals.Listener_HTTP_ProxyRoute).all(GenericHandler(this.serverlessHandler))
   }
 }

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

@@ -1,28 +1,16 @@
-import * as unflatten from "unflatten"
-// https://aws.amazon.com/blogs/compute/support-for-multi-value-parameters-in-amazon-api-gateway/
-// (rawHeaders: Array<string>): { [string]: Array<string> }
-export function parseMultiValueHeaders(rawHeaders) {
-  if (rawHeaders.length === 0) return null
-  //
-  const map = new Map()
-  const unflattened = unflatten(rawHeaders, 2)
-  // eslint-disable-next-line no-restricted-syntax
-  for (const key of Object.keys(unflattened)) {
-    const item = map.get(key)
-    if (item) item.push(unflattened[key])
-    else map.set(key, [unflattened[key]])
-  }
-  return Object.fromEntries(map)
-}
-// https://aws.amazon.com/blogs/compute/support-for-multi-value-parameters-in-amazon-api-gateway/
-// [ [ 'petType', 'dog' ], [ 'petType', 'fish' ] ]
-// => { petType: [ 'dog', 'fish' ] },
-export function parseMultiValueQueryStringParameters(url) {
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @param {string} url
+ * @returns {*}
+ */
+export function parseMultiValueQueryStringParameters(url: string) {
   // dummy placeholder url for the WHATWG URL constructor
   // https://github.com/nodejs/node/issues/12682
-  const { searchParams } = new URL(url, "http://example")
+  const { searchParams } = new URL(url, 'http://example')
   //
-  if (Array.from(searchParams).length === 0) return null
+  if (Array.from(searchParams).length === 0) return {}
   const map = new Map()
   // eslint-disable-next-line no-restricted-syntax
   for (const [key, value] of searchParams) {
@@ -32,14 +20,17 @@ export function parseMultiValueQueryStringParameters(url) {
   }
   return Object.fromEntries(map)
 }
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @param {*} url
+ * @returns {*}
+ */
 export function parseQueryStringParameters(url) {
   // dummy placeholder url for the WHATWG URL constructor
   // https://github.com/nodejs/node/issues/12682
-  const { searchParams } = new URL(url, "http://example")
+  const { searchParams } = new URL(url, 'http://example')
   if (Array.from(searchParams).length === 0) return null
   return Object.fromEntries(searchParams)
 }
-//
-export function nullIfEmpty(obj) {
-  return obj && (Object.keys(obj).length > 0 ? obj : null)
-}

package/src/Validation/Validator.ts

@@ -1,27 +1,43 @@
-import { z } from "zod"
+import { z } from 'zod'
 
-import Response, { ResponseErrorType } from "../API/Response"
-import Globals from "../Globals"
+import Response, { ResponseErrorType } from '../API/Response'
+import Globals from '../Globals'
 
+/**
+ * Description placeholder
+ *
+ * @export
+ * @class Validator
+ * @typedef {Validator}
+ */
 export default class Validator {
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @param {*} data
+   * @param {z.ZodObject<any>} schema
+   * @returns {(boolean | Response<ResponseErrorType>)}
+   */
   public static validateSchema(
     data: any,
-    schema: z.ZodObject<any>,
+    schema: z.ZodObject<any>
   ): boolean | Response<ResponseErrorType> {
     let error, validatedInput
     // Validate body against known zod schema
     try {
       validatedInput = schema.parse(data) as typeof schema
     } catch (err: z.ZodError | any) {
-      if (err.message) error = err.message
-      else error = "Unknown validation error!"
+      if (err instanceof z.ZodError) error = JSON.parse(err.message)
+      else error = 'Unknown validation error!' //unhandled case, hard to test
     }
     // Error validation
     if (!validatedInput || error) {
       return Response.BadRequestResponse(
         Globals.ErrorResponseValidationFail,
         Globals.ErrorCode_InvalidInput,
-        { validationFailure: error },
+        { validationFailure: error }
       )
     } else {
       return true