@creator.co/wapi 1.2.2 → 1.2.4

package/src/Publisher/Publisher.ts

@@ -3,8 +3,8 @@ import {
   PublishCommand,
   PublishCommandOutput,
   PublishCommandInput,
-} from "@aws-sdk/client-sns"
-import * as sha1 from "sha1"
+} from '@aws-sdk/client-sns'
+import * as sha1 from 'sha1'
 //reusable client
 // eslint-disable-next-line no-var
 /**
@@ -71,7 +71,7 @@ export default class Publisher {
   async publishOnTopic(
     messageObject: any,
     topic: string,
-    additionalProps?: object,
+    additionalProps?: object
   ): Promise<PublishCommandOutput> {
     let resp: null | PublishCommandOutput = null
     try {
@@ -84,11 +84,9 @@ export default class Publisher {
       }
       resp = await PUBLISHER_CONN.send(new PublishCommand(params))
     } catch (e) {
-      console.error(
-        `Error while publishing into topic ${topic} with error: ${e}`,
-      )
+      console.error(`Error while publishing into topic ${topic} with error: ${e}`)
     }
-    console.debug("Publisher resp", resp)
+    console.debug('Publisher resp', resp)
     return resp
   }
   /* Private */
@@ -96,12 +94,9 @@ export default class Publisher {
    * ${1:Description placeholder}
    */
   _connect() {
-    if (
-      (!PUBLISHER_CONN && !PUBLISHER_CONN_HASH) ||
-      PUBLISHER_CONN_HASH != sha1(this.region)
-    ) {
+    if ((!PUBLISHER_CONN && !PUBLISHER_CONN_HASH) || PUBLISHER_CONN_HASH != sha1(this.region)) {
       PUBLISHER_CONN = new SNSClient({
-        apiVersion: "2010-03-31",
+        apiVersion: '2010-03-31',
         region: this.region,
       })
       PUBLISHER_CONN_HASH = sha1(this.region).toString()

package/src/Server/RouteResolver.ts

@@ -1,4 +1,4 @@
-import { Route, RouterConfig } from "./Router"
+import { Route, RouterConfig } from './Router'
 
 /**
  * ${1:Description placeholder}
@@ -48,7 +48,7 @@ class Routes {
   public addRoute(route: Route, parts: string[]): void {
     const first = parts.shift()
     if (first) {
-      if (first.startsWith(":")) {
+      if (first.startsWith(':')) {
         this.variable = this.variable || new Routes()
         this.variable.addRoute(route, parts)
       } else {
@@ -56,8 +56,7 @@ class Routes {
         this.next[first].addRoute(route, parts)
       }
     } else {
-      if (this.current)
-        throw new Error(`Duplicate route: ${route.method}: ${route.path}`)
+      if (this.current) throw new Error(`Duplicate route: ${route.method}: ${route.path}`)
 
       this.current = route
     }
@@ -119,7 +118,7 @@ export default class RouteResolver {
    */
   public resolveRoute(method: string, path: string): Route | undefined {
     method = method.toLowerCase()
-    const parts = path.split("/").filter((p) => p.length)
+    const parts = path.split('/').filter(p => p.length)
 
     return this.routes[method]?.resolveRoute(parts)
   }
@@ -133,7 +132,7 @@ export default class RouteResolver {
   private buildRoutes(config: RouterConfig): void {
     for (const route of config.routes) {
       const method = route.method.toLowerCase()
-      const parts = route.path.split("/").filter((p) => p.length)
+      const parts = route.path.split('/').filter(p => p.length)
 
       this.routes[method] = this.routes[method] || new Routes()
       this.routes[method].addRoute(route, parts)

package/src/Server/Router.ts

@@ -1,13 +1,10 @@
-import { z } from "zod"
+import { z } from 'zod'
 
-import ContainerServer from "./lib/ContainerServer"
-import Server from "./lib/Server"
-import { ResponseErrorType } from "../API/Response"
-import Utils from "../API/Utils"
-import Transaction, {
-  TransactionConfig,
-  TransactionExecution,
-} from "../BaseEvent/Transaction"
+import ContainerServer from './lib/ContainerServer'
+import Server from './lib/Server'
+import { ResponseErrorType } from '../API/Response'
+import Utils from '../API/Utils'
+import Transaction, { TransactionConfig, TransactionExecution } from '../BaseEvent/Transaction'
 
 // Route
 /**
@@ -110,9 +107,7 @@ export default class Router {
    */
   constructor(config: RouterConfig) {
     this.config = config
-    this.server = this.isContainer()
-      ? new ContainerServer(config)
-      : new Server(config)
+    this.server = this.isContainer() ? new ContainerServer(config) : new Server(config)
   }
   /**
    * Description placeholder

package/src/Server/lib/ContainerServer.ts

@@ -1,6 +1,6 @@
-import Proxy from "./container/Proxy"
-import Server from "./Server"
-import { RouterConfig } from "../Router"
+import Proxy from './container/Proxy'
+import Server from './Server'
+import { RouterConfig } from '../Router'
 
 /**
  * ${1:Description placeholder}
@@ -71,7 +71,7 @@ export default class ContainerServer extends Server {
    */
   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
+    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
   }
 }

package/src/Server/lib/Server.ts

@@ -1,12 +1,12 @@
-import { APIGatewayProxyEvent, Context } from "aws-lambda"
-import * as pathToRegexp from "path-to-regexp"
+import { APIGatewayProxyEvent, Context } from 'aws-lambda'
+import * as pathToRegexp from 'path-to-regexp'
 
-import Request from "../../API/Request"
-import Response from "../../API/Response"
-import Transaction from "../../BaseEvent/Transaction"
-import Validator from "../../Validation/Validator"
-import { RouterConfig } from "../Router"
-import RouteResolver from "../RouteResolver"
+import Request from '../../API/Request'
+import Response from '../../API/Response'
+import Transaction from '../../BaseEvent/Transaction'
+import Validator from '../../Validation/Validator'
+import { RouterConfig } from '../Router'
+import RouteResolver from '../RouteResolver'
 
 /**
  * ${1:Description placeholder}
@@ -63,38 +63,26 @@ export default class Server {
    * @param {Context} context
    * @returns {*}
    */
-  public async handleServerlessEvent(
-    event: APIGatewayProxyEvent,
-    context: Context,
-  ) {
+  public async handleServerlessEvent(event: APIGatewayProxyEvent, context: Context) {
     // init transaction
-    await new Transaction(event, context, this.config).execute(
-      async (transaction) => {
-        const request = transaction.request
-        const route = this.routeResolver.resolveRoute(
-          request.getMethod(),
-          request.getPath(),
-        )
-        if (route) {
-          transaction.logger.log("Router accepted route:", route.path)
-          // Validate input
-          if (route.inputSchema) {
-            const validationResp = Validator.validateSchema(
-              request.getBody(),
-              route.inputSchema,
-            )
-            if (validationResp && validationResp instanceof Response)
-              return validationResp
-          }
-
-          this.parsePathParams(request, route.path)
-          // Continue to route handler
-          return await route.handler(transaction)
+    await new Transaction(event, context, this.config).execute(async transaction => {
+      const request = transaction.request
+      const route = this.routeResolver.resolveRoute(request.getMethod(), request.getPath())
+      if (route) {
+        transaction.logger.log('Router accepted route:', route.path)
+        // Validate input
+        if (route.inputSchema) {
+          const validationResp = Validator.validateSchema(request.getBody(), route.inputSchema)
+          if (validationResp && validationResp instanceof Response) return validationResp
         }
-        //No route found :/
-        return new Response(404, { err: "Route not found!" })
-      },
-    )
+
+        this.parsePathParams(request, route.path)
+        // Continue to route handler
+        return await route.handler(transaction)
+      }
+      //No route found :/
+      return new Response(404, { err: 'Route not found!' })
+    })
   }
 
   /**

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

@@ -1,13 +1,11 @@
-import { Request, Response } from "express"
+import { Request, Response } from 'express'
 
-import GenericHandlerEvent, {
-  GenericHandlerEventResponse,
-} from "./GenericHandlerEvent"
-import Utils from "../../../API/Utils"
-import Globals from "../../../Globals"
-import Server from "../Server"
+import GenericHandlerEvent, { GenericHandlerEventResponse } from './GenericHandlerEvent'
+import Utils from '../../../API/Utils'
+import Globals from '../../../Globals'
+import Server from '../Server'
 
-export default (serverlessHandler: Server["handleServerlessEvent"]) => {
+export default (serverlessHandler: Server['handleServerlessEvent']) => {
   return async (request: Request, res: Response) => {
     const startTime = Date.now()
     try {
@@ -18,7 +16,7 @@ export default (serverlessHandler: Server["handleServerlessEvent"]) => {
       // Respond
       processServerlessResponse(invokationResp, res)
     } catch (e) {
-      console.error("[Proxy] - Exception during execution!", e)
+      console.error('[Proxy] - Exception during execution!', e)
       console.error(e.stack)
       res.status(Globals.Resp_STATUSCODE_EXCEPTION).json({
         ...e,
@@ -33,10 +31,7 @@ export default (serverlessHandler: Server["handleServerlessEvent"]) => {
  * ${1:Description placeholder}
  *
  **/
-const processServerlessResponse = (
-  invokation: GenericHandlerEventResponse,
-  res: Response,
-) => {
+const processServerlessResponse = (invokation: GenericHandlerEventResponse, res: Response) => {
   // translate answer to http layer
   if (invokation && invokation.err) {
     // err came

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

@@ -1,13 +1,10 @@
-import type { APIGatewayProxyEvent, Context } from "aws-lambda"
-import * as cuid from "cuid"
-import { Request } from "express"
+import type { APIGatewayProxyEvent, Context } from 'aws-lambda'
+import * as cuid from 'cuid'
+import { Request } from 'express'
 
-import {
-  parseMultiValueQueryStringParameters,
-  parseQueryStringParameters,
-} 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}
@@ -38,7 +35,7 @@ export default class GenericHandlerEvent {
    * @public
    * @type {Server["handleServerlessEvent"]}
    */
-  public serverlessHandler: Server["handleServerlessEvent"]
+  public serverlessHandler: Server['handleServerlessEvent']
   /**
    * Creates an instance of GenericHandlerEvent.
    *
@@ -46,10 +43,7 @@ export default class GenericHandlerEvent {
    * @param {Request} request
    * @param {Server["handleServerlessEvent"]} serverlessHandler
    */
-  constructor(
-    request: Request,
-    serverlessHandler: Server["handleServerlessEvent"],
-  ) {
+  constructor(request: Request, serverlessHandler: Server['handleServerlessEvent']) {
     this.request = request
     this.serverlessHandler = serverlessHandler
   }
@@ -66,12 +60,9 @@ export default class GenericHandlerEvent {
       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) {
@@ -93,9 +84,7 @@ export default class GenericHandlerEvent {
       httpMethod: this.request.method?.toUpperCase(),
       isBase64Encoded: false,
       multiValueHeaders: <any>(this.request.headers || {}),
-      multiValueQueryStringParameters: parseMultiValueQueryStringParameters(
-        this.request.url,
-      ),
+      multiValueQueryStringParameters: parseMultiValueQueryStringParameters(this.request.url),
       path: this.request.path,
       pathParameters: null,
       queryStringParameters: this.request.query
@@ -108,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,
@@ -124,14 +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?.["user-agent"],
+          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(),
@@ -153,7 +139,7 @@ export default class GenericHandlerEvent {
    */
   private buildContext(
     event: APIGatewayProxyEvent,
-    callback: (err?: Error | string, data?: any) => void,
+    callback: (err?: Error | string, data?: any) => void
   ): Context {
     return {
       awsRequestId: event.requestContext.requestId,
@@ -162,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) => {
-  res.send("Healthy!")
+  res.send('Healthy!')
 }

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

@@ -1,15 +1,15 @@
-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}
@@ -49,7 +49,7 @@ export default class Proxy {
    * @readonly
    * @type {Server["handleServerlessEvent"]}
    */
-  private readonly serverlessHandler: Server["handleServerlessEvent"]
+  private readonly serverlessHandler: Server['handleServerlessEvent']
   /**
    * ${1:Description placeholder}
    *
@@ -64,10 +64,7 @@ export default class Proxy {
    * @param {RouterConfig} config
    * @param {Server["handleServerlessEvent"]} serverlessHandler
    */
-  constructor(
-    config: RouterConfig,
-    serverlessHandler: Server["handleServerlessEvent"],
-  ) {
+  constructor(config: RouterConfig, serverlessHandler: Server['handleServerlessEvent']) {
     this.stopping = false
     this.config = config
     this.serverlessHandler = serverlessHandler
@@ -75,8 +72,7 @@ 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
@@ -85,8 +81,8 @@ export default class Proxy {
               allowedHeaders: corsConfig.headers,
               credentials: !!corsConfig.allowCredentials,
             }
-          : {},
-      ),
+          : {}
+      )
     )
 
     // //This supposedly fix some 502 codes where nodejs socket would hang during
@@ -126,15 +122,13 @@ export default class Proxy {
    * @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]`)
@@ -153,11 +147,11 @@ export default class Proxy {
   private async stopListeners(err?: any) {
     if (this.stopping) return
     this.stopping = true
-    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]")
+    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)
       })
@@ -174,21 +168,15 @@ export default class Proxy {
     //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

@@ -8,7 +8,7 @@
 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 {}
   const map = new Map()
@@ -30,7 +30,7 @@ export function parseMultiValueQueryStringParameters(url: string) {
 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)
 }

package/src/Validation/Validator.ts

@@ -1,7 +1,7 @@
-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
@@ -22,7 +22,7 @@ export default class Validator {
    */
   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
@@ -30,14 +30,14 @@ export default class Validator {
       validatedInput = schema.parse(data) as typeof schema
     } catch (err: z.ZodError | any) {
       if (err instanceof z.ZodError) error = JSON.parse(err.message)
-      else error = "Unknown validation error!" //unhandled case, hard to test
+      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