@martel/calyx 1.11.0 → 1.13.0

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';
@@ -24,4 +25,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/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

@@ -4,3 +4,5 @@ export * from './client-tcp.ts';
 export * from './decorators.ts';
 export * from './server-tcp.ts';
 export * from './microservice.ts';
+export * from './clients.module.ts';
+export * from './exceptions.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/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/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);
+  }
+}

package/src/security/index.ts

@@ -1,3 +1,4 @@
 export * from './hashing.service.ts';
 export * from './cors.middleware.ts';
 export * from './helmet.middleware.ts';
+export * from './throttler.module.ts';

package/src/security/throttler.module.ts

@@ -0,0 +1,108 @@
+import { Module, DynamicModule, Injectable, Inject } from '../core/decorators.ts';
+import { CanActivate, ExecutionContext } from '../lifecycle/interfaces.ts';
+import { HttpException } from '../http/exceptions.ts';
+
+export const THROTTLE_LIMIT_KEY = 'throttler:limit';
+export const THROTTLE_SKIP_KEY = 'throttler:skip';
+
+export const Throttle = (limit: number, ttl: number) => (target: any, key?: string | symbol, descriptor?: any) => {
+  if (descriptor) {
+    Reflect.defineMetadata(THROTTLE_LIMIT_KEY, { limit, ttl }, descriptor.value);
+    return descriptor;
+  }
+  Reflect.defineMetadata(THROTTLE_LIMIT_KEY, { limit, ttl }, target);
+  return target;
+};
+
+export const SkipThrottle = (skip = true) => (target: any, key?: string | symbol, descriptor?: any) => {
+  if (descriptor) {
+    Reflect.defineMetadata(THROTTLE_SKIP_KEY, skip, descriptor.value);
+    return descriptor;
+  }
+  Reflect.defineMetadata(THROTTLE_SKIP_KEY, skip, target);
+  return target;
+};
+
+export interface ThrottlerModuleOptions {
+  limit?: number;
+  ttl?: number;
+}
+
+@Injectable()
+export class ThrottlerStorage {
+  private records = new Map<string, { count: number; expiresAt: number }>();
+
+  increment(key: string, ttlSeconds: number): { count: number; expiresAt: number } {
+    const now = Date.now();
+    const record = this.records.get(key);
+    if (!record || record.expiresAt < now) {
+      const newRecord = { count: 1, expiresAt: now + ttlSeconds * 1000 };
+      this.records.set(key, newRecord);
+      return newRecord;
+    }
+    record.count++;
+    return record;
+  }
+}
+
+@Injectable()
+export class ThrottlerGuard implements CanActivate {
+  constructor(
+    @Inject('THROTTLER_OPTIONS')
+    private readonly options: ThrottlerModuleOptions,
+    private readonly storage: ThrottlerStorage
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const handler = context.getHandler();
+    const controller = context.getClass();
+
+    const skipHandler = Reflect.getMetadata(THROTTLE_SKIP_KEY, handler);
+    if (skipHandler === true) return true;
+    const skipController = Reflect.getMetadata(THROTTLE_SKIP_KEY, controller);
+    if (skipController === true) return true;
+
+    const limitMeta = Reflect.getMetadata(THROTTLE_LIMIT_KEY, handler) ||
+                      Reflect.getMetadata(THROTTLE_LIMIT_KEY, controller) ||
+                      this.options;
+
+    const limit = limitMeta.limit ?? 10;
+    const ttl = limitMeta.ttl ?? 60;
+
+    const type = context.getType();
+    if (type !== 'http') return true;
+
+    const req = context.switchToHttp().getRequest<Request>();
+    const ip = req.headers.get('x-forwarded-for') || '';
+    const url = new URL(req.url);
+    const key = `throttle::${ip}::${url.pathname}`;
+
+    const record = this.storage.increment(key, ttl);
+    if (record.count > limit) {
+      throw new HttpException({
+        statusCode: 429,
+        message: 'ThrottlerException: Too Many Requests',
+      }, 429);
+    }
+
+    return true;
+  }
+}
+
+@Module({})
+export class ThrottlerModule {
+  static register(options: ThrottlerModuleOptions = {}): DynamicModule {
+    return {
+      module: ThrottlerModule,
+      providers: [
+        {
+          provide: 'THROTTLER_OPTIONS',
+          useValue: options,
+        },
+        ThrottlerStorage,
+        ThrottlerGuard,
+      ],
+      exports: [ThrottlerStorage, ThrottlerGuard],
+    };
+  }
+}

package/src/terminus/terminus.ts

@@ -0,0 +1,134 @@
+import { Injectable, Module, SetMetadata } from '../core/decorators.ts';
+import { HttpException } from '../http/exceptions.ts';
+
+export const HEALTH_CHECK_KEY = 'terminus:healthcheck';
+export const HealthCheck = () => SetMetadata(HEALTH_CHECK_KEY, true);
+
+@Injectable()
+export class HealthCheckService {
+  async check(indicators: (() => Promise<any> | any)[]): Promise<any> {
+    const info: Record<string, any> = {};
+    const error: Record<string, any> = {};
+    let isHealthy = true;
+
+    for (const indicator of indicators) {
+      try {
+        const result = await indicator();
+        Object.assign(info, result);
+      } catch (err: any) {
+        isHealthy = false;
+        Object.assign(error, err.payload || { [err.message || 'unknown']: { status: 'down' } });
+      }
+    }
+
+    const status = isHealthy ? 'ok' : 'error';
+    const responsePayload = {
+      status,
+      info: isHealthy ? info : {},
+      error: !isHealthy ? error : {},
+      details: { ...info, ...error },
+    };
+
+    if (!isHealthy) {
+      throw new HttpException(responsePayload, 503);
+    }
+    return responsePayload;
+  }
+}
+
+@Injectable()
+export class HttpHealthIndicator {
+  async pingCheck(key: string, url: string): Promise<any> {
+    try {
+      const res = await fetch(url);
+      if (!res.ok) {
+        throw new Error(`Response status code ${res.status}`);
+      }
+      return { [key]: { status: 'up' } };
+    } catch (err: any) {
+      const payload = { [key]: { status: 'down', message: err.message } };
+      const error: any = new Error(`Health check failed for URL: ${url}`);
+      error.payload = payload;
+      throw error;
+    }
+  }
+}
+
+@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,
+    TypeOrmHealthIndicator,
+    MongooseHealthIndicator,
+    SequelizeHealthIndicator,
+    MicroserviceHealthIndicator,
+    DiskHealthIndicator,
+    MemoryHealthIndicator,
+  ],
+  exports: [
+    HealthCheckService,
+    HttpHealthIndicator,
+    TypeOrmHealthIndicator,
+    MongooseHealthIndicator,
+    SequelizeHealthIndicator,
+    MicroserviceHealthIndicator,
+    DiskHealthIndicator,
+    MemoryHealthIndicator,
+  ],
+})
+export class TerminusModule {}
+