@jumentix/cli-init 0.0.0

package/templates/backend/src/interface/HTTP/adapters/derby-js/DerbyJsServer.ts

@@ -0,0 +1,242 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable class-methods-use-this */
+import { createServer, Server } from 'http';
+import fs from 'fs';
+import path from 'path';
+import { createUuid } from '@src/modules/port/UUID';
+import { _HTTP_PORT_ } from '@src/config/constants';
+import { Context as RequestContext } from '@src/infra/context/Context';
+import type {
+  IHTTPRequest,
+  IHTTPResponse,
+  IbaseHandler
+} from '@src/interface/HTTP/ports';
+import {
+  HTTPBaseServer
+} from '@src/interface/HTTP/ports';
+
+export type DerbyJsRequest = IHTTPRequest;
+export type DerbyJsResponse = {
+  status: (statusCode: number) => DerbyJsResponse;
+  json: (payload: any) => any;
+  send?: (payload: any) => any;
+} & IHTTPResponse;
+
+let derbyJsServer: HTTPBaseServer<any> | undefined;
+
+class DerbyJsServer extends HTTPBaseServer<any> {
+  public readonly application: any;
+
+  private readonly router: any;
+
+  private server: Server | undefined;
+
+  private staticDocs: Record<string, Map<string, string>> = {};
+
+  private staticDocsRegistered = false;
+
+  private static getContentType(fileName: string): string {
+    if (fileName.endsWith('.html')) return 'text/html; charset=utf-8';
+    if (fileName.endsWith('.js')) return 'application/javascript; charset=utf-8';
+    if (fileName.endsWith('.css')) return 'text/css; charset=utf-8';
+    if (fileName.endsWith('.json')) return 'application/json; charset=utf-8';
+    if (fileName.endsWith('.svg')) return 'image/svg+xml';
+    if (fileName.endsWith('.png')) return 'image/png';
+    if (fileName.endsWith('.jpg') || fileName.endsWith('.jpeg')) return 'image/jpeg';
+    return 'text/plain; charset=utf-8';
+  }
+
+  private static normalizeDocRequestPath(rawUrl: string, prefix: string): string {
+    const pathname = rawUrl.split('?')[0];
+    const trimmed = pathname.startsWith(prefix) ? pathname.slice(prefix.length) : pathname;
+    const candidate = trimmed.replace(/^\/+/, '') || 'index.html';
+    const normalized = path.posix.normalize(`/${candidate}`).replace(/^\/+/, '');
+    if (!normalized || normalized.includes('..')) return '';
+    return normalized;
+  }
+
+  private loadStaticDocManifest(docFolder: string): Map<string, string> {
+    const manifest = new Map<string, string>();
+    const absoluteFolder = path.resolve(process.cwd(), docFolder);
+    if (!fs.existsSync(absoluteFolder)) return manifest;
+
+    const walk = (currentPath: string) => {
+      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+      entries.forEach((entry) => {
+        const absoluteEntryPath = path.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+          walk(absoluteEntryPath);
+          return;
+        }
+        const relative = path.relative(absoluteFolder, absoluteEntryPath).split(path.sep).join('/');
+        manifest.set(relative, absoluteEntryPath);
+      });
+    };
+
+    walk(absoluteFolder);
+    return manifest;
+  }
+
+  constructor() {
+    super();
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    const derby = require('derby');
+    // eslint-disable-next-line global-require
+    const Router = require('find-my-way');
+
+    this.application = derby.createApp('api');
+    this.router = Router();
+  }
+
+  private createResponseAdapter(response: any): any {
+    return {
+      status(code: number) {
+        response.statusCode = code;
+        return this;
+      },
+      json(payload: any) {
+        response.setHeader('content-type', 'application/json; charset=utf-8');
+        response.end(JSON.stringify(payload));
+        return payload;
+      },
+      send(payload: any) {
+        if (typeof payload === 'object') {
+          response.setHeader('content-type', 'application/json; charset=utf-8');
+          response.end(JSON.stringify(payload));
+          return payload;
+        }
+        response.end(payload);
+        return payload;
+      }
+    };
+  }
+
+  private async readBody(request: any): Promise<any> {
+    const method = (request.method || 'GET').toUpperCase();
+    if (method === 'GET' || method === 'HEAD') return {};
+
+    const chunks: Buffer[] = [];
+    await new Promise<void>((resolve, reject) => {
+      request.on('data', (chunk: Buffer | string) => {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      request.on('end', () => resolve());
+      request.on('error', (error: Error) => reject(error));
+    });
+
+    if (!chunks.length) return {};
+    const raw = Buffer.concat(chunks).toString('utf8').trim();
+    if (!raw) return {};
+
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+
+  public endPointRegister(handlerFactory: IbaseHandler): void {
+    this.router.on(
+      handlerFactory.method.toUpperCase(),
+      handlerFactory.path,
+      async (request: any, response: any, params: Record<string, any>) => {
+        const body = await this.readBody(request);
+        const req = {
+          ...request,
+          params,
+          query: request.query || {},
+          headers: request.headers || {},
+          body
+        };
+        const res = this.createResponseAdapter(response);
+        await handlerFactory.handler(req, res);
+      }
+    );
+  }
+
+  private registerStaticDocsRoutes(): void {
+    this.staticDocs.OASdoc = this.loadStaticDocManifest('apps/backend-template/OASdoc');
+    this.staticDocs.AsyncAPIdoc = this.loadStaticDocManifest('apps/backend-template/AsyncAPIdoc');
+    const register = (prefix: string, docFolder: string) => {
+      const manifestKey = prefix.replace('/', '');
+      this.router.on('GET', `${prefix}/*`, async (request: any, response: any) => {
+        const normalizedPath = DerbyJsServer.normalizeDocRequestPath(request.url || '', prefix);
+        const manifest = this.staticDocs[manifestKey] || this.loadStaticDocManifest(docFolder);
+        const absolutePath = normalizedPath ? manifest.get(normalizedPath) : undefined;
+        if (!absolutePath || !fs.existsSync(absolutePath)) {
+          response.statusCode = 404;
+          response.end('Not found');
+          return;
+        }
+        response.statusCode = 200;
+        response.setHeader('content-type', DerbyJsServer.getContentType(absolutePath));
+        response.end(fs.readFileSync(absolutePath));
+      });
+    };
+
+    register('/OASdoc', 'apps/backend-template/OASdoc');
+    register('/AsyncAPIdoc', 'apps/backend-template/AsyncAPIdoc');
+    this.router.on('GET', '/docs/asyncapi', async (_request: any, response: any) => {
+      response.statusCode = 302;
+      response.setHeader('location', '/AsyncAPIdoc');
+      response.end();
+    });
+  }
+
+  /**
+   * The listener `start` binds, exposed so a test can drive it (JUM-704).
+   *
+   * Extracted rather than invented, matching Adonis-JS and Total-JS: `start`
+   * built this inline and bound it to a fixed port, which is why the suite named
+   * after this adapter never went near it.
+   */
+  public requestListener(): (req: any, res: any) => void {
+    if (!this.staticDocsRegistered) {
+      this.registerStaticDocsRoutes();
+      this.staticDocsRegistered = true;
+    }
+
+    /*
+     * The per-request store every handler reads. Express, Restify, Fastify and
+     * Lambda each establish it; this adapter did not, and it serves the same
+     * handlers — `localhost.get` reads `correlationId` from the store, so every
+     * request through it answered 500 with an empty message (JUM-698 found this
+     * in the four adapters that could be started; this is the same defect in one
+     * that could not).
+     */
+    return (req: any, res: any) => {
+      const store = new Map();
+      RequestContext.run(store, () => {
+        store.set('correlationId', createUuid());
+        store.set('timeStart', +new Date());
+        store.set('request', req);
+        store.set('authorization', req.headers?.authorization || '');
+        this.router.lookup(req, res);
+      });
+    };
+  }
+
+  public async start(): Promise<void> {
+    this.server = createServer(this.requestListener());
+    await new Promise<void>((resolve) => {
+      this.server!.listen(_HTTP_PORT_, resolve);
+    });
+  }
+
+  public async stop(): Promise<void> {
+    if (!this.server) return;
+    await new Promise<void>((resolve) => {
+      this.server!.close(() => resolve());
+    });
+  }
+
+  public static compile(): HTTPBaseServer<any> {
+    if (!derbyJsServer) {
+      derbyJsServer = new DerbyJsServer();
+    }
+    return derbyJsServer;
+  }
+}
+
+export { DerbyJsServer };

package/templates/backend/src/interface/HTTP/adapters/derby-js/derby-js.ts

@@ -0,0 +1,55 @@
+/* eslint-disable quote-props */
+import { DerbyJsServer } from '@src/interface/HTTP/adapters/derby-js/DerbyJsServer';
+import { infraHandlers } from '@src/interface/HTTP/adapters/derby-js/handlers/infraHandlers';
+
+import {
+  composeUsersAuthServices
+} from '@src/modules/Users';
+
+import { MutexService } from '@src/infra/mutex/adapter/MutexService';
+import { compileDatabaseClient } from '@src/infra/persistence/compileDatabaseClient';
+import { JwtService } from '@src/infra/jwt/JwtService';
+import { compileKeyValueStorageClient } from '@src/infra/persistence/KeyValueStorage/compileKeyValueStorageClient';
+import { PasswordCryptoService } from '@src/infra/security/PasswordCryptoService';
+import { compileMessageMediator } from '@src/infra/messages/compileMessageMediator';
+import { EHTTPFrameworks } from '@src/interface/HTTP/ports';
+import { RestAPI } from '@src/interface/HTTP/RestAPI';
+import { compileAdapterRuntime } from '@jumentix/adapter-runtime-bootstrap';
+
+const serverType = EHTTPFrameworks.derby_js;
+const webServer = DerbyJsServer.compile();
+
+const {
+  databaseClient,
+  keyValueStorageClient,
+  mutexService,
+  passwordCryptoService,
+  messageMediator,
+  authService
+} = compileAdapterRuntime({
+  compileDatabaseClient,
+  compileKeyValueStorageClient,
+  compileMutexService: (client) => MutexService.compile(client),
+  compilePasswordCryptoService: () => PasswordCryptoService.compile(),
+  compileJwtService: () => JwtService.compile(),
+  compileMessageMediator: () => compileMessageMediator(),
+  composeAuthServices: composeUsersAuthServices
+});
+
+const API = new RestAPI<any>({
+  databaseClient,
+  webServer,
+  infraHandlers,
+  serverType,
+  authService,
+  passwordCryptoService,
+  keyValueStorageClient,
+  mutexService,
+  eventBus: messageMediator,
+  messageMediator
+});
+
+(async () => {
+  await API.start();
+  await API.seedData();
+})();

package/templates/backend/src/interface/HTTP/adapters/derby-js/handlers/infraHandlers.ts

@@ -0,0 +1,3 @@
+import { infraHandlers as expressInfraHandlers } from '@src/interface/HTTP/adapters/express/handlers/infraHandlers';
+
+export const infraHandlers = expressInfraHandlers;

package/templates/backend/src/interface/HTTP/adapters/derby-js/responses/sendErrorResponse.ts

@@ -0,0 +1,9 @@
+import { BaseError, EErrorStringCodes } from '@src/infra/exceptions';
+import { buildErrorResponsePayload, toHttpStatus } from '@src/shared/utils';
+import type { DerbyJsResponse } from '@src/interface/HTTP/adapters/derby-js/DerbyJsServer';
+
+export function sendErrorResponse(error: BaseError, res: DerbyJsResponse) {
+  return res
+    .status(toHttpStatus(error.code as EErrorStringCodes) || 500)
+    .json(buildErrorResponsePayload(error));
+}

package/templates/backend/src/interface/HTTP/adapters/express/ExpressServer.ts

@@ -0,0 +1,94 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import express, { Express } from 'express';
+import bodyParser from 'body-parser';
+import cors from 'cors';
+import helmet from 'helmet';
+import { v4 } from 'uuid';
+import { _HTTP_PORT_ } from '@src/config/constants';
+import { isCorsOriginAllowed } from '@src/config/security';
+import { HTTPBaseServer } from '@src/interface/HTTP/ports';
+import { Context } from '@src/infra/context/Context';
+import { InternalServerError } from '@src/infra/exceptions';
+import { Server } from 'http';
+
+let server: any;
+
+class ExpressServer extends HTTPBaseServer<Express> {
+  public readonly application: Express;
+
+  private server: Server | undefined;
+
+  constructor() {
+    super();
+    this.application = express();
+    this.application.use(cors({
+      origin(origin, callback) {
+        if (isCorsOriginAllowed(origin)) {
+          callback(null, true);
+          return;
+        }
+        callback(new Error('Not allowed by CORS'));
+      }
+    }));
+    this.application.use(helmet());
+    this.application.use(bodyParser.json({ limit: '100mb' }));
+
+    this.application.use((req, res, next) => {
+      const store = new Map();
+      Context.run(store, () => {
+        store.set('correlationId', v4());
+        store.set('timeStart', +new Date());
+        store.set('request', req);
+        store.set('authorization', req.headers.authorization || '');
+
+        // requestLogger('request started');
+        next();
+      });
+    });
+    // this.application.use(bodyParser.urlencoded({ limit: '100mb', extended: true }));
+    this.createDocEndPoint();
+  }
+
+  private createDocEndPoint() {
+    this.application.use('/OASdoc', express.static('apps/backend-template/OASdoc'));
+    this.application.use('/AsyncAPIdoc', express.static('apps/backend-template/AsyncAPIdoc'));
+    this.application.get('/docs/asyncapi', (_, res) => {
+      res.redirect('/AsyncAPIdoc');
+    });
+  }
+
+  public start(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const port = Number(process.env.JUMENTIX_HTTP_PORT || _HTTP_PORT_);
+        this.server = this.application.listen(port, () => {
+          // eslint-disable-next-line no-console
+          console.log(`Express App Listening on Port ${port}`);
+          resolve();
+        });
+      } catch (error) {
+        // console.error(`An error occurred: ${JSON.stringify(error)}`);
+        this.stop();
+        reject(new InternalServerError((error as Error).message));
+      }
+    });
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  public async stop(): Promise<void> {
+    if (!this.server) {
+      return;
+    }
+    await Promise.resolve(this.server.close());
+    // process.exit(0);
+  }
+
+  public static compile(): HTTPBaseServer<Express> {
+    if (!server) {
+      server = new this();
+    }
+    return server;
+  }
+}
+
+export { ExpressServer };

