@jumentix/cli-init 0.0.0

package/templates/backend/src/interface/WebSocket/WebSocketAPI.ts

@@ -0,0 +1,189 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import http from 'http';
+import { Server, Socket } from 'socket.io';
+import { randomUUID } from 'crypto';
+
+import { _HTTP_PORT_ } from '@src/config/constants';
+import type {
+  IAsyncOperationRequest,
+  IAsyncOperationResponse,
+  IRealtimeAPIFactory
+} from '@src/interface/Async/RealtimeAPIBase';
+import {
+  RealtimeAPIBase
+} from '@src/interface/Async/RealtimeAPIBase';
+
+export interface IWebSocketAPIFactory extends IRealtimeAPIFactory {
+  host?: string;
+  port?: number;
+  path?: string;
+  configureSocketIo?: (io: Server) => Promise<void> | void;
+  cleanupSocketIo?: () => Promise<void> | void;
+}
+
+export class WebSocketAPI extends RealtimeAPIBase {
+  private readonly host: string;
+
+  private readonly port: number;
+
+  private readonly path: string;
+
+  private httpServer?: http.Server;
+
+  private io?: Server;
+
+  private readonly configureSocketIo?: (io: Server) => Promise<void> | void;
+
+  private readonly cleanupSocketIo?: () => Promise<void> | void;
+
+  constructor(config: IWebSocketAPIFactory) {
+    super({
+      ...config,
+      interfaceType: 'websocketapi',
+      frameworkName: 'socket-io'
+    });
+    this.host = config.host || '0.0.0.0';
+    this.port = config.port || Number(process.env.JUMENTIX_WEBSOCKET_PORT || (_HTTP_PORT_ + 1));
+    this.path = config.path || '/ws';
+    this.configureSocketIo = config.configureSocketIo;
+    this.cleanupSocketIo = config.cleanupSocketIo;
+  }
+
+  private async handleOperationRequest(
+    request: IAsyncOperationRequest
+  ): Promise<IAsyncOperationResponse> {
+    return this.executeOperation(request);
+  }
+
+  private bindSocket(socket: Socket): void {
+    socket.on(
+      'api:request',
+      async (
+        request: IAsyncOperationRequest,
+        ack?: (response: IAsyncOperationResponse) => void
+      ) => {
+        const requestId = request?.metadata?.requestId || randomUUID();
+        const response = await this.handleOperationRequest({
+          ...request,
+          metadata: {
+            ...(request.metadata || {}),
+            requestId,
+            clientId: socket.id
+          }
+        });
+        const responseChannel = response?.metadata?.channel || `api:${response.operationId}:response`;
+        const responsePayload = {
+          ...response,
+          metadata: {
+            ...(response.metadata || {}),
+            requestId,
+            clientId: socket.id,
+            channel: responseChannel
+          }
+        };
+        socket.emit('api:response', responsePayload);
+        socket.emit(responseChannel, responsePayload);
+        if (typeof ack === 'function') {
+          ack(responsePayload);
+        }
+      }
+    );
+
+    for (const operationId of this.listOperationIds()) {
+      socket.on(
+        `api:${operationId}:request`,
+        async (
+          request: Omit<IAsyncOperationRequest, 'operationId'>,
+          ack?: (response: IAsyncOperationResponse) => void
+        ) => {
+          const requestId = request?.metadata?.requestId || randomUUID();
+          const response = await this.handleOperationRequest({
+            ...request,
+            metadata: {
+              ...(request.metadata || {}),
+              requestId,
+              clientId: socket.id
+            },
+            operationId
+          });
+          const responseChannel = response?.metadata?.channel || `api:${operationId}:response`;
+          const responsePayload = {
+            ...response,
+            metadata: {
+              ...(response.metadata || {}),
+              requestId,
+              clientId: socket.id,
+              channel: responseChannel
+            }
+          };
+          socket.emit(responseChannel, responsePayload);
+          if (typeof ack === 'function') {
+            ack(responsePayload);
+          }
+        }
+      );
+    }
+  }
+
+  public async start(): Promise<void> {
+    if (this.started) return;
+
+    if (this.keyValueStorageClient) {
+      await this.keyValueStorageClient.connect();
+    }
+    await this.databaseClient.connect();
+
+    this.httpServer = http.createServer();
+    this.io = new Server(this.httpServer, {
+      path: this.path,
+      transports: ['websocket'],
+      cors: {
+        origin: '*'
+      }
+    });
+    if (this.configureSocketIo) {
+      await this.configureSocketIo(this.io);
+    }
+
+    this.io.on('connection', (socket) => {
+      this.bindSocket(socket);
+    });
+
+    await new Promise<void>((resolve) => {
+      this.httpServer!.listen(this.port, this.host, () => {
+        resolve();
+      });
+    });
+
+    this.started = true;
+  }
+
+  public async stop(): Promise<void> {
+    if (!this.started) return;
+
+    if (this.io) {
+      this.io.close();
+      this.io = undefined;
+    }
+
+    if (this.cleanupSocketIo) {
+      await this.cleanupSocketIo();
+    }
+
+    if (this.httpServer) {
+      await new Promise<void>((resolve) => {
+        this.httpServer!.close(() => resolve());
+      });
+      this.httpServer = undefined;
+    }
+
+    if (this.keyValueStorageClient) {
+      await this.keyValueStorageClient.disconnect();
+    }
+    await this.databaseClient.disconnect();
+    this.started = false;
+  }
+}
+
+export default WebSocketAPI;

