@martel/calyx 1.8.0 → 1.10.0

package/src/queue/queue.module.ts

@@ -0,0 +1,174 @@
+import { Module, DynamicModule, Inject } from '../core/decorators.ts';
+import { METADATA_KEYS } from '../core/metadata.ts';
+
+export interface Job<T = any> {
+  id: string;
+  name: string;
+  data: T;
+  opts?: any;
+  status: 'waiting' | 'active' | 'completed' | 'failed';
+  result?: any;
+  error?: any;
+}
+
+export const PROCESSOR_METADATA_KEY = 'calyx:processor';
+export const PROCESS_METADATA_KEY = 'calyx:process';
+
+export function Processor(queueName?: string): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata(PROCESSOR_METADATA_KEY, queueName ?? target.name, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+}
+
+export interface ProcessOptions {
+  name?: string;
+}
+
+export function Process(options?: ProcessOptions | string): MethodDecorator {
+  return (target, propertyKey) => {
+    const name = typeof options === 'string' ? options : options?.name;
+    const existing = Reflect.getMetadata(PROCESS_METADATA_KEY, target.constructor) || [];
+    existing.push({ name: name ?? '', propertyKey });
+    Reflect.defineMetadata(PROCESS_METADATA_KEY, existing, target.constructor);
+  };
+}
+
+export function InjectQueue(name: string): ParameterDecorator & PropertyDecorator {
+  return Inject(`Queue_${name}`);
+}
+
+export class QueueManager {
+  private static processors = new Map<string, { instance: any; handlers: { name: string; propertyKey: string | symbol }[] }>();
+  private static queues = new Map<string, Queue>();
+
+  static registerProcessor(queueName: string, instance: any) {
+    const handlers = Reflect.getMetadata(PROCESS_METADATA_KEY, instance.constructor) || [];
+    this.processors.set(queueName, { instance, handlers });
+  }
+
+  static getOrCreateQueue(name: string): Queue {
+    let q = this.queues.get(name);
+    if (!q) {
+      q = new Queue(name);
+      this.queues.set(name, q);
+    }
+    return q;
+  }
+
+  static async dispatch(queueName: string, job: Job) {
+    const proc = this.processors.get(queueName);
+    if (!proc) {
+      // No processor registered yet, mark job as completed (dummy/mock queue mode)
+      job.status = 'completed';
+      return;
+    }
+
+    job.status = 'active';
+    const handler = proc.handlers.find((h) => h.name === job.name || (h.name === '' && !job.name));
+    if (handler) {
+      try {
+        const res = proc.instance[handler.propertyKey](job);
+        if (res instanceof Promise) {
+          job.result = await res;
+        } else {
+          job.result = res;
+        }
+        job.status = 'completed';
+      } catch (err: any) {
+        job.error = err;
+        job.status = 'failed';
+      }
+    } else {
+      // Fallback: match any handler or first one
+      const fallback = proc.handlers[0];
+      if (fallback) {
+        try {
+          const res = proc.instance[fallback.propertyKey](job);
+          if (res instanceof Promise) {
+            job.result = await res;
+          } else {
+            job.result = res;
+          }
+          job.status = 'completed';
+        } catch (err: any) {
+          job.error = err;
+          job.status = 'failed';
+        }
+      } else {
+        job.status = 'completed';
+      }
+    }
+  }
+}
+
+export class Queue {
+  private jobs: Job[] = [];
+  private jobCounter = 0;
+
+  constructor(public readonly name: string) {}
+
+  async add<T = any>(name: string, data: T, opts?: any): Promise<Job<T>>;
+  async add<T = any>(data: T, opts?: any): Promise<Job<T>>;
+  async add<T = any>(first: any, second?: any, third?: any): Promise<Job<T>> {
+    let name = '';
+    let data: T;
+    let opts: any;
+
+    if (typeof first === 'string') {
+      name = first;
+      data = second;
+      opts = third;
+    } else {
+      data = first;
+      opts = second;
+    }
+
+    this.jobCounter++;
+    const job: Job<T> = {
+      id: `${this.name}_job_${this.jobCounter}`,
+      name,
+      data,
+      opts,
+      status: 'waiting',
+    };
+
+    this.jobs.push(job);
+
+    // Run dispatch asynchronously in the background
+    queueMicrotask(() => {
+      QueueManager.dispatch(this.name, job);
+    });
+
+    return job;
+  }
+
+  async getJobs(): Promise<Job[]> {
+    return this.jobs;
+  }
+}
+
+@Module({})
+export class QueueModule {
+  static registerQueue(...configs: { name: string }[]): DynamicModule {
+    const providers = configs.map((c) => {
+      return {
+        provide: `Queue_${c.name}`,
+        useFactory: () => {
+          return QueueManager.getOrCreateQueue(c.name);
+        },
+      };
+    });
+
+    return {
+      module: QueueModule,
+      providers,
+      exports: configs.map((c) => `Queue_${c.name}`),
+    };
+  }
+
+  // Automatic processor registration on initialization
+  onApplicationBootstrap() {
+    // Handled in CalyxApplication initialization dynamically
+  }
+}

