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

package/error-format.mjs

@@ -0,0 +1,86 @@
+import "./chunk-PQJP2ZCI.mjs";
+import {
+  createAip193ErrorInfoDetail,
+  getCanonicalStatus,
+  toAip193ErrorPayload
+} from "@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) => 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 : 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 : getCanonicalStatus(statusCode);
+    const message = typeof result.message === "string" ? result.message : "";
+    const details = toArray(result.details) || [createAip193ErrorInfoDetail(status, errorDomain)];
+    return {
+      error: {
+        code: statusCode,
+        status,
+        message,
+        ...details ? { details } : {}
+      }
+    };
+  }
+  return {
+    error: {
+      code: 422,
+      status: getCanonicalStatus(422),
+      message: String(result),
+      details: [createAip193ErrorInfoDetail(getCanonicalStatus(422), errorDomain)]
+    }
+  };
+};
+export {
+  defaultErrorMessageProvider,
+  toSimpleErrorPayload,
+  toStructuredGenericErrorPayload,
+  toStructuredHttpErrorPayload
+};

package/http-response.d.mts

@@ -0,0 +1,54 @@
+import * as _web_ts_toolkit_http_errors from '@web-ts-toolkit/http-errors';
+import { BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, MethodNotAllowedError, NotAcceptableError, ProxyAuthRequiredError, RequestTimeoutError, ConflictError, GoneError, LengthRequiredError, PreconditionFailedError, PayloadTooLargeError, UriTooLongError, UnsupportedMediaTypeError, RequestedRangeNotSatisfiableError, ExpectationFailedError, TeapotError, MisdirectedRequestError, UnprocessableEntityError, LockedError, FailedDependencyError, UpgradeRequiredError, PreconditionRequiredError, TooManyRequestsError, RequestHeaderFieldsTooLargeError, UnavailableForLegalReasonsError } from '@web-ts-toolkit/http-errors';
+import { OK, Created, Accepted, NonAuthoritativeInfo, NoContent, ResetContent, PartialContent, MultiStatus, AlreadyReported, IMUsed } from './responses/success.mjs';
+import { CSVResponse } from './responses/csv.mjs';
+import './responses/index.mjs';
+
+declare const HttpResponse: {
+    ok: (data: unknown) => OK<unknown>;
+    created: (data: unknown) => Created<unknown>;
+    accepted: (data: unknown) => Accepted<unknown>;
+    nonAuthoritativeInfo: (data: unknown) => NonAuthoritativeInfo<unknown>;
+    noContent: (data: unknown) => NoContent<unknown>;
+    resetContent: (data: unknown) => ResetContent<unknown>;
+    partialContent: (data: unknown) => PartialContent<unknown>;
+    multiStatus: (data: unknown) => MultiStatus<unknown>;
+    alreadyReported: (data: unknown) => AlreadyReported<unknown>;
+    imUsed: (data: unknown) => IMUsed<unknown>;
+    badRequest: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => BadRequestError;
+    unauthorized: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UnauthorizedError;
+    forbidden: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => ForbiddenError;
+    notFound: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => NotFoundError;
+    methodNotAllowed: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => MethodNotAllowedError;
+    notAcceptable: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => NotAcceptableError;
+    proxyAuthRequired: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => ProxyAuthRequiredError;
+    requestTimeout: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => RequestTimeoutError;
+    conflict: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => ConflictError;
+    gone: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => GoneError;
+    lengthRequired: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => LengthRequiredError;
+    preconditionFailed: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => PreconditionFailedError;
+    payloadTooLarge: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => PayloadTooLargeError;
+    uriTooLong: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UriTooLongError;
+    unsupportedMediaType: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UnsupportedMediaTypeError;
+    requestedRangeNotSatisfiable: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => RequestedRangeNotSatisfiableError;
+    expectationFailed: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => ExpectationFailedError;
+    teapot: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => TeapotError;
+    misdirectedRequest: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => MisdirectedRequestError;
+    unprocessableEntity: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UnprocessableEntityError;
+    locked: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => LockedError;
+    failedDependency: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => FailedDependencyError;
+    upgradeRequired: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UpgradeRequiredError;
+    preconditionRequired: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => PreconditionRequiredError;
+    tooManyRequests: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => TooManyRequestsError;
+    requestHeaderFieldsTooLarge: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => RequestHeaderFieldsTooLargeError;
+    unavailableForLegalReasons: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UnavailableForLegalReasonsError;
+    json: (data: unknown) => OK<unknown>;
+    csv: (dataset?: unknown, options?: {
+        filename?: string;
+        headers?: boolean;
+        processor?: (value: unknown) => unknown;
+    } | undefined) => CSVResponse;
+};
+type HttpResponseHelpers = typeof HttpResponse;
+
+export { HttpResponse, type HttpResponseHelpers };

