// 従来の設計（制御はアプリケーション側）
class UserService {
  private userRepo: IUserRepository;
 
  constructor() {
    // 自分で依存を生成
    this.userRepo = new PostgresUserRepository();
  }
}
 
// IoC 適用後（制御はコンテナ側）
class UserService {
  constructor(
    private readonly userRepo: IUserRepository // コンテナが注入
  ) {}
}
 
// コンテナが UserService の依存を解決して注入
const userService = container.resolve(UserService);

// TypeScript の型システムが依存を保証
interface IUserRepository {
  findById(id: string): Promise<User | null>;
  save(user: User): Promise<void>;
  delete(id: string): Promise<void>;
}
 
interface IEmailService {
  send(to: string, subject: string, body: string): Promise<void>;
}
 
interface ILogger {
  info(message: string, meta?: Record<string, unknown>): void;
  error(message: string, error?: unknown): void;
}
 
// コンストラクタ注入（最も基本的な DI）
class UserService {
  constructor(
    private readonly userRepo: IUserRepository,
    private readonly emailService: IEmailService,
    private readonly logger: ILogger
  ) {}
 
  async createUser(data: CreateUserDto): Promise<User> {
    this.logger.info("Creating user", { email: data.email });
 
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
 
    await this.userRepo.save(user);
    await this.emailService.send(
      user.email,
      "Welcome!",
      `Hello ${user.name}`
    );
 
    return user;
  }
 
  async deleteUser(id: string): Promise<void> {
    const user = await this.userRepo.findById(id);
    if (!user) {
      throw new Error(`User ${id} not found`);
    }
 
    await this.userRepo.delete(id);
    await this.emailService.send(
      user.email,
      "Account Deleted",
      `Goodbye ${user.name}`
    );
 
    this.logger.info("User deleted", { id });
  }
}

// ドメイン層（型定義）
interface User {
  id: string;
  name: string;
  email: string;
  createdAt: Date;
}
 
interface CreateUserDto {
  name: string;
  email: string;
}
 
// 抽象（インターフェース）
interface IUserRepository {
  findById(id: string): Promise<User | null>;
  findByEmail(email: string): Promise<User | null>;
  save(user: User): Promise<void>;
  delete(id: string): Promise<void>;
}
 
interface IEmailService {
  send(to: string, subject: string, body: string): Promise<void>;
}
 
interface ILogger {
  info(message: string, meta?: Record<string, unknown>): void;
  error(message: string, error?: unknown): void;
  warn(message: string, meta?: Record<string, unknown>): void;
}
 
// 実装（インフラ層）
class PostgresUserRepository implements IUserRepository {
  constructor(private readonly connectionString: string) {}
 
  async findById(id: string): Promise<User | null> {
    // 実際の DB クエリ
    console.log(`SELECT * FROM users WHERE id = '${id}'`);
    return null;
  }
 
  async findByEmail(email: string): Promise<User | null> {
    console.log(`SELECT * FROM users WHERE email = '${email}'`);
    return null;
  }
 
  async save(user: User): Promise<void> {
    console.log(`INSERT INTO users VALUES (...)`, user);
  }
 
  async delete(id: string): Promise<void> {
    console.log(`DELETE FROM users WHERE id = '${id}'`);
  }
}
 
class SmtpEmailService implements IEmailService {
  constructor(private readonly smtpUrl: string) {}
 
  async send(to: string, subject: string, body: string): Promise<void> {
    console.log(`Sending email to ${to}: ${subject}`);
    // 実際の SMTP 送信
  }
}
 
class ConsoleLogger implements ILogger {
  info(message: string, meta?: Record<string, unknown>): void {
    console.log(`[INFO] ${message}`, meta);
  }
 
  error(message: string, error?: unknown): void {
    console.error(`[ERROR] ${message}`, error);
  }
 
  warn(message: string, meta?: Record<string, unknown>): void {
    console.warn(`[WARN] ${message}`, meta);
  }
}
 
// サービス層（ビジネスロジック）
class UserService {
  constructor(
    private readonly userRepo: IUserRepository,
    private readonly emailService: IEmailService,
    private readonly logger: ILogger
  ) {}
 
  async createUser(data: CreateUserDto): Promise<User> {
    this.logger.info("Creating user", { email: data.email });
 
    // ビジネスルール: 重複チェック
    const existing = await this.userRepo.findByEmail(data.email);
    if (existing) {
      throw new Error(`User with email ${data.email} already exists`);
    }
 
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
 
    await this.userRepo.save(user);
    await this.emailService.send(
      user.email,
      "Welcome!",
      `Hello ${user.name}, welcome to our service!`
    );
 
    this.logger.info("User created successfully", { userId: user.id });
    return user;
  }
 
  async deleteUser(id: string): Promise<void> {
    const user = await this.userRepo.findById(id);
    if (!user) {
      throw new Error(`User ${id} not found`);
    }
 
    await this.userRepo.delete(id);
    await this.emailService.send(
      user.email,
      "Account Deleted",
      `Goodbye ${user.name}, your account has been deleted.`
    );
 
    this.logger.info("User deleted", { id });
  }
}
 
