class-resolver 1.1.0 → 2.0.0

package/README.md

@@ -1,13 +1,27 @@
 # Simple Class resolver
 
-## Getting started
+A lightweight TypeScript/JavaScript library for implementing the Chain of Responsibility pattern with class-based resolvers.
 
-```
-$ npm i -S class-resolver
-```
+## Features
+
+- Simple and intuitive API for handling different types of requests
+- Type-safe implementation with TypeScript support
+- Flexible resolver registration (constructor, setUpdaters, addUpdater)
+- Support for multiple resolvers with different handling logic
+- Clear error handling for unsupported types
+- Generic type support for better type safety
+
+## Installation
 
-## Example code
+```bash
+npm install class-resolver
+# or
+yarn add class-resolver
 ```
+
+## Basic Usage
+
+```typescript
 const Resolver = require('class-resolver')
 
 class ExampleClass {
@@ -26,32 +40,206 @@ class ExampleClass2 {
     return 'fuga'
   }
 }
-console.log(Resolver)
+
 const resolver = new Resolver(new ExampleClass(), new ExampleClass2())
 const c = resolver.resolve('hoge')
-console.log(c.handle())
+console.log(c.handle()) // Output: hoge
+
 const c2 = resolver.resolve('fuga')
-console.log(c2.handle())
+console.log(c2.handle()) // Output: fuga
 
 try {
-  resolver.resolve('xxx')
+  resolver.resolve('xxx') // This will throw an error
 } catch (e) {
-  console.log(e)
+  console.log(e) // Error: Unsupported type: xxx
 }
 ```
 
-Execute result
+## Advanced Usage
+
+### With TypeScript and Parameters
+
+```typescript
+import Resolver from 'class-resolver';
+import { ResolveTarget } from 'class-resolver';
+
+// Using generics for better type safety
+class MessageFormatter implements ResolveTarget<[string, number], string> {
+  supports(type: string): boolean {
+    return type === 'greeting'
+  }
+  
+  handle(name: string, count: number): string {
+    return `Hello ${name}, this is message #${count}!`
+  }
+}
 
