@jaypie/express 1.1.16 → 1.1.18-rc.0

package/src/expressHandler.js

@@ -1,346 +0,0 @@
-import {
-  force,
-  getHeaderFrom,
-  HTTP,
-  JAYPIE,
-  jaypieHandler,
-  log as publicLogger,
-  UnhandledError,
-  validate as validateIs,
-} from "@jaypie/core";
-import { DATADOG, hasDatadogEnv, submitMetric } from "@jaypie/datadog";
-
-import getCurrentInvokeUuid from "./getCurrentInvokeUuid.adapter.js";
-import decorateResponse from "./decorateResponse.helper.js";
-import summarizeRequest from "./summarizeRequest.helper.js";
-import summarizeResponse from "./summarizeResponse.helper.js";
-
-//
-//
-// Main
-//
-
-const expressHandler = (handler, options = {}) => {
-  // If handler is an object and options is a function, swap them
-  if (typeof handler === "object" && typeof options === "function") {
-    const temp = handler;
-    handler = options;
-    options = temp;
-  }
-
-  //
-  //
-  // Validate
-  //
-  let {
-    chaos,
-    locals,
-    name,
-    setup = [],
-    teardown = [],
-    unavailable,
-    validate,
-  } = options;
-  validateIs.function(handler);
-  validateIs.optional.object(locals);
-  setup = force.array(setup); // allows a single item
-  teardown = force.array(teardown); // allows a single item
-
-  //
-  //
-  // Setup
-  //
-
-  let jaypieFunction;
-
-  return async (req, res, ...params) => {
-    // * This is the first line of code that runs when a request is received
-
-    // Set default chaos value
-    if (chaos === undefined) {
-      chaos =
-        process.env.PROJECT_CHAOS ||
-        getHeaderFrom(HTTP.HEADER.PROJECT.CHAOS, req);
-    }
-
-    // Re-init the logger
-    publicLogger.init();
-    // Very low-level, internal sub-trace details
-    const libLogger = publicLogger.lib({
-      lib: JAYPIE.LIB.EXPRESS,
-    });
-    // Top-level, important details that run at the same level as the main logger
-    const log = publicLogger.lib({
-      level: publicLogger.level,
-      lib: JAYPIE.LIB.EXPRESS,
-    });
-
-    // Update the public logger with the request ID
-    const invokeUuid = getCurrentInvokeUuid();
-    if (invokeUuid) {
-      publicLogger.tag({ invoke: invokeUuid });
-      publicLogger.tag({ shortInvoke: invokeUuid.slice(0, 8) });
-      // TODO: in theory this is redundant
-      libLogger.tag({ invoke: invokeUuid });
-      libLogger.tag({ shortInvoke: invokeUuid.slice(0, 8) });
-      log.tag({ invoke: invokeUuid });
-      log.tag({ shortInvoke: invokeUuid.slice(0, 8) });
-    }
-
-    if (!name) {
-      // If handler has a name, use it
-      if (handler.name) {
-        name = handler.name;
-      } else {
-        name = JAYPIE.UNKNOWN;
-      }
-    }
-    publicLogger.tag({ handler: name });
-    // TODO: in theory this is redundant
-    libLogger.tag({ handler: name });
-    log.tag({ handler: name });
-
-    libLogger.trace("[jaypie] Express init");
-
-    // Set req.locals if it doesn't exist
-    if (!req.locals) req.locals = {};
-    if (!req.locals._jaypie) req.locals._jaypie = {};
-
-    // Set res.locals if it doesn't exist
-    if (!res.locals) res.locals = {};
-    if (!res.locals._jaypie) res.locals._jaypie = {};
-
-    const originalRes = {
-      attemptedCall: undefined,
-      attemptedParams: undefined,
-      end: res.end,
-      json: res.json,
-      send: res.send,
-      status: res.status,
-      statusSent: false,
-    };
-
-    res.end = (...params) => {
-      originalRes.attemptedCall = originalRes.end;
-      originalRes.attemptedParams = params;
-      log.warn(
-        "[jaypie] Illegal call to res.end(); prefer Jaypie response conventions",
-      );
-    };
-
-    res.json = (...params) => {
-      originalRes.attemptedCall = originalRes.json;
-      originalRes.attemptedParams = params;
-      log.warn(
-        "[jaypie] Illegal call to res.json(); prefer Jaypie response conventions",
-      );
-    };
-
-    res.send = (...params) => {
-      originalRes.attemptedCall = originalRes.send;
-      originalRes.attemptedParams = params;
-      log.warn(
-        "[jaypie] Illegal call to res.send(); prefer Jaypie response conventions",
-      );
-    };
-
-    res.status = (...params) => {
-      originalRes.statusSent = params[0];
-      return originalRes.status(...params);
-    };
-
-    //
-    //
-    // Preprocess
-    //
-
-    if (locals) {
-      // Locals
-      const keys = Object.keys(locals);
-      if (keys.length > 0) {
-        const localsSetup = async (localsReq, localsRes) => {
-          for (let i = 0; i < keys.length; i += 1) {
-            const key = keys[i];
-            libLogger.trace(`[jaypie] Locals: ${key}`);
-            if (typeof locals[key] === "function") {
-              localsReq.locals[key] = await locals[key](localsReq, localsRes);
-            } else {
-              localsReq.locals[key] = locals[key];
-            }
-          }
-        };
-        setup.push(localsSetup);
-      }
-    }
-
-    let response;
-    let status = HTTP.CODE.OK;
-
-    try {
-      log.info.var({ req: summarizeRequest(req) });
-
-      // Initialize after logging is set up
-      jaypieFunction = jaypieHandler(handler, {
-        chaos,
-        name,
-        setup,
-        teardown,
-        unavailable,
-        validate,
-      });
-
-      libLogger.trace("[jaypie] Express execution");
-
-      //
-      //
-      // Process
-      //
-
-      response = await jaypieFunction(req, res, ...params);
-
-      //
-      //
-      // Error Handling
-      //
-    } catch (error) {
-      // In theory jaypieFunction has handled all errors
-      if (error.status) {
-        status = error.status;
-      }
-      if (typeof error.json === "function") {
-        response = error.json();
-      } else {
-        // This should never happen
-        const unhandledError = new UnhandledError();
-        response = unhandledError.json();
-        status = unhandledError.status;
-      }
-    }
-
-    //
-    //
-    // Postprocess
-    //
-
-    // Restore original res functions
-    res.end = originalRes.end;
-    res.json = originalRes.json;
-    res.send = originalRes.send;
-    res.status = originalRes.status;
-
-    // Decorate response
-    decorateResponse(res, { handler: name });
-
-    // Allow the sent status to override the status in the response
-    if (originalRes.statusSent) {
-      status = originalRes.statusSent;
-    }
-
-    // Send response
-    try {
-      if (!originalRes.attemptedCall) {
-        // Body
-        if (response) {
-          if (typeof response === "object") {
-            if (typeof response.json === "function") {
-              res.json(response.json());
-            } else {
-              res.status(status).json(response);
-            }
-          } else if (typeof response === "string") {
-            try {
-              res.status(status).json(JSON.parse(response));
-              // eslint-disable-next-line no-unused-vars
-            } catch (error) {
-              res.status(status).send(response);
-            }
-          } else if (response === true) {
-            res.status(HTTP.CODE.CREATED).send();
-          } else {
-            res.status(status).send(response);
-          }
-        } else {
-          // No response
-          res.status(HTTP.CODE.NO_CONTENT).send();
-        }
-      } else {
-        // Resolve illegal call to res.end(), res.json(), or res.send()
-        log.debug("[jaypie] Resolving illegal call to res");
-        log.var({
-          attemptedCall: {
-            name: originalRes.attemptedCall.name,
-            params: originalRes.attemptedParams,
-          },
-        });
-        // Call the original function with the original parameters and the original `this` (res)
-        originalRes.attemptedCall.call(res, ...originalRes.attemptedParams);
-      }
-    } catch (error) {
-      log.fatal("Express encountered an error while sending the response");
-      log.var({ responseError: error });
-    }
-
-    // Log response
-    const extras = {};
-    if (response) extras.body = response;
-    log.info.var({
-      res: summarizeResponse(res, extras),
-    });
-
-    // Submit metric if Datadog is configured
-    if (hasDatadogEnv()) {
-      // Construct path from baseUrl and url
-      let path = (req.baseUrl || "") + (req.url || "");
-      // Ensure path starts with /
-      if (!path.startsWith("/")) {
-        path = "/" + path;
-      }
-      // Remove trailing slash unless it's the root path
-      if (path.length > 1 && path.endsWith("/")) {
-        path = path.slice(0, -1);
-      }
-
-      // Replace UUIDs with :id for better aggregation
-      // Matches standard UUID v4 format (8-4-4-4-12 hex characters)
-      path = path.replace(
-        /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi,
-        ":id",
-      );
-
-      // Determine metric name based on environment variables
-      let metricPrefix = "project";
-      if (process.env.PROJECT_SPONSOR) {
-        metricPrefix = process.env.PROJECT_SPONSOR;
-      } else if (process.env.PROJECT_KEY) {
-        metricPrefix = `project.${process.env.PROJECT_KEY}`;
-      }
-
-      await submitMetric({
-        name: `${metricPrefix}.api.response`,
-        type: DATADOG.METRIC.TYPE.COUNT,
-        value: 1,
-        tags: {
-          status: res.statusCode,
-          path,
-        },
-      });
-    }
-
-    // Clean up the public logger
-    publicLogger.untag("handler");
-
-    //
-    //
-    // Return
-    //
-
-    return response;
-  };
-};
-
-//
-//
-// Export
-//
-
-export default expressHandler;

