@jumentix/cli-init 0.0.0

package/templates/backend/src/infra/cache/ICacheService.ts

@@ -0,0 +1,7 @@
+export interface ICacheService {
+  get<T = any>(key: string): Promise<T | undefined>;
+  set<T = any>(key: string, value: T, ttlInSeconds?: number): Promise<void>;
+  del(key: string): Promise<void>;
+  getVersion(namespace: string): Promise<number>;
+  bumpVersion(namespace: string): Promise<number>;
+}

package/templates/backend/src/infra/cache/index.ts

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

package/templates/backend/src/infra/context/Context.ts

@@ -0,0 +1,199 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const MAX_DURATION_SAMPLES = 256;
+const MAX_CORRELATION_IDS = 20;
+const MAX_RECENT_STORES = 20;
+const SENSITIVE_KEY = /password|token|secret|authorization|cookie/i;
+
+type MetricsState = {
+  active: number;
+  enteredTotal: number;
+  exitedTotal: number;
+  errorTotal: number;
+  durationSumMs: number;
+  durationCount: number;
+  durations: number[];
+  lastCorrelationIds: string[];
+  recentStores: Array<{ collectedAt: string; entries: Record<string, unknown> }>;
+};
+
+const state: MetricsState = {
+  active: 0,
+  enteredTotal: 0,
+  exitedTotal: 0,
+  errorTotal: 0,
+  durationSumMs: 0,
+  durationCount: 0,
+  durations: [],
+  lastCorrelationIds: [],
+  recentStores: []
+};
+
+const storage = new AsyncLocalStorage<Map<unknown, unknown>>();
+
+function percentile95(samples: number[]): number {
+  if (!samples.length) return 0;
+  const sorted = [...samples].sort((left, right) => left - right);
+  const index = Math.min(sorted.length - 1, Math.ceil(sorted.length * 0.95) - 1);
+  return sorted[Math.max(0, index)];
+}
+
+function serializeValue(value: unknown): unknown {
+  if (value === null || value === undefined) return value;
+  const type = typeof value;
+  if (type === 'string' || type === 'number' || type === 'boolean') return value;
+  if (type === 'bigint') return String(value);
+  if (Array.isArray(value)) return value.map(serializeValue);
+  if (value instanceof Map) {
+    const object: Record<string, unknown> = {};
+    value.forEach((entry, key) => {
+      object[String(key)] = serializeValue(entry);
+    });
+    return object;
+  }
+  if (type === 'object') {
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch (_error) {
+      return '[unserializable]';
+    }
+  }
+  return String(value);
+}
+
+export function redactSensitive(value: unknown, keyHint = ''): unknown {
+  if (keyHint && SENSITIVE_KEY.test(keyHint)) return '[REDACTED]';
+  if (Array.isArray(value)) return value.map((entry) => redactSensitive(entry));
+  if (value && typeof value === 'object') {
+    const object: Record<string, unknown> = {};
+    Object.entries(value as Record<string, unknown>).forEach(([key, entry]) => {
+      object[key] = redactSensitive(entry, key);
+    });
+    return object;
+  }
+  return value;
+}
+
+function snapshotStoreEntries(store: Map<unknown, unknown> | undefined): Record<string, unknown> {
+  const entries: Record<string, unknown> = {};
+  if (!store || typeof store.forEach !== 'function') return entries;
+  store.forEach((value, key) => {
+    const keyName = String(key);
+    entries[keyName] = redactSensitive(serializeValue(value), keyName);
+  });
+  return entries;
+}
+
+function pushRecentStore(store: Map<unknown, unknown> | undefined): void {
+  state.recentStores.push({
+    collectedAt: new Date().toISOString(),
+    entries: snapshotStoreEntries(store)
+  });
+  if (state.recentStores.length > MAX_RECENT_STORES) {
+    state.recentStores.shift();
+  }
+}
+
+function pushCorrelationId(store: Map<unknown, unknown> | undefined): void {
+  if (!store || typeof store.get !== 'function') return;
+  const value = store.get('correlationId');
+  if (typeof value !== 'string' || !value) return;
+  state.lastCorrelationIds.push(value);
+  if (state.lastCorrelationIds.length > MAX_CORRELATION_IDS) {
+    state.lastCorrelationIds.shift();
+  }
+}
+
+function recordDuration(durationMs: number): void {
+  if (!Number.isFinite(durationMs) || durationMs < 0) return;
+  state.durationSumMs += durationMs;
+  state.durationCount += 1;
+  state.durations.push(durationMs);
+  if (state.durations.length > MAX_DURATION_SAMPLES) {
+    state.durations.shift();
+  }
+}
+
+export function snapshotAsyncContextMetrics() {
+  const avgDurationMs = state.durationCount > 0
+    ? state.durationSumMs / state.durationCount
+    : 0;
+  const current = storage.getStore();
+  return {
+    active: state.active,
+    enteredTotal: state.enteredTotal,
+    exitedTotal: state.exitedTotal,
+    errorTotal: state.errorTotal,
+    avgDurationMs,
+    p95Ms: percentile95(state.durations),
+    lastCorrelationIds: [...state.lastCorrelationIds],
+    recentStores: state.recentStores.map((entry) => ({
+      collectedAt: entry.collectedAt,
+      entries: { ...entry.entries }
+    })),
+    currentStore: current ? snapshotStoreEntries(current) : null,
+    collectedAt: new Date().toISOString()
+  };
+}
+
+export function resetAsyncContextMetricsForTests(): void {
+  state.active = 0;
+  state.enteredTotal = 0;
+  state.exitedTotal = 0;
+  state.errorTotal = 0;
+  state.durationSumMs = 0;
+  state.durationCount = 0;
+  state.durations = [];
+  state.lastCorrelationIds = [];
+  state.recentStores = [];
+}
+
+export function runWithContext<T>(store: Map<unknown, unknown>, fn: () => T): T {
+  const startedAt = Date.now();
+  state.active += 1;
+  state.enteredTotal += 1;
+  pushCorrelationId(store);
+  pushRecentStore(store);
+  return storage.run(store, () => {
+    let finished = false;
+    const finish = (hadError: boolean) => {
+      if (finished) return;
+      finished = true;
+      if (hadError) state.errorTotal += 1;
+      state.active = Math.max(0, state.active - 1);
+      state.exitedTotal += 1;
+      recordDuration(Date.now() - startedAt);
+    };
+    try {
+      const result = fn();
+      if (result != null && typeof (result as unknown as { then?: unknown }).then === 'function') {
+        return (result as unknown as Promise<unknown>).then(
+          (value) => {
+            finish(false);
+            return value;
+          },
+          (error) => {
+            finish(true);
+            throw error;
+          }
+        ) as T;
+      }
+      finish(false);
+      return result;
+    } catch (error) {
+      finish(true);
+      throw error;
+    }
+  });
+}
+
+/**
+ * Drop-in facade over AsyncLocalStorage that instruments every `run`.
+ * Call sites keep using `Context.run` / `Context.getStore`.
+ */
+export const Context = {
+  run: runWithContext,
+  getStore: () => storage.getStore(),
+  enterWith: (store: Map<unknown, unknown>) => storage.enterWith(store),
+  disable: () => storage.disable()
+};

