@martel/calyx 1.4.0 → 1.6.0

package/src/lifecycle/context.ts

@@ -4,6 +4,10 @@ import { Type } from '../core/metadata.ts';
 export class CalyxArgumentsHost implements ArgumentsHost {
   protected req!: Request;
   protected res!: any;
+  protected type: 'http' | 'ws' | 'rpc' = 'http';
+  protected wsClient: any = null;
+  protected rpcContext: any = null;
+  protected data: any = null;
 
   constructor(req?: Request, res?: any) {
     if (req && res) {
@@ -12,16 +16,47 @@ export class CalyxArgumentsHost implements ArgumentsHost {
   }
 
   reset(req: Request, res: any) {
+    this.type = 'http';
     this.req = req;
     this.res = res;
+    this.wsClient = null;
+    this.rpcContext = null;
+    this.data = null;
+  }
+
+  resetWs(client: any, data: any) {
+    this.type = 'ws';
+    this.wsClient = client;
+    this.data = data;
+    this.req = null as any;
+    this.res = null;
+    this.rpcContext = null;
+  }
+
+  resetRpc(ctx: any, data: any) {
+    this.type = 'rpc';
+    this.rpcContext = ctx;
+    this.data = data;
+    this.req = null as any;
+    this.res = null;
+    this.wsClient = null;
   }
 
   clear() {
     this.req = null as any;
     this.res = null;
+    this.wsClient = null;
+    this.rpcContext = null;
+    this.data = null;
   }
 
   getArgs<T extends any[] = any[]>(): T {
+    if (this.type === 'ws') {
+      return [this.wsClient, this.data] as unknown as T;
+    }
+    if (this.type === 'rpc') {
+      return [this.data, this.rpcContext] as unknown as T;
+    }
     return [this.req, this.res] as unknown as T;
   }
 
@@ -36,6 +71,24 @@ export class CalyxArgumentsHost implements ArgumentsHost {
       getNext: <T = any>() => (() => {}) as unknown as T,
     };
   }
+
+  switchToWs(): any {
+    return {
+      getClient: <T = any>() => this.wsClient as T,
+      getData: <T = any>() => this.data as T,
+    };
+  }
+
+  switchToRpc(): any {
+    return {
+      getContext: <T = any>() => this.rpcContext as T,
+      getData: <T = any>() => this.data as T,
+    };
+  }
+
+  getType<TContextType extends string = string>(): TContextType {
+    return this.type as TContextType;
+  }
 }
 
 export class CalyxExecutionContext extends CalyxArgumentsHost implements ExecutionContext {
@@ -65,6 +118,28 @@ export class CalyxExecutionContext extends CalyxArgumentsHost implements Executi
     this.handlerMethod = handlerMethod;
   }
 
+  resetContextWs(
+    client: any,
+    data: any,
+    targetClass: Type<any>,
+    handlerMethod: Function
+  ) {
+    this.resetWs(client, data);
+    this.targetClass = targetClass;
+    this.handlerMethod = handlerMethod;
+  }
+
+  resetContextRpc(
+    ctx: any,
+    data: any,
+    targetClass: Type<any>,
+    handlerMethod: Function
+  ) {
+    this.resetRpc(ctx, data);
+    this.targetClass = targetClass;
+    this.handlerMethod = handlerMethod;
+  }
+
   clearContext() {
     this.clear();
     this.targetClass = null as any;

package/src/lifecycle/interfaces.ts

@@ -4,6 +4,9 @@ export interface ArgumentsHost {
   getArgs<T extends any[] = any[]>(): T;
   getArgByIndex<T = any>(index: number): T;
   switchToHttp(): HttpArgumentsHost;
+  switchToWs(): any;
+  switchToRpc(): any;
+  getType<TContextType extends string = string>(): TContextType;
 }
 
 export interface HttpArgumentsHost {

package/src/microservices/client-proxy.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+
+export abstract class ClientProxy {
+  abstract send<TResult = any, TInput = any>(pattern: any, data: TInput): Observable<TResult>;
+  abstract emit<TResult = any, TInput = any>(pattern: any, data: TInput): Observable<TResult>;
+  abstract close(): void;
+}

package/src/microservices/client-tcp.ts

@@ -0,0 +1,127 @@
+import { ClientProxy } from './client-proxy.ts';
+import { Observable } from 'rxjs';
+
+export class ClientTcp extends ClientProxy {
+  private socket: any;
+  private readonly host: string;
+  private readonly port: number;
+  private messageId = 0;
+  private pendingRequests = new Map<string, { next: (val: any) => void; error: (err: any) => void; complete: () => void }>();
+  private socketPromise: Promise<any> | null = null;
+  private buffer = '';
+
+  constructor(options: { host?: string; port?: number }) {
+    super();
+    this.host = options.host ?? '127.0.0.1';
+    this.port = options.port ?? 3000;
+  }
+
+  private async getSocket(): Promise<any> {
+    if (this.socket) return this.socket;
+    if (this.socketPromise) return this.socketPromise;
+
+    this.socketPromise = (async () => {
+      const self = this;
+      const socket = await Bun.connect({
+        hostname: this.host,
+        port: this.port,
+        socket: {
+          data(socket, data) {
+            self.handleData(data);
+          },
+          error(socket, error) {
+            self.handleError(error);
+          },
+          close(socket) {
+            self.socket = null;
+            self.socketPromise = null;
+          }
+        }
+      });
+      this.socket = socket;
+      return socket;
+    })();
+
+    return this.socketPromise;
+  }
+
+  private handleData(data: Uint8Array) {
+    this.buffer += new TextDecoder().decode(data);
+    let boundary = this.buffer.indexOf('\n');
+    while (boundary !== -1) {
+      const messageStr = this.buffer.substring(0, boundary).trim();
+      this.buffer = this.buffer.substring(boundary + 1);
+
+      if (messageStr) {
+        try {
+          const parsed = JSON.parse(messageStr);
+          const { id, response, error, isDisposed } = parsed;
+
+          const pending = this.pendingRequests.get(id);
+          if (pending) {
+            if (error) {
+              pending.error(new Error(error));
+              this.pendingRequests.delete(id);
+            } else if (isDisposed) {
+              pending.complete();
+              this.pendingRequests.delete(id);
+            } else {
+              pending.next(response);
+            }
+          }
+        } catch (err) {
+          // ignore parsing errors for partial or malformed frames
+        }
+      }
+      boundary = this.buffer.indexOf('\n');
+    }
+  }
+
+  private handleError(error: any) {
+    for (const pending of this.pendingRequests.values()) {
+      pending.error(error);
+    }
+    this.pendingRequests.clear();
+  }
+
+  send<TResult = any, TInput = any>(pattern: any, data: TInput): Observable<TResult> {
+    return new Observable<TResult>((observer) => {
+      this.messageId++;
+      const id = String(this.messageId);
+      this.pendingRequests.set(id, observer);
+
+      this.getSocket().then((socket) => {
+        const packet = JSON.stringify({ pattern, data, id }) + '\n';
+        socket.write(packet);
+      }).catch((err) => {
+        observer.error(err);
+      });
+
+      return () => {
+        this.pendingRequests.delete(id);
+      };
+    });
+  }
+
+  emit<TResult = any, TInput = any>(pattern: any, data: TInput): Observable<TResult> {
+    return new Observable<TResult>((observer) => {
+      this.getSocket().then((socket) => {
+        const packet = JSON.stringify({ pattern, data }) + '\n';
+        socket.write(packet);
+        observer.next(undefined as any);
+        observer.complete();
+      }).catch((err) => {
+        observer.error(err);
+      });
+    });
+  }
+
+  close() {
+    if (this.socket) {
+      this.socket.end();
+      this.socket = null;
+    }
+    this.socketPromise = null;
+    this.pendingRequests.clear();
+  }
+}

package/src/microservices/decorators.ts

@@ -0,0 +1,19 @@
+import 'reflect-metadata';
+
+export function MessagePattern(pattern: any): MethodDecorator {
+  return (target, propertyKey) => {
+    const constructor = target.constructor;
+    const existing = Reflect.getOwnMetadata('calyx:message_pattern', constructor) || [];
+    existing.push({ pattern, propertyKey });
+    Reflect.defineMetadata('calyx:message_pattern', existing, constructor);
+  };
+}
+
+export function EventPattern(pattern: any): MethodDecorator {
+  return (target, propertyKey) => {
+    const constructor = target.constructor;
+    const existing = Reflect.getOwnMetadata('calyx:event_pattern', constructor) || [];
+    existing.push({ pattern, propertyKey });
+    Reflect.defineMetadata('calyx:event_pattern', existing, constructor);
+  };
+}

package/src/microservices/index.ts

@@ -0,0 +1,6 @@
+export * from './interfaces.ts';
+export * from './client-proxy.ts';
+export * from './client-tcp.ts';
+export * from './decorators.ts';
+export * from './server-tcp.ts';
+export * from './microservice.ts';

package/src/microservices/interfaces.ts

@@ -0,0 +1,11 @@
+export enum Transport {
+  TCP = 0,
+}
+
+export interface MicroserviceOptions {
+  transport?: Transport;
+  options?: {
+    host?: string;
+    port?: number;
+  };
+}

package/src/microservices/microservice.ts

@@ -0,0 +1,114 @@
+import { CalyxContainer } from '../core/container.ts';
+import { ServerTcp } from './server-tcp.ts';
+import { MicroserviceOptions, Transport } from './interfaces.ts';
+
+export class CalyxMicroservice {
+  private readonly container = new CalyxContainer();
+  private readonly server: ServerTcp;
+  private isListening = false;
+  private cleanupListeners: (() => void)[] = [];
+  private readonly globalGuards: any[] = [];
+  private readonly globalInterceptors: any[] = [];
+
+  constructor(private readonly rootModule: any, options: MicroserviceOptions = {}) {
+    const transport = options.transport ?? Transport.TCP;
+    if (transport !== Transport.TCP) {
+      throw new Error(`Calyx microservice: Transport algorithm "${transport}" not supported`);
+    }
+    this.server = new ServerTcp(options.options);
+  }
+
+  useGlobalGuards(...guards: any[]) {
+    this.globalGuards.push(...guards);
+    return this;
+  }
+
+  useGlobalInterceptors(...interceptors: any[]) {
+    this.globalInterceptors.push(...interceptors);
+    return this;
+  }
+
+  async listen(): Promise<any> {
+    if (this.isListening) return;
+
+    this.container.bootstrap(this.rootModule);
+    this.server.registerHandlers(this.container, this.globalGuards, this.globalInterceptors);
+
+    const hostInfo = await this.server.listen();
+    this.isListening = true;
+
+    await this.runOnModuleInit();
+    await this.runOnApplicationBootstrap();
+
+    return hostInfo;
+  }
+
+  async close() {
+    if (!this.isListening) return;
+
+    await this.runShutdownHooks();
+
+    for (const cleanup of this.cleanupListeners) {
+      cleanup();
+    }
+    this.cleanupListeners = [];
+
+    this.server.close();
+    this.isListening = false;
+  }
+
+  enableShutdownHooks(signals: string[] = ['SIGTERM', 'SIGINT']) {
+    const handler = async (signal: string) => {
+      await this.close();
+      process.exit(0);
+    };
+
+    for (const signal of signals) {
+      const listener = () => handler(signal);
+      process.on(signal as any, listener);
+      this.cleanupListeners.push(() => {
+        process.off(signal as any, listener);
+      });
+    }
+  }
+
+  private async runOnModuleInit() {
+    const instances = this.container.getProviderAndControllerInstances();
+    for (const instance of instances) {
+      if (instance && typeof instance.onModuleInit === 'function') {
+        await instance.onModuleInit();
+      }
+    }
+  }
+
+  private async runOnApplicationBootstrap() {
+    const instances = this.container.getProviderAndControllerInstances();
+    for (const instance of instances) {
+      if (instance && typeof instance.onApplicationBootstrap === 'function') {
+        await instance.onApplicationBootstrap();
+      }
+    }
+  }
+
+  private async runShutdownHooks() {
+    const instances = this.container.getProviderAndControllerInstances();
+    
+    for (const instance of instances) {
+      if (instance && typeof instance.onModuleDestroy === 'function') {
+        await instance.onModuleDestroy();
+      }
+    }
+
+    for (const instance of instances) {
+      if (instance && typeof instance.beforeApplicationShutdown === 'function') {
+        await instance.beforeApplicationShutdown();
+      }
+    }
+
+    for (const instance of instances) {
+      if (instance && typeof instance.onApplicationShutdown === 'function') {
+        await instance.onApplicationShutdown();
+      }
+    }
+  }
+}

package/src/microservices/server-tcp.ts

@@ -0,0 +1,210 @@
+import { CalyxContainer } from '../core/container.ts';
+import { METADATA_KEYS } from '../core/metadata.ts';
+import { CalyxExecutionContext } from '../lifecycle/context.ts';
+
+export class ServerTcp {
+  private server: any;
+  private readonly host: string;
+  private readonly port: number;
+  private readonly messageHandlers = new Map<string, {
+    instance: any;
+    propertyKey: string | symbol;
+    guards: any[];
+    interceptors: any[];
+    controllerClass: any;
+  }>();
+  private readonly eventHandlers = new Map<string, { instance: any; propertyKey: string | symbol }>();
+
+  constructor(options: { host?: string; port?: number } = {}) {
+    this.host = options.host ?? '127.0.0.1';
+    this.port = options.port ?? 3000;
+  }
+
+  registerHandlers(
+    container: CalyxContainer,
+    globalGuards: any[] = [],
+    globalInterceptors: any[] = []
+  ) {
+    const instances = container.getProviderAndControllerInstances();
+    for (const instance of instances) {
+      if (!instance || !instance.constructor) continue;
+
+      const msgPatterns: { pattern: any; propertyKey: string | symbol }[] =
+        Reflect.getMetadata('calyx:message_pattern', instance.constructor) || [];
+      for (const handler of msgPatterns) {
+        const patternStr = typeof handler.pattern === 'string' ? handler.pattern : JSON.stringify(handler.pattern);
+
+        const classGuards = Reflect.getMetadata(METADATA_KEYS.GUARDS, instance.constructor) || [];
+        const methodGuards = Reflect.getMetadata(METADATA_KEYS.GUARDS, instance.constructor.prototype, handler.propertyKey) || [];
+        const guards = this.compileLifecycleItems(container, [...globalGuards, ...classGuards, ...methodGuards]);
+
+        const classInterceptors = Reflect.getMetadata(METADATA_KEYS.INTERCEPTORS, instance.constructor) || [];
+        const methodInterceptors = Reflect.getMetadata(METADATA_KEYS.INTERCEPTORS, instance.constructor.prototype, handler.propertyKey) || [];
+        const interceptors = this.compileLifecycleItems(container, [...globalInterceptors, ...classInterceptors, ...methodInterceptors]);
+
+        this.messageHandlers.set(patternStr, {
+          instance,
+          propertyKey: handler.propertyKey,
+          guards,
+          interceptors,
+          controllerClass: instance.constructor,
+        });
+      }
+
+      const eventPatterns: { pattern: any; propertyKey: string | symbol }[] =
+        Reflect.getMetadata('calyx:event_pattern', instance.constructor) || [];
+      for (const handler of eventPatterns) {
+        const patternStr = typeof handler.pattern === 'string' ? handler.pattern : JSON.stringify(handler.pattern);
+        this.eventHandlers.set(patternStr, { instance, propertyKey: handler.propertyKey });
+      }
+    }
+  }
+
+  private compileLifecycleItems(
+    container: CalyxContainer,
+    items: any[]
+  ): any[] {
+    return items.map((item) => {
+      if (typeof item === 'function') {
+        const proto = item.prototype;
+        const hasLifecycle = proto && (proto.canActivate || proto.intercept);
+        if (hasLifecycle) {
+          try {
+            return { instance: container.resolveTokenGlobally(item) };
+          } catch {
+            return { instance: new item() };
+          }
+        }
+        return { instance: { canActivate: item, intercept: item } };
+      }
+      return { instance: item };
+    });
+  }
+
+  listen(): Promise<any> {
+    const self = this;
+    return new Promise((resolve, reject) => {
+      try {
+        this.server = Bun.listen({
+          hostname: this.host,
+          port: this.port,
+          socket: {
+            data(socket, data) {
+              self.handleSocketData(socket, data);
+            },
+            error(socket, err) {
+              console.error(`Microservice socket error:`, err);
+            }
+          }
+        });
+        resolve(this.server);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  private handleSocketData(socket: any, data: Uint8Array) {
+    if (!socket.data) {
+      socket.data = { buffer: '' };
+    }
+
+    socket.data.buffer += new TextDecoder().decode(data);
+    let boundary = socket.data.buffer.indexOf('\n');
+    while (boundary !== -1) {
+      const messageStr = socket.data.buffer.substring(0, boundary).trim();
+      socket.data.buffer = socket.data.buffer.substring(boundary + 1);
+
+      if (messageStr) {
+        this.handleMessage(socket, messageStr);
+      }
+      boundary = socket.data.buffer.indexOf('\n');
+    }
+  }
+
+  private async handleMessage(socket: any, messageStr: string) {
+    try {
+      const parsed = JSON.parse(messageStr);
+      const { pattern, data, id } = parsed;
+      const patternStr = typeof pattern === 'string' ? pattern : JSON.stringify(pattern);
+
+      if (id !== undefined) {
+        const handler = this.messageHandlers.get(patternStr);
+        if (!handler) {
+          socket.write(JSON.stringify({ id, error: `Handler for pattern "${patternStr}" not found` }) + '\n');
+          return;
+        }
+
+        const context = new CalyxExecutionContext();
+        context.resetContextRpc(socket, data, handler.controllerClass, handler.instance[handler.propertyKey]);
+
+        try {
+          for (const guard of handler.guards) {
+            const canActive = await guard.instance.canActivate(context);
+            if (!canActive) {
+              throw new Error('Forbidden resource');
+            }
+          }
+
+          const nextCall = {
+            handle: async () => {
+              return handler.instance[handler.propertyKey](data);
+            }
+          };
+
+          let chain = nextCall.handle;
+          for (let i = handler.interceptors.length - 1; i >= 0; i--) {
+            const interceptor = handler.interceptors[i];
+            const currentChain = chain;
+            chain = async () => {
+              return interceptor.instance.intercept(context, {
+                handle: () => currentChain()
+              });
+            };
+          }
+
+          const result = await chain();
+          
+          if (result && typeof result.subscribe === 'function') {
+            result.subscribe({
+              next: (val: any) => {
+                socket.write(JSON.stringify({ id, response: val }) + '\n');
+              },
+              error: (err: any) => {
+                socket.write(JSON.stringify({ id, error: err.message }) + '\n');
+              },
+              complete: () => {
+                socket.write(JSON.stringify({ id, isDisposed: true }) + '\n');
+              }
+            });
+          } else {
+            socket.write(JSON.stringify({ id, response: result }) + '\n');
+            socket.write(JSON.stringify({ id, isDisposed: true }) + '\n');
+          }
+        } catch (err: any) {
+          socket.write(JSON.stringify({ id, error: err.message }) + '\n');
+        } finally {
+          context.clearContext();
+        }
+      } else {
+        const handler = this.eventHandlers.get(patternStr);
+        if (handler) {
+          try {
+            handler.instance[handler.propertyKey](data);
+          } catch (err) {
+            console.error(`Error executing EventPattern handler for pattern "${patternStr}":`, err);
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  close() {
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+    }
+  }
+}

package/src/schedule/cron.matcher.ts

@@ -0,0 +1,45 @@
+export class CronMatcher {
+  static match(pattern: string, date: Date): boolean {
+    const parts = pattern.split(' ');
+    if (parts.length < 5) return false;
+
+    const hasSeconds = parts.length === 6;
+    const sec = hasSeconds ? date.getSeconds() : 0;
+    const min = date.getMinutes();
+    const hour = date.getHours();
+    const dom = date.getDate();
+    const month = date.getMonth() + 1; // 1-12
+    const dow = date.getDay(); // 0-6 (Sunday-Saturday)
+
+    const matchPart = (part: string, val: number): boolean => {
+      if (part === '*') return true;
+      if (part.includes('/')) {
+        const [left, right] = part.split('/');
+        const step = Number(right);
+        if (left === '*') {
+          return val % step === 0;
+        }
+        const start = Number(left);
+        return val >= start && (val - start) % step === 0;
+      }
+      if (part.includes(',')) {
+        return part.split(',').map(Number).includes(val);
+      }
+      if (part.includes('-')) {
+        const [start, end] = part.split('-').map(Number);
+        return val >= start && val <= end;
+      }
+      return Number(part) === val;
+    };
+
+    if (hasSeconds && !matchPart(parts[0], sec)) return false;
+    const offset = hasSeconds ? 1 : 0;
+    if (!matchPart(parts[offset + 0], min)) return false;
+    if (!matchPart(parts[offset + 1], hour)) return false;
+    if (!matchPart(parts[offset + 2], dom)) return false;
+    if (!matchPart(parts[offset + 3], month)) return false;
+    if (!matchPart(parts[offset + 4], dow)) return false;
+
+    return true;
+  }
+}

package/src/schedule/decorators.ts

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

package/src/schedule/index.ts

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