@creator.co/wapi 1.2.1-beta6 → 1.2.2

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

@@ -10,27 +10,29 @@ import Server from "../Server"
 export default (serverlessHandler: Server["handleServerlessEvent"]) => {
   return async (request: Request, res: Response) => {
     const startTime = Date.now()
-    let resp = null
     try {
       // Generate event with request stuff (http to serverless translation)
       const event = new GenericHandlerEvent(request, serverlessHandler)
       // Invoke
       const invokationResp = await event.invoke()
       // Respond
-      resp = processServerlessResponse(invokationResp, res)
+      processServerlessResponse(invokationResp, res)
     } catch (e) {
       console.error("[Proxy] - Exception during execution!", e)
       console.error(e.stack)
-      resp = res.status(Globals.Resp_STATUSCODE_EXCEPTION).json({
+      res.status(Globals.Resp_STATUSCODE_EXCEPTION).json({
         ...e,
         err: Globals.Resp_MSG_EXCEPTION,
         errCode: Globals.Resp_CODE_EXCEPTION,
       })
     }
     console.debug(`[Proxy] - Request took ${Date.now() - startTime}ms`)
-    return resp
   }
 }
+/**
+ * ${1:Description placeholder}
+ *
+ **/
 const processServerlessResponse = (
   invokation: GenericHandlerEventResponse,
   res: Response,
@@ -47,7 +49,7 @@ const processServerlessResponse = (
     })
   } else {
     // Check for headers
-    if (invokation?.data?.headers) {
+    if (invokation.data.headers) {
       for (const hKey of Object.keys(invokation.data.headers)) {
         res.header(hKey, invokation.data.headers[hKey])
       }

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

@@ -1,22 +1,51 @@
 import type { APIGatewayProxyEvent, Context } from "aws-lambda"
 import * as cuid from "cuid"
 import { Request } from "express"
-import * as unflatten from "unflatten"
 
 import {
-  parseMultiValueHeaders,
   parseMultiValueQueryStringParameters,
   parseQueryStringParameters,
-  nullIfEmpty,
 } 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
+  /**
+   * ${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"],
@@ -24,6 +53,13 @@ export default class GenericHandlerEvent {
     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) => {
@@ -44,24 +80,24 @@ 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 || [] : [],
-      ),
+      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,
@@ -89,11 +125,9 @@ export default class GenericHandlerEvent {
           principalOrgId: null,
           sourceIp:
             <string>this.request.headers?.["x-forwarded-for"] ||
-            this.request.socket.remoteAddress,
+            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,
@@ -109,6 +143,14 @@ 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,

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

@@ -1,5 +1,5 @@
 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

@@ -11,12 +11,59 @@ 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
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {Server["handleServerlessEvent"]}
+   */
   private readonly serverlessHandler: Server["handleServerlessEvent"]
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {HTTPServer}
+   */
   private listener: HTTPServer
+  /**
+   * Creates an instance of Proxy.
+   *
+   * @constructor
+   * @param {RouterConfig} config
+   * @param {Server["handleServerlessEvent"]} serverlessHandler
+   */
   constructor(
     config: RouterConfig,
     serverlessHandler: Server["handleServerlessEvent"],
@@ -34,11 +81,9 @@ export default class Proxy {
       cors(
         corsConfig
           ? {
-              options: {
-                origin: corsConfig?.origin,
-                allowedHeaders: corsConfig?.headers,
-                credentials: !!corsConfig?.allowCredentials,
-              },
+              origin: corsConfig.origin,
+              allowedHeaders: corsConfig.headers,
+              credentials: !!corsConfig.allowCredentials,
             }
           : {},
       ),
@@ -52,14 +97,34 @@ 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) => {
       const port = this.config.port || Globals.Listener_HTTP_DefaultPort
@@ -77,17 +142,33 @@ 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)
+    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.

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")
   //
-  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,6 +20,13 @@ 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
@@ -39,7 +34,3 @@ export function parseQueryStringParameters(url) {
   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

@@ -3,7 +3,23 @@ import { z } from "zod"
 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>,
@@ -13,8 +29,8 @@ export default class Validator {
     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) {

package/tests/API/Request.test.ts

@@ -0,0 +1,263 @@
+import { APIGatewayEvent, Context } from "aws-lambda"
+import { expect } from "chai"
+
+import Request from "../../src/API/Request"
+import Logger from "../../src/Logger/Logger"
+
+function newReq(event: any, context?: any) {
+  const logger = new Logger(
+    {
+      logLevel: "DEBUG",
+    },
+    "123-456",
+  )
+  return new Request(
+    <APIGatewayEvent>(<unknown>event),
+    <Context>context ? context : {},
+    logger,
+  )
+}
+
+describe("Request querystring", () => {
+  test("Null query string", () => {
+    const r = newReq({
+      queryStringParameters: null,
+    })
+    expect(r.containsQueryParam("123")).to.be.false
+    expect(r.getQueryParam("123")).to.be.null
+  })
+
+  test("Empty query string", () => {
+    const r = newReq({
+      queryStringParameters: {},
+    })
+    expect(r.containsQueryParam("123")).to.be.false
+    expect(r.getQueryParam("123")).to.be.null
+  })
+
+  test("Valid query string", () => {
+    const r = newReq({
+      queryStringParameters: { "123": "abc" },
+    })
+    expect(r.containsQueryParam("123")).to.be.true
+    expect(r.getQueryParam("123")).to.be.equals("abc")
+  })
+
+  test("Valid query string number", () => {
+    const r = newReq({
+      queryStringParameters: { "123": 456 },
+    })
+    expect(r.containsQueryParam("123")).to.be.true
+    expect(r.getQueryParam("123")).to.be.equals(456)
+  })
+})
+
+describe("Request headers", () => {
+  test("Null headers", () => {
+    const r = newReq({ headers: null })
+    expect(r.getHeader("123")).to.be.null
+  })
+
+  test("Empty headers", () => {
+    const r = newReq({ headers: {} })
+    expect(r.getHeader("123")).to.be.null
+  })
+
+  test("Valid headers", () => {
+    const r = newReq({ headers: { "123": "abc" } })
+    expect(r.getHeader("123")).to.be.equals("abc")
+  })
+
+  test("Auth headers", () => {
+    const r = newReq({ headers: { Authorization: "abc" } })
+    expect(r.getAuthorizationHeader()).to.be.equals("abc")
+  })
+})
+
+describe("Request context", () => {
+  test("Null context", () => {
+    const r = newReq({ requestContext: null })
+    expect(r.getContextParam("123")).to.be.null
+  })
+
+  test("Empty context", () => {
+    const r = newReq({ requestContext: {} })
+    expect(r.getContextParam("123")).to.be.null
+  })
+
+  test("Valid context", () => {
+    const r = newReq({
+      requestContext: { "123": "abc" },
+    })
+    expect(r.getContextParam("123")).to.be.equals("abc")
+  })
+})
+
+describe("Request path params", () => {
+  test("Null path params", () => {
+    const r = newReq({ pathParameters: null })
+    expect(r.containsPathParam("123")).to.be.false
+    expect(r.getPathParam("123")).to.be.null
+    expect(r.getPathParams()).to.be.null
+  })
+
+  test("Empty path params", () => {
+    const r = newReq({ pathParameters: {} })
+    expect(r.containsPathParam("123")).to.be.false
+    expect(r.getPathParam("123")).to.be.null
+    expect(r.getPathParams()).to.be.deep.equal({})
+  })
+
+  test("Valid path params", () => {
+    const v = { "123": "abc" }
+    const r = newReq({
+      pathParameters: v,
+    })
+    expect(r.containsPathParam("123")).to.be.true
+    expect(r.getPathParam("123")).to.be.equals("abc")
+    expect(r.getPathParams()).to.be.deep.equal(v)
+  })
+
+  test("Valid path param number", () => {
+    const v = { "123": 456 }
+    const r = newReq({
+      pathParameters: v,
+    })
+    expect(r.containsPathParam("123")).to.be.true
+    expect(r.getPathParam("123")).to.be.equals(456)
+    expect(r.getPathParams()).to.be.deep.equal(v)
+  })
+
+  test("Fix path params", () => {
+    const v = { "123": "abc" }
+    const r = newReq({ pathParameters: null })
+    r.setFixedPathParams(
+      Object.keys(v).map((k) => ({ name: k })),
+      ["/"].concat(Object.values(v)),
+    )
+    expect(r.containsPathParam("123")).to.be.true
+    expect(r.getPathParam("123")).to.be.equals("abc")
+    expect(r.getPathParams()).to.be.deep.equal(v)
+  })
+})
+
+describe("Request body", () => {
+  test("Null body", () => {
+    const r = newReq({ body: null })
+    expect(r.getBody()).to.be.null
+  })
+
+  test("Empty body", () => {
+    const r = newReq({ body: {} })
+    expect(r.getBody()).to.be.deep.equals({})
+  })
+
+  test("Empty string body", () => {
+    const r = newReq({ body: "{}" })
+    expect(r.getBody()).to.be.deep.equals({})
+  })
+
+  test("Broken json string body", () => {
+    const r = newReq({ body: '{name": "Joe"}' })
+    expect(r.getBody()).to.be.equals('{name": "Joe"}')
+  })
+
+  test("Valid string body", () => {
+    const r = newReq({ body: '{"name": "Joe"}' })
+    expect(r.getBody()).to.be.deep.equals({
+      name: "Joe",
+    })
+  })
+
+  test("Valid json body", () => {
+    const r = newReq({ body: { name: "Joe" } })
+    expect(r.getBody()).to.be.deep.equals({
+      name: "Joe",
+    })
+  })
+})
+
+describe("Request path/method", () => {
+  test("Null path/method", () => {
+    const r = newReq({
+      path: null,
+      httpMethod: null,
+    })
+    expect(r.getPath()).to.be.null
+    expect(r.getMethod()).to.be.null
+  })
+
+  test("Empty path/method", () => {
+    const r = newReq({
+      path: "",
+      httpMethod: "",
+    })
+    expect(r.getPath()).to.be.a("string")
+    expect(r.getPath()).to.be.equals("")
+    expect(r.getMethod()).to.be.a("string")
+    expect(r.getMethod()).to.be.equals("")
+  })
+
+  test("Valid method/path", () => {
+    const r = newReq({
+      path: "/root",
+      httpMethod: "GET",
+    })
+    expect(r.getPath()).to.be.a("string")
+    expect(r.getPath()).to.be.equals("/root")
+    expect(r.getMethod()).to.be.a("string")
+    expect(r.getMethod()).to.be.equals("GET")
+  })
+})
+
+describe("Request ID", () => {
+  test("From context", () => {
+    const r = newReq({}, { awsRequestId: "123" })
+    expect(r.getRequestID()).to.not.be.null
+    expect(r.getRequestID()).to.be.equals("123")
+  })
+
+  test("From event", () => {
+    const r = newReq({
+      requestContext: { requestId: "123" },
+    })
+    expect(r.getRequestID()).to.not.be.null
+    expect(r.getRequestID()).to.be.equals("123")
+  })
+
+  test("unknown", () => {
+    const r = newReq({})
+    expect(r.getRequestID()).to.not.be.null
+    expect(r.getRequestID()).to.be.equals("unknown")
+  })
+})
+
+describe("Request origin IP", () => {
+  test("From context", () => {
+    const r = newReq({
+      requestContext: {
+        identity: { sourceIp: "127.0.0.1" },
+      },
+    })
+    expect(r.getOriginIP()).to.not.be.null
+    expect(r.getOriginIP()).to.be.equals("127.0.0.1")
+  })
+
+  test("From header", () => {
+    const r = newReq({
+      headers: {
+        "X-Forwarded-For": "127.0.0.1",
+      },
+    })
+    expect(r.getOriginIP()).to.not.be.null
+    expect(r.getOriginIP()).to.be.equals("127.0.0.1")
+  })
+
+  test("unknown", () => {
+    const r = newReq({})
+    expect(r.getOriginIP()).to.not.be.null
+    expect(r.getOriginIP()).to.be.equals("unknown")
+  })
+})
+
+export {}