feat: global providers

Author: carlossalasamper

README.md

@@ -23,7 +23,7 @@
     - [Providers](#providers)
     - [Exports](#exports)
     - [Get the Container of a Module](#get-the-container-of-a-module)
-- [Code Coverage](#code-coverage)
+- [Testing](#testing)
 - [Support the Project](#support-the-project)
 - [License](#license)
 
@@ -230,11 +230,37 @@ Below you will find a detailed explanation of each of the concepts that this lib
 
 #### Get the Container of a Module
 
-// TODO
+Ideally we shouldn't be accessing module containers directly to get a service. In either case, the `getModuleContainer` function allows you to get the container of a module in case you need to access it in an statement.
+
+```typescript
+import { getModuleContainer, module, InversifySugar } from "inversify-sugar";
+import { injectable } from "inversify";
+
+@injectable()
+class TestService {}
+
+@module({
+  providers: [TestService],
+})
+class TestModule {}
+
+@module({
+  imports: [TestModule],
+})
+class AppModule {}
+
+InversifySugar.run(AppModule);
+
+// Accessing the container of a imported module
+const testModuleContainer = getModuleContainer(TestModule);
+const testService = testModuleContainer.get(TestService);
+```
+
+## Testing
 
-## Code Coverage
+The complexity of the memory state during the execution of Inversify Sugar, managing multiple Inversify containers under the hood, is too high to ensure that it is working correctly without writing unit tests of each of the functionalities separately.
 
-The complexity of the memory state during the execution of Inversify Sugar, managing multiple Inversify containers under the hood, is too high to be able to ensure that it is working correctly without writing unit tests of each of the functionalities separately.
+For this reason, a set of tests have been written that you can consult [here](./tests).
 
 So you can use it without worries. You are facing a completely armored dependency system.
 

assets/badges/coverage/badge-branches.svg

@@ -34,8 +34,8 @@
     "lint": "eslint . --ext .ts",
     "test:unit": "jest --coverage && jest-coverage-badges --input ./coverage/coverage-summary.json --output ./assets/badges/coverage",
     "test": "yarn test:unit",
-    "build": "ttsc",
-    "build:dev": "yarn build --watch",
+    "build": "ttsc --project tsconfig.build.json",
+    "build:dev": "yarn build --project tsconfig.build.json --watch",
     "yalc:publish": "npx yalc publish",
     "yalc:update": "npx yalc push --scripts --update --replace",
     "npm:publish": "yarn build && npm publish"

assets/badges/coverage/badge-functions.svg

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Container } from "inversify";
 import { Constructor } from "../types";
 import ModuleMetadata, { ModuleMetadataArgs } from "../types/ModuleMetadata";
@@ -8,14 +9,22 @@ export default function module({
   exports = [],
 }: ModuleMetadataArgs) {
   return (target: Constructor) => {
-    const metadata = {
+    const scopedProviders = providers.filter(
+      (provider: any) => !provider.isGlobal
+    );
+    const globalProviders = providers.filter(
+      (provider: any) => !!provider.isGlobal
+    );
+    const metadata: ModuleMetadata = {
       isModule: true,
       isBinded: false,
       container: new Container(),
+      exportsContainer: new Container(),
       imports,
-      providers,
+      providers: scopedProviders,
+      globalProviders,
       exports,
-    } as ModuleMetadata;
+    };
 
     for (const key in metadata) {
       if (metadata.hasOwnProperty(key)) {

assets/badges/coverage/badge-lines.svg

@@ -1,7 +1,7 @@
 import { keys } from "ts-transformer-keys";
 import Provider from "./Provider";
 import { Constructor } from ".";
-import { Container, interfaces } from "inversify";
+import { Container } from "inversify";
 
 /**
  * @description Interface defining the property object that describes the module.
@@ -24,18 +24,24 @@ export interface ModuleMetadataArgs {
   /**
    * @description Optional list of providers exported from this module.
    */
-  exports?: interfaces.ServiceIdentifier[];
+  exports?: Provider[];
 }
 
 export default interface ModuleMetadata {
   isModule: true;
   isBinded: boolean;
   container: Container;
+  exportsContainer: Container;
   imports: Constructor[];
   providers: Provider[];
-  exports: Constructor[];
+  globalProviders: Provider[];
+  exports: Provider[];
 }
 
-export const IsModuleKey: keyof ModuleMetadata = "isModule";
+export const isModuleKey: keyof ModuleMetadata = "isModule";
+
+export const isBindedKey: keyof ModuleMetadata = "isBinded";
+
+export const containerKey: keyof ModuleMetadata = "container";
 
 export const moduleMetadataKeys = keys<ModuleMetadata>();

assets/badges/coverage/badge-statements.svg

@@ -6,7 +6,14 @@ interface WithProvide {
   /**
    * @description ServiceIdentifier / InjectionToken
    */
-  provide: interfaces.ServiceIdentifier;
+  provide: string | symbol;
+}
+
+interface WithIsGlobal {
+  /**
+   * @description Flag that indicates if the provider is binded to the global container.
+   */
+  isGlobal?: boolean;
 }
 
 /**
@@ -17,14 +24,16 @@ export type ConstructorProvider<T = any> = Constructor<T>;
 /**
  * @description Interface defining a *Class* type provider.
  */
-export interface ClassProvider<T = any> extends Partial<WithProvide> {
+export interface ClassProvider<T = any>
+  extends Partial<WithProvide>,
+    WithIsGlobal {
   /**
    * @description Instance of a provider to be injected.
    */
   useClass: T;
   useValue?: never;
   /**
-   * Binding scope of a provider.
+   * @description Binding scope of a provider.
    * @default 'Singleton'
    */
   scope?: interfaces.BindingScope;
@@ -33,7 +42,7 @@ export interface ClassProvider<T = any> extends Partial<WithProvide> {
 /**
  * @description Interface defining a *Value* type provider.
  */
-export interface ValueProvider<T = any> extends WithProvide {
+export interface ValueProvider<T = any> extends WithProvide, WithIsGlobal {
   /**
    * @description Instance of a provider to be injected.
    */
@@ -44,7 +53,7 @@ export interface ValueProvider<T = any> extends WithProvide {
 /**
  * @description Interface defining a *Factory* type provider. The scope of a factory provider is always singleton.
  */
-export interface FactoryProvider<T = any> extends WithProvide {
+export interface FactoryProvider<T = any> extends WithProvide, WithIsGlobal {
   /**
    * @description Factory function to be injected.
    */

package.json

@@ -2,7 +2,7 @@ import { Container, interfaces } from "inversify";
 import { Constructor } from "../types";
 import importModule from "./importModule";
 import ModuleMetadata from "../types/ModuleMetadata";
-import clc from "cli-color";
+import messagesMap from "./messagesMap";
 
 /**
  * @description InversifySugar is a utility class that helps you to bootstrap inversify and configure it.
@@ -18,7 +18,9 @@ export default class InversifySugar {
    */
   public static debug = false;
 
-  private static _rootContainer: Container | undefined;
+  private static isRunning = false;
+
+  private static _globalContainer = new Container();
 
   private static _onModuleImported:
     | ((
@@ -28,11 +30,21 @@ export default class InversifySugar {
       ) => void)
     | undefined;
 
+  static get globalContainer() {
+    return InversifySugar._globalContainer;
+  }
+
   /**
    * @description This method is used to bootstrap inversify and import the AppModule.
    */
-  static run(AppModule: Constructor): Container {
-    return importModule(AppModule, true);
+  static run(AppModule: Constructor) {
+    if (InversifySugar.isRunning) {
+      throw new Error(messagesMap.alreadyRunning);
+    }
+
+    InversifySugar.isRunning = true;
+
+    importModule(AppModule, true);
   }
 
   static onModuleImported(
@@ -43,7 +55,7 @@ export default class InversifySugar {
     InversifySugar._onModuleImported?.(container, metadata, Module);
 
     if (InversifySugar.debug) {
-      console.log(clc.bold("[@module]"), clc.green(`${Module.name} imported.`));
+      console.log(messagesMap.moduleImported(Module.name));
     }
   }
 
@@ -56,18 +68,4 @@ export default class InversifySugar {
   ) {
     InversifySugar._onModuleImported = value;
   }
-
-  static get rootContainer() {
-    if (!InversifySugar._rootContainer) {
-      console.warn(
-        clc.xterm(250)("You are accessing the root container before it is set.")
-      );
-    }
-
-    return InversifySugar._rootContainer;
-  }
-
-  static setRootContainer(container: Container | undefined) {
-    InversifySugar._rootContainer = container;
-  }
 }

src/decorators/module.ts

@@ -1,16 +1,16 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Container, interfaces } from "inversify";
+import { Container } from "inversify";
 import Provider, {
   ClassProvider,
   ConstructorProvider,
   FactoryProvider,
   ValueProvider,
 } from "../types/Provider";
-import InversifySugar from "./InversifySugar";
 import isConstructorProvider from "./validation/isConstructorProvider";
 import isClassProvider from "./validation/isClassProvider";
 import isValueProvider from "./validation/isValueProvider";
 import isFactoryProvider from "./validation/isFactoryProvider";
+import setScope from "./setScope";
 
 const bindProvider = (provider: Provider, container: Container) => {
   if (isConstructorProvider(provider)) {
@@ -38,21 +38,4 @@ const bindProvider = (provider: Provider, container: Container) => {
   }
 };
 
-function setScope(
-  binding: interfaces.BindingInWhenOnSyntax<any>,
-  scope: interfaces.BindingScope = InversifySugar.defaultScope
-) {
-  switch (scope) {
-    case "Transient":
-      binding.inTransientScope();
-      break;
-    case "Request":
-      binding.inRequestScope();
-      break;
-    case "Singleton":
-      binding.inSingletonScope();
-      break;
-  }
-}
-
 export default bindProvider;

src/types/ModuleMetadata.ts

@@ -0,0 +1,12 @@
+import { Constructor } from "../types";
+import ModuleMetadata, { moduleMetadataKeys } from "../types/ModuleMetadata";
+import getAllMetadata from "./getAllMetadata";
+
+export default function getModuleContainer(Module: Constructor) {
+  const metadata = getAllMetadata<ModuleMetadata>(
+    Module.prototype,
+    moduleMetadataKeys
+  );
+
+  return metadata.container;
+}