package/http-response.d.ts

@@ -0,0 +1,54 @@
+import * as _web_ts_toolkit_http_errors from '@web-ts-toolkit/http-errors';
+import { BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, MethodNotAllowedError, NotAcceptableError, ProxyAuthRequiredError, RequestTimeoutError, ConflictError, GoneError, LengthRequiredError, PreconditionFailedError, PayloadTooLargeError, UriTooLongError, UnsupportedMediaTypeError, RequestedRangeNotSatisfiableError, ExpectationFailedError, TeapotError, MisdirectedRequestError, UnprocessableEntityError, LockedError, FailedDependencyError, UpgradeRequiredError, PreconditionRequiredError, TooManyRequestsError, RequestHeaderFieldsTooLargeError, UnavailableForLegalReasonsError } from '@web-ts-toolkit/http-errors';
+import { OK, Created, Accepted, NonAuthoritativeInfo, NoContent, ResetContent, PartialContent, MultiStatus, AlreadyReported, IMUsed } from './responses/success.js';
+import { CSVResponse } from './responses/csv.js';
+import './responses/index.js';
+
+declare const HttpResponse: {
+    ok: (data: unknown) => OK<unknown>;
+    created: (data: unknown) => Created<unknown>;
+    accepted: (data: unknown) => Accepted<unknown>;
+    nonAuthoritativeInfo: (data: unknown) => NonAuthoritativeInfo<unknown>;
+    noContent: (data: unknown) => NoContent<unknown>;
+    resetContent: (data: unknown) => ResetContent<unknown>;
+    partialContent: (data: unknown) => PartialContent<unknown>;
+    multiStatus: (data: unknown) => MultiStatus<unknown>;
+    alreadyReported: (data: unknown) => AlreadyReported<unknown>;
+    imUsed: (data: unknown) => IMUsed<unknown>;
+    badRequest: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => BadRequestError;
+    unauthorized: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UnauthorizedError;
+    forbidden: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => ForbiddenError;
+    notFound: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => NotFoundError;
+    methodNotAllowed: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => MethodNotAllowedError;
+    notAcceptable: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => NotAcceptableError;
+    proxyAuthRequired: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => ProxyAuthRequiredError;
+    requestTimeout: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => RequestTimeoutError;
+    conflict: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => ConflictError;
+    gone: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => GoneError;
+    lengthRequired: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => LengthRequiredError;
+    preconditionFailed: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => PreconditionFailedError;
+    payloadTooLarge: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => PayloadTooLargeError;
+    uriTooLong: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UriTooLongError;
+    unsupportedMediaType: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UnsupportedMediaTypeError;
+    requestedRangeNotSatisfiable: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => RequestedRangeNotSatisfiableError;
+    expectationFailed: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => ExpectationFailedError;
+    teapot: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => TeapotError;
+    misdirectedRequest: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => MisdirectedRequestError;
+    unprocessableEntity: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UnprocessableEntityError;
+    locked: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => LockedError;
+    failedDependency: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => FailedDependencyError;
+    upgradeRequired: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UpgradeRequiredError;
+    preconditionRequired: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => PreconditionRequiredError;
+    tooManyRequests: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => TooManyRequestsError;
+    requestHeaderFieldsTooLarge: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => RequestHeaderFieldsTooLargeError;
+    unavailableForLegalReasons: (message?: string | undefined, options?: _web_ts_toolkit_http_errors.HttpErrorOptions | undefined) => UnavailableForLegalReasonsError;
+    json: (data: unknown) => OK<unknown>;
+    csv: (dataset?: unknown, options?: {
+        filename?: string;
+        headers?: boolean;
+        processor?: (value: unknown) => unknown;
+    } | undefined) => CSVResponse;
+};
+type HttpResponseHelpers = typeof HttpResponse;
+
+export { HttpResponse, type HttpResponseHelpers };

