カスタムプロバイダ — useValue / useFactory / useClass のサンプルコード — NestJS

1クラス省略形の正体は useClass

providers にクラスを並べるだけの書き方が、provide と useClass を組にした省略形であることを示します。両者はまったく同じ意味で、フルの形を知っておくと次の useValue / useFactory への発展が理解しやすくなります。

import { Module } from "@nestjs/common";
import { UsersService } from "./users.service";

@Module({
  // この2つはまったく同じ意味
  providers: [
    UsersService, // 省略形
    // { provide: UsersService, useClass: UsersService }, // フルの形
  ],
})
export class UsersModule {}

2useValue で固定値を注入する

設定オブジェクトや定数のような「生成不要の固定値」は useValue で注入します。トークンに文字列を使った場合、受け取る側は @Inject("トークン名") を明示する必要がある点が、クラスをトークンにする場合との違いです。

import { Module, Injectable, Inject } from "@nestjs/common";

@Injectable()
export class MailService {
  // 文字列トークンは @Inject で明示して受け取る
  constructor(@Inject("MAIL_CONFIG") private cfg: { from: string }) {}
  sender() {
    return this.cfg.from;
  }
}

@Module({
  providers: [
    { provide: "MAIL_CONFIG", useValue: { from: "noreply@example.com" } },
    MailService,
  ],
})
export class MailModule {}

3useFactory の本質をプレーンTSで再現

useFactory の「トークンごとにファクトリ関数で値を生成し、inject で指定した依存も渡す」という核心を、デコレータなしの簡易コンテナで再現した実行例です。useValue と useFactory の両方を1つのコンテナで解決する流れが追えます。

TypeScript

// カスタムプロバイダ(useValue / useFactory)の本質を Map で再現
type Provider =
  | { provide: string; useValue: unknown }
  | {
      provide: string;
      useFactory: (...deps: any[]) => unknown;
      inject?: string[];
    };

class MiniContainer {
  private resolved = new Map<string, unknown>();

  constructor(providers: Provider[]) {
    for (const p of providers) {
      if ("useValue" in p) {
        this.resolved.set(p.provide, p.useValue); // 固定値
      } else {
        // inject のトークンを先に解決し、ファクトリに渡す
        const deps = (p.inject ?? []).map((t) => this.get(t));
        this.resolved.set(p.provide, p.useFactory(...deps));
      }
    }
  }

  get<T>(token: string): T {
    if (!this.resolved.has(token)) throw new Error("未登録: " + token);
    return this.resolved.get(token) as T;
  }
}

const container = new MiniContainer([
  { provide: "CONFIG", useValue: { dbName: "app" } },
  {
    provide: "DB_CLIENT", // CONFIG を読んでクライアントを組み立てる
    useFactory: (config: { dbName: string }) => ({
      connectedTo: config.dbName,
    }),
    inject: ["CONFIG"],
  },
]);

console.log("CONFIG.dbName: " + container.get<{ dbName: string }>("CONFIG").dbName);
const client = container.get<{ connectedTo: string }>("DB_CLIENT");
console.log("DB_CLIENT.connectedTo: " + client.connectedTo);

// カスタムプロバイダ(useValue / useFactory)の本質を Map で再現
type Provider =
  | { provide: string; useValue: unknown }
  | {
      provide: string;
      useFactory: (...deps: any[]) => unknown;
      inject?: string[];
    };

class MiniContainer {
  private resolved = new Map<string, unknown>();

constructor(providers: Provider[]) {
    for (const p of providers) {
      if ("useValue" in p) {
        this.resolved.set(p.provide, p.useValue); // 固定値
      } else {
        // inject のトークンを先に解決し、ファクトリに渡す
        const deps = (p.inject ?? []).map((t) => this.get(t));
        this.resolved.set(p.provide, p.useFactory(...deps));
      }
    }
  }

get<T>(token: string): T {
    if (!this.resolved.has(token)) throw new Error("未登録: " + token);
    return this.resolved.get(token) as T;
  }
}

const container = new MiniContainer([
  { provide: "CONFIG", useValue: { dbName: "app" } },
  {
    provide: "DB_CLIENT", // CONFIG を読んでクライアントを組み立てる
    useFactory: (config: { dbName: string }) => ({
      connectedTo: config.dbName,
    }),
    inject: ["CONFIG"],
  },
]);

console.log("CONFIG.dbName: " + container.get<{ dbName: string }>("CONFIG").dbName);
const client = container.get<{ connectedTo: string }>("DB_CLIENT");
console.log("DB_CLIENT.connectedTo: " + client.connectedTo);

4useFactory の解決順序を再現

useFactory が inject の依存を先に解決してから自分を生成する、という順序を生成ログで可視化した実行例です。登録順ではなく依存関係に沿って組み立てられることが、出力されるログの並びから確認できます。

TypeScript

// useFactory の inject 依存が「先に」解決される様子をログで可視化
type Factory = { provide: string; useFactory: () => unknown; inject: string[] };

const store = new Map<string, unknown>();

// 依存を解決してから自分を生成する(NestJS の解決順序と同じ)
function resolve(token: string, defs: Factory[]): unknown {
  if (store.has(token)) return store.get(token);
  const def = defs.find((d) => d.provide === token);
  if (!def) throw new Error("未登録: " + token);
  for (const dep of def.inject) resolve(dep, defs); // 依存を先に
  console.log("生成: " + token);
  const value = def.useFactory();
  store.set(token, value);
  return value;
}

// あえて依存先(CONFIG)を後ろに登録しても、先に生成される
const defs: Factory[] = [
  { provide: "DB_CLIENT", useFactory: () => ({ ok: true }), inject: ["CONFIG"] },
  { provide: "CONFIG", useFactory: () => ({ dbName: "app" }), inject: [] },
];

resolve("DB_CLIENT", defs);
// 出力は「生成: CONFIG → 生成: DB_CLIENT」の順になる

5実務: 環境ごとに useClass で実装を差し替える

本番では本物の決済クライアント、開発ではログを出すだけの偽実装、というように環境変数で実装を丸ごと差し替える実務例です。注入側は共通のインターフェースしか知らないため、差し替えても呼び出しコードは一切変わりません。

import { Module } from "@nestjs/common";

// 注入側はこのインターフェースだけに依存する
export interface PaymentClient {
  charge(amount: number): Promise<string>;
}

export class StripePaymentClient implements PaymentClient {
  async charge(amount: number) {
    return "stripe:" + amount; // 本物の決済 API を叩く
  }
}
export class FakePaymentClient implements PaymentClient {
  async charge(amount: number) {
    return "fake:" + amount; // 開発用。実際には課金しない
  }
}

@Module({
  providers: [
    {
      provide: "PAYMENT_CLIENT",
      // 環境変数で実装を丸ごと差し替える(呼び出し側は無変更)
      useClass:
        process.env.NODE_ENV === "production"
          ? StripePaymentClient
          : FakePaymentClient,
    },
  ],
  exports: ["PAYMENT_CLIENT"],
})
export class PaymentModule {}

サンプルコードで身につける: カスタムプロバイダ — useValue / useFactory / useClass

1クラス省略形の正体は useClass

2useValue で固定値を注入する

3useFactory の本質をプレーンTSで再現

4useFactory の解決順序を再現

5実務: 環境ごとに useClass で実装を差し替える