@quanticjs/core 1.1.1 → 2.1.0

package/src/filters/GlobalExceptionFilter.ts

@@ -1,125 +0,0 @@
-import {
-  ExceptionFilter,
-  Catch,
-  ArgumentsHost,
-  HttpException,
-  Logger,
-} from '@nestjs/common';
-import { ThrottlerException } from '@nestjs/throttler';
-import { Request, Response } from 'express';
-import { correlationStore } from '../middleware/CorrelationStore';
-
-interface ProblemDetails {
-  type: string;
-  title: string;
-  status: number;
-  detail?: string;
-  instance?: string;
-  correlationId?: string;
-  retryAfter?: number;
-  errors?: Array<{ field?: string; message: string }>;
-  stack?: string;
-}
-
-/**
- * Global exception filter for framework-level exceptions (guards, pipes, throttler).
- * Result<T> errors are handled by ResultInterceptor — they never reach this filter.
- */
-@Catch()
-export class GlobalExceptionFilter implements ExceptionFilter {
-  private readonly logger = new Logger(GlobalExceptionFilter.name);
-  private readonly isProduction = process.env.NODE_ENV === 'production';
-
-  catch(exception: unknown, host: ArgumentsHost): void {
-    const ctx = host.switchToHttp();
-    const request = ctx.getRequest<Request>();
-    const response = ctx.getResponse<Response>();
-    const correlationId = correlationStore.getStore()?.correlationId;
-
-    if (response.headersSent) return;
-
-    if (correlationId) {
-      response.setHeader('X-Correlation-ID', correlationId);
-    }
-
-    const problem = this.toProblemDetails(exception, correlationId, request.originalUrl);
-
-    if (problem.retryAfter) {
-      response.setHeader('Retry-After', String(problem.retryAfter));
-    }
-
-    this.logger.error({
-      msg: `${problem.status} ${problem.title}`,
-      correlationId,
-      status: problem.status,
-      detail: problem.detail,
-    });
-
-    response
-      .status(problem.status)
-      .setHeader('Content-Type', 'application/problem+json')
-      .json(problem);
-  }
-
-  private toProblemDetails(
-    exception: unknown,
-    correlationId?: string,
-    instance?: string,
-  ): ProblemDetails {
-    // ThrottlerException → 429
-    if (exception instanceof ThrottlerException) {
-      return {
-        type: 'https://arex.dev/errors/RATE_LIMITED',
-        title: 'Too Many Requests',
-        status: 429,
-        detail: 'Rate limit exceeded. Please retry later.',
-        instance,
-        correlationId,
-        retryAfter: 60,
-      };
-    }
-
-    // NestJS HttpException (guards, pipes, etc.)
-    if (exception instanceof HttpException) {
-      const status = exception.getStatus();
-      const exceptionResponse = exception.getResponse();
-      const detail =
-        typeof exceptionResponse === 'string'
-          ? exceptionResponse
-          : (exceptionResponse as Record<string, unknown>).message;
-
-      if (status === 400 && Array.isArray(detail)) {
-        return {
-          type: 'https://arex.dev/errors/VALIDATION_ERROR',
-          title: 'Validation Error',
-          status: 400,
-          detail: 'One or more validation errors occurred.',
-          instance,
-          correlationId,
-          errors: (detail as string[]).map((msg) => ({ message: msg })),
-        };
-      }
-
-      return {
-        type: `https://arex.dev/errors/HTTP_${status}`,
-        title: exception.name,
-        status,
-        detail: typeof detail === 'string' ? detail : JSON.stringify(detail),
-        instance,
-        correlationId,
-      };
-    }
-
-    // Unhandled errors (middleware crashes, etc.)
-    const error = exception instanceof Error ? exception : new Error(String(exception));
-    return {
-      type: 'https://arex.dev/errors/INTERNAL_ERROR',
-      title: 'Internal Server Error',
-      status: 500,
-      detail: this.isProduction ? 'An unexpected error occurred.' : error.message,
-      instance,
-      correlationId,
-      ...(this.isProduction ? {} : { stack: error.stack }),
-    };
-  }
-}

package/src/guards/JwtAuthGuard.ts

