How to register `JwtModule` with secret globally? about jwt HOT 10 CLOSED

@Module({
  imports: [
    {
      ...JwtModule.register({
        secret: process.env.SECRET
      }),
      global: true
    }
  ],
  exports: [JwtModule]
})
export class CoreModule {}

{
   ...
   imports: [
      {
           ...JwtModule.register(options),
           global: true
      }
   ]
   ...
}

import { DynamicModule, Global, Module } from "@nestjs/common";
import {
  JwtModuleAsyncOptions,
  JwtModuleOptions,
} from "@nestjs/jwt";
import { PassportModule } from "@nestjs/passport";
import { JWT_OPTIONS } from "./config";
import { JwtDomainService } from "./services/jwt-domain.service";
import { JwtStrategy } from "./strategies";

@Global()
@Module({})
export class JwtDomainModule {
  static forRoot(options: JwtModuleOptions): DynamicModule {
    const module: DynamicModule = {
      global: true,
      module: JwtDomainModule,
      imports: [PassportModule],
      providers: [
        JwtStrategy,
        JwtDomainService,
        {
          provide: JWT_OPTIONS,
          useValue: options,
        },
      ],
      exports: [JwtDomainService],
    };

    return module;
  }

  static forRootAsync(options: JwtModuleAsyncOptions): DynamicModule {
    const module: DynamicModule = {
      global: true,
      module: JwtDomainModule,
      imports: [...(options.imports || []), PassportModule],
      providers: [
        JwtStrategy,
        JwtDomainService,
        {
          provide: JWT_OPTIONS,
          useFactory: async (...args) => {
            let config = options.useFactory(...args);

            if (config instanceof Promise) config = await config;

            return config;
          },
          inject: options.inject || [],
        },
      ],
      exports: [JwtDomainService],
    };

    return module;
  }
}

export const JWT_OPTIONS = "JWT_OPTIONS";

import { Inject, Injectable } from "@nestjs/common";
import { JwtModuleOptions, JwtService } from "@nestjs/jwt";
import { JWT_OPTIONS } from "../config";

@Injectable()
export class JwtDomainService extends JwtService {
  constructor(@Inject(JWT_OPTIONS) options: JwtModuleOptions) {
    super(options);
  }
}

import { Inject, Injectable } from "@nestjs/common";
import { PassportStrategy } from "@nestjs/passport";
import { ExtractJwt, Strategy } from "passport-jwt";

import { JwtTokenPayload } from "../interfaces";
import { JWT_OPTIONS } from "../config";
import { JwtModuleOptions } from "@nestjs/jwt";

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(@Inject(JWT_OPTIONS) options: JwtModuleOptions) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: options.secret,
      jsonWebTokenOptions: { ignoreExpiration: false },
    });
  }

/// JwtTokenPayload is my custom interface that extends the JwtToken to include private claims
  validate(payload: JwtTokenPayload): JwtTokenPayload {
    return payload;
  }
}