node-server-engine 1.4.9 → 1.5.0

package/src/middleware/multiPartFileUploader/multiPartFileUploader.ts

@@ -1,249 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import multer from 'multer';
-import fs from 'fs-extra';
-import path from 'path';
-import { Schema } from 'express-validator';
-import { reportDebug, reportError } from 'utils';
-import { WebError } from 'entities/WebError';
-import { validate } from './validate';
-import { MultiPartFileUploaderConfig } from './multiPartFileUploader.types';
-
-const namespace = 'engine:middleware:multiPartFileUploader';
-
-const TEMP_DIR: string = path.join(
-  process.env.FILE_STORAGE_FOLDER || './uploads',
-  'temp_chunks'
-);
-const FILE_DIR: string = path.join(
-  process.env.FILE_STORAGE_FOLDER || './uploads',
-  'completed_files'
-);
-
-fs.ensureDirSync(FILE_DIR);
-fs.ensureDirSync(TEMP_DIR);
-
-const storage = multer.memoryStorage();
-
-export function multiPartFileUploader(
-  filesOption: MultiPartFileUploaderConfig,
-  validator: Schema
-) {
-  return async (
-    req: Request,
-    res: Response,
-    next: NextFunction
-  ): Promise<void> => {
-    try {
-      reportDebug({ namespace, message: 'Starting file upload middleware' });
-
-      const uploadSingle = multer({ storage }).single('file');
-      uploadSingle(req, res, async (err) => {
-        if (err) {
-          reportError('Error uploading chunk');
-          return next(
-            new WebError({
-              statusCode: 500,
-              errorCode: 'upload-failed',
-              message: 'Error uploading file chunk',
-              data: { error: err.message }
-            })
-          );
-        }
-
-        try {
-          reportDebug({ namespace, message: 'Validating request' });
-          await validate(req, validator);
-        } catch (error) {
-          reportDebug({
-            namespace,
-            message: 'Validation failed',
-            data: { error }
-          });
-          return next(
-            new WebError({
-              statusCode: 400,
-              errorCode: 'validation-failed',
-              message: 'Validation failed for file upload',
-              data: { error: (error as Error).message }
-            })
-          );
-        }
-
-        const { filename, totalChunks, chunkIndex, uniqueID } = req.body;
-        reportDebug({
-          namespace,
-          message: 'Received chunk data',
-          data: { filename, totalChunks, chunkIndex, uniqueID }
-        });
-
-        if (
-          !filename ||
-          !totalChunks ||
-          chunkIndex === undefined ||
-          !uniqueID ||
-          !req.file
-        ) {
-          return next(
-            new WebError({
-              statusCode: 400,
-              errorCode: 'missing-field',
-              message: 'Missing required fields',
-              data: {
-                filename,
-                totalChunks,
-                chunkIndex,
-                uniqueID,
-                receivedChunk: !!req.file
-              }
-            })
-          );
-        }
-
-        if (
-          filesOption?.maxSize &&
-          req.file.size > parseInt(filesOption?.maxSize, 10)
-        ) {
-          return next(
-            new WebError({
-              statusCode: 400,
-              errorCode: 'chunk-too-large',
-              message: 'Uploaded chunk exceeds the maximum allowed size',
-              data: {
-                maxSize: filesOption.maxSize,
-                receivedSize: req.file.size
-              }
-            })
-          );
-        }
-
-        const sessionFolder = path.join(TEMP_DIR, uniqueID);
-        fs.ensureDirSync(sessionFolder);
-        const chunkPath = path.join(
-          sessionFolder,
-          `${filename}.part${chunkIndex}`
-        );
-
-        try {
-          reportDebug({
-            namespace,
-            message: 'Writing chunk to disk',
-            data: { chunkPath }
-          });
-          await fs.writeFile(chunkPath, req.file.buffer);
-        } catch (writeErr) {
-          return next(
-            new WebError({
-              statusCode: 500,
-              errorCode: 'chunk-write-failed',
-              message: 'Failed to write chunk',
-              data: { chunkIndex, error: (writeErr as Error).message }
-            })
-          );
-        }
-
-        const uploadedChunks = await fs.readdir(sessionFolder);
-        reportDebug({
-          namespace,
-          message: 'Uploaded chunk count',
-          data: { uploadedChunks: uploadedChunks.length, totalChunks }
-        });
-
-        if (uploadedChunks.length === parseInt(totalChunks, 10)) {
-          try {
-            const finalFilePath = path.join(
-              FILE_DIR,
-              `${uniqueID}_${filename}`
-            );
-            await mergeChunks(
-              filename,
-              totalChunks,
-              sessionFolder,
-              finalFilePath
-            );
-            req.multipartFile = {
-              isPending: false,
-              originalname: filename,
-              uniqueID,
-              filePath: finalFilePath
-            };
-          } catch (mergeErr) {
-            return next(
-              new WebError({
-                statusCode: 500,
-                errorCode: 'file-merge-failed',
-                message: 'Error merging file chunks',
-                data: { error: (mergeErr as Error).message }
-              })
-            );
-          }
-          return next();
-        }
-
-        req.multipartFile = {
-          isPending: true,
-          originalname: filename,
-          uniqueID,
-          chunkIndex,
-          totalChunks
-        };
-        next();
-      });
-    } catch (error) {
-      next(
-        new WebError({
-          statusCode: 500,
-          errorCode: 'unexpected-error',
-          message: 'Unexpected error in file upload',
-          data: { error: (error as Error).message }
-        })
-      );
-    }
-  };
-}
-
-async function mergeChunks(
-  filename: string,
-  totalChunks: string | number,
-  sessionFolder: string,
-  finalFilePath: string
-): Promise<void> {
-  const writeStream = fs.createWriteStream(finalFilePath);
-  reportDebug({
-    namespace,
-    message: 'Merging file chunks',
-    data: { finalFilePath }
-  });
-
-  for (let i = 0; i < parseInt(totalChunks as string, 10); i++) {
-    const partPath = path.join(sessionFolder, `${filename}.part${i}`);
-    try {
-      const chunkData = await fs.readFile(partPath);
-      writeStream.write(chunkData);
-    } catch (error) {
-      throw new WebError({
-        statusCode: 500,
-        errorCode: 'chunk-read-failed',
-        message: `Error reading chunk ${i}`,
-        data: { error: (error as Error).message }
-      });
-    }
-    fs.remove(partPath).catch((err: Error) =>
-      reportError(`Error removing part ${partPath}: ${err.message}`)
-    );
-  }
-
-  writeStream.end();
-  return new Promise<void>((resolve, reject) => {
-    writeStream.on('finish', () => resolve(undefined));
-    writeStream.on('error', (error) =>
-      reject(
-        new WebError({
-          statusCode: 500,
-          errorCode: 'file-merge-error',
-          message: 'Error merging file chunks',
-          data: { error: (error as Error).message }
-        })
-      )
-    );
-  });
-}