package/http-response.js

@@ -0,0 +1,71 @@
+"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 http_response_exports = {};
+__export(http_response_exports, {
+  HttpResponse: () => HttpResponse
+});
+module.exports = __toCommonJS(http_response_exports);
+var import_success = require("./responses/success");
+var import_csv = require("./responses/csv");
+var import_http_errors = require("@web-ts-toolkit/http-errors");
+const HttpResponse = {
+  ok: (...args) => new import_success.OK(...args),
+  created: (...args) => new import_success.Created(...args),
+  accepted: (...args) => new import_success.Accepted(...args),
+  nonAuthoritativeInfo: (...args) => new import_success.NonAuthoritativeInfo(...args),
+  noContent: (...args) => new import_success.NoContent(...args),
+  resetContent: (...args) => new import_success.ResetContent(...args),
+  partialContent: (...args) => new import_success.PartialContent(...args),
+  multiStatus: (...args) => new import_success.MultiStatus(...args),
+  alreadyReported: (...args) => new import_success.AlreadyReported(...args),
+  imUsed: (...args) => new import_success.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 import_success.OK(...args),
+  csv: (...args) => new import_csv.CSVResponse(...args)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpResponse
+});

package/http-response.mjs

@@ -0,0 +1,87 @@
+import "./chunk-PQJP2ZCI.mjs";
+import {
+  Accepted,
+  AlreadyReported,
+  Created,
+  IMUsed,
+  MultiStatus,
+  NoContent,
+  NonAuthoritativeInfo,
+  OK,
+  PartialContent,
+  ResetContent
+} from "./responses/success";
+import { CSVResponse } from "./responses/csv";
+import {
+  BadRequestError,
+  ConflictError,
+  ExpectationFailedError,
+  FailedDependencyError,
+  ForbiddenError,
+  GoneError,
+  LengthRequiredError,
+  LockedError,
+  MethodNotAllowedError,
+  MisdirectedRequestError,
+  NotAcceptableError,
+  NotFoundError,
+  PayloadTooLargeError,
+  PreconditionFailedError,
+  PreconditionRequiredError,
+  ProxyAuthRequiredError,
+  RequestHeaderFieldsTooLargeError,
+  RequestedRangeNotSatisfiableError,
+  RequestTimeoutError,
+  TeapotError,
+  TooManyRequestsError,
+  UnauthorizedError,
+  UnavailableForLegalReasonsError,
+  UnprocessableEntityError,
+  UnsupportedMediaTypeError,
+  UpgradeRequiredError,
+  UriTooLongError
+} from "@web-ts-toolkit/http-errors";
+const 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 BadRequestError(...args),
+  unauthorized: (...args) => new UnauthorizedError(...args),
+  forbidden: (...args) => new ForbiddenError(...args),
+  notFound: (...args) => new NotFoundError(...args),
+  methodNotAllowed: (...args) => new MethodNotAllowedError(...args),
+  notAcceptable: (...args) => new NotAcceptableError(...args),
+  proxyAuthRequired: (...args) => new ProxyAuthRequiredError(...args),
+  requestTimeout: (...args) => new RequestTimeoutError(...args),
+  conflict: (...args) => new ConflictError(...args),
+  gone: (...args) => new GoneError(...args),
+  lengthRequired: (...args) => new LengthRequiredError(...args),
+  preconditionFailed: (...args) => new PreconditionFailedError(...args),
+  payloadTooLarge: (...args) => new PayloadTooLargeError(...args),
+  uriTooLong: (...args) => new UriTooLongError(...args),
+  unsupportedMediaType: (...args) => new UnsupportedMediaTypeError(...args),
+  requestedRangeNotSatisfiable: (...args) => new RequestedRangeNotSatisfiableError(...args),
+  expectationFailed: (...args) => new ExpectationFailedError(...args),
+  teapot: (...args) => new TeapotError(...args),
+  misdirectedRequest: (...args) => new MisdirectedRequestError(...args),
+  unprocessableEntity: (...args) => new UnprocessableEntityError(...args),
+  locked: (...args) => new LockedError(...args),
+  failedDependency: (...args) => new FailedDependencyError(...args),
+  upgradeRequired: (...args) => new UpgradeRequiredError(...args),
+  preconditionRequired: (...args) => new PreconditionRequiredError(...args),
+  tooManyRequests: (...args) => new TooManyRequestsError(...args),
+  requestHeaderFieldsTooLarge: (...args) => new RequestHeaderFieldsTooLargeError(...args),
+  unavailableForLegalReasons: (...args) => new UnavailableForLegalReasonsError(...args),
+  json: (...args) => new OK(...args),
+  csv: (...args) => new CSVResponse(...args)
+};
+export {
+  HttpResponse
+};

