@creator.co/wapi 1.1.8 → 1.2.0-alpha1

package/src/Server/lib/Server.ts

@@ -0,0 +1,66 @@
+import { APIGatewayProxyEvent, Context } from "aws-lambda"
+import { pathToRegexp } from "path-to-regexp"
+
+import Response from "../../API/Response"
+import Transaction from "../../BaseEvent/Transaction"
+import Validator from "../../Validation/Validator"
+import { RouterConfig } from "../Router"
+
+export default class Server {
+  protected readonly config: RouterConfig
+  constructor(config: RouterConfig) {
+    this.config = config
+  }
+
+  public getExport(): CallableFunction {
+    return this.handleServerlessEvent
+  }
+
+  public async handleServerlessEvent(
+    event: APIGatewayProxyEvent,
+    context: Context,
+  ) {
+    // init transaction
+    await new Transaction(event, context, this.config).execute(
+      async (transaction) => {
+        for (const route of this.config.routes) {
+          // Check for possible paths
+          const handler = this.routeMatches(route.path, route.method, event)
+          if (handler) {
+            transaction.logger.log("Router accepted route:", route)
+            // Validate input?
+            if (route.inputValidation) {
+              const validationResp = Validator.validateSchema(
+                transaction.request.getBody(),
+                route.inputValidation,
+              )
+              if (validationResp && validationResp instanceof Response)
+                return validationResp
+            }
+            // 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 routeMatches(
+    routePath: string,
+    routeMethod: string,
+    event: APIGatewayProxyEvent,
+  ): boolean {
+    const path = event.path
+    const keys = []
+    const result = pathToRegexp(routePath, keys).exec(path)
+    if (result) {
+      const reqMethod = event.httpMethod
+      if (reqMethod.toLowerCase() == routeMethod.toLowerCase()) {
+        return true
+      }
+    }
+    return false
+  }
+}

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

@@ -0,0 +1,63 @@
+import { Request, Response } from "express"
+
+import GenericHandlerEvent, {
+  GenericHandlerEventResponse,
+} from "./GenericHandlerEvent"
+import Globals from "../../../Globals"
+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)
+    } catch (e) {
+      console.error("[Proxy] - Exception during execution!", e)
+      resp = res
+        .json({
+          ...e,
+          err: Globals.Resp_MSG_EXCEPTION,
+          errCode: Globals.Resp_CODE_EXCEPTION,
+        })
+        .status(Globals.Resp_STATUSCODE_EXCEPTION) //bad gateway
+    }
+    console.debug(`[Proxy] - Request took ${Date.now() - startTime}ms`)
+    return resp
+  }
+}
+const processServerlessResponse = (
+  invokation: GenericHandlerEventResponse,
+  res: Response,
+) => {
+  // translate answer to http layer
+  if (invokation && invokation.err) {
+    // err came
+    return res.json({ err: invokation.err }).status(400)
+  } else if (!invokation || !invokation.data) {
+    // invalid response came
+    return res
+      .json({
+        err: Globals.Resp_MSG_INVALIDRESP,
+        errCode: Globals.Resp_CODE_INVALIDRESP,
+      })
+      .status(Globals.Resp_STATUSCODE_INVALIDRESP)
+  } else {
+    // valid
+    const response = res
+      .json(invokation.data.body || {})
+      .status(invokation.data.statusCode)
+    // Check for headers
+    if (invokation?.data?.headers) {
+      for (const hKey of Object.keys(invokation.data.headers)) {
+        response.header(hKey, invokation.data.headers[hKey])
+      }
+    }
+    return response
+  }
+}

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

@@ -0,0 +1,133 @@
+import type { APIGatewayProxyEvent, Context } from "aws-lambda"
+import * as cuid from "cuid"
+import { Request } from "express"
+import unflatten from "unflatten"
+
+import {
+  parseMultiValueHeaders,
+  parseMultiValueQueryStringParameters,
+  parseQueryStringParameters,
+  nullIfEmpty,
+} from "./Utils"
+import Globals from "../../../Globals"
+import Server from "../Server"
+//
+export type GenericHandlerEventResponse = { err?: Error | string; data?: any }
+//
+export default class GenericHandlerEvent {
+  public request: Request
+  public serverlessHandler: Server["handleServerlessEvent"]
+  constructor(
+    request: Request,
+    serverlessHandler: Server["handleServerlessEvent"],
+  ) {
+    this.request = request
+    this.serverlessHandler = serverlessHandler
+  }
+  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 })
+          },
+        )
+        // Invoke
+        await this.serverlessHandler(event, context)
+      } catch (e) {
+        reject(e) // forward rejection
+      }
+    })
+  }
+  /* private */
+  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,
+      isBase64Encoded: false,
+      multiValueHeaders: parseMultiValueHeaders(
+        this.request.headers ? this.request.headers || [] : [],
+      ),
+      multiValueQueryStringParameters: parseMultiValueQueryStringParameters(
+        this.request.url,
+      ),
+      path: this.request.path,
+      pathParameters: this.request.params
+        ? nullIfEmpty(this.request.params)
+        : null,
+      queryStringParameters: this.request.query
+        ? parseQueryStringParameters(this.request.query)
+        : null,
+      requestContext: {
+        accountId: process.env.AWS_ACCOUNT_ID || null,
+        apiId: null,
+        authorizer: null,
+        domainName: null,
+        domainPrefix: null,
+        extendedRequestId: cuid(),
+        httpMethod: this.request.method
+          ? this.request.method.toUpperCase()
+          : null,
+        identity: {
+          accessKey: null,
+          accountId: process.env.AWS_ACCOUNT_ID || null,
+          caller: null,
+          apiKey: null,
+          apiKeyId: null,
+          clientCert: null,
+          cognitoAuthenticationProvider: null,
+          cognitoAuthenticationType: null,
+          cognitoIdentityId: null,
+          cognitoIdentityPoolId: null,
+          principalOrgId: null,
+          sourceIp:
+            <string>this.request.headers?.["x-forwarded-for"] ||
+            this.request.socket.remoteAddress,
+          user: null,
+          userAgent: this.request.headers
+            ? this.request.headers["user-agent"]
+            : null,
+          userArn: null,
+        },
+        path: this.request.path,
+        protocol: "HTTP/1.1",
+        requestId: `${cuid()}-${cuid()}`,
+        requestTime: new Date().toISOString(),
+        requestTimeEpoch: Date.now(),
+        resourceId: null,
+        resourcePath: Globals.Listener_HTTP_ProxyRoute,
+        stage: process.env.STAGE,
+      },
+      resource: Globals.Listener_HTTP_ProxyRoute,
+      stageVariables: null,
+    }
+  }
+  private buildContext(
+    event: APIGatewayProxyEvent,
+    callback: (err?: Error | string, data?: any) => void,
+  ): Context {
+    return {
+      awsRequestId: event.requestContext.requestId,
+      callbackWaitsForEmptyEventLoop: true,
+      getRemainingTimeInMillis: () => {
+        return 0
+      },
+      done: (err, data) => callback(err, data),
+      fail: (err) => callback(err),
+      succeed: (res) => callback(null, res),
+      functionName: null,
+      functionVersion: "LATEST",
+      invokedFunctionArn: null,
+      memoryLimitInMB: "-1",
+      logGroupName: null,
+      logStreamName: null,
+    }
+  }
+}

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

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

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

