@martel/calyx 1.8.0 → 1.10.0

package/src/http-client/http-client.module.ts

@@ -0,0 +1,124 @@
+import { Observable } from 'rxjs';
+import { Module, DynamicModule, Injectable } from '../core/decorators.ts';
+
+export interface AxiosResponse<T = any> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: any;
+  config: any;
+  request?: any;
+}
+
+@Injectable()
+export class HttpService {
+  request<T = any>(config: any): Observable<AxiosResponse<T>> {
+    return new Observable((subscriber) => {
+      const controller = new AbortController();
+      const { url, method = 'GET', data, headers, ...rest } = config;
+
+      const options: RequestInit = {
+        method,
+        headers,
+        signal: controller.signal,
+        ...rest,
+      };
+
+      if (data !== undefined) {
+        if (typeof data === 'object') {
+          options.body = JSON.stringify(data);
+          options.headers = { 'content-type': 'application/json', ...options.headers };
+        } else {
+          options.body = data;
+        }
+      }
+
+      fetch(url, options)
+        .then(async (res) => {
+          let responseData: any;
+          const contentType = res.headers.get('content-type') || '';
+          if (contentType.includes('application/json')) {
+            try {
+              responseData = await res.json();
+            } catch {
+              responseData = {};
+            }
+          } else {
+            try {
+              responseData = await res.text();
+            } catch {
+              responseData = '';
+            }
+          }
+
+          const headersObj: Record<string, string> = {};
+          res.headers.forEach((val, key) => {
+            headersObj[key] = val;
+          });
+
+          subscriber.next({
+            data: responseData,
+            status: res.status,
+            statusText: res.statusText,
+            headers: headersObj,
+            config,
+          });
+          subscriber.complete();
+        })
+        .catch((err) => {
+          subscriber.error(err);
+        });
+
+      return () => {
+        controller.abort();
+      };
+    });
+  }
+
+  get<T = any>(url: string, config?: any): Observable<AxiosResponse<T>> {
+    return this.request({ ...config, url, method: 'GET' });
+  }
+
+  post<T = any>(url: string, data?: any, config?: any): Observable<AxiosResponse<T>> {
+    return this.request({ ...config, url, data, method: 'POST' });
+  }
+
+  put<T = any>(url: string, data?: any, config?: any): Observable<AxiosResponse<T>> {
+    return this.request({ ...config, url, data, method: 'PUT' });
+  }
+
+  delete<T = any>(url: string, config?: any): Observable<AxiosResponse<T>> {
+    return this.request({ ...config, url, method: 'DELETE' });
+  }
+
+  patch<T = any>(url: string, data?: any, config?: any): Observable<AxiosResponse<T>> {
+    return this.request({ ...config, url, data, method: 'PATCH' });
+  }
+
+  head<T = any>(url: string, config?: any): Observable<AxiosResponse<T>> {
+    return this.request({ ...config, url, method: 'HEAD' });
+  }
+
+  options<T = any>(url: string, config?: any): Observable<AxiosResponse<T>> {
+    return this.request({ ...config, url, method: 'OPTIONS' });
+  }
+}
+
+@Module({
+  providers: [HttpService],
+  exports: [HttpService],
+})
+export class HttpModule {
+  static register(options: any = {}): DynamicModule {
+    return {
+      module: HttpModule,
+      providers: [
+        {
+          provide: HttpService,
+          useValue: new HttpService(),
+        },
+      ],
+      exports: [HttpService],
+    };
+  }
+}

package/src/http-client/index.ts

@@ -0,0 +1 @@
+export * from './http-client.module.ts';

package/src/index.ts

@@ -11,3 +11,17 @@ export * from './microservices/index.ts';
 export * from './cache/index.ts';
 export * from './validation/index.ts';
 export * from './openapi/index.ts';