package/index.d.mts

@@ -0,0 +1,10 @@
+import { ExpressResponseHandler } from './public-types.mjs';
+import './http-response.mjs';
+import '@web-ts-toolkit/http-errors';
+import './responses/success.mjs';
+import './responses/index.mjs';
+import './responses/csv.mjs';
+
+declare const apiHandler: ExpressResponseHandler;
+
+export { apiHandler as default };

package/index.d.ts

@@ -0,0 +1,10 @@
+import { ExpressResponseHandler } from './public-types.js';
+import './http-response.js';
+import '@web-ts-toolkit/http-errors';
+import './responses/success.js';
+import './responses/index.js';
+import './responses/csv.js';
+
+declare const apiHandler: ExpressResponseHandler;
+
+export { apiHandler as default };

package/index.js

@@ -0,0 +1,4 @@
+"use strict";
+var import_create_express_response_handler = require("./create-express-response-handler");
+const apiHandler = (0, import_create_express_response_handler.createExpressResponseHandler)();
+module.exports = apiHandler;

package/index.mjs

@@ -0,0 +1,11 @@
+import {
+  __commonJS
+} from "./chunk-PQJP2ZCI.mjs";
+import { createExpressResponseHandler } from "./create-express-response-handler";
+var require_index = __commonJS({
+  "src/index.ts"(exports, module) {
+    const apiHandler = createExpressResponseHandler();
+    module.exports = apiHandler;
+  }
+});
+export default require_index();

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@web-ts-toolkit/express-response-handler",
+  "description": "Express response handler",
+  "version": "0.0.2",
+  "keywords": [
+    "express",
+    "api",
+    "request",
+    "handler"
+  ],
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./types": {
+      "types": "./public-types.d.ts",
+      "import": "./public-types.mjs",
+      "require": "./public-types.js",
+      "default": "./public-types.js"
+    },
+    "./responses": {
+      "types": "./responses/index.d.ts",
+      "import": "./responses/index.mjs",
+      "require": "./responses/index.js",
+      "default": "./responses/index.js"
+    },
+    "./responses/csv": {
+      "types": "./responses/csv.d.ts",
+      "import": "./responses/csv.mjs",
+      "require": "./responses/csv.js",
+      "default": "./responses/csv.js"
+    },
+    "./responses/success": {
+      "types": "./responses/success.d.ts",
+      "import": "./responses/success.mjs",
+      "require": "./responses/success.js",
+      "default": "./responses/success.js"
+    }
+  },
+  "dependencies": {
+    "@fast-csv/format": "^5.0.5",
+    "@web-ts-toolkit/http-errors": "0.0.2"
+  },
+  "author": "Junmin Dev",
+  "bugs": {
+    "url": "https://github.com/egose/web-ts-toolkit/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/egose/web-ts-toolkit.git",
+    "directory": "packages/express-response-handler"
+  }
+}

package/public-types.d.mts