// 手動でワイヤリング（Composition Root）
function createApp() {
  // 環境変数から設定を読み込み
  const databaseUrl = process.env.DATABASE_URL || "postgres://localhost/mydb";
  const smtpUrl = process.env.SMTP_URL || "smtp://localhost";
 
  // インフラ層のインスタンス生成
  const logger = new ConsoleLogger();
  const userRepo = new PostgresUserRepository(databaseUrl);
  const emailService = new SmtpEmailService(smtpUrl);
 
  // サービス層のインスタンス生成（依存を注入）
  const userService = new UserService(userRepo, emailService, logger);
 
  return { userService };
}
 
// アプリケーションエントリポイント
const app = createApp();
 
// 使用例
app.userService.createUser({
  name: "Alice",
  email: "alice@example.com",
});

// 関数を依存として注入
type GenerateId = () => string;
type GetCurrentTime = () => Date;
 
class OrderService {
  constructor(
    private readonly generateId: GenerateId,
    private readonly getCurrentTime: GetCurrentTime,
    private readonly logger: ILogger
  ) {}
 
  createOrder(userId: string, items: OrderItem[]): Order {
    const order: Order = {
      id: this.generateId(), // 注入された関数を使用
      userId,
      items,
      createdAt: this.getCurrentTime(), // 注入された関数を使用
      status: "pending",
    };
 
    this.logger.info("Order created", { orderId: order.id });
    return order;
  }
}
 
// 本番環境
const orderService = new OrderService(
  () => crypto.randomUUID(), // 実際の UUID 生成
  () => new Date(), // 実際の現在時刻
  new ConsoleLogger()
);
 
// テスト環境
const testOrderService = new OrderService(
  () => "test-id-123", // 固定 ID
  () => new Date("2024-01-01"), // 固定時刻
  new MockLogger()
);

// ファクトリを依存として注入
interface IUserRepositoryFactory {
  create(connectionString: string): IUserRepository;
}
 
class PostgresUserRepositoryFactory implements IUserRepositoryFactory {
  create(connectionString: string): IUserRepository {
    return new PostgresUserRepository(connectionString);
  }
}
 
class MultiTenantUserService {
  constructor(
    private readonly repoFactory: IUserRepositoryFactory,
    private readonly emailService: IEmailService,
    private readonly logger: ILogger
  ) {}
 
  async createUserForTenant(
    tenantId: string,
    data: CreateUserDto
  ): Promise<User> {
    // テナントごとに異なる DB 接続を使用
    const connectionString = `postgres://localhost/${tenantId}`;
    const userRepo = this.repoFactory.create(connectionString);
 
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
 
    await userRepo.save(user);
    await this.emailService.send(
      user.email,
      "Welcome!",
      `Hello ${user.name}`
    );
 
    this.logger.info("User created for tenant", { tenantId, userId: user.id });
    return user;
  }
}

// inversify は reflect-metadata が必要
import "reflect-metadata";
import { Container, injectable, inject, interfaces } from "inversify";
 
// シンボルでトークンを定義（文字列の衝突を防止）
const TYPES = {
  UserRepository: Symbol.for("UserRepository"),
  OrderRepository: Symbol.for("OrderRepository"),
  EmailService: Symbol.for("EmailService"),
  Logger: Symbol.for("Logger"),
  Database: Symbol.for("Database"),
  UserService: Symbol.for("UserService"),
  OrderService: Symbol.for("OrderService"),
} as const;
 
// 実装クラスに @injectable デコレータ
@injectable()
class PostgresDatabase {
  constructor() {
    console.log("PostgresDatabase initialized");
  }
 
  async query(sql: string): Promise<any[]> {
    console.log(`Executing: ${sql}`);
    return [];
  }
 
  async close(): Promise<void> {
    console.log("Database connection closed");
  }
}
 
@injectable()
class PostgresUserRepository implements IUserRepository {
  constructor(
    @inject(TYPES.Database) private readonly db: PostgresDatabase
  ) {}
 
  async findById(id: string): Promise<User | null> {
    const results = await this.db.query(`SELECT * FROM users WHERE id = '${id}'`);
    return results[0] || null;
  }
 
  async findByEmail(email: string): Promise<User | null> {
    const results = await this.db.query(`SELECT * FROM users WHERE email = '${email}'`);
    return results[0] || null;
  }
 
  async save(user: User): Promise<void> {
    await this.db.query(`INSERT INTO users VALUES (...)`);
  }
 
  async delete(id: string): Promise<void> {
    await this.db.query(`DELETE FROM users WHERE id = '${id}'`);
  }
}
 
@injectable()
class PostgresOrderRepository {
  constructor(
    @inject(TYPES.Database) private readonly db: PostgresDatabase
  ) {}
 
  async findById(id: string): Promise<Order | null> {
    const results = await this.db.query(`SELECT * FROM orders WHERE id = '${id}'`);
    return results[0] || null;
  }
 