package/src/getCurrentInvokeUuid.adapter.js

@@ -1,33 +0,0 @@
-import { getCurrentInvoke } from "@codegenie/serverless-express";
-
-//
-//
-// Helper Functions
-//
-
-// Adapter for the "@codegenie/serverless-express" uuid
-function getServerlessExpressUuid() {
-  const currentInvoke = getCurrentInvoke();
-  if (
-    currentInvoke &&
-    currentInvoke.context &&
-    currentInvoke.context.awsRequestId
-  ) {
-    return currentInvoke.context.awsRequestId;
-  }
-  return undefined;
-}
-
-//
-//
-// Main
-//
-
-const getCurrentInvokeUuid = () => getServerlessExpressUuid();
-
-//
-//
-// Export
-//
-
-export default getCurrentInvokeUuid;

package/src/http.handler.js

@@ -1,73 +0,0 @@
-import {
-  BadGatewayError,
-  BadRequestError,
-  ForbiddenError,
-  GatewayTimeoutError,
-  GoneError,
-  HTTP,
-  InternalError,
-  log,
-  MethodNotAllowedError,
-  NotFoundError,
-  TeapotError,
-  UnauthorizedError,
-  UnavailableError,
-} from "@jaypie/core";
-
-import expressHandler from "./expressHandler.js";
-
-//
-//
-// Main
-//
-
-const httpHandler = (statusCode = HTTP.CODE.OK, context = {}) => {
-  // Give a default name if there isn't one
-  if (!context.name) {
-    context.name = "_http";
-  }
-
-  // Return a function that will be used as an express route
-  return expressHandler(async (req, res) => {
-    // Map the most throwable status codes to errors and throw them!
-    const error = {
-      [HTTP.CODE.BAD_REQUEST]: BadRequestError,
-      [HTTP.CODE.UNAUTHORIZED]: UnauthorizedError,
-      [HTTP.CODE.FORBIDDEN]: ForbiddenError,
-      [HTTP.CODE.NOT_FOUND]: NotFoundError,
-      [HTTP.CODE.METHOD_NOT_ALLOWED]: MethodNotAllowedError,
-      [HTTP.CODE.GONE]: GoneError,
-      [HTTP.CODE.TEAPOT]: TeapotError,
-      [HTTP.CODE.INTERNAL_ERROR]: InternalError,
-      [HTTP.CODE.BAD_GATEWAY]: BadGatewayError,
-      [HTTP.CODE.UNAVAILABLE]: UnavailableError,
-      [HTTP.CODE.GATEWAY_TIMEOUT]: GatewayTimeoutError,
-    };
-
-    // If this maps to an error, throw it
-    if (error[statusCode]) {
-      log.trace(
-        `@knowdev/express: gracefully throwing ${statusCode} up to projectHandler`,
-      );
-      throw new error[statusCode]();
-    }
-
-    // If this is an error and we didn't get thrown, log a warning
-    if (statusCode >= 400) {
-      log.warn(
-        `@knowdev/express: status code ${statusCode} not mapped as throwable`,
-      );
-    }
-
-    // Send the response
-    res.status(statusCode);
-    return statusCode === HTTP.CODE.NO_CONTENT ? null : {};
-  }, context);
-};
-
-//
-//
-// Export
-//
-
-export default httpHandler;