package/templates/backend/src/infra/events/InMemoryEventBus.ts

@@ -0,0 +1,24 @@
+import type { IEventBus, IIntegrationEvent } from '@src/modules/port';
+
+export class InMemoryEventBus implements IEventBus {
+  private listeners: Record<string, Array<(event: IIntegrationEvent) => Promise<void> | void>> = {};
+
+  public async publish(event: IIntegrationEvent): Promise<void> {
+    const eventListeners = this.listeners[event.name] || [];
+    await Promise.all(eventListeners.map(async (listener) => listener(event)));
+  }
+
+  public subscribe(
+    eventName: string,
+    listener: (event: IIntegrationEvent) => Promise<void> | void
+  ): void {
+    if (!this.listeners[eventName]) {
+      this.listeners[eventName] = [];
+    }
+    this.listeners[eventName].push(listener);
+  }
+
+  public static compile(): IEventBus {
+    return new InMemoryEventBus();
+  }
+}

package/templates/backend/src/infra/exceptions/BaseError.ts

@@ -0,0 +1,42 @@
+import { Context } from '@src/infra/context/Context';
+import type { ISerializedError } from '@src/infra/exceptions/ISerializedError';
+
+/**
+ * Base class for custom errors.
+ * @abstract
+ * @class BaseError
+ * @extends {Error}
+ */
+export abstract class BaseError extends Error {
+  abstract code: string;
+
+  abstract name: string;
+
+  public readonly correlationId: string;
+
+  /**
+   * @param {string} message
+   * @param {ObjectLiteral} [metadata={}]
+   */
+  constructor(
+    readonly message: string,
+    readonly cause?: Error,
+    readonly metadata?: unknown
+  ) {
+    super(message);
+    Error.captureStackTrace(this, this.constructor);
+    const store: Map<any, any> = Context.getStore() as Map<any, any>;
+    this.correlationId = store ? store.get('correlationId') : '';
+  }
+
+  toJSON(): ISerializedError {
+    return {
+      message: this.message,
+      code: this.code,
+      stack: this.stack,
+      correlationId: this.correlationId,
+      cause: JSON.stringify(this.cause),
+      metadata: this.metadata
+    };
+  }
+}

