@martel/calyx 1.5.0 → 1.7.0

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/validation/compiler.ts

@@ -0,0 +1,124 @@
+import 'reflect-metadata';
+import { ValidationRule } from './decorators.ts';
+
+export class ValidationCompiler {
+  private static readonly compiledValidators = new Map<any, (obj: any) => string[] | null>();
+
+  static compile(dtoClass: any): (obj: any) => string[] | null {
+    if (this.compiledValidators.has(dtoClass)) {
+      return this.compiledValidators.get(dtoClass)!;
+    }
+
+    const rules: ValidationRule[] = Reflect.getMetadata('calyx:validation_rules', dtoClass) || [];
+
+    const rulesByProp = new Map<string, ValidationRule[]>();
+    for (const rule of rules) {
+      let list = rulesByProp.get(rule.propertyKey);
+      if (!list) {
+        list = [];
+        rulesByProp.set(rule.propertyKey, list);
+      }
+      list.push(rule);
+    }
+
+    const codeParts: string[] = ['const errors = [];'];
+
+    for (const [prop, propRules] of rulesByProp.entries()) {
+      const isOptional = propRules.some((r) => r.type === 'optional');
+
+      const propCode: string[] = [];
+      for (const rule of propRules) {
+        if (rule.type === 'optional') continue;
+
+        if (rule.type === 'string') {
+          propCode.push(`if (typeof obj.${prop} !== 'string') errors.push('${prop} must be a string');`);
+        } else if (rule.type === 'number') {
+          propCode.push(`if (typeof obj.${prop} !== 'number' || isNaN(obj.${prop})) errors.push('${prop} must be a number');`);
+        } else if (rule.type === 'email') {
+          propCode.push(
+            `if (typeof obj.${prop} !== 'string' || !obj.${prop}.includes('@')) errors.push('${prop} must be a valid email');`
+          );
+        }
+      }
+
+      if (isOptional) {
+        codeParts.push(`if (obj.${prop} !== undefined && obj.${prop} !== null) {
+          ${propCode.join('\n')}
+        }`);
+      } else {
+        codeParts.push(`if (obj.${prop} === undefined || obj.${prop} === null) {
+          errors.push('${prop} should not be empty');
+        } else {
+          ${propCode.join('\n')}
+        }`);
+      }
+    }
+
+    codeParts.push('return errors.length > 0 ? errors : null;');
+
+    const fnBody = codeParts.join('\n');
+    try {
+      const validator = new Function('obj', fnBody) as (obj: any) => string[] | null;
+      this.compiledValidators.set(dtoClass, validator);
+      return validator;
+    } catch (err) {
+      console.error('Failed to compile validation JIT for class:', dtoClass.name || dtoClass);
+      console.error('Code body:', fnBody);
+      throw err;
+    }
+  }
+}
+
+export class SerializationCompiler {
+  private static readonly compiledSerializers = new Map<any, (obj: any) => string>();
+
+  static compile(dtoClass: any): (obj: any) => string {
+    if (this.compiledSerializers.has(dtoClass)) {
+      return this.compiledSerializers.get(dtoClass)!;
+    }
+
+    const excludes: Set<string> = Reflect.getMetadata('calyx:exclude_properties', dtoClass) || new Set();
+
+    const rules: ValidationRule[] = Reflect.getMetadata('calyx:validation_rules', dtoClass) || [];
+    const exposedKeys = new Set(rules.map((r) => r.propertyKey));
+
+    const exposes: Set<string> = Reflect.getMetadata('calyx:expose_properties', dtoClass) || new Set();
+    for (const exp of exposes) {
+      exposedKeys.add(exp);
+    }
+
+    const keys = Array.from(exposedKeys).filter((k) => !excludes.has(k));
+
+    const jsonParts: string[] = [];
+    for (const key of keys) {
+      const propRules = rules.filter((r) => r.propertyKey === key);
+      const isNumber = propRules.some((r) => r.type === 'number');
+      const isString = propRules.some((r) => r.type === 'string');
+
+      if (isNumber) {
+        jsonParts.push(`"${key}":\${obj.${key} === undefined || obj.${key} === null ? null : obj.${key}}`);
+      } else if (isString) {
+        jsonParts.push(
+          `"${key}":\${obj.${key} === undefined || obj.${key} === null ? null : JSON.stringify(obj.${key})}`
+        );
+      } else {
+        jsonParts.push(
+          `"${key}":\${obj.${key} === undefined || obj.${key} === null ? null : JSON.stringify(obj.${key})}`
+        );
+      }
+    }
+
+    const fnBody = `
+      return \`{${jsonParts.join(',')}}\`;
+    `;
+
+    try {
+      const serializer = new Function('obj', fnBody) as (obj: any) => string;
+      this.compiledSerializers.set(dtoClass, serializer);
+      return serializer;
+    } catch (err) {
+      console.error('Failed to compile JIT response serializer for class:', dtoClass.name || dtoClass);
+      throw err;
+    }
+  }
+}

