TypeScriptでクラスを使ったデコレーターパターンの実装方法を徹底解説

TypeScriptでクラスを使ったデコレーターパターンの実装は、コードを柔軟に拡張し、再利用可能な機能を追加するための強力な手法です。デコレーターパターンは、オブジェクトに動的に機能を付加できるデザインパターンで、特にアスペクト指向プログラミングやクロスカッティングの関心事を扱う場面で有効です。TypeScriptは、ECMAScriptの標準に準拠しつつ、デコレータを標準機能として提供しており、クラスやメソッド、プロパティに対して柔軟に適用できます。本記事では、デコレーターパターンの基礎からTypeScriptでの実装方法まで、具体的な例を交えて詳しく解説します。

デコレーターパターンとは

デコレーターパターンは、既存のオブジェクトに新たな機能を追加するためのデザインパターンです。このパターンの大きな特徴は、元のオブジェクトを変更せずに動的に機能を拡張できる点にあります。クラスやオブジェクトに直接手を加えることなく、特定の処理を追加したり、既存のメソッドの振る舞いを変更することが可能です。

基本概念と仕組み

デコレーターパターンは、オブジェクトに対して”ラップ”するようにして、新しい振る舞いを追加します。これにより、コードの可読性を保ちながら、動的な拡張を可能にします。また、デコレータは、オブジェクト指向プログラミングの原則である「オープン/クローズド原則」に従います。これは、コードを変更することなく、機能を追加できるという利点を持っています。

実際の使用例

例えば、ログ記録やパフォーマンス計測、認証処理の追加といった、横断的な関心事を効率よく実装する際に利用されます。デコレータを使うことで、これらの処理をメソッドごとに埋め込む必要がなくなり、コードの重複を避けつつ、必要な機能をクラスに付与できます。

TypeScriptにおけるデコレータの仕組み

TypeScriptでは、デコレータを使ってクラスやメソッド、プロパティに機能を追加することが可能です。デコレータは、関数として定義され、クラス定義やメソッドの宣言の上に配置されます。この関数は、クラスやそのメンバーのメタデータにアクセスし、それを変更したり、新たな機能を追加したりすることができます。

デコレータの基本構文

デコレータの構文は、@記号を使って適用されます。例えば、次のようにクラスにデコレータを適用することができます。

function MyDecorator(constructor: Function) {
  console.log("クラスが定義されました: " + constructor.name);
}

@MyDecorator
class MyClass {
  constructor() {
    console.log("MyClassのインスタンスが作成されました");
  }
}

この例では、MyDecoratorというデコレータがクラスの定義に適用されており、クラスのコンストラクタがデコレータ関数に渡されます。デコレータ関数内では、クラス名を取得してログ出力しています。

クラスデコレータ、メソッドデコレータ、プロパティデコレータ

TypeScriptには、次のように3種類のデコレータがあります。

クラスデコレータ：クラス全体に適用され、クラスのコンストラクタにアクセスできます。
メソッドデコレータ：メソッドに適用され、メソッドのプロパティやその動作を変更します。
プロパティデコレータ：クラスのプロパティに適用され、プロパティのメタデータにアクセスできます。

デコレータはこれらの要素に対して柔軟に機能を追加できるため、さまざまなユースケースに対応できます。

クラスデコレータの基本的な使い方

クラスデコレータは、クラス自体に対して機能を追加するために使われるデコレータです。クラスデコレータを使用することで、クラスの振る舞いを変更したり、メタデータを操作したりすることが可能です。基本的には、クラス定義の上にデコレータ関数を適用し、コンストラクタにアクセスしてそのクラスの挙動を拡張します。

クラスデコレータの構文

クラスデコレータの基本的な構文は、次のようになります。

function LogClass(target: Function) {
  console.log(`クラス ${target.name} が作成されました`);
}

@LogClass
class ExampleClass {
  constructor() {
    console.log("ExampleClassのインスタンスが生成されました");
  }
}

この例では、LogClassというデコレータがクラスExampleClassに適用されており、クラスが定義された際にクラス名がコンソールに出力されます。LogClassはクラスのコンストラクタを受け取り、そのクラスに関する情報を出力するシンプルな例です。

クラスの動的な拡張

クラスデコレータは、クラス自体の動作を変更することもできます。例えば、クラスのコンストラクタに新しいプロパティを追加することも可能です。以下の例では、クラスに新しいプロパティを動的に追加しています。

