@jderstd/express 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present, Alpheus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# JDER Express
+
+A response builder for Express.
+
+This package includes different response builders based on the JSON response structure specified in [JSON Data Errors Response (JDER)](https://github.com/jder-std/spec). With the builders, various kinds of responses can be created easily instead of sending plain text responses.
+
+## Quick Start
+
+To create a JSON response, use the following code:
+
+```ts
+import type { Request, Response } from "express";
+
+import { createJsonResponse } from "@jderstd/express";
+
+const route = (req: Request, res: Response): Response => {
+    return createJsonResponse(res);
+}
+```
+
+And the response will be shown as below:
+
+```json
+{
+    "success": true
+}
+```
+
+## License
+
+This project is licensed under the terms of the MIT license.

package/dist/index.d.ts

@@ -0,0 +1,267 @@
+import { JsonResponse, JsonResponseError } from "@jderstd/core";
+import { ErrorRequestHandler, Response } from "express";
+import { CreateResponseStructOptions } from "@jderstd/core/response/common/struct";
+import { CreateJsonResponseStructOptions } from "@jderstd/core/response/json/struct";
+/** Options for `errorRequestHandler` function. */
+type ErrorRequestHandlerOptions = {
+  /**
+   * Whether show more information.
+   * By default, it's `false`.
+   */
+  verbose?: boolean;
+};
+/**
+ * Error request handler.
+ *
+ * Following response could be returned on error:
+ *
+ * ```jsonc
+ * // Status: 500
+ * {
+ *     "success": false,
+ *     "errors": [
+ *         {
+ *             "code": "server"
+ *         }
+ *     ]
+ * }
+ * ```
+ *
+ * ### Examples
+ *
+ * Basic example of using `errorRequestHandler` handler:
+ *
+ * ```js
+ * // JavaScript
+ *
+ * import express from "express";
+ * import { errorRequestHandler } from "@jderstd/express";
+ *
+ * const app = express();
+ *
+ * app.use(errorRequestHandler());
+ * ```
+ *
+ * ```ts
+ * // TypeScript
+ *
+ * import type { Express } from "express";
+ *
+ * import express from "express";
+ * import { errorRequestHandler } from "@jderstd/express";
+ *
+ * const app: Express = express();
+ *
+ * app.use(errorRequestHandler());
+ * ```
+ *
+ * Show more information with `verbose` option:
+ *
+ * ```js
+ * // JavaScript
+ *
+ * import express from "express";
+ * import { errorRequestHandler } from "@jderstd/express";
+ *
+ * const app = express();
+ *
+ * app.use(errorRequestHandler({ verbose: true }));
+ * ```
+ *
+ * ```ts
+ * // TypeScript
+ *
+ * import type { Express } from "express";
+ *
+ * import express from "express";
+ * import { errorRequestHandler } from "@jderstd/express";
+ *
+ * const app: Express = express();
+ *
+ * app.use(errorRequestHandler({ verbose: true }));
+ * ```
+ */
+declare const errorRequestHandler: (options?: ErrorRequestHandlerOptions) => ErrorRequestHandler;
+/** Options of `createResponse` function. */
+type CreateResponseOptions<B$1 extends BodyInit = BodyInit> = CreateResponseStructOptions<B$1>;
+/**
+ * Create a response.
+ *
+ * ### Examples
+ *
+ * Example for creating a basic response:
+ *
+ * ```js
+ * // JavaScript
+ *
+ * import { createResponse } from "@jderstd/express";
+ *
+ * const route = (req, res) => {
+ *     createResponse(res);
+ * };
+ * ```
+ *
+ * ```ts
+ * // TypeScript
+ *
+ * import type { Request, Response } from "express";
+ *
+ * import { createResponse } from "@jderstd/express";
+ *
+ * const route = (req: Request, res: Response): void => {
+ *     createResponse(res);
+ * };
+ * ```
+ *
+ * Example for creating a response with status, headers, and body:
+ *
+ * ```js
+ * // JavaScript
+ *
+ * import { createResponse } from "@jderstd/express";
+ *
+ * const route = (req, res) => {
+ *     createResponse(res, {
+ *         status: 404,
+ *         headers: [
+ *             ["Content-Type", "text/plain"],
+ *         ],
+ *         body: "Not Found",
+ *     });
+ * };
+ * ```
+ *
+ * ```ts
+ * // TypeScript
+ *
+ * import type { Request, Response } from "express";
+ *
+ * import { createResponse } from "@jderstd/express";
+ *
+ * const route = (req: Request, res: Response): void => {
+ *     createResponse(res, {
+ *         status: 404,
+ *         headers: [
+ *             ["Content-Type", "text/plain"],
+ *         ],
+ *         body: "Not Found",
+ *     });
+ * };
+ * ```
+ */
+declare const createResponse: <B extends BodyInit>(res: Response, options?: CreateResponseOptions<B>) => Response<any, Record<string, any>>;
+/** Options of `createJsonResponse` function. */
+type CreateJsonResponseOptions<D$1 = unknown> = CreateJsonResponseStructOptions<D$1>;
+/**
+ * Create a JSON response with context.
+ *
+ * ### Examples
+ *
+ * Example for creating a successful JSON response without data:
+ *
+ * ```js
+ * // JavaScript
+ *
+ * import { createJsonResponse } from "@jderstd/express";
+ *
+ * const route = (req, res) => {
+ *     createJsonResponse(res);
+ * };
+ * ```
+ *
+ * ```ts
+ * // TypeScript
+ *
+ * import type { Request, Response } from "express";
+ *
+ * import { createJsonResponse } from "@jderstd/express";
+ *
+ * const route = (req: Request, res: Response): void => {
+ *     createJsonResponse(res);
+ * };
+ * ```
+ *
+ * Example for creating a successful JSON response with data:
+ *
+ * ```js
+ * // JavaScript
+ *
+ * import { createJsonResponse } from "@jderstd/express";
+ *
+ * const route = (req, res) => {
+ *     return createJsonResponse(res, {
+ *         data: "Hello, World!",
+ *     });
+ * };
+ * ```
+ *
+ * ```ts
+ * // TypeScript
+ *
+ * import type { Request, Response } from "express";
+ *
+ * import { createJsonResponse } from "@jderstd/express";
+ *
+ * const route = (req: Request, res: Response): void => {
+ *     return createJsonResponse(res, {
+ *         data: "Hello, World!",
+ *     });
+ * };
+ * ```
+ *
+ * Example for creating a failed JSON response:
+ *
+ * ```js
+ * // JavaScript
+ *
+ * import { createJsonResponse } from "@jderstd/express";
+ *
+ * const route = (req, res) => {
+ *     return createJsonResponse(res, {
+ *         errors: [
+ *             {
+ *                 code: "server",
+ *                 message: "Internal server error",
+ *             },
+ *         ],
+ *     });
+ * };
+ * ```
+ *
+ * ```ts
+ * // TypeScript
+ *
+ * import type { Request, Response } from "express";
+ *
+ * import { createJsonResponse } from "@jderstd/express";
+ *
+ * const route = (req: Request, res: Response): void => {
+ *     return createJsonResponse(res, {
+ *         errors: [
+ *             {
+ *                 code: "server",
+ *                 message: "Internal server error",
+ *             },
+ *         ],
+ *     });
+ * };
+ * ```
+ */
+declare const createJsonResponse: <D = unknown>(res: Response, options?: CreateJsonResponseOptions<D>) => Response<any, Record<string, any>>;
+/**
+ * Response error code.
+ */
+declare enum ResponseErrorCode {
+  /**
+   * Internal server error.
+   *
+   * For `errorRequestHandler` function.
+   */
+  Server = "server",
+}
+/**
+ * Get response error message by code.
+ */
+declare const getResponseErrorMessage: (code: ResponseErrorCode) => string;
+export { type CreateJsonResponseOptions, type CreateResponseOptions, type ErrorRequestHandlerOptions, type JsonResponse, type JsonResponseError, ResponseErrorCode, createJsonResponse, createResponse, errorRequestHandler, getResponseErrorMessage };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,306 @@
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+let __jderstd_core_response_json_struct = require("@jderstd/core/response/json/struct");
+__jderstd_core_response_json_struct = __toESM(__jderstd_core_response_json_struct);
+let __jderstd_core_response_common_struct = require("@jderstd/core/response/common/struct");
+__jderstd_core_response_common_struct = __toESM(__jderstd_core_response_common_struct);
+
+/**
+* Response error code.
+*/
+var ResponseErrorCode = /* @__PURE__ */ function(ResponseErrorCode$1) {
+	/**
+	* Internal server error.
+	*
+	* For `errorRequestHandler` function.
+	*/
+	ResponseErrorCode$1["Server"] = "server";
+	return ResponseErrorCode$1;
+}(ResponseErrorCode || {});
+/**
+* Get response error message by code.
+*/
+const getResponseErrorMessage = (code) => {
+	switch (code) {
+		case ResponseErrorCode.Server: return "Internal server error";
+	}
+};
+
+/**
+* Create a JSON response with context.
+*
+* ### Examples
+*
+* Example for creating a successful JSON response without data:
+*
+* ```js
+* // JavaScript
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     createJsonResponse(res);
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     createJsonResponse(res);
+* };
+* ```
+*
+* Example for creating a successful JSON response with data:
+*
+* ```js
+* // JavaScript
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     return createJsonResponse(res, {
+*         data: "Hello, World!",
+*     });
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     return createJsonResponse(res, {
+*         data: "Hello, World!",
+*     });
+* };
+* ```
+*
+* Example for creating a failed JSON response:
+*
+* ```js
+* // JavaScript
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     return createJsonResponse(res, {
+*         errors: [
+*             {
+*                 code: "server",
+*                 message: "Internal server error",
+*             },
+*         ],
+*     });
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     return createJsonResponse(res, {
+*         errors: [
+*             {
+*                 code: "server",
+*                 message: "Internal server error",
+*             },
+*         ],
+*     });
+* };
+* ```
+*/
+const createJsonResponse = (res, options) => {
+	const { status, headers, json } = (0, __jderstd_core_response_json_struct.createJsonResponseStruct)(options);
+	return res.status(status).setHeaders(new Map(headers)).json(json);
+};
+
+/**
+* Error request handler.
+*
+* Following response could be returned on error:
+*
+* ```jsonc
+* // Status: 500
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "server"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Examples
+*
+* Basic example of using `errorRequestHandler` handler:
+*
+* ```js
+* // JavaScript
+*
+* import express from "express";
+* import { errorRequestHandler } from "@jderstd/express";
+*
+* const app = express();
+*
+* app.use(errorRequestHandler());
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Express } from "express";
+*
+* import express from "express";
+* import { errorRequestHandler } from "@jderstd/express";
+*
+* const app: Express = express();
+*
+* app.use(errorRequestHandler());
+* ```
+*
+* Show more information with `verbose` option:
+*
+* ```js
+* // JavaScript
+*
+* import express from "express";
+* import { errorRequestHandler } from "@jderstd/express";
+*
+* const app = express();
+*
+* app.use(errorRequestHandler({ verbose: true }));
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Express } from "express";
+*
+* import express from "express";
+* import { errorRequestHandler } from "@jderstd/express";
+*
+* const app: Express = express();
+*
+* app.use(errorRequestHandler({ verbose: true }));
+* ```
+*/
+const errorRequestHandler = (options) => {
+	return (err, _req, res, _next) => {
+		return createJsonResponse(res, {
+			status: 500,
+			errors: [{
+				code: ResponseErrorCode.Server,
+				...options?.verbose && { message: err instanceof Error ? err.message : String(err) }
+			}]
+		});
+	};
+};
+
+/**
+* Create a response.
+*
+* ### Examples
+*
+* Example for creating a basic response:
+*
+* ```js
+* // JavaScript
+*
+* import { createResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     createResponse(res);
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     createResponse(res);
+* };
+* ```
+*
+* Example for creating a response with status, headers, and body:
+*
+* ```js
+* // JavaScript
+*
+* import { createResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     createResponse(res, {
+*         status: 404,
+*         headers: [
+*             ["Content-Type", "text/plain"],
+*         ],
+*         body: "Not Found",
+*     });
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     createResponse(res, {
+*         status: 404,
+*         headers: [
+*             ["Content-Type", "text/plain"],
+*         ],
+*         body: "Not Found",
+*     });
+* };
+* ```
+*/
+const createResponse = (res, options) => {
+	const { status, headers, body } = (0, __jderstd_core_response_common_struct.createResponseStruct)(options);
+	return res.status(status).setHeaders(new Map(headers)).send(body);
+};
+
+exports.ResponseErrorCode = ResponseErrorCode;
+exports.createJsonResponse = createJsonResponse;
+exports.createResponse = createResponse;
+exports.errorRequestHandler = errorRequestHandler;
+exports.getResponseErrorMessage = getResponseErrorMessage;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/response/error/index.ts","../src/response/json/index.ts","../src/middlewares/error.ts","../src/response/common/index.ts"],"sourcesContent":["/**\n * Response error code.\n */\nenum ResponseErrorCode {\n    /**\n     * Internal server error.\n     *\n     * For `errorRequestHandler` function.\n     */\n    Server = \"server\",\n}\n\n/**\n * Get response error message by code.\n */\nconst getResponseErrorMessage = (code: ResponseErrorCode): string => {\n    switch (code) {\n        case ResponseErrorCode.Server: {\n            return \"Internal server error\";\n        }\n    }\n};\n\nexport { ResponseErrorCode, getResponseErrorMessage };\n","import type { CreateJsonResponseStructOptions } from \"@jderstd/core/response/json/struct\";\nimport type { Response } from \"express\";\n\nimport { createJsonResponseStruct } from \"@jderstd/core/response/json/struct\";\n\n/** Options of `createJsonResponse` function. */\ntype CreateJsonResponseOptions<D = unknown> =\n    CreateJsonResponseStructOptions<D>;\n\n/**\n * Create a JSON response with context.\n *\n * ### Examples\n *\n * Example for creating a successful JSON response without data:\n *\n * ```js\n * // JavaScript\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     createJsonResponse(res);\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     createJsonResponse(res);\n * };\n * ```\n *\n * Example for creating a successful JSON response with data:\n *\n * ```js\n * // JavaScript\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     return createJsonResponse(res, {\n *         data: \"Hello, World!\",\n *     });\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     return createJsonResponse(res, {\n *         data: \"Hello, World!\",\n *     });\n * };\n * ```\n *\n * Example for creating a failed JSON response:\n *\n * ```js\n * // JavaScript\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     return createJsonResponse(res, {\n *         errors: [\n *             {\n *                 code: \"server\",\n *                 message: \"Internal server error\",\n *             },\n *         ],\n *     });\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     return createJsonResponse(res, {\n *         errors: [\n *             {\n *                 code: \"server\",\n *                 message: \"Internal server error\",\n *             },\n *         ],\n *     });\n * };\n * ```\n */\nconst createJsonResponse = <D = unknown>(\n    res: Response,\n    options?: CreateJsonResponseOptions<D>,\n) => {\n    const { status, headers, json } = createJsonResponseStruct<D>(options);\n    return res.status(status).setHeaders(new Map(headers)).json(json);\n};\n\nexport type { CreateJsonResponseOptions };\nexport { createJsonResponse };\n","import type { ErrorRequestHandler } from \"express\";\n\nimport { ResponseErrorCode } from \"#/response/error\";\nimport { createJsonResponse } from \"#/response/json\";\n\n/** Options for `errorRequestHandler` function. */\ntype ErrorRequestHandlerOptions = {\n    /**\n     * Whether show more information.\n     * By default, it's `false`.\n     */\n    verbose?: boolean;\n};\n\n/**\n * Error request handler.\n *\n * Following response could be returned on error:\n *\n * ```jsonc\n * // Status: 500\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"server\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Examples\n *\n * Basic example of using `errorRequestHandler` handler:\n *\n * ```js\n * // JavaScript\n *\n * import express from \"express\";\n * import { errorRequestHandler } from \"@jderstd/express\";\n *\n * const app = express();\n *\n * app.use(errorRequestHandler());\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Express } from \"express\";\n *\n * import express from \"express\";\n * import { errorRequestHandler } from \"@jderstd/express\";\n *\n * const app: Express = express();\n *\n * app.use(errorRequestHandler());\n * ```\n *\n * Show more information with `verbose` option:\n *\n * ```js\n * // JavaScript\n *\n * import express from \"express\";\n * import { errorRequestHandler } from \"@jderstd/express\";\n *\n * const app = express();\n *\n * app.use(errorRequestHandler({ verbose: true }));\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Express } from \"express\";\n *\n * import express from \"express\";\n * import { errorRequestHandler } from \"@jderstd/express\";\n *\n * const app: Express = express();\n *\n * app.use(errorRequestHandler({ verbose: true }));\n * ```\n */\nconst errorRequestHandler = (\n    options?: ErrorRequestHandlerOptions,\n): ErrorRequestHandler => {\n    return (err, _req, res, _next) => {\n        return createJsonResponse(res, {\n            status: 500,\n            errors: [\n                {\n                    code: ResponseErrorCode.Server,\n                    ...(options?.verbose && {\n                        message:\n                            err instanceof Error ? err.message : String(err),\n                    }),\n                },\n            ],\n        });\n    };\n};\n\nexport type { ErrorRequestHandlerOptions };\nexport { errorRequestHandler };\n","import type { CreateResponseStructOptions } from \"@jderstd/core/response/common/struct\";\nimport type { Response } from \"express\";\n\nimport { createResponseStruct } from \"@jderstd/core/response/common/struct\";\n\n/** Options of `createResponse` function. */\ntype CreateResponseOptions<B extends BodyInit = BodyInit> =\n    CreateResponseStructOptions<B>;\n\n/**\n * Create a response.\n *\n * ### Examples\n *\n * Example for creating a basic response:\n *\n * ```js\n * // JavaScript\n *\n * import { createResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     createResponse(res);\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     createResponse(res);\n * };\n * ```\n *\n * Example for creating a response with status, headers, and body:\n *\n * ```js\n * // JavaScript\n *\n * import { createResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     createResponse(res, {\n *         status: 404,\n *         headers: [\n *             [\"Content-Type\", \"text/plain\"],\n *         ],\n *         body: \"Not Found\",\n *     });\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     createResponse(res, {\n *         status: 404,\n *         headers: [\n *             [\"Content-Type\", \"text/plain\"],\n *         ],\n *         body: \"Not Found\",\n *     });\n * };\n * ```\n */\nconst createResponse = <B extends BodyInit>(\n    res: Response,\n    options?: CreateResponseOptions<B>,\n) => {\n    const { status, headers, body } = createResponseStruct(options);\n    return res.status(status).setHeaders(new Map(headers)).send(body);\n};\n\nexport type { CreateResponseOptions };\nexport { createResponse };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAK,kEAAL;;;;;;AAMI;;EANC;;;;AAYL,MAAM,2BAA2B,SAAoC;AACjE,SAAQ,MAAR;EACI,KAAK,kBAAkB,OACnB,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACsFnB,MAAM,sBACF,KACA,YACC;CACD,MAAM,EAAE,QAAQ,SAAS,2EAAqC,QAAQ;AACtE,QAAO,IAAI,OAAO,OAAO,CAAC,WAAW,IAAI,IAAI,QAAQ,CAAC,CAAC,KAAK,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxBrE,MAAM,uBACF,YACsB;AACtB,SAAQ,KAAK,MAAM,KAAK,UAAU;AAC9B,SAAO,mBAAmB,KAAK;GAC3B,QAAQ;GACR,QAAQ,CACJ;IACI,MAAM,kBAAkB;IACxB,GAAI,SAAS,WAAW,EACpB,SACI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACvD;IACJ,CACJ;GACJ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC1BV,MAAM,kBACF,KACA,YACC;CACD,MAAM,EAAE,QAAQ,SAAS,yEAA8B,QAAQ;AAC/D,QAAO,IAAI,OAAO,OAAO,CAAC,WAAW,IAAI,IAAI,QAAQ,CAAC,CAAC,KAAK,KAAK"}

package/dist/index.mjs

@@ -0,0 +1,279 @@
+import { createJsonResponseStruct } from "@jderstd/core/response/json/struct";
+import { createResponseStruct } from "@jderstd/core/response/common/struct";
+
+/**
+* Response error code.
+*/
+var ResponseErrorCode = /* @__PURE__ */ function(ResponseErrorCode$1) {
+	/**
+	* Internal server error.
+	*
+	* For `errorRequestHandler` function.
+	*/
+	ResponseErrorCode$1["Server"] = "server";
+	return ResponseErrorCode$1;
+}(ResponseErrorCode || {});
+/**
+* Get response error message by code.
+*/
+const getResponseErrorMessage = (code) => {
+	switch (code) {
+		case ResponseErrorCode.Server: return "Internal server error";
+	}
+};
+
+/**
+* Create a JSON response with context.
+*
+* ### Examples
+*
+* Example for creating a successful JSON response without data:
+*
+* ```js
+* // JavaScript
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     createJsonResponse(res);
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     createJsonResponse(res);
+* };
+* ```
+*
+* Example for creating a successful JSON response with data:
+*
+* ```js
+* // JavaScript
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     return createJsonResponse(res, {
+*         data: "Hello, World!",
+*     });
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     return createJsonResponse(res, {
+*         data: "Hello, World!",
+*     });
+* };
+* ```
+*
+* Example for creating a failed JSON response:
+*
+* ```js
+* // JavaScript
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     return createJsonResponse(res, {
+*         errors: [
+*             {
+*                 code: "server",
+*                 message: "Internal server error",
+*             },
+*         ],
+*     });
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createJsonResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     return createJsonResponse(res, {
+*         errors: [
+*             {
+*                 code: "server",
+*                 message: "Internal server error",
+*             },
+*         ],
+*     });
+* };
+* ```
+*/
+const createJsonResponse = (res, options) => {
+	const { status, headers, json } = createJsonResponseStruct(options);
+	return res.status(status).setHeaders(new Map(headers)).json(json);
+};
+
+/**
+* Error request handler.
+*
+* Following response could be returned on error:
+*
+* ```jsonc
+* // Status: 500
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "server"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Examples
+*
+* Basic example of using `errorRequestHandler` handler:
+*
+* ```js
+* // JavaScript
+*
+* import express from "express";
+* import { errorRequestHandler } from "@jderstd/express";
+*
+* const app = express();
+*
+* app.use(errorRequestHandler());
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Express } from "express";
+*
+* import express from "express";
+* import { errorRequestHandler } from "@jderstd/express";
+*
+* const app: Express = express();
+*
+* app.use(errorRequestHandler());
+* ```
+*
+* Show more information with `verbose` option:
+*
+* ```js
+* // JavaScript
+*
+* import express from "express";
+* import { errorRequestHandler } from "@jderstd/express";
+*
+* const app = express();
+*
+* app.use(errorRequestHandler({ verbose: true }));
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Express } from "express";
+*
+* import express from "express";
+* import { errorRequestHandler } from "@jderstd/express";
+*
+* const app: Express = express();
+*
+* app.use(errorRequestHandler({ verbose: true }));
+* ```
+*/
+const errorRequestHandler = (options) => {
+	return (err, _req, res, _next) => {
+		return createJsonResponse(res, {
+			status: 500,
+			errors: [{
+				code: ResponseErrorCode.Server,
+				...options?.verbose && { message: err instanceof Error ? err.message : String(err) }
+			}]
+		});
+	};
+};
+
+/**
+* Create a response.
+*
+* ### Examples
+*
+* Example for creating a basic response:
+*
+* ```js
+* // JavaScript
+*
+* import { createResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     createResponse(res);
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     createResponse(res);
+* };
+* ```
+*
+* Example for creating a response with status, headers, and body:
+*
+* ```js
+* // JavaScript
+*
+* import { createResponse } from "@jderstd/express";
+*
+* const route = (req, res) => {
+*     createResponse(res, {
+*         status: 404,
+*         headers: [
+*             ["Content-Type", "text/plain"],
+*         ],
+*         body: "Not Found",
+*     });
+* };
+* ```
+*
+* ```ts
+* // TypeScript
+*
+* import type { Request, Response } from "express";
+*
+* import { createResponse } from "@jderstd/express";
+*
+* const route = (req: Request, res: Response): void => {
+*     createResponse(res, {
+*         status: 404,
+*         headers: [
+*             ["Content-Type", "text/plain"],
+*         ],
+*         body: "Not Found",
+*     });
+* };
+* ```
+*/
+const createResponse = (res, options) => {
+	const { status, headers, body } = createResponseStruct(options);
+	return res.status(status).setHeaders(new Map(headers)).send(body);
+};
+
+export { ResponseErrorCode, createJsonResponse, createResponse, errorRequestHandler, getResponseErrorMessage };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/response/error/index.ts","../src/response/json/index.ts","../src/middlewares/error.ts","../src/response/common/index.ts"],"sourcesContent":["/**\n * Response error code.\n */\nenum ResponseErrorCode {\n    /**\n     * Internal server error.\n     *\n     * For `errorRequestHandler` function.\n     */\n    Server = \"server\",\n}\n\n/**\n * Get response error message by code.\n */\nconst getResponseErrorMessage = (code: ResponseErrorCode): string => {\n    switch (code) {\n        case ResponseErrorCode.Server: {\n            return \"Internal server error\";\n        }\n    }\n};\n\nexport { ResponseErrorCode, getResponseErrorMessage };\n","import type { CreateJsonResponseStructOptions } from \"@jderstd/core/response/json/struct\";\nimport type { Response } from \"express\";\n\nimport { createJsonResponseStruct } from \"@jderstd/core/response/json/struct\";\n\n/** Options of `createJsonResponse` function. */\ntype CreateJsonResponseOptions<D = unknown> =\n    CreateJsonResponseStructOptions<D>;\n\n/**\n * Create a JSON response with context.\n *\n * ### Examples\n *\n * Example for creating a successful JSON response without data:\n *\n * ```js\n * // JavaScript\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     createJsonResponse(res);\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     createJsonResponse(res);\n * };\n * ```\n *\n * Example for creating a successful JSON response with data:\n *\n * ```js\n * // JavaScript\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     return createJsonResponse(res, {\n *         data: \"Hello, World!\",\n *     });\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     return createJsonResponse(res, {\n *         data: \"Hello, World!\",\n *     });\n * };\n * ```\n *\n * Example for creating a failed JSON response:\n *\n * ```js\n * // JavaScript\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     return createJsonResponse(res, {\n *         errors: [\n *             {\n *                 code: \"server\",\n *                 message: \"Internal server error\",\n *             },\n *         ],\n *     });\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createJsonResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     return createJsonResponse(res, {\n *         errors: [\n *             {\n *                 code: \"server\",\n *                 message: \"Internal server error\",\n *             },\n *         ],\n *     });\n * };\n * ```\n */\nconst createJsonResponse = <D = unknown>(\n    res: Response,\n    options?: CreateJsonResponseOptions<D>,\n) => {\n    const { status, headers, json } = createJsonResponseStruct<D>(options);\n    return res.status(status).setHeaders(new Map(headers)).json(json);\n};\n\nexport type { CreateJsonResponseOptions };\nexport { createJsonResponse };\n","import type { ErrorRequestHandler } from \"express\";\n\nimport { ResponseErrorCode } from \"#/response/error\";\nimport { createJsonResponse } from \"#/response/json\";\n\n/** Options for `errorRequestHandler` function. */\ntype ErrorRequestHandlerOptions = {\n    /**\n     * Whether show more information.\n     * By default, it's `false`.\n     */\n    verbose?: boolean;\n};\n\n/**\n * Error request handler.\n *\n * Following response could be returned on error:\n *\n * ```jsonc\n * // Status: 500\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"server\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Examples\n *\n * Basic example of using `errorRequestHandler` handler:\n *\n * ```js\n * // JavaScript\n *\n * import express from \"express\";\n * import { errorRequestHandler } from \"@jderstd/express\";\n *\n * const app = express();\n *\n * app.use(errorRequestHandler());\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Express } from \"express\";\n *\n * import express from \"express\";\n * import { errorRequestHandler } from \"@jderstd/express\";\n *\n * const app: Express = express();\n *\n * app.use(errorRequestHandler());\n * ```\n *\n * Show more information with `verbose` option:\n *\n * ```js\n * // JavaScript\n *\n * import express from \"express\";\n * import { errorRequestHandler } from \"@jderstd/express\";\n *\n * const app = express();\n *\n * app.use(errorRequestHandler({ verbose: true }));\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Express } from \"express\";\n *\n * import express from \"express\";\n * import { errorRequestHandler } from \"@jderstd/express\";\n *\n * const app: Express = express();\n *\n * app.use(errorRequestHandler({ verbose: true }));\n * ```\n */\nconst errorRequestHandler = (\n    options?: ErrorRequestHandlerOptions,\n): ErrorRequestHandler => {\n    return (err, _req, res, _next) => {\n        return createJsonResponse(res, {\n            status: 500,\n            errors: [\n                {\n                    code: ResponseErrorCode.Server,\n                    ...(options?.verbose && {\n                        message:\n                            err instanceof Error ? err.message : String(err),\n                    }),\n                },\n            ],\n        });\n    };\n};\n\nexport type { ErrorRequestHandlerOptions };\nexport { errorRequestHandler };\n","import type { CreateResponseStructOptions } from \"@jderstd/core/response/common/struct\";\nimport type { Response } from \"express\";\n\nimport { createResponseStruct } from \"@jderstd/core/response/common/struct\";\n\n/** Options of `createResponse` function. */\ntype CreateResponseOptions<B extends BodyInit = BodyInit> =\n    CreateResponseStructOptions<B>;\n\n/**\n * Create a response.\n *\n * ### Examples\n *\n * Example for creating a basic response:\n *\n * ```js\n * // JavaScript\n *\n * import { createResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     createResponse(res);\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     createResponse(res);\n * };\n * ```\n *\n * Example for creating a response with status, headers, and body:\n *\n * ```js\n * // JavaScript\n *\n * import { createResponse } from \"@jderstd/express\";\n *\n * const route = (req, res) => {\n *     createResponse(res, {\n *         status: 404,\n *         headers: [\n *             [\"Content-Type\", \"text/plain\"],\n *         ],\n *         body: \"Not Found\",\n *     });\n * };\n * ```\n *\n * ```ts\n * // TypeScript\n *\n * import type { Request, Response } from \"express\";\n *\n * import { createResponse } from \"@jderstd/express\";\n *\n * const route = (req: Request, res: Response): void => {\n *     createResponse(res, {\n *         status: 404,\n *         headers: [\n *             [\"Content-Type\", \"text/plain\"],\n *         ],\n *         body: \"Not Found\",\n *     });\n * };\n * ```\n */\nconst createResponse = <B extends BodyInit>(\n    res: Response,\n    options?: CreateResponseOptions<B>,\n) => {\n    const { status, headers, body } = createResponseStruct(options);\n    return res.status(status).setHeaders(new Map(headers)).send(body);\n};\n\nexport type { CreateResponseOptions };\nexport { createResponse };\n"],"mappings":";;;;;;AAGA,IAAK,kEAAL;;;;;;AAMI;;EANC;;;;AAYL,MAAM,2BAA2B,SAAoC;AACjE,SAAQ,MAAR;EACI,KAAK,kBAAkB,OACnB,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACsFnB,MAAM,sBACF,KACA,YACC;CACD,MAAM,EAAE,QAAQ,SAAS,SAAS,yBAA4B,QAAQ;AACtE,QAAO,IAAI,OAAO,OAAO,CAAC,WAAW,IAAI,IAAI,QAAQ,CAAC,CAAC,KAAK,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxBrE,MAAM,uBACF,YACsB;AACtB,SAAQ,KAAK,MAAM,KAAK,UAAU;AAC9B,SAAO,mBAAmB,KAAK;GAC3B,QAAQ;GACR,QAAQ,CACJ;IACI,MAAM,kBAAkB;IACxB,GAAI,SAAS,WAAW,EACpB,SACI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACvD;IACJ,CACJ;GACJ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC1BV,MAAM,kBACF,KACA,YACC;CACD,MAAM,EAAE,QAAQ,SAAS,SAAS,qBAAqB,QAAQ;AAC/D,QAAO,IAAI,OAAO,OAAO,CAAC,WAAW,IAAI,IAAI,QAAQ,CAAC,CAAC,KAAK,KAAK"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@jderstd/express",
+  "version": "0.1.0",
+  "description": "A response builder for Express",
+  "keywords": [
+    "jder",
+    "express",
+    "response",
+    "ts",
+    "typescript",
+    "js",
+    "javascript"
+  ],
+  "homepage": "https://github.com/jderstd/express",
+  "bugs": "https://github.com/jderstd/express/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jderstd/express.git",
+    "directory": "packages/express"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Alpheus",
+    "email": "contact@alphe.us"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/response.js",
+  "module": "./dist/response.mjs",
+  "types": "./dist/response.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@jderstd/core": "~0.4.0"
+  },
+  "devDependencies": {
+    "@types/express": "~5.0.0",
+    "express": "5.0.0"
+  },
+  "peerDependencies": {
+    "@types/express": "^5.0.0",
+    "express": "^5.0.0"
+  }
+}