package/src/session/index.ts

@@ -0,0 +1 @@
+export * from './session.middleware.ts';

package/src/session/session.middleware.ts

@@ -0,0 +1,82 @@
+import { createParamDecorator } from '../http/decorators.ts';
+import { formatCookie } from '../cookies/cookies.ts';
+
+export interface SessionData {
+  id: string;
+  data: Record<string, any>;
+  expiresAt: number;
+}
+
+export class MemorySessionStore {
+  private store = new Map<string, SessionData>();
+
+  get(sid: string): SessionData | undefined {
+    const session = this.store.get(sid);
+    if (!session) return undefined;
+    if (session.expiresAt < Date.now()) {
+      this.store.delete(sid);
+      return undefined;
+    }
+    return session;
+  }
+
+  set(sid: string, data: Record<string, any>, ttlSeconds: number) {
+    this.store.set(sid, {
+      id: sid,
+      data,
+      expiresAt: Date.now() + ttlSeconds * 1000,
+    });
+  }
+
+  destroy(sid: string) {
+    this.store.delete(sid);
+  }
+}
+
+export const sessionStore = new MemorySessionStore();
+
+export interface SessionOptions {
+  secret?: string;
+  name?: string;
+  ttl?: number; // TTL in seconds, default 1 day
+}
+
+export function session(options: SessionOptions = {}) {
+  const cookieName = options.name ?? 'calyx_sid';
+  const ttl = options.ttl ?? 86400; // 1 day
+
+  return (req: any, res: any, next: any) => {
+    const cookies = req.cookies || {};
+    let sid = cookies[cookieName];
+    let sessionData = sid ? sessionStore.get(sid) : undefined;
+
+    if (!sessionData) {
+      sid = crypto.randomUUID();
+      sessionData = {
+        id: sid,
+        data: {},
+        expiresAt: Date.now() + ttl * 1000,
+      };
+      sessionStore.set(sid, sessionData.data, ttl);
+    }
+
+    req.session = sessionData.data;
+
+    // Attach finalizeSession hook to request
+    req.finalizeSession = (responseHeaders: Headers) => {
+      sessionStore.set(sid, req.session, ttl);
+      responseHeaders.append('Set-Cookie', formatCookie(cookieName, sid, {
+        maxAge: ttl,
+        httpOnly: true,
+        path: '/',
+      }));
+    };
+
+    next();
+  };
+}
+
+export const Session = createParamDecorator((data, ctx) => {
+  const req = ctx.switchToHttp().getRequest();
+  return (req as any).session;
+});

package/src/sse/index.ts

@@ -0,0 +1 @@
+export * from './sse.ts';

package/src/sse/sse.ts

@@ -0,0 +1,18 @@
+import 'reflect-metadata';
+import { METADATA_KEYS } from '../core/metadata.ts';
+
+export interface MessageEvent {
+  data: string | object;
+  id?: string;
+  type?: string;
+  retry?: number;
+}
+
+export function Sse(path = ''): MethodDecorator {
+  return (target: any, propertyKey: string | symbol, descriptor: any) => {
+    // SSE routes are GET requests
+    Reflect.defineMetadata(METADATA_KEYS.HTTP_METHOD, { method: 'GET', path }, target, propertyKey);
+    Reflect.defineMetadata('calyx:sse', true, target, propertyKey);
+    return descriptor;
+  };
+}

package/src/streaming/index.ts

@@ -0,0 +1 @@
+export * from './streamable-file.ts';

package/src/streaming/streamable-file.ts

@@ -0,0 +1,32 @@
+export interface StreamableFileOptions {
+  type?: string;
+  disposition?: string;
+  length?: number;
+}
+
+export class StreamableFile {
+  constructor(
+    public readonly streamOrBuffer: any,
+    public readonly options: StreamableFileOptions = {}
+  ) {}
+
+  getStream(): any {
+    return this.streamOrBuffer;
+  }
+
+  getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {};
+    if (this.options.type) {
+      headers['content-type'] = this.options.type;
+    } else {
+      headers['content-type'] = 'application/octet-stream';
+    }
+    if (this.options.disposition) {
+      headers['content-disposition'] = this.options.disposition;
+    }
+    if (this.options.length !== undefined) {
+      headers['content-length'] = String(this.options.length);
+    }
+    return headers;
+  }
+}