package/templates/backend/src/infra/exceptions/ComposeEventError.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+import { _EVENT_INVALID_MESSAGE_ } from '@src/config/constants';
+
+export class ComposeEventError extends BaseError {
+  readonly code = EErrorStringCodes.INVALID_INPUT;
+
+  readonly name = _EVENT_INVALID_MESSAGE_;
+}

package/templates/backend/src/infra/exceptions/ConflictError.ts

@@ -0,0 +1,10 @@
+/**
+ * Re-exported from `@jumentix/persistence-contracts` (JUM-601).
+ *
+ * It used to be defined here and imported by `external-store-proxy` through
+ * the `@src` alias — a workspace library reaching into this application's
+ * source. The definition moved to the contracts package the library can
+ * legitimately depend on; this file keeps the application's own import paths
+ * working, so nothing else in `apps/backend-template` changed.
+ */
+export { ConflictError } from '@jumentix/persistence-contracts';

package/templates/backend/src/infra/exceptions/DataBaseNotFoundError.ts

@@ -0,0 +1,10 @@
+/**
+ * Re-exported from `@jumentix/persistence-contracts` (JUM-601).
+ *
+ * It used to be defined here and imported by `external-store-proxy` through
+ * the `@src` alias — a workspace library reaching into this application's
+ * source. The definition moved to the contracts package the library can
+ * legitimately depend on; this file keeps the application's own import paths
+ * working, so nothing else in `apps/backend-template` changed.
+ */
+export { DataBaseNotFoundError } from '@jumentix/persistence-contracts';

package/templates/backend/src/infra/exceptions/DatabasePagingError.ts

@@ -0,0 +1,10 @@
+/**
+ * Re-exported from `@jumentix/persistence-contracts` (JUM-601).
+ *
+ * It used to be defined here and imported by `external-store-proxy` through
+ * the `@src` alias — a workspace library reaching into this application's
+ * source. The definition moved to the contracts package the library can
+ * legitimately depend on; this file keeps the application's own import paths
+ * working, so nothing else in `apps/backend-template` changed.
+ */
+export { DatabasePagingError } from '@jumentix/persistence-contracts';

package/templates/backend/src/infra/exceptions/DomainNotFoundError.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+import { _DOMAIN_NOT_FOUND_ERROR_NAME_ } from '@src/config/constants';
+
+export class DomainNotFoundError extends BaseError {
+  readonly code = EErrorStringCodes.NOT_FOUND;
+
+  readonly name = _DOMAIN_NOT_FOUND_ERROR_NAME_;
+}

package/templates/backend/src/infra/exceptions/DomainValidationError.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+import { _DOMAIN_VALIDATION_ERROR_NAME_ } from '@src/config/constants';
+
+export class DomainValidationError extends BaseError {
+  readonly code = EErrorStringCodes.INVALID_INPUT;
+
+  readonly name = _DOMAIN_VALIDATION_ERROR_NAME_;
+}

package/templates/backend/src/infra/exceptions/ForbiddenError.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+import { _FORBIDDEN_ERROR_NAME_ } from '@src/config/constants';
+
+export class ForbiddenError extends BaseError {
+  readonly code = EErrorStringCodes.FORBIDDEN;
+
+  readonly name = _FORBIDDEN_ERROR_NAME_;
+}

