@martel/calyx 1.7.0 → 1.9.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

@@ -10,3 +10,18 @@ export * from './websockets/index.ts';
 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

@@ -0,0 +1,203 @@
+import 'reflect-metadata';
+
+export function ApiTags(...tags: string[]): ClassDecorator & MethodDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    const key = 'calyx:api_tags';
+    if (propertyKey) {
+      Reflect.defineMetadata(key, tags, target, propertyKey);
+    } else {
+      Reflect.defineMetadata(key, tags, target);
+    }
+  };
+}
+
+export function ApiOperation(options: { summary?: string; description?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata('calyx:api_operation', options, target, propertyKey);
+  };
+}
+
+export function ApiResponse(options: {
+  status: number;
+  description: string;
+  type?: any;
+}): MethodDecorator & ClassDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    const key = 'calyx:api_responses';
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(key, target, propertyKey) || [];
+      existing.push(options);
+      Reflect.defineMetadata(key, existing, target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(key, target) || [];
+      existing.push(options);
+      Reflect.defineMetadata(key, existing, target);
+    }
+  };
+}
+
+export function ApiProperty(options: {
+  description?: string;
+  type?: any;
+  required?: boolean;
+} = {}): PropertyDecorator {
+  return (target, propertyKey) => {
+    const properties = Reflect.getOwnMetadata('calyx:api_properties', target.constructor) || [];
+    properties.push({ propertyKey: String(propertyKey), ...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/index.ts

@@ -0,0 +1,2 @@
+export * from './decorators.ts';
+export * from './swagger.module.ts';