package/templates/backend/src/interface/WebSocket/adapters/socket-io/clusterAdapter.ts

@@ -0,0 +1,35 @@
+import cluster from 'cluster';
+import os from 'os';
+import { createAdapter, setupPrimary } from '@socket.io/cluster-adapter';
+import { Server } from 'socket.io';
+
+export interface IClusterSocketIoAdapter {
+  configure: (io: Server) => Promise<void>;
+  cleanup: () => Promise<void>;
+}
+
+export const isClusterSocketIoEnabled = (
+  env: NodeJS.ProcessEnv = process.env
+): boolean => env.JUMENTIX_WEBSOCKET_SOCKETIO_ADAPTER === 'cluster';
+
+export const resolveWebSocketClusterWorkers = (
+  env: NodeJS.ProcessEnv = process.env
+): number => {
+  const parsed = Number(env.JUMENTIX_WEBSOCKET_CLUSTER_WORKERS || '');
+  if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  return Math.max(1, os.cpus().length);
+};
+
+export const setupSocketIoClusterPrimary = (): void => {
+  setupPrimary();
+  cluster.setupPrimary({
+    serialization: 'advanced'
+  });
+};
+
+export const createClusterSocketIoAdapter = (): IClusterSocketIoAdapter => ({
+  configure: async (io: Server): Promise<void> => {
+    io.adapter(createAdapter());
+  },
+  cleanup: async (): Promise<void> => Promise.resolve()
+});

package/templates/backend/src/interface/WebSocket/adapters/socket-io/redisStreamsAdapter.ts