package/src/validation/pipe.ts

@@ -3,25 +3,94 @@ import { Injectable } from '../core/decorators.ts';
 import { HttpException } from '../http/exceptions.ts';
 import { ValidationCompiler } from './compiler.ts';
 
+// Dynamic detection of class-validator and class-transformer
+let classValidator: any = null;
+let classTransformer: any = null;
+try {
+  require.resolve('class-validator');
+  require.resolve('class-transformer');
+  classValidator = require('class-validator');
+  classTransformer = require('class-transformer');
+} catch {
+  // ignore
+}
+
+export interface ValidationPipeOptions {
+  transform?: boolean;
+  disableErrorMessages?: boolean;
+  whitelist?: boolean;
+  forbidNonWhitelisted?: boolean;
+  groups?: string[];
+  dismissDefaultMessages?: boolean;
+  validationError?: {
+    target?: boolean;
+    value?: boolean;
+  };
+}
+
 @Injectable()
 export class ValidationPipe implements PipeTransform {
+  private transformOption: boolean;
+  private whitelistOption: boolean;
+  private forbidNonWhitelistedOption: boolean;
+
+  constructor(options: ValidationPipeOptions = {}) {
+    this.transformOption = options.transform ?? true;
+    this.whitelistOption = options.whitelist ?? false;
+    this.forbidNonWhitelistedOption = options.forbidNonWhitelisted ?? false;
+  }
+
   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);
-    }
+    if (classValidator && classTransformer) {
+      try {
+        const object = classTransformer.plainToInstance(metatype, value);
+        const errors = await classValidator.validate(object, {
+          whitelist: this.whitelistOption,
+          forbidNonWhitelisted: this.forbidNonWhitelistedOption,
+        });
+
+        if (errors.length > 0) {
+          const errorMessages = errors.flatMap((err: any) => {
+            return err.constraints ? Object.values(err.constraints) : [];
+          });
+          throw new HttpException({
+            statusCode: 400,
+            message: 'Validation failed',
+            errors: errorMessages,
+          }, 400);
+        }
 
-    return value;
+        return this.transformOption ? object : value;
+      } catch (err) {
+        // Fallback to JIT if dynamic call fails
+        const validate = ValidationCompiler.compile(metatype);
+        const errors = validate(value);
+        if (errors) {
+          throw new HttpException({
+            statusCode: 400,
+            message: 'Validation failed',
+            errors,
+          }, 400);
+        }
+        return value;
+      }
+    } else {
+      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 {

package/src/versioning/versioning.ts

@@ -0,0 +1,46 @@
+import 'reflect-metadata';
+import { SetMetadata } from '../core/decorators.ts';
+
+export enum VersioningType {
+  URI = 'uri',
+  HEADER = 'header',
+  MEDIA_TYPE = 'media-type',
+}
+
+export interface VersioningOptions {
+  type: VersioningType;
+  defaultVersion?: string | string[];
+  header?: string; // For HEADER type, e.g., 'X-API-Version'
+  key?: string;    // For MEDIA_TYPE type, e.g., 'v'
+}
+
+export const VERSION_METADATA_KEY = 'calyx:version';
+
+export function Version(version: string | string[]): MethodDecorator & ClassDecorator {
+  return (target: any, key?: string | symbol, descriptor?: any) => {
+    if (descriptor) {
+      Reflect.defineMetadata(VERSION_METADATA_KEY, version, descriptor.value);
+      return descriptor;
+    }
+    Reflect.defineMetadata(VERSION_METADATA_KEY, version, target);
+    return target;
+  };
+}
+
+export class VersionExtractor {
+  static extract(req: Request, type: VersioningType, options: VersioningOptions): string | undefined {
+    if (type === VersioningType.HEADER) {
+      const headerName = options.header ?? 'x-api-version';
+      return req.headers.get(headerName.toLowerCase()) || undefined;
+    }
+
+    if (type === VersioningType.MEDIA_TYPE) {
+      const accept = req.headers.get('accept') || '';
+      const key = options.key ?? 'v';
+      const match = accept.match(new RegExp(`${key}=([a-zA-Z0-9_-]+)`));
+      return match ? match[1] : undefined;
+    }
+
+    return undefined;
+  }
+}