function AddTimestamp(target: Function) {
  return class extends target {
    timestamp = new Date();
  };
}

@AddTimestamp
class TimeStampedClass {}

const instance = new TimeStampedClass();
console.log(instance.timestamp); // 現在の日付が表示される

このデコレータは、TimeStampedClassにtimestampというプロパティを追加し、インスタンスが作成された時点の日付を保持するようにしています。

クラスデコレータの利便性

クラスデコレータは、次のような場面で便利です。

ロギング：クラスの作成や利用に関するログを簡単に出力できる。
メタデータの付与：クラスにメタデータを追加し、その後の処理で利用する。
動的なプロパティ追加：既存のクラスに新しい機能を追加して拡張できる。

クラスデコレータは、コードの拡張性を高めるだけでなく、コードの再利用性を向上させる重要な技術です。

メソッドデコレータの活用方法

メソッドデコレータは、クラス内の特定のメソッドに対して追加の機能や処理を行うために使用されます。これにより、メソッドの実行前後に特定のロジックを注入したり、メソッドの動作をカスタマイズしたりすることが可能です。TypeScriptでは、メソッドデコレータを使用することで、クロスカッティングの関心事（例：ロギングや検証処理）を簡単に適用できます。

メソッドデコレータの基本構文

メソッドデコレータは、メソッド定義の上に@記号で指定されます。デコレータ関数は、メソッドのターゲットオブジェクト、メソッド名、そしてプロパティディスクリプタを引数として受け取ります。これを使って、メソッドの振る舞いを変更することができます。

function LogMethod(
  target: any,
  propertyKey: string,
  descriptor: PropertyDescriptor
) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`メソッド ${propertyKey} が呼び出されました`);
    console.log(`引数:`, args);
    const result = originalMethod.apply(this, args);
    console.log(`結果:`, result);
    return result;
  };
}

class ExampleClass {
  @LogMethod
  add(a: number, b: number): number {
    return a + b;
  }
}

const instance = new ExampleClass();
instance.add(2, 3);

この例では、LogMethodデコレータがaddメソッドに適用されています。デコレータ関数は、メソッドの元の処理を保存し、それをラップする形で追加のロジックを実行します。メソッドが呼び出された際に、引数と結果がコンソールに出力されます。

メソッドデコレータの活用場面

メソッドデコレータは、以下のような場面で役立ちます。

1. ロギング

メソッド呼び出し時の引数や結果をログに記録することが容易です。複数のメソッドで同様の処理を行いたい場合、各メソッドに対してデコレータを適用するだけで対応できます。

2. メソッドの実行前後の処理

メソッドの実行前に前処理を行ったり、実行後に後処理を行うために使用できます。たとえば、トランザクション処理やエラーハンドリングを統一して実装できます。

3. メソッドの実行条件の制御

メソッドの実行前に条件をチェックし、条件が満たされない場合はメソッドの実行をスキップする、といった制御も可能です。

function Validate(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    if (args.some(arg => arg < 0)) {
      throw new Error("負の数は許可されていません");
    }
    return originalMethod.apply(this, args);
  };
}

class Calculator {
  @Validate
  multiply(a: number, b: number): number {
    return a * b;
  }
}

const calc = new Calculator();
console.log(calc.multiply(5, 3)); // OK
// console.log(calc.multiply(-5, 3)); // エラー

この例では、Validateデコレータが適用されており、メソッド実行前に引数が有効かどうかを検証しています。

メソッドデコレータを活用することで、コードの再利用性と可読性を向上させ、複雑な処理をシンプルに管理することができます。

プロパティデコレータとアクセサデコレータ

TypeScriptでは、プロパティやアクセサにもデコレータを適用できます。プロパティデコレータはクラスのプロパティに追加の機能を持たせるために使われ、アクセサデコレータはプロパティのgetterやsetterに対して動作を変更するために利用されます。これにより、データの検証やプロパティの変更を監視するなどの処理を自動化できます。

プロパティデコレータの基本的な使い方

プロパティデコレータは、クラスのプロパティに追加のメタデータを付与するために使用されます。ただし、プロパティの値自体を直接操作することはできません。代わりに、プロパティのメタ情報にアクセスして、プロパティの利用に対する制約を加えるなどの処理が可能です。

