@martel/calyx 1.11.0 → 1.12.0

package/src/cqrs/cqrs.ts

@@ -0,0 +1,175 @@
+import { Module, Injectable } from '../core/decorators.ts';
+import { Type } from '../core/metadata.ts';
+import { ModuleRef } from '../core/module-ref.ts';
+
+export interface ICommand {}
+export interface ICommandHandler<TCommand extends ICommand = any, TResult = any> {
+  execute(command: TCommand): Promise<TResult>;
+}
+
+export interface IQuery {}
+export interface IQueryHandler<TQuery extends IQuery = any, TResult = any> {
+  execute(query: TQuery): Promise<TResult>;
+}
+
+export interface IEvent {}
+export interface IEventHandler<TEvent extends IEvent = any> {
+  handle(event: TEvent): any;
+}
+
+import { METADATA_KEYS } from '../core/metadata.ts';
+
+export const COMMAND_HANDLER_METADATA = 'cqrs:command_handler';
+export const QUERY_HANDLER_METADATA = 'cqrs:query_handler';
+export const EVENT_HANDLER_METADATA = 'cqrs:event_handler';
+
+export const CommandHandler = (command: Type<ICommand>): ClassDecorator => {
+  return (target) => {
+    Reflect.defineMetadata(COMMAND_HANDLER_METADATA, command, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+};
+
+export const QueryHandler = (query: Type<IQuery>): ClassDecorator => {
+  return (target) => {
+    Reflect.defineMetadata(QUERY_HANDLER_METADATA, query, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+};
+
+export const EventsHandler = (...events: Type<IEvent>[]): ClassDecorator => {
+  return (target) => {
+    Reflect.defineMetadata(EVENT_HANDLER_METADATA, events, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+};
+
+@Injectable()
+export class CommandBus {
+  private handlers = new Map<any, ICommandHandler>();
+
+  register(command: any, handler: ICommandHandler) {
+    this.handlers.set(command, handler);
+  }
+
+  async execute<T extends ICommand, R = any>(command: T): Promise<R> {
+    const commandClass = command.constructor;
+    const handler = this.handlers.get(commandClass);
+    if (!handler) {
+      throw new Error(`CommandHandler not found for command: ${commandClass.name}`);
+    }
+    return (await handler.execute(command)) as R;
+  }
+}
+
+@Injectable()
+export class QueryBus {
+  private handlers = new Map<any, IQueryHandler>();
+
+  register(query: any, handler: IQueryHandler) {
+    this.handlers.set(query, handler);
+  }
+
+  async execute<T extends IQuery, R = any>(query: T): Promise<R> {
+    const queryClass = query.constructor;
+    const handler = this.handlers.get(queryClass);
+    if (!handler) {
+      throw new Error(`QueryHandler not found for query: ${queryClass.name}`);
+    }
+    return (await handler.execute(query)) as R;
+  }
+}
+
+@Injectable()
+export class EventBus {
+  private handlers = new Map<any, IEventHandler[]>();
+
+  register(event: any, handler: IEventHandler) {
+    const existing = this.handlers.get(event) || [];
+    existing.push(handler);
+    this.handlers.set(event, existing);
+  }
+
+  publish<T extends IEvent>(event: T) {
+    const eventClass = event.constructor;
+    const eventHandlers = this.handlers.get(eventClass) || [];
+    for (const handler of eventHandlers) {
+      try {
+        handler.handle(event);
+      } catch (err) {
+        console.error(`Error in event handler:`, err);
+      }
+    }
+  }
+}
+
+@Injectable()
+export class EventPublisher {
+  constructor(private readonly eventBus: EventBus) {}
+
+  mergeClassContext<T extends Type<any>>(metatype: T): T {
+    const eventBus = this.eventBus;
+    return class extends metatype {
+      publish(event: IEvent) {
+        eventBus.publish(event);
+      }
+      publishAll(events: IEvent[]) {
+        for (const event of events) {
+          eventBus.publish(event);
+        }
+      }
+    };
+  }
+
+  mergeObjectContext<T extends Object>(object: T): T {
+    const eventBus = this.eventBus;
+    return Object.assign(object, {
+      publish: (event: IEvent) => eventBus.publish(event),
+      publishAll: (events: IEvent[]) => {
+        for (const event of events) {
+          eventBus.publish(event);
+        }
+      },
+    });
+  }
+}
+
+@Module({
+  providers: [CommandBus, QueryBus, EventBus, EventPublisher],
+  exports: [CommandBus, QueryBus, EventBus, EventPublisher],
+})
+export class CqrsModule {
+  constructor(
+    private readonly moduleRef: ModuleRef,
+    private readonly commandBus: CommandBus,
+    private readonly queryBus: QueryBus,
+    private readonly eventBus: EventBus
+  ) {}
+
+  onModuleInit() {
+    const container = (this.moduleRef as any).container;
+    if (!container) return;
+
+    const instances = container.getProviderAndControllerInstances();
+    for (const inst of instances) {
+      if (!inst || !inst.constructor) continue;
+
+      const command = Reflect.getMetadata(COMMAND_HANDLER_METADATA, inst.constructor);
+      if (command) {
+        this.commandBus.register(command, inst);
+      }
+
+      const query = Reflect.getMetadata(QUERY_HANDLER_METADATA, inst.constructor);
+      if (query) {
+        this.queryBus.register(query, inst);
+      }
+
+      const events = Reflect.getMetadata(EVENT_HANDLER_METADATA, inst.constructor);
+      if (events && Array.isArray(events)) {
+        for (const event of events) {
+          this.eventBus.register(event, inst);
+        }
+      }
+    }
+  }
+}

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';
@@ -66,6 +67,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 {
@@ -186,7 +222,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();
@@ -685,6 +721,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 ? req.headers.get('host') : req.headers.get('host'); break;
+            case 'next': val = next; break;
             case 'custom': val = config.factory ? config.factory(config.name, context) : undefined; break;
           }
 
@@ -939,6 +979,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 ? req.headers.get('host') : req.headers.get('host');
+          break;
+        case 'next':
+          val = () => {};
+          break;
         case 'custom':
           val = config.factory ? config.factory(config.name, context!) : undefined;
           break;
@@ -1554,11 +1606,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 +1643,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 +1663,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 +1680,10 @@ export class CalyxApplication {
           }
         }, timeout.ms);
         this.cleanupListeners.push(() => clearTimeout(timer));
+
+        if (registry && timeout.name) {
+          registry.addTimeout(timeout.name, timer);
+        }
       }
     }
   }
@@ -1635,14 +1709,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 +1738,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 +1827,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 +1838,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 +1881,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);