+export * from './database/typeorm.module.ts';
+export * from './database/mongoose.module.ts';
+export * from './versioning/versioning.ts';
+export * from './queue/queue.module.ts';
+export * from './logger/index.ts';
+export * from './cookies/cookies.ts';
+export * from './compression/compression.middleware.ts';
+export * from './file-upload/index.ts';
+export * from './streaming/index.ts';
+export * from './http-client/index.ts';
+export * from './session/index.ts';
+export * from './mvc/index.ts';
+export * from './sse/index.ts';
+

package/src/logger/index.ts

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

package/src/logger/logger.service.ts

@@ -0,0 +1,118 @@
+import { Injectable } from '../core/decorators.ts';
+
+export interface LoggerService {
+  log(message: any, context?: string): any;
+  error(message: any, trace?: string, context?: string): any;
+  warn(message: any, context?: string): any;
+  debug?(message: any, context?: string): any;
+  verbose?(message: any, context?: string): any;
+}
+
+export type LogLevel = 'log' | 'error' | 'warn' | 'debug' | 'verbose';
+
+@Injectable()
+export class Logger implements LoggerService {
+  private static instance: LoggerService | null = null;
+  private static levels: Set<LogLevel> = new Set(['log', 'error', 'warn']);
+
+  constructor(private context?: string) {}
+
+  static overrideLogger(logger: LoggerService | null) {
+    this.instance = logger;
+  }
+
+  static setLogLevels(levels: LogLevel[]) {
+    this.levels = new Set(levels);
+  }
+
+  log(message: any, context?: string) {
+    const activeContext = context ?? this.context;
+    if (Logger.instance) {
+      Logger.instance.log(message, activeContext);
+      return;
+    }
+    if (!Logger.levels.has('log')) return;
+    this.print('LOG', message, activeContext);
+  }
+
+  error(message: any, trace?: string, context?: string) {
+    const activeContext = context ?? this.context;
+    if (Logger.instance) {
+      Logger.instance.error(message, trace, activeContext);
+      return;
+    }
+    if (!Logger.levels.has('error')) return;
+    this.print('ERROR', message, activeContext, trace);
+  }
+
+  warn(message: any, context?: string) {
+    const activeContext = context ?? this.context;
+    if (Logger.instance) {
+      Logger.instance.warn(message, activeContext);
+      return;
+    }
+    if (!Logger.levels.has('warn')) return;
+    this.print('WARN', message, activeContext);
+  }
+
+  debug(message: any, context?: string) {
+    const activeContext = context ?? this.context;
+    if (Logger.instance) {
+      Logger.instance.debug?.(message, activeContext);
+      return;
+    }
+    if (!Logger.levels.has('debug')) return;
+    this.print('DEBUG', message, activeContext);
+  }
+
+  verbose(message: any, context?: string) {
+    const activeContext = context ?? this.context;
+    if (Logger.instance) {
+      Logger.instance.verbose?.(message, activeContext);
+      return;
+    }
+    if (!Logger.levels.has('verbose')) return;
+    this.print('VERBOSE', message, activeContext);
+  }
+
+  // Static methods
+  static log(message: any, context?: string) {
+    new Logger(context).log(message);
+  }
+
+  static error(message: any, trace?: string, context?: string) {
+    new Logger(context).error(message, trace);
+  }
+
+  static warn(message: any, context?: string) {
+    new Logger(context).warn(message);
+  }
+
+  static debug(message: any, context?: string) {
+    new Logger(context).debug(message);
+  }
+
+  static verbose(message: any, context?: string) {
+    new Logger(context).verbose(message);
+  }
+
+  private print(level: string, message: any, context?: string, trace?: string) {
+    const timestamp = new Date().toISOString();
+    const formattedContext = context ? ` [${context}]` : '';
+    const formattedTrace = trace ? `\n${trace}` : '';
+    const msgStr = typeof message === 'object' ? JSON.stringify(message) : String(message);
+    
+    // Using process.stdout.write or console.log/error
+    if (level === 'ERROR') {
+      console.error(`${timestamp} - \x1b[31m${level}\x1b[0m:${formattedContext} ${msgStr}${formattedTrace}`);
+    } else if (level === 'WARN') {
+      console.warn(`${timestamp} - \x1b[33m${level}\x1b[0m:${formattedContext} ${msgStr}`);
+    } else if (level === 'DEBUG') {
+      console.log(`${timestamp} - \x1b[35m${level}\x1b[0m:${formattedContext} ${msgStr}`);
+    } else if (level === 'VERBOSE') {
+      console.log(`${timestamp} - \x1b[36m${level}\x1b[0m:${formattedContext} ${msgStr}`);
+    } else {
+      console.log(`${timestamp} - \x1b[32m${level}\x1b[0m:${formattedContext} ${msgStr}`);
+    }
+  }
+}