function ReadOnly(target: any, propertyKey: string) {
  Object.defineProperty(target, propertyKey, {
    writable: false,
  });
}

class Person {
  @ReadOnly
  name: string = "John Doe";
}

const person = new Person();
person.name = "Jane"; // エラー：このプロパティは読み取り専用です

この例では、ReadOnlyデコレータによって、nameプロパティが読み取り専用に設定されています。デコレータによって定義されたルールが適用され、プロパティの書き換えが制限されています。

アクセサデコレータの基本的な使い方

アクセサデコレータは、プロパティのgetterまたはsetterに対して機能を追加するために使用されます。これにより、プロパティの取得や設定時にカスタムロジックを実行することができます。

function LogAccess(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalGetter = descriptor.get;

  descriptor.get = function () {
    console.log(`プロパティ ${propertyKey} にアクセスしました`);
    return originalGetter?.apply(this);
  };
}

class User {
  private _age: number = 30;

  @LogAccess
  get age() {
    return this._age;
  }
}

const user = new User();
console.log(user.age); // プロパティ age にアクセスしました

この例では、LogAccessデコレータがageプロパティのgetterに適用され、プロパティにアクセスした際にログが出力されるようになっています。

プロパティデコレータとアクセサデコレータの応用

プロパティデコレータとアクセサデコレータは、以下のような場面で効果を発揮します。

1. データの検証

プロパティに値を設定する際に、その値が特定の条件を満たしているかを確認するデコレータを適用できます。たとえば、負の数が設定されないようにする、特定の文字列フォーマットを強制する、といったロジックを簡単に追加できます。

2. プロパティへのアクセス制御

アクセサデコレータを使用して、プロパティへの読み書きの際に特定の条件をチェックし、アクセスを制御することができます。たとえば、認証が必要な場合や、特定のロールが付与されているユーザーのみがアクセスできるプロパティを定義することが可能です。

3. ログの自動記録

アクセサデコレータを使うことで、特定のプロパティにアクセスした際にログを自動的に記録することができます。これは、デバッグやトラッキングのために役立ちます。

プロパティデコレータとアクセサデコレータを効果的に活用することで、データの一貫性を確保しつつ、柔軟なデータ操作を実現できます。

デコレータの応用例

デコレータは、単純なメソッドやプロパティの拡張にとどまらず、実際のプロジェクトでも広く活用できる強力なツールです。ここでは、TypeScriptにおけるデコレータの応用例をいくつか紹介し、デコレータを利用して効率的にコードを管理・拡張する方法を示します。

1. ロールベースのアクセス制御

デコレータを使用することで、メソッドやプロパティに対してロールベースのアクセス制御を簡単に実装できます。例えば、あるメソッドが管理者だけに許可されるようなシステムを作成できます。

function AdminOnly(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    if (this.role !== "admin") {
      throw new Error("この操作は管理者のみ許可されています");
    }
    return originalMethod.apply(this, args);
  };
}

class UserService {
  role: string;

  constructor(role: string) {
    this.role = role;
  }

  @AdminOnly
  deleteUser(userId: number) {
    console.log(`ユーザーID ${userId} を削除しました`);
  }
}

const admin = new UserService("admin");
admin.deleteUser(1); // OK

const guest = new UserService("guest");
// guest.deleteUser(1); // エラー：この操作は管理者のみ許可されています

この例では、AdminOnlyデコレータが適用されたメソッドdeleteUserに対して、管理者のみが実行できるよう制御が追加されています。デコレータを使えば、このようなアクセス制御を簡単に実現できます。

2. APIリクエストのキャッシュ機能

APIのレスポンスをキャッシュし、同じリクエストに対して何度もサーバーにアクセスしないようにする処理を、デコレータを使って実装できます。

function CacheResult(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const cache = new Map();
  const originalMethod = descriptor.value;

  descriptor.value = async function (...args: any[]) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      console.log("キャッシュから結果を取得しました");
      return cache.get(key);
    }
    const result = await originalMethod.apply(this, args);
    cache.set(key, result);
    return result;
  };
}

class APIService {
  @CacheResult
  async fetchData(url: string) {
    console.log(`APIリクエストを送信しています: ${url}`);
    const response = await fetch(url);
    return response.json();
  }
}

const apiService = new APIService();
apiService.fetchData("https://api.example.com/data");

