@northern/di 1.0.3 → 2.0.1

package/README.md

@@ -1,6 +1,6 @@
 # DI
 
-A simple Dependency Injection container for JavaScript.
+A simple Dependency Injection container for JavaScript & TypeScript.
 
 ## Install
 
@@ -20,48 +20,49 @@ import Container from '@northern/di'
 
 const container = new Container()
 ````
-With the newly instantiated container, you can start registering services. There are two ways you can register a service, the "service" method and/or the "factory" method.
+With the newly instantiated container, you can start registering services. There are two ways you can register a service, either use the `service` method or you can use the `factory` method.
 
 ## Registering a service
 
 With the `service` method a new service provider can be registered. The `service` method takes three parameters:
 
-    Container.service(name, provider[, lazy = false])
+    Container.service(name, provider[, lazy = true, overwrite = false])
 
-The `name` is a string with the "name" of the service, e.g. `'logger'`. The `provider` is a function that "returns" the service instance. The `lazy` parameter specifies whether the service is "lazy" or not, more on that later.
+The `name` is a string with the "name" of the service, e.g. `logger`. The `provider` is a function that, when called, "returns" the service instance. The `lazy` parameter specifies whether the service is "lazy" or not, more on that later and the `overwrite` parameter allows you to re-register a service if it already exists in the service registry of the container (handy during integration tests when you want to swap a service with a mock).
 
-A "service" instance is only ever created once (as opposed to a factory, which returns a new instance each time). Let's look at a simple service registration process:
+A "service" instance is only ever created once (as opposed to a factory, which returns a new instance of the service each time).
+
+Let's look at a simple service registration example:
 ````
 class Logger {
   info(message) {
-    console.log(message)
+    console.info(message)
   }
 }
 
 container.service('logger', container => {
   return new Logger()
 })
-
 ````
-It's that simple. We can now get the "logger" by using the `get` method on the container:
-
-    const logger = container.get('logger')
-   
-    logger.info("Hello DI")
+It's that simple. We can now get the "logger" service by using the `get` method on the container:
+````
+const logger = container.get('logger')
 