  async save(order: Order): Promise<void> {
    await this.db.query(`INSERT INTO orders VALUES (...)`);
  }
}
 
@injectable()
class SmtpEmailService implements IEmailService {
  async send(to: string, subject: string, body: string): Promise<void> {
    console.log(`Sending email to ${to}: ${subject}`);
  }
}
 
@injectable()
class ConsoleLogger implements ILogger {
  info(message: string, meta?: Record<string, unknown>): void {
    console.log(`[INFO] ${message}`, meta);
  }
 
  error(message: string, error?: unknown): void {
    console.error(`[ERROR] ${message}`, error);
  }
 
  warn(message: string, meta?: Record<string, unknown>): void {
    console.warn(`[WARN] ${message}`, meta);
  }
}
 
// サービスクラスに @inject で依存を宣言
@injectable()
class UserService {
  constructor(
    @inject(TYPES.UserRepository) private readonly userRepo: IUserRepository,
    @inject(TYPES.EmailService) private readonly emailService: IEmailService,
    @inject(TYPES.Logger) private readonly logger: ILogger
  ) {}
 
  async createUser(data: CreateUserDto): Promise<User> {
    this.logger.info("Creating user", { email: data.email });
 
    const existing = await this.userRepo.findByEmail(data.email);
    if (existing) {
      throw new Error(`User with email ${data.email} already exists`);
    }
 
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
 
    await this.userRepo.save(user);
    await this.emailService.send(
      user.email,
      "Welcome!",
      `Hello ${user.name}`
    );
 
    this.logger.info("User created", { userId: user.id });
    return user;
  }
}
 
@injectable()
class OrderService {
  constructor(
    @inject(TYPES.OrderRepository) private readonly orderRepo: PostgresOrderRepository,
    @inject(TYPES.UserRepository) private readonly userRepo: IUserRepository,
    @inject(TYPES.Logger) private readonly logger: ILogger
  ) {}
 
  async createOrder(userId: string, items: OrderItem[]): Promise<Order> {
    const user = await this.userRepo.findById(userId);
    if (!user) {
      throw new Error(`User ${userId} not found`);
    }
 
    const order: Order = {
      id: crypto.randomUUID(),
      userId,
      items,
      createdAt: new Date(),
      status: "pending",
    };
 
    await this.orderRepo.save(order);
    this.logger.info("Order created", { orderId: order.id });
    return order;
  }
}

// コンテナの設定
const container = new Container();
 
// シングルトンスコープ（アプリ全体で1つのインスタンス）
container
  .bind<PostgresDatabase>(TYPES.Database)
  .to(PostgresDatabase)
  .inSingletonScope();
 
container
  .bind<ILogger>(TYPES.Logger)
  .to(ConsoleLogger)
  .inSingletonScope();
 
container
  .bind<IUserRepository>(TYPES.UserRepository)
  .to(PostgresUserRepository)
  .inSingletonScope();
 
container
  .bind<PostgresOrderRepository>(TYPES.OrderRepository)
  .to(PostgresOrderRepository)
  .inSingletonScope();
 
// トランジェントスコープ（毎回新しいインスタンス）
container
  .bind<IEmailService>(TYPES.EmailService)
  .to(SmtpEmailService)
  .inTransientScope(); // 毎回新規作成
 
// リクエストスコープ（リクエスト単位で1つのインスタンス）
container
  .bind<UserService>(TYPES.UserService)
  .to(UserService)
  .inRequestScope(); // リクエストごとに新規作成
 
container
  .bind<OrderService>(TYPES.OrderService)
  .to(OrderService);
 
// 解決
const userService = container.get<UserService>(TYPES.UserService);
const orderService = container.get<OrderService>(TYPES.OrderService);
 
// 全ての依存が自動的に注入される
await userService.createUser({
  name: "Bob",
  email: "bob@example.com",
});

import { ContainerModule, interfaces } from "inversify";
 
// インフラ層モジュール
const infrastructureModule = new ContainerModule((bind: interfaces.Bind) => {
  bind<ILogger>(TYPES.Logger)
    .to(ConsoleLogger)
    .inSingletonScope();
 
  bind<PostgresDatabase>(TYPES.Database)
    .to(PostgresDatabase)
    .inSingletonScope();
});
 
// リポジトリ層モジュール
const repositoryModule = new ContainerModule((bind: interfaces.Bind) => {
  bind<IUserRepository>(TYPES.UserRepository)
    .to(PostgresUserRepository)
    .inSingletonScope();
 
  bind<PostgresOrderRepository>(TYPES.OrderRepository)
    .to(PostgresOrderRepository)
    .inSingletonScope();
});
 
// サービス層モジュール
const serviceModule = new ContainerModule((bind: interfaces.Bind) => {
  bind<IEmailService>(TYPES.EmailService)
    .to(SmtpEmailService)
    .inTransientScope();
 
  bind<UserService>(TYPES.UserService)
    .to(UserService);
 
  bind<OrderService>(TYPES.OrderService)
    .to(OrderService);
});
 
