@martel/calyx 1.12.0 → 1.13.0

package/src/http/exceptions.ts

@@ -45,3 +45,100 @@ export class InternalServerErrorException extends HttpException {
     super(message, 500);
   }
 }
+
+export class NotAcceptableException extends HttpException {
+  constructor(message: string | object = 'Not Acceptable') {
+    super(message, 406);
+  }
+}
+
+export class RequestTimeoutException extends HttpException {
+  constructor(message: string | object = 'Request Timeout') {
+    super(message, 408);
+  }
+}
+
+export class ConflictException extends HttpException {
+  constructor(message: string | object = 'Conflict') {
+    super(message, 409);
+  }
+}
+
+export class GoneException extends HttpException {
+  constructor(message: string | object = 'Gone') {
+    super(message, 410);
+  }
+}
+
+export class PayloadTooLargeException extends HttpException {
+  constructor(message: string | object = 'Payload Too Large') {
+    super(message, 413);
+  }
+}
+
+export class UnsupportedMediaTypeException extends HttpException {
+  constructor(message: string | object = 'Unsupported Media Type') {
+    super(message, 415);
+  }
+}
+
+export class UnprocessableEntityException extends HttpException {
+  constructor(message: string | object = 'Unprocessable Entity') {
+    super(message, 422);
+  }
+}
+
+export class NotImplementedException extends HttpException {
+  constructor(message: string | object = 'Not Implemented') {
+    super(message, 501);
+  }
+}
+
+export class HttpVersionNotSupportedException extends HttpException {
+  constructor(message: string | object = 'HTTP Version Not Supported') {
+    super(message, 505);
+  }
+}
+
+export class BadGatewayException extends HttpException {
+  constructor(message: string | object = 'Bad Gateway') {
+    super(message, 502);
+  }
+}
+
+export class ServiceUnavailableException extends HttpException {
+  constructor(message: string | object = 'Service Unavailable') {
+    super(message, 503);
+  }
+}
+
+export class GatewayTimeoutException extends HttpException {
+  constructor(message: string | object = 'Gateway Timeout') {
+    super(message, 504);
+  }
+}
+
+export class PreconditionFailedException extends HttpException {
+  constructor(message: string | object = 'Precondition Failed') {
+    super(message, 412);
+  }
+}
+
+export class MethodNotAllowedException extends HttpException {
+  constructor(message: string | object = 'Method Not Allowed') {
+    super(message, 405);
+  }
+}
+
+export class ImATeapotException extends HttpException {
+  constructor(message: string | object = "I'm a teapot") {
+    super(message, 418);
+  }
+}
+
+export class MisdirectedException extends HttpException {
+  constructor(message: string | object = 'Misdirected Request') {
+    super(message, 421);
+  }
+}
+

package/src/http/factory.ts

@@ -14,3 +14,6 @@ export class CalyxFactory {
     return app;
   }
 }
+
+export const NestFactory = CalyxFactory;
+

package/src/http/router.ts

