@martel/calyx 1.10.1 → 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

@@ -1,4 +1,4 @@
-import { CalyxContainer } from '../core/container.ts';
+import { CalyxContainer, DynamicModule } from '../core/container.ts';
 import { Module } from '../core/decorators.ts';
 import {
   GraphQLSchema,
@@ -13,17 +13,42 @@ import {
   GraphQLBoolean,
   GraphQLList,
   GraphQLNonNull,
+  buildSchema as buildGqlSchema,
 } from 'graphql';
 
+export interface GraphQLOptions {
+  typeDefs?: string;
+  context?: (ctx: { req: any }) => any | Promise<any>;
+}
+
 @Module({})
 export class GraphQLModule {
+  static forRoot(options: GraphQLOptions): DynamicModule {
+    return {
+      module: GraphQLModule,
+      providers: [
+        {
+          provide: 'calyx:graphql_options',
+          useValue: options,
+        },
+      ],
+    };
+  }
+
   static buildSchema(container: CalyxContainer): GraphQLSchema | null {
     const instances = container.getProviderAndControllerInstances();
     const resolverInstances = instances.filter(
       (inst) => inst && inst.constructor && Reflect.hasMetadata('calyx:resolver', inst.constructor)
     );
 
-    if (resolverInstances.length === 0) {
+    let options: GraphQLOptions | undefined;
+    try {
+      options = container.getGlobalOrAnyInstance('calyx:graphql_options');
+    } catch {
+      // Options provider not bound, fallback to default code-first
+    }
+
+    if (resolverInstances.length === 0 && !options?.typeDefs) {
       return null;
     }
 
@@ -98,7 +123,12 @@ export class GraphQLModule {
       // Custom Scalar
       if (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:scalar', typeClass)) {
         const scalarMeta = Reflect.getMetadata('calyx:scalar', typeClass);
-        const inst = container.get(typeClass) || new typeClass();
+        let inst: any;
+        try {
+          inst = container.getGlobalOrAnyInstance(typeClass);
+        } catch {
+          inst = new typeClass();
+        }
         const gqlScalar = new GraphQLScalarType({
           name: scalarMeta.name,
           description: Reflect.getMetadata('calyx:description', typeClass),
@@ -283,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);
             };
 
@@ -443,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);
                   };
 
@@ -480,6 +526,60 @@ export class GraphQLModule {
       }
     }
 
+    // Support Schema-First Approach if typeDefs is specified
+    if (options?.typeDefs) {
+      const schema = buildGqlSchema(options.typeDefs);
+
+      // Attach code-first resolver actions onto schema-first AST definitions
+      const queryType = schema.getQueryType();
+      if (queryType) {
+        const fields = queryType.getFields();
+        for (const [fieldName, field] of Object.entries(fields)) {
+          if (queryFields[fieldName]) {
+            field.resolve = queryFields[fieldName].resolve;
+          }
+        }
+      }
+      const mutationType = schema.getMutationType();
+      if (mutationType) {
+        const fields = mutationType.getFields();
+        for (const [fieldName, field] of Object.entries(fields)) {
+          if (mutationFields[fieldName]) {
+            field.resolve = mutationFields[fieldName].resolve;
+          }
+        }
+      }
+      const subscriptionType = schema.getSubscriptionType();
+      if (subscriptionType) {
+        const fields = subscriptionType.getFields();
+        for (const [fieldName, field] of Object.entries(fields)) {
+          if (subscriptionFields[fieldName]) {
+            field.subscribe = subscriptionFields[fieldName].subscribe;
+            field.resolve = subscriptionFields[fieldName].resolve;
+          }
+        }
+      }
+
+      // Map Custom ObjectType ResolveFields from code-first typeMap
+      for (const [typeClass, codeFirstType] of typeMap.entries()) {
+        if (codeFirstType instanceof GraphQLObjectType) {
+          const typeName = codeFirstType.name;
+          const schemaFirstType = schema.getType(typeName);
+          if (schemaFirstType instanceof GraphQLObjectType) {
+            const codeFirstFields = codeFirstType.getFields();
+            const schemaFirstFields = schemaFirstType.getFields();
+            for (const [fieldName, cfField] of Object.entries(codeFirstFields)) {
+              if (cfField.resolve && schemaFirstFields[fieldName]) {
+                schemaFirstFields[fieldName].resolve = cfField.resolve;
+              }
+            }
+          }
+        }
+      }
+
+      return schema;
+    }
+
     if (Object.keys(queryFields).length === 0) {
       return null;
     }

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;
@@ -1231,10 +1283,25 @@ export class CalyxApplication {
         this.graphqlQueryCache.set(query, document);
       }
 
+      let options: any;
+      try {
+        options = this.container.get('calyx:graphql_options');
+      } catch {}
+
+      let contextValue: any = { req };
+      if (options?.context) {
+        contextValue = await options.context({ req });
+        if (contextValue && typeof contextValue === 'object') {
+          contextValue.req = req;
+        } else {
+          contextValue = { req, ...contextValue };
+        }
+      }
+
       const result = await execute({
         schema: this.graphqlSchema,
         document,
-        contextValue: { req },
+        contextValue,
         variableValues: variables,
       });
 
@@ -1349,11 +1416,26 @@ export class CalyxApplication {
             this.graphqlQueryCache.set(query, document);
           }
 
+          let options: any;
+          try {
+            options = this.container.get('calyx:graphql_options');
+          } catch {}
+
+          let contextValue: any = { req: ws.data?.req };
+          if (options?.context) {
+            contextValue = await options.context({ req: ws.data?.req });
+            if (contextValue && typeof contextValue === 'object') {
+              contextValue.req = ws.data?.req;
+            } else {
+              contextValue = { req: ws.data?.req, ...contextValue };
+            }
+          }
+
           const subResult = await subscribe({
             schema: this.graphqlSchema,
             document,
             variableValues: variables,
-            contextValue: { req: ws.data?.req },
+            contextValue,
           });
           
           if (subResult && Symbol.asyncIterator in subResult) {
@@ -1524,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(' ');
@@ -1554,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(() => {
@@ -1567,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(() => {
@@ -1580,6 +1680,10 @@ export class CalyxApplication {
           }
         }, timeout.ms);
         this.cleanupListeners.push(() => clearTimeout(timer));
+
+        if (registry && timeout.name) {
+          registry.addTimeout(timeout.name, timer);
+        }
       }
     }
   }
@@ -1605,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',
+            };
           }
         }
 
@@ -1624,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,
         });
       }
@@ -1708,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]);
 
@@ -1729,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);
@@ -1752,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';