package/src/middleware/multiPartFileUploader/multiPartFileUploader.types.ts

@@ -1,23 +0,0 @@
-// Extend Express request object to include `files`
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace Express {
-    interface Request {
-      /** Uploaded files mapped by field name */
-      multipartFile?: {
-        isPending: boolean;
-        originalname: string;
-        uniqueID: string;
-        filePath?: string;
-        chunkIndex?: number;
-        totalChunks?: number;
-      };
-    }
-  }
-}
-
-/** Configuration for Multi part file upload */
-export interface MultiPartFileUploaderConfig {
-  required?: boolean;
-  maxSize?: string;
-}

package/src/middleware/multiPartFileUploader/validate/index.ts

@@ -1 +0,0 @@
-export * from './validate';

package/src/middleware/multiPartFileUploader/validate/validate.ts

@@ -1,27 +0,0 @@
-import { Request } from 'express';
-import { Schema } from 'express-validator';
-import { validate as validateMiddleware } from 'middleware/validate';
-
-/** Validate a schema against a request using our validation middleware */
-export async function validate(
-  request: Request,
-  schema: Schema
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    // Generate a validation chain using our middleware
-    const validationChain = validateMiddleware(schema).flat();
-    if (!validationChain.length) resolve();
-    // Recursively go through each middleware by imitating the next function from express
-    let position = -1;
-    const next = (error?: unknown): void => {
-      if (error) reject(error);
-      position++;
-      if (position === validationChain.length) {
-        resolve();
-        return;
-      }
-      validationChain[position](request, undefined, next);
-    };
-    next();
-  });
-}

