node-server-engine 1.4.9 → 1.5.1

package/babel.config.json

@@ -1,34 +0,0 @@
-{
-  "presets": [
-    "@babel/preset-typescript",
-    [
-      "@babel/preset-env",
-      {
-        "targets": { "node": 20 },
-        "useBuiltIns": "entry",
-        "corejs": 3
-      }
-    ]
-  ],
-  "plugins": [
-    [
-      "module-resolver",
-      {
-        "root": "src",
-        "alias": {
-          "test": "test"
-        },
-        "extensions": [".js", ".ts"]
-      }
-    ],
-    ["@babel/plugin-proposal-decorators", { "legacy": true }],
-    "@babel/plugin-transform-class-properties",
-    "@babel/plugin-transform-classes",
-    "@babel/plugin-transform-runtime"
-  ],
-  "env": {
-    "test": {
-      "plugins": ["istanbul"]
-    }
-  }
-}

package/eslint.config.mjs

@@ -1,11 +0,0 @@
-import globals from 'globals';
-import pluginJs from '@eslint/js';
-import tseslint from 'typescript-eslint';
-
-export default [
-  { files: ['.src/', '**/*.{js,mjs,cjs,ts}'] },
-  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
-  pluginJs.configs.recommended,
-  { ignores: ['**/*.test.ts', '**/*.d.ts'] },
-  ...tseslint.configs.recommended
-];

package/src/const/DebeziumEvent.ts

@@ -1,6 +0,0 @@
-/** Debezium event types */
-export enum DebeziumEvent {
-  Create = 'c',
-  Update = 'u',
-  Delete = 'd'
-}

package/src/const/LogSeverity.ts

@@ -1,7 +0,0 @@
-export enum LogSeverity {
-  DEBUG = 'DEBUG',
-  INFO = 'INFO',
-  WARNING = 'WARNING',
-  ERROR = 'ERROR',
-  CRITICAL = 'CRITICAL'
-}

package/src/const/index.ts

@@ -1,5 +0,0 @@
-export * from './mime';
-export * from './metrics';
-export * from './DebeziumEvent';
-export * from './LogSeverity';
-export * from './tokenIssuer';

package/src/const/metrics.ts

@@ -1,6 +0,0 @@
-import { Registry } from 'prom-client';
-
-// Registry for metrics that apply to this specific instance of the service
-export const instanceRegistry = new Registry();
-// Registry for metrics that apply to the service as a whole
-export const serviceRegistry = new Registry();

package/src/const/mime.ts

@@ -1,37 +0,0 @@
-export const IMAGE_BASIC_MIME = ['image/jpeg', 'image/png'];
-
-export const IMAGE_MIME = [...IMAGE_BASIC_MIME, 'image/gif', 'image/bmp'];
-
-export const AUDIO_MIME = [
-  'audio/aac',
-  'audio/mpeg',
-  'audio/wave',
-  'audio/wav'
-];
-
-export const VIDEO_MIME = [
-  'video/mpeg',
-  'video/mp4',
-  'video/3gpp',
-  'video/3gp2'
-];
-
-export const PDF_MIME = ['application/pdf'];
-
-export const WORD_MIME = [
-  'application/msword',
-  'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
-];
-
-export const EXCEL_MIME = [
-  'application/vnd.ms-excel',
-  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-];
-
-export const POWERPOINT_MIME = [
-  'application/vnd.ms-powerpoint',
-  'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  'application/vnd.openxmlformats-officedocument.presentationml.slideshow'
-];
-
-export const OFFICE_MIME = [...WORD_MIME, ...EXCEL_MIME, ...POWERPOINT_MIME];

package/src/const/tokenIssuer.ts

@@ -1,7 +0,0 @@
-/** Enum to identify access tokens JWT issuers */
-export enum TokenIssuer {
-  /** For tokens issued by the auth service */
-  AUTH_SERVICE
-}
-
-export const TOKEN_ISSUERS = Object.values(TokenIssuer);

package/src/db/migrations/20241030121500-create-sequelize-meta-table.ts

