@trayio/express 0.0.1-beta

package/dist/http/ExpressHttpController.d.ts

@@ -0,0 +1,16 @@
+import { Router } from 'express-serve-static-core';
+import { HttpController } from '@trayio/commons/http/HttpController';
+export declare class ExpressHttpController {
+    protected controller: HttpController;
+    protected baseTmpPathForUploadedFiles: string;
+    constructor(controller: HttpController, baseTmpPathForUploadedFiles?: string);
+    private addRoute;
+    addRoutes: (router: Router) => Router;
+    private parseRequestBody;
+    private parseGeneralRequestBody;
+    private parseMultipartFormData;
+    private flattenFields;
+    private flattenFiles;
+    private convertFormidableFileToTrayFile;
+}
+//# sourceMappingURL=ExpressHttpController.d.ts.map

package/dist/http/ExpressHttpController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressHttpController.d.ts","sourceRoot":"","sources":["../../src/http/ExpressHttpController.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAQnD,OAAO,EACN,cAAc,EAEd,MAAM,qCAAqC,CAAC;AAa7C,qBAAa,qBAAqB;IAEhC,SAAS,CAAC,UAAU,EAAE,cAAc;IACpC,SAAS,CAAC,2BAA2B,EAAE,MAAM;gBADnC,UAAU,EAAE,cAAc,EAC1B,2BAA2B,GAAE,MAAe;IAGvD,OAAO,CAAC,QAAQ,CAsDd;IAEF,SAAS,WAAY,MAAM,YAKzB;IAEF,OAAO,CAAC,gBAAgB,CAgBtB;IAGF,OAAO,CAAC,uBAAuB,CAI7B;IAEF,OAAO,CAAC,sBAAsB,CAiC3B;IAEH,OAAO,CAAC,aAAa,CAenB;IAEF,OAAO,CAAC,YAAY,CAkBlB;IAEF,OAAO,CAAC,+BAA+B,CAQpC;CACH"}

package/dist/http/ExpressHttpController.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressHttpController = void 0;
+const TE = __importStar(require("fp-ts/TaskEither"));
+const E = __importStar(require("fp-ts/Either"));
+const Http_1 = require("@trayio/commons/http/Http");
+const BufferExtensions_1 = require("@trayio/commons/buffer/BufferExtensions");
+const formidable_1 = __importDefault(require("formidable"));
+const stream_1 = require("stream");
+class ExpressHttpController {
+    constructor(controller, baseTmpPathForUploadedFiles = '/tmp') {
+        this.controller = controller;
+        this.baseTmpPathForUploadedFiles = baseTmpPathForUploadedFiles;
+        this.addRoute = (endpoint) => {
+            const route = (req, res) => __awaiter(this, void 0, void 0, function* () {
+                const headers = Object.entries(req.headers).reduce((acc, [key, value]) => {
+                    const newValue = typeof value === 'undefined' ? '' : value;
+                    return Object.assign(Object.assign({}, acc), { [key]: newValue });
+                }, {});
+                const requestBody = yield this.parseRequestBody(req);
+                const httpResponse = yield endpoint.execute({
+                    headers,
+                    pathParams: req.params,
+                    queryString: req.query,
+                    body: requestBody,
+                })();
+                const response = Object.entries(httpResponse.headers)
+                    .reduce((acc, [key, value]) => acc.setHeader(key, value), res)
+                    .status(httpResponse.statusCode);
+                httpResponse.body.pipe(response);
+            });
+            let method;
+            switch (endpoint.method) {
+                case Http_1.HttpMethod.Get:
+                    method = 'get';
+                    break;
+                case Http_1.HttpMethod.Post:
+                    method = 'post';
+                    break;
+                case Http_1.HttpMethod.Put:
+                    method = 'put';
+                    break;
+                case Http_1.HttpMethod.Delete:
+                    method = 'delete';
+                    break;
+                case Http_1.HttpMethod.Patch:
+                    method = 'patch';
+                    break;
+                default:
+                    method = 'get';
+                    break;
+            }
+            return (router) => router[method](endpoint.path, route);
+        };
+        this.addRoutes = (router) => {
+            this.controller
+                .getEndpoints()
+                .forEach((endpoint) => this.addRoute(endpoint)(router));
+            return router;
+        };
+        this.parseRequestBody = (req) => __awaiter(this, void 0, void 0, function* () {
+            const contentType = req.headers['content-type'];
+            if (contentType && contentType.startsWith('multipart/form-data')) {
+                const multiPartResponse = yield this.parseMultipartFormData(req)();
+                const multiPartBody = E.getOrElse((error) => {
+                    throw new Error(error.message);
+                })(multiPartResponse);
+                return multiPartBody;
+            }
+            return this.parseGeneralRequestBody(req);
+        });
+        // express defaults empty request body to an empty object, so we need to transform to an array buffer
+        this.parseGeneralRequestBody = (req) => {
+            const body = Object.keys(req.body).length === 0 ? new ArrayBuffer(0) : req.body;
+            return BufferExtensions_1.BufferExtensions.arrayBufferToReadable(body);
+        };
+        this.parseMultipartFormData = (req) => TE.tryCatch(() => new Promise((resolve, reject) => {
+            /*
+             * NOTE: inorder to use any other underlying file storage other than node fs, we would have to use
+             * formidable's fileWriteStreamHandler option that enables formidable to write a file to a stream.
+             * When used the fileWriteStreamHandler option with passThrough stream, we ran into errors that we didn't have
+             * time to solve, but ideally, we would be using the FileStorage interface instead of letting formidable
+             * write to the file system directly.
+             */
+            const form = (0, formidable_1.default)({
+                maxFiles: 1,
+                maxFileSize: 50 * 1024 * 1024,
+                uploadDir: this.baseTmpPathForUploadedFiles,
+            });
+            form.parse(req, (err, fields, files) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    const body = {
+                        fields: this.flattenFields(fields),
+                        files: this.flattenFiles(files),
+                    };
+                    resolve(body);
+                }
+            });
+        }), (error) => new Error(error.message));
+        this.flattenFields = (fields) => {
+            const flattenedFields = {};
+            Object.entries(fields).forEach(([key, value]) => {
+                if (Array.isArray(value) && value.length > 1) {
+                    throw new Error(`Field ${key} has more than one value and is current not supported`);
+                }
+                if (Array.isArray(value)) {
+                    flattenedFields[key] = value.join(',');
+                }
+                else {
+                    flattenedFields[key] = value !== null && value !== void 0 ? value : '';
+                }
+            });
+            return flattenedFields;
+        };
+        this.flattenFiles = (files) => {
+            const flattenedFiles = {};
+            Object.entries(files)
+                .filter(([key, file]) => file !== null)
+                .forEach(([key, file]) => {
+                if (Array.isArray(file) && file.length > 1) {
+                    throw new Error(`Field ${key} has more than one file and is currently not supported`);
+                }
+                if (Array.isArray(file)) {
+                    const fileContent = this.convertFormidableFileToTrayFile(file[0]);
+                    flattenedFiles[key] = fileContent;
+                }
+            });
+            return flattenedFiles;
+        };
+        this.convertFormidableFileToTrayFile = (file) => {
+            var _a;
+            return ({
+                key: file.newFilename,
+                metadata: {
+                    name: file.newFilename,
+                    contentType: (_a = file.mimetype) !== null && _a !== void 0 ? _a : undefined,
+                    size: file.size,
+                },
+                content: stream_1.Readable.from('0'),
+            });
+        };
+    }
+}
+exports.ExpressHttpController = ExpressHttpController;