package/templates/backend/src/infra/exceptions/ISerializedError.ts

@@ -0,0 +1,8 @@
+export interface ISerializedError {
+  message: string;
+  code: string;
+  correlationId: string;
+  stack?: string;
+  cause?: string;
+  metadata?: unknown;
+}

package/templates/backend/src/infra/exceptions/InternalServerError.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+import { _INTERNAL_SERVER_ERROR_ } from '@src/config/constants';
+
+export class InternalServerError extends BaseError {
+  readonly code = EErrorStringCodes.INTERNAL_SERVER_ERROR;
+
+  readonly name = _INTERNAL_SERVER_ERROR_;
+}

package/templates/backend/src/infra/exceptions/NotFoundError.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+import { _NOT_FOUND_ERROR_NAME_ } from '@src/config/constants';
+
+export class NotFoundError extends BaseError {
+  readonly code = EErrorStringCodes.NOT_FOUND;
+
+  readonly name = _NOT_FOUND_ERROR_NAME_;
+}

package/templates/backend/src/infra/exceptions/NotImplemented.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+import { _INFRA_NOT_IMPLEMENTED_ } from '@src/config/constants';
+
+export class NotImplemented extends BaseError {
+  readonly code = EErrorStringCodes.NOT_IMPLEMENTED;
+
+  readonly name = _INFRA_NOT_IMPLEMENTED_;
+}

package/templates/backend/src/infra/exceptions/ResourceLockedError.ts

@@ -0,0 +1,10 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+
+import { _LOCKED_RESOURCE_ERROR_NAME_ } from '@src/config/constants';
+
+export class ResourceLockedError extends BaseError {
+  readonly code = EErrorStringCodes.RESOURCE_LOCKED;
+
+  readonly name = _LOCKED_RESOURCE_ERROR_NAME_;
+}

package/templates/backend/src/infra/exceptions/UnauthorizedError.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+import { _UNAUTHORIZED_ERROR_NAME_ } from '@src/config/constants';
+
+export class UnauthorizedError extends BaseError {
+  readonly code = EErrorStringCodes.UNAUTHORIZED;
+
+  readonly name = _UNAUTHORIZED_ERROR_NAME_;
+}

package/templates/backend/src/infra/exceptions/ValidationError.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '@src/infra/exceptions/BaseError';
+import { EErrorStringCodes } from '@src/infra/exceptions/error.codes';
+import { _VALIDATION_ERROR_NAME_ } from '@src/config/constants';
+
+export class ValidationError extends BaseError {
+  readonly code = EErrorStringCodes.INVALID_INPUT;
+
+  readonly name = _VALIDATION_ERROR_NAME_;
+}

package/templates/backend/src/infra/exceptions/error.codes.ts

@@ -0,0 +1,23 @@
+// eslint-disable-next-line no-shadow
+export enum EErrorStringCodes {
+  INVALID_INPUT = 'GENERIC.INVALID_INPUT',
+  NOT_FOUND = 'GENERIC.NOT_FOUND',
+  NOT_IMPLEMENTED = 'GENERIC.NOT_IMPLEMENTED',
+  UNAUTHORIZED = 'GENERIC.UNAUTHORIZED',
+  FORBIDDEN = 'GENERIC.FORBIDDEN',
+  CONFLICT = 'GENERIC.CONFLICT',
+  RESOURCE_LOCKED = 'GENERIC.RESOURCE_LOCKED',
+  INTERNAL_SERVER_ERROR = 'GENERIC.INTERNAL_SERVER_ERROR',
+}
+
+// eslint-disable-next-line no-shadow
+export enum EErrorNumberCodes {
+  'GENERIC.INVALID_INPUT' = 400,
+  'GENERIC.NOT_FOUND' = 404,
+  'GENERIC.NOT_IMPLEMENTED' = 501,
+  'GENERIC.UNAUTHORIZED' = 401,
+  'GENERIC.FORBIDDEN' = 403,
+  'GENERIC.CONFLICT' = 409,
+  'GENERIC.RESOURCE_LOCKED' = 423,
+  'GENERIC.INTERNAL_SERVER_ERROR' = 500,
+}

