@jumentix/cli-init 0.0.0

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

@@ -0,0 +1,56 @@
+/* eslint-disable quote-props */
+import type { Fastify } from '@src/interface/HTTP/adapters/fastify/FastifyServer';
+import { FastifyServer } from '@src/interface/HTTP/adapters/fastify/FastifyServer';
+import { infraHandlers } from '@src/interface/HTTP/adapters/fastify/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.fastify;
+const webServer = FastifyServer.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: RestAPI<Fastify> = new RestAPI<Fastify>({
+  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/fastify/handlers/apiDocGetHandlerFactory.ts

@@ -0,0 +1,23 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+
+import type { IHandlerFactory, EndPointFactory, IbaseHandler } from '@src/interface/HTTP/ports';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/fastify/responses/sendErrorResponse';
+import { BaseError } from '@src/infra/exceptions';
+
+const apiDocGetHandlerFactory: EndPointFactory = (
+  { spec, version }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: `/${version}`,
+    method: 'get',
+    async handler(_req: FastifyRequest, res: FastifyReply) {
+      try {
+        return await res.send(spec);
+      } catch (error: unknown) {
+        return sendErrorResponse(error as BaseError, res);
+      }
+    }
+  };
+};
+
+export default apiDocGetHandlerFactory;

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

@@ -0,0 +1,24 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+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',
+    async handler(req: FastifyRequest, res: FastifyReply): Promise<any> {
+      const versions: Record<string, string> = {};
+      if (typeof apiDocs !== 'undefined') {
+        for (const [version] of apiDocs) {
+          versions[version] = `${_DOCS_PREFIX_}/${version}`;
+        }
+      }
+      res.code(200);
+      return Promise.resolve({ versions });
+    }
+  };
+};
+
+export default apiVersionsGetHandlerFactory;

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

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

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

@@ -0,0 +1,15 @@
+import type { EndPointFactory, IbaseHandler } from '@src/interface/HTTP/ports';
+import { Context } from '@src/infra/context/Context';
+
+const localhostGetHandlerFactory: EndPointFactory = (): IbaseHandler => {
+  return {
+    path: '/',
+    method: 'get',
+    async handler(): Promise<any> {
+      const store: Map<any, any> = Context.getStore() as Map<any, any>;
+      return { status: 'result', correlationId: store.get('correlationId') };
+    }
+  };
+};
+
+export default localhostGetHandlerFactory;

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

@@ -0,0 +1,10 @@
+// file deepcode ignore ServerLeak: <error information is available only for authorized users>
+import { FastifyReply } from 'fastify';
+import { buildErrorResponsePayload, toHttpStatus } from '@src/shared/utils';
+import { BaseError, EErrorStringCodes } from '@src/infra/exceptions';
+
+export function sendErrorResponse(error: BaseError, res: FastifyReply) {
+  res
+    .code(toHttpStatus(error.code as EErrorStringCodes) || 500)
+    .send(buildErrorResponsePayload(error));
+}

package/templates/backend/src/interface/HTTP/adapters/feathers/FeathersServer.ts