@@ -17,6 +17,7 @@ export class RadixRouter<T> {
   private handlersArray: T[] = [];
   private compiledMatch: ((method: string, path: string) => RouteMatch<T> | null) | null = null;
   private routesList: { method: string; path: string; handler: T }[] = [];
+  private regexRoutes: { method: string; regex: RegExp; handler: T }[] = [];
 
   getRoutes() {
     return this.routesList;
@@ -26,13 +27,26 @@ export class RadixRouter<T> {
     this.root = new RouterNode<T>();
     this.staticRoutes.clear();
     this.routesList = [];
+    this.regexRoutes = [];
     this.compiledMatch = null;
   }
 
   insert(method: string, path: string, handler: T) {
     this.routesList.push({ method, path, handler });
+    
+    const isWildcardPath = path.includes('*') && !path.endsWith('/*') && path !== '*';
+    if (isWildcardPath) {
+      const escaped = path.replace(/[\-\[\]\/\{\}\(\)\+\?\.\\\^\$\|]/g, '\\$&');
+      const regexStr = '^' + escaped.replace(/\*/g, '.*') + '$';
+      this.regexRoutes.push({
+        method: method.toUpperCase(),
+        regex: new RegExp(regexStr),
+        handler,
+      });
+    }
+
     const hasParams = path.includes(':') || path.includes('*');
-    if (!hasParams) {
+    if (!hasParams && !isWildcardPath) {
       this.staticRoutes.set(method.toUpperCase() + ' ' + path, handler);
     }
 
@@ -68,6 +82,15 @@ export class RadixRouter<T> {
   }
 
   match(method: string, path: string): RouteMatch<T> | null {
+    if (this.regexRoutes.length > 0) {
+      const uMethod = method.toUpperCase();
+      for (const route of this.regexRoutes) {
+        if (route.method === uMethod && route.regex.test(path)) {
+          return { handler: route.handler, params: {} };
+        }
+      }
+    }
+
     if (this.compiledMatch) {
       return this.compiledMatch(method, path);
     }
@@ -105,6 +128,7 @@ export class RadixRouter<T> {
       staticCheckCode = `
       switch (method) {
       `;
+
       for (const [method, routes] of Object.entries(staticRoutesByMethod)) {
         staticCheckCode += `  case '${method}':\n    switch (path) {\n`;
         for (const [path, handlerIdx] of Object.entries(routes)) {
@@ -152,7 +176,7 @@ export class RadixRouter<T> {
           const handlerIdx = registerHandler(handler);
           parts.push(`  case '${method}': return { handler: handlers[${handlerIdx}], params };`);
         }
-        const fallbackWildcardHandler = node.wildcardChild.handlers.get('ALL') ?? node.wildcardChild.handlers.values().next().value;
+        const fallbackWildcardHandler = node.wildcardChild.handlers.get('ALL');
         if (fallbackWildcardHandler) {
           const handlerIdx = registerHandler(fallbackWildcardHandler);
           parts.push(`  default: return { handler: handlers[${handlerIdx}], params };`);
@@ -170,7 +194,7 @@ export class RadixRouter<T> {
           const handlerIdx = registerHandler(handler);
           parts.push(`    case '${method}': return { handler: handlers[${handlerIdx}], params };`);
         }
-        const fallbackHandler = node.handlers.get('ALL') ?? node.handlers.values().next().value;
+        const fallbackHandler = node.handlers.get('ALL');
         if (fallbackHandler) {
           const handlerIdx = registerHandler(fallbackHandler);
           parts.push(`    default: return { handler: handlers[${handlerIdx}], params };`);
@@ -191,7 +215,6 @@ export class RadixRouter<T> {
       return null;
     `;
 
-
     try {
       this.compiledMatch = new Function('handlers', `
         return function match(method, path) {

package/src/index.ts

@@ -13,6 +13,7 @@ export * from './validation/index.ts';
 export * from './openapi/index.ts';
 export * from './database/typeorm.module.ts';
 export * from './database/mongoose.module.ts';
+export { SequelizeModule, InjectModel as InjectModelSequelize, Model as SequelizeModel } from './database/sequelize.module.ts';
 export * from './versioning/versioning.ts';
 export * from './queue/queue.module.ts';
 export * from './logger/index.ts';

package/src/microservices/exceptions.ts

@@ -0,0 +1,10 @@
+export class RpcException extends Error {
+  constructor(private readonly error: string | object) {
+    super(typeof error === 'string' ? error : JSON.stringify(error));
+    this.name = 'RpcException';
+  }
+
+  getError() {
+    return this.error;
+  }
+}

package/src/microservices/index.ts

@@ -5,3 +5,4 @@ export * from './decorators.ts';
 export * from './server-tcp.ts';
 export * from './microservice.ts';
 export * from './clients.module.ts';
+export * from './exceptions.ts';

package/src/queue/queue.module.ts

@@ -105,6 +105,7 @@ export class QueueManager {
 export class Queue {
   private jobs: Job[] = [];
   private jobCounter = 0;
+  private paused = false;
 
   constructor(public readonly name: string) {}
 
@@ -146,16 +147,80 @@ export class Queue {
   async getJobs(): Promise<Job[]> {
     return this.jobs;
   }
+
+  async pause(): Promise<void> {
+    this.paused = true;
+  }
+
+  async resume(): Promise<void> {
+    this.paused = false;
+  }
+
+  async isPaused(): Promise<boolean> {
+    return this.paused;
+  }
+
+  async obliterate(): Promise<void> {
+    this.jobs = [];
+    this.jobCounter = 0;
+  }
+
+  async clean(): Promise<void> {
+    this.jobs = this.jobs.filter((j) => j.status !== 'completed' && j.status !== 'failed');
+  }
+
+  async drain(): Promise<void> {
+    this.jobs = [];
+  }
+
+  async count(): Promise<number> {
+    return this.jobs.length;
+  }
+
+  async getJob(id: string): Promise<Job | null> {
+    return this.jobs.find((j) => j.id === id) ?? null;
+  }
 }
 
 @Module({})
 export class QueueModule {
-  static registerQueue(...configs: { name: string }[]): DynamicModule {
-    const providers = configs.map((c) => {
+  static forRoot(options: any = {}): DynamicModule {
+    return {
+      module: QueueModule,
+      providers: [
+        {
+          provide: 'BULL_MODULE_OPTIONS',
+          useValue: options,
+        },
+      ],
+      exports: [],
+      global: true,
+    };
+  }
+
+  static forRootAsync(options: any = {}): DynamicModule {
+    return {
+      module: QueueModule,
+      providers: [
+        {
+          provide: 'BULL_MODULE_OPTIONS',
+          useFactory: options.useFactory || (() => ({})),
+          inject: options.inject || [],
+        },
+      ],
+      exports: [],
+      global: true,
+    };
+  }
+
+  static registerQueue(...args: any[]): DynamicModule {
+    const configs = Array.isArray(args[0]) ? args[0] : args;
+    const providers = configs.map((c: any) => {
+      const name = typeof c === 'string' ? c : c.name;
       return {
-        provide: `Queue_${c.name}`,
+        provide: `Queue_${name}`,
         useFactory: () => {
-          return QueueManager.getOrCreateQueue(c.name);
+          return QueueManager.getOrCreateQueue(name);
         },
       };
     });
@@ -163,7 +228,7 @@ export class QueueModule {
     return {
       module: QueueModule,
       providers,
-      exports: configs.map((c) => `Queue_${c.name}`),
+      exports: configs.map((c: any) => `Queue_${typeof c === 'string' ? c : c.name}`),
     };
   }
 
@@ -172,3 +237,6 @@ export class QueueModule {
     // Handled in CalyxApplication initialization dynamically
   }
 }
+
+export const BullModule = QueueModule;
+

package/src/terminus/terminus.ts

@@ -54,8 +54,81 @@ export class HttpHealthIndicator {
   }
 }
 
+@Injectable()
+export class TypeOrmHealthIndicator {
+  async pingCheck(key: string, options?: any): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class MongooseHealthIndicator {
+  async pingCheck(key: string, options?: any): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class SequelizeHealthIndicator {
+  async pingCheck(key: string, options?: any): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class MicroserviceHealthIndicator {
+  async pingCheck(key: string, options?: any): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class DiskHealthIndicator {
+  async checkStorage(key: string, options?: { thresholdPercent?: number; path?: string }): Promise<any> {
+    return { [key]: { status: 'up' } };
+  }
+}
+
+@Injectable()
+export class MemoryHealthIndicator {
+  async checkHeap(key: string, thresholdBytes: number): Promise<any> {
+    const usage = process.memoryUsage().heapUsed;
+    if (usage > thresholdBytes) {
+      throw new Error(`Heap memory usage ${usage} exceeded threshold ${thresholdBytes}`);
+    }
+    return { [key]: { status: 'up', heapUsed: usage } };
+  }
+
+  async checkRSS(key: string, thresholdBytes: number): Promise<any> {
+    const usage = process.memoryUsage().rss;
+    if (usage > thresholdBytes) {
+      throw new Error(`RSS memory usage ${usage} exceeded threshold ${thresholdBytes}`);
+    }
+    return { [key]: { status: 'up', rss: usage } };
+  }
+}
+
 @Module({
-  providers: [HealthCheckService, HttpHealthIndicator],
-  exports: [HealthCheckService, HttpHealthIndicator],
+  providers: [
+    HealthCheckService,
+    HttpHealthIndicator,
+    TypeOrmHealthIndicator,
+    MongooseHealthIndicator,
+    SequelizeHealthIndicator,
+    MicroserviceHealthIndicator,
+    DiskHealthIndicator,
+    MemoryHealthIndicator,
+  ],
+  exports: [
+    HealthCheckService,
+    HttpHealthIndicator,
+    TypeOrmHealthIndicator,
+    MongooseHealthIndicator,
+    SequelizeHealthIndicator,
+    MicroserviceHealthIndicator,
+    DiskHealthIndicator,
+    MemoryHealthIndicator,
+  ],
 })
 export class TerminusModule {}
+

package/src/validation/compiler.ts

@@ -28,16 +28,139 @@ export class ValidationCompiler {
 
       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');`
-          );
+        const args = rule.args || [];
+        const type = rule.type;
+        
+        if (type === 'optional') continue;
+        
+        switch (type) {
+          case 'isDefined':
+            propCode.push(`if (obj.${prop} === undefined || obj.${prop} === null) errors.push('${prop} must be defined');`);
+            break;
+          case 'equals':
+            propCode.push(`if (obj.${prop} !== ${JSON.stringify(args[0])}) errors.push('${prop} must be equal to ${args[0]}');`);
+            break;
+          case 'notEquals':
+            propCode.push(`if (obj.${prop} === ${JSON.stringify(args[0])}) errors.push('${prop} must not be equal to ${args[0]}');`);
+            break;
+          case 'isEmpty':
+            propCode.push(`if (obj.${prop} !== '' && obj.${prop} !== undefined && obj.${prop} !== null) errors.push('${prop} must be empty');`);
+            break;
+          case 'isNotEmpty':
+            propCode.push(`if (obj.${prop} === '' || obj.${prop} === undefined || obj.${prop} === null) errors.push('${prop} should not be empty');`);
+            break;
+          case 'isIn':
+            propCode.push(`if (!${JSON.stringify(args[0])}.includes(obj.${prop})) errors.push('${prop} must be one of the following values: ' + ${JSON.stringify(args[0])}.join(', '));`);
+            break;
+          case 'isNotIn':
+            propCode.push(`if (${JSON.stringify(args[0])}.includes(obj.${prop})) errors.push('${prop} must not be one of the following values: ' + ${JSON.stringify(args[0])}.join(', '));`);
+            break;
+          case 'isBoolean':
+            propCode.push(`if (typeof obj.${prop} !== 'boolean') errors.push('${prop} must be a boolean');`);
+            break;
+          case 'isDate':
+            propCode.push(`if (!(obj.${prop} instanceof Date) || isNaN(obj.${prop}.getTime())) errors.push('${prop} must be a Date instance');`);
+            break;
+          case 'string':
+            propCode.push(`if (typeof obj.${prop} !== 'string') errors.push('${prop} must be a string');`);
+            break;
+          case 'number':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || isNaN(obj.${prop})) errors.push('${prop} must be a number');`);
+            break;
+          case 'isInt':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || !Number.isInteger(obj.${prop})) errors.push('${prop} must be an integer');`);
+            break;
+          case 'isArray':
+            propCode.push(`if (!Array.isArray(obj.${prop})) errors.push('${prop} must be an array');`);
+            break;
+          case 'isEnum':
+            const enumValues = Object.values(args[0]);
+            propCode.push(`if (!${JSON.stringify(enumValues)}.includes(obj.${prop})) errors.push('${prop} must be a valid enum value');`);
+            break;
+          case 'isObject':
+            propCode.push(`if (typeof obj.${prop} !== 'object' || obj.${prop} === null || Array.isArray(obj.${prop})) errors.push('${prop} must be an object');`);
+            break;
+          case 'isPositive':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || obj.${prop} <= 0) errors.push('${prop} must be a positive number');`);
+            break;
+          case 'isNegative':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || obj.${prop} >= 0) errors.push('${prop} must be a negative number');`);
+            break;
+          case 'min':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || obj.${prop} < ${args[0]}) errors.push('${prop} must not be less than ${args[0]}');`);
+            break;
+          case 'max':
+            propCode.push(`if (typeof obj.${prop} !== 'number' || obj.${prop} > ${args[0]}) errors.push('${prop} must not be greater than ${args[0]}');`);
+            break;
+          case 'contains':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !obj.${prop}.includes(${JSON.stringify(args[0])})) errors.push('${prop} must contain a ${args[0]} string');`);
+            break;
+          case 'notContains':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop}.includes(${JSON.stringify(args[0])})) errors.push('${prop} must not contain a ${args[0]} string');`);
+            break;
+          case 'isAlpha':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^[a-zA-Z]+$/.test(obj.${prop})) errors.push('${prop} must contain only letters');`);
+            break;
+          case 'isAlphanumeric':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^[a-zA-Z0-9]+$/.test(obj.${prop})) errors.push('${prop} must contain only letters and numbers');`);
+            break;
+          case 'isDecimal':
+            propCode.push(`if (typeof obj.${prop} !== 'string' && typeof obj.${prop} !== 'number' || !/^\\d+\\.\\d+$/.test(String(obj.${prop}))) errors.push('${prop} must be a decimal number');`);
+            break;
+          case 'email':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !obj.${prop}.includes('@')) errors.push('${prop} must be a valid email');`);
+            break;
+          case 'isUrl':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^(https?:\\/\\/)?([\\da-z\\.-]+)\\.([a-z\\.]{2,6})([\\/\\w \\.-]*)*\\/?$/.test(obj.${prop})) errors.push('${prop} must be a URL address');`);
+            break;
+          case 'isIP':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^(?:[0-9]{1,3}\\.){3}[0-9]{1,3}$/.test(obj.${prop})) errors.push('${prop} must be an IP address');`);
+            break;
+          case 'isPort':
+            propCode.push(`if (typeof obj.${prop} !== 'number' && typeof obj.${prop} !== 'string' || Number(obj.${prop}) < 0 || Number(obj.${prop}) > 65535) errors.push('${prop} must be a port');`);
+            break;
+          case 'isJSON':
+            propCode.push(`if (typeof obj.${prop} !== 'string') errors.push('${prop} must be a json string'); else { try { JSON.parse(obj.${prop}); } catch { errors.push('${prop} must be a json string'); } }`);
+            break;
+          case 'isLowercase':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop} !== obj.${prop}.toLowerCase()) errors.push('${prop} must be a lowercase string');`);
+            break;
+          case 'isUppercase':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop} !== obj.${prop}.toUpperCase()) errors.push('${prop} must be a uppercase string');`);
+            break;
+          case 'isNumberString':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || isNaN(Number(obj.${prop}))) errors.push('${prop} must be a number string');`);
+            break;
+          case 'isUUID':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(obj.${prop})) errors.push('${prop} must be a UUID');`);
+            break;
+          case 'isDateString':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || isNaN(Date.parse(obj.${prop}))) errors.push('${prop} must be a valid ISO 8601 date string');`);
+            break;
+          case 'length':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop}.length < ${args[0]} || obj.${prop}.length > ${args[1]}) errors.push('${prop} length must be between ${args[0]} and ${args[1]}');`);
+            break;
+          case 'minLength':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop}.length < ${args[0]}) errors.push('${prop} length must be at least ${args[0]}');`);
+            break;
+          case 'maxLength':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || obj.${prop}.length > ${args[0]}) errors.push('${prop} length must not exceed ${args[0]}');`);
+            break;
+          case 'matches':
+            propCode.push(`if (typeof obj.${prop} !== 'string' || !${args[0].toString()}.test(obj.${prop})) errors.push('${prop} must match regular expression');`);
+            break;
+          case 'arrayNotEmpty':
+            propCode.push(`if (!Array.isArray(obj.${prop}) || obj.${prop}.length === 0) errors.push('${prop} should not be empty');`);
+            break;
+          case 'arrayMinSize':
+            propCode.push(`if (!Array.isArray(obj.${prop}) || obj.${prop}.length < ${args[0]}) errors.push('${prop} must contain at least ${args[0]} elements');`);
+            break;
+          case 'arrayMaxSize':
+            propCode.push(`if (!Array.isArray(obj.${prop}) || obj.${prop}.length > ${args[0]}) errors.push('${prop} must contain not more than ${args[0]} elements');`);
+            break;
+          case 'arrayUnique':
+            propCode.push(`if (!Array.isArray(obj.${prop}) || new Set(obj.${prop}).size !== obj.${prop}.length) errors.push('${prop} must contain unique elements');`);
+            break;
         }
       }