@@ -0,0 +1,49 @@
+import { createClient } from 'redis';
+import { createAdapter } from '@socket.io/redis-streams-adapter';
+import { Server } from 'socket.io';
+
+export interface IRedisStreamsSocketIoAdapter {
+  configure: (io: Server) => Promise<void>;
+  cleanup: () => Promise<void>;
+}
+
+export const isRedisStreamsSocketIoEnabled = (
+  env: NodeJS.ProcessEnv = process.env
+): boolean => env.JUMENTIX_WEBSOCKET_SOCKETIO_ADAPTER === 'redis-streams';
+
+export const buildRedisConnectionUrl = (
+  env: NodeJS.ProcessEnv = process.env
+): string => {
+  if (env.JUMENTIX_WEBSOCKET_REDIS_URL) return env.JUMENTIX_WEBSOCKET_REDIS_URL;
+  if (env.JUMENTIX_REDIS_URL) return env.JUMENTIX_REDIS_URL;
+
+  const host = env.JUMENTIX_REDIS_HOST || '127.0.0.1';
+  const port = env.JUMENTIX_REDIS_PORT || '6379';
+  const db = env.JUMENTIX_REDIS_DATABASE || '0';
+  const password = env.JUMENTIX_REDIS_PASSWORD;
+  const authPrefix = password ? `:${encodeURIComponent(password)}@` : '';
+
+  return `redis://${authPrefix}${host}:${port}/${db}`;
+};
+
+export const createRedisStreamsSocketIoAdapter = (
+  env: NodeJS.ProcessEnv = process.env
+): IRedisStreamsSocketIoAdapter => {
+  const client = createClient({
+    url: buildRedisConnectionUrl(env)
+  });
+
+  return {
+    configure: async (io: Server): Promise<void> => {
+      if (!client.isOpen) {
+        await client.connect();
+      }
+      io.adapter(createAdapter(client));
+    },
+    cleanup: async (): Promise<void> => {
+      if (client.isOpen) {
+        await client.quit();
+      }
+    }
+  };
+};

package/templates/backend/src/interface/WebSocket/adapters/socket-io/socket-io.ts

@@ -0,0 +1,93 @@
+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 { MutexService } from '@src/infra/mutex/adapter/MutexService';
+import { compileMessageMediator } from '@src/infra/messages/compileMessageMediator';
+import { composeUsersAuthServices } from '@src/modules/Users';
+import { WebSocketAPI } from '@src/interface/WebSocket/WebSocketAPI';
+import { ExpressServer } from '@src/interface/HTTP/adapters/express/ExpressServer';
+import { infraHandlers } from '@src/interface/HTTP/adapters/express/handlers/infraHandlers';
+import { EHTTPFrameworks } from '@src/interface/HTTP/ports';
+import { RestAPI } from '@src/interface/HTTP/RestAPI';
+import {
+  createRedisStreamsSocketIoAdapter,
+  isRedisStreamsSocketIoEnabled
+} from '@src/interface/WebSocket/adapters/socket-io/redisStreamsAdapter';
+import {
+  createClusterSocketIoAdapter,
+  isClusterSocketIoEnabled
+} from '@src/interface/WebSocket/adapters/socket-io/clusterAdapter';
+import { compileAdapterRuntime } from '@jumentix/adapter-runtime-bootstrap';
+
+export function shouldStartFallbackRestApi(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.JUMENTIX_DISABLE_FALLBACK_REST !== 'true';
+}
+
+export async function startWebSocketAdapter(): Promise<void> {
+  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
+  });
+
+  let socketIoAdapter:
+    | ReturnType<typeof createClusterSocketIoAdapter>
+    | ReturnType<typeof createRedisStreamsSocketIoAdapter>
+    | undefined;
+  if (isClusterSocketIoEnabled()) {
+    socketIoAdapter = createClusterSocketIoAdapter();
+  } else if (isRedisStreamsSocketIoEnabled()) {
+    socketIoAdapter = createRedisStreamsSocketIoAdapter();
+  }
+
+  const API = new WebSocketAPI({
+    databaseClient,
+    authService,
+    passwordCryptoService,
+    keyValueStorageClient,
+    mutexService,
+    eventBus: messageMediator,
+    messageMediator,
+    configureSocketIo: socketIoAdapter?.configure,
+    cleanupSocketIo: socketIoAdapter?.cleanup
+  });
+
+  let fallbackRestAPI: RestAPI<any> | undefined;
+  if (shouldStartFallbackRestApi()) {
+    process.env.JUMENTIX_HTTP_PORT = process.env.JUMENTIX_HTTP_FALLBACK_PORT || '3000';
+    fallbackRestAPI = new RestAPI({
+      databaseClient,
+      webServer: ExpressServer.compile(),
+      infraHandlers,
+      serverType: EHTTPFrameworks.express,
+      authService,
+      passwordCryptoService,
+      keyValueStorageClient,
+      mutexService,
+      eventBus: messageMediator,
+      messageMediator
+    });
+  }
+
+  if (fallbackRestAPI) {
+    await fallbackRestAPI.start();
+  }
+  await API.start();
+}
+
+/* istanbul ignore if */
+if (require.main === module) {
+  startWebSocketAdapter();
+}

