@creator.co/wapi 1.2.1-beta6 → 1.2.3

package/src/Publisher/Publisher.ts

@@ -3,20 +3,55 @@ 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
-var PUBLISHER_CONN: SNSClient | null = null
+/**
+ * ${1:Description placeholder}
+ *
+ * @type {(SNSClient | null)}
+ */
+let PUBLISHER_CONN: SNSClient | null = null
 // eslint-disable-next-line no-var
-var PUBLISHER_CONN_HASH: string | null = null
+/**
+ * ${1:Description placeholder}
+ *
+ * @type {(string | null)}
+ */
+let PUBLISHER_CONN_HASH: string | null = null
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @typedef {PublisherConfig}
+ */
 export type PublisherConfig = {
   region?: string
 }
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Publisher
+ * @typedef {Publisher}
+ */
 export default class Publisher {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {string}
+   */
   private region: string
+  /**
+   * Creates an instance of Publisher.
+   *
+   * @constructor
+   * @param {?PublisherConfig} [config]
+   */
   constructor(config?: PublisherConfig) {
     if (config && config.region) {
       this.region = config.region
@@ -24,10 +59,19 @@ export default class Publisher {
     }
   }
   /* Public */
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @param {*} messageObject
+   * @param {string} topic
+   * @param {?object} [additionalProps]
+   * @returns {Promise<PublishCommandOutput>}
+   */
   async publishOnTopic(
     messageObject: any,
     topic: string,
-    additionalProps?: object,
+    additionalProps?: object
   ): Promise<PublishCommandOutput> {
     let resp: null | PublishCommandOutput = null
     try {
@@ -38,24 +82,21 @@ export default class Publisher {
         TopicArn: topic,
         ...(additionalProps ? additionalProps : {}),
       }
-      if (PUBLISHER_CONN)
-        resp = await PUBLISHER_CONN.send(new PublishCommand(params))
+      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 */
+  /**
+   * ${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

@@ -0,0 +1,141 @@
+import { Route, RouterConfig } from './Router'
+
+/**
+ * ${1:Description placeholder}
+ *
+ * @class Routes
+ * @typedef {Routes}
+ */
+class Routes {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {?Route}
+   */
+  private current?: Route
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {?Routes}
+   */
+  private variable?: Routes
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {{ [k: string]: Routes }\}
+   */
+  private readonly next: { [k: string]: Routes }
+  /**
+   * Creates an instance of Routes.
+   *
+   * @constructor
+   */
+  constructor() {
+    this.next = {}
+  }
+
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {Route} route
+   * @param {string[]} parts
+   */
+  public addRoute(route: Route, parts: string[]): void {
+    const first = parts.shift()
+    if (first) {
+      if (first.startsWith(':')) {
+        this.variable = this.variable || new Routes()
+        this.variable.addRoute(route, parts)
+      } else {
+        this.next[first] = this.next[first] || new Routes()
+        this.next[first].addRoute(route, parts)
+      }
+    } else {
+      if (this.current) throw new Error(`Duplicate route: ${route.method}: ${route.path}`)
+
+      this.current = route
+    }
+  }
+
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string[]} parts
+   * @returns {Route}
+   */
+  public resolveRoute(parts: string[]): Route {
+    const first = parts.shift()
+    if (first) {
+      if (first in this.next) {
+        return this.next[first].resolveRoute(parts)
+      }
+      return this.variable?.resolveRoute(parts)
+    }
+    return this.current
+  }
+}
+
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class RouteResolver
+ * @typedef {RouteResolver}
+ */
+export default class RouteResolver {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {{ [method: string]: Routes }\}
+   */
+  private routes: { [method: string]: Routes }
+
+  /**
+   * Creates an instance of RouteResolver.
+   *
+   * @constructor
+   * @param {RouterConfig} config
+   */
+  constructor(readonly config: RouterConfig) {
+    this.routes = {}
+    this.buildRoutes(config)
+  }
+
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} method
+   * @param {string} path
+   * @returns {(Route | undefined)}
+   */
+  public resolveRoute(method: string, path: string): Route | undefined {
+    method = method.toLowerCase()
+    const parts = path.split('/').filter(p => p.length)
+
+    return this.routes[method]?.resolveRoute(parts)
+  }
+
+  /**
+   * Description placeholder
+   *
+   * @private
+   * @param {RouterConfig} config
+   */
+  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)
+
+      this.routes[method] = this.routes[method] || new Routes()
+      this.routes[method].addRoute(route, parts)
+    }
+  }
+}