この例では、CacheResultデコレータを用いて、APIリクエストの結果をキャッシュしています。同じ引数でメソッドが呼び出された場合、キャッシュされた結果を返すことで、パフォーマンスの向上を図っています。

3. データバリデーションの自動化

フォームデータの入力検証やAPIリクエストのバリデーション処理をデコレータを使って自動化できます。以下の例では、入力データのバリデーションを行うデコレータを適用しています。

function ValidateInput(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    if (args.some(arg => arg === null || arg === undefined)) {
      throw new Error("無効な入力があります");
    }
    return originalMethod.apply(this, args);
  };
}

class ProductService {
  @ValidateInput
  createProduct(name: string, price: number) {
    console.log(`製品 ${name} を価格 ${price} で作成しました`);
  }
}

const productService = new ProductService();
productService.createProduct("Laptop", 1000); // OK
// productService.createProduct("Laptop", null); // エラー：無効な入力があります

この例では、ValidateInputデコレータを使用して、メソッドに渡される引数がすべて有効であるかをチェックしています。このように、バリデーションロジックを簡潔に追加できるのがデコレータの強みです。

4. メトリクスの収集

パフォーマンスモニタリングや実行回数の追跡といったメトリクスを、デコレータで収集することができます。以下の例では、メソッドの実行時間を計測するデコレータを使用しています。

function MeasureExecutionTime(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    const start = performance.now();
    const result = originalMethod.apply(this, args);
    const end = performance.now();
    console.log(`${propertyKey} の実行時間: ${(end - start).toFixed(2)}ms`);
    return result;
  };
}

class MathService {
  @MeasureExecutionTime
  calculateFibonacci(n: number): number {
    if (n <= 1) return n;
    return this.calculateFibonacci(n - 1) + this.calculateFibonacci(n - 2);
  }
}

const mathService = new MathService();
mathService.calculateFibonacci(10); // 実行時間がコンソールに出力される

この例では、MeasureExecutionTimeデコレータを使用して、calculateFibonacciメソッドの実行時間を計測し、その結果をログに出力しています。

デコレータを活用することで、再利用可能で効率的なコードを実装でき、横断的な関心事をシンプルに管理することが可能です。

デコレータを使ったパフォーマンス向上の工夫

デコレータは、コードの拡張や再利用を容易にするだけでなく、パフォーマンスを向上させるためのさまざまな工夫に活用することができます。キャッシュや遅延実行など、リソースの効率的な利用をサポートするデザインパターンとしても機能します。ここでは、デコレータを使ってどのようにパフォーマンスを改善できるかを具体例を交えて解説します。

1. メモ化（キャッシュ）によるパフォーマンス向上

メモ化（memoization）は、計算結果をキャッシュし、同じ引数に対して再計算せずにキャッシュされた結果を返す手法です。これにより、特に高コストな計算処理やAPIリクエストの回数を減らすことができます。

function Memoize(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  const cache = new Map();

  descriptor.value = function (...args: any[]) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      console.log(`キャッシュを利用: ${key}`);
      return cache.get(key);
    }
    const result = originalMethod.apply(this, args);
    cache.set(key, result);
    return result;
  };
}

class MathService {
  @Memoize
  fibonacci(n: number): number {
    if (n <= 1) return n;
    return this.fibonacci(n - 1) + this.fibonacci(n - 2);
  }
}

const mathService = new MathService();
console.log(mathService.fibonacci(30)); // 初回計算
console.log(mathService.fibonacci(30)); // キャッシュから結果を取得

この例では、Memoizeデコレータを使用して、計算コストの高いfibonacciメソッドにキャッシュ機能を追加しています。これにより、同じ計算を何度も繰り返さず、パフォーマンスが向上します。

2. 遅延実行（Lazy Initialization）

データベース接続や重いリソースの生成など、実際に必要になるまで処理を遅らせる「遅延実行」の技術は、アプリケーションの初期化時の負荷を軽減するために役立ちます。デコレータを使って、特定のメソッドやプロパティの処理を遅延させることができます。

function LazyInit(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  let initialized = false;
  let value: any;

  descriptor.value = function (...args: any[]) {
    if (!initialized) {
      value = originalMethod.apply(this, args);
      initialized = true;
      console.log(`${propertyKey} が初期化されました`);
    }
    return value;
  };
}

class ConfigService {
  @LazyInit
  loadConfig() {
    console.log("設定を読み込んでいます...");
    return { appName: "MyApp", version: "1.0.0" };
  }
}