// コンテナにモジュールをロード
const container = new Container();
container.load(
  infrastructureModule,
  repositoryModule,
  serviceModule
);
 
export { container };

// 環境に応じて実装を切り替え
const container = new Container();
 
if (process.env.NODE_ENV === "production") {
  container
    .bind<ILogger>(TYPES.Logger)
    .to(CloudWatchLogger)
    .inSingletonScope();
} else if (process.env.NODE_ENV === "test") {
  container
    .bind<ILogger>(TYPES.Logger)
    .to(MockLogger)
    .inSingletonScope();
} else {
  container
    .bind<ILogger>(TYPES.Logger)
    .to(ConsoleLogger)
    .inSingletonScope();
}
 
// 名前付きバインディング
container
  .bind<IUserRepository>(TYPES.UserRepository)
  .to(PostgresUserRepository)
  .whenTargetNamed("postgres");
 
container
  .bind<IUserRepository>(TYPES.UserRepository)
  .to(MongoUserRepository)
  .whenTargetNamed("mongo");
 
// 使用時に名前で指定
@injectable()
class MultiDbService {
  constructor(
    @inject(TYPES.UserRepository) @named("postgres")
    private readonly pgRepo: IUserRepository,
 
    @inject(TYPES.UserRepository) @named("mongo")
    private readonly mongoRepo: IUserRepository
  ) {}
}

// ファクトリ関数でインスタンス生成をカスタマイズ
container
  .bind<IUserRepository>(TYPES.UserRepository)
  .toFactory<IUserRepository>((context: interfaces.Context) => {
    return (tenantId: string) => {
      const db = context.container.get<PostgresDatabase>(TYPES.Database);
      return new TenantUserRepository(db, tenantId);
    };
  });
 
// 使用例
const userRepoFactory = container.get<(tenantId: string) => IUserRepository>(
  TYPES.UserRepository
);
const tenant1Repo = userRepoFactory("tenant-1");
const tenant2Repo = userRepoFactory("tenant-2");

import "reflect-metadata";
import { container, injectable, inject, singleton, scoped, Lifecycle } from "tsyringe";
 
// tsyringe はクラストークンを直接使える
@singleton()
class ConfigService {
  get(key: string): string {
    return process.env[key] ?? "";
  }
}
 
@singleton()
class DatabaseConnection {
  constructor(private readonly config: ConfigService) {
    const url = this.config.get("DATABASE_URL");
    console.log(`Connecting to database: ${url}`);
  }
 
  async query(sql: string): Promise<any[]> {
    console.log(`Query: ${sql}`);
    return [];
  }
}
 
@singleton()
class PostgresUserRepository implements IUserRepository {
  constructor(private readonly db: DatabaseConnection) {}
 
  async findById(id: string): Promise<User | null> {
    await this.db.query(`SELECT * FROM users WHERE id = '${id}'`);
    return null;
  }
 
  async findByEmail(email: string): Promise<User | null> {
    await this.db.query(`SELECT * FROM users WHERE email = '${email}'`);
    return null;
  }
 
  async save(user: User): Promise<void> {
    await this.db.query(`INSERT INTO users VALUES (...)`);
  }
 
  async delete(id: string): Promise<void> {
    await this.db.query(`DELETE FROM users WHERE id = '${id}'`);
  }
}
 
// インターフェーストークン（抽象の場合）
const IEmailServiceToken = Symbol("IEmailService");
 
@injectable()
class SmtpEmailService implements IEmailService {
  constructor(private readonly config: ConfigService) {}
 
  async send(to: string, subject: string, body: string): Promise<void> {
    const smtpUrl = this.config.get("SMTP_URL");
    console.log(`Sending via ${smtpUrl} to ${to}: ${subject}`);
  }
}
 
// トークンで登録
container.register<IEmailService>(IEmailServiceToken, {
  useClass: SmtpEmailService,
});
 
@injectable()
class UserService {
  constructor(
    private readonly userRepo: PostgresUserRepository, // クラス直接指定
    @inject(IEmailServiceToken) private readonly emailService: IEmailService, // トークン指定
    private readonly config: ConfigService
  ) {}
 
  async createUser(data: CreateUserDto): Promise<User> {
    console.log("Creating user:", data.email);
 
    const existing = await this.userRepo.findByEmail(data.email);
    if (existing) {
      throw new Error(`User with email ${data.email} already exists`);
    }
 
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
 
    await this.userRepo.save(user);
    await this.emailService.send(
      user.email,
      "Welcome!",
      `Hello ${user.name}`
    );
 
    return user;
  }
}
 
// 解決
const userService = container.resolve(UserService);
await userService.createUser({
  name: "Charlie",
  email: "charlie@example.com",
});

import { Lifecycle, scoped, injectable } from "tsyringe";
 
// シングルトン（デフォルト）
@singleton()
class AppConfig {
  readonly version = "1.0.0";
}
 
