@yamato-daiwa/express-extensions 0.0.0

package/Distributable/RequestBody/parseAndValidateJSON_RequestBody.d.ts

@@ -0,0 +1,5 @@
+import { RawObjectDataProcessor, type ReadonlyParsedJSON } from "@yamato-daiwa/es-extensions";
+export declare function parseAndValidateJSON_RequestBody<RequestData extends ReadonlyParsedJSON>(settings: Readonly<{
+    requestBodySizeLimit__bytesPackageFormat: string | number;
+    validationAndProcessing: RawObjectDataProcessor.ObjectDataSpecification;
+}>): (request: unknown, response: unknown, toNextMiddleware: (error?: unknown) => void) => void;

package/Distributable/RequestBody/parseAndValidateJSON_RequestBody.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAndValidateJSON_RequestBody = parseAndValidateJSON_RequestBody;
+const body_parser_1 = __importDefault(require("body-parser"));
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+function parseAndValidateJSON_RequestBody(settings) {
+    return (_request, _response, toNextMiddleware) => {
+        const request = _request;
+        const response = _response;
+        body_parser_1.default.json({ limit: settings.requestBodySizeLimit__bytesPackageFormat })(request, response, (error) => {
+            if ((0, es_extensions_1.isNeitherUndefinedNorNull)(error)) {
+                toNextMiddleware(error);
+                return;
+            }
+            const requestBodyValidationAndProcessingResult = es_extensions_1.RawObjectDataProcessor.process(request.body, settings.validationAndProcessing);
+            if (requestBodyValidationAndProcessingResult.rawDataIsInvalid) {
+                response.
+                    status(es_extensions_1.HTTP_StatusCodes.badRequest).
+                    json(requestBodyValidationAndProcessingResult.validationErrorsMessages);
+                return;
+            }
+            request.body = requestBodyValidationAndProcessingResult.processedData;
+            toNextMiddleware();
+        });
+    };
+}

package/Distributable/RequestBody/validateAndProcessJSON_RequestBody.d.ts

@@ -0,0 +1,3 @@
+import { RawObjectDataProcessor } from "@yamato-daiwa/es-extensions";
+import type { ReadonlyParsedJSON } from "@yamato-daiwa/es-extensions";
+export declare function validateAndProcessJSON_RequestBody<RequestData extends ReadonlyParsedJSON>(validRequestBodySpecification: RawObjectDataProcessor.ObjectDataSpecification): (request: unknown, response: unknown, toNextMiddleware: () => void) => void;

package/Distributable/RequestBody/validateAndProcessJSON_RequestBody.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndProcessJSON_RequestBody = validateAndProcessJSON_RequestBody;
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+function validateAndProcessJSON_RequestBody(validRequestBodySpecification) {
+    return (request, response, toNextMiddleware) => {
+        if (!(0, es_extensions_1.isArbitraryObject)(request)) {
+            response.status(es_extensions_1.HTTP_StatusCodes.internalServerError);
+            es_extensions_1.Logger.logError({
+                errorType: es_extensions_1.InvalidParameterValueError.NAME,
+                title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                description: es_extensions_1.InvalidParameterValueError.localization.generateDescription({
+                    parameterName: "request",
+                    parameterNumber: 1,
+                    messageSpecificPart: `The "request" is not object and has type "${typeof request}"`
+                }),
+                occurrenceLocation: "validateAndProcessRequestBody -> innerFunction(request, response, toNextMiddleware)"
+            });
+            return;
+        }
+        const requestBodyProcessingResult = es_extensions_1.RawObjectDataProcessor.
+            process(request.body, validRequestBodySpecification);
+        if (requestBodyProcessingResult.rawDataIsInvalid) {
+            response.
+                status(es_extensions_1.HTTP_StatusCodes.badRequest).
+                json(requestBodyProcessingResult.validationErrorsMessages);
+            return;
+        }
+        request.body = requestBodyProcessingResult.processedData;
+        toNextMiddleware();
+    };
+}

package/Distributable/Session/disposeExpressSession.d.ts

@@ -0,0 +1,7 @@
+import type { Session } from "express-session";
+export declare function disposeExpressSession(session: Session, options: Readonly<{
+    mustWaitUntilCompletion: true;
+}>): Promise<void>;
+export declare function disposeExpressSession(session: Session, options: Readonly<{
+    mustWaitUntilCompletion: false;
+}>): void;