@@ -1,29 +0,0 @@
-import { QueryInterface, DataTypes } from 'sequelize';
-
-export async function up(queryInterface: QueryInterface): Promise<void> {
-  await queryInterface.createTable(
-    'SequelizeMeta',
-    {
-      id: {
-        type: DataTypes.INTEGER,
-        autoIncrement: true,
-        primaryKey: true
-      },
-      name: {
-        type: DataTypes.STRING,
-        allowNull: false
-      },
-      version: {
-        type: DataTypes.STRING,
-        allowNull: false
-      }
-    },
-    {
-      charset: 'utf8mb4',
-      collate: 'utf8mb4_unicode_ci' // Change this to a valid collation
-    }
-  );
-}
-export async function down(queryInterface: QueryInterface): Promise<void> {
-  await queryInterface.dropTable('SequelizeMeta');
-}

package/src/db/models/SequelizeMeta.ts

@@ -1,16 +0,0 @@
-import { Table, Column, Model, DataType } from 'sequelize-typescript';
-
-@Table
-export class SequelizeMeta extends Model {
-  @Column({
-    type: DataType.STRING,
-    allowNull: false
-  })
-  name!: string;
-
-  @Column({
-    type: DataType.STRING,
-    allowNull: false
-  })
-  version!: string;
-}

package/src/db/models/index.ts

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

package/src/entities/ElasticSearch/ElasticSearch.ts

@@ -1,103 +0,0 @@
-import { readdirSync } from 'fs';
-import path from 'path';
-import { Client } from '@elastic/elasticsearch';
-import { ElasticSearchMigration } from './ElasticSearch.types';
-import { EngineError } from 'entities/EngineError';
-import { LifecycleController } from 'entities/LifecycleController';
-import { envAssert, reportError, reportInfo } from 'utils';
-import { checkEnvironment } from 'utils/checkEnvironment';
-
-/** Elastic search client */
-let client: undefined | Client;
-
-export const ElasticSearch = {
-  /**
-   * Init function that should be called on server startup to establish the connection
-   */
-  async init(): Promise<void> {
-    checkEnvironment({
-      ELASTIC_SEARCH_HOST: envAssert.isString(),
-      ELASTIC_SEARCH_USERNAME: envAssert.isString(),
-      ELASTIC_SEARCH_PASSWORD: envAssert.isString(),
-      ELASTIC_SEARCH_MIGRATION_PATH: envAssert.isString()
-    });
-
-    if (!process.env.ELASTIC_SEARCH_HOST)
-      throw new EngineError({
-        message: 'ElasticSearch Hosts not set in environment'
-      });
-
-    client = new Client({
-      node: process.env.ELASTIC_SEARCH_HOST,
-      auth: {
-        username: process.env.ELASTIC_SEARCH_USERNAME as string,
-        password: process.env.ELASTIC_SEARCH_PASSWORD as string
-      }
-    });
-    // In test environment flush the database before running migrations
-    if (process.env.NODE_ENV === 'test')
-      await client.indices.delete({ index: '*' });
-    await this.migrate();
-    LifecycleController.register(this);
-  },
-
-  /**
-   * Migration function called during the init process
-   * Manages the database structure
-   */
-  async migrate(): Promise<void> {
-    if (!client) throw new EngineError('ElasticSearch was not initialized');
-    const migrationPath = path.resolve(
-      process.env.ELASTIC_SEARCH_MIGRATION_PATH as string
-    );
-    const files = readdirSync(`${migrationPath}`);
-    const indexExists = await client.indices.exists({
-      index: 'migrations'
-    });
-    const ran = [];
-    for (const file of files) {
-      if (indexExists) {
-        const {
-          hits: { total }
-        } = await client.search({
-          index: 'migrations',
-          body: { query: { match: { file } } }
-        });
-        let tot = 0;
-        if (typeof total === 'number') {
-          tot = total;
-        } else {
-          tot = total?.value ?? 0;
-        }
-        if (tot > 0) continue;
-      }
-      ran.push(file);
-      const migration = (await import(
-        `${migrationPath}/${file}`
-      )) as ElasticSearchMigration;
-      try {
-        await migration.migrate(client);
-      } catch (error) {
-        reportError(error);
-        process.exit(1);
-      }
-
-      await client.create({
-        index: 'migrations',
-        id: file,
-        body: { file, ranAt: new Date() }
-      });
-    }
-    reportInfo({
-      message: `ElasticSearch: ran ${ran.length} migrations`,
-      data: { files: ran }
-    });
-  },
-
-  /**
-   * Shutdown function that should be called on server stop to close the connection
-   */
-  async shutdown(): Promise<void> {
-    if (client) await client.close();
-  }
-};