package/src/Server/Router.ts

@@ -1,17 +1,33 @@
-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
+/**
+ * Description placeholder
+ *
+ * @export
+ * @interface Route
+ * @typedef {Route}
+ * @template [InputType=any]
+ * @template [OutputType=any]
+ */
 export interface Route<InputType = any, OutputType = any> {
+  /**
+   * Description placeholder
+   *
+   * @type {string}
+   */
   path: string
+  /**
+   * Description placeholder
+   *
+   * @type {string}
+   */
   method: string
   /* If you are here to know why implementing this method
     does not auto infer the param type, check long discussion on TS 
@@ -19,14 +35,33 @@ export interface Route<InputType = any, OutputType = any> {
     - https://github.com/microsoft/TypeScript/issues/23911#issuecomment-1351020050 (proposed solution)
     - https://github.com/microsoft/TypeScript/issues/10570
   */
+  /**
+   * Description placeholder
+   *
+   * @type {TransactionExecution<
+   *     Transaction<InputType, OutputType | ResponseErrorType>,
+   *     OutputType | ResponseErrorType
+   *   >}
+   */
   handler: TransactionExecution<
     Transaction<InputType, OutputType | ResponseErrorType>,
     OutputType | ResponseErrorType
   >
+  /**
+   * Description placeholder
+   *
+   * @type {?z.ZodObject<any>}
+   */
   inputSchema?: z.ZodObject<any>
 }
 
 // Config