@@ -0,0 +1,107 @@
+import { Server as HTTPServer, createServer } from "http"
+
+import 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 Globals from "../../../Globals"
+import { RouterConfig } from "../../Router"
+
+export default class Proxy {
+  private stopping: boolean
+  private readonly config: RouterConfig
+  private readonly app: express.Express
+  private readonly serverlessHandler: Server["handleServerlessEvent"]
+  private listener: HTTPServer
+  constructor(
+    config: RouterConfig,
+    serverlessHandler: Server["handleServerlessEvent"],
+  ) {
+    this.stopping = false
+    this.config = config
+    this.serverlessHandler = serverlessHandler
+    this.app = express()
+    this.app.use(
+      cors(
+        this.config.cors
+          ? {
+              options: {
+                origin: this.config?.cors?.origin,
+                allowedHeaders: this.config?.cors?.headers,
+                credentials: !!this.config?.cors?.allowCredentials,
+              },
+            }
+          : {},
+      ),
+    )
+
+    // //This supposedly fix some 502 codes where nodejs socket would hang during
+    // //a request and if behind ALB, it would cause 502 codes. Had experiencied this
+    // //and 502 codes reduced dramastically, but still some appearances. Maybe this
+    // //is just a palliative work-around for the real issue; TODO: need to investigate
+    // //in the future.
+    // this.listener.listener.keepAliveTimeout = 120e3
+    // this.listener.listener.headersTimeout = 120e3
+  }
+  async load() {
+    await this.startListeners()
+    this.installRoutes()
+  }
+  async unload(err) {
+    await this.stopListeners(err)
+  }
+  /* lifecycle */
+  private async startListeners(): Promise<void> {
+    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,
+      )
+      // Start Server
+      this.listener.listen(port, () => {
+        console.log(`[Proxy] - [STARTED]`)
+        resolve()
+      })
+    })
+  }
+  private async stopListeners(err) {
+    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)
+    })
+  }
+  /* routing */
+  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.app
+      .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))
+  }
+}

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

@@ -0,0 +1,45 @@
+import 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) {
+  // 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
+  const map = new Map()
+  // eslint-disable-next-line no-restricted-syntax
+  for (const [key, value] of searchParams) {
+    const item = map.get(key)
+    if (item) item.push(value)
+    else map.set(key, [value])
+  }
+  return Object.fromEntries(map)
+}
+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")
+  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

@@ -0,0 +1,35 @@
+import { z } from "zod"
+
+import Response from "../API/Response"
+import Globals from "../Globals"
+
+export default class Validator {
+  public static validateSchema(
+    data: any,
+    schema: z.ZodObject<any>,
+  ): boolean | Response {
+    let error, validatedInput
+    // Validate body against known zod schema
+    try {
+      validatedInput = schema.parse(data) as typeof schema
+    } catch (err: z.ZodError | any) {
+      if (err instanceof z.ZodError) {
+        error = err.issues
+          .map((v) => {
+            return `${v.code} - ${v.message} ${v.path}`
+          })
+          .join(", ")
+      } else if (err.message) error = err.message
+      else error = "Unknown validation error!"
+    }
+    // Error validation
+    if (!validatedInput || error) {
+      return Response.BadRequestResponse(
+        Globals.ErrorResponseValidationFail,
+        Globals.ErrorCode_InvalidInput,
+      )
+    } else {
+      return true
+    }
+  }
+}

package/tsconfig.json

@@ -3,6 +3,8 @@
     "noImplicitAny": false,
     "noEmitOnError": true,
     "removeComments": false,
+    "downlevelIteration": true,
+    "resolveJsonModule": true,
     "sourceMap": true,
     "target": "es5",
     "outDir": "dist",