Added javascript support, removed "require decorator" things , added injectmany decorator, fixed issues #47 #48 #51

Author: Umed Khudoiberdiev

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.7.0
+
+* added javascript support
+* removed deprecated `@Require` decorator
+* added support for transient services
+* now service constructors cannot accept non-service arguments
+* added `@InjectMany` decorator to support injection of "many" values
+* fixed the way how global services work
+
 ## 0.6.1
 
 * added `Container.has` method

README.md

@@ -5,44 +5,107 @@
 [![Dependency Status](https://david-dm.org/typestack/typedi.svg)](https://david-dm.org/typestack/typedi)
 [![Join the chat at https://gitter.im/typestack/typedi](https://badges.gitter.im/typestack/typedi.svg)](https://gitter.im/typestack/typedi?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-TypeDI is a [dependency injection](https://en.wikipedia.org/wiki/Dependency_injection) tool for TypeScript.
+TypeDI is a [dependency injection](https://en.wikipedia.org/wiki/Dependency_injection) tool for JavaScript and TypeScript.
 Using TypeDI you can build well-structured and easily tested applications.
 
-## Installation
+## Usage with JavaScript
 
+Install the module:
+
+`npm install typedi --save`
+
+Now you can use TypeDI.
+The most simple usage example is:
+
+```javascript
+class SomeClass {
+
+    someMethod() {
+    }
+
+}
+
+var Container = require("typedi");
+let someClass = Container.get(SomeClass);
+someClass.someMethod();
+```
+
+Then you can call `Container.get(SomeClass)` from anywhere in your application
+ and you'll always have the same instance of `SomeClass`.
+
+In your class's constructor you always recieve as a last argument a container which you can use to get other dependencies.
+
+```javascript
+class BeanFactory {
+    create() {
+    }
+}
+
+class SugarFactory {
+    create() {
+    }
+}
+
+class WaterFactory {
+    create() {
+    }
+}
+
+class CoffeeMaker {
+
+    constructor(container) {
+        this.beanFactory = container.get(BeanFactory);
+        this.beanFactory = container.get(SugarFactory);
+        this.beanFactory = container.get(WaterFactory);
+    }
+
+    make() {
+        this.beanFactory.create();
+        this.sugarFactory.create();
+        this.waterFactory.create();
+    }
+
+}
+
+var container = require("typedi");
+var coffeeMaker = container.get(CoffeeMaker);
+coffeeMaker.make();
+```
+
+## Usage with TypeScript
 
 1. Install module:
 
     `npm install typedi --save`
 
-2. You also need to install [reflect-metadata](https://www.npmjs.com/package/reflect-metadata) package.
+2. Install [reflect-metadata](https://www.npmjs.com/package/reflect-metadata) package:
 
     `npm install reflect-metadata --save`
-    
-    and import it somewhere in the global place of your app (for example in `app.ts`):
-    
+
+    and import it somewhere in the global place of your app before any service declaration or import (for example in `app.ts`):
+
     `import "reflect-metadata";`
 
 3. You may need to install node typings:
 
     `npm install @types/node --save`
-    
 
-4. Also make sure you are using TypeScript compiler version > **2.1** 
-and you have enabled following settings in `tsconfig.json`:
+
+4. Enabled following settings in `tsconfig.json`:
 
 ```json
 "emitDecoratorMetadata": true,
 "experimentalDecorators": true,
 ```
 
-## Usage
-
+Now you can use TypeDI.
 The most simple usage example is:
 
 ```typescript
-import {Container} from "typedi";
+import "reflect-metadata";
+import {Service, Container} from "typedi";
 
+@Service()
 class SomeClass {
 
     someMethod() {
@@ -56,24 +119,8 @@ someClass.someMethod();
 
 Then you can call `Container.get(SomeClass)` from anywhere in your application
  and you'll always have the same instance of `SomeClass`.
- 
-If you want to use more advanced functionality you need to mark your class with `@Service` decorator:
-
-```typescript
-import {Service} from "typedi";
-
-@Service()
-class SomeClass {
-
-    someMethod() {
-    }
-
-}
-```
-
-Its recommended to always use `@Service` decorator on your service classes.
 
-You can services into your class using `@Inject` decorator:
+You can use **property injection** and inject services into your class using `@Inject` decorator:
 
 ```typescript
 import {Container, Inject, Service} from "typedi";

package.json

@@ -1,6 +1,6 @@
 {
   "name": "typedi",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Dependency injection for TypeScript",
   "license": "MIT",
   "readmeFilename": "README.md",

src/ContainerInstance.ts

@@ -91,14 +91,11 @@ export class ContainerInstance {
      * Optionally, parameters can be passed in case if instance is initialized in the container for the first time.
      */
     get<T>(identifier: ServiceIdentifier): T {
-        let service = this.findService(identifier);
 
-        // in the case if service was not found registered we search in the global container for this service
-        if (!service) {
-            const globalService = Container.of(undefined).findService(identifier);
-            if (globalService && globalService.global === true)
-                service = globalService;
-        }
+        const globalContainer = Container.of(undefined);
+        let service = globalContainer.findService(identifier);
+        if ((!service || service.global !== true) && globalContainer !== this)
+            service = this.findService(identifier);
 
         return this.getServiceValue(identifier, service);
     }
@@ -271,6 +268,7 @@ export class ContainerInstance {
         let params: any[] = paramTypes ? this.initializeParams(type, paramTypes) : [];
 
         // if factory is set then use it to create service instance
+        let value: any;
         if (service.factory) {
 
             // filter out non-service parameters from created service constructor
@@ -281,10 +279,10 @@ export class ContainerInstance {
             if (service.factory instanceof Array) {
                 // use special [Type, "create"] syntax to allow factory services
                 // in this case Type instance will be obtained from Container and its method "create" will be called
-                service.value = (this.get(service.factory[0]) as any)[service.factory[1]](...params);
+                value = (this.get(service.factory[0]) as any)[service.factory[1]](...params);
 
             } else { // regular factory function
-                service.value = service.factory(...params);
+                value = service.factory(...params);
             }
 
         } else {  // otherwise simply create a new object instance
@@ -293,19 +291,21 @@ export class ContainerInstance {
 
             params.unshift(null);
 
-            // if there are no constructor parameters in the class then pass a container instance into it
+            // "extra feature" - always pass container instance as the last argument to the service function
             // this allows us to support javascript where we don't have decorators and emitted metadata about dependencies
             // need to be injected, and user can use provided container to get instances he needs
-            if (params.length === 1)
-                params.push(this);
+            params.push(this);
 
-            service.value = new (type.bind.apply(type, params))();
+            value = new (type.bind.apply(type, params))();
         }
 
+        if (service && !service.transient && value)
+            service.value = value;
+
         if (type)
-            this.applyPropertyHandlers(type, service.value);
+            this.applyPropertyHandlers(type, value);
 
-        return service.value;
+        return value;
     }
 
     /**

src/decorators/InjectMany.ts

@@ -0,0 +1,52 @@
+import {Container} from "../Container";
+import {Token} from "../Token";
+import {CannotInjectError} from "../error/CannotInjectError";
+
+/**
+ * Injects a service into a class property or constructor parameter.
+ */
+export function InjectMany(type?: (type?: any) => Function): Function;
+
+/**
+ * Injects a service into a class property or constructor parameter.
+ */
+export function InjectMany(serviceName?: string): Function;
+
+/**
+ * Injects a service into a class property or constructor parameter.
+ */
+export function InjectMany(token: Token<any>): Function;
+
+/**
+ * Injects a service into a class property or constructor parameter.
+ */
+export function InjectMany(typeOrName?: ((type?: any) => Function)|string|Token<any>): Function {
+    return function(target: Object, propertyName: string, index?: number) {
+
+        if (!typeOrName)
+            typeOrName = () => (Reflect as any).getMetadata("design:type", target, propertyName);
+
+        Container.registerHandler({
+            object: target,
+            propertyName: propertyName,
+            index: index,
+            value: containerInstance => {
+                let identifier: any;
+                if (typeof typeOrName === "string") {
+                    identifier = typeOrName;
+
+                } else if (typeOrName instanceof Token) {
+                    identifier = typeOrName;
+
+                } else {
+                    identifier = typeOrName();
+                }
+
+                if (identifier === Object)
+                    throw new CannotInjectError(target, propertyName);
+
+                return containerInstance.getMany<any>(identifier);
+            }
+        });
+    };
+}

src/decorators/Require.ts

@@ -36,13 +36,15 @@ export function Service<T, K extends keyof T>(optionsOrServiceName?: ServiceOpti
         if (typeof optionsOrServiceName === "string" || optionsOrServiceName instanceof Token) {
             service.id = optionsOrServiceName;
             service.multiple = (optionsOrServiceName as ServiceOptions<T, K>).multiple;
-            service.global = (optionsOrServiceName as ServiceOptions<T, K>).global;
+            service.global = true;
+            service.transient = (optionsOrServiceName as ServiceOptions<T, K>).transient;
 
         } else if (optionsOrServiceName) { // ServiceOptions
             service.id = (optionsOrServiceName as ServiceOptions<T, K>).id;
             service.factory = (optionsOrServiceName as ServiceOptions<T, K>).factory;
             service.multiple = (optionsOrServiceName as ServiceOptions<T, K>).multiple;
-            service.global = (optionsOrServiceName as ServiceOptions<T, K>).global;
+            service.global = true;
+            service.transient = (optionsOrServiceName as ServiceOptions<T, K>).transient;
         }
 
         Container.set(service);

src/decorators/Service.ts

@@ -1,11 +1,15 @@
+import {Container} from "./Container";
+
 export * from "./decorators/Service";
 export * from "./decorators/Inject";
-export * from "./decorators/Require";
+export * from "./decorators/InjectMany";
 export {Container} from "./Container";
 export {ContainerInstance} from "./ContainerInstance";
 export {Token} from "./Token";
 export {Handler} from "./types/Handler";
 export {ServiceOptions} from "./types/ServiceOptions";
 export {ServiceIdentifier} from "./types/ServiceIdentifier";
 export {ServiceMetadata} from "./types/ServiceMetadata";
-export {ObjectType} from "./types/ObjectType";
+export {ObjectType} from "./types/ObjectType";
+
+export default Container;

src/index.ts

@@ -18,6 +18,12 @@ export interface ServiceMetadata<T, K extends keyof T> {
      */
     global?: boolean;
 
+    /**
+     * Indicates if instance of this class must be created on each its request.
+     * Global option is ignored when this option is used.
+     */
+    transient?: boolean;
+
     /**
      * Allows to setup multiple instances the different classes under a single service id string or token.
      */

src/types/ServiceMetadata.ts

@@ -12,6 +12,12 @@ export interface ServiceOptions<T, K extends keyof T> {
      */
     global?: boolean;
 
+    /**
+     * Indicates if instance of this class must be created on each its request.
+     * Global option is ignored when this option is used.
+     */
+    transient?: boolean;
+
     /**
      * Allows to setup multiple instances the different classes under a single service id string or token.
      */