// トランジェント（毎回新規作成）
@injectable()
class RequestLogger {
  private readonly requestId = crypto.randomUUID();
 
  log(message: string) {
    console.log(`[${this.requestId}] ${message}`);
  }
}
 
// スコープ指定でライフサイクル制御
@scoped(Lifecycle.ContainerScoped)
class RequestContext {
  constructor(public readonly requestId: string) {}
}
 
// 手動登録でライフサイクル指定
container.register("DatabasePool", DatabaseConnection, {
  lifecycle: Lifecycle.Singleton,
});
 
container.register("RequestHandler", RequestHandler, {
  lifecycle: Lifecycle.Transient,
});

// ファクトリ登録
container.register("DatabaseConnection", {
  useFactory: (c) => {
    const config = c.resolve(ConfigService);
    const url = config.get("DATABASE_URL");
    return new DatabaseConnection(url);
  },
});
 
// 値の登録
container.register("API_KEY", {
  useValue: process.env.API_KEY,
});
 
container.register("APP_VERSION", {
  useValue: "1.0.0",
});
 
// 使用例
@injectable()
class ApiClient {
  constructor(@inject("API_KEY") private readonly apiKey: string) {}
 
  async fetch(endpoint: string) {
    console.log(`Fetching ${endpoint} with key ${this.apiKey}`);
  }
}

import { container as rootContainer } from "tsyringe";
 
// HTTP リクエストハンドラ
async function handleRequest(req: Request, res: Response) {
  // リクエストごとに子コンテナを作成
  const requestContainer = rootContainer.createChildContainer();
 
  // リクエスト固有の値を登録
  requestContainer.register("RequestId", {
    useValue: crypto.randomUUID(),
  });
 
  requestContainer.register("UserId", {
    useValue: req.headers["x-user-id"],
  });
 
  // リクエストコンテナからサービスを解決
  const userService = requestContainer.resolve(UserService);
 
  // リクエスト処理
  const result = await userService.createUser({
    name: req.body.name,
    email: req.body.email,
  });
 
  res.json(result);
 
  // 子コンテナを破棄（リソース解放）
  requestContainer.dispose();
}

import { inject, delay, injectable } from "tsyringe";
 
// 重い初期化処理を持つクラス
@singleton()
class HeavyService {
  constructor() {
    console.log("HeavyService initializing... (expensive)");
    // 重い初期化処理
  }
 
  process(): string {
    return "processed";
  }
}
 
@injectable()
class OptimizedService {
  constructor(
    // 遅延注入: 実際に使用するまで HeavyService は初期化されない
    @inject(delay(() => HeavyService))
    private readonly heavyServiceFactory: () => HeavyService
  ) {
    console.log("OptimizedService created (HeavyService not yet initialized)");
  }
 
  async doSomething() {
    console.log("Doing lightweight work...");
 
    // 必要になったタイミングで初期化
    const heavyService = this.heavyServiceFactory();
    return heavyService.process();
  }
}
 
const service = container.resolve(OptimizedService);
// この時点では HeavyService はまだ初期化されていない
 
await service.doSomething();
// ここで初めて HeavyService が初期化される

import { Module, Injectable, Inject } from "@nestjs/common";
 
// Provider（DI で管理されるクラス）
@Injectable()
class ConfigService {
  get(key: string): string {
    return process.env[key] ?? "";
  }
}
 
@Injectable()
class DatabaseService {
  constructor(private readonly config: ConfigService) {
    const url = this.config.get("DATABASE_URL");
    console.log(`Database initialized: ${url}`);
  }
 
  async query(sql: string): Promise<any[]> {
    console.log(`Query: ${sql}`);
    return [];
  }
}
 
@Injectable()
class UserRepository {
  constructor(private readonly db: DatabaseService) {}
 
  async findById(id: string): Promise<User | null> {
    await this.db.query(`SELECT * FROM users WHERE id = '${id}'`);
    return null;
  }
 
  async save(user: User): Promise<void> {
    await this.db.query(`INSERT INTO users VALUES (...)`);
  }
}
 
@Injectable()
class UserService {
  constructor(private readonly userRepo: UserRepository) {}
 
  async createUser(data: CreateUserDto): Promise<User> {
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
 
    await this.userRepo.save(user);
    return user;
  }
}
 
// Module（Provider をグループ化）
@Module({
  providers: [ConfigService, DatabaseService, UserRepository, UserService],
  exports: [UserService], // 他のモジュールから使えるようにエクスポート
})
class UserModule {}

import { Module, Provider } from "@nestjs/common";
 
// 値プロバイダ
const configProvider: Provider = {
  provide: "APP_CONFIG",
  useValue: {
    apiKey: process.env.API_KEY,
    appName: "MyApp",
    version: "1.0.0",
  },
};
 
// ファクトリプロバイダ
const databaseProvider: Provider = {
  provide: "DATABASE_CONNECTION",
  useFactory: (config: ConfigService) => {
    const url = config.get("DATABASE_URL");
    return new DatabaseConnection(url);
  },
  inject: [ConfigService], // ファクトリの依存
};
 
