class-resolver 2.1.0 → 2.2.0

package/README.md

@@ -10,6 +10,8 @@ A lightweight TypeScript/JavaScript library for implementing the Chain of Respon
 - Support for multiple resolvers with different handling logic
 - Clear error handling for unsupported types
 - Generic type support for better type safety
+- **Fallback handler support for graceful handling of unsupported types**
+- **Method chaining support for fluent API usage**
 
 ## Installation
 
@@ -55,6 +57,27 @@ try {
 }
 ```
 
+## Fallback Handler Usage
+
+The fallback handler allows you to gracefully handle unsupported types without throwing errors:
+
+```typescript
+const resolver = new Resolver(new ExampleClass(), new ExampleClass2())
+
+// Set a fallback handler for unsupported types
+resolver.setFallbackHandler((type) => {
+  return `Fallback: ${type}`
+})
+
+// Now unsupported types will use the fallback handler instead of throwing errors
+const result = resolver.resolve('xxx')
+console.log(result.handle('xxx')) // Output: Fallback: xxx
+
+// Supported types still work normally
+const c = resolver.resolve('hoge')
+console.log(c.handle()) // Output: hoge
+```
+
 ## Advanced Usage
 
 ### With TypeScript and Parameters
@@ -113,6 +136,33 @@ resolver.addUpdater(new MessageFormatter())
 resolver.addUpdater(new ErrorFormatter())
 ```
 
