@creator.co/wapi 1.1.8 → 1.2.0-alpha2

package/src/Config/Configuration.ts

@@ -0,0 +1,83 @@
+import * as MemCache from "node-cache"
+import * as DurationParser from "parse-duration"
+
+import EnvironmentVar, { EnvironmentType } from "./EnvironmentVar"
+
+// Hold cached values at nodeVM level
+const cacheStore = new MemCache()
+
+export type ConfigurationSchema = {
+  [name: string]: {
+    type: EnvironmentType
+    required?: boolean
+    cachingPolicy?: string
+  }
+}
+
+// runtime type infer to ConfigurationSchema keys, which type is remote
+type ExtractRemote<Type> = keyof {
+  [Property in keyof Type]: Type[Property] extends {
+    type: EnvironmentType.PlainRemote | EnvironmentType.SecureRemote
+  }
+    ? Property
+    : never
+}
+// runtime type infer to ConfigurationSchema keys, which type is local
+type ExtractLocal<Type> = keyof {
+  [Property in keyof Type]: Type[Property] extends {
+    type: EnvironmentType.Local
+  }
+    ? Property
+    : never
+}
+
+export default class Configuration<T extends ConfigurationSchema> {
+  private readonly schema: T
+  private readonly remotePrefix: string
+  constructor(schema: T, remotePrefix: string) {
+    this.schema = schema
+    this.remotePrefix = remotePrefix
+  }
+
+  public get(propName: ExtractLocal<T>): any {
+    propName = propName as string // TODO: find a better way, this seems to come from keyof
+    const propSchema = this.schema[propName]
+    let v = this.getCachedValue(propName)
+    v =
+      v ||
+      new EnvironmentVar<string>(
+        propName,
+        propSchema.type,
+        propSchema.required,
+        this.remotePrefix,
+      ).syncResolve()
+    this.cacheValue(propName, v, propSchema.cachingPolicy)
+    return v
+  }
+  public async asyncGet(propName: ExtractRemote<T>): Promise<any> {
+    propName = propName as string // TODO: find a better way, this seems to come from keyof
+    const propSchema = this.schema[propName]
+    let v = this.getCachedValue(propName)
+    v =
+      v ||
+      (await new EnvironmentVar<string>(
+        propName,
+        propSchema.type,
+        propSchema.required,
+        this.remotePrefix,
+      ).resolve())
+    this.cacheValue(propName, v, propSchema.cachingPolicy)
+    return v
+  }
+  // caching layer
+  private getCachedValue(valueKey: string): any {
+    return cacheStore.get(valueKey)
+  }
+  private cacheValue(
+    valueKey: string,
+    value: any,
+    policy: string = "1d",
+  ): void {
+    cacheStore.set(valueKey, value, DurationParser(policy, "s"))
+  }
+}

package/src/Config/EnvironmentVar.ts

@@ -0,0 +1,94 @@
+import {
+  SecretsManagerClient,
+  GetSecretValueCommand,
+} from "@aws-sdk/client-secrets-manager"
+import { SSMClient, GetParameterCommand } from "@aws-sdk/client-ssm"
+// important for dev env to load .env file
+import * as dotenv from "dotenv"
+dotenv.config()
+
+// Explicity setting VM level variables in order to persist
+// client across different important and instances.
+// eslint-disable-next-line no-var
+var ssmClient = null,
+  secretsClient = null
+
+export enum EnvironmentType {
+  PlainRemote,
+  SecureRemote,
+  Local,
+}
+export default class EnvironmentVar<T> {
+  private readonly paramName: string
+  private readonly type: EnvironmentType
+  private readonly optional: boolean
+  private readonly paramPrefix: string
+  constructor(
+    paramName: string,
+    type: EnvironmentType,
+    optional?: boolean,
+    paramPrefix = `/creatorco-api-${process.env.STAGE}/env/` /* only allowed process.env */,
+  ) {
+    this.paramName = paramName
+    this.type = type
+    this.optional = !!optional
+    this.paramPrefix = paramPrefix
+  }
+
+  public syncResolve(): T {
+    if (this.type == EnvironmentType.Local) return this.getLocalValue()
+    else {
+      throw new Error(
+        "EnvironmentVar syncResolve method can only be called for environments of type 'Local'",
+      )
+    }
+  }
+  public async resolve() {
+    if (this.type == EnvironmentType.Local) return this.getLocalValue()
+    else if (this.type == EnvironmentType.SecureRemote)
+      return this.getSecureValue()
+    else return this.getPlainValue()
+  }
+
+  private getLocalValue(): T {
+    const value = process.env[this.paramName]
+    if (!value && !this.optional) {
+      throw new Error(
+        `Local environment ${this.paramName} is not defined, please reconfigure the application and redeploy!`,
+      )
+    }
+    return value as T
+  }
+  private async getPlainValue(): Promise<T> {
+    if (!ssmClient) ssmClient = new SSMClient()
+    const pName = `${this.paramPrefix}${this.paramName}`
+    try {
+      const data = await ssmClient.send(
+        new GetParameterCommand({ Name: pName }),
+      )
+      if (data.Parameter && data.Parameter.Value)
+        return data.Parameter.Value as T
+    } catch (error) {
+      console.error(error)
+    }
+    if (!this.optional) {
+      throw new Error(`Unable to retrieve plain remote env value: ${pName}`)
+    }
+  }
+  private async getSecureValue(): Promise<T> {
+    if (!secretsClient) secretsClient = new SecretsManagerClient()
+    const pName = `${this.paramPrefix}${this.paramName}`
+    try {
+      const data = await secretsClient.send(
+        new GetSecretValueCommand({ SecretId: pName }),
+      )
+      if (data.Parameter && data.Parameter.Value)
+        return data.Parameter.Value as T
+    } catch (error) {
+      console.error(error)
+    }
+    if (!this.optional) {
+      throw new Error(`Unable to retrieve secure remote env: ${pName}`)
+    }
+  }
+}