+class ErrorFormatter implements ResolveTarget<[string, number], string> {
+  supports(type: string): boolean {
+    return type === 'error'
+  }
+  
+  handle(message: string, code: number): string {
+    return `Error ${code}: ${message}`
+  }
+}
+
+// Specify the generic type for better type safety
+const resolver = new Resolver<ResolveTarget<[string, number], string>>(
+  new MessageFormatter(), 
+  new ErrorFormatter()
+)
+
+// Using the greeting formatter
+const greeting = resolver.resolve('greeting')
+console.log(greeting.handle('John', 1)) // Output: Hello John, this is message #1!
+
+// Using the error formatter
+const error = resolver.resolve('error')
+console.log(error.handle('Not Found', 404)) // Output: Error 404: Not Found
 ```
-$ node index.js
-hoge
-fuga
-Error: Unsupported type: xxx
+
+### Dynamic Resolver Registration
+
+```typescript
+// Specify the generic type for better type safety
+const resolver = new Resolver<ResolveTarget<[string, number], string>>()
+
+// Add resolvers after initialization
+resolver.setUpdaters(new MessageFormatter(), new ErrorFormatter())
+
+// Or add them one by one
+resolver.addUpdater(new MessageFormatter())
+resolver.addUpdater(new ErrorFormatter())
 ```
 
-## Contributing
+## Generic Type Support
+
+From version 2.0.0, class-resolver supports generic types for better type safety:
 
+```typescript
+// Define the interface with generics
+interface ResolveTarget<TArgs extends any[] = any[], TReturn = any> {
+  supports(type: string): boolean;
+  handle(...args: TArgs): TReturn;
+}
+
+// Define a class that implements the interface with specific types
+class StringFormatter implements ResolveTarget<[string], string> {
+  supports(type: string): boolean {
+    return type === 'string-format';
+  }
+  
+  handle(input: string): string {
+    return input.toUpperCase();
+  }
+}
+
+// Create a resolver with the specific type
+const resolver = new Resolver<ResolveTarget<[string], string>>(new StringFormatter());
+const formatter = resolver.resolve('string-format');
+const result = formatter.handle('hello'); // result is typed as string
 ```
+
+## Use Cases
+
+1. **Command Pattern Implementation**: Handle different types of commands with specific handlers
+2. **Format Conversion**: Convert data between different formats based on type
+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
+
+## Error Handling
+
+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"`
+
+## Upgrade Guide
+
+### Upgrading from 1.x to 2.0.0
+
+Version 2.0.0 introduces generic type support for better type safety. This change is backward compatible for JavaScript users, but TypeScript users may need to update their code.
+
+#### Changes for TypeScript Users
+
+1. The `ResolveTarget` interface now supports generics:
+   ```typescript
+   // Before (1.x)
+   interface ResolveTarget {
+     supports(type: string): boolean;
+     handle(...args: any[]): any;
+   }
+   
+   // After (2.0.0)
+   interface ResolveTarget<TArgs extends any[] = any[], TReturn = any> {
+     supports(type: string): boolean;
+     handle(...args: TArgs): TReturn;
+   }
+   ```
+
+2. The `Resolver` class now supports generics:
+   ```typescript
+   // Before (1.x)
+   class Resolver {
+     // ...
+   }
+   
+   // After (2.0.0)
+   class Resolver<TBase extends ResolveTarget = ResolveTarget> {
+     // ...
+   }
+   ```
+
+#### Migration Steps
+
+1. If you're using TypeScript with default `any` types, your code should continue to work without changes.
+
+2. To take advantage of the improved type safety, update your class implementations:
+   ```typescript
+   // Before (1.x)
+   class MyHandler implements ResolveTarget {
+     supports(type: string): boolean {
+       return type === 'my-type';
+     }
+     handle(name: string): string {
+       return `Hello ${name}`;
+     }
+   }
+   
+   // After (2.0.0)
+   class MyHandler implements ResolveTarget<[string], string> {
+     supports(type: string): boolean {
+       return type === 'my-type';
+     }
+     handle(name: string): string {
+       return `Hello ${name}`;
+     }
+   }
+   ```
+
+3. When creating a new Resolver, specify the generic type:
+   ```typescript
+   // Before (1.x)
+   const resolver = new Resolver(new MyHandler());
+   
+   // After (2.0.0)
+   const resolver = new Resolver<ResolveTarget<[string], string>>(new MyHandler());
+   ```
+
+4. If you have mixed handler types, you can use a union type or keep using the default `any` type:
+   ```typescript
+   // Using union type
+   type MyHandlers = ResolveTarget<[string], string> | ResolveTarget<[number], boolean>;
+   const resolver = new Resolver<MyHandlers>(new StringHandler(), new NumberHandler());
+   
+   // Or keep using the default any type
+   const resolver = new Resolver(new StringHandler(), new NumberHandler());
+   ```
+
+## Contributing
+
+```bash
 $ npm install
 $ git checkout -b YOUR_TOPIC_BRANCH
 $ npm test
@@ -59,4 +247,8 @@ $ npm run build
 $ git add ./
 $ git commit -m "YOUR UPDATE DESCRIPTION"
 $ git push YOUR_ORIGIN YOUR_TOPIC_BRANCH
-```
+```
+
+## License
+
+MIT

package/dist/index.js

@@ -1,8 +1,26 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interface"), exports);
 const resolver_1 = __importDefault(require("./resolver"));
 exports.default = resolver_1.default;
+// Export for CommonJS compatibility
+// @ts-ignore
 module.exports = resolver_1.default;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../libs/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,8CAA2B;AAC3B,0DAAiC;AACjC,kBAAe,kBAAQ,CAAA;AACvB,oCAAoC;AACpC,aAAa;AACb,MAAM,CAAC,OAAO,GAAG,kBAAQ,CAAA"}

package/dist/interface.d.ts

@@ -1,6 +1,23 @@
+/**
+ * Interface that classes which are targets for the resolver should implement
+ */
+export interface ResolveTarget<TArgs extends any[] = any[], TReturn = any> {
+    /**
+     * Determines whether the specified type is supported
+     * @param type The type to check for support
+     * @returns true if supported, false otherwise
+     */
+    supports(type: string): boolean;
+    /**
+     * Handles the request
+     * @param args Arguments needed for processing
+     * @returns Processing result
+     */
+    handle(...args: TArgs): TReturn;
+}
 export declare namespace interfaces {
-    interface ResolveTarget {
+    interface ResolveTarget<TArgs extends any[] = any[], TReturn = any> {
         supports(type: string): boolean;
-        handle(...args: any): any;
+        handle(...args: TArgs): TReturn;
     }
 }

package/dist/interface.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","sourceRoot":"","sources":["../libs/interface.ts"],"names":[],"mappings":""}

package/dist/resolver.d.ts

@@ -1,12 +1,48 @@
-import { interfaces } from './interface';
-import ResolveTarget = interfaces.ResolveTarget;
-declare class Resolver {
-    private updater;
-    constructor(...args: ResolveTarget[]);
-    getArgs(arg: ResolveTarget[]): ResolveTarget[];
-    set(updaters: ResolveTarget[]): void;
-    setUpdaters(...args: ResolveTarget[]): void;
-    addUpdater(updater: ResolveTarget): void;
-    resolve(type: string): ResolveTarget;
+import { ResolveTarget } from './interface';
+/**
+ * Resolver class implementing the Chain of Responsibility pattern
+ * Resolves handlers for specific types
+ */
+declare class Resolver<TBase extends ResolveTarget = ResolveTarget> {
+    /**
+     * Array of registered resolver targets
+     * @private
+     */
+    private updaters;
+    /**
+     * Initializes the resolver
+     * @param args Initial resolver targets
+     */
+    constructor(...args: TBase[]);
+    /**
+     * Processes an array of arguments
+     * @param args Array of resolver targets
+     * @returns Processed array
+     * @private
+     */
+    private getArgs;
+    /**
+     * Sets resolver targets
+     * @param updaters Array of resolver targets
+     */
+    set(updaters: TBase[]): void;
+    /**
+     * Sets resolver targets (variadic version)
+     * @param args Resolver targets
+     */
+    setUpdaters(...args: TBase[]): void;
+    /**
+     * Adds a resolver target
+     * @param updater Resolver target to add
+     */
+    addUpdater(updater: TBase): void;
+    /**
+     * 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
+     */
+    resolve(type: string): TBase;
 }
 export default Resolver;

package/dist/resolver.js

@@ -1,29 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Resolver class implementing the Chain of Responsibility pattern
+ * Resolves handlers for specific types
+ */
 class Resolver {
+    /**
+     * Initializes the resolver
+     * @param args Initial resolver targets
+     */
     constructor(...args) {
-        this.updater = [];
-        this.set(this.getArgs(args));
+        /**
+         * Array of registered resolver targets
+         * @private
+         */
+        this.updaters = [];
+        if (args.length > 0) {
+            this.set(args);
+        }
     }
-    getArgs(arg) {
-        return Array.prototype.slice.call(arg, 0);
+    /**
+     * Processes an array of arguments
+     * @param args Array of resolver targets
+     * @returns Processed array
+     * @private
+     */
+    getArgs(args) {
+        return [...args];
     }
+    /**
+     * Sets resolver targets
+     * @param updaters Array of resolver targets
+     */
     set(updaters) {
-        this.updater = updaters;
+        this.updaters = updaters;
     }
+    /**
+     * Sets resolver targets (variadic version)
+     * @param args Resolver targets
+     */
     setUpdaters(...args) {
         this.set(this.getArgs(args));
     }
+    /**
+     * Adds a resolver target
+     * @param updater Resolver target to add
+     */
     addUpdater(updater) {
-        this.updater.push(updater);
+        this.updaters.push(updater);
     }
+    /**
+     * 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
+     */
     resolve(type) {
-        if (this.updater.length < 1)
+        if (this.updaters.length < 1) {
             throw new Error('Unasigned resolve target.');
-        const target = this.updater.filter(updater => updater.supports(type));
-        if (target.length < 1)
+        }
+        const target = this.updaters.find(updater => updater.supports(type));
+        if (!target) {
             throw new Error(`Unsupported type: ${type}`);
-        return target[0];
+        }
+        return target;
     }
 }
 exports.default = Resolver;
+//# sourceMappingURL=resolver.js.map

package/dist/resolver.js.map

@@ -0,0 +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,IAAY;QACzB,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"}

package/index.js

@@ -1,3 +1,5 @@
-const Resolver = require('./libs/resolver')
+'use strict';
 
-module.exports = Resolver.default || Resolver
+const Resolver = require('./dist/index');
+
+module.exports = Resolver.default || Resolver;

package/libs/index.ts

@@ -1,4 +1,6 @@
 export * from './interface'
 import Resolver from './resolver'
 export default Resolver
+// Export for CommonJS compatibility
+// @ts-ignore
 module.exports = Resolver

package/libs/interface.ts

@@ -1,10 +1,26 @@
-export interface ResolveTarget {
+/**
+ * Interface that classes which are targets for the resolver should implement
+ */
+export interface ResolveTarget<TArgs extends any[] = any[], TReturn = any> {
+  /**
+   * Determines whether the specified type is supported
+   * @param type The type to check for support
+   * @returns true if supported, false otherwise
+   */
   supports(type: string): boolean
-  handle(...args:any): any
+  
+  /**
+   * Handles the request
+   * @param args Arguments needed for processing
+   * @returns Processing result
+   */
+  handle(...args: TArgs): TReturn
 }
+
+// Maintain namespace for backward compatibility
 export namespace interfaces {
-  export interface ResolveTarget {
+  export interface ResolveTarget<TArgs extends any[] = any[], TReturn = any> {
     supports(type: string): boolean
-    handle(...args:any): any
+    handle(...args: TArgs): TReturn
   }
 }

package/libs/resolver.ts

@@ -1,29 +1,80 @@
-import { interfaces } from './interface'
-import ResolveTarget = interfaces.ResolveTarget
-
-class Resolver {
-  private updater: ResolveTarget[]
-  constructor (...args: ResolveTarget[]) {
-    this.updater = []
-    this.set(this.getArgs(args))
+import { ResolveTarget } from './interface'
+
+/**
+ * Resolver class implementing the Chain of Responsibility pattern
+ * Resolves handlers for specific types
+ */
+class Resolver<TBase extends ResolveTarget = ResolveTarget> {
+  /**
+   * Array of registered resolver targets
+   * @private
+   */
+  private updaters: TBase[] = [];
+
+  /**
+   * Initializes the resolver
+   * @param args Initial resolver targets
+   */
+  constructor(...args: TBase[]) {
+    if (args.length > 0) {
+      this.set(args);
+    }
   }
-  getArgs (arg: ResolveTarget[]): ResolveTarget[] {
-    return Array.prototype.slice.call(arg, 0)
+
+  /**
+   * Processes an array of arguments
+   * @param args Array of resolver targets
+   * @returns Processed array
+   * @private
+   */
+  private getArgs(args: TBase[]): TBase[] {
+    return [...args];
   }
-  set (updaters: ResolveTarget[]) {
-    this.updater = updaters
+
+  /**
+   * Sets resolver targets
+   * @param updaters Array of resolver targets
+   */
+  public set(updaters: TBase[]): void {
+    this.updaters = updaters;
   }
-  setUpdaters (...args: ResolveTarget[]) {
-    this.set(this.getArgs(args))
+
+  /**
+   * Sets resolver targets (variadic version)
+   * @param args Resolver targets
+   */
+  public setUpdaters(...args: TBase[]): void {
+    this.set(this.getArgs(args));
   }
-  addUpdater (updater: ResolveTarget) {
-    this.updater.push(updater)
+
+  /**
+   * Adds a resolver target
+   * @param updater Resolver target to add
+   */
+  public addUpdater(updater: TBase): void {
+    this.updaters.push(updater);
   }
-  resolve (type: string): ResolveTarget {
-    if (this.updater.length < 1) throw new Error('Unasigned resolve target.')
-    const target = this.updater.filter(updater => updater.supports(type))
-    if (target.length < 1) throw new Error(`Unsupported type: ${type}`)
-    return target[0]
+
+  /**
+   * 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
+   */
+  public resolve(type: string): TBase {
+    if (this.updaters.length < 1) {
+      throw new Error('Unasigned resolve target.');
+    }
+    
+    const target = this.updaters.find(updater => updater.supports(type));
+    
+    if (!target) {
+      throw new Error(`Unsupported type: ${type}`);
+    }
+    
+    return target;
   }
 }
-export default Resolver
+
+export default Resolver;

package/package.json

@@ -1,21 +1,29 @@
 {
   "name": "class-resolver",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Simple class resolver.",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "test": "jest"
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:dev": "jest --watch --silent=false --verbose false --coverage",
+    "prepublishOnly": "npm run build"
   },
-  "keywords": [],
+  "keywords": [
+    "resolver",
+    "chain-of-responsibility",
+    "typescript"
+  ],
   "author": "Hidetaka Okamoto <info@wp-kyoto.net> (https://wp-kyoto.net)",
   "license": "MIT",
   "devDependencies": {
-    "@types/jest": "^23.3.10",
-    "@types/node": "^11.10.4",
-    "jest": "^23.6.0",
-    "ts-jest": "^23.10.5",
-    "typescript": "^3.2.2"
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
   },
   "jest": {
     "moduleFileExtensions": [
@@ -24,15 +32,17 @@
       "js"
     ],
     "transform": {
-      "^.+\\.(ts|tsx)$": "ts-jest"
-    },
-    "globals": {
-      "ts-jest": {
-        "tsConfigFile": "tsconfig.json"
-      }
+      "^.+\\.(ts|tsx)$": ["ts-jest", { "tsconfig": "tsconfig.json" }]
     },
     "testMatch": [
       "**/__tests__/*.+(ts|tsx|js)"
     ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hideokamoto/class-resolver.git"
+  },
+  "engines": {
+    "node": ">=14.0.0"
   }
 }