@@ -1,29 +0,0 @@
-import { ExecutionContext, Injectable } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { AuthGuard } from '@nestjs/passport';
-
-const IS_PUBLIC_KEY = 'isPublic';
-
-export const Public = () => (target: object, _key?: string | symbol, descriptor?: PropertyDescriptor) => {
-  if (descriptor) {
-    Reflect.defineMetadata(IS_PUBLIC_KEY, true, descriptor.value!);
-  } else {
-    Reflect.defineMetadata(IS_PUBLIC_KEY, true, target);
-  }
-};
-
-@Injectable()
-export class JwtAuthGuard extends AuthGuard('jwt') {
-  constructor(private readonly reflector: Reflector) {
-    super();
-  }
-
-  canActivate(context: ExecutionContext) {
-    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
-      context.getHandler(),
-      context.getClass(),
-    ]);
-    if (isPublic) return true;
-    return super.canActivate(context);
-  }
-}

package/src/guards/JwtStrategy.ts

@@ -1,41 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { PassportStrategy } from '@nestjs/passport';
-import { Strategy, ExtractJwt } from 'passport-jwt';
-import { passportJwtSecret } from 'jwks-rsa';
-
-export interface JwtPayload {
-  sub: string;
-  email: string;
-  realm_access?: { roles: string[] };
-  preferred_username?: string;
-}
-
-@Injectable()
-export class JwtStrategy extends PassportStrategy(Strategy) {
-  constructor() {
-    const internalUrl = process.env.KEYCLOAK_INTERNAL_URL || process.env.KEYCLOAK_URL || 'http://localhost:8080';
-    const publicUrl = process.env.KEYCLOAK_URL || 'http://localhost:8080';
-    const realm = process.env.KEYCLOAK_REALM || 'arex';
-
-    super({
-      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-      secretOrKeyProvider: passportJwtSecret({
-        jwksUri: `${internalUrl}/realms/${realm}/protocol/openid-connect/certs`,
-        cache: true,
-        cacheMaxAge: 600_000,
-        rateLimit: true,
-      }),
-      issuer: `${publicUrl}/realms/${realm}`,
-      algorithms: ['RS256'],
-    });
-  }
-
-  validate(payload: JwtPayload) {
-    return {
-      keycloakId: payload.sub,
-      email: payload.email,
-      roles: payload.realm_access?.roles || [],
-      username: payload.preferred_username,
-    };
-  }
-}

package/src/guards/RolesGuard.ts

@@ -1,39 +0,0 @@
-import { CanActivate, ExecutionContext, ForbiddenException, Injectable } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-
-const ROLES_KEY = 'roles';
-
-export const Roles = (...roles: string[]): ClassDecorator & MethodDecorator =>
-  (target: object, _key?: string | symbol, descriptor?: PropertyDescriptor) => {
-    if (descriptor) {
-      Reflect.defineMetadata(ROLES_KEY, roles, descriptor.value!);
-    } else {
-      Reflect.defineMetadata(ROLES_KEY, roles, target);
-    }
-  };
-
-@Injectable()
-export class RolesGuard implements CanActivate {
-  constructor(private readonly reflector: Reflector) {}
-
-  canActivate(context: ExecutionContext): boolean {
-    const requiredRoles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
-      context.getHandler(),
-      context.getClass(),
-    ]);
-
-    if (!requiredRoles || requiredRoles.length === 0) return true;
-
-    const request = context.switchToHttp().getRequest();
-    const userRoles: string[] = request.user?.roles || [];
-
-    const hasRole = requiredRoles.some((role) => userRoles.includes(role));
-    if (!hasRole) {
-      throw new ForbiddenException({
-        error: { code: 'FORBIDDEN', message: 'Insufficient permissions' },
-      });
-    }
-
-    return true;
-  }
-}

package/src/index.ts