package/src/middleware/requestMetrics/index.ts

@@ -1 +0,0 @@
-export * from './requestMetrics';

package/src/middleware/requestMetrics/requestMetrics.test.ts

@@ -1,77 +0,0 @@
-import { expect } from 'chai';
-import express from 'express';
-import { faker } from '@faker-js/faker';
-import { stub, match, SinonStub } from 'sinon';
-import request from 'supertest';
-import { requestMetrics } from './requestMetrics';
-import { httpRequestCount, httpRequestDuration } from 'metrics/request';
-
-describe('Middleware - requestMetrics', function () {
-  let requestCountStub: SinonStub;
-  let requestDurationStub: SinonStub;
-
-  beforeEach(() => {
-    requestCountStub = stub(httpRequestCount, 'inc').returns();
-    requestDurationStub = stub(httpRequestDuration, 'observe').returns();
-  });
-
-  it('should handle metrics for the requests', async () => {
-    const service = faker.lorem.word();
-    process.env.CHART = service;
-
-    const app = express();
-    app.use(requestMetrics);
-    app.get('/test', function (req, res) {
-      res.sendStatus(200);
-    });
-
-    await request(app).get('/test').expect(200);
-
-    const labels = { service, path: '/test', method: 'GET', status: '2XX' };
-    expect(requestCountStub).to.have.been.calledOnceWithExactly(labels);
-    expect(requestDurationStub).to.have.been.calledOnceWithExactly(
-      labels,
-      match.number
-    );
-  });
-
-  it('should not keep query parameters in path', async () => {
-    const service = faker.lorem.word();
-    process.env.CHART = service;
-
-    const app = express();
-    app.use(requestMetrics);
-    app.get('/test', function (req, res) {
-      res.sendStatus(200);
-    });
-
-    await request(app).get('/test?param=value').expect(200);
-
-    const labels = { service, path: '/test', method: 'GET', status: '2XX' };
-    expect(requestCountStub).to.have.been.calledOnceWithExactly(labels);
-    expect(requestDurationStub).to.have.been.calledOnceWithExactly(
-      labels,
-      match.number
-    );
-  });
-
-  it('should not keep anchor in path', async () => {
-    const service = faker.lorem.word();
-    process.env.CHART = service;
-
-    const app = express();
-    app.use(requestMetrics);
-    app.get('/test', function (req, res) {
-      res.sendStatus(200);
-    });
-
-    await request(app).get('/test#place').expect(200);
-
-    const labels = { service, path: '/test', method: 'GET', status: '2XX' };
-    expect(requestCountStub).to.have.been.calledOnceWithExactly(labels);
-    expect(requestDurationStub).to.have.been.calledOnceWithExactly(
-      labels,
-      match.number
-    );
-  });
-});

package/src/middleware/requestMetrics/requestMetrics.ts

@@ -1,20 +0,0 @@
-import { Request, Response } from 'express';
-import responseTime from 'response-time';
-import { httpRequestCount, httpRequestDuration } from 'metrics';
-
-/** Middleware that gets metrics on each request */
-export const requestMetrics = responseTime(
-  (request: Request, response: Response, time: number) => {
-    const labels = {
-      path: (request.route?.path ?? request.path) as string,
-      method: request.method,
-      status: response.statusCode
-        ? `${response.statusCode.toString().substring(0, 1)}XX`
-        : '',
-      service: process.env.CHART
-    };
-
-    httpRequestCount.inc(labels);
-    httpRequestDuration.observe(labels, time / 1000);
-  }
-);

package/src/middleware/swaggerDocs/index.ts

@@ -1,2 +0,0 @@
-export * from './swaggerDocs';
-export * from './swaggerDocs.types';

package/src/middleware/swaggerDocs/swaggerDocs.ts