package/templates/backend/src/interface/WebSocket/adapters/start-websocket-api.ts

@@ -0,0 +1,34 @@
+import { shouldStartRealtimeApi } from '@src/interface/runtime/RuntimeEnvironment';
+import { startWebSocketAdapter } from '@src/interface/WebSocket/adapters/socket-io/socket-io';
+import cluster from 'cluster';
+import {
+  isClusterSocketIoEnabled,
+  resolveWebSocketClusterWorkers,
+  setupSocketIoClusterPrimary
+} from '@src/interface/WebSocket/adapters/socket-io/clusterAdapter';
+
+export async function startWebSocketApiAdapter(
+  env: NodeJS.ProcessEnv = process.env
+): Promise<boolean> {
+  if (!shouldStartRealtimeApi('websocket', env)) return false;
+  if (isClusterSocketIoEnabled(env)) {
+    if (cluster.isPrimary) {
+      setupSocketIoClusterPrimary();
+      const totalWorkers = resolveWebSocketClusterWorkers(env);
+      for (let i = 0; i < totalWorkers; i += 1) {
+        cluster.fork();
+      }
+      cluster.on('exit', () => {
+        cluster.fork();
+      });
+      return true;
+    }
+  }
+  await startWebSocketAdapter();
+  return true;
+}
+
+/* istanbul ignore if */
+if (require.main === module) {
+  startWebSocketApiAdapter();
+}

package/templates/backend/src/interface/gRPC/adapters/grpc/grpc.ts

@@ -0,0 +1,73 @@
+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 { MutexService } from '@src/infra/mutex/adapter/MutexService';
+import { compileMessageMediator } from '@src/infra/messages/compileMessageMediator';
+import { composeUsersAuthServices } from '@src/modules/Users';
+import { GrpcAPI } from '@src/interface/gRPC/gRPCAPI';
+import { ExpressServer } from '@src/interface/HTTP/adapters/express/ExpressServer';
+import { infraHandlers } from '@src/interface/HTTP/adapters/express/handlers/infraHandlers';
+import { EHTTPFrameworks } from '@src/interface/HTTP/ports';
+import { RestAPI } from '@src/interface/HTTP/RestAPI';
+import { compileAdapterRuntime } from '@jumentix/adapter-runtime-bootstrap';
+
+export function shouldStartFallbackRestApi(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.JUMENTIX_DISABLE_FALLBACK_REST !== 'true';
+}
+
+export async function startGrpcAdapter(): Promise<void> {
+  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 GrpcAPI({
+    databaseClient,
+    authService,
+    passwordCryptoService,
+    keyValueStorageClient,
+    mutexService,
+    eventBus: messageMediator,
+    messageMediator
+  });
+
+  let fallbackRestAPI: RestAPI<any> | undefined;
+  if (shouldStartFallbackRestApi()) {
+    process.env.JUMENTIX_HTTP_PORT = process.env.JUMENTIX_HTTP_FALLBACK_PORT || '3000';
+    fallbackRestAPI = new RestAPI({
+      databaseClient,
+      webServer: ExpressServer.compile(),
+      infraHandlers,
+      serverType: EHTTPFrameworks.express,
+      authService,
+      passwordCryptoService,
+      keyValueStorageClient,
+      mutexService,
+      eventBus: messageMediator,
+      messageMediator
+    });
+  }
+
+  if (fallbackRestAPI) {
+    await fallbackRestAPI.start();
+  }
+  await API.start();
+}
+
+/* istanbul ignore if */
+if (require.main === module) {
+  startGrpcAdapter();
+}

