@martel/calyx 1.12.0 → 1.13.1

package/src/http/application.ts

@@ -18,6 +18,8 @@ import { parseCookies, formatCookie } from '../cookies/cookies.ts';
 import { StreamableFile } from '../streaming/streamable-file.ts';
 import { defaultRenderEngine, ViewEngine } from '../mvc/mvc.ts';
 import { join } from 'path';
+import { CalyxMicroservice } from '../microservices/microservice.ts';
+
 
 class ObjectPool<T> {
   private pool: T[] = [];
@@ -156,14 +158,57 @@ export class CalyxApplication {
   private serverPort = 3000;
   private graphqlSchema: any = null;
   private graphqlQueryCache = new Map<string, any>();
+  private graphqlLib: any = null;
   private isInitialized = false;
   private versioningOptions?: VersioningOptions;
+  private globalPrefix?: string;
+  private globalPrefixOptions?: { exclude?: (string | { path: string; method: string })[] };
+  private connectedMicroservices: any[] = [];
+  private websocketAdapter: any = null;
 
   enableVersioning(options: VersioningOptions) {
     this.versioningOptions = options;
     return this;
   }
 
+  setGlobalPrefix(prefix: string, options?: { exclude?: (string | { path: string; method: string })[] }) {
+    this.globalPrefix = prefix;
+    this.globalPrefixOptions = options;
+    return this;
+  }
+
+  getHttpServer() {
+    return this.server;
+  }
+
+  getHttpAdapter() {
+    return {
+      getInstance: () => this.server,
+      getHttpServer: () => this.server,
+    };
+  }
+
+  async getUrl(): Promise<string> {
+    return `http://localhost:${this.serverPort}`;
+  }
+
+  useWebSocketAdapter(adapter: any) {
+    this.websocketAdapter = adapter;
+    return this;
+  }
+
+  connectMicroservice(options: any) {
+    const microservice = new CalyxMicroservice(this.rootModule, options);
+    this.connectedMicroservices.push(microservice);
+    return microservice;
+  }
+
+  async startAllMicroservices(): Promise<void> {
+    for (const ms of this.connectedMicroservices) {
+      await ms.listen();
+    }
+  }
+
   private compressionEnabled = false;
 
   enableCompression() {
@@ -268,6 +313,7 @@ export class CalyxApplication {
         const isControllerRequestScoped = controllerScope === Scope.REQUEST;
         const singletonInstance = isControllerRequestScoped ? null : record.instances.get(controllerClass);
 
+        const controllerHost = Reflect.getMetadata('calyx:controller_host', controllerClass);
         for (const method of methods) {
           const routeMeta = Reflect.getMetadata(METADATA_KEYS.HTTP_METHOD, controllerClass.prototype, method);
           if (!routeMeta) continue;
@@ -275,7 +321,13 @@ export class CalyxApplication {
           // Normalize prefix and path
           const normalizedPrefix = prefix.replace(/^\/|\/$/g, '');
           const normalizedPath = routeMeta.path.replace(/^\/|\/$/g, '');
-          const fullPath = '/' + [normalizedPrefix, normalizedPath].filter(Boolean).join('/');
+          const baseRoutePath = '/' + [normalizedPrefix, normalizedPath].filter(Boolean).join('/');
+          
+          let fullPath = baseRoutePath;
+          if (this.globalPrefix && !this.isRouteExcludedFromGlobalPrefix(baseRoutePath, routeMeta.method)) {
+            const cleanGlobal = this.globalPrefix.replace(/^\/|\/$/g, '');
+            fullPath = '/' + [cleanGlobal, normalizedPrefix, normalizedPath].filter(Boolean).join('/');
+          }
 
           const paramsConfig: ParameterConfig[] = Reflect.getMetadata(METADATA_KEYS.HTTP_PARAMS, controllerClass.prototype, method) || [];
           // Sort parameters by index ascending so they map correctly to function arguments
@@ -361,7 +413,14 @@ export class CalyxApplication {
                         Reflect.hasMetadata('calyx:sse', methodFn);
 
           const insertRoute = (methodStr: string, pathStr: string) => {
-            this.router.insert(methodStr, pathStr, {
+            let finalMethod = methodStr;
+            if (controllerHost) {
+              const hasParams = controllerHost.includes(':');
+              finalMethod = hasParams
+                ? `${methodStr}:host-dynamic:${controllerHost}`
+                : `${methodStr}:host:${controllerHost}`;
+            }
+            this.router.insert(finalMethod, pathStr, {
               controllerClass,
               moduleClass,
               instance: singletonInstance,
@@ -388,7 +447,11 @@ export class CalyxApplication {
           if (this.versioningOptions && this.versioningOptions.type === VersioningType.URI && versions.length > 0) {
             for (const version of versions) {
               const versionPrefix = `/v${version}`;
-              const versionedPath = '/' + [versionPrefix.replace(/^\/|\/$/g, ''), normalizedPrefix, normalizedPath].filter(Boolean).join('/');
+              let versionedPath = '/' + [versionPrefix.replace(/^\/|\/$/g, ''), normalizedPrefix, normalizedPath].filter(Boolean).join('/');
+              if (this.globalPrefix && !this.isRouteExcludedFromGlobalPrefix(versionedPath, routeMeta.method)) {
+                const cleanGlobal = this.globalPrefix.replace(/^\/|\/$/g, '');
+                versionedPath = '/' + [cleanGlobal, versionPrefix.replace(/^\/|\/$/g, ''), normalizedPrefix, normalizedPath].filter(Boolean).join('/');
+              }
               insertRoute(routeMeta.method, versionedPath);
             }
           } else if (this.versioningOptions && (this.versioningOptions.type === VersioningType.HEADER || this.versioningOptions.type === VersioningType.MEDIA_TYPE) && versions.length > 0) {
@@ -516,8 +579,8 @@ export class CalyxApplication {
     try {
       const urlStr = req.url;
       // Parse cookies
-      const cookieHeader = req.headers.get('cookie') || '';
-      (req as any).cookies = parseCookies(cookieHeader);
+      const cookieHeader = req.headers.get('cookie');
+      (req as any).cookies = cookieHeader ? parseCookies(cookieHeader) : {};
 
       // Fast path parsing
       let pathname = '/';
@@ -540,12 +603,27 @@ export class CalyxApplication {
       }
 
       let matched = null;
+      const hostHeader = req.headers.get('host') || '';
+
       if (this.versioningOptions && this.versioningOptions.type !== VersioningType.URI) {
         const version = VersionExtractor.extract(req, this.versioningOptions.type, this.versioningOptions);
         if (version) {
-          matched = this.router.match(`${req.method}:v${version}`.toUpperCase(), pathname);
+          const vMethod = `${req.method}:v${version}`.toUpperCase();
+          matched = this.router.match(`${vMethod}:host:${hostHeader}`.toUpperCase(), pathname);
+          if (!matched) {
+            matched = this.matchDynamicHost(vMethod, hostHeader, pathname);
+          }
+          if (!matched) {
+            matched = this.router.match(vMethod, pathname);
+          }
         }
       }
+      if (!matched) {
+        matched = this.router.match(`${req.method}:host:${hostHeader}`.toUpperCase(), pathname);
+      }
+      if (!matched) {
+        matched = this.matchDynamicHost(req.method.toUpperCase(), hostHeader, pathname);
+      }
       if (!matched) {
         matched = this.router.match(req.method, pathname);
       }
@@ -723,7 +801,7 @@ export class CalyxApplication {
             case 'headers': val = config.name ? req.headers.get(config.name) : Object.fromEntries(req.headers.entries()); break;
             case 'session': val = (req as any).session; break;
             case 'ip': val = this.server ? (this.server.requestIP(req)?.address ?? req.headers.get('x-forwarded-for') ?? '') : (req.headers.get('x-forwarded-for') ?? ''); break;
-            case 'hostparam': val = config.name ? req.headers.get('host') : req.headers.get('host'); break;
+            case 'hostparam': val = config.name ? params[config.name] : params; break;
             case 'next': val = next; break;
             case 'custom': val = config.factory ? config.factory(config.name, context) : undefined; break;
           }
@@ -986,7 +1064,7 @@ export class CalyxApplication {
           val = this.server ? (this.server.requestIP(req)?.address ?? req.headers.get('x-forwarded-for') ?? '') : (req.headers.get('x-forwarded-for') ?? '');
           break;
         case 'hostparam':
-          val = config.name ? req.headers.get('host') : req.headers.get('host');
+          val = config.name ? params[config.name] : params;
           break;
         case 'next':
           val = () => {};
@@ -1268,7 +1346,7 @@ export class CalyxApplication {
       const body = await req.json() as any;
       const { query, variables } = body;
 
-      const { parse, validate, execute } = await import('graphql');
+      const { parse, validate, execute } = this.graphqlLib || (this.graphqlLib = await import('graphql'));
       
       let document = this.graphqlQueryCache.get(query);
       if (!document) {
@@ -1403,7 +1481,7 @@ export class CalyxApplication {
           const { id, payload } = data;
           const { query, variables } = payload;
           
-          const { subscribe, parse, validate } = await import('graphql');
+          const { subscribe, parse, validate } = this.graphqlLib || (this.graphqlLib = await import('graphql'));
           
           let document = this.graphqlQueryCache.get(query);
           if (!document) {
@@ -1904,6 +1982,58 @@ export class CalyxApplication {
     }
   }
 
+  private isRouteExcludedFromGlobalPrefix(path: string, method: string): boolean {
+    if (!this.globalPrefixOptions?.exclude) return false;
+    const cleanPath = path.replace(/^\/|\/$/g, '');
+    for (const exclusion of this.globalPrefixOptions.exclude) {
+      if (typeof exclusion === 'string') {
+        if (exclusion.replace(/^\/|\/$/g, '') === cleanPath) return true;
+      } else {
+        const cleanExclPath = exclusion.path.replace(/^\/|\/$/g, '');
+        const exclMethod = String(exclusion.method).toUpperCase();
+        if (cleanExclPath === cleanPath && (exclMethod === 'ALL' || exclMethod === method.toUpperCase())) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  private matchDynamicHost(method: string, hostHeader: string, pathname: string): any {
+    const routes = this.router.getRoutes();
+    for (const route of routes) {
+      if (route.method.startsWith(method + ':host-dynamic:')) {
+        const hostPattern = route.method.substring((method + ':host-dynamic:').length);
+        const params = this.matchHostPattern(hostPattern, hostHeader);
+        if (params) {
+          const matched = this.router.match(route.method, pathname);
+          if (matched) {
+            matched.params = { ...matched.params, ...params };
+            return matched;
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  private matchHostPattern(pattern: string, host: string): Record<string, string> | null {
+    const patternSegments = pattern.split('.');
+    const hostSegments = host.split('.');
+    if (patternSegments.length !== hostSegments.length) return null;
+    const params: Record<string, string> = {};
+    for (let i = 0; i < patternSegments.length; i++) {
+      const pSeg = patternSegments[i];
+      const hSeg = hostSegments[i];
+      if (pSeg.startsWith(':')) {
+        params[pSeg.slice(1)] = hSeg;
+      } else if (pSeg !== hSeg) {
+        return null;
+      }
+    }
+    return params;
+  }
+
   getRoutes() {
     return this.router.getRoutes();
   }

package/src/http/decorators.ts

@@ -1,9 +1,29 @@
 import 'reflect-metadata';
 import { METADATA_KEYS } from '../core/metadata.ts';
 
-export function Controller(prefix = ''): ClassDecorator {
+export interface ControllerOptions {
+  path?: string;
+  host?: string;
+  scope?: any;
+}
+
+export function Controller(prefixOrOptions?: string | ControllerOptions): ClassDecorator {
   return (target) => {
+    let prefix = '';
+    let host: string | undefined = undefined;
+    if (typeof prefixOrOptions === 'string') {
+      prefix = prefixOrOptions;
+    } else if (prefixOrOptions && typeof prefixOrOptions === 'object') {
+      prefix = prefixOrOptions.path ?? '';
+      host = prefixOrOptions.host;
+      if (prefixOrOptions.scope) {
+        Reflect.defineMetadata(METADATA_KEYS.SCOPE, prefixOrOptions.scope, target);
+      }
+    }
     Reflect.defineMetadata(METADATA_KEYS.CONTROLLER, prefix, target);
+    if (host !== undefined) {
+      Reflect.defineMetadata('calyx:controller_host', host, target);
+    }
   };
 }
 

package/src/http/exceptions.ts

@@ -45,3 +45,100 @@ export class InternalServerErrorException extends HttpException {
     super(message, 500);
   }
 }
+
+export class NotAcceptableException extends HttpException {
+  constructor(message: string | object = 'Not Acceptable') {
+    super(message, 406);
+  }
+}
+
+export class RequestTimeoutException extends HttpException {
+  constructor(message: string | object = 'Request Timeout') {
+    super(message, 408);
+  }
+}
+
+export class ConflictException extends HttpException {
+  constructor(message: string | object = 'Conflict') {
+    super(message, 409);
+  }
+}
+
+export class GoneException extends HttpException {
+  constructor(message: string | object = 'Gone') {
+    super(message, 410);
+  }
+}
+
+export class PayloadTooLargeException extends HttpException {
+  constructor(message: string | object = 'Payload Too Large') {
+    super(message, 413);
+  }
+}
+
+export class UnsupportedMediaTypeException extends HttpException {
+  constructor(message: string | object = 'Unsupported Media Type') {
+    super(message, 415);
+  }
+}
+
+export class UnprocessableEntityException extends HttpException {
+  constructor(message: string | object = 'Unprocessable Entity') {
+    super(message, 422);
+  }
+}
+
+export class NotImplementedException extends HttpException {
+  constructor(message: string | object = 'Not Implemented') {
+    super(message, 501);
+  }
+}
+
+export class HttpVersionNotSupportedException extends HttpException {
+  constructor(message: string | object = 'HTTP Version Not Supported') {
+    super(message, 505);
+  }
+}
+
+export class BadGatewayException extends HttpException {
+  constructor(message: string | object = 'Bad Gateway') {
+    super(message, 502);
+  }
+}
+
+export class ServiceUnavailableException extends HttpException {
+  constructor(message: string | object = 'Service Unavailable') {
+    super(message, 503);
+  }
+}
+
+export class GatewayTimeoutException extends HttpException {
+  constructor(message: string | object = 'Gateway Timeout') {
+    super(message, 504);
+  }
+}
+
+export class PreconditionFailedException extends HttpException {
+  constructor(message: string | object = 'Precondition Failed') {
+    super(message, 412);
+  }
+}
+
+export class MethodNotAllowedException extends HttpException {
+  constructor(message: string | object = 'Method Not Allowed') {
+    super(message, 405);
+  }
+}
+
+export class ImATeapotException extends HttpException {
+  constructor(message: string | object = "I'm a teapot") {
+    super(message, 418);
+  }
+}
+
+export class MisdirectedException extends HttpException {
+  constructor(message: string | object = 'Misdirected Request') {
+    super(message, 421);
+  }
+}
+

package/src/http/factory.ts

@@ -14,3 +14,6 @@ export class CalyxFactory {
     return app;
   }
 }
+
+export const NestFactory = CalyxFactory;
+

package/src/http/router.ts

@@ -17,6 +17,7 @@ export class RadixRouter<T> {
   private handlersArray: T[] = [];
   private compiledMatch: ((method: string, path: string) => RouteMatch<T> | null) | null = null;
   private routesList: { method: string; path: string; handler: T }[] = [];
+  private regexRoutes: { method: string; regex: RegExp; handler: T }[] = [];
 
   getRoutes() {
     return this.routesList;
@@ -26,13 +27,26 @@ export class RadixRouter<T> {
     this.root = new RouterNode<T>();
     this.staticRoutes.clear();
     this.routesList = [];
+    this.regexRoutes = [];
     this.compiledMatch = null;
   }
 
   insert(method: string, path: string, handler: T) {
     this.routesList.push({ method, path, handler });
+    
+    const isWildcardPath = path.includes('*') && !path.endsWith('/*') && path !== '*';
+    if (isWildcardPath) {
+      const escaped = path.replace(/[\-\[\]\/\{\}\(\)\+\?\.\\\^\$\|]/g, '\\$&');
+      const regexStr = '^' + escaped.replace(/\*/g, '.*') + '$';
+      this.regexRoutes.push({
+        method: method.toUpperCase(),
+        regex: new RegExp(regexStr),
+        handler,
+      });
+    }
+
     const hasParams = path.includes(':') || path.includes('*');
-    if (!hasParams) {
+    if (!hasParams && !isWildcardPath) {
       this.staticRoutes.set(method.toUpperCase() + ' ' + path, handler);
     }
 
@@ -68,6 +82,15 @@ export class RadixRouter<T> {
   }
 
   match(method: string, path: string): RouteMatch<T> | null {
+    if (this.regexRoutes.length > 0) {
+      const uMethod = method.toUpperCase();
+      for (const route of this.regexRoutes) {
+        if (route.method === uMethod && route.regex.test(path)) {
+          return { handler: route.handler, params: {} };
+        }
+      }
+    }
+
     if (this.compiledMatch) {
       return this.compiledMatch(method, path);
     }
@@ -105,6 +128,7 @@ export class RadixRouter<T> {
       staticCheckCode = `
       switch (method) {
       `;
+
       for (const [method, routes] of Object.entries(staticRoutesByMethod)) {
         staticCheckCode += `  case '${method}':\n    switch (path) {\n`;
         for (const [path, handlerIdx] of Object.entries(routes)) {
@@ -152,7 +176,7 @@ export class RadixRouter<T> {
           const handlerIdx = registerHandler(handler);
           parts.push(`  case '${method}': return { handler: handlers[${handlerIdx}], params };`);
         }
-        const fallbackWildcardHandler = node.wildcardChild.handlers.get('ALL') ?? node.wildcardChild.handlers.values().next().value;
+        const fallbackWildcardHandler = node.wildcardChild.handlers.get('ALL');
         if (fallbackWildcardHandler) {
           const handlerIdx = registerHandler(fallbackWildcardHandler);
           parts.push(`  default: return { handler: handlers[${handlerIdx}], params };`);
@@ -170,7 +194,7 @@ export class RadixRouter<T> {
           const handlerIdx = registerHandler(handler);
           parts.push(`    case '${method}': return { handler: handlers[${handlerIdx}], params };`);
         }
-        const fallbackHandler = node.handlers.get('ALL') ?? node.handlers.values().next().value;
+        const fallbackHandler = node.handlers.get('ALL');
         if (fallbackHandler) {
           const handlerIdx = registerHandler(fallbackHandler);
           parts.push(`    default: return { handler: handlers[${handlerIdx}], params };`);
@@ -191,7 +215,6 @@ export class RadixRouter<T> {
       return null;
     `;
 
-
     try {
       this.compiledMatch = new Function('handlers', `
         return function match(method, path) {

package/src/index.ts

@@ -13,6 +13,7 @@ export * from './validation/index.ts';
 export * from './openapi/index.ts';
 export * from './database/typeorm.module.ts';
 export * from './database/mongoose.module.ts';
+export { SequelizeModule, InjectModel as InjectModelSequelize, Model as SequelizeModel } from './database/sequelize.module.ts';
 export * from './versioning/versioning.ts';
 export * from './queue/queue.module.ts';
 export * from './logger/index.ts';

package/src/microservices/exceptions.ts

@@ -0,0 +1,10 @@
+export class RpcException extends Error {
+  constructor(private readonly error: string | object) {
+    super(typeof error === 'string' ? error : JSON.stringify(error));
+    this.name = 'RpcException';
+  }
+
+  getError() {
+    return this.error;
+  }
+}

package/src/microservices/index.ts

@@ -5,3 +5,4 @@ export * from './decorators.ts';
 export * from './server-tcp.ts';
 export * from './microservice.ts';
 export * from './clients.module.ts';
+export * from './exceptions.ts';

package/src/queue/queue.module.ts

@@ -105,6 +105,7 @@ export class QueueManager {
 export class Queue {
   private jobs: Job[] = [];
   private jobCounter = 0;
+  private paused = false;
 
   constructor(public readonly name: string) {}
 
@@ -146,16 +147,80 @@ export class Queue {
   async getJobs(): Promise<Job[]> {
     return this.jobs;
   }
+
+  async pause(): Promise<void> {
+    this.paused = true;
+  }
+
+  async resume(): Promise<void> {
+    this.paused = false;
+  }
+
+  async isPaused(): Promise<boolean> {
+    return this.paused;
+  }
+
+  async obliterate(): Promise<void> {
+    this.jobs = [];
+    this.jobCounter = 0;
+  }
+
+  async clean(): Promise<void> {
+    this.jobs = this.jobs.filter((j) => j.status !== 'completed' && j.status !== 'failed');
+  }
+
+  async drain(): Promise<void> {
+    this.jobs = [];
+  }
+
+  async count(): Promise<number> {
+    return this.jobs.length;
+  }
+
+  async getJob(id: string): Promise<Job | null> {
+    return this.jobs.find((j) => j.id === id) ?? null;
+  }
 }
 
 @Module({})
 export class QueueModule {
-  static registerQueue(...configs: { name: string }[]): DynamicModule {
-    const providers = configs.map((c) => {
+  static forRoot(options: any = {}): DynamicModule {
+    return {
+      module: QueueModule,
+      providers: [
+        {
+          provide: 'BULL_MODULE_OPTIONS',
+          useValue: options,
+        },
+      ],
+      exports: [],
+      global: true,
+    };
+  }
+
+  static forRootAsync(options: any = {}): DynamicModule {
+    return {
+      module: QueueModule,
+      providers: [
+        {
+          provide: 'BULL_MODULE_OPTIONS',
+          useFactory: options.useFactory || (() => ({})),
+          inject: options.inject || [],
+        },
+      ],
+      exports: [],
+      global: true,
+    };
+  }
+
+  static registerQueue(...args: any[]): DynamicModule {
+    const configs = Array.isArray(args[0]) ? args[0] : args;
+    const providers = configs.map((c: any) => {
+      const name = typeof c === 'string' ? c : c.name;
       return {
-        provide: `Queue_${c.name}`,
+        provide: `Queue_${name}`,
         useFactory: () => {
-          return QueueManager.getOrCreateQueue(c.name);
+          return QueueManager.getOrCreateQueue(name);
         },
       };
     });
@@ -163,7 +228,7 @@ export class QueueModule {
     return {
       module: QueueModule,
       providers,
-      exports: configs.map((c) => `Queue_${c.name}`),
+      exports: configs.map((c: any) => `Queue_${typeof c === 'string' ? c : c.name}`),
     };
   }
 
@@ -172,3 +237,6 @@ export class QueueModule {
     // Handled in CalyxApplication initialization dynamically
   }
 }
+
+export const BullModule = QueueModule;
+

package/src/terminus/terminus.ts

@@ -54,8 +54,81 @@ export class HttpHealthIndicator {
   }
 }
 
+@Injectable()
+export class TypeOrmHealthIndicator {
+  async pingCheck(key: string, options?: any): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class MongooseHealthIndicator {
+  async pingCheck(key: string, options?: any): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class SequelizeHealthIndicator {
+  async pingCheck(key: string, options?: any): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class MicroserviceHealthIndicator {
+  async pingCheck(key: string, options?: any): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class DiskHealthIndicator {
+  async checkStorage(key: string, options?: { thresholdPercent?: number; path?: string }): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class MemoryHealthIndicator {
+  async checkHeap(key: string, thresholdBytes: number): Promise<any> {
+    const usage = process.memoryUsage().heapUsed;
+    if (usage > thresholdBytes) {
+      throw new Error(`Heap memory usage ${usage} exceeded threshold ${thresholdBytes}`);
+    }
+    return { [key]: { status: 'up', heapUsed: usage } };
+  }
+
+  async checkRSS(key: string, thresholdBytes: number): Promise<any> {
+    const usage = process.memoryUsage().rss;
+    if (usage > thresholdBytes) {
+      throw new Error(`RSS memory usage ${usage} exceeded threshold ${thresholdBytes}`);
+    }
+    return { [key]: { status: 'up', rss: usage } };
+  }
+}
+
 @Module({
-  providers: [HealthCheckService, HttpHealthIndicator],
-  exports: [HealthCheckService, HttpHealthIndicator],
+  providers: [
+    HealthCheckService,
+    HttpHealthIndicator,
+    TypeOrmHealthIndicator,
+    MongooseHealthIndicator,
+    SequelizeHealthIndicator,
+    MicroserviceHealthIndicator,
+    DiskHealthIndicator,
+    MemoryHealthIndicator,
+  ],
+  exports: [
+    HealthCheckService,
+    HttpHealthIndicator,
+    TypeOrmHealthIndicator,
+    MongooseHealthIndicator,
+    SequelizeHealthIndicator,
+    MicroserviceHealthIndicator,
+    DiskHealthIndicator,
+    MemoryHealthIndicator,
+  ],
 })
 export class TerminusModule {}
+