const configService = new ConfigService();
console.log(configService.loadConfig()); // 初回のみ設定を読み込む
console.log(configService.loadConfig()); // 2回目以降はキャッシュされた結果を返す

この例では、LazyInitデコレータを使用して、設定の読み込み処理を遅延させ、初回アクセス時にのみ設定をロードし、以降はキャッシュされた結果を返しています。これにより、無駄な処理を回避し、アプリケーションのパフォーマンスを向上させることができます。

3. サーバーリクエストの最適化

デコレータを使用して、APIリクエストをバッチ処理やサーキットブレーカーなどのパターンで最適化することも可能です。ここでは、サーキットブレーカー（システムが過負荷になった際にリクエストを一時的に停止する仕組み）をデコレータで実装します。

function CircuitBreaker(threshold: number) {
  let failureCount = 0;
  let open = false;

  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;

    descriptor.value = async function (...args: any[]) {
      if (open) {
        throw new Error("サーキットがオープン状態です。リクエストを受け付けられません。");
      }

      try {
        const result = await originalMethod.apply(this, args);
        failureCount = 0; // 成功したら失敗カウントをリセット
        return result;
      } catch (error) {
        failureCount++;
        if (failureCount >= threshold) {
          open = true;
          console.log("サーキットがオープンされました。リクエストが一時停止されます。");
        }
        throw error;
      }
    };
  };
}

class APIService {
  @CircuitBreaker(3)
  async fetchData(url: string) {
    console.log(`APIリクエスト: ${url}`);
    // 模擬APIエラー
    throw new Error("APIエラーが発生しました");
  }
}

const apiService = new APIService();
apiService.fetchData("https://api.example.com/data").catch(console.error);

この例では、CircuitBreakerデコレータを使って、一定回数のリクエスト失敗が発生した場合にサーキットをオープンし、リクエストを一時的に停止する仕組みを実装しています。この手法により、システムが過負荷になるのを防ぎ、パフォーマンスを保つことができます。

4. 処理の非同期化

デコレータを使って、非同期処理を自動化することで、パフォーマンスを向上させることができます。例えば、時間のかかるメソッドをバックグラウンドで実行するデコレータを作成し、UIの応答性を保つことが可能です。

function AsyncProcess(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = async function (...args: any[]) {
    console.log(`${propertyKey} を非同期で処理しています`);
    setTimeout(() => originalMethod.apply(this, args), 0); // 実際の処理を遅延させる
  };
}

class FileService {
  @AsyncProcess
  uploadFile(file: string) {
    console.log(`ファイル ${file} をアップロード中...`);
  }
}

const fileService = new FileService();
fileService.uploadFile("test.txt");
console.log("ファイルアップロードのリクエストを非同期で処理中...");

この例では、AsyncProcessデコレータを使用して、ファイルのアップロード処理を非同期で実行し、メインスレッドの負荷を軽減しています。

デコレータは、コードのパフォーマンスを最適化するための強力なツールであり、キャッシュ、遅延実行、非同期処理などを活用することで、アプリケーションの効率を大幅に改善できます。

デコレータを使ったテスト方法

デコレータを使用したコードのテストは、デコレータがどのように機能を変更しているかを理解した上で、正しく行う必要があります。デコレータによってメソッドやプロパティの振る舞いが変更されるため、ユニットテストでは、デコレータの適用後の動作が期待通りであるかどうかを確認することが重要です。

ここでは、TypeScriptのデコレータをテストする方法について説明します。ユニットテストを効果的に行うためのポイントや、具体的なテスト手法も紹介します。

1. テスト環境の準備

まず、TypeScriptのユニットテストを行うために、一般的なテスティングフレームワークである Jest や Mocha を使用することが推奨されます。これらのフレームワークを利用して、デコレータの動作を検証するテストケースを作成します。

例えば、Jestを使用する場合、以下のようにセットアップします。

npm install --save-dev jest ts-jest @types/jest
npx ts-jest config:init

テスト環境が整ったら、デコレータをテストするための具体的なコードを見ていきましょう。

2. メソッドデコレータのテスト

メソッドデコレータは、特定のメソッドの挙動を変更するため、デコレータが正しく適用され、期待する動作をしているかどうかをテストします。以下の例では、ログ記録を行うデコレータのテストを行っています。