package/templates/backend/src/interface/gRPC/adapters/start-grpc-api.ts

@@ -0,0 +1,13 @@
+import { shouldStartRealtimeApi } from '@src/interface/runtime/RuntimeEnvironment';
+import { startGrpcAdapter } from '@src/interface/gRPC/adapters/grpc/grpc';
+
+export async function startGrpcApiAdapter(env: NodeJS.ProcessEnv = process.env): Promise<boolean> {
+  if (!shouldStartRealtimeApi('grpc', env)) return false;
+  await startGrpcAdapter();
+  return true;
+}
+
+/* istanbul ignore if */
+if (require.main === module) {
+  startGrpcApiAdapter();
+}

package/templates/backend/src/interface/gRPC/gRPCAPI.ts

@@ -0,0 +1,211 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as grpc from '@grpc/grpc-js';
+import * as protoLoader from '@grpc/proto-loader';
+
+import { _HTTP_PORT_ } from '@src/config/constants';
+import type {
+  IAsyncOperationRequest,
+  IAsyncOperationResponse,
+  IRealtimeAPIFactory
+} from '@src/interface/Async/RealtimeAPIBase';
+import {
+  RealtimeAPIBase
+} from '@src/interface/Async/RealtimeAPIBase';
+import { resolveGrpcProtoPath } from '@src/interface/gRPC/resolveGrpcProtoPath';
+
+/**
+ * Unwrap a CommonJS interop namespace.
+ *
+ * `@grpc/grpc-js` and `@grpc/proto-loader` are CommonJS. Depending on how the
+ * consumer's bundler or runtime performs interop, `import * as x` yields either
+ * the module's exports directly or a namespace whose `default` holds them. Both
+ * shapes appear in practice across the runtimes this template supports, so the
+ * call sites have to cope with either.
+ *
+ * Exported so the fallback can be asserted directly. It was previously reached
+ * by assigning `undefined` over the live module namespace, which Bun rejects —
+ * an ES module namespace is read-only there — so that test ran only under Jest
+ * (JUM-583).
+ */
+export function interopDefault<T>(moduleNamespace: T): T {
+  return ((moduleNamespace as { default?: T }).default ?? moduleNamespace) as T;
+}
+
+export interface IGrpcAPIFactory extends IRealtimeAPIFactory {
+  host?: string;
+  port?: number;
+  protoFilePath?: string;
+}
+
+interface IGrpcAsyncApiRequest {
+  version?: string;
+  operationId: string;
+  requestId?: string;
+  clientId?: string;
+  authorization?: string;
+  inputJson?: string;
+  paramsJson?: string;
+  queryStringJson?: string;
+  metadataJson?: string;
+}
+
+interface IGrpcAsyncApiResponse {
+  ok: boolean;
+  version?: string;
+  operationId: string;
+  requestId?: string;
+  clientId?: string;
+  metadataJson?: string;
+  resultJson?: string;
+  errorName?: string;
+  errorMessage?: string;
+}
+
+export class GrpcAPI extends RealtimeAPIBase {
+  private readonly host: string;
+
+  private readonly port: number;
+
+  private readonly protoFilePath: string;
+
+  private server?: grpc.Server;
+
+  constructor(config: IGrpcAPIFactory) {
+    super({
+      ...config,
+      interfaceType: 'grpcapi',
+      frameworkName: 'grpc'
+    });
+    this.host = config.host || '0.0.0.0';
+    this.port = config.port || Number(process.env.JUMENTIX_GRPC_PORT || (_HTTP_PORT_ + 2));
+    this.protoFilePath = resolveGrpcProtoPath(config.protoFilePath);
+  }
+
+  private static parseJson(raw?: string): Record<string, any> {
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch (error) {
+      return {};
+    }
+  }
+
+  private static toGrpcResponse(response: IAsyncOperationResponse): IGrpcAsyncApiResponse {
+    const requestId = response.metadata?.requestId;
+    const clientId = response.metadata?.clientId;
+    return {
+      ok: response.ok,
+      version: response.version,
+      operationId: response.operationId,
+      requestId,
+      clientId,
+      metadataJson: response.metadata ? JSON.stringify(response.metadata) : undefined,
+      resultJson: response.result === undefined ? undefined : JSON.stringify(response.result),
+      errorName: response.error?.name,
+      errorMessage: response.error?.message
+    };
+  }
+
+  private static toDomainRequest(request: IGrpcAsyncApiRequest): IAsyncOperationRequest {
+    const metadataFromJson = GrpcAPI.parseJson(request.metadataJson);
+    return {
+      version: request.version,
+      operationId: request.operationId,
+      authorization: request.authorization || '',
+      input: GrpcAPI.parseJson(request.inputJson),
+      params: GrpcAPI.parseJson(request.paramsJson),
+      queryString: GrpcAPI.parseJson(request.queryStringJson),
+      metadata: {
+        ...metadataFromJson,
+        requestId: request.requestId || metadataFromJson.requestId,
+        clientId: request.clientId || metadataFromJson.clientId
+      }
+    };
+  }
+
+  private loadProtoService(): any {
+    const protoLoaderLib: any = interopDefault(protoLoader);
+    const grpcLib: any = interopDefault(grpc);
+    const packageDefinition = protoLoaderLib.loadSync(this.protoFilePath, {
+      longs: String,
+      enums: String,
+      defaults: true,
+      oneofs: true
+    });
+    const grpcObject = grpcLib.loadPackageDefinition(packageDefinition) as any;
+    return grpcObject.realtime;
+  }
+
+  public async start(): Promise<void> {
+    if (this.started) return;
+    if (this.keyValueStorageClient) {
+      await this.keyValueStorageClient.connect();
+    }
+    await this.databaseClient.connect();
+
+    const realtimePackage = this.loadProtoService();
+    const grpcLib: any = interopDefault(grpc);
+    this.server = new grpcLib.Server();
+    this.server!.addService(realtimePackage.AsyncApiGateway.service, {
+      request: async (
+        call: grpc.ServerUnaryCall<IGrpcAsyncApiRequest, IGrpcAsyncApiResponse>,
+        callback: grpc.sendUnaryData<IGrpcAsyncApiResponse>
+      ) => {
+        const response = await this.executeOperation(
+          GrpcAPI.toDomainRequest(call.request)
+        );
+        callback(null, GrpcAPI.toGrpcResponse(response));
+      },
+      exchange: (
+        stream: grpc.ServerDuplexStream<IGrpcAsyncApiRequest, IGrpcAsyncApiResponse>
+      ) => {
+        stream.on('data', async (request: IGrpcAsyncApiRequest) => {
+          const response = await this.executeOperation(
+            GrpcAPI.toDomainRequest(request)
+          );
+          stream.write(GrpcAPI.toGrpcResponse(response));
+        });
+        stream.on('end', () => {
+          stream.end();
+        });
+      }
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      this.server!.bindAsync(
+        `${this.host}:${this.port}`,
+        grpcLib.ServerCredentials.createInsecure(),
+        (error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          this.server!.start();
+          resolve();
+        }
+      );
+    });
+
+    this.started = true;
+  }
+
+  public async stop(): Promise<void> {
+    if (!this.started) return;
+
+    if (this.server) {
+      await new Promise<void>((resolve) => {
+        this.server!.tryShutdown(() => resolve());
+      });
+      this.server = undefined;
+    }
+
+    if (this.keyValueStorageClient) {
+      await this.keyValueStorageClient.disconnect();
+    }
+    await this.databaseClient.disconnect();
+    this.started = false;
+  }
+}
+
+export default GrpcAPI;