package/Distributable/Session/disposeExpressSession.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disposeExpressSession = disposeExpressSession;
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+function disposeExpressSession(session, { mustWaitUntilCompletion }) {
+    if (!mustWaitUntilCompletion) {
+        session.destroy(() => { });
+    }
+    return new Promise((resolve, reject) => {
+        session.destroy((error) => {
+            if ((0, es_extensions_1.isNeitherUndefinedNorNull)(error)) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}

package/Distributable/Session/saveExpressSession.d.ts

@@ -0,0 +1,2 @@
+import type { Session } from "express-session";
+export declare function saveExpressSession(session: Session): Promise<void> | void;

package/Distributable/Session/saveExpressSession.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveExpressSession = saveExpressSession;
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+function saveExpressSession(session) {
+    return new Promise((resolve, reject) => {
+        session.save((error) => {
+            if ((0, es_extensions_1.isNeitherUndefinedNorNull)(error)) {
+                reject(error);
+            }
+            resolve();
+        });
+    });
+}

package/Distributable/index.d.ts

@@ -0,0 +1,4 @@
+export { parseAndValidateJSON_RequestBody } from "./RequestBody/parseAndValidateJSON_RequestBody";
+export { validateAndProcessJSON_RequestBody } from "./RequestBody/validateAndProcessJSON_RequestBody";
+export { saveExpressSession } from "./Session/saveExpressSession";
+export { disposeExpressSession } from "./Session/disposeExpressSession";

package/Distributable/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disposeExpressSession = exports.saveExpressSession = exports.validateAndProcessJSON_RequestBody = exports.parseAndValidateJSON_RequestBody = void 0;
+var parseAndValidateJSON_RequestBody_1 = require("./RequestBody/parseAndValidateJSON_RequestBody");
+Object.defineProperty(exports, "parseAndValidateJSON_RequestBody", { enumerable: true, get: function () { return parseAndValidateJSON_RequestBody_1.parseAndValidateJSON_RequestBody; } });
+var validateAndProcessJSON_RequestBody_1 = require("./RequestBody/validateAndProcessJSON_RequestBody");
+Object.defineProperty(exports, "validateAndProcessJSON_RequestBody", { enumerable: true, get: function () { return validateAndProcessJSON_RequestBody_1.validateAndProcessJSON_RequestBody; } });
+var saveExpressSession_1 = require("./Session/saveExpressSession");
+Object.defineProperty(exports, "saveExpressSession", { enumerable: true, get: function () { return saveExpressSession_1.saveExpressSession; } });
+var disposeExpressSession_1 = require("./Session/disposeExpressSession");
+Object.defineProperty(exports, "disposeExpressSession", { enumerable: true, get: function () { return disposeExpressSession_1.disposeExpressSession; } });

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023-present, Yamato Daiwa Co., Ltd.
+
+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,110 @@
+# Yamato Daiwa Express Extensions
+
+Additional functions for [express](https://www.npmjs.com/package/express) and its plugins, and also for 
+  [routing-controllers](https://www.npmjs.com/package/routing-controllers).
+
+
+## Installation
+
+```Bash
+npm i @yamato-daiwa/express-extensions -E
+```
+
+Also, install the following peer dependencies if not installed yet.
+
++ **body-parser**: ~1.20.0
++ **express**: ~4.21.0
++ **express-session**: ~1.18.0
++ **routing-controllers**: ~0.10.0
+
+
+## Functionality
+
++ Session
+
+  + [`saveExpressSession`](#saveexpresssession)
+  + [`disposeExpressSession`](#disposeexpresssession)
+  
++ Request Body
+
+  + [`parseAndValidateJSON_RequestBody`](#parseandvalidatejson_requestbody)
+  + [`validateAndProcessJSON_RequestBody`](#validateandprocessrequestbody) 
+
+
+### Session
+#### `saveExpressSession`
+
+```
+saveExpressSession(session: Session): Promise<void>
+```
+
+The promisfied version of [`session.save(callback)`](https://www.npmjs.com/package/express-session#user-content-sessionsavecallback).
+The promise will reject if the callback of `session.save` will receive
+  neither undefined nor null parameter.
+
+
+#### `disposeExpressSession`
+
+```
+# === [ Overload 1 ] Must waint until completion
+export function disposeExpressSession(session: Session, options: Readonly<{ mustWaitUntilCompletion: true; }>): Promise<void>;
+
+# === [ Overload 2 ] Do not waint until completion
+export function disposeExpressSession(session: Session, options: Readonly<{ mustWaitUntilCompletion: false; }>): void;
+```
+
+The wrapper for [`session.destroy(callback)`](https://www.npmjs.com/package/express-session#user-content-sessiondestroycallback).
+
+* If the second parameter has been set to `{ mustWaitUntilCompletion: true }`, this function will return the promise which
+    will be resolved when the disposal will successfully complete. 
+  In this case, the `disposeExpressSession` is the promisfied version of `session.destroy(callback)`. 
+* If there is no need to wait the ending of disposal, set the second parameter to `{ mustWaitUntilCompletion: false }` 
+    and this function will return nothing.
+  
+
+### Request Body
+#### `parseAndValidateJSON_RequestBody`
+
+```
+<RequestData extends ReadonlyParsedJSON>(
+  settings: Readonly<{
+    requestBodySizeLimit__bytesPackageFormat: string | number;
+    validationAndProcessing: RawObjectDataProcessor.ObjectDataSpecification;
+  }>
+): ExpressMiddleware
+```
+
+Parses expected to be the JSON-type request body, validates it by [RawObjectDataProcessor](https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions/blob/master/CoreLibrary/Package/Documentation/RawObjectDataProcessor/RawObjectDataProcessor.md)
+  and, if demanded, modifying it by same util.
+The *alternative* to [class-transformer](https://github.com/typestack/class-transformer) which is transforming the
+  request body to the instances of classes for the cases when there is no need to turn the objects to the instances
+  of the classes.
+
+* Requirements 
+  1. **body-parser** has _not_ been applied neither globally nor locally, by other words, the request body
+    has not been parsed yet.
+  2. The *class-transformer* is disabled by `useExpressServer({ classTransformer: false })` where the `useExpressServer`
+     is the function from **routing-controllers** 
+* Intended to be used as one of parameters of **routing-controllers** middleware.
+
+
+#### `validateAndProcessJSON_RequestBody`
+
+
+```
+<RequestData extends ReadonlyParsedJSON>(
+  validRequestBodySpecification: RawObjectDataProcessor.ObjectDataSpecification
+): ExpressMiddleware
+```
+
+Validates the pre-parsed JSON body by [RawObjectDataProcessor](https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions/blob/master/CoreLibrary/Package/Documentation/RawObjectDataProcessor/RawObjectDataProcessor.md)
+  and, if demanded, modifying it by same util.
+The *alternative* to [class-transformer](https://github.com/typestack/class-transformer) which is transforming the
+  request body to the instances of classes for the cases when there is no need to turn the objects to the instances
+  of the classes.
+
+* Requirements
+  1. The JSON-type request body has been preliminary parsed by **body-parser**.
+  2. The *class-transformer* is disabled by `useExpressServer({ classTransformer: false })` where the `useExpressServer`
+     is the function from **routing-controllers**
+* Intended to be used as one of parameters of **routing-controllers** middleware.

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@yamato-daiwa/express-extensions",
+  "version": "0.0.0",
+  "description": "Additional functionality for Express.js and also \"routing-controllers\" aimed to reduce the routine code.",
+  "keywords": [
+    "nodejs",
+    "typescript",
+    "express"
+  ],
+  "author": {
+    "name": "Yamato Daiwa Co., Ltd."
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/TokugawaTakeshi/YamatoDaiwaExpressExtensions",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TokugawaTakeshi/YamatoDaiwaExpressExtensions.git"
+  },
+  "bugs": {
+    "url": "https://github.com/TokugawaTakeshi/YamatoDaiwaExpressExtensions/issues"
+  },
+  "main": "./Distributable/index.js",
+  "sideEffects": false,
+  "types": "./Distributable/index.d.ts",
+  "files": [
+    "Distributable"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "body-parser": "~1.20.0",
+    "express": "~4.21.0",
+    "express-session": "~1.18.0",
+    "routing-controllers": "~0.10.0"
+  },
+  "devDependencies": {
+    "@types/express-session": "1.18.1",
+    "@yamato-daiwa/style_guides": "0.6.2",
+    "body-parser": "1.20.3",
+    "express": "4.21.2",
+    "express-session": "1.18.1",
+    "rimraf": "6.0.1",
+    "routing-controllers": "0.10.4",
+    "typescript": "5.7.3"
+  },
+  "scripts": {
+    "Rebuild Distributable Without Preliminary Cleaning": "tsc",
+    "Rebuild Distributable": "rimraf Distributable && tsc",
+    "Rebuild Distributable and Realize Alpha": "npm run \"Rebuild Distributable\" && npm publish --tag alpha",
+    "Rebuild Distributable and Realize RC": "npm run \"Rebuild Distributable\" && npm publish --tag rc"
+  },
+  "dependencies": {
+    "@yamato-daiwa/es-extensions": "1.7.2"
+  }
+}