@web-ts-toolkit/express-response-handler 0.31.0 → 0.31.2

package/create-handler.js

@@ -26,67 +26,340 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/create-handler.ts
 var create_handler_exports = {};
 __export(create_handler_exports, {
   createHandler: () => createHandler
 });
 module.exports = __toCommonJS(create_handler_exports);
 var import_assert = __toESM(require("assert"));
+var import_utils3 = require("@web-ts-toolkit/utils");
+
+// src/responses/csv.ts
+var import_format = require("@fast-csv/format");
 var import_utils = require("@web-ts-toolkit/utils");
-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");
-var import_error_formats = require("./error-formats");
-const promisify = (fn) => (value) => Promise.resolve().then(() => fn(value));
-const invokePostHook = (hook, value) => {
+var csvResponseBrand = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/express-response-handler.csv-response");
+var isCSVResponse = (value) => {
+  if (value instanceof CSVResponse) {
+    return true;
+  }
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return candidate[csvResponseBrand] === true && typeof candidate.streamCsv === "function";
+};
+var _a;
+_a = csvResponseBrand;
+var CSVResponse = class {
+  constructor(dataset = [], options = {}) {
+    this[_a] = true;
+    this.dataset = (0, import_utils.castArray)(dataset);
+    this.filename = options.filename || "download.csv";
+    this.processor = options.processor || ((value) => value);
+    if ((0, import_utils.isBoolean)(options.headers)) {
+      this.headers = options.headers;
+    } else if (this.dataset.length > 0) {
+      this.headers = (0, import_utils.isPlainObject)(this.dataset[0]);
+    }
+  }
+  streamCsv(res) {
+    const stream = (0, import_format.format)({ headers: this.headers });
+    res.set("Content-Type", "text/csv");
+    res.set("Content-Disposition", `attachment;filename=${this.filename}`);
+    stream.pipe(res);
+    stream.on("error", (error) => {
+      if (res.destroy) {
+        res.destroy(error);
+        return;
+      }
+      res.end();
+    });
+    stream.on("end", () => res.end());
+    this.dataset.forEach((value) => stream.write(this.processor(value)));
+    stream.end();
+  }
+};
+
+// src/responses/index.ts
+var responseBrand = /* @__PURE__ */ Symbol.for("@web-ts-toolkit/express-response-handler.response");
+var isResponse = (value) => {
+  if (value instanceof Response) {
+    return true;
+  }
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return candidate[responseBrand] === true && typeof candidate.statusCode === "number" && "data" in candidate;
+};
+var _a2;
+_a2 = responseBrand;
+var Response = class {
+  constructor(statusCode = 200, data) {
+    this[_a2] = true;
+    this.statusCode = statusCode;
+    this.data = data;
+  }
+};
+
+// src/responses/success.ts
+var OK = class extends Response {
+  constructor(data) {
+    super(200, data);
+  }
+};
+var Created = class extends Response {
+  constructor(data) {
+    super(201, data);
+  }
+};
+var Accepted = class extends Response {
+  constructor(data) {
+    super(202, data);
+  }
+};
+var NonAuthoritativeInfo = class extends Response {
+  constructor(data) {
+    super(203, data);
+  }
+};
+var NoContent = class extends Response {
+  constructor() {
+    super(204, void 0);
+  }
+};
+var ResetContent = class extends Response {
+  constructor(data) {
+    super(205, data);
+  }
+};
+var PartialContent = class extends Response {
+  constructor(data) {
+    super(206, data);
+  }
+};
+var MultiStatus = class extends Response {
+  constructor(data) {
+    super(207, data);
+  }
+};
+var AlreadyReported = class extends Response {
+  constructor(data) {
+    super(208, data);
+  }
+};
+var IMUsed = class extends Response {
+  constructor(data) {
+    super(226, data);
+  }
+};
+
+// src/http-response.ts
+var import_http_errors = require("@web-ts-toolkit/http-errors");
+var HttpResponse = {
+  ok: (...args) => new OK(...args),
+  created: (...args) => new Created(...args),
+  accepted: (...args) => new Accepted(...args),
+  nonAuthoritativeInfo: (...args) => new NonAuthoritativeInfo(...args),
+  noContent: (...args) => new NoContent(...args),
+  resetContent: (...args) => new ResetContent(...args),
+  partialContent: (...args) => new PartialContent(...args),
+  multiStatus: (...args) => new MultiStatus(...args),
+  alreadyReported: (...args) => new AlreadyReported(...args),
+  imUsed: (...args) => new IMUsed(...args),
+  badRequest: (...args) => new import_http_errors.BadRequestError(...args),
+  unauthorized: (...args) => new import_http_errors.UnauthorizedError(...args),
+  forbidden: (...args) => new import_http_errors.ForbiddenError(...args),
+  notFound: (...args) => new import_http_errors.NotFoundError(...args),
+  methodNotAllowed: (...args) => new import_http_errors.MethodNotAllowedError(...args),
+  notAcceptable: (...args) => new import_http_errors.NotAcceptableError(...args),
+  proxyAuthRequired: (...args) => new import_http_errors.ProxyAuthRequiredError(...args),
+  requestTimeout: (...args) => new import_http_errors.RequestTimeoutError(...args),
+  conflict: (...args) => new import_http_errors.ConflictError(...args),
+  gone: (...args) => new import_http_errors.GoneError(...args),
+  lengthRequired: (...args) => new import_http_errors.LengthRequiredError(...args),
+  preconditionFailed: (...args) => new import_http_errors.PreconditionFailedError(...args),
+  payloadTooLarge: (...args) => new import_http_errors.PayloadTooLargeError(...args),
+  uriTooLong: (...args) => new import_http_errors.UriTooLongError(...args),
+  unsupportedMediaType: (...args) => new import_http_errors.UnsupportedMediaTypeError(...args),
+  requestedRangeNotSatisfiable: (...args) => new import_http_errors.RequestedRangeNotSatisfiableError(...args),
+  expectationFailed: (...args) => new import_http_errors.ExpectationFailedError(...args),
+  teapot: (...args) => new import_http_errors.TeapotError(...args),
+  misdirectedRequest: (...args) => new import_http_errors.MisdirectedRequestError(...args),
+  unprocessableEntity: (...args) => new import_http_errors.UnprocessableEntityError(...args),
+  locked: (...args) => new import_http_errors.LockedError(...args),
+  failedDependency: (...args) => new import_http_errors.FailedDependencyError(...args),
+  upgradeRequired: (...args) => new import_http_errors.UpgradeRequiredError(...args),
+  preconditionRequired: (...args) => new import_http_errors.PreconditionRequiredError(...args),
+  tooManyRequests: (...args) => new import_http_errors.TooManyRequestsError(...args),
+  requestHeaderFieldsTooLarge: (...args) => new import_http_errors.RequestHeaderFieldsTooLargeError(...args),
+  unavailableForLegalReasons: (...args) => new import_http_errors.UnavailableForLegalReasonsError(...args),
+  json: (...args) => new OK(...args),
+  csv: (...args) => new CSVResponse(...args)
+};
+
+// src/error-format.ts
+var import_http_errors2 = require("@web-ts-toolkit/http-errors");
+var import_utils2 = require("@web-ts-toolkit/utils");
+var toStatusCode = (status, code, fallbackStatusCode) => {
+  if (typeof status === "number") {
+    return status;
+  }
+  return typeof code === "number" ? code : fallbackStatusCode;
+};
+var toOptionalString = (value) => typeof value === "string" ? value : void 0;
+var toMetadata = (value) => {
+  return (0, import_utils2.toStringRecord)(value);
+};
+var toArray = (value) => {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  return (0, import_utils2.isArray)(value) ? value : [value];
+};
+var 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,
+  type: error.type,
+  title: error.title,
+  instance: error.instance
+});
+var toProblemDetailsSource = (result) => {
+  if ((0, import_utils2.isPlainObject)(result) && (0, import_utils2.isPlainObject)(result.error)) {
+    return result.error;
+  }
+  return (0, import_utils2.isPlainObject)(result) ? result : void 0;
+};
+var defaultErrorMessageProvider = function(error) {
+  const errorLike = error;
+  return errorLike.message ?? errorLike._message ?? String(error);
+};
+var toSimpleErrorPayload = (result) => (0, import_utils2.isString)(result) ? { message: result } : { ...result };
+var toStructuredHttpErrorPayload = (error, errorDomain) => (0, import_http_errors2.toAip193ErrorPayload)(toHttpErrorShape(error, errorDomain), errorDomain);
+var toRfc9457HttpErrorPayload = (error, errorDomain) => (0, import_http_errors2.toRfc9457ErrorPayload)(toHttpErrorShape(error, errorDomain));
+var toStructuredGenericErrorPayload = (result, errorDomain) => {
+  if ((0, import_utils2.isPlainObject)(result) && (0, import_utils2.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_errors2.getCanonicalStatus)(statusCode);
+    const message = typeof error.message === "string" ? error.message : "";
+    const details = toArray(error.details);
+    return {
+      error: {
+        code: statusCode,
+        status,
+        message,
+        ...details ? { details } : {}
+      }
+    };
+  }
+  if ((0, import_utils2.isPlainObject)(result)) {
+    const statusCode = typeof result.code === "number" ? result.code : 422;
+    const status = typeof result.status === "string" ? result.status : (0, import_http_errors2.getCanonicalStatus)(statusCode);
+    const message = typeof result.message === "string" ? result.message : "";
+    const details = toArray(result.details) || [(0, import_http_errors2.createAip193ErrorInfoDetail)(status, errorDomain)];
+    return {
+      error: {
+        code: statusCode,
+        status,
+        message,
+        ...details ? { details } : {}
+      }
+    };
+  }
+  return {
+    error: {
+      code: 422,
+      status: (0, import_http_errors2.getCanonicalStatus)(422),
+      message: String(result),
+      details: [(0, import_http_errors2.createAip193ErrorInfoDetail)((0, import_http_errors2.getCanonicalStatus)(422), errorDomain)]
+    }
+  };
+};
+var toRfc9457GenericErrorPayload = (result) => {
+  const problem = toProblemDetailsSource(result);
+  if (problem) {
+    const statusCode = toStatusCode(problem.status, problem.code, 422);
+    return (0, import_http_errors2.toRfc9457ErrorPayload)({
+      statusCode,
+      message: toOptionalString(problem.detail) ?? toOptionalString(problem.message) ?? "",
+      errors: problem.errors,
+      type: toOptionalString(problem.type),
+      title: toOptionalString(problem.title),
+      instance: toOptionalString(problem.instance)
+    });
+  }
+  return (0, import_http_errors2.toRfc9457ErrorPayload)({
+    statusCode: 422,
+    message: String(result)
+  });
+};
+
+// src/error-formats.ts
+var ErrorFormats = {
+  simple: "simple",
+  aip193: "aip193",
+  rfc9457: "rfc9457"
+};
+
+// src/create-handler.ts
+var promisify = (fn) => (value) => Promise.resolve().then(() => fn(value));
+var invokePostHook = (hook, value) => {
   void hook(value).catch(() => void 0);
 };