// デコレータ本体
function LogMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function (...args: any[]) {
    console.log(`メソッド ${propertyKey} が呼び出されました`);
    return originalMethod.apply(this, args);
  };
}

// テスト対象クラス
class Calculator {
  @LogMethod
  add(a: number, b: number): number {
    return a + b;
  }
}

// テストコード
describe('Calculator', () => {
  let calculator: Calculator;
  beforeEach(() => {
    calculator = new Calculator();
  });

  it('メソッドデコレータが適用されていることを確認', () => {
    const spy = jest.spyOn(console, 'log');
    calculator.add(2, 3);
    expect(spy).toHaveBeenCalledWith('メソッド add が呼び出されました');
    spy.mockRestore();
  });

  it('メソッドの計算結果が正しいことを確認', () => {
    expect(calculator.add(2, 3)).toBe(5);
  });
});

このテストでは、LogMethodデコレータが正しく適用され、console.logが呼び出されたかどうかを確認しています。また、メソッドの計算結果も検証しています。

3. クラスデコレータのテスト

クラスデコレータをテストする際には、クラス全体に対してどのように振る舞いが変更されたかを確認する必要があります。以下では、クラスデコレータをテストする例を紹介します。

// デコレータ本体
function WithTimestamp(constructor: Function) {
  return class extends constructor {
    timestamp = new Date();
  };
}

// テスト対象クラス
@WithTimestamp
class Document {
  title: string;
  constructor(title: string) {
    this.title = title;
  }
}

// テストコード
describe('Document', () => {
  it('デコレータによってtimestampプロパティが追加されることを確認', () => {
    const doc = new Document('My Document');
    expect(doc.timestamp).toBeDefined();
    expect(doc.timestamp).toBeInstanceOf(Date);
  });

  it('元のプロパティが正しく設定されることを確認', () => {
    const doc = new Document('My Document');
    expect(doc.title).toBe('My Document');
  });
});

このテストでは、クラスデコレータWithTimestampが正しく動作し、timestampプロパティがインスタンスに追加されているかを確認しています。クラス自体の振る舞いも正しいかどうかをテストしています。

4. プロパティデコレータのテスト

プロパティデコレータをテストする場合、プロパティが正しく設定され、デコレータによる制約や挙動が反映されているかを確認します。以下は、プロパティの読み取り専用制限を行うデコレータのテストです。

// デコレータ本体
function ReadOnly(target: any, propertyKey: string) {
  Object.defineProperty(target, propertyKey, {
    writable: false,
  });
}

// テスト対象クラス
class User {
  @ReadOnly
  name: string = 'John Doe';
}

// テストコード
describe('User', () => {
  it('nameプロパティが読み取り専用であることを確認', () => {
    const user = new User();
    expect(() => {
      user.name = 'Jane Doe';
    }).toThrowError();
  });

  it('初期値が正しいことを確認', () => {
    const user = new User();
    expect(user.name).toBe('John Doe');
  });
});

このテストでは、ReadOnlyデコレータによってnameプロパティが読み取り専用であるかどうかをテストしています。書き込みを行おうとした場合にエラーが発生することを確認しています。

5. デコレータの適用順序のテスト

複数のデコレータを同時に使用する場合、それらが正しい順序で適用されることを確認するテストも必要です。デコレータは上から下の順序で適用されるため、意図した順序で動作しているかを確認します。

function First(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  console.log('First デコレータが適用されました');
}

function Second(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  console.log('Second デコレータが適用されました');
}

class TestClass {
  @First
  @Second
  method() {}
}

// テストコード
describe('デコレータの適用順序', () => {
  it('デコレータが正しい順序で適用されることを確認', () => {
    const spy = jest.spyOn(console, 'log');
    new TestClass().method();
    expect(spy).toHaveBeenCalledWith('Second デコレータが適用されました');
    expect(spy).toHaveBeenCalledWith('First デコレータが適用されました');
    spy.mockRestore();
  });
});

このテストでは、デコレータの適用順序が正しくログに出力されていることを確認しています。

まとめ

デコレータを使用したコードのテストでは、デコレータが正しく機能していることを確認することが重要です。メソッド、クラス、プロパティのそれぞれに適用されたデコレータが期待通りに動作するかどうかを、ユニットテストを通じて検証することで、デコレータの影響範囲や動作を安心して導入することができます。