package/templates/backend/src/interface/HTTP/adapters/express/express.ts

@@ -0,0 +1,56 @@
+/* eslint-disable quote-props */
+import { Express } from 'express';
+import { ExpressServer } from '@src/interface/HTTP/adapters/express/ExpressServer';
+import { infraHandlers } from '@src/interface/HTTP/adapters/express/handlers/infraHandlers';
+
+import {
+  composeUsersAuthServices
+} from '@src/modules/Users';
+
+import { MutexService } from '@src/infra/mutex/adapter/MutexService';
+import { compileDatabaseClient } from '@src/infra/persistence/compileDatabaseClient';
+import { JwtService } from '@src/infra/jwt/JwtService';
+import { compileKeyValueStorageClient } from '@src/infra/persistence/KeyValueStorage/compileKeyValueStorageClient';
+import { PasswordCryptoService } from '@src/infra/security/PasswordCryptoService';
+import { compileMessageMediator } from '@src/infra/messages/compileMessageMediator';
+import { EHTTPFrameworks } from '@src/interface/HTTP/ports';
+import { RestAPI } from '@src/interface/HTTP/RestAPI';
+import { compileAdapterRuntime } from '@jumentix/adapter-runtime-bootstrap';
+
+const serverType = EHTTPFrameworks.express;
+const webServer = ExpressServer.compile();
+
+const {
+  databaseClient,
+  keyValueStorageClient,
+  mutexService,
+  passwordCryptoService,
+  messageMediator,
+  authService
+} = compileAdapterRuntime({
+  compileDatabaseClient,
+  compileKeyValueStorageClient,
+  compileMutexService: (client) => MutexService.compile(client),
+  compilePasswordCryptoService: () => PasswordCryptoService.compile(),
+  compileJwtService: () => JwtService.compile(),
+  compileMessageMediator: () => compileMessageMediator(),
+  composeAuthServices: composeUsersAuthServices
+});
+
+const API = new RestAPI<Express>({
+  databaseClient,
+  webServer,
+  infraHandlers,
+  serverType,
+  authService,
+  passwordCryptoService,
+  keyValueStorageClient,
+  mutexService,
+  eventBus: messageMediator,
+  messageMediator
+});
+
+(async () => {
+  await API.start();
+  await API.seedData();
+})();