-const RFC_9457_CONTENT_TYPE = "application/problem+json";
-const shouldSkipResponse = (res, event) => res.headersSent || event.canceled;
-const sendProblemJson = (res, statusCode, payload, contentType) => {
+var RFC_9457_CONTENT_TYPE = "application/problem+json";
+var shouldSkipResponse = (res, event) => res.headersSent || event.canceled;
+var sendProblemJson = (res, statusCode, payload, contentType) => {
   res.status(statusCode);
   res.set("Content-Type", contentType);
   res.send(payload);
 };
-const sendHttpErrorByFormat = {
-  [import_error_formats.ErrorFormats.simple]: (res, error) => {
+var sendHttpErrorByFormat = {
+  [ErrorFormats.simple]: (res, error) => {
     const payload = { message: error.message ?? "" };
     if (error.errors !== void 0) {
       payload.errors = error.errors;
     }
     res.status(error.statusCode ?? 500).send(payload);
   },
-  [import_error_formats.ErrorFormats.aip193]: (res, error, domain) => {
-    res.status(error.statusCode ?? 500).send((0, import_error_format.toStructuredHttpErrorPayload)(error, domain));
+  [ErrorFormats.aip193]: (res, error, domain) => {
+    res.status(error.statusCode ?? 500).send(toStructuredHttpErrorPayload(error, domain));
   },
-  [import_error_formats.ErrorFormats.rfc9457]: (res, error, domain) => {
-    sendProblemJson(res, error.statusCode ?? 500, (0, import_error_format.toRfc9457HttpErrorPayload)(error, domain), RFC_9457_CONTENT_TYPE);
+  [ErrorFormats.rfc9457]: (res, error, domain) => {
+    sendProblemJson(res, error.statusCode ?? 500, toRfc9457HttpErrorPayload(error, domain), RFC_9457_CONTENT_TYPE);
   }
 };
-const sendGenericErrorByFormat = {
-  [import_error_formats.ErrorFormats.simple]: (res, result) => {
-    res.status(422).send((0, import_error_format.toSimpleErrorPayload)(result));
+var sendGenericErrorByFormat = {
+  [ErrorFormats.simple]: (res, result) => {
+    res.status(422).send(toSimpleErrorPayload(result));
   },
-  [import_error_formats.ErrorFormats.aip193]: (res, result, domain) => {
-    const payload = (0, import_error_format.toStructuredGenericErrorPayload)(result, domain);
+  [ErrorFormats.aip193]: (res, result, domain) => {
+    const payload = toStructuredGenericErrorPayload(result, domain);
     res.status(payload.error.code).send(payload);
   },
-  [import_error_formats.ErrorFormats.rfc9457]: (res, result) => {
-    const payload = (0, import_error_format.toRfc9457GenericErrorPayload)(result);
+  [ErrorFormats.rfc9457]: (res, result) => {
+    const payload = toRfc9457GenericErrorPayload(result);
     sendProblemJson(res, payload.status ?? 422, payload, RFC_9457_CONTENT_TYPE);
   }
 };
-const assertMiddleware = (fn) => {
-  import_assert.default.ok((0, import_utils.isFunction)(fn), "middleware handler must be a function");
+var assertMiddleware = (fn) => {
+  import_assert.default.ok((0, import_utils3.isFunction)(fn), "middleware handler must be a function");
 };
-const normalizeMiddlewareList = (fns) => {
+var 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 ((0, import_utils.isArray)(fns[0])) {
+  if ((0, import_utils3.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];
@@ -95,10 +368,10 @@ const normalizeMiddlewareList = (fns) => {
   return [fns[0]];
 };
 function createHandler(options = {}) {
-  const errorFormat = options.errorFormat ?? import_error_formats.ErrorFormats.simple;
+  const errorFormat = options.errorFormat ?? ErrorFormats.simple;
   const errorDomain = options.errorDomain ?? "express-response-handler";
   const rfc9457ContentType = options.rfc9457ContentType ?? RFC_9457_CONTENT_TYPE;
-  let errorMessageProvider = import_error_format.defaultErrorMessageProvider;
+  let errorMessageProvider = defaultErrorMessageProvider;
   let preJson = null;
   let postJson = null;
   let preError = null;
@@ -113,7 +386,7 @@ function createHandler(options = {}) {
       rebuild();
       return;
     }
-    import_assert.default.ok((0, import_utils.isFunction)(fn), `${name} hook must be a function`);
+    import_assert.default.ok((0, import_utils3.isFunction)(fn), `${name} hook must be a function`);
     setState(fn, promisify(fn));
     rebuild();
   };
@@ -124,11 +397,11 @@ function createHandler(options = {}) {
     if (data === void 0) {
       return;
     }
-    if (data instanceof import_responses.Response) {
+    if (isResponse(data)) {
       res.status(data.statusCode).json(data.data);
       return;
     }
-    if (data instanceof import_csv.CSVResponse) {
+    if (isCSVResponse(data)) {
       data.streamCsv(res);
       return;
     }
@@ -140,11 +413,11 @@ function createHandler(options = {}) {
     }
     const error = err;
     if (error.statusCode) {
-      if (errorFormat === import_error_formats.ErrorFormats.rfc9457) {
+      if (errorFormat === ErrorFormats.rfc9457) {
         sendProblemJson(
           res,
           error.statusCode ?? 500,
-          (0, import_error_format.toRfc9457HttpErrorPayload)(error, errorDomain),
+          toRfc9457HttpErrorPayload(error, errorDomain),
           rfc9457ContentType
         );
         return;
@@ -153,8 +426,8 @@ function createHandler(options = {}) {
       return;
     }
     const result = errorMessageProvider(err);
-    if (errorFormat === import_error_formats.ErrorFormats.rfc9457) {
-      const payload = (0, import_error_format.toRfc9457GenericErrorPayload)(result);
+    if (errorFormat === ErrorFormats.rfc9457) {
+      const payload = toRfc9457GenericErrorPayload(result);
       sendProblemJson(res, payload.status ?? 422, payload, rfc9457ContentType);
       return;
     }
@@ -222,7 +495,7 @@ function createHandler(options = {}) {
       sendError(res, event.nextError, event);
       return;
     }
-    if ((0, import_utils.isPromise)(result)) {
+    if ((0, import_utils3.isPromise)(result)) {
       handlePromise(res, result, event);
       return;
     }
@@ -264,13 +537,13 @@ function createHandler(options = {}) {
     handleResponse,
     handleResult,
     handlePromise,
-    HttpResponse: import_http_response.HttpResponse,
+    HttpResponse,
     createHandler,
     get errorMessageProvider() {
       return errorMessageProvider;
     },
     set errorMessageProvider(fn) {
-      import_assert.default.ok((0, import_utils.isFunction)(fn), "error message provider must be a function");
+      import_assert.default.ok((0, import_utils3.isFunction)(fn), "error message provider must be a function");
       errorMessageProvider = fn;
     },
     get preJson() {