デコレータパターンのメリットとデメリット

デコレータパターンは、クラスやメソッド、プロパティに追加の機能を付与するための強力なツールです。しかし、他のデザインパターンと同様に、メリットとデメリットの両方があります。ここでは、デコレータパターンを使う際に考慮すべき利点と欠点を説明します。

メリット

1. コードの再利用性の向上

デコレータを使用することで、共通のロジックや処理を複数の場所で使い回すことができます。例えば、ロギング、キャッシング、データ検証などの共通処理を、各メソッドに直接書くことなくデコレータを通じて適用することで、コードの重複を避けることが可能です。

2. クリーンで読みやすいコード

デコレータを使うことで、主要なビジネスロジックとクロスカッティングの関心事（ロギングや認証など）を分離することができます。これにより、クラスやメソッドがシンプルに保たれ、可読性が向上します。

3. 柔軟な機能追加

デコレータを使えば、クラスやメソッドに対して柔軟に機能を追加できます。特に、後から機能を拡張したい場合でも、既存のコードを変更することなく、新しいデコレータを適用するだけで対応可能です。

4. オープン/クローズド原則の実現

デコレータパターンは、オブジェクト指向プログラミングの重要な原則である「オープン/クローズド原則」（既存のコードを変更することなく、拡張が可能）を実現します。コードの修正を避け、デコレータを使って新しい振る舞いを追加することができます。

デメリット

1. 複雑性の増加

デコレータを大量に使用すると、コードの追跡や理解が難しくなる場合があります。特に、複数のデコレータが同じメソッドやクラスに適用される場合、それぞれのデコレータがどのように動作するかを把握するのが困難になることがあります。

2. デバッグの難しさ

デコレータは、メソッドやプロパティの挙動を変更するため、デバッグが難しくなる場合があります。特に、デコレータが複雑な処理を行う場合、その影響を追跡することが難しくなる可能性があります。

3. 適用範囲が広がりすぎる可能性

デコレータは非常に便利な機能ですが、過度に使用すると、デコレータによって管理される機能が多くなりすぎ、逆にコードの意図がわかりにくくなることがあります。デコレータを適用する範囲を慎重に選ばないと、意図しない動作を引き起こすリスクもあります。

4. 性能への影響

特定のデコレータ（特に、ロギングやキャッシングなど）は、処理時間やメモリの使用量に影響を与える場合があります。頻繁に呼び出されるメソッドに対して過度な処理を追加するデコレータを適用すると、アプリケーションのパフォーマンスが低下する可能性があります。

まとめ

デコレータパターンは、再利用性の高いコードを作成し、柔軟に機能を拡張できる点で非常に有用です。しかし、適用範囲やデコレータの使いすぎには注意が必要です。効果的にデコレータを利用するためには、その利点と欠点を理解し、適切な場面で使用することが重要です。

演習問題

デコレータパターンの理解を深めるために、以下の演習問題を実施してみましょう。これらの問題では、TypeScriptのデコレータ機能を使った実装や応用方法を確認できます。

問題 1: メソッドデコレータの作成

以下の仕様に従って、メソッドデコレータを作成してください。

ロギング機能を持つメソッドデコレータを作成する
メソッドが呼び出された際に、メソッド名と引数がコンソールに表示されるようにする

例:

class UserService {
  @LogMethod
  getUser(id: number) {
    console.log(`ユーザーID: ${id} を取得しました`);
  }
}

const service = new UserService();
service.getUser(123);

期待される出力:

メソッド getUser が呼び出されました
引数: [123]
ユーザーID: 123 を取得しました

問題 2: プロパティデコレータでバリデーションを追加

プロパティデコレータを使って、クラス内の数値プロパティに対してバリデーションを追加してください。バリデータは、値が負数でないことを確認するものとします。

仕様:

プロパティの値が負数に設定されようとした場合、エラーをスローする
正常な値はそのままプロパティに設定される

例:

class Product {
  @ValidatePositive
  price: number = 100;

  constructor(price: number) {
    this.price = price;
  }
}

const product = new Product(150); // OK
product.price = -50; // エラー: 負の数は設定できません

問題 3: クラスデコレータを使った拡張

クラスデコレータを使用して、クラスに新しいプロパティcreatedAtを自動的に追加してください。createdAtプロパティは、クラスのインスタンスが作成された日時を保持するものとします。