Fatal编程技术网
  • dependency-injection/
  • Dependency injection '；请求'；对象在NestJS动态模块中始终未定义

Dependency injection '；请求'；对象在NestJS动态模块中始终未定义

dependency-injection nestjs

Dependency injection '；请求'；对象在NestJS动态模块中始终未定义,dependency-injection,nestjs,Dependency Injection,Nestjs,我创建了一些动态模块（log.module.ts） 和提供程序（log.provider.ts） 我的问题是，在“LoggerService”上，我试图获取Documanation中的“REQUEST”对象：但总是未定义的。。（log.service.ts） 我的案例与文档不同，因为我使用new关键字初始化我的服务，并在“useFactory”上返回该关键字 谢谢你的帮助 因此，对于任何有类似问题的人来说：问题在于“winston”选项的实现 这是我使用winston实现的记录器，如果您有任何问

我创建了一些动态模块（log.module.ts）

和提供程序（log.provider.ts）

我的问题是，在“LoggerService”上，我试图获取Documanation中的“REQUEST”对象：但总是未定义的。。（log.service.ts）

我的案例与文档不同，因为我使用new关键字初始化我的服务，并在“useFactory”上返回该关键字

谢谢你的帮助

因此，对于任何有类似问题的人来说：问题在于“winston”选项的实现

这是我使用winston实现的记录器，如果您有任何问题，可以问我：

logger.module.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
logger.providers.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
logger.service.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
logger.interfaces.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
logger.interfaces.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
而且…您可以在项目中的任何其他模块中使用它

在模块文件中，在“导入”中添加LoggerModule：

  LoggerModule.forRoot({
  options: loggerOptions('user', 'user', 'json', 'error'), name: 'user'
})
然后，在控制器/服务中，使用依赖项注入在构造函数中获得记录器对象：

constructor(private readonly logger: LoggerService ) { }
因此，对于任何有类似问题的人来说：问题在于“winston”选项的实现

这是我使用winston实现的记录器，如果您有任何问题，可以问我：

logger.module.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
logger.providers.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
logger.service.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
logger.interfaces.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
logger.interfaces.ts

import { DynamicModule, Module } from '@nestjs/common';
import { WinstonModuleOptions } from './logger.interfaces';
import { createWinstonProviders } from './logger.providers';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  exports: [LoggerService],
}) export class LoggerModule {
  public static forRoot(options?: WinstonModuleOptions): DynamicModule {
    const providers = createWinstonProviders(options);
    return {
      module: LoggerModule,
      providers: providers,
      exports: providers,
    };
  }
}

  import { Provider, Scope } from '@nestjs/common';
  import { WinstonModuleOptions } from './logger.interfaces';

  export function createWinstonProviders(loggerOptions: WinstonModuleOptions): Provider[] {
  return [
    {
      provide: 'loggerOptions',
      useValue: loggerOptions || null,
      scope: Scope.TRANSIENT
    },
  ];
}

 import * as winston from 'winston';
    import { Injectable, Scope, Inject } from '@nestjs/common';
    import { REQUEST } from '@nestjs/core';
    import { Request } from 'express';
    import { WinstonModuleOptions } from './logger.interfaces';
    import { defaultLoggerOptions } from './logger.constants';

    @Injectable({
      scope: Scope.TRANSIENT
    })
    export class LoggerService {
      private name: string;

      constructor(@Inject('loggerOptions') private readonly loggerOptions: WinstonModuleOptions, @Inject(REQUEST) private readonly request: Request) {
        this.name = loggerOptions.name;
        winston.loggers.add(this.loggerOptions.name, loggerOptions.options || defaultLoggerOptions());
      }

      private logMessage(message, level) {
        const logger = winston.loggers.get(this.name);
        if (logger) {
          logger.log({
            level,
            message: message
          })
        }
      }

      error(message: string) {
        this.logMessage(message, 'error');
      }

      log(message: string) {
        this.logMessage(message, 'info');
      }

      warn(message: string) {
        this.logMessage(message, 'warn');
      }

      info(message: string) {
        this.logMessage(message, 'info');
      }
    }

import { LoggerOptions } from 'winston';

export type WinstonModuleOptions = { options: LoggerOptions, name: string };

import * as winston from 'winston';

export const defaultLoggerOptions = () => ({
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(), winston.format.simple())
    })
  ],
});

export const loggerOptions = (logGroupName: string, logStreamName: string, format: string = 'simple', level: string = 'error') =>
  ({
    transports: [
      new winston.transports.Console({
        format: format === 'json' ? winston.format.combine(
          winston.format.colorize(),
          winston.format.json()
        ) : winston.format.combine(
          winston.format.colorize(),
          winston.format.simple()
        )
      })
    ]
  });
而且…您可以在项目中的任何其他模块中使用它

在模块文件中，在“导入”中添加LoggerModule：

  LoggerModule.forRoot({
  options: loggerOptions('user', 'user', 'json', 'error'), name: 'user'
})
然后，在控制器/服务中，使用依赖项注入在构造函数中获得记录器对象：

constructor(private readonly logger: LoggerService ) { }