package/dist/http/ExpressHttpServer.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import http = require('http');
+import { ExpressHttpController } from './ExpressHttpController';
+interface ExpressServerOptions {
+    port?: number;
+}
+export declare const startServer: (controllers: ExpressHttpController[], options: ExpressServerOptions) => http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+export {};
+//# sourceMappingURL=ExpressHttpServer.d.ts.map

package/dist/http/ExpressHttpServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressHttpServer.d.ts","sourceRoot":"","sources":["../../src/http/ExpressHttpServer.ts"],"names":[],"mappings":";AAEA,OAAO,IAAI,GAAG,QAAQ,MAAM,CAAC,CAAC;AAE9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,UAAU,oBAAoB;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,WAAW,gBACV,qBAAqB,EAAE,WAC3B,oBAAoB,yEAkC7B,CAAC"}

package/dist/http/ExpressHttpServer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = void 0;
+const express = require("express");
+const cors = require("cors");
+const startServer = (controllers, options) => {
+    var _a;
+    const port = (_a = options.port) !== null && _a !== void 0 ? _a : 3000;
+    const app = express();
+    const router = express.Router();
+    app.use(cors());
+    const newRouter = controllers.map((controller) => controller.addRoutes(router));
+    app.disable('etag');
+    app.disable('x-powered-by');
+    const skipBodyParserForMultipartFormData = (req) => {
+        const contentType = req.headers['content-type'];
+        return !(contentType && contentType.startsWith('multipart/form-data'));
+    };
+    app.use(express.raw({
+        limit: '50mb',
+        type: (req) => skipBodyParserForMultipartFormData(req),
+    }));
+    app.use('/', newRouter);
+    return app.listen(port, () => {
+        console.log(`Web server listening on port ${port}`);
+    });
+};
+exports.startServer = startServer;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@trayio/express",
+  "version": "0.0.1-beta",
+  "description": "Express extensions and implementations",
+  "exports": {
+    "./*": "./dist/*.js"
+  },
+  "author": "Tray.io",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.x"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@trayio/commons": "0.0.1-beta",
+    "cors": "2.8.5",
+    "express": "4.18.2",
+    "formidable": "3.5.1"
+  },
+  "devDependencies": {
+    "@types/cors": "*",
+    "@types/express": "*",
+    "@types/formidable": "*"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "dist/*"
+      ]
+    }
+  },
+  "files": [
+    "/dist"
+  ]
+}