package/src/entities/ElasticSearch/ElasticSearch.types.ts

@@ -1,7 +0,0 @@
-import { Client } from '@elastic/elasticsearch';
-
-/** Represents a migration that should be executed on ElasticSearch */
-export interface ElasticSearchMigration {
-  /** Migration function */
-  migrate: (client: Client) => Promise<void>;
-}

package/src/entities/ElasticSearch/index.ts

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

package/src/entities/Endpoint/Endpoint.test.ts

@@ -1,248 +0,0 @@
-import { randomUUID } from 'crypto';
-import { generateAccessToken } from 'backend-test-tools';
-import { expect } from 'chai';
-import express, { Request, Response, NextFunction } from 'express';
-import { faker } from '@faker-js/faker';
-import { fake } from 'sinon';
-import request from 'supertest';
-import { Endpoint } from './Endpoint';
-import {
-  EndpointMethod,
-  EndpointAuthType,
-  EndpointOptions
-} from './Endpoint.types';
-import { Server } from 'entities/Server';
-import { request as httpRequest } from 'utils/request';
-import { tlsRequest } from 'utils/tlsRequest';
-
-const PATH = '/test';
-let app = express();
-
-const config: EndpointOptions<EndpointAuthType.NONE> = {
-  method: EndpointMethod.GET,
-  path: PATH,
-  handler: (req: Request, res: Response) => {
-    res.sendStatus(200);
-  },
-  validator: {},
-  authType: EndpointAuthType.NONE
-};
-
-describe('Entity - Endpoint', () => {
-  beforeEach(() => {
-    app = express();
-  });
-
-  // Base
-
-  it('should create a valid Endpoint', async () => {
-    const endpoint = new Endpoint(config);
-    endpoint.register(app);
-    await request(app).get(PATH).expect(200);
-  });
-
-  // Async
-
-  it('should handle asynchronous errors', async () => {
-    const endpoint = new Endpoint({
-      ...config,
-      handler: async (): Promise<void> => {
-        return new Promise((resolve, reject) => {
-          reject(new Error());
-        });
-      }
-    });
-    endpoint.register(app);
-    await request(app).get(PATH).expect(500);
-  });
-
-  // Middleware
-
-  it('should handle specific middleware', async () => {
-    const middleware = fake(
-      (req: Request, res: Response, next: NextFunction) => {
-        next();
-      }
-    );
-    const endpoint = new Endpoint({
-      ...config,
-      middleware: [middleware]
-    });
-    endpoint.register(app);
-    await request(app).get(PATH).expect(200);
-    expect(middleware).to.have.been.called;
-  });
-
-  it('should handle specific error middleware', async () => {
-    const middleware = fake(
-      (err: Error, req: Request, res: Response, next: NextFunction) => {
-        res.sendStatus(200);
-      }
-    );
-    const endpoint = new Endpoint({
-      ...config,
-      handler: (): void => {
-        throw new Error();
-      },
-      errorMiddleware: [middleware]
-    });
-    endpoint.register(app);
-    await request(app).get(PATH).expect(200);
-    expect(middleware).to.have.been.called;
-  });
-
-  // Validator
-
-  it('should accept request with a valid shape', async () => {
-    const endpoint = new Endpoint({
-      ...config,
-      validator: { number: { in: 'query', isInt: true } }
-    });
-    endpoint.register(app);
-    await request(app)
-      .get(PATH)
-      .query({ number: faker.number.int() })
-      .expect(200);
-  });
-
-  it('should reject request with an invalid shape', async () => {
-    const endpoint = new Endpoint({
-      ...config,
-      validator: { number: { in: 'query', isInt: true } }
-    });
-    endpoint.register(app);
-    await request(app)
-      .get(PATH)
-      .query({ number: faker.lorem.word() })
-      .expect(400);
-  });
-
-  // Middleware
-  it('should inject middlewares', async () => {
-    const middleware = fake(
-      (req: Request, res: Response, next: NextFunction) => {
-        next();
-      }
-    );
-    const endpoint = new Endpoint({
-      ...config,
-      middleware
-    });
-    endpoint.register(app);
-    await request(app).get(PATH).expect(200);
-    expect(middleware.called).to.be.true;
-  });
-
-  it('should inject multiple middlewares', async () => {
-    const middleware = [
-      fake((req: Request, res: Response, next: NextFunction) => {
-        next();
-      }),
-      fake((req: Request, res: Response, next: NextFunction) => {
-        next();
-      })
-    ];
-    const endpoint = new Endpoint({
-      ...config,
-      middleware
-    });
-    endpoint.register(app);
-    await request(app).get(PATH).expect(200);
-    expect(middleware[0].called).to.be.true;
-    expect(middleware[1].called).to.be.true;
-  });
-
-  // AUTH JWT
-
-  it('it should authenticate with authJwt middleware', async () => {
-    const id = randomUUID();
-    const token = generateAccessToken(id);
-    const endpoint = new Endpoint({
-      ...config,
-      authType: EndpointAuthType.JWT,
-      handler: (req: Request, res: Response) => {
-        res.sendStatus(200);
-      }
-    } as EndpointOptions<EndpointAuthType.JWT>);
-    const server = new Server({ endpoints: [endpoint] });
-
-    await server.init();
-
-    await request(server.getApp())
-      .get(PATH)
-      .set('Authorization', 'Bearer ' + token)
-      .expect(200);
-
-    await server.shutdown();
-  });
-
-  it('it should reject if the user has no valid JWT', async () => {
-    const endpoint = new Endpoint({
-      ...config,
-      authType: EndpointAuthType.JWT,
-      handler: (req: Request, res: Response) => {
-        res.sendStatus(200);
-      }
-    } as EndpointOptions<EndpointAuthType.JWT>);
-    endpoint.register(app);
-    await request(app).get(PATH).expect(401);
-  });
-
-  it('it should not trigger JWT error if acceptInvalid is set', async () => {
-    const endpoint = new Endpoint({
-      ...config,
-      authType: EndpointAuthType.JWT,
-      authParams: { acceptInvalid: true },
-      handler: (req: Request, res: Response) => {
-        res.sendStatus(200);
-      }
-    } as EndpointOptions<EndpointAuthType.JWT>);
-    endpoint.register(app);
-    await request(app).get(PATH).expect(200);
-  });
-
-  // TLS
-  it('it should authenticate with authTLS middleware', async () => {
-    const endpoint = new Endpoint({
-      ...config,
-      authType: EndpointAuthType.TLS,
-      handler: (req: Request, res: Response) => {
-        res.sendStatus(200);
-      }
-    } as EndpointOptions<EndpointAuthType.TLS>);
-    const server = new Server({ endpoints: [endpoint] });
-
-    await server.init();
-
-    await expect(
-      tlsRequest({
-        method: 'get',
-        url: `https://127.0.0.1:${process.env.PORT as string}${PATH}`
-      })
-    ).to.not.be.rejected;
-
-    await server.shutdown();
-  });
-
-  it('it should reject if the user has no valid TLS credentials', async () => {
-    const endpoint = new Endpoint({
-      ...config,
-      authType: EndpointAuthType.TLS,
-      handler: (req: Request, res: Response) => {
-        res.sendStatus(200);
-      }
-    } as EndpointOptions<EndpointAuthType.TLS>);
-    const server = new Server({ endpoints: [endpoint] });
-
-    await server.init();
-
-    await expect(
-      httpRequest({
-        method: 'get',
-        url: `https://127.0.0.1:${process.env.PORT as string}${PATH}`
-      })
-    ).to.be.rejected;
-
-    await server.shutdown();
-  });
-});