@@ -0,0 +1,218 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable class-methods-use-this */
+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 FeathersRequest = IHTTPRequest;
+export type FeathersResponse = {
+  status: (statusCode: number) => FeathersResponse;
+  json: (payload: any) => any;
+  send?: (payload: any) => any;
+} & IHTTPResponse;
+
+let feathersServer: HTTPBaseServer<any> | undefined;
+
+type RegisteredRoute = {
+  method: string;
+  path: string;
+  handler: IbaseHandler['handler'];
+};
+
+class FeathersServer extends HTTPBaseServer<any> {
+  public readonly application: any;
+
+  private httpServer: any;
+
+  /**
+   * Routes this adapter serves (JUM-704).
+   *
+   * `endPointRegister` used to call `this.application[method](path, handler)`.
+   * A Koa/Feathers application has no such method — the call threw
+   * `this.application[method] is undefined` on the first endpoint, which means
+   * **this adapter has never registered a route**. Nothing reported it: the
+   * suite named after it called an Express handler directly, and the framework
+   * was not installed, so no build ever loaded this file.
+   *
+   * Matching here rather than adding a router dependency keeps the shape the
+   * Vercel adapter already uses in this repository.
+   */
+  private readonly routes: RegisteredRoute[] = [];
+
+  constructor() {
+    super();
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    const { feathers } = require('@feathersjs/feathers');
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    const {
+      koa,
+      rest,
+      bodyParser,
+      errorHandler
+    } = require('@feathersjs/koa');
+
+    this.application = koa(feathers());
+
+    /*
+     * The per-request store every handler reads (JUM-704).
+     *
+     * 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 and fixed the same defect in the four
+     * adapters that could be started at the time; this one could not be, because
+     * its framework was not installed.
+     *
+     * First in the chain on purpose: everything downstream runs inside the
+     * store, including the static-doc branch and the route handlers.
+     */
+    this.application.use(async (context: any, next: any) => {
+      const store = new Map();
+      return RequestContext.run(store, () => {
+        store.set('correlationId', createUuid());
+        store.set('timeStart', +new Date());
+        store.set('request', context.request);
+        store.set('authorization', context.request?.headers?.authorization || '');
+        return next();
+      });
+    });
+
+    this.application.use(async (context: any, next: any) => {
+      const requestPath = context.path || context.request?.path || '';
+      const rootDir = process.cwd();
+      const readStatic = (prefix: string, folder: string): boolean => {
+        if (!requestPath.startsWith(prefix)) return false;
+        const relative = requestPath.replace(`${prefix}/`, '') || 'index.html';
+        const absolute = path.join(rootDir, folder, relative);
+        if (!fs.existsSync(absolute)) {
+          context.status = 404;
+          context.body = { message: 'Not found' };
+          return true;
+        }
+        context.status = 200;
+        context.body = fs.readFileSync(absolute);
+        if (absolute.endsWith('.html')) context.type = 'text/html';
+        else if (absolute.endsWith('.js')) context.type = 'application/javascript';
+        else if (absolute.endsWith('.css')) context.type = 'text/css';
+        else if (absolute.endsWith('.json')) context.type = 'application/json';
+        return true;
+      };
+      if (requestPath === '/docs/asyncapi') {
+        context.status = 302;
+        context.redirect('/AsyncAPIdoc');
+        return;
+      }
+      if (readStatic('/OASdoc', 'apps/backend-template/OASdoc')) return;
+      if (readStatic('/AsyncAPIdoc', 'apps/backend-template/AsyncAPIdoc')) return;
+      await next();
+    });
+    this.application.use(bodyParser());
+    this.application.configure(rest());
+    // After the body parser, before the error handler: the routes need a parsed
+    // body, and a handler that throws should reach `errorHandler` (JUM-704).
+    this.registerRouter();
+    this.application.use(errorHandler());
+  }
+
+  private createResponseAdapter(context: any): any {
+    return {
+      status(code: number) {
+        context.status = code;
+        return this;
+      },
+      json(payload: any) {
+        context.body = payload;
+        return payload;
+      },
+      send(payload: any) {
+        context.body = payload;
+        return payload;
+      }
+    };
+  }
+
+  public endPointRegister(handlerFactory: IbaseHandler): void {
+    this.routes.push({
+      method: handlerFactory.method.toUpperCase(),
+      path: handlerFactory.path,
+      handler: handlerFactory.handler
+    });
+  }
+
+  /** `/users/:id` against `/users/7`, returning the parameters it bound. */
+  private static matchPath(template: string, value: string): { matched: boolean; params: any } {
+    const templateParts = template.split('/').filter(Boolean);
+    const valueParts = value.split('/').filter(Boolean);
+    if (templateParts.length !== valueParts.length) return { matched: false, params: {} };
+
+    const params: Record<string, string> = {};
+    for (let index = 0; index < templateParts.length; index += 1) {
+      const templatePart = templateParts[index];
+      const valuePart = valueParts[index];
+      if (templatePart.startsWith(':')) {
+        params[templatePart.slice(1)] = decodeURIComponent(valuePart);
+      } else if (templatePart !== valuePart) {
+        return { matched: false, params: {} };
+      }
+    }
+    return { matched: true, params };
+  }
+
+  private registerRouter(): void {
+    this.application.use(async (context: any, next: any) => {
+      const method = String(context.method || 'GET').toUpperCase();
+      const pathname = context.path || context.request?.path || '/';
+      const matched = this.routes
+        .map((route) => ({ route, match: FeathersServer.matchPath(route.path, pathname) }))
+        .find((candidate) => candidate.route.method === method && candidate.match.matched);
+
+      if (!matched) {
+        await next();
+        return;
+      }
+
+      const req = {
+        ...context.request,
+        body: context.request?.body,
+        params: matched.match.params,
+        query: context.request?.query || {},
+        headers: context.request?.headers || {}
+      };
+      const res = this.createResponseAdapter(context);
+      const result = await matched.route.handler(req as any, res as any);
+      if (result !== undefined && context.body === undefined) {
+        context.body = result;
+      }
+    });
+  }
+
+  public async start(): Promise<void> {
+    this.httpServer = await this.application.listen(_HTTP_PORT_);
+  }
+
+  public async stop(): Promise<void> {
+    if (this.httpServer?.close) {
+      await Promise.resolve(this.httpServer.close());
+    }
+  }
+
+  public static compile(): HTTPBaseServer<any> {
+    if (!feathersServer) {
+      feathersServer = new FeathersServer();
+    }
+    return feathersServer;
+  }
+}
+
+export { FeathersServer };

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