package/src/http/decorators.ts

@@ -82,6 +82,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/index.ts

@@ -24,4 +24,6 @@ export * from './http-client/index.ts';
 export * from './session/index.ts';
 export * from './mvc/index.ts';
 export * from './sse/index.ts';
+export * from './terminus/terminus.ts';
+export * from './cqrs/cqrs.ts';
 

package/src/microservices/clients.module.ts

@@ -0,0 +1,47 @@
+import { Module, DynamicModule } from '../core/decorators.ts';
+import { ClientTcp } from './client-tcp.ts';
+
+export function Client(options: any): PropertyDecorator {
+  return (target: any, propertyKey: string | symbol) => {
+    let clientInstance: any = null;
+    Object.defineProperty(target, propertyKey, {
+      get() {
+        if (!clientInstance) {
+          clientInstance = new ClientTcp(options?.options || options || {});
+        }
+        return clientInstance;
+      },
+      configurable: true,
+      enumerable: true,
+    });
+  };
+}
+
+export interface ClientProviderConfig {
+  name: string;
+  transport?: any;
+  options?: {
+    host?: string;
+    port?: number;
+  };
+}
+
+@Module({})
+export class ClientsModule {
+  static register(clients: ClientProviderConfig[]): DynamicModule {
+    const providers = clients.map((client) => {
+      return {
+        provide: client.name,
+        useFactory: () => {
+          return new ClientTcp(client.options || {});
+        },
+      };
+    });
+
+    return {
+      module: ClientsModule,
+      providers,
+      exports: clients.map((c) => c.name),
+    };
+  }
+}

package/src/microservices/index.ts

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

package/src/microservices/microservice.ts

