@martel/calyx 0.1.0

package/src/http/application.ts

@@ -0,0 +1,588 @@
+import { calyxContainer } from '../core/container.ts';
+import { METADATA_KEYS } from '../core/metadata.ts';
+import { RadixRouter } from './router.ts';
+import { ParameterConfig } from './decorators.ts';
+import { HttpException, NotFoundException } from './exceptions.ts';
+import { ArgumentsHost, ExecutionContext } from '../lifecycle/interfaces.ts';
+import { calyxArgumentsHost, calyxExecutionContext } from '../lifecycle/context.ts';
+
+export class calyxResponse {
+  statusCode = 200;
+  headers = new Headers();
+  body: any = null;
+  sent = false;
+
+  status(code: number) {
+    this.statusCode = code;
+    return this;
+  }
+
+  send(body: any) {
+    this.body = body;
+    this.sent = true;
+    return this;
+  }
+
+  json(body: any) {
+    this.headers.set('content-type', 'application/json');
+    this.body = JSON.stringify(body);
+    this.sent = true;
+    return this;
+  }
+
+  set(name: string, value: string) {
+    this.headers.set(name, value);
+    return this;
+  }
+}
+
+interface HandlerConfig {
+  instance: any;
+  methodName: string;
+  paramsConfig: ParameterConfig[];
+  httpCode?: number;
+  headers: { name: string; value: string }[];
+  redirect?: { url: string; statusCode?: number };
+  hasBodyParam: boolean;
+  hasQueryParam: boolean;
+  hasResParam: boolean;
+  hasLifecycleMetadata: boolean;
+}
+
+export class calyxApplication {
+  private container = new calyxContainer();
+  private router = new RadixRouter<HandlerConfig>();
+  private server: any;
+
+  private globalGuards: any[] = [];
+  private globalInterceptors: any[] = [];
+  private globalPipes: any[] = [];
+  private globalFilters: any[] = [];
+
+  useGlobalGuards(...guards: any[]) {
+    this.globalGuards.push(...guards);
+  }
+
+  useGlobalInterceptors(...interceptors: any[]) {
+    this.globalInterceptors.push(...interceptors);
+  }
+
+  useGlobalPipes(...pipes: any[]) {
+    this.globalPipes.push(...pipes);
+  }
+
+  useGlobalFilters(...filters: any[]) {
+    this.globalFilters.push(...filters);
+  }
+
+  constructor(private rootModule: any) {}
+
+  async init() {
+    // Bootstrap the dependency injection container
+    this.container.bootstrap(this.rootModule);
+
+    // Build the routing table from registered controllers
+    this.buildRoutes();
+  }
+
+  private buildRoutes() {
+    const modules = this.container.getModules();
+    for (const [moduleClass, record] of modules.entries()) {
+      for (const controllerClass of record.controllers) {
+        const prefix = Reflect.getMetadata(METADATA_KEYS.CONTROLLER, controllerClass) ?? '';
+        const instance = record.instances.get(controllerClass);
+        if (!instance) continue;
+
+        const methods = this.getMethods(controllerClass.prototype);
+        for (const method of methods) {
+          const routeMeta = Reflect.getMetadata(METADATA_KEYS.HTTP_METHOD, controllerClass.prototype, method);
+          if (!routeMeta) continue;
+
+          // Normalize prefix and path
+          const normalizedPrefix = prefix.replace(/^\/|\/$/g, '');
+          const normalizedPath = routeMeta.path.replace(/^\/|\/$/g, '');
+          const fullPath = '/' + [normalizedPrefix, normalizedPath].filter(Boolean).join('/');
+
+          const paramsConfig: ParameterConfig[] = Reflect.getMetadata(METADATA_KEYS.HTTP_PARAMS, controllerClass.prototype, method) || [];
+          // Sort parameters by index ascending so they map correctly to function arguments
+          paramsConfig.sort((a, b) => a.index - b.index);
+
+          const httpCode = Reflect.getMetadata(METADATA_KEYS.HTTP_CODE, controllerClass.prototype, method);
+          const headers = Reflect.getMetadata(METADATA_KEYS.HTTP_HEADERS, controllerClass.prototype, method) || [];
+          const redirect = Reflect.getMetadata(METADATA_KEYS.REDIRECT, controllerClass.prototype, method);
+
+          const hasBodyParam = paramsConfig.some((p) => p.type === 'body');
+          const hasQueryParam = paramsConfig.some((p) => p.type === 'query');
+          const hasResParam = paramsConfig.some((p) => p.type === 'res');
+
+          const hasLifecycleMetadata =
+            Reflect.hasMetadata(METADATA_KEYS.GUARDS, controllerClass) ||
+            Reflect.hasMetadata(METADATA_KEYS.GUARDS, controllerClass.prototype, method) ||
+            Reflect.hasMetadata(METADATA_KEYS.INTERCEPTORS, controllerClass) ||
+            Reflect.hasMetadata(METADATA_KEYS.INTERCEPTORS, controllerClass.prototype, method) ||
+            Reflect.hasMetadata(METADATA_KEYS.PIPES, controllerClass) ||
+            Reflect.hasMetadata(METADATA_KEYS.PIPES, controllerClass.prototype, method) ||
+            Reflect.hasMetadata(METADATA_KEYS.FILTERS, controllerClass) ||
+            Reflect.hasMetadata(METADATA_KEYS.FILTERS, controllerClass.prototype, method) ||
+            paramsConfig.some((p) => p.pipes && p.pipes.length > 0);
+
+          this.router.insert(routeMeta.method, fullPath, {
+            instance,
+            methodName: method,
+            paramsConfig,
+            httpCode,
+            headers,
+            redirect,
+            hasBodyParam,
+            hasQueryParam,
+            hasResParam,
+            hasLifecycleMetadata,
+          });
+        }
+      }
+    }
+  }
+
+  private getMethods(obj: any): string[] {
+    const properties = new Set<string>();
+    let currentObj = obj;
+    while (currentObj && currentObj !== Object.prototype) {
+      Object.getOwnPropertyNames(currentObj).forEach((item) => properties.add(item));
+      currentObj = Object.getPrototypeOf(currentObj);
+    }
+    return Array.from(properties).filter((item) => typeof obj[item] === 'function' && item !== 'constructor');
+  }
+
+  private hasGlobalLifecycle(): boolean {
+    return (
+      this.globalGuards.length > 0 ||
+      this.globalInterceptors.length > 0 ||
+      this.globalPipes.length > 0 ||
+      this.globalFilters.length > 0
+    );
+  }
+
+  private handleRequest(req: Request): Response | Promise<Response> {
+    try {
+      const urlStr = req.url;
+      // Fast path parsing
+      let pathname = '/';
+      let search = '';
+      const protoIdx = urlStr.indexOf('://');
+      if (protoIdx !== -1) {
+        const slashIdx = urlStr.indexOf('/', protoIdx + 3);
+        if (slashIdx !== -1) {
+          pathname = urlStr.substring(slashIdx);
+        }
+      }
+      const queryIdx = pathname.indexOf('?');
+      if (queryIdx !== -1) {
+        search = pathname.substring(queryIdx);
+        pathname = pathname.substring(0, queryIdx);
+      }
+
+      const matched = this.router.match(req.method, pathname);
+      if (!matched) {
+        throw new NotFoundException(`Cannot ${req.method} ${pathname}`);
+      }
+
+      const { handler, params } = matched;
+
+      // Check if we need to run lifecycle hooks
+      const hasLifecycle = handler.hasLifecycleMetadata || this.hasGlobalLifecycle();
+      if (hasLifecycle) {
+        if (handler.hasBodyParam && req.body && req.method !== 'GET' && req.method !== 'HEAD') {
+          return this.handleRequestPipelineAsync(req, handler, params, search);
+        }
+        return this.handleRequestPipeline(req, handler, params, search, null);
+      }
+
+      // Check if we need to parse body (which makes it async)
+      if (handler.hasBodyParam && req.body && req.method !== 'GET' && req.method !== 'HEAD') {
+        return this.handleRequestAsync(req, handler, params, search);
+      }
+
+      return this.executeHandlerSync(req, handler, params, search, null);
+    } catch (err: any) {
+      return this.handleError(err);
+    }
+  }
+
+  private async handleRequestPipelineAsync(
+    req: Request,
+    handler: HandlerConfig,
+    params: Record<string, string>,
+    search: string
+  ): Promise<Response> {
+    try {
+      let body: any = null;
+      const contentType = req.headers.get('content-type') || '';
+      if (contentType.includes('application/json')) {
+        try {
+          body = await req.json();
+        } catch {
+          body = {};
+        }
+      } else if (contentType.includes('application/x-www-form-urlencoded')) {
+        try {
+          const text = await req.text();
+          body = Object.fromEntries(new URLSearchParams(text).entries());
+        } catch {
+          body = {};
+        }
+      } else {
+        try {
+          body = await req.text();
+        } catch {
+          body = null;
+        }
+      }
+
+      return this.handleRequestPipeline(req, handler, params, search, body);
+    } catch (err: any) {
+      const resWrapper = new calyxResponse();
+      const host = new calyxArgumentsHost(req, resWrapper);
+      return this.handleLifecycleError(err, host, handler.instance.constructor, handler.methodName);
+    }
+  }
+
+  private async handleRequestPipeline(
+    req: Request,
+    handler: HandlerConfig,
+    params: Record<string, string>,
+    search: string,
+    body: any
+  ): Promise<Response> {
+    const { instance, methodName, paramsConfig, httpCode, headers, redirect, hasQueryParam, hasResParam } = handler;
+    const controllerClass = instance.constructor;
+    const moduleClass = this.getControllerModule(controllerClass);
+    const resWrapper = new calyxResponse();
+    const host = new calyxArgumentsHost(req, resWrapper);
+    const context = new calyxExecutionContext(req, resWrapper, controllerClass, instance[methodName]);
+
+    try {
+      // 1. Run Guards
+      const classGuards = Reflect.getMetadata(METADATA_KEYS.GUARDS, controllerClass) || [];
+      const methodGuards = Reflect.getMetadata(METADATA_KEYS.GUARDS, controllerClass.prototype, methodName) || [];
+      const guards = [...this.globalGuards, ...classGuards, ...methodGuards];
+
+      for (const guard of guards) {
+        const guardInstance = this.resolveLifecycleInstance(moduleClass, guard);
+        const canActivate = await guardInstance.canActivate(context);
+        if (!canActivate) {
+          throw new HttpException('Forbidden resource', 403);
+        }
+      }
+
+      // 2. Run Interceptors & Pipes & Handler
+      const classInterceptors = Reflect.getMetadata(METADATA_KEYS.INTERCEPTORS, controllerClass) || [];
+      const methodInterceptors = Reflect.getMetadata(METADATA_KEYS.INTERCEPTORS, controllerClass.prototype, methodName) || [];
+      const interceptors = [...this.globalInterceptors, ...classInterceptors, ...methodInterceptors];
+
+      let query: any = null;
+      if (hasQueryParam && search) {
+        query = Object.fromEntries(new URLSearchParams(search).entries());
+      } else if (hasQueryParam) {
+        query = {};
+      }
+
+      const paramTypes = Reflect.getMetadata('design:paramtypes', controllerClass.prototype, methodName) || [];
+
+      // Execute pipes for each argument
+      const args: any[] = [];
+      for (const config of paramsConfig) {
+        let val: any;
+        switch (config.type) {
+          case 'req':
+            val = req;
+            break;
+          case 'res':
+            val = resWrapper;
+            break;
+          case 'param':
+            val = config.name ? params[config.name] : params;
+            break;
+          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;
+        }
+
+        // Apply pipes
+        const classPipes = Reflect.getMetadata(METADATA_KEYS.PIPES, controllerClass) || [];
+        const methodPipes = Reflect.getMetadata(METADATA_KEYS.PIPES, controllerClass.prototype, methodName) || [];
+        const paramPipes = config.pipes || [];
+        const pipes = [...this.globalPipes, ...classPipes, ...methodPipes, ...paramPipes];
+
+        for (const pipe of pipes) {
+          const pipeInstance = this.resolveLifecycleInstance(moduleClass, pipe);
+          val = await pipeInstance.transform(val, {
+            type: config.type,
+            metatype: paramTypes[config.index],
+            data: config.name,
+          });
+        }
+
+        args[config.index] = val;
+      }
+
+      let interceptorIndex = 0;
+      const executeHandler = async (): Promise<any> => {
+        if (interceptorIndex < interceptors.length) {
+          const interceptor = interceptors[interceptorIndex++];
+          const interceptorInstance = this.resolveLifecycleInstance(moduleClass, interceptor);
+          return interceptorInstance.intercept(context, { handle: () => executeHandler() });
+        }
+        return instance[methodName](...args);
+      };
+
+      const result = await executeHandler();
+
+      return this.processResult(req, result, resWrapper, httpCode, headers, redirect);
+    } catch (err: any) {
+      return this.handleLifecycleError(err, host, controllerClass, methodName);
+    }
+  }
+
+  private async handleLifecycleError(
+    err: any,
+    host: ArgumentsHost,
+    controllerClass: any,
+    methodName: string
+  ): Promise<Response> {
+    const classFilters = Reflect.getMetadata(METADATA_KEYS.FILTERS, controllerClass) || [];
+    const methodFilters = Reflect.getMetadata(METADATA_KEYS.FILTERS, controllerClass.prototype, methodName) || [];
+    const filters = [...this.globalFilters, ...classFilters, ...methodFilters];
+
+    const moduleClass = this.getControllerModule(controllerClass);
+
+    for (const filter of filters) {
+      const filterInstance = this.resolveLifecycleInstance(moduleClass, filter);
+      const catchExceptions = Reflect.getMetadata(METADATA_KEYS.CATCH, filterInstance.constructor) || [];
+
+      const catchesException =
+        catchExceptions.length === 0 ||
+        catchExceptions.some((excClass: any) => err instanceof excClass);
+
+      if (catchesException) {
+        await filterInstance.catch(err, host);
+        const resWrapper = host.switchToHttp().getResponse<calyxResponse>();
+        if (resWrapper.sent) {
+          return new Response(resWrapper.body, {
+            status: resWrapper.statusCode,
+            headers: resWrapper.headers,
+          });
+        }
+      }
+    }
+
+    return this.handleError(err);
+  }
+
+  private getControllerModule(controllerClass: any): any {
+    const modules = this.container.getModules();
+    for (const [moduleClass, record] of modules.entries()) {
+      if (record.controllers.has(controllerClass)) {
+        return moduleClass;
+      }
+    }
+    return null;
+  }
+
+  private resolveLifecycleInstance(moduleClass: any, item: any): any {
+    if (typeof item === 'function') {
+      try {
+        return this.container.resolveTokenInModuleContext(moduleClass, item);
+      } catch {
+        return new item();
+      }
+    }
+    return item;
+  }
+
+  private async handleRequestAsync(
+    req: Request,
+    handler: HandlerConfig,
+    params: Record<string, string>,
+    search: string
+  ): Promise<Response> {
+    try {
+      let body: any = null;
+      const contentType = req.headers.get('content-type') || '';
+      if (contentType.includes('application/json')) {
+        try {
+          body = await req.json();
+        } catch {
+          body = {};
+        }
+      } else if (contentType.includes('application/x-www-form-urlencoded')) {
+        try {
+          const text = await req.text();
+          body = Object.fromEntries(new URLSearchParams(text).entries());
+        } catch {
+          body = {};
+        }
+      } else {
+        try {
+          body = await req.text();
+        } catch {
+          body = null;
+        }
+      }
+
+      return this.executeHandlerSync(req, handler, params, search, body);
+    } catch (err: any) {
+      return this.handleError(err);
+    }
+  }
+
+  private executeHandlerSync(
+    req: Request,
+    handler: HandlerConfig,
+    params: Record<string, string>,
+    search: string,
+    body: any
+  ): Response | Promise<Response> {
+    const { instance, methodName, paramsConfig, httpCode, headers, redirect, hasQueryParam, hasResParam } = handler;
+
+    // Parse query on-demand
+    let query: any = null;
+    if (hasQueryParam && search) {
+      query = Object.fromEntries(new URLSearchParams(search).entries());
+    } else if (hasQueryParam) {
+      query = {};
+    }
+
+    const resWrapper = hasResParam ? new calyxResponse() : null;
+    const args: any[] = [];
+
+    for (const config of paramsConfig) {
+      let val: any;
+      switch (config.type) {
+        case 'req':
+          val = req;
+          break;
+        case 'res':
+          val = resWrapper;
+          break;
+        case 'param':
+          val = config.name ? params[config.name] : params;
+          break;
+        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;
+      }
+      args[config.index] = val;
+    }
+
+    const result = instance[methodName](...args);
+
+    if (result instanceof Promise) {
+      return result.then((resolvedResult) => this.processResult(req, resolvedResult, resWrapper, httpCode, headers, redirect));
+    }
+
+    return this.processResult(req, result, resWrapper, httpCode, headers, redirect);
+  }
+
+  private processResult(
+    req: Request,
+    result: any,
+    resWrapper: calyxResponse | null,
+    httpCode: number | undefined,
+    headers: { name: string; value: string }[],
+    redirect: { url: string; statusCode?: number } | undefined
+  ): Response {
+    if (redirect) {
+      return Response.redirect(redirect.url, redirect.statusCode || 302);
+    }
+
+    if (resWrapper?.sent) {
+      return new Response(resWrapper.body, {
+        status: resWrapper.statusCode,
+        headers: resWrapper.headers,
+      });
+    }
+
+    const status = httpCode ?? (req.method === 'POST' ? 201 : 200);
+
+    // Build headers only if we have custom headers or content-type requirements
+    let responseHeaders: Headers | undefined = undefined;
+    if (headers.length > 0) {
+      responseHeaders = new Headers();
+      for (const header of headers) {
+        responseHeaders.set(header.name, header.value);
+      }
+    }
+
+    if (result === undefined || result === null) {
+      return new Response(null, { status, headers: responseHeaders });
+    }
+
+    if (result instanceof Response) {
+      return result;
+    }
+
+    if (typeof result === 'object') {
+      if (responseHeaders) {
+        responseHeaders.set('content-type', 'application/json');
+        return new Response(JSON.stringify(result), { status, headers: responseHeaders });
+      }
+      return Response.json(result, { status });
+    }
+
+    if (responseHeaders) {
+      return new Response(String(result), { status, headers: responseHeaders });
+    }
+    return new Response(String(result), { status });
+  }
+
+  private handleError(err: any): Response {
+    if (err instanceof HttpException) {
+      const response = err.getResponse();
+      const status = err.getStatus();
+      const body = typeof response === 'object' ? JSON.stringify(response) : JSON.stringify({ statusCode: status, message: response });
+      return new Response(body, {
+        status,
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+
+    console.error(err);
+    return new Response(
+      JSON.stringify({
+        statusCode: 500,
+        message: 'Internal server error',
+      }),
+      {
+        status: 500,
+        headers: { 'content-type': 'application/json' },
+      }
+    );
+  }
+
+  async listen(port: number): Promise<any> {
+    await this.init();
+    this.server = Bun.serve({
+      port,
+      fetch: (req) => this.handleRequest(req),
+    });
+    return this.server;
+  }
+
+  async close() {
+    if (this.server) {
+      this.server.stop();
+    }
+  }
+}

package/src/http/decorators.ts

@@ -0,0 +1,103 @@
+import 'reflect-metadata';
+import { METADATA_KEYS } from '../core/metadata.ts';
+
+export function Controller(prefix = ''): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEYS.CONTROLLER, prefix, target);
+  };
+}
+
+function createRouteDecorator(method: string) {
+  return (path = ''): MethodDecorator => {
+    return (target, propertyKey) => {
+      Reflect.defineMetadata(METADATA_KEYS.HTTP_METHOD, { method, path }, target, propertyKey);
+    };
+  };
+}
+
+export const Get = createRouteDecorator('GET');
+export const Post = createRouteDecorator('POST');
+export const Put = createRouteDecorator('PUT');
+export const Delete = createRouteDecorator('DELETE');
+export const Patch = createRouteDecorator('PATCH');
+export const Options = createRouteDecorator('OPTIONS');
+export const Head = createRouteDecorator('HEAD');
+export const All = createRouteDecorator('ALL');
+
+export interface ParameterConfig {
+  index: number;
+  type: 'req' | 'res' | 'param' | 'query' | 'body' | 'headers';
+  name?: string;
+  pipes?: any[];
+}
+
+function createParamDecorator(type: ParameterConfig['type'], name?: string, pipes: any[] = []): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey) return;
+    const existingParams: ParameterConfig[] =
+      Reflect.getOwnMetadata(METADATA_KEYS.HTTP_PARAMS, target, propertyKey) || [];
+    existingParams.push({ index: parameterIndex, type, name, pipes });
+    Reflect.defineMetadata(METADATA_KEYS.HTTP_PARAMS, existingParams, target, propertyKey);
+  };
+}
+
+function parseParamArgs(first?: any, ...rest: any[]) {
+  let name: string | undefined = undefined;
+  let pipes: any[] = [];
+
+  if (typeof first === 'string') {
+    name = first;
+    pipes = rest;
+  } else if (first !== undefined) {
+    pipes = [first, ...rest];
+  }
+
+  return { name, pipes };
+}
+
+export const Req = () => createParamDecorator('req');
+export const Request = Req;
+
+export const Res = () => createParamDecorator('res');
+export const Response = Res;
+
+export const Param = (first?: any, ...pipes: any[]) => {
+  const { name, pipes: parsedPipes } = parseParamArgs(first, ...pipes);
+  return createParamDecorator('param', name, parsedPipes);
+};
+
+export const Query = (first?: any, ...pipes: any[]) => {
+  const { name, pipes: parsedPipes } = parseParamArgs(first, ...pipes);
+  return createParamDecorator('query', name, parsedPipes);
+};
+
+export const Body = (first?: any, ...pipes: any[]) => {
+  const { name, pipes: parsedPipes } = parseParamArgs(first, ...pipes);
+  return createParamDecorator('body', name, parsedPipes);
+};
+
+export const Headers = (first?: any, ...pipes: any[]) => {
+  const { name, pipes: parsedPipes } = parseParamArgs(first, ...pipes);
+  return createParamDecorator('headers', name, parsedPipes);
+};
+
+export function HttpCode(code: number): MethodDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(METADATA_KEYS.HTTP_CODE, code, target, propertyKey);
+  };
+}
+
+export function Header(name: string, value: string): MethodDecorator {
+  return (target, propertyKey) => {
+    const existingHeaders: { name: string; value: string }[] =
+      Reflect.getOwnMetadata(METADATA_KEYS.HTTP_HEADERS, target, propertyKey) || [];
+    existingHeaders.push({ name, value });
+    Reflect.defineMetadata(METADATA_KEYS.HTTP_HEADERS, existingHeaders, target, propertyKey);
+  };
+}
+
+export function Redirect(url: string, statusCode = 302): MethodDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(METADATA_KEYS.REDIRECT, { url, statusCode }, target, propertyKey);
+  };
+}