+### Fallback Handler with TypeScript
+
+The fallback handler maintains full type safety and automatically infers types from your resolver configuration:
+
+```typescript
+// Create a resolver with specific types
+const resolver = new Resolver<ResolveTarget<[string, number], string>>(
+  new MessageFormatter()
+)
+
+// Set a fallback handler with the same type signature
+resolver.setFallbackHandler((name: string, count: number): string => {
+  return `Default greeting for ${name} (message #${count})`
+})
+
+// The fallback handler will be used for unsupported types
+const result = resolver.resolve('unknown').handle('John', 5)
+console.log(result) // Output: Default greeting for John (message #5)
+
+// Method chaining is also supported
+resolver
+  .setFallbackHandler((name: string, count: number): string => {
+    return `Custom fallback: ${name} - ${count}`
+  })
+  .addUpdater(new ErrorFormatter())
+```
+
 ## Generic Type Support
 
 From version 2.0.0, class-resolver supports generic types for better type safety:
@@ -209,6 +259,9 @@ This advanced type support allows you to:
 3. **Request Processing**: Process different types of requests with dedicated handlers
 4. **Plugin System**: Implement a plugin system where different plugins handle specific types of operations
 5. **Message Formatting**: Format different types of messages with specific formatters
+6. **Graceful Degradation**: Use fallback handlers to provide default behavior for unknown types
+7. **API Versioning**: Handle different API versions with fallback to backward-compatible behavior
+8. **Feature Flags**: Implement feature flags with fallback to basic functionality
 
 ## Error Handling
 
@@ -216,6 +269,26 @@ The resolver will throw errors in the following cases:
 - When no resolvers are registered: `"Unasigned resolve target."`
 - When trying to resolve an unsupported type: `"Unsupported type: xxx"`
 
+### Fallback Handler for Error Prevention
+
+With the fallback handler, you can prevent errors for unsupported types:
+
+```typescript
+const resolver = new Resolver(new ExampleClass())
+
+// Without fallback handler - throws error
+try {
+  resolver.resolve('unknown')
+} catch (e) {
+  console.log(e) // Error: Unsupported type: unknown
+}
+
+// With fallback handler - no error thrown
+resolver.setFallbackHandler((type) => `Default: ${type}`)
+const result = resolver.resolve('unknown') // No error, uses fallback
+console.log(result.handle('unknown')) // Output: Default: unknown
+```
+
 ## Upgrade Guide
 
 ### Upgrading from 1.x to 2.0.0

package/dist/resolver.d.ts

@@ -9,6 +9,11 @@ declare class Resolver<TBase extends ResolveTarget<any[], any, any> = ResolveTar
      * @private
      */
     private updaters;
+    /**
+     * Fallback handler function
+     * @private
+     */
+    private fallbackHandler?;
     /**
      * Initializes the resolver
      * @param args Initial resolver targets
@@ -35,13 +40,19 @@ declare class Resolver<TBase extends ResolveTarget<any[], any, any> = ResolveTar
      * Adds a resolver target
      * @param updater Resolver target to add
      */
-    addUpdater(updater: TBase): void;
+    addUpdater(updater: TBase): this;
+    /**
+     * Sets a fallback handler for unsupported types
+     * @param handler Fallback handler function
+     * @returns This resolver instance for method chaining
+     */
+    setFallbackHandler(handler: (...args: Parameters<TBase['handle']>) => ReturnType<TBase['handle']>): this;
     /**
      * Resolves a resolver target for the specified type
      * @param type Type to resolve
      * @returns Resolved resolver target
      * @throws {Error} When no resolver targets are registered
-     * @throws {Error} When no resolver target supporting the specified type is found
+     * @throws {Error} When no resolver target supporting the specified type is found and no fallback is set
      */
     resolve(type: TType): TBase;
 }

package/dist/resolver.js

@@ -48,21 +48,42 @@ class Resolver {
      */
     addUpdater(updater) {
         this.updaters.push(updater);
+        return this;
+    }
+    /**
+     * Sets a fallback handler for unsupported types
+     * @param handler Fallback handler function
+     * @returns This resolver instance for method chaining
+     */
+    setFallbackHandler(handler) {
+        this.fallbackHandler = handler;
+        return this;
     }
     /**
      * Resolves a resolver target for the specified type
      * @param type Type to resolve
      * @returns Resolved resolver target
      * @throws {Error} When no resolver targets are registered
-     * @throws {Error} When no resolver target supporting the specified type is found
+     * @throws {Error} When no resolver target supporting the specified type is found and no fallback is set
      */
     resolve(type) {
         if (this.updaters.length < 1) {
-            throw new Error('Unasigned resolve target.');
+            throw new Error('Unassigned resolve target.');
         }
         const target = this.updaters.find(updater => updater.supports(type));
         if (!target) {
-            throw new Error(`Unsupported type: ${type}`);
+            // If fallback handler is set, create a temporary target that uses it
+            if (this.fallbackHandler) {
+                return {
+                    supports: () => true,
+                    handle: this.fallbackHandler
+                };
+            }
+            // Determine the string representation of the unsupported type
+            // If it's a non-null object, use JSON.stringify for detailed output
+            // Otherwise, use String() for basic conversion
+            const typeString = typeof type === 'object' && type !== null ? JSON.stringify(type) : String(type);
+            throw new Error(`Unsupported type: ${typeString}`);
         }
         return target;
     }

package/dist/resolver.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../libs/resolver.ts"],"names":[],"mappings":";;AAEA;;;GAGG;AACH,MAAM,QAAQ;IAOZ;;;OAGG;IACH,YAAY,GAAG,IAAa;QAV5B;;;WAGG;QACK,aAAQ,GAAY,EAAE,CAAC;QAO7B,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,OAAO,CAAC,IAAa;QAC3B,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACnB,CAAC;IAED;;;OAGG;IACI,GAAG,CAAC,QAAiB;QAC1B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACI,WAAW,CAAC,GAAG,IAAa;QACjC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACI,UAAU,CAAC,OAAc;QAC9B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;OAMG;IACI,OAAO,CAAC,IAAW;QACxB,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAErE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,qBAAqB,IAAI,EAAE,CAAC,CAAC;QAC/C,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAED,kBAAe,QAAQ,CAAC"}
+{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../libs/resolver.ts"],"names":[],"mappings":";;AAEA;;;GAGG;AACH,MAAM,QAAQ;IAaZ;;;OAGG;IACH,YAAY,GAAG,IAAa;QAhB5B;;;WAGG;QACK,aAAQ,GAAY,EAAE,CAAC;QAa7B,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,OAAO,CAAC,IAAa;QAC3B,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACnB,CAAC;IAED;;;OAGG;IACI,GAAG,CAAC,QAAiB;QAC1B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACI,WAAW,CAAC,GAAG,IAAa;QACjC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACI,UAAU,CAAC,OAAc;QAC9B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,kBAAkB,CACvB,OAA8E;QAE9E,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACI,OAAO,CAAC,IAAW;QACxB,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAChD,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAErE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,qEAAqE;YACrE,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;gBACzB,OAAO;oBACL,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI;oBACpB,MAAM,EAAE,IAAI,CAAC,eAAe;iBACT,CAAC;YACxB,CAAC;YAED,8DAA8D;YAC9D,oEAAoE;YACpE,+CAA+C;YAC/C,MAAM,UAAU,GAAG,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACnG,MAAM,IAAI,KAAK,CAAC,qBAAqB,UAAU,EAAE,CAAC,CAAC;QACrD,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAED,kBAAe,QAAQ,CAAC"}

package/libs/resolver.ts

@@ -11,6 +11,12 @@ class Resolver<TBase extends ResolveTarget<any[], any, any> = ResolveTarget<any[
    */
   private updaters: TBase[] = [];
 
+  /**
+   * Fallback handler function
+   * @private
+   */
+  private fallbackHandler?: (...args: Parameters<TBase['handle']>) => ReturnType<TBase['handle']>;
+
   /**
    * Initializes the resolver
    * @param args Initial resolver targets
@@ -51,8 +57,21 @@ class Resolver<TBase extends ResolveTarget<any[], any, any> = ResolveTarget<any[
    * Adds a resolver target
    * @param updater Resolver target to add
    */
-  public addUpdater(updater: TBase): void {
+  public addUpdater(updater: TBase): this {
     this.updaters.push(updater);
+    return this;
+  }
+
+  /**
+   * Sets a fallback handler for unsupported types
+   * @param handler Fallback handler function
+   * @returns This resolver instance for method chaining
+   */
+  public setFallbackHandler(
+    handler: (...args: Parameters<TBase['handle']>) => ReturnType<TBase['handle']>
+  ): this {
+    this.fallbackHandler = handler;
+    return this;
   }
 
   /**
@@ -60,17 +79,29 @@ class Resolver<TBase extends ResolveTarget<any[], any, any> = ResolveTarget<any[
    * @param type Type to resolve
    * @returns Resolved resolver target
    * @throws {Error} When no resolver targets are registered
-   * @throws {Error} When no resolver target supporting the specified type is found
+   * @throws {Error} When no resolver target supporting the specified type is found and no fallback is set
    */
   public resolve(type: TType): TBase {
     if (this.updaters.length < 1) {
-      throw new Error('Unasigned resolve target.');
+      throw new Error('Unassigned resolve target.');
     }
     
     const target = this.updaters.find(updater => updater.supports(type));
     
     if (!target) {
-      throw new Error(`Unsupported type: ${type}`);
+      // If fallback handler is set, create a temporary target that uses it
+      if (this.fallbackHandler) {
+        return {
+          supports: () => true,
+          handle: this.fallbackHandler
+        } as unknown as TBase;
+      }
+      
+      // Determine the string representation of the unsupported type
+      // If it's a non-null object, use JSON.stringify for detailed output
+      // Otherwise, use String() for basic conversion
+      const typeString = typeof type === 'object' && type !== null ? JSON.stringify(type) : String(type);
+      throw new Error(`Unsupported type: ${typeString}`);
     }
     
     return target;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "class-resolver",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Simple class resolver.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/readme-ja.md

@@ -10,6 +10,8 @@
 - 異なる処理ロジックを持つ複数のリゾルバーのサポート
 - サポートされていないタイプに対する明確なエラー処理
 - より良い型安全性のためのジェネリック型サポート
+- **サポートされていないタイプのためのフォールバックハンドラーサポート**
+- **メソッドチェーンサポートによる流れるようなAPI**
 
 ## インストール
 
@@ -55,6 +57,27 @@ try {
 }
 ```
 