@@ -1,118 +0,0 @@
-// Result
-export { Result, ErrorType } from './result/Result';
-
-// Entities
-export { BaseEntity } from './entities/BaseEntity';
-export { TenantBaseEntity } from './entities/TenantBaseEntity';
-
-// Middleware
-export { CorrelationIdMiddleware } from './middleware/CorrelationIdMiddleware';
-export { correlationStore } from './middleware/CorrelationStore';
-export type { CorrelationStoreData } from './middleware/CorrelationStore';
-export { TenantContextMiddleware, TenantContext } from './middleware/TenantContextMiddleware';
-export { tenantStore } from './middleware/TenantStore';
-export type { TenantStoreData } from './middleware/TenantStore';
-
-// Filters
-export { GlobalExceptionFilter } from './filters/GlobalExceptionFilter';
-
-// Interceptors
-export { ResultInterceptor } from './interceptors/ResultInterceptor';
-
-// Guards
-export { JwtAuthGuard, Public } from './guards/JwtAuthGuard';
-export { JwtStrategy, JwtPayload } from './guards/JwtStrategy';
-export { RolesGuard, Roles } from './guards/RolesGuard';
-
-// Subscribers
-export { TenantSubscriber } from './subscribers/TenantSubscriber';
-
-// Resilience
-export { createCircuitBreaker } from './resilience/CircuitBreakerFactory';
-export type { CircuitBreakerOptions } from './resilience/CircuitBreakerFactory';
-
-// Bootstrap
-export { bootstrapService } from './bootstrap/bootstrapService';
-export type { BootstrapOptions } from './bootstrap/bootstrapService';
-
-// Logging
-export { createPinoConfig } from './logging/pino-config';
-
-// CQRS Constants
-export { REDIS_CLIENT } from './cqrs/constants';
-
-// CQRS Decorators
-export { FeatureFlag, getFeatureFlagMetadata } from './cqrs/decorators/FeatureFlag.decorator';
-export type { FeatureFlagOptions } from './cqrs/decorators/FeatureFlag.decorator';
-export { Log, getLogMetadata } from './cqrs/decorators/Log.decorator';
-export type { LogOptions } from './cqrs/decorators/Log.decorator';
-export { Validate, shouldValidate, getValidatorClass } from './cqrs/decorators/Validate.decorator';
-
-// Validation
-export type { ICommandValidator } from './cqrs/validation/ICommandValidator';
-export { validateCommand } from './cqrs/validation/ICommandValidator';
-export { Cache, getCacheMetadata } from './cqrs/decorators/Cache.decorator';
-export type { CacheOptions } from './cqrs/decorators/Cache.decorator';
-export { InvalidateCache, getInvalidateCacheMetadata } from './cqrs/decorators/InvalidateCache.decorator';
-export type { InvalidateCacheOptions } from './cqrs/decorators/InvalidateCache.decorator';
-export { DistributedLock, getDistributedLockMetadata } from './cqrs/decorators/DistributedLock.decorator';
-export type { DistributedLockOptions } from './cqrs/decorators/DistributedLock.decorator';
-export { IsolatedTransaction, isIsolatedTransaction } from './cqrs/decorators/IsolatedTransaction.decorator';
-export { Workflow, getWorkflowMetadata } from './cqrs/decorators/Workflow.decorator';
-export type { WorkflowOptions } from './cqrs/decorators/Workflow.decorator';
-
-// Workflow Engine Interface
-export { WORKFLOW_ENGINE } from './cqrs/interfaces/WorkflowEngine';
-export type { WorkflowEngine, WorkflowStartResult } from './cqrs/interfaces/WorkflowEngine';
-
-// Transaction (UnitOfWork)
-export { TransactionContext } from './cqrs/transaction/TransactionContext';
-export { getTransactionalRepo } from './cqrs/transaction/getTransactionalRepo';
-
-// Metrics
-export { MetricsService } from './metrics/MetricsService';
-export { MetricsController } from './metrics/MetricsController';
-
-// CQRS Behaviors
-export { LogBehavior } from './cqrs/behaviors/LogBehavior';
-export { FeatureFlagBehavior } from './cqrs/behaviors/FeatureFlagBehavior';
-export { ValidationBehavior } from './cqrs/behaviors/ValidationBehavior';
-export { CacheBehavior } from './cqrs/behaviors/CacheBehavior';
-export { InvalidateCacheBehavior } from './cqrs/behaviors/InvalidateCacheBehavior';
-export { DistributedLockBehavior } from './cqrs/behaviors/DistributedLockBehavior';
-export { TransactionalBehavior } from './cqrs/behaviors/TransactionalBehavior';
-export { PerformanceBehavior } from './cqrs/behaviors/PerformanceBehavior';
-export { WorkflowBehavior } from './cqrs/behaviors/WorkflowBehavior';
-
-// CQRS Pipeline
-export { QuanticCommandBus } from './cqrs/pipeline/QuanticCommandBus';
-export { QuanticQueryBus } from './cqrs/pipeline/QuanticQueryBus';
-export { type BehaviorFn } from './cqrs/pipeline/runPipeline';
-
-// Redis
-export { RedisModule } from './redis/redis.module';
-export type { RedisModuleOptions } from './redis/redis.module';
-
-// Events
-export { DomainEvent } from './events/DomainEvent';
-export type { DomainEventPayload } from './events/DomainEvent';
-export { OutboxEvent, OutboxEventStatus } from './events/OutboxEvent.entity';
-export { RedisStreamPublisher } from './events/RedisStreamPublisher';
-export { RedisStreamConsumer } from './events/RedisStreamConsumer';
-export { OutboxPublisherService } from './events/OutboxPublisherService';
-
-// Unleash
-export { UnleashModule } from './unleash/unleash.module';
-export type { UnleashModuleOptions } from './unleash/unleash.module';
-
-// Lifecycle
-export { GracefulShutdownService } from './lifecycle/GracefulShutdownService';
-
-// QuanticModule
-export { QuanticModule, SharedKernelModule } from './shared-kernel.module';
-export type { QuanticModuleOptions, SharedKernelModuleOptions } from './shared-kernel.module';
-
-// Testing mock helpers (safe for prod — no @nestjs/testing dependency)
-export { createMockRepository, createMockRedisClient } from './testing/mocks';
-
-