package/src/validation/decorators.ts

@@ -0,0 +1,47 @@
+import 'reflect-metadata';
+
+export interface ValidationRule {
+  type: string;
+  propertyKey: string;
+  args?: any[];
+}
+
+function registerValidationRule(type: string, target: any, propertyKey: string, args?: any[]) {
+  const existing: ValidationRule[] = Reflect.getOwnMetadata('calyx:validation_rules', target.constructor) || [];
+  existing.push({ type, propertyKey, args });
+  Reflect.defineMetadata('calyx:validation_rules', existing, target.constructor);
+}
+
+export function IsString(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('string', target, String(propertyKey));
+}
+
+export function IsNumber(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('number', target, String(propertyKey));
+}
+
+export function IsOptional(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('optional', target, String(propertyKey));
+}
+
+export function IsEmail(): PropertyDecorator {
+  return (target, propertyKey) => registerValidationRule('email', target, String(propertyKey));
+}
+
+export function Expose(): PropertyDecorator {
+  return (target, propertyKey) => {
+    const constructor = target.constructor;
+    const existing = Reflect.getOwnMetadata('calyx:expose_properties', constructor) || new Set();
+    existing.add(String(propertyKey));
+    Reflect.defineMetadata('calyx:expose_properties', existing, constructor);
+  };
+}
+
+export function Exclude(): PropertyDecorator {
+  return (target, propertyKey) => {
+    const constructor = target.constructor;
+    const existing = Reflect.getOwnMetadata('calyx:exclude_properties', constructor) || new Set();
+    existing.add(String(propertyKey));
+    Reflect.defineMetadata('calyx:exclude_properties', existing, constructor);
+  };
+}

package/src/validation/index.ts

@@ -0,0 +1,3 @@
+export * from './decorators.ts';
+export * from './compiler.ts';
+export * from './pipe.ts';

package/src/validation/pipe.ts

@@ -0,0 +1,31 @@
+import { PipeTransform, ArgumentMetadata } from '../lifecycle/interfaces.ts';
+import { Injectable } from '../core/decorators.ts';
+import { HttpException } from '../http/exceptions.ts';
+import { ValidationCompiler } from './compiler.ts';
+
+@Injectable()
+export class ValidationPipe implements PipeTransform {
+  async transform(value: any, metadata: ArgumentMetadata) {
+    const metatype = metadata.metatype;
+    if (!metatype || this.toValidate(metatype)) {
+      return value;
+    }
+
+    const validate = ValidationCompiler.compile(metatype);
+    const errors = validate(value);
+    if (errors) {
+      throw new HttpException({
+        statusCode: 400,
+        message: 'Validation failed',
+        errors,
+      }, 400);
+    }
+
+    return value;
+  }
+
+  private toValidate(metatype: Function): boolean {
+    const types: Function[] = [String, Boolean, Number, Array, Object];
+    return types.includes(metatype);
+  }
+}