@web-ts-toolkit/express-response-handler 0.0.2

package/create-express-response-handler.js

@@ -0,0 +1,292 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_express_response_handler_exports = {};
+__export(create_express_response_handler_exports, {
+  createExpressResponseHandler: () => createExpressResponseHandler
+});
+module.exports = __toCommonJS(create_express_response_handler_exports);
+var import_assert = __toESM(require("assert"));
+var import_csv = require("./responses/csv");
+var import_responses = require("./responses");
+var import_http_response = require("./http-response");
+var import_error_format = require("./error-format");
+const isFunction = (value) => typeof value === "function";
+const isPromise = (value) => Boolean(value) && isFunction(value.then);
+const promisify = (fn) => (value) => Promise.resolve().then(() => fn(value));
+const { isArray } = Array;
+const invokePostHook = (hook, value) => {
+  void hook(value).catch(() => void 0);
+};
+const assertMiddleware = (fn) => {
+  import_assert.default.ok(isFunction(fn), "middleware handler must be a function");
+};
+const normalizeMiddlewareList = (fns) => {
+  import_assert.default.ok(fns.length > 0, "at least one middleware handler is required");
+  if (fns.length > 1) {
+    fns.forEach(assertMiddleware);
+    return fns;
+  }
+  if (isArray(fns[0])) {
+    import_assert.default.ok(fns[0].length > 0, "at least one middleware handler is required");
+    fns[0].forEach(assertMiddleware);
+    return fns[0];
+  }
+  assertMiddleware(fns[0]);
+  return [fns[0]];
+};
+function createExpressResponseHandler(options = {}) {
+  const errorFormat = options.errorFormat || "simple";
+  const errorDomain = options.errorDomain || "express-response-handler";
+  let errorMessageProvider = import_error_format.defaultErrorMessageProvider;
+  let preJson = null;
+  let postJson = null;
+  let preError = null;
+  let postError = null;
+  let preJsonHook = null;
+  let postJsonHook = null;
+  let preErrorHook = null;
+  let postErrorHook = null;
+  const sendBaseJson = function(res, data, event) {
+    if (res.headersSent || event.canceled) {
+      return;
+    }
+    if (data instanceof import_responses.Response) {
+      res.status(data.statusCode).json(data.data);
+      return;
+    }
+    if (data instanceof import_csv.CSVResponse) {
+      data.streamCsv(res);
+      return;
+    }
+    res.json(data);
+  };
+  const sendBaseError = function(res, err, event) {
+    if (res.headersSent || event.canceled) {
+      return;
+    }
+    const error = err;
+    if (error.statusCode) {
+      if (errorFormat === "aip193") {
+        res.status(error.statusCode).send((0, import_error_format.toStructuredHttpErrorPayload)(error, errorDomain));
+        return;
+      }
+      const payload = { message: error.message || "" };
+      if (error.errors !== void 0) {
+        payload.errors = error.errors;
+      }
+      res.status(error.statusCode).send(payload);
+      return;
+    }
+    const result = errorMessageProvider(err);
+    if (errorFormat === "aip193") {
+      const payload = (0, import_error_format.toStructuredGenericErrorPayload)(result, errorDomain);
+      res.status(payload.error.code).send(payload);
+      return;
+    }
+    res.status(422).send((0, import_error_format.toSimpleErrorPayload)(result));
+  };
+  let sendJson = sendBaseJson;
+  let sendError = sendBaseError;
+  const rebuildSendJson = () => {
+    if (!preJsonHook && !postJsonHook) {
+      sendJson = sendBaseJson;
+      return;
+    }
+    sendJson = function(res, data, event) {
+      const finalize = () => {
+        try {
+          sendBaseJson(res, data, event);
+        } catch (err) {
+          sendError(res, err, event);
+          return;
+        }
+        if (postJsonHook) {
+          invokePostHook(postJsonHook, data);
+        }
+      };
+      if (preJsonHook) {
+        preJsonHook(data).then(finalize, (err) => sendError(res, err, event));
+        return;
+      }
+      finalize();
+    };
+  };
+  const rebuildSendError = () => {
+    if (!preErrorHook && !postErrorHook) {
+      sendError = sendBaseError;
+      return;
+    }
+    sendError = function(res, err, event) {
+      const finalize = () => {
+        sendBaseError(res, err, event);
+        if (postErrorHook) {
+          invokePostHook(postErrorHook, err);
+        }
+      };
+      if (preErrorHook) {
+        preErrorHook(err).then(finalize, (hookErr) => sendBaseError(res, hookErr, event));
+        return;
+      }
+      finalize();
+    };
+  };
+  const handlePromise = function(res, promise, event) {
+    promise.then((data) => {
+      if (event.nextError) {
+        sendError(res, event.nextError, event);
+        return;
+      }
+      sendJson(res, data, event);
+    }).catch((err) => sendError(res, err, event));
+  };
+  const handleResult = function(res, result, event) {
+    if (res.headersSent || event.canceled) {
+      return;
+    }
+    if (event.nextError) {
+      sendError(res, event.nextError, event);
+      return;
+    }
+    if (isPromise(result)) {
+      handlePromise(res, result, event);
+      return;
+    }
+    sendJson(res, result, event);
+  };
+  const nextFn = function(event, next) {
+    return function(...args) {
+      if (args.length === 0) {
+        event.canceled = true;
+        next();
+        return;
+      }
+      if (args[0] instanceof Error) {
+        event.nextError = args[0];
+        return;
+      }
+      event.nextError = new TypeError("next(value) is not supported; return a value instead");
+    };
+  };
+  const routerFn = function(fn) {
+    return function(req, res, next) {
+      const event = { canceled: false, nextError: null };
+      try {
+        const result = fn(req, res, nextFn(event, next));
+        handleResult(res, result, event);
+      } catch (err) {
+        if (res.headersSent) {
+          return;
+        }
+        sendError(res, err, event);
+      }
+    };
+  };
+  const handleResponse = function(...fns) {
+    const middlewares = normalizeMiddlewareList(fns);
+    return middlewares.length === 1 ? routerFn(middlewares[0]) : middlewares.map(routerFn);
+  };
+  return {
+    handleResponse,
+    handleResult,
+    handlePromise,
+    HttpResponse: import_http_response.HttpResponse,
+    createExpressResponseHandler,
+    get errorMessageProvider() {
+      return errorMessageProvider;
+    },
+    set errorMessageProvider(fn) {
+      import_assert.default.ok(isFunction(fn), "error message provider must be a function");
+      errorMessageProvider = fn;
+    },
+    get preJson() {
+      return preJson;
+    },
+    set preJson(fn) {
+      if (fn === null) {
+        preJson = null;
+        preJsonHook = null;
+        rebuildSendJson();
+        return;
+      }
+      import_assert.default.ok(isFunction(fn), "pre-json hook must be a function");
+      preJson = fn;
+      preJsonHook = promisify(fn);
+      rebuildSendJson();
+    },
+    get postJson() {
+      return postJson;
+    },
+    set postJson(fn) {
+      if (fn === null) {
+        postJson = null;
+        postJsonHook = null;
+        rebuildSendJson();
+        return;
+      }
+      import_assert.default.ok(isFunction(fn), "post-json hook must be a function");
+      postJson = fn;
+      postJsonHook = promisify(fn);
+      rebuildSendJson();
+    },
+    get preError() {
+      return preError;
+    },
+    set preError(fn) {
+      if (fn === null) {
+        preError = null;
+        preErrorHook = null;
+        rebuildSendError();
+        return;
+      }
+      import_assert.default.ok(isFunction(fn), "pre-error hook must be a function");
+      preError = fn;
+      preErrorHook = promisify(fn);
+      rebuildSendError();
+    },
+    get postError() {
+      return postError;
+    },
+    set postError(fn) {
+      if (fn === null) {
+        postError = null;
+        postErrorHook = null;
+        rebuildSendError();
+        return;
+      }
+      import_assert.default.ok(isFunction(fn), "post-error hook must be a function");
+      postError = fn;
+      postErrorHook = promisify(fn);
+      rebuildSendError();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createExpressResponseHandler
+});

package/create-express-response-handler.mjs

@@ -0,0 +1,264 @@
+import "./chunk-PQJP2ZCI.mjs";
+import assert from "assert";
+import { CSVResponse } from "./responses/csv";
+import { Response } from "./responses";
+import { HttpResponse } from "./http-response";
+import {
+  defaultErrorMessageProvider,
+  toSimpleErrorPayload,
+  toStructuredGenericErrorPayload,
+  toStructuredHttpErrorPayload
+} from "./error-format";
+const isFunction = (value) => typeof value === "function";
+const isPromise = (value) => Boolean(value) && isFunction(value.then);
+const promisify = (fn) => (value) => Promise.resolve().then(() => fn(value));
+const { isArray } = Array;
+const invokePostHook = (hook, value) => {
+  void hook(value).catch(() => void 0);
+};
+const assertMiddleware = (fn) => {
+  assert.ok(isFunction(fn), "middleware handler must be a function");
+};
+const normalizeMiddlewareList = (fns) => {
+  assert.ok(fns.length > 0, "at least one middleware handler is required");
+  if (fns.length > 1) {
+    fns.forEach(assertMiddleware);
+    return fns;
+  }
+  if (isArray(fns[0])) {
+    assert.ok(fns[0].length > 0, "at least one middleware handler is required");
+    fns[0].forEach(assertMiddleware);
+    return fns[0];
+  }
+  assertMiddleware(fns[0]);
+  return [fns[0]];
+};
+function createExpressResponseHandler(options = {}) {
+  const errorFormat = options.errorFormat || "simple";
+  const errorDomain = options.errorDomain || "express-response-handler";
+  let errorMessageProvider = defaultErrorMessageProvider;
+  let preJson = null;
+  let postJson = null;
+  let preError = null;
+  let postError = null;
+  let preJsonHook = null;
+  let postJsonHook = null;
+  let preErrorHook = null;
+  let postErrorHook = null;
+  const sendBaseJson = function(res, data, event) {
+    if (res.headersSent || event.canceled) {
+      return;
+    }
+    if (data instanceof Response) {
+      res.status(data.statusCode).json(data.data);
+      return;
+    }
+    if (data instanceof CSVResponse) {
+      data.streamCsv(res);
+      return;
+    }
+    res.json(data);
+  };
+  const sendBaseError = function(res, err, event) {
+    if (res.headersSent || event.canceled) {
+      return;
+    }
+    const error = err;
+    if (error.statusCode) {
+      if (errorFormat === "aip193") {
+        res.status(error.statusCode).send(toStructuredHttpErrorPayload(error, errorDomain));
+        return;
+      }
+      const payload = { message: error.message || "" };
+      if (error.errors !== void 0) {
+        payload.errors = error.errors;
+      }
+      res.status(error.statusCode).send(payload);
+      return;
+    }
+    const result = errorMessageProvider(err);
+    if (errorFormat === "aip193") {
+      const payload = toStructuredGenericErrorPayload(result, errorDomain);
+      res.status(payload.error.code).send(payload);
+      return;
+    }
+    res.status(422).send(toSimpleErrorPayload(result));
+  };
+  let sendJson = sendBaseJson;
+  let sendError = sendBaseError;
+  const rebuildSendJson = () => {
+    if (!preJsonHook && !postJsonHook) {
+      sendJson = sendBaseJson;
+      return;
+    }
+    sendJson = function(res, data, event) {
+      const finalize = () => {
+        try {
+          sendBaseJson(res, data, event);
+        } catch (err) {
+          sendError(res, err, event);
+          return;
+        }
+        if (postJsonHook) {
+          invokePostHook(postJsonHook, data);
+        }
+      };
+      if (preJsonHook) {
+        preJsonHook(data).then(finalize, (err) => sendError(res, err, event));
+        return;
+      }
+      finalize();
+    };
+  };
+  const rebuildSendError = () => {
+    if (!preErrorHook && !postErrorHook) {
+      sendError = sendBaseError;
+      return;
+    }
+    sendError = function(res, err, event) {
+      const finalize = () => {
+        sendBaseError(res, err, event);
+        if (postErrorHook) {
+          invokePostHook(postErrorHook, err);
+        }
+      };
+      if (preErrorHook) {
+        preErrorHook(err).then(finalize, (hookErr) => sendBaseError(res, hookErr, event));
+        return;
+      }
+      finalize();
+    };
+  };
+  const handlePromise = function(res, promise, event) {
+    promise.then((data) => {
+      if (event.nextError) {
+        sendError(res, event.nextError, event);
+        return;
+      }
+      sendJson(res, data, event);
+    }).catch((err) => sendError(res, err, event));
+  };
+  const handleResult = function(res, result, event) {
+    if (res.headersSent || event.canceled) {
+      return;
+    }
+    if (event.nextError) {
+      sendError(res, event.nextError, event);
+      return;
+    }
+    if (isPromise(result)) {
+      handlePromise(res, result, event);
+      return;
+    }
+    sendJson(res, result, event);
+  };
+  const nextFn = function(event, next) {
+    return function(...args) {
+      if (args.length === 0) {
+        event.canceled = true;
+        next();
+        return;
+      }
+      if (args[0] instanceof Error) {
+        event.nextError = args[0];
+        return;
+      }
+      event.nextError = new TypeError("next(value) is not supported; return a value instead");
+    };
+  };
+  const routerFn = function(fn) {
+    return function(req, res, next) {
+      const event = { canceled: false, nextError: null };
+      try {
+        const result = fn(req, res, nextFn(event, next));
+        handleResult(res, result, event);
+      } catch (err) {
+        if (res.headersSent) {
+          return;
+        }
+        sendError(res, err, event);
+      }
+    };
+  };
+  const handleResponse = function(...fns) {
+    const middlewares = normalizeMiddlewareList(fns);
+    return middlewares.length === 1 ? routerFn(middlewares[0]) : middlewares.map(routerFn);
+  };
+  return {
+    handleResponse,
+    handleResult,
+    handlePromise,
+    HttpResponse,
+    createExpressResponseHandler,
+    get errorMessageProvider() {
+      return errorMessageProvider;
+    },
+    set errorMessageProvider(fn) {
+      assert.ok(isFunction(fn), "error message provider must be a function");
+      errorMessageProvider = fn;
+    },
+    get preJson() {
+      return preJson;
+    },
+    set preJson(fn) {
+      if (fn === null) {
+        preJson = null;
+        preJsonHook = null;
+        rebuildSendJson();
+        return;
+      }
+      assert.ok(isFunction(fn), "pre-json hook must be a function");
+      preJson = fn;
+      preJsonHook = promisify(fn);
+      rebuildSendJson();
+    },
+    get postJson() {
+      return postJson;
+    },
+    set postJson(fn) {
+      if (fn === null) {
+        postJson = null;
+        postJsonHook = null;
+        rebuildSendJson();
+        return;
+      }
+      assert.ok(isFunction(fn), "post-json hook must be a function");
+      postJson = fn;
+      postJsonHook = promisify(fn);
+      rebuildSendJson();
+    },
+    get preError() {
+      return preError;
+    },
+    set preError(fn) {
+      if (fn === null) {
+        preError = null;
+        preErrorHook = null;
+        rebuildSendError();
+        return;
+      }
+      assert.ok(isFunction(fn), "pre-error hook must be a function");
+      preError = fn;
+      preErrorHook = promisify(fn);
+      rebuildSendError();
+    },
+    get postError() {
+      return postError;
+    },
+    set postError(fn) {
+      if (fn === null) {
+        postError = null;
+        postErrorHook = null;
+        rebuildSendError();
+        return;
+      }
+      assert.ok(isFunction(fn), "post-error hook must be a function");
+      postError = fn;
+      postErrorHook = promisify(fn);
+      rebuildSendError();
+    }
+  };
+}
+export {
+  createExpressResponseHandler
+};

package/error-format.d.mts

@@ -0,0 +1,13 @@
+import { Aip193ErrorPayload } from '@web-ts-toolkit/http-errors';
+import { ErrorMessageProvider, ErrorMessageResult, ErrorWithPayload } from './public-types.mjs';
+import './http-response.mjs';
+import './responses/success.mjs';
+import './responses/index.mjs';
+import './responses/csv.mjs';
+
+declare const defaultErrorMessageProvider: ErrorMessageProvider;
+declare const toSimpleErrorPayload: (result: ErrorMessageResult) => Record<string, unknown>;
+declare const toStructuredHttpErrorPayload: (error: ErrorWithPayload, errorDomain: string) => Aip193ErrorPayload;
+declare const toStructuredGenericErrorPayload: (result: ErrorMessageResult, errorDomain: string) => Aip193ErrorPayload;
+
+export { defaultErrorMessageProvider, toSimpleErrorPayload, toStructuredGenericErrorPayload, toStructuredHttpErrorPayload };

package/error-format.d.ts

@@ -0,0 +1,13 @@
+import { Aip193ErrorPayload } from '@web-ts-toolkit/http-errors';
+import { ErrorMessageProvider, ErrorMessageResult, ErrorWithPayload } from './public-types.js';
+import './http-response.js';
+import './responses/success.js';
+import './responses/index.js';
+import './responses/csv.js';
+
+declare const defaultErrorMessageProvider: ErrorMessageProvider;
+declare const toSimpleErrorPayload: (result: ErrorMessageResult) => Record<string, unknown>;
+declare const toStructuredHttpErrorPayload: (error: ErrorWithPayload, errorDomain: string) => Aip193ErrorPayload;
+declare const toStructuredGenericErrorPayload: (result: ErrorMessageResult, errorDomain: string) => Aip193ErrorPayload;
+
+export { defaultErrorMessageProvider, toSimpleErrorPayload, toStructuredGenericErrorPayload, toStructuredHttpErrorPayload };

package/error-format.js

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_format_exports = {};
+__export(error_format_exports, {
+  defaultErrorMessageProvider: () => defaultErrorMessageProvider,
+  toSimpleErrorPayload: () => toSimpleErrorPayload,
+  toStructuredGenericErrorPayload: () => toStructuredGenericErrorPayload,
+  toStructuredHttpErrorPayload: () => toStructuredHttpErrorPayload
+});
+module.exports = __toCommonJS(error_format_exports);
+var import_http_errors = require("@web-ts-toolkit/http-errors");
+const isString = (value) => typeof value === "string";
+const isPlainObject = (value) => value !== null && typeof value === "object";
+const { isArray } = Array;
+const toMetadata = (value) => {
+  if (!isPlainObject(value)) {
+    return void 0;
+  }
+  const metadata = Object.entries(value).reduce((result, [key, entry]) => {
+    result[key] = String(entry);
+    return result;
+  }, {});
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+};
+const toArray = (value) => {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  return isArray(value) ? value : [value];
+};
+const toHttpErrorShape = (error, fallbackDomain) => ({
+  statusCode: error.statusCode || 500,
+  status: error.status,
+  message: error.message || "",
+  reason: error.reason,
+  domain: error.domain || fallbackDomain,
+  metadata: toMetadata(error.metadata),
+  details: toArray(error.details),
+  errors: error.errors
+});
+const defaultErrorMessageProvider = function(error) {
+  const errorLike = error;
+  return errorLike.message || errorLike._message || String(error);
+};
+const toSimpleErrorPayload = (result) => isString(result) ? { message: result } : { ...result };
+const toStructuredHttpErrorPayload = (error, errorDomain) => (0, import_http_errors.toAip193ErrorPayload)(toHttpErrorShape(error, errorDomain), errorDomain);
+const toStructuredGenericErrorPayload = (result, errorDomain) => {
+  if (isPlainObject(result) && isPlainObject(result.error)) {
+    const error = result.error;
+    const statusCode = typeof error.code === "number" ? error.code : 422;
+    const status = typeof error.status === "string" ? error.status : (0, import_http_errors.getCanonicalStatus)(statusCode);
+    const message = typeof error.message === "string" ? error.message : "";
+    const details = toArray(error.details);
+    return {
+      error: {
+        code: statusCode,
+        status,
+        message,
+        ...details ? { details } : {}
+      }
+    };
+  }
+  if (isPlainObject(result)) {
+    const statusCode = typeof result.code === "number" ? result.code : 422;
+    const status = typeof result.status === "string" ? result.status : (0, import_http_errors.getCanonicalStatus)(statusCode);
+    const message = typeof result.message === "string" ? result.message : "";
+    const details = toArray(result.details) || [(0, import_http_errors.createAip193ErrorInfoDetail)(status, errorDomain)];
+    return {
+      error: {
+        code: statusCode,
+        status,
+        message,
+        ...details ? { details } : {}
+      }
+    };
+  }
+  return {
+    error: {
+      code: 422,
+      status: (0, import_http_errors.getCanonicalStatus)(422),
+      message: String(result),
+      details: [(0, import_http_errors.createAip193ErrorInfoDetail)((0, import_http_errors.getCanonicalStatus)(422), errorDomain)]
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultErrorMessageProvider,
+  toSimpleErrorPayload,
+  toStructuredGenericErrorPayload,
+  toStructuredHttpErrorPayload
+});