+## フォールバックハンドラーの使い方
+
+フォールバックハンドラーを使用すると、サポートされていないタイプをエラーをスローすることなく適切に処理できます：
+
+```typescript
+const resolver = new Resolver(new ExampleClass(), new ExampleClass2())
+
+// サポートされていないタイプのためのフォールバックハンドラーを設定
+resolver.setFallbackHandler((type) => {
+  return `フォールバック: ${type}`
+})
+
+// これでサポートされていないタイプはエラーをスローせずにフォールバックハンドラーが使用されます
+const result = resolver.resolve('xxx')
+console.log(result.handle('xxx')) // 出力: フォールバック: xxx
+
+// サポートされているタイプは通常通り動作します
+const c = resolver.resolve('hoge')
+console.log(c.handle()) // 出力: hoge
+```
+
 ## 高度な使い方
 
 ### TypeScriptとパラメータの使用
@@ -113,6 +136,33 @@ resolver.addUpdater(new MessageFormatter())
 resolver.addUpdater(new ErrorFormatter())
 ```
 
+### TypeScriptでのフォールバックハンドラー
+
+フォールバックハンドラーは完全な型安全性を維持し、リゾルバーの設定から自動的に型を推論します：
+
+```typescript
+// 特定の型でリゾルバーを作成
+const resolver = new Resolver<ResolveTarget<[string, number], string>>(
+  new MessageFormatter()
+)
+
+// 同じ型シグネチャでフォールバックハンドラーを設定
+resolver.setFallbackHandler((name: string, count: number): string => {
+  return `${name}のデフォルトの挨拶（メッセージ #${count}）`
+})
+
+// フォールバックハンドラーはサポートされていないタイプに使用されます
+const result = resolver.resolve('unknown').handle('田中', 5)
+console.log(result) // 出力: 田中 のデフォルトの挨拶（メッセージ #5）
+
+// メソッドチェーンもサポートされています
+resolver
+  .setFallbackHandler((name: string, count: number): string => {
+    return `カスタムフォールバック: ${name} - ${count}`
+  })
+  .addUpdater(new ErrorFormatter())
+```
+
 ## ジェネリック型サポート
 
 バージョン2.0.0から、class-resolverはより良い型安全性のためにジェネリック型をサポートしています：
@@ -148,6 +198,9 @@ const result = formatter.handle('hello'); // resultはstring型として型付
 3. **リクエスト処理**: 専用のハンドラーで異なるタイプのリクエストを処理
 4. **プラグインシステム**: 異なるプラグインが特定のタイプの操作を処理するプラグインシステムを実装
 5. **メッセージフォーマット**: 特定のフォーマッターで異なるタイプのメッセージをフォーマット
+6. **適切な機能低下**: フォールバックハンドラーを使用して未知のタイプのデフォルト動作を提供
+7. **APIバージョニング**: フォールバックを使用して後方互換性のある動作で異なるAPIバージョンを処理
+8. **フィーチャーフラグ**: フォールバックを使用して基本的な機能にフィーチャーフラグを実装
 
 ## エラー処理
 
@@ -155,6 +208,26 @@ const result = formatter.handle('hello'); // resultはstring型として型付
 - リゾルバーが登録されていない場合: `"Unasigned resolve target."`
 - サポートされていないタイプを解決しようとした場合: `"Unsupported type: xxx"`
 
+### フォールバックハンドラーによるエラー防止
+
+フォールバックハンドラーを使用すると、サポートされていないタイプのエラーを防ぐことができます：
+
+```typescript
+const resolver = new Resolver(new ExampleClass())
+
+// フォールバックハンドラーなし - エラーがスローされる
+try {
+  resolver.resolve('unknown')
+} catch (e) {
+  console.log(e) // Error: Unsupported type: unknown
+}
+
+// フォールバックハンドラーあり - エラーはスローされない
+resolver.setFallbackHandler((type) => `デフォルト: ${type}`)
+const result = resolver.resolve('unknown') // エラーなし、フォールバックが使用される
+console.log(result.handle('unknown')) // 出力: デフォルト: unknown
+```
+
 ## アップグレードガイド
 
 ### 1.xから2.0.0へのアップグレード