package/src/interceptors/ResultInterceptor.ts

@@ -1,93 +0,0 @@
-import {
-  Injectable,
-  NestInterceptor,
-  ExecutionContext,
-  CallHandler,
-  Logger,
-} from '@nestjs/common';
-import { Request, Response } from 'express';
-import { Observable, switchMap, catchError, of, EMPTY } from 'rxjs';
-import { Result, ErrorType } from '../result/Result';
-import { correlationStore } from '../middleware/CorrelationStore';
-
-const ERROR_TYPE_TO_STATUS: Record<string, number> = {
-  [ErrorType.NotFound]: 404,
-  [ErrorType.Forbidden]: 403,
-  [ErrorType.Unauthorized]: 401,
-  [ErrorType.Conflict]: 409,
-  [ErrorType.ValidationError]: 400,
-  [ErrorType.UnprocessableEntity]: 422,
-  [ErrorType.InternalError]: 500,
-};
-
-const ERROR_TYPE_TO_TITLE: Record<string, string> = {
-  [ErrorType.NotFound]: 'Not Found',
-  [ErrorType.Forbidden]: 'Forbidden',
-  [ErrorType.Unauthorized]: 'Unauthorized',
-  [ErrorType.Conflict]: 'Conflict',
-  [ErrorType.ValidationError]: 'Validation Error',
-  [ErrorType.UnprocessableEntity]: 'Unprocessable Entity',
-  [ErrorType.InternalError]: 'Internal Server Error',
-};
-
-@Injectable()
-export class ResultInterceptor implements NestInterceptor {
-  private readonly logger = new Logger(ResultInterceptor.name);
-
-  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
-    return next.handle().pipe(
-      switchMap((data) => {
-        if (data instanceof Result && !data.isSuccess) {
-          this.sendResultError(context, data);
-          return EMPTY;
-        }
-        return of(data);
-      }),
-      catchError((error) => {
-        if (error instanceof Result) {
-          this.sendResultError(context, error);
-          return EMPTY;
-        }
-        const err = error instanceof Error ? error : new Error(String(error));
-        this.logger.error({
-          msg: 'Unhandled exception before CQRS pipeline',
-          error: err.message,
-          stack: err.stack,
-        });
-        this.sendResultError(context, Result.failure(ErrorType.InternalError, err.message));
-        return EMPTY;
-      }),
-    );
-  }
-
-  private sendResultError(context: ExecutionContext, result: Result<unknown>): void {
-    const request = context.switchToHttp().getRequest<Request>();
-    const response = context.switchToHttp().getResponse<Response>();
-    const correlationId = correlationStore.getStore()?.correlationId;
-    const status = ERROR_TYPE_TO_STATUS[result.errorType!] ?? 500;
-    const title = ERROR_TYPE_TO_TITLE[result.errorType!] ?? 'Unknown Error';
-
-    if (correlationId) {
-      response.setHeader('X-Correlation-ID', correlationId);
-    }
-
-    this.logger.warn({
-      msg: `${status} ${result.errorType}`,
-      correlationId,
-      status,
-      detail: result.errorMessage,
-    });
-
-    response
-      .status(status)
-      .setHeader('Content-Type', 'application/problem+json')
-      .json({
-        type: `https://arex.dev/errors/${result.errorType}`,
-        title,
-        status,
-        detail: result.errorMessage,
-        instance: request.originalUrl,
-        correlationId,
-      });
-  }
-}