@@ -1,114 +0,0 @@
-import fs from 'fs';
-import { Router } from 'express';
-import { glob } from 'glob';
-import YAML from 'yamljs';
-import swaggerUi from 'swagger-ui-express';
-import {
-  EndpointDocumentation,
-  IndexDocumentation,
-  ResponsesConfig,
-  EndpointConfig,
-  SchemasConfig,
-  SwaggerConfig
-} from './swaggerDocs.types';
-
-/** Get the paths of all the endpoint documentation files */
-function getEndpointDocPaths(): Array<string> {
-  return [
-    ...glob.sync(`${process.cwd()}/src/**/*.docs.yaml`),
-    ...glob.sync(`${process.cwd()}/dist/**/*.docs.yaml`)
-  ];
-}
-
-/** Get the paths of all the schema files */
-function getSchemaPaths(): Array<string> {
-  return [
-    ...glob.sync(`${process.cwd()}/src/docs/schemas/*.yaml`),
-    ...glob.sync(`${process.cwd()}/dist/docs/schemas/*.yaml`)
-  ];
-}
-
-/** Get the paths of all the response files */
-function getResponsePaths(): Array<string> {
-  return [
-    ...glob.sync(`${process.cwd()}/src/docs/responses/*.yaml`),
-    ...glob.sync(`${process.cwd()}/dist/docs/responses/*.yaml`)
-  ];
-}
-
-/**
- * Load all data files and merge them in a single object
- * @param files
- * @return {Object}
- */
-function loadAndMergeData(files: Array<string>): EndpointDocumentation {
-  return files
-    .map((file) => YAML.load(file) as EndpointDocumentation)
-    .reduce((result, endpoint) => {
-      for (const path of Object.keys(endpoint)) {
-        if (!(path in result)) result[path] = {};
-        result[path] = { ...result[path], ...endpoint[path] };
-      }
-      return result;
-    }, {});
-}
-
-/** Load documentation files of all the endpoints */
-function loadEndpoints(): EndpointConfig {
-  const paths = getEndpointDocPaths();
-  const endpoints = loadAndMergeData(paths);
-  return {
-    paths: endpoints
-  };
-}
-
-/** Load documentation files of all the schemas */
-function loadSchemas(): SchemasConfig {
-  const paths = getSchemaPaths();
-  const schemas = loadAndMergeData(paths);
-  return { schemas };
-}
-
-/** Load documentation files of all the responses */
-function loadResponses(): ResponsesConfig {
-  const paths = getResponsePaths();
-  const responses = loadAndMergeData(paths);
-  return { responses };
-}
-
-/** Load the whole Swagger config */
-function loadConfig(): SwaggerConfig {
-  const indexPath = `${process.cwd()}/src/docs/index.yaml`;
-  const config = (
-    fs.existsSync(indexPath) ? YAML.load(indexPath) : {}
-  ) as IndexDocumentation;
-  const schemaConfig = loadSchemas();
-  const responseConfig = loadResponses();
-  const endpointConfig = loadEndpoints();
-  return {
-    ...config,
-    ...endpointConfig,
-    components: {
-      ...config.components,
-      ...schemaConfig,
-      ...responseConfig
-    }
-  };
-}
-
-/**
- * Get a middleware that serves the documentation
- * @return {Router}
- */
-export function swaggerDocs(): Router {
-  // Stringify the result and replace any environment variable, then turn it again to an object
-  const stringifiedDocumentation = JSON.stringify(loadConfig());
-  const placeholderRegex = /##(.+?)##/g;
-  const overwrittenDocumentation = stringifiedDocumentation.replace(
-    placeholderRegex,
-    (match: string, p1: string): string => process.env[p1] ?? ''
-  );
-  const config = JSON.parse(overwrittenDocumentation) as EndpointDocumentation;
-  
-  return Router().use('/docs', swaggerUi.serve, swaggerUi.setup(config));
-}

package/src/middleware/swaggerDocs/swaggerDocs.types.ts

@@ -1,41 +0,0 @@
-/** Documentation content */
-export interface EndpointDocumentation {
-  [path: string]: { [key: string]: unknown };
-}
-
-/** Documentation content  */
-interface ComponentDocumentation {
-  [name: string]: { [key: string]: unknown };
-}
-
-/** root documentation config */
-export interface IndexDocumentation extends EndpointDocumentation {
-  /** Global components to be documented */
-  components: ComponentDocumentation;
-}
-
-/** Documentation config for endpoints */
-export interface EndpointConfig {
-  /** Documentation content */
-  paths: EndpointDocumentation;
-}
-
-/** Documentation config for responses */
-export interface ResponsesConfig {
-  /** Documentation content */
-  responses: ComponentDocumentation;
-}
-
-/** Documentation config for schemas */
-export interface SchemasConfig {
-  /** Documentation content */
-  schemas: ComponentDocumentation;
-}
-
-export type SwaggerConfig = IndexDocumentation &
-  EndpointConfig & {
-    /** Shared components documentation */
-    components: IndexDocumentation['components'] &
-      ResponsesConfig &
-      SchemasConfig;
-  };