@@ -0,0 +1,62 @@
+import { HttpResponseHelpers } from './http-response.mjs';
+import '@web-ts-toolkit/http-errors';
+import './responses/success.mjs';
+import './responses/index.mjs';
+import './responses/csv.mjs';
+
+type ErrorMessageResult = string | Record<string, unknown>;
+type ErrorMessageProvider = (error: unknown) => ErrorMessageResult;
+type ErrorFormat = 'simple' | 'aip193';
+type MaybePromise<T> = T | Promise<T>;
+type Hook = (value: unknown) => unknown;
+type AsyncHook = (value: unknown) => Promise<unknown>;
+type NextFunction = (error?: unknown) => void;
+type ExpressResponseHandlerOptions = {
+    errorFormat?: ErrorFormat;
+    errorDomain?: string;
+};
+type ResponseLike = {
+    headersSent: boolean;
+    status(code: number): ResponseLike;
+    json(data: unknown): unknown;
+    send(data: unknown): unknown;
+    set(name: string, value: string): unknown;
+    end(): void;
+};
+type EventState = {
+    canceled: boolean;
+    nextError: unknown;
+};
+type MiddlewareFunction<Request = unknown, Response extends ResponseLike = ResponseLike, Return = unknown> = (req: Request, res: Response, next: NextFunction) => MaybePromise<Return>;
+type RouterFunction<Request = unknown, Response extends ResponseLike = ResponseLike> = (req: Request, res: Response, next: NextFunction) => void;
+type HandleResponse = {
+    <Request = unknown, Response extends ResponseLike = ResponseLike, Return = unknown>(fn: MiddlewareFunction<Request, Response, Return>): RouterFunction<Request, Response>;
+    <Request = unknown, Response extends ResponseLike = ResponseLike, Return = unknown>(...fns: Array<MiddlewareFunction<Request, Response, Return>>): Array<RouterFunction<Request, Response>>;
+    <Request = unknown, Response extends ResponseLike = ResponseLike, Return = unknown>(fns: Array<MiddlewareFunction<Request, Response, Return>>): Array<RouterFunction<Request, Response>>;
+};
+type ErrorWithPayload = {
+    statusCode?: number;
+    message?: string;
+    errors?: unknown;
+    _message?: string;
+    status?: string;
+    reason?: string;
+    domain?: string;
+    metadata?: unknown;
+    details?: unknown;
+};
+type ExpressResponseHandlerFactory = (options?: ExpressResponseHandlerOptions) => ExpressResponseHandler;
+type ExpressResponseHandler = {
+    handleResponse: HandleResponse;
+    handleResult: (res: ResponseLike, result: unknown, event: EventState) => void;
+    handlePromise: (res: ResponseLike, promise: Promise<unknown>, event: EventState) => void;
+    HttpResponse: HttpResponseHelpers;
+    createExpressResponseHandler: ExpressResponseHandlerFactory;
+    errorMessageProvider: ErrorMessageProvider;
+    preJson: Hook | null;
+    postJson: Hook | null;
+    preError: Hook | null;
+    postError: Hook | null;
+};
+
+export { type AsyncHook, type ErrorFormat, type ErrorMessageProvider, type ErrorMessageResult, type ErrorWithPayload, type EventState, type ExpressResponseHandler, type ExpressResponseHandlerFactory, type ExpressResponseHandlerOptions, type HandleResponse, type Hook, HttpResponseHelpers, type MaybePromise, type MiddlewareFunction, type NextFunction, type ResponseLike, type RouterFunction };

package/public-types.d.ts