package/src/lifecycle/GracefulShutdownService.ts

@@ -1,77 +0,0 @@
-import { Injectable, Logger, OnModuleDestroy, Optional, Inject } from '@nestjs/common';
-import { DataSource } from 'typeorm';
-import { REDIS_CLIENT } from '../cqrs/constants';
-import type { Redis } from 'ioredis';
-
-const SHUTDOWN_TIMEOUT_MS = 30_000;
-
-/**
- * GracefulShutdownService ensures clean resource teardown on SIGTERM/SIGINT.
- *
- * Shutdown order:
- * 1. Wait for in-flight work (subclasses can override `drainWork`)
- * 2. Close database connections
- * 3. Quit Redis
- */
-@Injectable()
-export class GracefulShutdownService implements OnModuleDestroy {
-  private readonly logger = new Logger(GracefulShutdownService.name);
-
-  constructor(
-    @Optional() private readonly dataSource?: DataSource,
-    @Optional() @Inject(REDIS_CLIENT) private readonly redis?: Redis,
-  ) {}
-
-  async onModuleDestroy(): Promise<void> {
-    this.logger.log('Graceful shutdown initiated...');
-
-    // 1. Drain in-flight work with timeout
-    try {
-      await this.withTimeout(this.drainWork(), SHUTDOWN_TIMEOUT_MS, 'Work drain');
-    } catch (err) {
-      this.logger.warn(`Work drain timeout or error: ${(err as Error).message}`);
-    }
-
-    // 2. Close database connections
-    if (this.dataSource?.isInitialized) {
-      try {
-        await this.dataSource.destroy();
-        this.logger.log('Database connections closed');
-      } catch (err) {
-        this.logger.warn(`Database close error: ${(err as Error).message}`);
-      }
-    }
-
-    // 3. Quit Redis
-    if (this.redis) {
-      try {
-        await this.redis.quit();
-        this.logger.log('Redis connection closed');
-      } catch (err) {
-        this.logger.warn(`Redis quit error: ${(err as Error).message}`);
-      }
-    }
-
-    this.logger.log('Graceful shutdown complete');
-  }
-
-  /**
-   * Override in service-specific subclasses to drain Bull queues,
-   * close Socket.IO servers, etc.
-   */
-  protected async drainWork(): Promise<void> {
-    // Base implementation — no-op
-  }
-
-  private withTimeout(promise: Promise<void>, ms: number, label: string): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(`${label} timed out after ${ms}ms`));
-      }, ms);
-
-      promise
-        .then(() => { clearTimeout(timer); resolve(); })
-        .catch((err) => { clearTimeout(timer); reject(err); });
-    });
-  }
-}

package/src/logging/pino-config.ts

