@martel/calyx 1.11.0 → 1.13.0

package/src/graphql/decorators.ts

@@ -47,6 +47,22 @@ export function Parent(): ParameterDecorator {
   };
 }
 
+export function Context(name?: string): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    const contextParams = Reflect.getOwnMetadata('calyx:context', target, propertyKey!) || [];
+    contextParams.push({ parameterIndex, name });
+    Reflect.defineMetadata('calyx:context', contextParams, target, propertyKey!);
+  };
+}
+
+export function Info(): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    const infoParams = Reflect.getOwnMetadata('calyx:info', target, propertyKey!) || [];
+    infoParams.push(parameterIndex);
+    Reflect.defineMetadata('calyx:info', infoParams, target, propertyKey!);
+  };
+}
+
 export function ObjectType(): ClassDecorator {
   return (target) => {
     Reflect.defineMetadata('calyx:object_type', true, target);

package/src/graphql/graphql.module.ts

@@ -313,6 +313,14 @@ export class GraphQLModule {
               for (const idx of parentParams) {
                 params[idx] = parent;
               }
+              const contextParams = Reflect.getMetadata('calyx:context', resolverInstance, fieldMeta.propertyKey) || [];
+              for (const item of contextParams) {
+                params[item.parameterIndex] = item.name ? context?.[item.name] : context;
+              }
+              const infoParams = Reflect.getMetadata('calyx:info', resolverInstance, fieldMeta.propertyKey) || [];
+              for (const idx of infoParams) {
+                params[idx] = info;
+              }
               return resolverInstance[fieldMeta.propertyKey](...params);
             };
 
@@ -473,6 +481,14 @@ export class GraphQLModule {
                     for (const idx of parentParams) {
                       params[idx] = parent;
                     }
+                    const contextParams = Reflect.getMetadata('calyx:context', resolverInstance, fieldRes.propertyKey) || [];
+                    for (const item of contextParams) {
+                      params[item.parameterIndex] = item.name ? context?.[item.name] : context;
+                    }
+                    const infoParams = Reflect.getMetadata('calyx:info', resolverInstance, fieldRes.propertyKey) || [];
+                    for (const idx of infoParams) {
+                      params[idx] = info;
+                    }
                     return resolverInstance[fieldRes.propertyKey](...params);
                   };
 

package/src/http/application.ts

@@ -10,6 +10,7 @@ import { EventEmitter } from '../event-emitter/event-emitter.ts';
 import { cors, CorsOptions } from '../security/cors.middleware.ts';
 import { helmet, HelmetOptions } from '../security/helmet.middleware.ts';
 import { CronMatcher } from '../schedule/cron.matcher.ts';
+import { SchedulerRegistry } from '../schedule/scheduler-registry.ts';
 import { SerializationCompiler } from '../validation/compiler.ts';
 import { VersioningOptions, VersioningType, VersionExtractor, VERSION_METADATA_KEY } from '../versioning/versioning.ts';
 import { QueueManager, PROCESSOR_METADATA_KEY } from '../queue/queue.module.ts';
@@ -17,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[] = [];
@@ -66,6 +69,41 @@ export class CalyxResponse {
     this.cookiesList.push(formatCookie(name, value, options));
     return this;
   }
+
+  header(name: string, value: string) {
+    return this.set(name, value);
+  }
+
+  type(contentType: string) {
+    return this.set('content-type', contentType);
+  }
+
+  redirect(url: string, status?: number) {
+    this.statusCode = status ?? 302;
+    this.set('location', url);
+    this.sent = true;
+    return this;
+  }
+
+  end() {
+    this.sent = true;
+    return this;
+  }
+
+  get(name: string): string | undefined {
+    return this.headers[name.toLowerCase()];
+  }
+
+  append(name: string, value: string) {
+    const key = name.toLowerCase();
+    const existing = this.headers[key];
+    this.headers[key] = existing ? `${existing}, ${value}` : value;
+    return this;
+  }
+
+  clearCookie(name: string, options?: any) {
+    return this.cookie(name, '', { ...options, expires: new Date(0) });
+  }
 }
 
 interface CompiledLifecycleItem {
@@ -122,12 +160,54 @@ export class CalyxApplication {
   private graphqlQueryCache = new Map<string, any>();
   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() {
@@ -186,7 +266,7 @@ export class CalyxApplication {
     this.isInitialized = true;
 
     // Bootstrap the dependency injection container
-    this.container.bootstrap(this.rootModule);
+    await this.container.bootstrap(this.rootModule);
 
     // Resolve registered modules middlewares
     this.resolveMiddleware();
@@ -232,6 +312,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;
@@ -239,7 +320,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
@@ -325,7 +412,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,
@@ -352,7 +446,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) {
@@ -504,12 +602,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);
       }
@@ -685,6 +798,10 @@ export class CalyxApplication {
             case 'query': val = config.name ? query?.[config.name] : query; break;
             case 'body': val = config.name ? body?.[config.name] : body; break;
             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 ? params[config.name] : params; break;
+            case 'next': val = next; break;
             case 'custom': val = config.factory ? config.factory(config.name, context) : undefined; break;
           }
 
@@ -939,6 +1056,18 @@ 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 ? params[config.name] : params;
+          break;
+        case 'next':
+          val = () => {};
+          break;
         case 'custom':
           val = config.factory ? config.factory(config.name, context!) : undefined;
           break;
@@ -1554,11 +1683,18 @@ export class CalyxApplication {
       return;
     }
 
+    let registry: SchedulerRegistry | null = null;
+    try {
+      registry = this.container.getGlobalOrAnyInstance(SchedulerRegistry);
+    } catch {
+      // ignore
+    }
+
     const instances = this.container.getProviderAndControllerInstances();
     for (const instance of instances) {
       if (!instance || !instance.constructor) continue;
 
-      const crons: { expression: string; propertyKey: string | symbol }[] =
+      const crons: { expression: string; propertyKey: string | symbol; name?: string }[] =
         Reflect.getMetadata('calyx:cron', instance.constructor) || [];
       for (const cron of crons) {
         const parts = cron.expression.split(' ');
@@ -1584,9 +1720,16 @@ export class CalyxApplication {
         const intervalMs = isSecondLevel ? 1000 : 20000;
         const timer = setInterval(tick, intervalMs);
         this.cleanupListeners.push(() => clearInterval(timer));
+
+        if (registry && cron.name) {
+          registry.addCronJob(cron.name, {
+            start: () => {},
+            stop: () => clearInterval(timer),
+          });
+        }
       }
 
-      const intervals: { ms: number; propertyKey: string | symbol }[] =
+      const intervals: { ms: number; propertyKey: string | symbol; name?: string }[] =
         Reflect.getMetadata('calyx:interval', instance.constructor) || [];
       for (const interval of intervals) {
         const timer = setInterval(() => {
@@ -1597,9 +1740,13 @@ export class CalyxApplication {
           }
         }, interval.ms);
         this.cleanupListeners.push(() => clearInterval(timer));
+
+        if (registry && interval.name) {
+          registry.addInterval(interval.name, timer);
+        }
       }
 
-      const timeouts: { ms: number; propertyKey: string | symbol }[] =
+      const timeouts: { ms: number; propertyKey: string | symbol; name?: string }[] =
         Reflect.getMetadata('calyx:timeout', instance.constructor) || [];
       for (const timeout of timeouts) {
         const timer = setTimeout(() => {
@@ -1610,6 +1757,10 @@ export class CalyxApplication {
           }
         }, timeout.ms);
         this.cleanupListeners.push(() => clearTimeout(timer));
+
+        if (registry && timeout.name) {
+          registry.addTimeout(timeout.name, timer);
+        }
       }
     }
   }
@@ -1635,14 +1786,24 @@ export class CalyxApplication {
       for (const sub of subMessages) {
         const paramMapping: any[] = [];
         
+        const classPipes = Reflect.getMetadata(METADATA_KEYS.PIPES, instance.constructor) || [];
+        const methodPipes = Reflect.getMetadata(METADATA_KEYS.PIPES, instance.constructor.prototype, sub.propertyKey) || [];
+        const methodPipesCompiled = this.compileLifecycleItems(this.rootModule, [...this.globalPipes, ...classPipes, ...methodPipes]);
+
         for (const bp of bodyParams) {
           if (bp.propertyKey === sub.propertyKey) {
-            paramMapping[bp.parameterIndex] = 'body';
+            paramMapping[bp.parameterIndex] = {
+              type: 'body',
+              name: bp.name,
+              pipes: [...methodPipesCompiled, ...this.compileLifecycleItems(this.rootModule, bp.pipes || [])],
+            };
           }
         }
         for (const sp of socketParams) {
           if (sp.propertyKey === sub.propertyKey) {
-            paramMapping[sp.parameterIndex] = 'socket';
+            paramMapping[sp.parameterIndex] = {
+              type: 'socket',
+            };
           }
         }
 
@@ -1654,11 +1815,16 @@ export class CalyxApplication {
         const methodInterceptors = Reflect.getMetadata(METADATA_KEYS.INTERCEPTORS, instance.constructor.prototype, sub.propertyKey) || [];
         const interceptors = this.compileLifecycleItems(this.rootModule, [...this.globalInterceptors, ...classInterceptors, ...methodInterceptors]);
 
+        const classFilters = Reflect.getMetadata(METADATA_KEYS.FILTERS, instance.constructor) || [];
+        const methodFilters = Reflect.getMetadata(METADATA_KEYS.FILTERS, instance.constructor.prototype, sub.propertyKey) || [];
+        const filters = this.compileLifecycleItems(this.rootModule, [...this.globalFilters, ...classFilters, ...methodFilters]);
+
         handlers.set(sub.event, {
           propertyKey: sub.propertyKey,
           paramMapping,
           guards,
           interceptors,
+          filters,
           gatewayClass: instance.constructor,
         });
       }
@@ -1738,16 +1904,6 @@ export class CalyxApplication {
 
       const handlerInfo = gateway.handlers.get(event);
       if (handlerInfo) {
-        const args: any[] = [];
-        for (let i = 0; i < handlerInfo.paramMapping.length; i++) {
-          const type = handlerInfo.paramMapping[i];
-          if (type === 'body') {
-            args[i] = data;
-          } else if (type === 'socket') {
-            args[i] = ws;
-          }
-        }
-
         const context = this.contextPool.acquire();
         context.resetContextWs(ws, data, handlerInfo.gatewayClass, gateway.instance[handlerInfo.propertyKey]);
 
@@ -1759,6 +1915,26 @@ export class CalyxApplication {
             }
           }
 
+          const args: any[] = [];
+          for (let i = 0; i < handlerInfo.paramMapping.length; i++) {
+            const mapping = handlerInfo.paramMapping[i];
+            if (!mapping) continue;
+            if (mapping.type === 'body') {
+              let val = mapping.name ? data?.[mapping.name] : data;
+              for (const pipe of mapping.pipes || []) {
+                const transformed = pipe.instance.transform(val, {
+                  type: 'body',
+                  metatype: undefined,
+                  data: mapping.name,
+                });
+                val = transformed instanceof Promise ? await transformed : transformed;
+              }
+              args[i] = val;
+            } else if (mapping.type === 'socket') {
+              args[i] = ws;
+            }
+          }
+
           const nextCall = {
             handle: async () => {
               return gateway.instance[handlerInfo.propertyKey](...args);
@@ -1782,7 +1958,19 @@ export class CalyxApplication {
             ws.send(JSON.stringify(result));
           }
         } catch (err: any) {
-          // ignore or log
+          if (handlerInfo.filters && handlerInfo.filters.length > 0) {
+            for (const filter of handlerInfo.filters) {
+              const catchException = Reflect.getMetadata('calyx:catch', filter.token) || [];
+              if (catchException.length === 0 || catchException.some((exc: any) => err instanceof exc)) {
+                const filterResult = filter.instance.catch(err, context);
+                if (filterResult !== undefined) {
+                  ws.send(JSON.stringify(filterResult));
+                  return;
+                }
+              }
+            }
+          }
+          ws.send(JSON.stringify({ event: 'error', data: err.message || 'Internal error' }));
         } finally {
           context.clearContext();
           this.contextPool.release(context);
@@ -1793,6 +1981,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);
+    }
   };
 }
 
@@ -82,6 +102,10 @@ export const Headers = (first?: any, ...pipes: any[]) => {
   return createHttpParamDecorator('headers', name, parsedPipes);
 };
 
+export const Ip = () => createHttpParamDecorator('ip');
+export const HostParam = (name?: string) => createHttpParamDecorator('hostparam', name);
+export const Next = () => createHttpParamDecorator('next');
+
 export function HttpCode(code: number): MethodDecorator {
   return (target, propertyKey) => {
     Reflect.defineMetadata(METADATA_KEYS.HTTP_CODE, code, target, propertyKey);

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;
+