package/src/routes.js

@@ -1,43 +0,0 @@
-import { HTTP, NotImplementedError } from "@jaypie/core";
-import expressHandler from "./expressHandler.js";
-import httpHandler from "./http.handler.js";
-import echoHandler from "./echo.handler.js";
-
-//
-//
-// Functions
-//
-
-const routes = {
-  badRequestRoute: httpHandler(HTTP.CODE.BAD_REQUEST, { name: "_badRequest" }),
-  echoRoute: echoHandler(),
-  forbiddenRoute: httpHandler(HTTP.CODE.FORBIDDEN, { name: "_forbidden" }),
-  goneRoute: httpHandler(HTTP.CODE.GONE, { name: "_gone" }),
-  methodNotAllowedRoute: httpHandler(HTTP.CODE.METHOD_NOT_ALLOWED, {
-    name: "_methodNotAllowed",
-  }),
-  noContentRoute: httpHandler(HTTP.CODE.NO_CONTENT, { name: "_noContent" }),
-  notFoundRoute: httpHandler(HTTP.CODE.NOT_FOUND, { name: "_notFound" }),
-  notImplementedRoute: expressHandler(
-    () => {
-      throw new NotImplementedError();
-    },
-    { name: "_notImplemented" },
-  ),
-};
-
-//
-//
-// Export
-//
-
-export const {
-  badRequestRoute,
-  echoRoute,
-  forbiddenRoute,
-  goneRoute,
-  methodNotAllowedRoute,
-  noContentRoute,
-  notFoundRoute,
-  notImplementedRoute,
-} = routes;

package/src/summarizeRequest.helper.js

@@ -1,28 +0,0 @@
-//
-//
-// Function Definition
-//
-
-function summarizeRequest(req) {
-  // If body is a buffer, convert it to a string
-  let { body } = req;
-  if (Buffer.isBuffer(body)) {
-    body = body.toString();
-  }
-
-  return {
-    baseUrl: req.baseUrl,
-    body,
-    headers: req.headers,
-    method: req.method,
-    query: req.query,
-    url: req.url,
-  };
-}
-
-//
-//
-// Export
-//
-
-export default summarizeRequest;

package/src/summarizeResponse.helper.js

@@ -1,25 +0,0 @@
-//
-//
-// Function Definition
-//
-
-function summarizeResponse(res, extras) {
-  const response = {
-    statusCode: res.statusCode,
-    statusMessage: res.statusMessage,
-  };
-  if (typeof res.getHeaders === "function") {
-    response.headers = res.getHeaders();
-  }
-  if (typeof extras === "object" && extras !== null) {
-    Object.assign(response, extras);
-  }
-  return response;
-}
-
-//
-//
-// Export
-//
-
-export default summarizeResponse;