+/**
+ * Description placeholder
+ *
+ * @export
+ * @typedef {RouterConfig}
+ */
 export type RouterConfig = TransactionConfig & {
   routes: Route[]
   // container based configs - otherwise enforced by serverless engine
@@ -40,18 +75,55 @@ export type RouterConfig = TransactionConfig & {
   healthCheckRoute?: string
 }
 
+/**
+ * Description placeholder
+ *
+ * @export
+ * @class Router
+ * @typedef {Router}
+ */
 export default class Router {
+  /**
+   * Description placeholder
+   *
+   * @private
+   * @readonly
+   * @type {RouterConfig}
+   */
   private readonly config: RouterConfig
+  /**
+   * Description placeholder
+   *
+   * @private
+   * @readonly
+   * @type {Server}
+   */
   private readonly server: Server
+  /**
+   * Creates an instance of Router.
+   *
+   * @constructor
+   * @param {RouterConfig} config
+   */
   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
+   *
+   * @public
+   * @returns {CallableFunction}
+   */
   public getExport(): CallableFunction {
     return this.server.getExport()
   }
+  /**
+   * Description placeholder
+   *
+   * @private
+   * @returns {boolean}
+   */
   private isContainer(): boolean {
     return Utils.isHybridlessContainer()
   }

package/src/Server/lib/ContainerServer.ts

@@ -1,14 +1,41 @@
-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}
+ *
+ * @export
+ * @class ContainerServer
+ * @typedef {ContainerServer}
+ * @extends {Server}
+ */
 export default class ContainerServer extends Server {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @protected
+   * @readonly
+   * @type {Proxy}
+   */
   protected readonly proxy: Proxy
+  /**
+   * Creates an instance of ContainerServer.
+   *
+   * @constructor
+   * @param {RouterConfig} config
+   */
   constructor(config: RouterConfig) {
     super(config)
     this.proxy = new Proxy(config, this.handleServerlessEvent.bind(this))
     this.listenProcessEvents()
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {CallableFunction}
+   */
   public getExport(): CallableFunction {
     // start server socket
     this.start()
@@ -16,15 +43,35 @@ export default class ContainerServer extends Server {
     return () => {}
   }
   /* private */
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @returns {*}
+   */
   public async start() {
     await this.proxy.load()
   }
-  public async stop(err) {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @param {?*} [err]
+   * @returns {*}
+   */
+  public async stop(err?: any) {
     await this.proxy.unload(err)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   */
   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,73 +1,101 @@
-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 Response from "../../API/Response"
-import Transaction from "../../BaseEvent/Transaction"
-import Validator from "../../Validation/Validator"
-import { RouterConfig } from "../Router"
+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}
+ *
+ * @export
+ * @class Server
+ * @typedef {Server}
+ */
 export default class Server {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @protected
+   * @readonly
+   * @type {RouterConfig}
+   */
   protected readonly config: RouterConfig
+  /**
+   * ${1:Description placeholder}
+   *
+   * @protected
+   * @readonly
+   * @type {RouteResolver}
+   */
+  protected readonly routeResolver: RouteResolver
+
+  /**
+   * Creates an instance of Server.
+   *
+   * @constructor
+   * @param {RouterConfig} config
+   */
   constructor(config: RouterConfig) {
     this.config = config
+    this.routeResolver = new RouteResolver(config)
   }
 
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {CallableFunction}
+   */
   public getExport(): CallableFunction {
     return this.handleServerlessEvent.bind(this)
   }
 
-  public async handleServerlessEvent(
-    event: APIGatewayProxyEvent,
-    context: Context,
-  ) {
-    const config = this.config
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @param {APIGatewayProxyEvent} event
+   * @param {Context} context
+   * @returns {*}
+   */
+  public async handleServerlessEvent(event: APIGatewayProxyEvent, context: Context) {
     // init transaction
-    await new Transaction(event, context, config).execute(
-      async (transaction) => {
-        for (const route of config.routes) {
-          // Check for possible paths
-          const handler = Server.routeMatches(
-            route.path,
-            route.method,
-            transaction,
-          )
-          if (handler) {
-            transaction.logger.log("Router accepted route:", route.path)
-            // Validate input
-            if (route.inputSchema) {
-              const validationResp = Validator.validateSchema(
-                transaction.request.getBody(),
-                route.inputSchema,
-              )
-              if (validationResp && validationResp instanceof Response)
-                return validationResp
-            }
-            // 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!' })
+    })
   }
-  // Helper function to match route
-  private static routeMatches(
-    routePath: string,
-    routeMethod: string,
-    transaction: Transaction,
-  ): boolean {
-    const path = transaction.request.getPath()
+
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @param {Request<any>} req
+   * @param {string} routePath
+   */
+  private parsePathParams(req: Request<any>, routePath: string) {
+    const path = req.getPath()
     const keys = []
     const result = pathToRegexp(routePath, keys).exec(path)
-    if (result) {
-      const reqMethod = transaction.request.getMethod()
-      if (reqMethod.toLowerCase() == routeMethod.toLowerCase()) {
-        //Fix path params on proxy
-        transaction.request.setFixedPathParams(keys, result)
-        return true
-      }
-    }
-    return false
+    req.setFixedPathParams(keys, result)
   }
 }

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

@@ -1,40 +1,37 @@
-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()
-    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('[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
   }
 }
-const processServerlessResponse = (
-  invokation: GenericHandlerEventResponse,
-  res: Response,
-) => {
+/**
+ * ${1:Description placeholder}
+ *
+ **/
+const processServerlessResponse = (invokation: GenericHandlerEventResponse, res: Response) => {
   // translate answer to http layer
   if (invokation && invokation.err) {
     // err came
@@ -47,7 +44,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])
       }