// クラスプロバイダ（エイリアス）
const loggerProvider: Provider = {
  provide: "ILogger",
  useClass: process.env.NODE_ENV === "production"
    ? CloudWatchLogger
    : ConsoleLogger,
};
 
// 既存プロバイダ（エイリアス）
const userRepoProvider: Provider = {
  provide: "IUserRepository",
  useExisting: UserRepository,
};
 
@Module({
  providers: [
    ConfigService,
    configProvider,
    databaseProvider,
    loggerProvider,
    UserRepository,
    userRepoProvider,
  ],
})
class AppModule {}
 
// 使用例
@Injectable()
class SomeService {
  constructor(
    @Inject("APP_CONFIG") private readonly config: any,
    @Inject("DATABASE_CONNECTION") private readonly db: DatabaseConnection,
    @Inject("ILogger") private readonly logger: ILogger,
    @Inject("IUserRepository") private readonly userRepo: UserRepository
  ) {}
}

import { Module, Global, DynamicModule } from "@nestjs/common";
 
// グローバルモジュール（全モジュールで使える）
@Global()
@Module({
  providers: [ConfigService, LoggerService],
  exports: [ConfigService, LoggerService],
})
class CoreModule {}
 
// 動的モジュール（設定に応じてプロバイダを変更）
@Module({})
class DatabaseModule {
  static forRoot(options: DatabaseOptions): DynamicModule {
    return {
      module: DatabaseModule,
      providers: [
        {
          provide: "DATABASE_OPTIONS",
          useValue: options,
        },
        {
          provide: DatabaseService,
          useFactory: (opts: DatabaseOptions) => {
            return new DatabaseService(opts);
          },
          inject: ["DATABASE_OPTIONS"],
        },
      ],
      exports: [DatabaseService],
    };
  }
 
  static forFeature(entities: any[]): DynamicModule {
    const providers = entities.map((entity) => ({
      provide: `${entity.name}Repository`,
      useFactory: (db: DatabaseService) => {
        return new Repository(db, entity);
      },
      inject: [DatabaseService],
    }));
 
    return {
      module: DatabaseModule,
      providers,
      exports: providers,
    };
  }
}
 
// 使用例
@Module({
  imports: [
    CoreModule,
    DatabaseModule.forRoot({
      host: "localhost",
      port: 5432,
      database: "mydb",
    }),
    DatabaseModule.forFeature([User, Order]),
  ],
})
class AppModule {}

import { Injectable, Scope, Inject } from "@nestjs/common";
import { REQUEST } from "@nestjs/core";
import { Request } from "express";
 
// リクエストスコープ（リクエストごとに新規作成）
@Injectable({ scope: Scope.REQUEST })
class RequestScopedService {
  constructor(
    @Inject(REQUEST) private readonly request: Request
  ) {
    console.log(`RequestScopedService created for ${request.url}`);
  }
 
  getRequestId(): string {
    return this.request.headers["x-request-id"] as string;
  }
}
 
// トランジェントスコープ（注入されるたびに新規作成）
@Injectable({ scope: Scope.TRANSIENT })
class TransientService {
  private readonly instanceId = crypto.randomUUID();
 
  getInstanceId(): string {
    return this.instanceId;
  }
}
 
// デフォルトスコープ（シングルトン）
@Injectable() // scope: Scope.DEFAULT
class SingletonService {
  private readonly createdAt = new Date();
 
  getCreatedAt(): Date {
    return this.createdAt;
  }
}

// Reader Monad: 依存を「環境」として伝播
type Reader<Env, A> = (env: Env) => A;
 
// 依存の定義
interface Dependencies {
  userRepo: IUserRepository;
  emailService: IEmailService;
  logger: ILogger;
}
 
// Reader Monad を返す関数
function createUser(data: CreateUserDto): Reader<Dependencies, Promise<User>> {
  return async (deps) => {
    deps.logger.info("Creating user", { email: data.email });
 
    const existing = await deps.userRepo.findByEmail(data.email);
    if (existing) {
      throw new Error(`User with email ${data.email} already exists`);
    }
 
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
 
    await deps.userRepo.save(user);
    await deps.emailService.send(
      user.email,
      "Welcome!",
      `Hello ${user.name}`
    );
 
    deps.logger.info("User created", { userId: user.id });
    return user;
  };
}
 
function deleteUser(id: string): Reader<Dependencies, Promise<void>> {
  return async (deps) => {
    const user = await deps.userRepo.findById(id);
    if (!user) {
      throw new Error(`User ${id} not found`);
    }
 
    await deps.userRepo.delete(id);
    await deps.emailService.send(
      user.email,
      "Account Deleted",
      `Goodbye ${user.name}`
    );
 
    deps.logger.info("User deleted", { id });
  };
}
 
// 使用例
const deps: Dependencies = {
  userRepo: new PostgresUserRepository("postgres://localhost/mydb"),
  emailService: new SmtpEmailService("smtp://localhost"),
  logger: new ConsoleLogger(),
};
 