package/templates/backend/src/interface/HTTP/adapters/express/handlers/apiDocGetHandlerFactory.ts

@@ -0,0 +1,22 @@
+import { Request, Response } from 'express';
+
+import type { IHandlerFactory, EndPointFactory, IbaseHandler } from '@src/interface/HTTP/ports';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/express/responses/sendErrorResponse';
+
+const apiDocGetHandlerFactory: EndPointFactory = (
+  { spec, version }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: `/${version}`,
+    method: 'get',
+    handler(req: Request, res: Response) {
+      try {
+        res.json(spec);
+      } catch (error: any) {
+        sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default apiDocGetHandlerFactory;

package/templates/backend/src/interface/HTTP/adapters/express/handlers/apiversions.get.ts

@@ -0,0 +1,23 @@
+import { Request, Response } from 'express';
+import { _DOCS_PREFIX_ } from '@src/config/constants';
+import type { IHandlerFactory, IbaseHandler, EndPointFactory } from '@src/interface/HTTP/ports';
+
+const apiVersionsGetHandlerFactory: EndPointFactory = (
+  { apiDocs }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/versions',
+    method: 'get',
+    handler(req: Request, res: Response): void {
+      const versions: Record<string, string> = {};
+      if (typeof apiDocs !== 'undefined') {
+        for (const [version] of apiDocs) {
+          versions[version] = `${_DOCS_PREFIX_}/${version}`;
+        }
+      }
+      res.status(200).json({ versions });
+    }
+  };
+};
+
+export default apiVersionsGetHandlerFactory;

package/templates/backend/src/interface/HTTP/adapters/express/handlers/infraHandlers.ts

@@ -0,0 +1,9 @@
+import localhostGetHandlerFactory from '@src/interface/HTTP/adapters/express/handlers/localhost.get';
+import apiVersionsGetHandlerFactory from '@src/interface/HTTP/adapters/express/handlers/apiversions.get';
+import apiDocGetHandlerFactory from '@src/interface/HTTP/adapters/express/handlers/apiDocGetHandlerFactory';
+
+export const infraHandlers = {
+  localhostGetHandlerFactory,
+  apiVersionsGetHandlerFactory,
+  apiDocGetHandlerFactory
+};

package/templates/backend/src/interface/HTTP/adapters/express/handlers/localhost.get.ts

@@ -0,0 +1,23 @@
+import { Request, Response } from 'express';
+
+import type { EndPointFactory, IbaseHandler } from '@src/interface/HTTP/ports';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/express/responses/sendErrorResponse';
+import { Context } from '@src/infra/context/Context';
+import { BaseError } from '@src/infra/exceptions';
+
+const localhostGetHandlerFactory: EndPointFactory = (): IbaseHandler => {
+  return {
+    path: '/',
+    method: 'get',
+    handler(req: Request, res: Response) {
+      try {
+        const store: Map<any, any> = Context.getStore() as Map<any, any>;
+        res.json({ status: 'result', correlationId: store.get('correlationId') });
+      } catch (error: any) {
+        sendErrorResponse(error as BaseError, res);
+      }
+    }
+  };
+};
+
+export default localhostGetHandlerFactory;

package/templates/backend/src/interface/HTTP/adapters/express/responses/sendErrorResponse.ts

@@ -0,0 +1,10 @@
+import { Response } from 'express';
+
+import { BaseError, EErrorStringCodes } from '@src/infra/exceptions';
+import { buildErrorResponsePayload, toHttpStatus } from '@src/shared/utils';
+
+export function sendErrorResponse(error: BaseError, res: Response) {
+  res
+    .status(toHttpStatus(error.code as EErrorStringCodes) || 500)
+    .json(buildErrorResponsePayload(error));
+}

package/templates/backend/src/interface/HTTP/adapters/fastify/FastifyServer.ts

@@ -0,0 +1,113 @@
+import fastify, { FastifyRequest, FastifyReply } from 'fastify';
+import cors from '@fastify/cors';
+import helmet from '@fastify/helmet';
+import fastifyStatic from '@fastify/static';
+import formBody from '@fastify/formbody';
+import path from 'node:path';
+import { v4 } from 'uuid';
+
+import { _HTTP_PORT_ } from '@src/config/constants';
+import { isCorsOriginAllowed } from '@src/config/security';
+import { HTTPBaseServer } from '@src/interface/HTTP/ports';
+import { Context } from '@src/infra/context/Context';
+
+const fastifyApp = fastify({
+  bodyLimit: 1048576 * 100 // 100mb
+});
+export type Fastify = typeof fastifyApp;
+
+let fastifyServer: any;
+
+class FastifyServer extends HTTPBaseServer<Fastify> {
+  public readonly application: Fastify;
+
+  constructor() {
+    super();
+    this.application = fastifyApp;
+    this.application.register(cors, {
+      origin(origin, callback) {
+        if (isCorsOriginAllowed(origin)) {
+          callback(null, true);
+          return;
+        }
+        callback(new Error('Not allowed by CORS'), false);
+      }
+    });
+    this.application.register(helmet, {
+      contentSecurityPolicy: false
+    });
+    this.application.register(formBody);
+    (this.application as any).addHook('preHandler', (req: FastifyRequest, res: FastifyReply, next: any) => {
+      const store = new Map();
+      Context.run(store, () => {
+        store.set('correlationId', v4());
+        store.set('timeStart', +new Date());
+        store.set('request', req);
+        store.set('authorization', req.headers.authorization || '');
+
+        // requestLogger('request started');
+        next();
+      });
+    });
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    /* await this.application.register(require('middie'));
+
+    this.application.use((req: FastifyRequest, res: FastifyReply, next: any) => {
+      const store = new Map();
+      Context.run(store, () => {
+        store.set('correlationId', v4());
+        store.set('timeStart', +new Date());
+        store.set('request', req);
+        store.set('authorization', req.headers.authorization || '');
+
+        // requestLogger('request started');
+        next();
+      });
+    }); */
+
+    this.createDocEndPoint();
+  }
+
+  private createDocEndPoint() {
+    this.application.register(fastifyStatic, {
+      root: path.resolve(process.cwd(), 'apps/backend-template/OASdoc'),
+      prefix: '/OASdoc/'
+    });
+    this.application.register(fastifyStatic, {
+      root: path.resolve(process.cwd(), 'apps/backend-template/AsyncAPIdoc'),
+      prefix: '/AsyncAPIdoc/',
+      decorateReply: false
+    });
+    this.application.get('/docs/asyncapi', async (_, reply) => {
+      return reply.redirect('/AsyncAPIdoc/');
+    });
+  }
+
+  public async start(): Promise<void> {
+    try {
+      await this.application.listen({ port: _HTTP_PORT_ });
+      // eslint-disable-next-line no-console
+      console.log(`Fastify App Listening on Port ${_HTTP_PORT_}`);
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(`An error occurred: ${JSON.stringify(error)}`);
+      this.stop();
+      throw error;
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  public async stop(): Promise<void> {
+    await Promise.resolve(this.application.close());
+    // process.exit(0);
+  }
+
+  public static compile(): HTTPBaseServer<Fastify> {
+    if (!fastifyServer) {
+      fastifyServer = new FastifyServer();
+    }
+    return fastifyServer;
+  }
+}
+
+export { FastifyServer };