package/src/middleware/userResolver/index.ts

@@ -1 +0,0 @@
-export * from './userResolver';

package/src/middleware/userResolver/userResolver.ts

@@ -1,53 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import { EngineError } from 'entities/EngineError';
-import { reportDebug } from 'utils';
-import { tlsRequest } from 'utils/tlsRequest';
-
-const namespace = 'engine:middleware:userResolver';
-
-/** Fetch the user previously identified by a JWT and adds his data to the request.user object */
-export async function userResolver(
-  request: Request,
-  response: Response,
-  next: NextFunction
-): Promise<void> {
-  const id = request.user?.id;
-  if (!id)
-    throw new EngineError({
-      message: 'Could not resolve user as the request is missing his ID'
-    });
-  const user = await getUserById(id);
-  if (!user)
-    throw new EngineError({
-      message: 'Could not resolve user as it could not be fetched',
-      data: { id }
-    });
-  reportDebug({
-    namespace,
-    message: 'Resolved user based on his token',
-    data: { user, request: request.user }
-  });
-  request.user = {
-    ...request?.user,
-    ...user
-  };
-
-  next();
-}
-
-/**
- * Call the GET /user/{id} endpoint using TLS
- */
-export async function getUserById(userId: number): Promise<unknown> {
-  const userServiceUrl = process.env.USER_SERVICE_URL;
-  if (!userServiceUrl) {
-    throw new Error('USER_SERVICE_URL is not defined in environment variables');
-  }
-
-  const response = await tlsRequest<unknown>({
-    method: 'GET',
-    url: `${userServiceUrl}/${userId}`
-  });
-
-  return response.data;
-}

package/src/middleware/validate/index.ts

@@ -1 +0,0 @@
-export * from './validate';

package/src/middleware/validate/validate.test.ts

@@ -1,43 +0,0 @@
-import { expect } from 'chai';
-import express, { Response, Request, NextFunction } from 'express';
-import request from 'supertest';
-import { validate } from './validate';
-import { ValidationError } from 'entities/ValidationError';
-
-describe('Middleware - validate', () => {
-  it('should validate according to the schema', async () => {
-    const app = express();
-    const middleware = validate({
-      size: {
-        in: 'query',
-        isInt: true
-      }
-    });
-
-    app.get('/example', ...middleware, (req: any, res: any) =>
-      res.sendStatus(200)
-    );
-
-    app.use(
-      (
-        error: ValidationError,
-        req: Request,
-        res: Response,
-        next: NextFunction
-      ) => {
-        expect(error.errorCode).to.equal('invalid-request');
-        expect((error.data as Record<string, string>).size).to.deep.equal(
-          'Invalid value'
-        );
-        res.sendStatus(error.statusCode);
-      }
-    );
-
-    await request(app).get('/example').query({ size: 4000 }).expect(200);
-
-    // await request(app)
-    //   .get('/example')
-    //   .query({ size: 'not number' })
-    //   .expect(400);
-  });
-});

package/src/middleware/validate/validate.ts

@@ -1,25 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import {
-  checkSchema,
-  validationResult,
-  Schema,
-  ValidationChain
-} from 'express-validator';
-import { ValidationError } from 'entities/ValidationError';
-
-/** Validate the express-validator results */
-export const validate = (
-  config: Schema
-): Array<
-  ValidationChain | ((req: Request, res: Response, next: NextFunction) => void)
-> => [
-  ...checkSchema(config),
-  (req: Request, res: Response, next: NextFunction): void => {
-    const result = validationResult(req);
-    if (result.isEmpty()) {
-      next();
-      return;
-    }
-    next(new ValidationError(result));
-  }
-];

package/src/middleware/version/index.ts

@@ -1 +0,0 @@
-export * from './version';