// Reader を実行（依存を注入）
const userReader = createUser({
  name: "David",
  email: "david@example.com",
});
const user = await userReader(deps);
 
const deleteReader = deleteUser(user.id);
await deleteReader(deps);

import { Effect, Context, Layer } from "effect";
 
// サービスの定義（Context を使う）
class UserRepository extends Context.Tag("UserRepository")<
  UserRepository,
  {
    findById: (id: string) => Effect.Effect<never, Error, User | null>;
    save: (user: User) => Effect.Effect<never, Error, void>;
  }
>() {}
 
class EmailService extends Context.Tag("EmailService")<
  EmailService,
  {
    send: (to: string, subject: string, body: string) => Effect.Effect<never, Error, void>;
  }
>() {}
 
class Logger extends Context.Tag("Logger")<
  Logger,
  {
    info: (message: string, meta?: Record<string, unknown>) => Effect.Effect<never, never, void>;
    error: (message: string, error?: unknown) => Effect.Effect<never, never, void>;
  }
>() {}
 
// ビジネスロジック（Effect を返す）
function createUser(data: CreateUserDto) {
  return Effect.gen(function* (_) {
    const userRepo = yield* _(UserRepository);
    const emailService = yield* _(EmailService);
    const logger = yield* _(Logger);
 
    yield* _(logger.info("Creating user", { email: data.email }));
 
    const existing = yield* _(userRepo.findById(data.email));
    if (existing) {
      return yield* _(Effect.fail(new Error(`User ${data.email} exists`)));
    }
 
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
 
    yield* _(userRepo.save(user));
    yield* _(emailService.send(user.email, "Welcome!", `Hello ${user.name}`));
    yield* _(logger.info("User created", { userId: user.id }));
 
    return user;
  });
}
 
// 実装の Layer（依存の実装を提供）
const UserRepositoryLive = Layer.succeed(
  UserRepository,
  {
    findById: (id: string) =>
      Effect.sync(() => {
        console.log(`Finding user ${id}`);
        return null;
      }),
    save: (user: User) =>
      Effect.sync(() => {
        console.log(`Saving user ${user.id}`);
      }),
  }
);
 
const EmailServiceLive = Layer.succeed(
  EmailService,
  {
    send: (to: string, subject: string, body: string) =>
      Effect.sync(() => {
        console.log(`Sending email to ${to}: ${subject}`);
      }),
  }
);
 
const LoggerLive = Layer.succeed(
  Logger,
  {
    info: (message: string, meta?: Record<string, unknown>) =>
      Effect.sync(() => {
        console.log(`[INFO] ${message}`, meta);
      }),
    error: (message: string, error?: unknown) =>
      Effect.sync(() => {
        console.error(`[ERROR] ${message}`, error);
      }),
  }
);
 
// Layer を合成
const AppLayer = Layer.mergeAll(
  UserRepositoryLive,
  EmailServiceLive,
  LoggerLive
);
 
// Effect を実行
const program = createUser({
  name: "Eve",
  email: "eve@example.com",
});
 
const runnable = Effect.provide(program, AppLayer);
await Effect.runPromise(runnable);

// 高階関数で依存を注入
type WithDependencies<T> = (deps: Dependencies) => T;
 
// 依存を持つ関数を合成
function compose<A, B, C>(
  f: (b: B) => C,
  g: (a: A) => B
): (a: A) => C {
  return (a) => f(g(a));
}
 
// 依存を持つ関数の合成
function composeWithDeps<A, B, C>(
  f: WithDependencies<(b: B) => Promise<C>>,
  g: WithDependencies<(a: A) => Promise<B>>
): WithDependencies<(a: A) => Promise<C>> {
  return (deps) => async (a) => {
    const gWithDeps = g(deps);
    const fWithDeps = f(deps);
    const b = await gWithDeps(a);
    return fWithDeps(b);
  };
}
 
// 使用例
const validateUser: WithDependencies<(data: CreateUserDto) => Promise<CreateUserDto>> =
  (deps) => async (data) => {
    deps.logger.info("Validating user", { email: data.email });
    const existing = await deps.userRepo.findByEmail(data.email);
    if (existing) {
      throw new Error(`User ${data.email} already exists`);
    }
    return data;
  };
 
const persistUser: WithDependencies<(data: CreateUserDto) => Promise<User>> =
  (deps) => async (data) => {
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
    await deps.userRepo.save(user);
    return user;
  };
 
const sendWelcomeEmail: WithDependencies<(user: User) => Promise<User>> =
  (deps) => async (user) => {
    await deps.emailService.send(
      user.email,
      "Welcome!",
      `Hello ${user.name}`
    );
    return user;
  };
 
// 関数を合成
const createUserPipeline = (deps: Dependencies) =>
  compose(
    compose(sendWelcomeEmail(deps), persistUser(deps)),
    validateUser(deps)
  );
 
// 実行
const deps: Dependencies = {
  userRepo: new PostgresUserRepository("postgres://localhost/mydb"),
  emailService: new SmtpEmailService("smtp://localhost"),
  logger: new ConsoleLogger(),
};
 
