The original Nest ConfigService cannot be extended without overriding it from the Nest ConfigModule. If your custom service is not provided in any module but still being injected into your UsersService, it will inevitably cause errors.

To resolve this issue, you need to create your own ConfigModule that utilizes both NestConfigModule and includes provision for your custom ConfigService:

import { ConfigModule as NestConfigModule } from '@nestjs/config';
import { ConfigService } from './config.service';
import { Module } from '@nestjs/common';

@Module({
  exports: [ConfigService],
  imports: [NestConfigModule.forRoot()],
  providers: [ConfigService],
})
export class ConfigModule {}

After attempting @reginald's code without success, it seems that the issue lies in NestConfigModule.forRoot using the internal ConfigService instead of your extended class.

View the source code here

By implementing a custom provider, I managed to make it work. Although I'm new to nestjs and it might not be considered best practices, you can give it a try.

// configuration.ts
const getConfiguration = () => ({key:'value'})

// config.service.ts
import { ConfigService as NestConfigService } from '@nestjs/config';
import { getConfiguration } from './configuration';

export class ConfigService extends NestConfigService<ReturnType<typeof getConfiguration>> {}

// config.module.ts
import { Module, Global } from '@nestjs/common';
import { ConfigService } from './config.service';
import { getConfiguration } from './configuration';

@Global()
@Module({
  exports: [ConfigService],
  providers: [
    {
      provide: ConfigService,
      useFactory() {
        return new ConfigService(getConfiguration());
      },
    },
  ],
})
export class ConfigModule {}

When using the nestjs config module, it utilizes its own ConfigService for its providers. Here is an example of what their provider may look like (though simplified):

const providers = [
{ provide: CONFIGURATION_SERVICE_TOKEN, useClass: ConfigService },
{
  provide: ConfigService,
    useFactory: (configService: ConfigService) => {
      if (options.cache) {
        (configService as any).isCacheEnabled = true;
      }
      return configService;
    },
    inject: [CONFIGURATION_SERVICE_TOKEN],
  }
]

The implementation in nestjs-typed-config could serve as a good reference for your situation. This custom config module has a static method forRoot, where the input parameter is the config service required. It also supports dependency injection.

export class TypedConfigModule {
  static forRoot(
    configService: typeof BaseTypedConfigService<any>,
    options: ConfigModuleOptions,
  ) {
    const configModule = ConfigModule.forRoot(options);
    configModule.providers?.push({
      provide: TYPED_CONFIG_SERVICE_INJECT_TOKEN,
      useClass: configService,
    });
    configModule.providers?.push({
      provide: configService,
      useFactory: (typedConfigService: BaseTypedConfigService<any>) => {
        (typedConfigService as any).isCacheEnabled = !!options.cache;
        return typedConfigService;
      },
      inject: [TYPED_CONFIG_SERVICE_INJECT_TOKEN],
    });
    configModule.exports?.push(configService);
    return configModule;
  }
}

If you are interested in utilizing ConfigService, you can explore nestjs-typed-config.

In the absence of a complete accepted answer in this post, I have compiled one by combining multiple up-voted comments. Here is my solution for extending the ConfigService to include a method for creating a plain object to provide to client instances:

app.module.cs

import { ConfigModule } from './config/config.module';
@Module({
  imports: [
    ConfigModule
  ],
  controllers: [],
  providers: [ MyClass ],
})
export class AppModule {}

config/config.module

import { Global, Module } from '@nestjs/common';
import { ConfigService } from "./config.service";
import { ConfigModule as NestConfigModule } from '@nestjs/config'; // <- mind the alias!

@Global()
@Module({
  exports: [ConfigService],
  imports: [NestConfigModule.forRoot({
    envFilePath: 'config.env', // <- just an .env file
  })],
  providers: [ConfigService],

})

export class ConfigModule {}

config/config.service

import { ConfigService as NestConfigService } from '@nestjs/config';
import { Logger } from "@nestjs/common";

interface MyEnvVars {
  USER: string;
  TOKEN: string;
}
export class ConfigService extends NestConfigService<MyEnvVars> {  // <-- brings
  private readonly logger = new Logger(ConfigService.name);

  constructor() {
    super();
    this.logger.log('Custom ConfigService initialized'); // <-- just for better visibility
  }

  public createCredentialsFromConfig = (): { user: string; token: string; } => {
    const user = this.getOrThrow<string>('USER', undefined);
    const token = this.get<string>('TOKEN', undefined);
    if (!(user && token)) {
      this.logger.error('check your config!');
    }
    this.logger.log('I got your token');  // <-- just for better visibility
    return { user, token };
  }
}

my-class.ts

import { Injectable, Logger } from '@nestjs/common';
import { ConfigService } from "../config/config.service";

@Injectable()
export class MyClass {
  private readonly logger = new Logger(MyClass.name);

  constructor(
      private readonly configService: ConfigService, // <-- injected is custom ConfigService
  ) { }

  public doSomething() {
    console.log(this.configService.createCredentialsFromConfig());
  }
}

Working flawlessly on my machine! 🚀