@@ -1,80 +0,0 @@
-function canResolvePinoSeq(): boolean {
-  try {
-    require.resolve('pino-seq');
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function buildTransport(logLevel: string) {
-  const seqUrl = process.env['SEQ_URL'];
-  const useSeq = seqUrl && canResolvePinoSeq();
-
-  if (process.env['NODE_ENV'] === 'production' && useSeq) {
-    return {
-      target: 'pino-seq',
-      options: { serverUrl: seqUrl, logOtherAs: 'Verbose' },
-    };
-  }
-
-  const targets: any[] = [
-    { target: 'pino/file', options: { destination: 1 }, level: logLevel },
-  ];
-
-  if (useSeq) {
-    targets.push({
-      target: 'pino-seq',
-      options: { serverUrl: seqUrl, logOtherAs: 'Verbose' },
-      level: logLevel,
-    });
-  }
-
-  return { targets };
-}
-
-export function createPinoConfig(serviceName: string) {
-  const logLevel = process.env['LOG_LEVEL'] || 'info';
-
-  return {
-    pinoHttp: {
-      level: logLevel,
-      transport: buildTransport(logLevel),
-      serializers: {
-        req(req: any) {
-          return {
-            id: req.id,
-            method: req.method,
-            url: req.url,
-            correlationId: req.raw?.correlationId || req.headers?.['x-correlation-id'],
-          };
-        },
-        res(res: any) {
-          return {
-            statusCode: res.statusCode,
-          };
-        },
-        email(value: string) {
-          if (!value || typeof value !== 'string') return value;
-          const [local, domain] = value.split('@');
-          if (!domain) return value;
-          return `${local[0]}***@${domain}`;
-        },
-        token(_value: string) {
-          return '[REDACTED]';
-        },
-        brd(value: string) {
-          if (!value || typeof value !== 'string') return value;
-          return value.length > 50 ? `${value.substring(0, 50)}...` : value;
-        },
-      },
-      customProps(req: any) {
-        return {
-          correlationId:
-            req.correlationId || req.headers?.['x-correlation-id'],
-          service: serviceName,
-        };
-      },
-    },
-  };
-}

package/src/metrics/MetricsController.ts

@@ -1,17 +0,0 @@
-import { Controller, Get, Res } from '@nestjs/common';
-import { Response } from 'express';
-import { Public } from '../guards/JwtAuthGuard';
-import { MetricsService } from './MetricsService';
-
-@Public()
-@Controller()
-export class MetricsController {
-  constructor(private readonly metrics: MetricsService) {}
-
-  @Get('metrics')
-  async getMetrics(@Res() res: Response) {
-    const metricsOutput = await this.metrics.getMetrics();
-    res.set('Content-Type', this.metrics.getContentType());
-    res.end(metricsOutput);
-  }
-}

package/src/metrics/MetricsService.ts

@@ -1,55 +0,0 @@
-import { Injectable, OnModuleInit } from '@nestjs/common';
-import { Registry, Counter, Histogram, Gauge, collectDefaultMetrics } from 'prom-client';
-
-@Injectable()
-export class MetricsService implements OnModuleInit {
-  readonly registry = new Registry();
-
-  readonly buildTotal = new Counter({
-    name: 'arex_build_total',
-    help: 'Total number of builds',
-    labelNames: ['status', 'tech_stack'] as const,
-    registers: [this.registry],
-  });
-
-  readonly stageDuration = new Histogram({
-    name: 'arex_stage_duration_seconds',
-    help: 'Duration of pipeline stages in seconds',
-    labelNames: ['stage_type', 'status'] as const,
-    buckets: [0.5, 1, 2, 5, 10, 30, 60, 120, 300],
-    registers: [this.registry],
-  });
-
-  readonly promptCacheHits = new Counter({
-    name: 'arex_prompt_cache_hits_total',
-    help: 'Total prompt cache hits',
-    registers: [this.registry],
-  });
-
-  readonly queueDepth = new Gauge({
-    name: 'arex_queue_depth',
-    help: 'Current depth of Bull job queue',
-    labelNames: ['queue'] as const,
-    registers: [this.registry],
-  });
-
-  readonly handlerDuration = new Histogram({
-    name: 'arex_handler_duration_seconds',
-    help: 'Duration of command/query handlers in seconds',
-    labelNames: ['handler', 'result'] as const,
-    buckets: [0.01, 0.05, 0.1, 0.25, 0.5, 1, 2, 5],
-    registers: [this.registry],
-  });
-
-  onModuleInit() {
-    collectDefaultMetrics({ register: this.registry });
-  }
-
-  async getMetrics(): Promise<string> {
-    return this.registry.metrics();
-  }
-
-  getContentType(): string {
-    return this.registry.contentType;
-  }
-}