const pipeline = createUserPipeline(deps);
const user = await pipeline({
  name: "Frank",
  email: "frank@example.com",
});

// モック実装
class MockUserRepository implements IUserRepository {
  private users = new Map<string, User>();
 
  async findById(id: string): Promise<User | null> {
    return this.users.get(id) || null;
  }
 
  async findByEmail(email: string): Promise<User | null> {
    for (const user of this.users.values()) {
      if (user.email === email) return user;
    }
    return null;
  }
 
  async save(user: User): Promise<void> {
    this.users.set(user.id, user);
  }
 
  async delete(id: string): Promise<void> {
    this.users.delete(id);
  }
 
  // テスト用ヘルパー
  clear() {
    this.users.clear();
  }
 
  getAll(): User[] {
    return Array.from(this.users.values());
  }
}
 
class MockEmailService implements IEmailService {
  sentEmails: Array<{ to: string; subject: string; body: string }> = [];
 
  async send(to: string, subject: string, body: string): Promise<void> {
    this.sentEmails.push({ to, subject, body });
  }
 
  // テスト用ヘルパー
  clear() {
    this.sentEmails = [];
  }
 
  getSentTo(email: string) {
    return this.sentEmails.filter((e) => e.to === email);
  }
}
 
class MockLogger implements ILogger {
  logs: Array<{ level: string; message: string; meta?: any }> = [];
 
  info(message: string, meta?: Record<string, unknown>): void {
    this.logs.push({ level: "info", message, meta });
  }
 
  error(message: string, error?: unknown): void {
    this.logs.push({ level: "error", message, meta: error });
  }
 
  warn(message: string, meta?: Record<string, unknown>): void {
    this.logs.push({ level: "warn", message, meta });
  }
 
  clear() {
    this.logs = [];
  }
 
  hasLog(level: string, message: string): boolean {
    return this.logs.some(
      (log) => log.level === level && log.message.includes(message)
    );
  }
}
 
// テストコード
import { describe, it, expect, beforeEach } from "vitest";
 
describe("UserService", () => {
  let userService: UserService;
  let mockUserRepo: MockUserRepository;
  let mockEmailService: MockEmailService;
  let mockLogger: MockLogger;
 
  beforeEach(() => {
    mockUserRepo = new MockUserRepository();
    mockEmailService = new MockEmailService();
    mockLogger = new MockLogger();
 
    // モックを注入
    userService = new UserService(
      mockUserRepo,
      mockEmailService,
      mockLogger
    );
  });
 
  it("should create user and send welcome email", async () => {
    const userData: CreateUserDto = {
      name: "Test User",
      email: "test@example.com",
    };
 
    const user = await userService.createUser(userData);
 
    // ユーザーが保存されたか確認
    expect(user.id).toBeDefined();
    expect(user.name).toBe("Test User");
    expect(user.email).toBe("test@example.com");
 
    const savedUser = await mockUserRepo.findById(user.id);
    expect(savedUser).toEqual(user);
 
    // メールが送信されたか確認
    expect(mockEmailService.sentEmails).toHaveLength(1);
    expect(mockEmailService.sentEmails[0].to).toBe("test@example.com");
    expect(mockEmailService.sentEmails[0].subject).toBe("Welcome!");
 
    // ログが記録されたか確認
    expect(mockLogger.hasLog("info", "Creating user")).toBe(true);
    expect(mockLogger.hasLog("info", "User created")).toBe(true);
  });
 
  it("should throw error if user already exists", async () => {
    // 既存ユーザーをセットアップ
    const existingUser: User = {
      id: "existing-id",
      name: "Existing User",
      email: "existing@example.com",
      createdAt: new Date(),
    };
    await mockUserRepo.save(existingUser);
 
    const userData: CreateUserDto = {
      name: "New User",
      email: "existing@example.com", // 同じメール
    };
 
    await expect(userService.createUser(userData)).rejects.toThrow(
      "User with email existing@example.com already exists"
    );
 
    // メールが送信されていないことを確認
    expect(mockEmailService.sentEmails).toHaveLength(0);
  });
 
  it("should delete user and send goodbye email", async () => {
    // ユーザーを作成
    const user: User = {
      id: "test-id",
      name: "Test User",
      email: "test@example.com",
      createdAt: new Date(),
    };
    await mockUserRepo.save(user);
 
    await userService.deleteUser(user.id);
 
    // ユーザーが削除されたか確認
    const deletedUser = await mockUserRepo.findById(user.id);
    expect(deletedUser).toBeNull();
 
    // メールが送信されたか確認
    expect(mockEmailService.sentEmails).toHaveLength(1);
    expect(mockEmailService.sentEmails[0].to).toBe("test@example.com");
    expect(mockEmailService.sentEmails[0].subject).toBe("Account Deleted");
 
    // ログが記録されたか確認
    expect(mockLogger.hasLog("info", "User deleted")).toBe(true);
  });
});