@@ -31,7 +31,7 @@ export class CalyxMicroservice {
   async listen(): Promise<any> {
     if (this.isListening) return;
 
-    this.container.bootstrap(this.rootModule);
+    await this.container.bootstrap(this.rootModule);
     this.server.registerHandlers(this.container, this.globalGuards, this.globalInterceptors);
 
     const hostInfo = await this.server.listen();

package/src/schedule/decorators.ts

@@ -1,28 +1,32 @@
 import 'reflect-metadata';
 
-export function Cron(expression: string): MethodDecorator {
+export function Cron(expression: string, options?: { name?: string }): MethodDecorator {
   return (target, propertyKey) => {
     const constructor = target.constructor;
     const existing = Reflect.getOwnMetadata('calyx:cron', constructor) || [];
-    existing.push({ expression, propertyKey });
+    existing.push({ expression, propertyKey, name: options?.name });
     Reflect.defineMetadata('calyx:cron', existing, constructor);
   };
 }
 
-export function Interval(ms: number): MethodDecorator {
+export function Interval(nameOrMs: string | number, ms?: number): MethodDecorator {
   return (target, propertyKey) => {
     const constructor = target.constructor;
+    const name = typeof nameOrMs === 'string' ? nameOrMs : undefined;
+    const intervalMs = typeof nameOrMs === 'number' ? nameOrMs : ms!;
     const existing = Reflect.getOwnMetadata('calyx:interval', constructor) || [];
-    existing.push({ ms, propertyKey });
+    existing.push({ ms: intervalMs, propertyKey, name });
     Reflect.defineMetadata('calyx:interval', existing, constructor);
   };
 }
 
-export function Timeout(ms: number): MethodDecorator {
+export function Timeout(nameOrMs: string | number, ms?: number): MethodDecorator {
   return (target, propertyKey) => {
     const constructor = target.constructor;
+    const name = typeof nameOrMs === 'string' ? nameOrMs : undefined;
+    const timeoutMs = typeof nameOrMs === 'number' ? nameOrMs : ms!;
     const existing = Reflect.getOwnMetadata('calyx:timeout', constructor) || [];
-    existing.push({ ms, propertyKey });
+    existing.push({ ms: timeoutMs, propertyKey, name });
     Reflect.defineMetadata('calyx:timeout', existing, constructor);
   };
 }

package/src/schedule/index.ts

@@ -1,3 +1,4 @@
 export * from './decorators.ts';
 export * from './schedule.module.ts';
+export * from './scheduler-registry.ts';
 export * from './cron.matcher.ts';

package/src/schedule/schedule.module.ts

@@ -1,12 +1,13 @@
 import { Module, DynamicModule } from '../core/decorators.ts';
+import { SchedulerRegistry } from './scheduler-registry.ts';
 
 @Module({})
 export class ScheduleModule {
   static forRoot(): DynamicModule {
     return {
       module: ScheduleModule,
-      providers: [],
-      exports: [],
+      providers: [SchedulerRegistry],
+      exports: [SchedulerRegistry],
       global: true,
     };
   }

package/src/schedule/scheduler-registry.ts

@@ -0,0 +1,50 @@
+import { Injectable } from '../core/decorators.ts';
+
+@Injectable()
+export class SchedulerRegistry {
+  private cronJobs = new Map<string, any>();
+  private intervals = new Map<string, any>();
+  private timeouts = new Map<string, any>();
+
+  // Cron
+  getCronJob(name: string) {
+    const job = this.cronJobs.get(name);
+    if (!job) throw new Error(`No Cron Job was found with the given name (${name})`);
+    return job;
+  }
+  getCronJobs(): Map<string, any> { return this.cronJobs; }
+  addCronJob(name: string, job: any) { this.cronJobs.set(name, job); }
+  deleteCronJob(name: string) {
+    const job = this.cronJobs.get(name);
+    if (job && typeof job.stop === 'function') job.stop();
+    this.cronJobs.delete(name);
+  }
+
+  // Interval
+  getInterval(name: string) {
+    const interval = this.intervals.get(name);
+    if (!interval) throw new Error(`No Interval was found with the given name (${name})`);
+    return interval;
+  }
+  getIntervals(): string[] { return Array.from(this.intervals.keys()); }
+  addInterval(name: string, intervalId: any) { this.intervals.set(name, intervalId); }
+  deleteInterval(name: string) {
+    const interval = this.intervals.get(name);
+    if (interval) clearInterval(interval);
+    this.intervals.delete(name);
+  }
+
+  // Timeout
+  getTimeout(name: string) {
+    const timeout = this.timeouts.get(name);
+    if (!timeout) throw new Error(`No Timeout was found with the given name (${name})`);
+    return timeout;
+  }
+  getTimeouts(): string[] { return Array.from(this.timeouts.keys()); }
+  addTimeout(name: string, timeoutId: any) { this.timeouts.set(name, timeoutId); }
+  deleteTimeout(name: string) {
+    const timeout = this.timeouts.get(name);
+    if (timeout) clearTimeout(timeout);
+    this.timeouts.delete(name);
+  }
+}