package/src/mvc/index.ts

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

package/src/mvc/mvc.ts

@@ -0,0 +1,22 @@
+import { SetMetadata } from '../core/decorators.ts';
+
+export function Render(template: string): MethodDecorator {
+  return SetMetadata('calyx:render_template', template);
+}
+
+export type ViewEngine = (templatePath: string, data: any) => string | Promise<string>;
+
+export async function defaultRenderEngine(templatePath: string, data: any): Promise<string> {
+  const file = Bun.file(templatePath);
+  if (!(await file.exists())) {
+    throw new Error(`Template not found at path: ${templatePath}`);
+  }
+  let content = await file.text();
+  if (data && typeof data === 'object') {
+    for (const [key, val] of Object.entries(data)) {
+      const regex = new RegExp(`{{\\s*${key}\\s*}}`, 'g');
+      content = content.replace(regex, String(val));
+    }
+  }
+  return content;
+}

package/src/openapi/decorators.ts

@@ -47,3 +47,157 @@ export function ApiProperty(options: {
     Reflect.defineMetadata('calyx:api_properties', properties, target.constructor);
   };
 }
+
+export function ApiBody(options: { type?: any; required?: boolean; description?: string; schema?: any }): MethodDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata('calyx:api_body', options, target, propertyKey);
+  };
+}
+
+export function ApiQuery(options: { name: string; type?: any; required?: boolean; description?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    const queries = Reflect.getOwnMetadata('calyx:api_queries', target, propertyKey) || [];
+    queries.push(options);
+    Reflect.defineMetadata('calyx:api_queries', queries, target, propertyKey);
+  };
+}
+
+export function ApiParam(options: { name: string; type?: any; required?: boolean; description?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    const params = Reflect.getOwnMetadata('calyx:api_params', target, propertyKey) || [];
+    params.push(options);
+    Reflect.defineMetadata('calyx:api_params', params, target, propertyKey);
+  };
+}
+
+export function ApiHeader(options: { name: string; description?: string; required?: boolean }): MethodDecorator {
+  return (target, propertyKey) => {
+    const headers = Reflect.getOwnMetadata('calyx:api_headers', target, propertyKey) || [];
+    headers.push(options);
+    Reflect.defineMetadata('calyx:api_headers', headers, target, propertyKey);
+  };
+}
+
+export function ApiExtraModels(...models: any[]): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:api_extra_models', models, target);
+  };
+}
+
+export function ApiBearerAuth(name = 'bearer'): ClassDecorator & MethodDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    const key = 'calyx:api_security';
+    const securityReq = { [name]: [] };
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(key, target, propertyKey) || [];
+      existing.push(securityReq);
+      Reflect.defineMetadata(key, existing, target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(key, target) || [];
+      existing.push(securityReq);
+      Reflect.defineMetadata(key, existing, target);
+    }
+  };
+}
+
+export function ApiBasicAuth(name = 'basic'): ClassDecorator & MethodDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    const key = 'calyx:api_security';
+    const securityReq = { [name]: [] };
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(key, target, propertyKey) || [];
+      existing.push(securityReq);
+      Reflect.defineMetadata(key, existing, target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(key, target) || [];
+      existing.push(securityReq);
+      Reflect.defineMetadata(key, existing, target);
+    }
+  };
+}
+
+export function ApiOAuth2(options: any, name = 'oauth2'): ClassDecorator & MethodDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    const key = 'calyx:api_security';
+    const securityReq = { [name]: options.scopes || [] };
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(key, target, propertyKey) || [];
+      existing.push(securityReq);
+      Reflect.defineMetadata(key, existing, target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(key, target) || [];
+      existing.push(securityReq);
+      Reflect.defineMetadata(key, existing, target);
+    }
+  };
+}
+
+export function ApiPropertyOptional(options: any = {}): PropertyDecorator {
+  return ApiProperty({ ...options, required: false });
+}
+
+export function PartialType<T>(classRef: new (...args: any[]) => T): new (...args: any[]) => Partial<T> {
+  const properties = Reflect.getMetadata('calyx:api_properties', classRef) || [];
+  
+  class PartialClass {}
+  Object.defineProperty(PartialClass, 'name', { value: `Partial${classRef.name}` });
+
+  const partialProps = properties.map((p: any) => ({ ...p, required: false }));
+  Reflect.defineMetadata('calyx:api_properties', partialProps, PartialClass);
+  
+  return PartialClass as any;
+}
+
+export function PickType<T, K extends keyof T>(
+  classRef: new (...args: any[]) => T,
+  keys: readonly K[]
+): new (...args: any[]) => Pick<T, K> {
+  const properties = Reflect.getMetadata('calyx:api_properties', classRef) || [];
+  const stringKeys = keys.map(String);
+  
+  class PickClass {}
+  Object.defineProperty(PickClass, 'name', { value: `Pick${classRef.name}` });
+
+  const pickProps = properties.filter((p: any) => stringKeys.includes(p.propertyKey));
+  Reflect.defineMetadata('calyx:api_properties', pickProps, PickClass);
+
+  return PickClass as any;
+}
+
+export function OmitType<T, K extends keyof T>(
+  classRef: new (...args: any[]) => T,
+  keys: readonly K[]
+): new (...args: any[]) => Omit<T, K> {
+  const properties = Reflect.getMetadata('calyx:api_properties', classRef) || [];
+  const stringKeys = keys.map(String);
+  
+  class OmitClass {}
+  Object.defineProperty(OmitClass, 'name', { value: `Omit${classRef.name}` });
+
+  const omitProps = properties.filter((p: any) => !stringKeys.includes(p.propertyKey));
+  Reflect.defineMetadata('calyx:api_properties', omitProps, OmitClass);
+
+  return OmitClass as any;
+}
+
+export function IntersectionType<A, B>(
+  classA: new (...args: any[]) => A,
+  classB: new (...args: any[]) => B
+): new (...args: any[]) => A & B {
+  const propsA = Reflect.getMetadata('calyx:api_properties', classA) || [];
+  const propsB = Reflect.getMetadata('calyx:api_properties', classB) || [];
+
+  class IntersectionClass {}
+  Object.defineProperty(IntersectionClass, 'name', { value: `${classA.name}And${classB.name}` });
+
+  const combinedProps = [...propsA];
+  for (const pB of propsB) {
+    if (!combinedProps.some((pA) => pA.propertyKey === pB.propertyKey)) {
+      combinedProps.push(pB);
+    }
+  }
+  Reflect.defineMetadata('calyx:api_properties', combinedProps, IntersectionClass);
+
+  return IntersectionClass as any;
+}
+