package/src/Globals.ts

@@ -11,4 +11,19 @@ export default class Globals {
   public static ErrorCode_InvalidInput = "INVALID_INPUT"
   public static ErrorCode_APIError = "API_ERROR"
   public static ErrorCode_NoRecords = "EMPTY_EVENT"
+
+  public static Listener_HTTP_DefaultPort = 80
+  public static Listener_HTTP_DefaultHost = "localhost"
+  public static Listener_HTTP_ProxyRoute = "*"
+  public static Listener_HTTP_DefaultTimeout = 30000
+  public static Listener_HTTP_DefaultHealthCheckRoute = "/health"
+  //Resps
+  public static Resp_MSG_EXCEPTION =
+    "[Proxy]: Exception during request execution!"
+  public static Resp_CODE_EXCEPTION = "EXEC_EXCEPTION"
+  public static Resp_STATUSCODE_EXCEPTION = 502
+
+  public static Resp_MSG_INVALIDRESP = "[Proxy]: Invalid response from server!"
+  public static Resp_CODE_INVALIDRESP = "EMPTY_RESPONSE"
+  public static Resp_STATUSCODE_INVALIDRESP = 400
 }

package/src/Server/Router.ts

@@ -0,0 +1,51 @@
+import { z } from "zod"
+
+import ContainerServer from "./lib/ContainerServer"
+import Server from "./lib/Server"
+import Transaction, {
+  TransactionConfig,
+  TransactionExecution,
+} from "../BaseEvent/Transaction"
+
+// Route
+export type Route<InputType = object> = {
+  path: string
+  method: string
+  handler: TransactionExecution<Transaction<InputType>>
+  inputValidation?: z.ZodObject<any>
+  outputValidation?: {
+    type: any
+    validationSchema: z.ZodObject<any>
+  }
+}
+
+// Config
+export type RouterConfig = TransactionConfig & {
+  routes: Route[]
+  // container based configs - otherwise enforced by serverless engine
+  port?: number
+  timeout?: number
+  cors?: {
+    origin?: string | string[]
+    headers?: string[]
+    allowCredentials?: boolean
+  }
+  healthCheckRoute?: string
+}
+
+export default class Router {
+  private readonly config: RouterConfig
+  private readonly server: Server
+  constructor(config: RouterConfig) {
+    this.config = config
+    this.server = this.isContainer()
+      ? new ContainerServer(config)
+      : new Server(config)
+  }
+  public getExport(): CallableFunction {
+    return this.server.getExport()
+  }
+  private isContainer(): boolean {
+    return true
+  }
+}

package/src/Server/lib/ContainerServer.ts

@@ -0,0 +1,27 @@
+import Proxy from "./container/Proxy"
+import Server from "./Server"
+import { RouterConfig } from "../Router"
+
+export default class ContainerServer extends Server {
+  protected readonly proxy: Proxy
+  constructor(config: RouterConfig) {
+    super(config)
+    this.proxy = new Proxy(config, this.handleServerlessEvent.bind(this))
+    this.listenProcessEvents()
+  }
+  public getExport(): CallableFunction {
+    return this.start
+  }
+  /* private */
+  public async start() {
+    await this.proxy.load()
+  }
+  public async stop(err) {
+    await this.proxy.unload(err)
+  }
+  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
+  }
+}

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))
+  }
+}