@@ -0,0 +1,55 @@
+/* eslint-disable quote-props */
+import { FeathersServer } from '@src/interface/HTTP/adapters/feathers/FeathersServer';
+import { infraHandlers } from '@src/interface/HTTP/adapters/feathers/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.feathers;
+const webServer = FeathersServer.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/feathers/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/feathers/responses/sendErrorResponse.ts

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

package/templates/backend/src/interface/HTTP/adapters/loopback/LoopBackServer.ts

@@ -0,0 +1,165 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable class-methods-use-this */
+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 LoopBackRequest = IHTTPRequest;
+export type LoopBackResponse = {
+  status: (statusCode: number) => LoopBackResponse;
+  json: (payload: any) => any;
+  send?: (payload: any) => any;
+} & IHTTPResponse;
+
+let loopBackServer: HTTPBaseServer<any> | undefined;
+
+class LoopBackServer extends HTTPBaseServer<any> {
+  public readonly application: any;
+
+  /**
+   * Mounted on the application; see `endPointRegister` for why.
+   *
+   * Built from **LoopBack's own Express**, not the workspace's. LoopBack 4
+   * bundles Express 4 and this repository runs Express 5; a v5 router mounted
+   * inside a v4 application answers every request with a 500 from
+   * `res.header (... reading 'charsets')`, because the two disagree about the
+   * response prototype. Resolving Express through `@loopback/rest` is what keeps
+   * the router and the app on one version (JUM-704).
+   */
+  public readonly router: any = LoopBackServer.loopbackExpress().Router();
+
+  private mounted = false;
+
+  private static loopbackExpress(): any {
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    return require(require.resolve('express', { paths: [require.resolve('@loopback/rest')] }));
+  }
+
+  constructor() {
+    super();
+    // Lazy require keeps compilation independent from optional framework install.
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    const { RestApplication } = require('@loopback/rest');
+    this.application = new RestApplication({
+      rest: { port: _HTTP_PORT_ }
+    });
+    if (this.application.static) {
+      this.application.static('/OASdoc', 'apps/backend-template/OASdoc');
+      this.application.static('/AsyncAPIdoc', 'apps/backend-template/AsyncAPIdoc');
+    }
+    // On the router, not on the application: `app.get(key)` is LoopBack's
+    // context lookup, and calling it with a path binds nothing — it now throws
+    // rather than silently registering a route that never existed (JUM-704).
+    this.router.get('/docs/asyncapi', (_req: any, res: any) => {
+      res.statusCode = 302;
+      res.setHeader('location', '/AsyncAPIdoc');
+      res.end();
+    });
+  }
+
+  /**
+   * Writes through the native response, not Express 4's helpers (JUM-704).
+   *
+   * This repository overrides `send` to `^1.2.0` for Express 5. LoopBack bundles
+   * Express 4, whose `res.json` reaches into `send`'s `mime.charsets` — a shape
+   * that version no longer has — so every reply through `res.json` here answers
+   * `500 TypeError: undefined is not an object (evaluating 'mime.charsets')`.
+   * A security override for one major silently broke the other's consumers.
+   *
+   * Writing the status, the content type and the body directly avoids the
+   * broken helper without loosening the override. What the caller receives is
+   * the same JSON.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  private createResponseAdapter(response: any): any {
+    let statusCode = 200;
+
+    const write = (payload: any, contentType: string) => {
+      response.statusCode = statusCode;
+      response.setHeader('content-type', contentType);
+      response.end(typeof payload === 'string' ? payload : JSON.stringify(payload));
+      return payload;
+    };
+
+    const adapter = {
+      status(code: number) {
+        statusCode = code;
+        return adapter;
+      },
+      json(payload: any) {
+        return write(payload, 'application/json; charset=utf-8');
+      },
+      send(payload: any) {
+        if (typeof payload === 'string') return write(payload, 'text/plain; charset=utf-8');
+        return write(payload, 'application/json; charset=utf-8');
+      }
+    };
+
+    return adapter;
+  }
+
+  /**
+   * Routes, on an Express router LoopBack mounts (JUM-704).
+   *
+   * This used to call `this.application[method](path, handler)` inside a
+   * `try` that swallowed everything. On a LoopBack 4 `RestApplication`,
+   * `app.get` is the **context lookup** — `get(bindingKey)` — not a route
+   * registration, so every endpoint was quietly bound as a context read and
+   * **no route was ever served**. The swallowing catch is why it looked fine.
+   *
+   * `mountExpressRouter` is LoopBack's own supported seam for handlers that
+   * need `req`/`res`, which these do.
+   */
+  public endPointRegister(handlerFactory: IbaseHandler): void {
+    const method = handlerFactory.method.toLowerCase() as 'get' | 'post' | 'put' | 'patch' | 'delete';
+    this.router[method](handlerFactory.path, (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 || '');
+        return Promise.resolve(handlerFactory.handler(req, this.createResponseAdapter(res)))
+          .catch(() => {
+            if (!res.headersSent) res.status(500).json({ message: '' });
+          });
+      });
+    });
+  }
+
+  public async start(): Promise<void> {
+    this.mountRouter();
+    await this.application.start();
+  }
+
+  /** Idempotent: `start` and a test driving the handler both need it mounted. */
+  public mountRouter(): void {
+    if (this.mounted) return;
+    this.mounted = true;
+    this.application.mountExpressRouter('/', this.router);
+  }
+
+  public async stop(): Promise<void> {
+    if (this.application?.stop) {
+      await this.application.stop();
+    }
+  }
+
+  public static compile(): HTTPBaseServer<any> {
+    if (!loopBackServer) {
+      loopBackServer = new LoopBackServer();
+    }
+    return loopBackServer;
+  }
+}
+
+export { LoopBackServer };

package/templates/backend/src/interface/HTTP/adapters/loopback/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/loopback/loopback.ts

@@ -0,0 +1,55 @@
+/* eslint-disable quote-props */
+import { LoopBackServer } from '@src/interface/HTTP/adapters/loopback/LoopBackServer';
+import { infraHandlers } from '@src/interface/HTTP/adapters/loopback/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.loopback;
+const webServer = LoopBackServer.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/loopback/responses/sendErrorResponse.ts

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