first-di 1.0.19 → 2.0.1

package/README.md

@@ -3,35 +3,64 @@ First DI
 
 Easy dependency injection for typescript applications
 
-Description:
+Installation
 ------
-- For working this library needed Metadata Reflection API. If your platform (browser/nodejs) don't support it you must use polifyll. Example: [reflect-metadata](https://www.npmjs.com/package/reflect-metadata).
-- For working reflection should be enabled the option emitDecoratorMetadata and experimentalDecorators in tsconfig file.
-- For generate reflection by typescript need to create any decorator or use @reflection decorator from this library.
-- Lazy Loading for resolve dependency. Each dependency will created only after request property with @autowired decorator.
+
+For the latest stable version:
+
+```Bash
+npm i first-di
+```
+
+Features
+------
+
+- Easy and powerful dependency injection for any typescript application.
+- 2 modes of work. Optional DI - for most apps. Classic DI - for advanced apps.
+- Support for multiple scopes.
+- Supports multiple life cycles.
 - Dependency Free. Dependency used only for development.
 
-Using in Easy mode:
+Setup
 ------
- Simply write code as you used to and use @autowired() decorator to implement dependencies. And for override dependencies just use method override.
+Install [reflect-metadata](https://www.npmjs.com/package/reflect-metadata) package and import in root typescript file. This package is needed to support reflection and is a mandatory requirement of Typescript.
+
+In tsconfig.json enable compiler options:
+
+```Json
+{
+    "compilerOptions": {
+        ...
+        "emitDecoratorMetadata": true,
+        "experimentalDecorators": true,
+        ...
+    }
+}
+
+```
+
+Using in Optional DI mode
+------
+
+Just write classes and inject dependencies through class constructors. When the 'resolve' function is called, all dependencies will be resolved.
 
 ```typescript
-import { autowired, override, reflection } from "first-di";
+import { resolve, override, reflection } from "first-di";
 
-@reflection // typescript will generate reflection metadata
-class ProdRepository { // default implementation
+@reflection // Typescript will generate reflection metadata
+class ProdRepository { // Default implementation
 
-    public async getData(): Promise<string> {
-        return await Promise.resolve("production");
+    public async getData (): Promise<string> {
+        return Promise.resolve("production");
     }
 
 }
 
 @reflection
-class MockRepository { // mock implementation with same interface
+class MockRepository implements ProdRepository { // Mock implementation with same interface
 
-    public async getData(): Promise<string> {
-        return await Promise.resolve("mock");
+    public async getData (): Promise<string> {
+        return Promise.resolve("mock");
     }
 
 }
@@ -39,33 +68,38 @@ class MockRepository { // mock implementation with same interface
 @reflection
 class ProdService {
 
-    constructor(private readonly prodRepository: ProdRepository) { }
+    public constructor (
+        private readonly prodRepository: ProdRepository
+    ) { }
 
-    public async getData(): Promise<string> {
-        return await this.prodRepository.getData();
+    public async getData (): Promise<string> {
+        return this.prodRepository.getData();
     }
 
 }
 
-class ProdController {
-
-    @autowired() // inject dependency
-    private readonly prodService!: ProdService;
+@reflection
+class ProdStore {
 
-    // constructor use library, don't use him for inject
+    public constructor (
+        // Inject dependency
+        private readonly prodService: ProdService
+    ) {
+        // Other logic here
+    }
 
-    public async getData(): Promise<string> {
-        return await this.prodService.getData();
+    public async getData (): Promise<string> {
+        return this.prodService.getData();
     }
 
 }
 
-if (process.env.NODE_ENV === "test") { // override in test environment
+if (process.env.NODE_ENV === "test") { // Override in test environment
     override(ProdRepository, MockRepository);
 }
 
-const controllerInstance = new ProdController(); // create intance by framework
-const data = await controllerInstance.getData();
+const store = resolve(ProdStore); // Create intance by framework
+const data = await store.getData();
 
 if (process.env.NODE_ENV === "test") {
     assert.strictEqual(data, "mock");
@@ -74,24 +108,25 @@ if (process.env.NODE_ENV === "test") {
 }
 ```
 
-Using in Pro mode:
+Using in Classic DI mode
 ------
+
  In professional mode Interfaces are used instead of implementations. But typescript does not generate Interfaces for working in runtime. But Interface is abstract base class. So instead of Interfaces, you need to write Abstract classes.
 
 ```typescript
-import { autowired, override, reflection } from "first-di";
+import { resolve, override, reflection } from "first-di";
 
-abstract class AbstractRepository { // abstract instead of interface
+abstract class AbstractRepository { // Abstract instead of interface
 
-    abstract getData(): Promise<string>;
+    public abstract getData (): Promise<string>;
 
 }
 
 @reflection
 class ProdRepository implements AbstractRepository {
 
-    public async getData(): Promise<string> {
-        return await Promise.resolve("production");
+    public async getData (): Promise<string> {
+        return Promise.resolve("production");
     }
 
 }
@@ -99,15 +134,15 @@ class ProdRepository implements AbstractRepository {
 @reflection
 class MockRepository implements AbstractRepository {
 
-    public async getData(): Promise<string> {
-        return await Promise.resolve("mock");
+    public async getData (): Promise<string> {
+        return Promise.resolve("mock");
     }
 
 }
 
-abstract class AbstractService { // abstract instead of interface
+abstract class AbstractService { // Abstract instead of interface
 
-    abstract getData(): Promise<string>;
+    public abstract getData (): Promise<string>;
 
 }
 
@@ -116,25 +151,25 @@ class ProdService implements AbstractService {
 
     private readonly prodRepository: AbstractRepository;
 
-    constructor(prodRepository: AbstractRepository) {
+    public constructor (prodRepository: AbstractRepository) {
         this.prodRepository = prodRepository;
     }
 
-    public async getData(): Promise<string> {
-        return await this.prodRepository.getData();
+    public async getData (): Promise<string> {
+        return this.prodRepository.getData();
     }
 
 }
 
-class ProdController {
-
-    @autowired()
-    private readonly prodService!: AbstractService;
+@reflection
+class ProdStore {
 
-    // constructor use library, don't use him for inject
+    public constructor (
+        private readonly prodService: AbstractService
+    ) {}
 
-    public async getData(): Promise<string> {
-        return await this.prodService.getData();
+    public async getData (): Promise<string> {
+        return this.prodService.getData();
     }
 
 }
@@ -147,8 +182,8 @@ if (process.env.NODE_ENV === "test") {
     override(AbstractRepository, ProdRepository);
 }
 
-const controllerInstance = new ProdController();
-const data = await controllerInstance.getData();
+const store = resolve(ProdStore);
+const data = await store.getData();
 
 if (process.env.NODE_ENV === "test") {
     assert.strictEqual(data, "mock");
@@ -157,14 +192,17 @@ if (process.env.NODE_ENV === "test") {
 }
 ```
 
-Options:
+Options
 ------
-First DI has several points for customizing dependency options.
+
+First DI has several points for customizing dependency options:
+
 - **Global** - `DI.defaultOptions: AutowiredOptions`. Sets global default behavior.
-- **Autowired** - `@autowired(options?: AutowiredOptions)`. Sets behaviors for resolve dependencies.
 - **Override** - `override(fromClass, toClass, options?: AutowiredOptions)`. Sets behavior overrided dependency.
+- **Resolve** - `resolve(class, options?: AutowiredOptions)`. Sets behaviors for resolve dependencies.
+
+Options has next properties:
 
-AutowiredOptions has next properties:
 - **lifeTime: AutowiredLifetimes** - Sets lifeTime of dependecy.
 
     SINGLETON - Create one instance for all resolvers.
@@ -175,8 +213,9 @@ AutowiredOptions has next properties:
 
     PER_ACCESS - Create new instance on each access to resolved property.
 
-Scopes:
+Scopes
 ------
+
 Support multiple scopes
 
 ```typescript
@@ -186,32 +225,18 @@ import { ProductionService } from "../services/ProductionService";
 const scopeA = new DI();
 const scopeB = new DI();
 
-export class Controller {
-
-    @scopeA.autowired()
-    private readonly serviceScopeA!: ProductionService;
-
-    @scopeB.autowired()
-    private readonly serviceScopeB!: ProductionService;
+const serviceScopeA = scopeA.resolve(ProductionService);
+const dataA = await serviceScopeA.getData();
 
-    // constructor use library, don't use him for inject
-
-    public async getDataScopeA(): Promise<string> {
-        return await this.serviceScopeA.getData();
-    }
-
-    public async getDataScopeB(): Promise<string> {
-        return await this.serviceScopeB.getData();
-    }
-
-}
+const serviceScopeB = scopeB.resolve(ProductionService);
+const dataB = await serviceScopeB.getData();
 ```
 
-API:
+API
 ------
-First DI also has an API for extended use. For example, use as A Service Locator.
 
-- autowired - Decorator. Assigned to property for resolve dependency.
+First DI also has an API for extended use.
+
 - override - Function. Override dependency and resolve options.
 - resolve - Function. Resolves dependence with default options or specified.
 - singleton - Function. Resolve singleton.
@@ -221,16 +246,10 @@ First DI also has an API for extended use. For example, use as A Service Locator
 Resolve, singleton, instance - can be used to implement the Service Locator.
 
 ```typescript
-import { singleton, instance, resolve, autowired, AutowiredLifetimes } from "first-di";
+import { singleton, instance, resolve, AutowiredLifetimes } from "first-di";
 
 class ApiDemo {
 
-    @autowired({ lifeTime: AutowiredLifetimes.SINGLETON })
-    private readonly service1!: ApiService1;
-
-    @autowired({ lifeTime: AutowiredLifetimes.PER_INSTANCE })
-    private readonly service2!: ApiService2;
-
     private readonly service3: ApiService3 = resolve(ApiService3, { lifeTime: AutowiredLifetimes.PER_INSTANCE });
 
     private readonly service4: ApiService4 = singleton(ApiService4);
@@ -240,10 +259,10 @@ class ApiDemo {
 }
 ```
 
-
-Extension DI:
+Extension DI
 ------
-First DI using OOP and SOLID design principles. Each part of DI can be overrided or extended after inheritance from base class.
+
+First DI using OOP and SOLID design principles. Each part of DI can be override or extende after inheritance from base class.
 
 ```typescript
 import { DI } from "first-di";

package/dist/classes/di.d.ts

@@ -13,6 +13,11 @@ export declare class DI {
     protected singletonsList: Map<ClassConstructor<object>, object>;
     protected overrideList: Map<OverrideConstructor<object>, OverrideOptions>;
     constructor();
+    /**
+     * Decorator @autowired is deprecated, and will by removed in next versions
+     * @param options
+     * @returns
+     */
     protected makeAutowired(options?: AutowiredOptions): PropertyDecorator;
     protected makeResolve<T extends object>(inConstructor: ClassConstructor<T>, inOptions?: AutowiredOptions, caller?: object, propertyKey?: string | symbol): T;
     protected makeReset(): void;

package/dist/classes/di.js

@@ -18,7 +18,16 @@ export class DI {
             this.makeOverride(from, to, options);
         };
     }
+    /**
+     * Decorator @autowired is deprecated, and will by removed in next versions
+     * @param options
+     * @returns
+     */
     makeAutowired(options) {
+        // eslint-disable-next-line no-console
+        console.warn("first-di: @autowired is depreacted, " +
+            "new standart of ecmascript decorators prohibits changing the classes, " +
+            "use 'resolve' functions instaed of @autowired");
         return (target, propertyKey) => {
             const type = Reflect.getMetadata("design:type", target, propertyKey);
             const { resolve } = this;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "first-di",
-    "version": "1.0.19",
+    "version": "2.0.1",
     "description": "Easy dependency injection for typescript applications",
     "main": "./dist/index.js",
     "type": "module",
@@ -9,15 +9,15 @@
         "reflect-metadata": ">=0.1.0"
     },
     "devDependencies": {
-        "@labeg/code-style": "^4.0.4",
-        "@types/chai": "^4.3.11",
+        "@labeg/code-style": "^4.0.7",
+        "@types/chai": "^4.3.14",
         "@types/mocha": "^10.0.6",
-        "@types/node": "^20.10.4",
-        "chai": "^4.3.10",
-        "mocha": "^10.2.0",
+        "@types/node": "^20.12.7",
+        "chai": "^5.1.0",
+        "mocha": "^10.4.0",
         "ts-node": "^10.9.2",
-        "reflect-metadata": "^0.2.1",
-        "typescript": "^5.3.3"
+        "reflect-metadata": "^0.2.2",
+        "typescript": "^5.4.5"
     },
     "scripts": {
         "lint": "eslint --fix -c .eslintrc.cjs --ext .tsx,.ts,.jsx,.js ./src/ ./tests/",