xcally-nest-library 0.0.27 → 0.0.28

package/src/modules/logger/winston.module.ts

@@ -1,63 +0,0 @@
-import { Module, DynamicModule, Global } from '@nestjs/common';
-import { createLogger, format, Logger } from 'winston';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { WinstonLoggerService } from './winston.service';
-import { DatadogTransportStrategy } from './datadogTransport.strategy';
-import { ElasticsearchTransportStrategy } from './elasticsearchTransport.strategy';
-import { ConsoleTransportStrategy } from './consoleTransport.strategy';
-import { FileTransportStrategy } from './fileTransport.strategy';
-
-@Global()
-@Module({})
-export class WinstonModule {
-  static forRoot(): DynamicModule {
-    const winstonProvider = {
-      provide: 'WINSTON_LOGGER',
-      useFactory: (configService: ConfigService): Logger => {
-        const nameService = configService.getOrThrow<string>('NAME_SERVICE');
-        const transportsArray = configService
-          .getOrThrow<string>('LOG_TRANSPORTS')
-          .split(',')
-          .map((item) => item.trim());
-        if (transportsArray.length === 0 || transportsArray.includes('')) {
-          throw new Error('LOG_TRANSPORTS configuration must contain at least one valid transport method.');
-        }
-
-        const selectedTransports = transportsArray.flatMap((key) => {
-          const strategyMap = {
-            elasticsearch: new ElasticsearchTransportStrategy(),
-            datadog: new DatadogTransportStrategy(),
-            file: new FileTransportStrategy(nameService),
-            console: new ConsoleTransportStrategy(),
-          };
-          const strategy = strategyMap[key];
-          if (strategy) {
-            return [].concat(strategy.createTransport(configService));
-          } else {
-            throw new Error(`No strategy found for transport ${key}`);
-          }
-        });
-
-        return createLogger({
-          level: configService.get<string>('LOG_LEVEL') || 'info',
-          format: format.combine(format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss:ms' })),
-          defaultMeta: { service: nameService },
-          transports: selectedTransports,
-        });
-      },
-      inject: [ConfigService],
-    };
-    const loggerServiceProvider = {
-      provide: WinstonLoggerService,
-      useFactory: (logger: Logger) => new WinstonLoggerService(logger),
-      inject: ['WINSTON_LOGGER'],
-    };
-
-    return {
-      module: WinstonModule,
-      imports: [ConfigModule],
-      providers: [winstonProvider, loggerServiceProvider],
-      exports: [winstonProvider, loggerServiceProvider],
-    };
-  }
-}

package/src/modules/logger/winston.service.ts

@@ -1,53 +0,0 @@
-// winston-logger.service.ts
-import { Logger } from 'winston';
-import { IWinstonLogger } from './winston.interface';
-import { LoggerCtx } from '../../types';
-
-export class WinstonLoggerService implements IWinstonLogger {
-  constructor(private readonly logger: Logger) {}
-
-  info(message: string, meta: LoggerCtx): void {
-    this.logger.info(message, meta);
-  }
-
-  warn(message: string, meta: LoggerCtx): void {
-    this.logger.warn(message, meta);
-  }
-
-  help(message: string, meta: LoggerCtx): void {
-    this.logger.help(message, meta);
-  }
-
-  data(message: string, meta: LoggerCtx): void {
-    this.logger.data(message, meta);
-  }
-
-  debug(message: string, meta: LoggerCtx): void {
-    this.logger.debug(message, meta);
-  }
-  prompt(message: string, meta: LoggerCtx): void {
-    this.logger.prompt(message, meta);
-  }
-
-  http(message: string, meta: LoggerCtx): void {
-    this.logger.http(message, meta);
-  }
-
-  verbose(message: string, meta: LoggerCtx): void {
-    this.logger.verbose(message, meta);
-  }
-
-  input(message: string, meta: LoggerCtx): void {
-    this.logger.input(message, meta);
-  }
-
-  silly(message: string, meta: LoggerCtx): void {
-    this.logger.silly(message, meta);
-  }
-
-  error(message: string, meta: LoggerCtx): void {
-    this.logger.error(message, meta);
-  }
-
-  // Add other methods for different logging levels as needed
-}

package/src/modules/tracer/tracer.middleware.ts

@@ -1,38 +0,0 @@
-import { Inject, Injectable, NestMiddleware } from '@nestjs/common';
-import { randomUUID } from 'crypto';
-import { NextFunction, Request, Response } from 'express';
-export const X_REQUEST_ID_HEADER = 'X-Request-ID';
-export const X_RESPONSE_ID_HEADER = 'X-Response-ID';
-import { ConfigurableModuleBuilder } from '@nestjs/common';
-import { RouteInfo } from '@nestjs/common/interfaces';
-import { Ctx } from '../../types';
-
-interface CtxLocal {
-  local: Ctx;
-}
-type CtxLocalRequest = Request & Ctx;
-
-export interface TracingModuleOptions {
-  routes: (string | RouteInfo)[];
-  excludedRoutes?: (string | RouteInfo)[];
-  onRequest?(uuid: string, next: NextFunction): void;
-}
-
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } =
-  new ConfigurableModuleBuilder<TracingModuleOptions>().build();
-
-@Injectable()
-export class TracerMiddleware implements NestMiddleware {
-  constructor(
-    @Inject(MODULE_OPTIONS_TOKEN)
-    protected readonly options: typeof OPTIONS_TYPE,
-  ) {}
-
-  async use(req: CtxLocalRequest & CtxLocal, res: Response, next: NextFunction) {
-    const { onRequest = (_, next) => next() } = this.options;
-    const uuid = req.header(X_REQUEST_ID_HEADER) ?? randomUUID();
-    req.local = { traceId: uuid };
-    res.setHeader(X_RESPONSE_ID_HEADER, uuid);
-    onRequest(uuid, next);
-  }
-}

package/src/modules/tracer/tracer.module.ts

@@ -1,18 +0,0 @@
-import { Inject, MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
-import { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, TracerMiddleware } from './tracer.middleware';
-
-@Module({})
-export class TracerModule extends ConfigurableModuleClass implements NestModule {
-  constructor(
-    @Inject(MODULE_OPTIONS_TOKEN)
-    protected readonly options: typeof OPTIONS_TYPE,
-  ) {
-    super();
-  }
-
-  configure(consumer: MiddlewareConsumer) {
-    const config = consumer.apply(TracerMiddleware);
-    if (this.options.excludedRoutes) config.exclude(...this.options.excludedRoutes);
-    config.forRoutes(...this.options.routes);
-  }
-}

package/src/types/auth.ts

@@ -1,37 +0,0 @@
-export type UserPermission = {
-  sectionId: number;
-  name: string;
-  category: string;
-  crudPermissions: Array<'r' | 'e' | 'd'>;
-};
-
-export type User = {
-  id: number;
-  role: Role;
-  name: string;
-  userProfileId: number;
-  permissions: UserPermission[];
-  // tenant:Tenant
-};
-
-export type Ctx = {
-  traceId: string;
-  user?: User;
-  auth?: Auth;
-};
-
-export type LoggerCtx = Ctx & {
-  className: string;
-  methodName: string;
-  [key: string]: any; // Allows for any number of additional properties
-};
-
-export enum Role {
-  User = 'user',
-  Admin = 'admin',
-  Agent = 'agent',
-}
-
-export type Auth = {
-  token: string;
-};

package/src/types/index.ts

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