@@ -0,0 +1,62 @@
+import { HttpResponseHelpers } from './http-response.js';
+import '@web-ts-toolkit/http-errors';
+import './responses/success.js';
+import './responses/index.js';
+import './responses/csv.js';
+
+type ErrorMessageResult = string | Record<string, unknown>;
+type ErrorMessageProvider = (error: unknown) => ErrorMessageResult;
+type ErrorFormat = 'simple' | 'aip193';
+type MaybePromise<T> = T | Promise<T>;
+type Hook = (value: unknown) => unknown;
+type AsyncHook = (value: unknown) => Promise<unknown>;
+type NextFunction = (error?: unknown) => void;
+type ExpressResponseHandlerOptions = {
+    errorFormat?: ErrorFormat;
+    errorDomain?: string;
+};
+type ResponseLike = {
+    headersSent: boolean;
+    status(code: number): ResponseLike;
+    json(data: unknown): unknown;
+    send(data: unknown): unknown;
+    set(name: string, value: string): unknown;
+    end(): void;
+};
+type EventState = {
+    canceled: boolean;
+    nextError: unknown;
+};
+type MiddlewareFunction<Request = unknown, Response extends ResponseLike = ResponseLike, Return = unknown> = (req: Request, res: Response, next: NextFunction) => MaybePromise<Return>;
+type RouterFunction<Request = unknown, Response extends ResponseLike = ResponseLike> = (req: Request, res: Response, next: NextFunction) => void;
+type HandleResponse = {
+    <Request = unknown, Response extends ResponseLike = ResponseLike, Return = unknown>(fn: MiddlewareFunction<Request, Response, Return>): RouterFunction<Request, Response>;
+    <Request = unknown, Response extends ResponseLike = ResponseLike, Return = unknown>(...fns: Array<MiddlewareFunction<Request, Response, Return>>): Array<RouterFunction<Request, Response>>;
+    <Request = unknown, Response extends ResponseLike = ResponseLike, Return = unknown>(fns: Array<MiddlewareFunction<Request, Response, Return>>): Array<RouterFunction<Request, Response>>;
+};
+type ErrorWithPayload = {
+    statusCode?: number;
+    message?: string;
+    errors?: unknown;
+    _message?: string;
+    status?: string;
+    reason?: string;
+    domain?: string;
+    metadata?: unknown;
+    details?: unknown;
+};
+type ExpressResponseHandlerFactory = (options?: ExpressResponseHandlerOptions) => ExpressResponseHandler;
+type ExpressResponseHandler = {
+    handleResponse: HandleResponse;
+    handleResult: (res: ResponseLike, result: unknown, event: EventState) => void;
+    handlePromise: (res: ResponseLike, promise: Promise<unknown>, event: EventState) => void;
+    HttpResponse: HttpResponseHelpers;
+    createExpressResponseHandler: ExpressResponseHandlerFactory;
+    errorMessageProvider: ErrorMessageProvider;
+    preJson: Hook | null;
+    postJson: Hook | null;
+    preError: Hook | null;
+    postError: Hook | null;
+};
+
+export { type AsyncHook, type ErrorFormat, type ErrorMessageProvider, type ErrorMessageResult, type ErrorWithPayload, type EventState, type ExpressResponseHandler, type ExpressResponseHandlerFactory, type ExpressResponseHandlerOptions, type HandleResponse, type Hook, HttpResponseHelpers, type MaybePromise, type MiddlewareFunction, type NextFunction, type ResponseLike, type RouterFunction };

package/public-types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 public_types_exports = {};
+module.exports = __toCommonJS(public_types_exports);

package/responses/csv.d.mts

@@ -0,0 +1,21 @@
+type CsvProcessor = (value: unknown) => unknown;
+type CsvResponseOptions = {
+    filename?: string;
+    headers?: boolean;
+    processor?: CsvProcessor;
+};
+type CsvStreamResponse = {
+    set(name: string, value: string): unknown;
+    destroy?(error?: Error): void;
+    end(): void;
+};
+declare class CSVResponse {
+    readonly dataset: unknown[];
+    readonly filename: string;
+    readonly processor: CsvProcessor;
+    readonly headers?: boolean;
+    constructor(dataset?: unknown, options?: CsvResponseOptions);
+    streamCsv(res: CsvStreamResponse): void;
+}
+
+export { CSVResponse };

package/responses/csv.d.ts

@@ -0,0 +1,21 @@
+type CsvProcessor = (value: unknown) => unknown;
+type CsvResponseOptions = {
+    filename?: string;
+    headers?: boolean;
+    processor?: CsvProcessor;
+};
+type CsvStreamResponse = {
+    set(name: string, value: string): unknown;
+    destroy?(error?: Error): void;
+    end(): void;
+};
+declare class CSVResponse {
+    readonly dataset: unknown[];
+    readonly filename: string;
+    readonly processor: CsvProcessor;
+    readonly headers?: boolean;
+    constructor(dataset?: unknown, options?: CsvResponseOptions);
+    streamCsv(res: CsvStreamResponse): void;
+}
+
+export { CSVResponse };