package/templates/backend/src/infra/exceptions/index.ts

@@ -0,0 +1,20 @@
+// Side-effect import: registers this application's correlation id source
+// with the store errors that now live in @jumentix/persistence-contracts
+// (JUM-601). Must run before any of them is constructed.
+import './registerPersistenceCorrelation';
+
+export * from './BaseError';
+export * from './error.codes';
+export * from './ComposeEventError';
+export * from './ConflictError';
+export * from './DataBaseNotFoundError';
+export * from './DatabasePagingError';
+export * from './DomainNotFoundError';
+export * from './DomainValidationError';
+export * from './ForbiddenError';
+export * from './InternalServerError';
+export * from './NotFoundError';
+export * from './ResourceLockedError';
+export * from './UnauthorizedError';
+export * from './ValidationError';
+export * from './ISerializedError';

package/templates/backend/src/infra/exceptions/registerPersistenceCorrelation.ts

@@ -0,0 +1,24 @@
+import { setCorrelationIdResolver } from '@jumentix/persistence-contracts';
+import { Context } from '@src/infra/context/Context';
+
+/**
+ * Gives the store errors this application's correlation id (JUM-601).
+ *
+ * `ConflictError`, `DataBaseNotFoundError` and `DatabasePagingError` moved to
+ * `@jumentix/persistence-contracts` so `external-store-proxy` would stop
+ * importing this application's source. They are thrown twenty-eight times
+ * inside that library, and `shared/utils.ts` puts `error.correlationId` into
+ * every error response — so without this the id would silently vanish from
+ * every database error.
+ *
+ * The dependency points the right way now: the library asks a function, and
+ * this file is the only place that knows the function reads an async-local
+ * `Context`.
+ *
+ * Imported for its side effect by the exceptions barrel, so anything that can
+ * throw one of these errors has already registered the resolver.
+ */
+setCorrelationIdResolver(() => {
+  const store: Map<unknown, unknown> = Context.getStore() as Map<unknown, unknown>;
+  return store ? String(store.get('correlationId') ?? '') : '';
+});

package/templates/backend/src/infra/jwt/IJwtService.ts

@@ -0,0 +1,6 @@
+import type { ITokenObject } from '../../modules/Users/service/ports/ITokenObject';
+
+export interface IJwtService {
+  decodeToken(token: string): ITokenObject | null;
+  generateToken(user: Record<any, any>): string;
+}

package/templates/backend/src/infra/jwt/JwtService.ts

@@ -0,0 +1,79 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as jwt from 'jsonwebtoken';
+import { randomUUID } from 'node:crypto';
+
+import type { IJwtService } from '@src/infra/jwt/IJwtService';
+import { _JWT_TOKEN_SECRET_KEY_, _JWT_TOKEN_EXPIRES_IN_ } from '@src/config/jwt';
+import type { ITokenObject } from '@src/modules/Users/service/ports/ITokenObject';
+import { NotImplemented } from '@src/infra/exceptions/NotImplemented';
+import { readProductEnv } from '@src/interface/runtime/RuntimeEnvironment';
+
+let jwtService: any;
+
+export class JwtService implements IJwtService {
+  private secret: string;
+
+  public expiresIn: number;
+
+  constructor(secret = _JWT_TOKEN_SECRET_KEY_) {
+    if (!secret) throw new NotImplemented('JWT secret key is not defined');
+    this.secret = secret;
+    this.expiresIn = _JWT_TOKEN_EXPIRES_IN_;
+  }
+
+  public decodeToken(token: string): ITokenObject | null {
+    // eslint-disable-next-line no-console
+    // console.log('+++++++  decodeToken() SECRET', this.secret);
+    let valid = null;
+    try {
+      const verifyOptions: jwt.VerifyOptions = {};
+      const jwtIssuer = readProductEnv(process.env, 'JUMENTIX_JWT_ISSUER');
+      if (jwtIssuer) {
+        verifyOptions.issuer = jwtIssuer;
+      }
+      const jwtAudience = readProductEnv(process.env, 'JUMENTIX_JWT_AUDIENCE');
+      if (jwtAudience) {
+        verifyOptions.audience = jwtAudience;
+      }
+      valid = jwt.verify(token, this.secret, verifyOptions) as ITokenObject;
+    } catch (error) {
+      valid = null;
+    }
+    return valid;
+  }
+
+  public generateToken(data: Record<any, any>): string {
+    const {
+      id, username, firstName, avatar, organization, roles
+    } = data;
+    const signOptions: jwt.SignOptions = { expiresIn: this.expiresIn };
+    const jwtIssuer = readProductEnv(process.env, 'JUMENTIX_JWT_ISSUER');
+    if (jwtIssuer) {
+      signOptions.issuer = jwtIssuer;
+    }
+    const jwtAudience = readProductEnv(process.env, 'JUMENTIX_JWT_AUDIENCE');
+    if (jwtAudience) {
+      signOptions.audience = jwtAudience;
+    }
+    const token = jwt.sign(
+      {
+        jti: `${id || username || 'anonymous'}:${randomUUID()}`,
+        id,
+        username,
+        firstName,
+        avatar,
+        organization,
+        roles
+      },
+      this.secret,
+      signOptions
+    );
+    return token;
+  }
+
+  public static compile() {
+    if (jwtService) return jwtService;
+    jwtService = new JwtService();
+    return jwtService;
+  }
+}