package/src/openapi/swagger.module.ts

@@ -11,6 +11,7 @@ export class DocumentBuilder {
     paths: {},
     components: {
       schemas: {},
+      securitySchemes: {},
     },
   };
 
@@ -29,6 +30,26 @@ export class DocumentBuilder {
     return this;
   }
 
+  addBearerAuth(options: any = { type: 'http', scheme: 'bearer', bearerFormat: 'JWT' }, name = 'bearer') {
+    this.document.components.securitySchemes[name] = options;
+    return this;
+  }
+
+  addBasicAuth(options: any = { type: 'http', scheme: 'basic' }, name = 'basic') {
+    this.document.components.securitySchemes[name] = options;
+    return this;
+  }
+
+  addOAuth2(options: any = { type: 'oauth2', flows: {} }, name = 'oauth2') {
+    this.document.components.securitySchemes[name] = options;
+    return this;
+  }
+
+  addSecurity(name: string, scheme: any) {
+    this.document.components.securitySchemes[name] = scheme;
+    return this;
+  }
+
   build() {
     return this.document;
   }
@@ -40,9 +61,42 @@ export class SwaggerModule {
     if (!document.paths) document.paths = {};
     if (!document.components) document.components = {};
     if (!document.components.schemas) document.components.schemas = {};
+    if (!document.components.securitySchemes) {
+      document.components.securitySchemes = config.components?.securitySchemes || {};
+    }
 
     const routes = app.getRoutes();
 
+    function registerSchema(typeClass: any) {
+      if (!typeClass || typeof typeClass !== 'function') return;
+      const schemaName = typeClass.name;
+      if (document.components.schemas[schemaName]) return;
+
+      const props = Reflect.getMetadata('calyx:api_properties', typeClass) || [];
+      const schemaProps: Record<string, any> = {};
+      const requiredProps: string[] = [];
+
+      for (const p of props) {
+        let pType = 'string';
+        if (p.type) {
+          pType = p.type.name ? p.type.name.toLowerCase() : String(p.type).toLowerCase();
+        }
+        schemaProps[p.propertyKey] = {
+          type: pType === 'number' || pType === 'boolean' || pType === 'object' || pType === 'array' ? pType : 'string',
+          description: p.description,
+        };
+        if (p.required) {
+          requiredProps.push(p.propertyKey);
+        }
+      }
+
+      document.components.schemas[schemaName] = {
+        type: 'object',
+        properties: schemaProps,
+        ...(requiredProps.length > 0 ? { required: requiredProps } : {}),
+      };
+    }
+
     for (const route of routes) {
       const { method, path, handler } = route;
 
@@ -60,15 +114,124 @@ export class SwaggerModule {
         [];
       const responsesMeta =
         Reflect.getMetadata('calyx:api_responses', handler.controllerClass.prototype, handler.methodName) || [];
+      const securityMeta =
+        Reflect.getMetadata('calyx:api_security', handler.controllerClass.prototype, handler.methodName) ||
+        Reflect.getMetadata('calyx:api_security', handler.controllerClass) ||
+        [];
+
+      // Extra Models
+      const extraModels = Reflect.getMetadata('calyx:api_extra_models', handler.controllerClass) || [];
+      for (const model of extraModels) {
+        registerSchema(model);
+      }
+
+      const parameters: any[] = [];
 
+      // Parse Path Params (Regex match)
       const pathParams = [...path.matchAll(/:([a-zA-Z0-9_]+)/g)].map((m) => m[1]);
+      const pathParamDecorators = Reflect.getMetadata('calyx:api_params', handler.controllerClass.prototype, handler.methodName) || [];
+
+      for (const name of pathParams) {
+        const dec = pathParamDecorators.find((d: any) => d.name === name) || {};
+        parameters.push({
+          name,
+          in: 'path',
+          required: true,
+          description: dec.description || '',
+          schema: {
+            type: dec.type ? dec.type.name.toLowerCase() : 'string',
+          },
+        });
+      }
+
+      // Parse Http Parameter Decorators (@Query, @Headers, etc.)
+      const httpParams: any[] = Reflect.getMetadata('calyx:http_params', handler.controllerClass.prototype, handler.methodName) || [];
+      const paramTypes = Reflect.getMetadata('design:paramtypes', handler.controllerClass.prototype, handler.methodName) || [];
+      const apiQueries = Reflect.getMetadata('calyx:api_queries', handler.controllerClass.prototype, handler.methodName) || [];
+      const apiHeaders = Reflect.getMetadata('calyx:api_headers', handler.controllerClass.prototype, handler.methodName) || [];
+      let requestBody: any = undefined;
+
+      for (const param of httpParams) {
+        const paramType = paramTypes[param.index];
+
+        if (param.type === 'query') {
+          const qName = param.name;
+          if (qName) {
+            const dec = apiQueries.find((q: any) => q.name === qName) || {};
+            parameters.push({
+              name: qName,
+              in: 'query',
+              required: dec.required ?? false,
+              description: dec.description || '',
+              schema: {
+                type: dec.type ? dec.type.name.toLowerCase() : (paramType ? paramType.name.toLowerCase() : 'string'),
+              },
+            });
+          }
+        } else if (param.type === 'headers') {
+          const hName = param.name;
+          if (hName) {
+            const dec = apiHeaders.find((h: any) => h.name === hName) || {};
+            parameters.push({
+              name: hName,
+              in: 'header',
+              required: dec.required ?? false,
+              description: dec.description || '',
+              schema: {
+                type: 'string',
+              },
+            });
+          }
+        } else if (param.type === 'body') {
+          const bodyDec = Reflect.getMetadata('calyx:api_body', handler.controllerClass.prototype, handler.methodName) || {};
+          const targetType = bodyDec.type || paramType;
+
+          if (targetType) {
+            registerSchema(targetType);
+            requestBody = {
+              description: bodyDec.description || '',
+              required: bodyDec.required ?? true,
+              content: {
+                'application/json': {
+                  schema: {
+                    $ref: `#/components/schemas/${targetType.name}`,
+                  },
+                },
+              },
+            };
+          }
+        }
+      }
+
+      // Add manual @ApiQuery annotations if they weren't matched to method params
+      for (const q of apiQueries) {
+        if (!parameters.some((p) => p.in === 'query' && p.name === q.name)) {
+          parameters.push({
+            name: q.name,
+            in: 'query',
+            required: q.required ?? false,
+            description: q.description || '',
+            schema: {
+              type: q.type ? q.type.name.toLowerCase() : 'string',
+            },
+          });
+        }
+      }
 
-      const parameters = pathParams.map((name) => ({
-        name,
-        in: 'path',
-        required: true,
-        schema: { type: 'string' },
-      }));
+      // Add manual @ApiHeader annotations if they weren't matched to method params
+      for (const h of apiHeaders) {
+        if (!parameters.some((p) => p.in === 'header' && p.name === h.name)) {
+          parameters.push({
+            name: h.name,
+            in: 'header',
+            required: h.required ?? false,
+            description: h.description || '',
+            schema: {
+              type: 'string',
+            },
+          });
+        }
+      }
 
       const responses: Record<string, any> = {};
       if (responsesMeta.length > 0) {
@@ -83,20 +246,7 @@ export class SwaggerModule {
                 schema: { $ref: `#/components/schemas/${schemaName}` },
               },
             };
-            if (!document.components.schemas[schemaName]) {
-              const props = Reflect.getMetadata('calyx:api_properties', res.type) || [];
-              const schemaProps: Record<string, any> = {};
-              for (const p of props) {
-                schemaProps[p.propertyKey] = {
-                  type: p.type ? p.type.name.toLowerCase() : 'string',
-                  description: p.description,
-                };
-              }
-              document.components.schemas[schemaName] = {
-                type: 'object',
-                properties: schemaProps,
-              };
-            }
+            registerSchema(res.type);
           }
         }
       } else {
@@ -108,7 +258,9 @@ export class SwaggerModule {
         description: operationMeta.description || '',
         tags,
         parameters,
+        ...(requestBody ? { requestBody } : {}),
         responses,
+        ...(securityMeta.length > 0 ? { security: securityMeta } : {}),
       };
     }