0.1.0

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Technove LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,177 @@
+# @technove/inject
+
+![Badge](https://img.shields.io/npm/v/@technove/inject?style=for-the-badge)
+
+A dependency injection library for TypeScript.
+With full support for custom injectors using promises.
+
+## Installation
+
+```
+yarn add @technove/inject reflect-metadata
+```
+
+Or on npm:
+
+```
+npm install --save @technove/inject reflect-metadata
+```
+
+Then at the top of your application's entry point, add the following line:
+
+```ts
+import "reflect-metadata";
+```
+
+## Usage
+
+### Defining a service
+
+```ts
+import {get, Service} from "@technove/inject";
+
+class MyLogger {
+    log(message: string) {
+        console.log(message);
+    }
+}
+
+const logger = get(MyLogger); // when you need to get the service
+logger.log("Hello, World!"); // -> "Hello, World!"
+
+// the instance will always be the same for repeated calls
+const logger2 = get(MyLogger);
+logger === logger2; // true!
+```
+
+### Using Abstract Classes
+
+A popular use-case for dependency injection is to define a different implementation for each environment.
+This is possible by declaring an abstract class, then extending it for each environment.
+
+```ts
+import {get, register, Service} from "@technove/inject";
+
+// logger.ts
+
+abstract class Logger {
+    abstract log(message: string): void;
+}
+
+// application.ts
+
+class ProductionLogger extends Logger {
+    log(message: string) {
+        console.log("PROD:", message);
+    }
+}
+
+register(ProductionLogger);
+
+// test.ts
+
+class TestingLogger extends Logger {
+    log(message: string) {
+        console.log("TEST:", message);
+    }
+}
+register(TestingLogger);
+
+// whenever you need a logger
+const logger = get(Logger);
+logger.log("Hello, World!");
+```
+
+### Using Services in Other Services
+
+Often you'll create a service that depends on another service.
+This is very easy to use, and is very flexible.
+
+```ts
+import {get, Service} from "@technove/inject";
+
+class Logger {
+    log(message: string) {
+        console.log(message);
+    }
+}
+
+class MyService {
+    @Inject()
+    private readonly logger!: Logger; // when you call get(MyService) the first time, this value will be filled
+
+    logMessage() {
+        this.logger.log("Hello, World!");
+    }
+}
+
+get(MyService).logMessage(); // -> "Hello, World!"
+```
+
+### Creating Custom Injection Providers
+
+Sometimes you may want to create a custom provider.
+This is made very simple!
+
+```ts
+import {get, FieldProvider, Inject} from "@technove/inject";
+
+const provider: FieldProvider = () => "Hello, World!";
+
+class MyService {
+    @Inject(provider)
+    private readonly message!: string;
+
+    logMessage() {
+        console.log(this.message);
+    }
+}
+
+get(MyService).logMessage(); // -> Hello, World!
+```
+
+These providers have access to the container, so they can even access other services!
+In fact, when you don't give a provider this is nearly equivalent what the default `@Inject()` uses:
+
+```ts
+const provider: FieldProvider = (container: Container) => container.get(Logger);
+```
+
+If you take arguments, you can make this fairly powerful.
+Say you had a filesystem service, you could use it to read files and inject it into your service:
+
+```ts
+const ReadFile = (path: string) => (container: Container) => container.get(FileSystem).readFile(path);
+
+class MyService {
+    @Inject(ReadFile("myfile.json"))
+    private readonly data!: string;
+}
+```
+
+### Creating Custom Injectors with Promises
+
+This idea is taken even further once you add promises to it.
+`FieldProvider`s can be marked async and return promised values.
+
+```ts
+const ReadJson = (path: string) => async () => {
+    const contents = await readFile(path, "utf-8");
+    return JSON.parse(contents);
+};
+
+class MyService {
+    @Inject(ReadFile("myfile.json"))
+    private readonly data!: any;
+}
+
+// NOTE:
+// using `get(MyService)` will throw an error, because you cannot load services with async values using it.
+// instead use the following:
+
+await load(MyService).data // has data from myfile.json!
+```
+
+## License
+
+MIT

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@technove/inject",
   "description": "Dependency injection for TypeScript",
-  "version": "0.0.12",
+  "version": "0.1.0",
   "author": "PaulBGD",
   "license": "MIT",
   "scripts": {

src/container.ts

@@ -111,3 +111,19 @@ export function get<T>(Service: Constructor<T>): T {
 export function load<T>(Service: Constructor<T>): Promise<T> {
     return globalContainer.load(Service);
 }
+
+export function register<T>(Service: Constructor<T>, instance: T) {
+    globalContainer.register(Service, instance);
+}
+
+export function getValue<T>(key: Key<T>): T | undefined {
+    return globalContainer.getValue(key);
+}
+
+export function setValue<T>(key: Key<T>, value: T) {
+    globalContainer.setValue(key, value);
+}
+
+export function removeValue<T>(key: Key<T>): T | undefined {
+    return globalContainer.removeValue(key);
+}

src/types.ts

@@ -4,4 +4,3 @@ export type Constructor<T> = Function & { prototype: T };
 export type PropertyType = String | Number | Boolean | Date | Array<any> | Constructor<any>;
 export type Provider = (container: Container, target: Object) => any | Promise<any>;
 export type FieldProvider = (container: Container, target: Object, propertyName: string, propertyType: PropertyType) => any | Promise<any>;
-