package/templates/backend/src/infra/messages/InMemoryMessageMediator.ts

@@ -0,0 +1,4 @@
+import { InMemoryMessageMediatorAdapter } from '@src/infra/messages/adapters/InMemoryMessageMediatorAdapter';
+
+// Backward-compatible export name while keeping adapter semantics explicit.
+export class InMemoryMessageMediator extends InMemoryMessageMediatorAdapter {}

package/templates/backend/src/infra/messages/adapters/BullMqMessageMediatorAdapter.ts

@@ -0,0 +1 @@
+export { BullMqMessageMediatorAdapter } from '@jumentix/message-mediator';

package/templates/backend/src/infra/messages/adapters/InMemoryMessageMediatorAdapter.ts

@@ -0,0 +1 @@
+export { InMemoryMessageMediatorAdapter } from '@jumentix/message-mediator';

package/templates/backend/src/infra/messages/adapters/RabbitMqMessageMediatorAdapter.ts

@@ -0,0 +1 @@
+export { RabbitMqMessageMediatorAdapter } from '@jumentix/message-mediator';

package/templates/backend/src/infra/messages/compileMessageMediator.ts

@@ -0,0 +1 @@
+export { compileMessageMediator } from '@jumentix/message-mediator';

package/templates/backend/src/infra/messages/repositories/QueueRequestResponseRepository.ts

@@ -0,0 +1,39 @@
+import type {
+  IMessage,
+  IMessageMediator,
+  IMessageRequestOptions,
+  IMessageResponse
+} from '@src/modules/port';
+
+export interface IQueueRequestResponseRepository {
+  sendRequest<TPayload = any, TResult = any>(
+    contract: string,
+    payload: TPayload,
+    options?: IMessageRequestOptions
+  ): Promise<IMessageResponse<TResult>>;
+}
+
+export class QueueRequestResponseRepository implements IQueueRequestResponseRepository {
+  private readonly mediator: IMessageMediator;
+
+  constructor(mediator: IMessageMediator) {
+    this.mediator = mediator;
+  }
+
+  public async sendRequest<TPayload = any, TResult = any>(
+    contract: string,
+    payload: TPayload,
+    options?: IMessageRequestOptions
+  ): Promise<IMessageResponse<TResult>> {
+    const message: IMessage<TPayload> = {
+      contract,
+      version: '1.0.0',
+      payload,
+      metadata: {
+        traceId: `queue-rr-${Date.now()}`
+      }
+    };
+
+    return this.mediator.request<TPayload, TResult>(message, options);
+  }
+}

package/templates/backend/src/infra/messages/repositories/index.ts

@@ -0,0 +1 @@
+export * from '@src/infra/messages/repositories/QueueRequestResponseRepository';

package/templates/backend/src/infra/mutex/adapter/MutexService.ts

@@ -0,0 +1 @@
+export { MutexService } from '@jumentix/mutex-service';

package/templates/backend/src/infra/mutex/port/IMutexService.ts

@@ -0,0 +1 @@
+export type { IMutexService } from '@jumentix/mutex-service';