@creator.co/wapi 1.2.1-beta5 → 1.2.2

package/src/Mailer/Mailer.ts

@@ -4,12 +4,49 @@ import * as Email from "email-templates"
 import * as nodemailer from "nodemailer"
 import type * as SESTransport from "nodemailer/lib/ses-transport"
 
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Mailer
+ * @typedef {Mailer}
+ */
 export default class Mailer {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {string}
+   */
   private readonly from: string
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {string}
+   */
   private readonly templateDefaultFile: string = "html"
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {ReturnType<
+   *     typeof nodemailer.createTransport<SESTransport.SentMessageInfo>
+   *   >}
+   */
   private readonly transporter: ReturnType<
     typeof nodemailer.createTransport<SESTransport.SentMessageInfo>
   >
+  /**
+   * Creates an instance of Mailer.
+   *
+   * @constructor
+   * @param {string} defaultFrom
+   * @param {string} region
+   */
   constructor(defaultFrom: string, region: string) {
     this.from = defaultFrom
     this.transporter = nodemailer.createTransport({
@@ -24,6 +61,21 @@ export default class Mailer {
     })
   }
 
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @param {(string | Array<string>)} to
+   * @param {string} htmlMessage
+   * @param {string} subject
+   * @param {?(string | Array<string>)} [optionalCC]
+   * @param {?string} [optionalFrom]
+   * @param {?string} [optionalReplyTo]
+   * @param {?any[]} [optionalAttachments]
+   * @param {?Email.NodeMailerTransportOptions} [optionalTransport]
+   * @returns {unknown}
+   */
   public async sendRawEmail(
     to: string | Array<string>,
     htmlMessage: string,
@@ -60,6 +112,21 @@ export default class Mailer {
     }
     return resp
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @param {(string | Array<string>)} to
+   * @param {(string | Array<string>)} templates
+   * @param {object} data
+   * @param {?(string | Array<string>)} [optionalCC]
+   * @param {?string} [optionalFrom]
+   * @param {?string} [optionalReplyTo]
+   * @param {?any[]} [optionalAttachments]
+   * @param {?Email.NodeMailerTransportOptions} [optionalTransport]
+   * @returns {unknown}
+   */
   public async sendTemplatedEmail(
     to: string | Array<string>,
     templates: string | Array<string>,
@@ -95,6 +162,16 @@ export default class Mailer {
     }
     return resp
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} host
+   * @param {number} portNumber
+   * @param {string} user
+   * @param {string} password
+   * @returns {Email.NodeMailerTransportOptions}
+   */
   public newSMTPTransporter(
     host: string,
     portNumber: number,
@@ -114,6 +191,15 @@ export default class Mailer {
   }
 
   /* private */
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @async
+   * @param {(string | Array<string>)} templates
+   * @param {object} data
+   * @returns {Promise<string>}
+   */
   private async chooseTemplate(
     templates: string | Array<string>,
     data: object,
@@ -131,6 +217,15 @@ export default class Mailer {
         JSON.stringify(data, null, 2),
     )
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @async
+   * @param {string} template
+   * @param {object} data
+   * @returns {Promise<boolean>}
+   */
   private async canRenderTemplate(
     template: string,
     data: object,

package/src/Publisher/Publisher.ts

@@ -7,16 +7,51 @@ import {
 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,6 +59,15 @@ 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,
@@ -38,8 +82,7 @@ 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}`,
@@ -49,6 +92,9 @@ export default class Publisher {
     return resp
   }
   /* Private */
+  /**
+   * ${1:Description placeholder}
+   */
   _connect() {
     if (
       (!PUBLISHER_CONN && !PUBLISHER_CONN_HASH) ||

package/src/Server/RouteResolver.ts

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

@@ -10,8 +10,27 @@ import Transaction, {
 } 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 +38,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 +78,57 @@ 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)
   }
+  /**
+   * 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

@@ -2,13 +2,40 @@ 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,12 +43,32 @@ 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

package/src/Server/lib/Server.ts

@@ -1,73 +1,113 @@
 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"
 
+/**
+ * ${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)
   }
 
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @param {APIGatewayProxyEvent} event
+   * @param {Context} context
+   * @returns {*}
+   */
   public async handleServerlessEvent(
     event: APIGatewayProxyEvent,
     context: Context,
   ) {
-    const config = this.config
     // init transaction
-    await new Transaction(event, context, config).execute(
+    await new Transaction(event, context, this.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)
+        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)
         }
         //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)
   }
 }