-Since the `Container` instance is passed into the service provider, it is possible to "wire" multiple services together. I.e. a service provider can use prior registered services and "inject" them into other services. E.g. if we register a service then we can pass the `logger` to that service:
+logger.info("Hello DI")
+````
+Since the `Container` instance is passed into the service provider, it is possible to "wire" multiple services together (i.e. create service dependencies by having one service require another already registered service). A service provider can use already registered services and "inject" them into other services. E.g. if we register a service then we can pass an instance of the `logger` service into that other service:
 ````
 class PaymentService {
   constructor(logger) {
     this.logger = logger
   }
 
-  process(paymentObject) {
+  processPayment(paymentObject) {
     this.logger.info("Starting payment process.")
   }
 }
 
-container.service('payment', container => {
+container.service('paymentService', container => {
   const logger = container.get('logger')
 
   const service = new PaymentService(logger)
@@ -69,20 +70,20 @@ container.service('payment', container => {
   return service
 })
 
-const paymentService = container.get('payment')
-paymentService.process({...})
+const paymentService = container.get('paymentService')
+paymentService.processPayment({ ... })
 ````
 
 ### Lazy services
 
-When a service is not "lazy" then the instance of that service will be created the moment the service is registered (i.e. when the `service` method is called). This is not always desireable. E.g. if the dependency graph is large and not all services are always used, i.e. usage depends of the code path of the application, it might be better to instantiate a service on a need by need basis. This what a "lazy" service does; it's instance is created on request time rather than registration time.
-
-To create a lazy service, simply pass the 3rd parameter of the `service` method as `true`.
+When a service is not "lazy" then the instance of that service will be created the moment the service is registered (i.e. when the `service` method is called). This is not usually desireable (and why `lazy` by default is `true`). E.g. if the dependency graph is large and not all services are always used, i.e. usage depends of the code path of the application, it might be better to instantiate a service on a need by need basis. This what a "lazy" service does; the instance is created the first time the service is requested rather than when the service was registered.
 
 ## Registering a factory
 
-With the `factory` method a new factory provider can be created. A factory will always return a new instance each time it is requested from the container. The factory registration is the same as that of a service except that a factory cannot be lazy. I.e. the `factory` method only has two parameters:
+With the `factory` method a new factory provider can be created. A factory will always return a new instance each time it is requested from the container. The factory registration is the same as that of a service except that a factory cannot be lazy (i.e. its always lazy).
+
+The `factory` method only has three parameters:
 
-    Container.factory(name, provider)
+    Container.factory(name, provider[, overwrite = false])
 
-That's it.
+That's it. Have fun wiring!

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export default class Container {
+    private services;
+    constructor();
+    service(name: string, provider: Function | any, lazy?: boolean, overwrite?: boolean): void;
+    factory(name: string, provider: Function | any, overwrite?: boolean): void;
+    get(name: string): any;
+}

package/lib/index.js

@@ -1,66 +1,46 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var Container = function () {
-  function Container() {
-    _classCallCheck(this, Container);
-
-    this.services = {};
-  }
-
-  _createClass(Container, [{
-    key: "service",
-    value: function service(name, callback) {
-      var _this = this;
-
-      var lazy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-      if (this.services[name]) {
-        throw new Error("Service with name '" + name + "' already exists.");
-      }
-
-      if (lazy) {
-        this.services[name] = function (container) {
-          return _this.services[name] = callback.call(null, container);
-        };
-      } else {
-        this.services[name] = callback.call(null, this);
-      }
+Object.defineProperty(exports, "__esModule", { value: true });
+class Container {
+    constructor() {
+        this.services = new Map();
     }
-  }, {
-    key: "factory",
-    value: function factory(name, callback) {
-      if (this.services[name]) {
-        throw new Error("Service with name '" + name + "' already exists.");
-      }
-
-      this.services[name] = callback;
+    service(name, provider, lazy = true, overwrite = false) {
+        if (this.services.has(name) && !overwrite) {
+            throw new Error(`Service with name '${name}' already exists.`);
+        }
+        if (provider instanceof Function) {
+            if (lazy) {
+                this.services.set(name, (container) => {
+                    return this.services.set(name, provider.call(null, container));
+                });
+            }
+            else {
+                this.services.set(name, provider.call(null, this));
+            }
+        }
+        else {
+            this.services.set(name, provider);
+        }
     }
-  }, {
-    key: "get",
-    value: function get(name) {
-      if (!this.services[name]) {
-        throw new Error("Service with name '" + name + "' does not exist.");
-      }
-
-      var service = this.services[name];
-
-      if (service instanceof Function) {
-        return service.call(null, this);
-      }
-
-      return service;
+    factory(name, provider, overwrite = false) {
+        if (this.services.has(name) && !overwrite) {
+            throw new Error(`Service with name '${name}' already exists.`);
+        }
+        this.services.set(name, provider);
     }
-  }]);
-
-  return Container;
-}();
-
-exports.default = Container;
+    get(name) {
+        if (!this.services.has(name)) {
+            throw new Error(`Service with name '${name}' does not exist.`);
+        }
+        const service = this.services.get(name);
+        if (service instanceof Function) {
+            const result = service.call(null, this);
+            if ('get' in result) {
+                return result.get(name);
+            }
+            return result;
+        }
+        return service;
+    }
+}
+exports.default = Container;

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@northern/di",
-  "version": "1.0.3",
+  "version": "2.0.1",
   "description": "A simple Dependency Injection container for JavaScript",
   "main": "lib/index.js",
+  "files": [
+    "lib/**/*"
+  ],
   "scripts": {
+    "build": "tsc --removeComments",
     "test": "jest",
-    "test:watch": "jest --watch",
-    "prepublish": "babel src --out-dir lib --ignore *.test.js"
+    "test:watch": "jest --watch --no-coverage",
+    "test:coverage": "jest --coverage",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm test"
   },
   "repository": {
     "type": "git",
@@ -24,18 +30,12 @@
     "url": "https://github.com/northern/di.js/issues"
   },
   "homepage": "https://github.com/northern/di.js#readme",
-  "babel": {
-    "presets": [
-      "es2015"
-    ]
-  },
-  "jest": {
-    "modulePathIgnorePatterns": ["node_mdules", "lib"]
-  },
   "devDependencies": {
-    "babel-cli": "^6.26.0",
-    "babel-core": "^6.26.3",
-    "babel-preset-es2015": "^6.24.1",
-    "jest": "^22.4.3"
+    "@types/jest": "^25.1.4",
+    "@types/uuid": "^7.0.0",
+    "jest": "^25.1.0",
+    "ts-jest": "^25.2.1",
+    "typescript": "^4.6.3",
+    "uuid": "^7.0.2"
   }
 }

package/.npmingore

@@ -1 +0,0 @@
-src

package/di.sublime-project

@@ -1,8 +0,0 @@
-{
-	"folders":
-	[
-		{
-			"path": "."
-		}
-	]
-}