mesh-ioc 0.3.0 → 1.2.0

package/README.md

@@ -6,13 +6,85 @@ Mesh IoC solves the problem of dependency management of application services. It
 
 ## Key features
 
-- 👗 Very slim — about 4KB minified, even less gzipped
+- 👗 Very slim — about 2KB minified, few hundred bytes gzipped
 - ⚡️ Blazing fast
 - 🧩 Flexible and composable
 - 🌿 Ergonomic
 - 🐓 🥚 Tolerates circular dependencies
 - 🕵️‍♀️ Provides APIs for dependency analysis
 
+## Quick API Cheatsheet
+
+```ts
+// Mesh is an IoC container that stores service bindings and instantiated objects
+const mesh = new Mesh('someName');
+
+// Bindings:
+
+// 1. Service (zero-arg constructor) to itself
+mesh.service(SomeDatabase);
+// 2. Abstract class to service implementation
+mesh.service(Logger, SomeLogger);
+// 3. String key to service (👎 because of limited type support)
+mesh.service('Something', Something);
+// 4. Service to instance
+mesh.constant(SomeService, someServiceInstance);
+// 5. String key to arbitrary constant
+mesh.constant('SessionId', 42);
+// 6. Alias (key to another key)
+mesh.alias('DB', SomeDatabase);
+
+// Methods can also be chained
+mesh.service(MyFoo)
+    .alias(Foo, MyFoo)
+    .constant('Secret', 'supersecret');
+
+// Declarative bindings in services:
+
+class SomeDatabase {
+    @dep() logger!: Logger; // auto-resolved by Mesh
+}
+
+// Manual resolution:
+
+const db = mesh.resolve(SomeDatabase);
+
+// Connect instances:
+
+class User {
+    @dep() db!: MyDatabase;
+}
+
+const user = mesh.connect(new User());  // now user.db will also be resolved by Mesh
+
+// Scopes:
+
+// Declare scoped bindings
+mesh.scope('request')
+    .service(UsersRouter)
+    .service(OrdersRouter);
+
+// Create and use scope
+const request = mesh.createScope('request')
+    // Bind scope-specific data
+    .constant(Request, req)
+    .constant(Response, res);
+
+// Scoped services can use scope-specific data
+class UsersRouter {
+    @dep() req!: Request;
+    @dep() res!: Response;
+}
+
+// Middleware:
+mesh.use(instance => {
+    // Allows modifying instances as they are created or connected
+    // (useful for logging, stats or replacing instances with proxies)
+    console.log('Instantiated', instance);
+    return instance;
+});
+```
+
 ## IoC Recap
 
 [IoC](https://en.wikipedia.org/wiki/Inversion_of_control) when applied to class dependency management states that each component should not resolve their dependencies — instead the dependencies should be provided to each component.
@@ -90,8 +162,9 @@ class Redis {
 // app.ts
 
 class AppMesh extends Mesh {
-    this.bind(Redis);
-    this.bind(Logger, ConsoleLogger);
+    // List all services so that mesh connects them together
+    this.service(Redis);
+    this.service(Logger, ConsoleLogger);
 }
 ```
 
@@ -115,7 +188,7 @@ There are several aspects that differentiate Mesh IoC from the rest of the DI li
 
   - Constant values can be bound to mesh. Those could be instances of other classes.
 
-**Important!** Mesh should be used to track _services_. We defined services as classes with **zero-argument constructors** (this is also enforced by TypeScript). However, there are multiple patterns to support construtor arguments, read on!
+**Important!** Mesh should be used to track _services_. We defined services as classes with **zero-argument constructors** (this is also enforced by TypeScript). However, there are multiple patterns to support constructor arguments, read on!
 
 ## Application Architecture Guide
 
@@ -127,49 +200,42 @@ This short guide briefly explains the basic concepts of a good application archi
   - **Request/session scope**: things like traditional HTTP routers will depend on `request` and `response` objects; the same reasoning can be applied to other scenarios, for example, web socket server may need functionality per each connected client — such components will depend on client socket.
   - **Short-lived per-instance scope**: if you use "fat" classes (e.g. Active Record pattern) then each entity instances should be conceptually "connected" to the rest of the application (e.g. `instance.save()` should somehow know about the database)
 
-2. Build the mesh hierarchy, starting from application scope.
+2. Build the mesh hierarchy, starting from application scope, descending into more granular scopes.
 
     ```ts
     // app.ts
     export class App {
         // You can either inherit from Mesh or store it as a field.
         // Name parameter is optional, but can be useful for debugging.
-        mesh = new Mesh('App');
-        // Define your application-scoped services
-        logger = mesh.bind(Logger, GlobalLogger);
-        database = mesh.bind(MyDatabase);
-        server = mesh.bind(MyServer);
-        // ...
+        mesh: Mesh;
+
+        constructor() {
+            this.mesh = new Mesh('App')
+                // Define your application-scoped services
+                .constant(App, this)
+                .service(Logger, GlobalLogger);
+                .service(MyDatabase);
+                .service(MyServer);
+                // Define your session-scoped services
+                .scope('session')
+                .service(Logger, SessionLogger)
+                .service(SessionScopedService);
+        }
 
         start() {
             // Define logic for application startup
             // (e.g. connect to databases, start listening to servers, etc)
+            this.mesh.resolve(MyServer).listen();
         }
-    }
-
-    // session.ts
-    export class Session {
-        mesh: Mesh;
 
-        // A sample session scope will depend on Request and Response;
-        // Parent mesh is required so that session-scoped services
-        // can access application-scoped services
-        // (the other way around does not work, obviously)
-        constructor(parentMesh: Mesh, req: Request, res: Response) {
-            this.mesh = new Mesh('Session', parentMesh);
-            // Session dependencies can be bound as constants
-            this.mesh.constant(Request, req);
-            this.mesh.constant(Response, req);
-            // Bindings from parent can be overridden, so that session-scoped services
-            // could use more specialized versions
-            this.mesh.bind(Logger, SessionLogger);
-            // Define other session-scoped services
-            this.mesh.bind(SessionScopedService);
-            // ...
-        }
-
-        start() {
-            // Define what happens when session is established
+        startSession(req: Request, res: Response) {
+            // Bind session-specific data (e.g. request, response, client web socket, session id, etc)
+            const sessionMesh = this.mesh.createScope('session')
+                // Session-specific data can be bound by session-scoped services
+                .constant(Request, req)
+                .constant(Response, res);
+            // Define logic for session initialisation
+            sessionMesh.resolve(SessionScopedService).doStuff();
         }
     }
     ```
@@ -187,8 +253,7 @@ This short guide briefly explains the basic concepts of a good application archi
 
     ```ts
     export class MyServer {
-        // Note: Mesh is automatically available in all "connected" classes
-        @dep() mesh!: Mesh;
+        @dep() app!: App;
 
         // The actual server (e.g. http server or web socket server)
         server: Server;
@@ -196,9 +261,7 @@ This short guide briefly explains the basic concepts of a good application archi
         constructor() {
             this.server = new Server((req, res) => {
                 // This is the actual entrypoint of Session
-                const session = new Session(this.mesh, req, res);
-                // Note the similarity to application entrypoint
-                session.start();
+                app.startSession(req, res);
             });
         }
     }
@@ -211,7 +274,7 @@ This short guide briefly explains the basic concepts of a good application archi
 
         @dep() database!: Database;
         @dep() req!: Request;
-        @dep() res!: Request;
+        @dep() res!: Response;
 
         // ...
     }
@@ -240,7 +303,7 @@ class User {
     @dep() database!: Database;
 
     // Note: constructor can have arbitrary arguments in this case,
-    // because the instantiated isn't controlled by Mesh
+    // because the instantiation isn't controlled by Mesh
     constructor(
         public firstName = '',
         public lastName = '',
@@ -254,6 +317,7 @@ class User {
 }
 
 class UserService {
+    // Note: Mesh is automatically available in all connected services
     @dep() mesh!: Mesh;
 
     createUser(firstName = '', lastName = '', email = '', /*...*/) {
@@ -266,43 +330,6 @@ class UserService {
 
 Note: the important limitation of this approach is that `@dep` are not available in entity constructors (e.g. `database` cannot be resolved in `User` constructor, because by the time the instance is instantiated it's not yet connected to the mesh).
 
-### Binding classes
-
-Mesh typically connects the instances of services (again, services are classes with zero-arg constructors).
-
-However, in some cases you may need to instantiate other classes, for example, third-party or with non-zero-arg constructors. You can always do it directly, however, a level of indirection can be introduced by defining a class on Mesh. This can be especially useful in tests where classes can be substituted on Mesh level without changing the implementation.
-
-Example:
-
-```ts
-// An example arbitrary class, unconnected to mesh
-class Session {
-    constructor(readonly sessionId: number) {}
-}
-
-// A normal service connected to mesh
-class SessionManager {
-    // Class constructor is injected (note: `key` is required because it cannot be deferred in this case)
-    @dep({ key: 'Session' }) Session!: typeof Session;
-
-    createSession(id: number): Session {
-        // Instantiate using injected constructor
-        return new this.Session(id);
-    }
-}
-
-// ...
-const mesh = new Mesh();
-mesh.bind(SessionManager);
-mesh.class(Session); // This makes Session class available as a binding
-
-// In tests this can be overridden, so SessionManager will transparently instantiate a different class
-// (assuming constructor signatures match)
-mesh.class(Session, MySession);
-```
-
-This approach can also be combined with `connect` so that the arbitrary class can also use `@dep`. Mix & match FTW!
-
 ## License
 
 [ISC](https://en.wikipedia.org/wiki/ISC_license) © Boris Okunskiy

package/out/main/bindings.d.ts

@@ -1,35 +1,14 @@
-import { Mesh } from './mesh';
-import { Constructor, ServiceConstructor } from './types';
-export declare abstract class Binding<T> {
-    readonly mesh: Mesh;
-    readonly key: string;
-    constructor(mesh: Mesh, key: string);
-    abstract get(): T;
-}
-export declare class ConstantBinding<T> extends Binding<T> {
+import { ServiceConstructor } from './types';
+export declare type Binding<T> = ConstantBinding<T> | ServiceBinding<T> | AliasBinding;
+export declare type ConstantBinding<T> = {
+    type: 'constant';
     value: T;
-    constructor(mesh: Mesh, key: string, value: T);
-    get(): T;
-}
-export declare class ServiceBinding<T> extends Binding<T> {
-    ctor: ServiceConstructor<T>;
-    instance: T | undefined;
-    constructor(mesh: Mesh, key: string, ctor: ServiceConstructor<T>);
-    get(): T;
-    protected processClass(ctor: any): {
-        new (): {
-            [x: string]: any;
-        };
-        [x: string]: any;
-    };
-}
-export declare class ClassBinding<T extends Constructor<T>> extends Binding<T> {
-    readonly ctor: T;
-    constructor(mesh: Mesh, key: string, ctor: T);
-    get(): T;
-}
-export declare class ProxyBinding<T> extends Binding<T> {
-    readonly alias: string;
-    constructor(mesh: Mesh, key: string, alias: string);
-    get(): T;
-}
+};
+export declare type ServiceBinding<T> = {
+    type: 'service';
+    class: ServiceConstructor<T>;
+};
+export declare type AliasBinding = {
+    type: 'alias';
+    key: string;
+};

package/out/main/bindings.js

@@ -1,63 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProxyBinding = exports.ClassBinding = exports.ServiceBinding = exports.ConstantBinding = exports.Binding = void 0;
-class Binding {
-    constructor(mesh, key) {
-        this.mesh = mesh;
-        this.key = key;
-    }
-}
-exports.Binding = Binding;
-class ConstantBinding extends Binding {
-    constructor(mesh, key, value) {
-        super(mesh, key);
-        this.value = this.mesh.connect(value);
-    }
-    get() {
-        return this.value;
-    }
-}
-exports.ConstantBinding = ConstantBinding;
-class ServiceBinding extends Binding {
-    constructor(mesh, key, ctor) {
-        super(mesh, key);
-        this.ctor = this.processClass(ctor);
-    }
-    get() {
-        if (!this.instance) {
-            const inst = new this.ctor();
-            this.instance = this.mesh.connect(inst);
-        }
-        return this.instance;
-    }
-    processClass(ctor) {
-        // A fake derived class is created with Mesh attached to its prototype.
-        // This allows accessing deps in constructor whilst preserving instanceof.
-        const derived = class extends ctor {
-        };
-        Object.defineProperty(derived, 'name', { value: ctor.name });
-        this.mesh.injectRef(derived.prototype);
-        return derived;
-    }
-}
-exports.ServiceBinding = ServiceBinding;
-class ClassBinding extends Binding {
-    constructor(mesh, key, ctor) {
-        super(mesh, key);
-        this.ctor = ctor;
-    }
-    get() {
-        return this.ctor;
-    }
-}
-exports.ClassBinding = ClassBinding;
-class ProxyBinding extends Binding {
-    constructor(mesh, key, alias) {
-        super(mesh, key);
-        this.alias = alias;
-    }
-    get() {
-        return this.mesh.resolve(this.alias);
-    }
-}
-exports.ProxyBinding = ProxyBinding;

package/out/main/decorators/dep.d.ts

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+import { DepMetadata } from '../types';
+export declare const depMetadata: DepMetadata[];
+export interface DepOptions {
+    key?: string;
+}
+export declare function dep(options?: DepOptions): (target: any, propertyName: string) => void;

package/out/main/decorators/dep.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dep = exports.depMetadata = void 0;
+require("reflect-metadata");
+const errors_1 = require("../errors");
+const mesh_1 = require("../mesh");
+exports.depMetadata = [];
+function dep(options = {}) {
+    return function (target, propertyName) {
+        var _a;
+        const className = target.constructor.name;
+        const designType = Reflect.getMetadata('design:type', target, propertyName);
+        const key = (_a = options.key) !== null && _a !== void 0 ? _a : designType === null || designType === void 0 ? void 0 : designType.name;
+        if (!key) {
+            throw new errors_1.DepKeyNotInferred(className, propertyName);
+        }
+        exports.depMetadata.push({
+            className,
+            propertyName,
+            designTypeName: designType.name,
+            key,
+        });
+        Object.defineProperty(target, propertyName, {
+            get() {
+                const mesh = this[mesh_1.MESH_REF];
+                if (!mesh) {
+                    throw new errors_1.DepInstanceNotConnected(className, propertyName);
+                }
+                return mesh.resolve(key);
+            }
+        });
+    };
+}
+exports.dep = dep;

package/out/main/decorators/service.d.ts

@@ -0,0 +1,7 @@
+import { ServiceMetadata } from '../types';
+export declare const serviceMetadata: ServiceMetadata[];
+export interface SvcOptions {
+    alias?: string;
+    metadata?: any;
+}
+export declare function service(options?: SvcOptions): (target: any) => void;

package/out/main/decorators/service.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.service = exports.serviceMetadata = void 0;
+exports.serviceMetadata = [];
+function service(options = {}) {
+    return function (target) {
+        exports.serviceMetadata.push(Object.assign({ class: target }, options));
+    };
+}
+exports.service = service;

package/out/main/errors.d.ts

@@ -11,7 +11,7 @@ export declare class DepInstanceNotConnected extends BaseError {
     propertyName: string;
     constructor(className: string, propertyName: string);
 }
-export declare class MeshServiceNotFound extends BaseError {
+export declare class MeshBindingNotFound extends BaseError {
     constructor(meshName: string, serviceKey: string);
 }
 export declare class MeshInvalidBinding extends BaseError {

package/out/main/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MeshInvalidBinding = exports.MeshServiceNotFound = exports.DepInstanceNotConnected = exports.DepKeyNotInferred = void 0;
+exports.MeshInvalidBinding = exports.MeshBindingNotFound = exports.DepInstanceNotConnected = exports.DepKeyNotInferred = void 0;
 class BaseError extends Error {
     constructor() {
         super(...arguments);
@@ -26,12 +26,12 @@ class DepInstanceNotConnected extends BaseError {
     }
 }
 exports.DepInstanceNotConnected = DepInstanceNotConnected;
-class MeshServiceNotFound extends BaseError {
+class MeshBindingNotFound extends BaseError {
     constructor(meshName, serviceKey) {
-        super(`Service "${serviceKey}" not found in Mesh "${meshName}"`);
+        super(`"${serviceKey}" not found in Mesh "${meshName}"`);
     }
 }
-exports.MeshServiceNotFound = MeshServiceNotFound;
+exports.MeshBindingNotFound = MeshBindingNotFound;
 class MeshInvalidBinding extends BaseError {
     constructor(key) {
         super(`Invalid binding "${key}". Valid bindings are: ` +

package/out/main/index.d.ts

@@ -1,6 +1,5 @@
-export * from './bindings';
-export * from './decorators';
+export * from './decorators/dep';
 export * from './errors';
 export * from './mesh';
-export * from './metadata';
+export * from './scope';
 export * from './types';

package/out/main/index.js

@@ -10,9 +10,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./bindings"), exports);
-__exportStar(require("./decorators"), exports);
+__exportStar(require("./decorators/dep"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./mesh"), exports);
-__exportStar(require("./metadata"), exports);
+__exportStar(require("./scope"), exports);
 __exportStar(require("./types"), exports);

package/out/main/mesh.d.ts

@@ -1,24 +1,24 @@
-import { ClassBinding } from '.';
-import { Binding } from './bindings';
-import { AbstractClass, Constructor, Middleware, ServiceConstructor, ServiceKey } from './types';
+import { Scope } from './scope';
+import { AbstractClass, Binding, Middleware, ServiceConstructor, ServiceKey } from './types';
 export declare const MESH_REF: unique symbol;
 export declare class Mesh {
     name: string;
     parent: Mesh | undefined;
-    bindings: Map<string, Binding<any>>;
+    currentScope: Scope;
+    childScopes: Map<string, Scope>;
+    instances: Map<string, any>;
     middlewares: Middleware[];
     constructor(name?: string, parent?: Mesh | undefined);
-    bind<T>(impl: ServiceConstructor<T>): Binding<T>;
-    bind<T>(key: AbstractClass<T> | string, impl: ServiceConstructor<T>): Binding<T>;
-    protected _bindService<T>(k: string, impl: ServiceConstructor<T>): Binding<T>;
-    class<T extends Constructor<any>>(ctor: T): ClassBinding<T>;
-    class<T extends Constructor<any>>(key: AbstractClass<T> | string, ctor: T): Binding<T>;
-    protected _bindClass<T extends Constructor<any>>(k: string, ctor: T): ClassBinding<T>;
-    constant<T>(key: ServiceKey<T>, value: T): Binding<T>;
-    alias<T>(key: AbstractClass<T> | string, referenceKey: AbstractClass<T> | string): Binding<T>;
+    service<T>(impl: ServiceConstructor<T>): this;
+    service<T>(key: AbstractClass<T> | string, impl: ServiceConstructor<T>): this;
+    constant<T>(key: ServiceKey<T>, value: T): this;
+    alias<T>(key: AbstractClass<T> | string, referenceKey: AbstractClass<T> | string): this;
     resolve<T>(key: ServiceKey<T>): T;
     connect<T>(value: T): T;
     use(fn: Middleware): this;
+    scope(scopeId: string): Scope;
+    createScope(scopeId: string, scopeName?: string): Mesh;
+    protected instantiate<T>(binding: Binding<T>): T;
     protected applyMiddleware<T>(value: T): T;
-    injectRef(value: any): void;
+    protected injectRef(value: any): void;
 }

package/out/main/mesh.js

@@ -1,71 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mesh = exports.MESH_REF = void 0;
-const _1 = require(".");
-const bindings_1 = require("./bindings");
 const errors_1 = require("./errors");
+const scope_1 = require("./scope");
+const util_1 = require("./util");
 exports.MESH_REF = Symbol.for('MESH_REF');
 class Mesh {
     constructor(name = 'default', parent = undefined) {
         this.name = name;
         this.parent = parent;
-        this.bindings = new Map();
+        this.childScopes = new Map();
+        this.instances = new Map();
         this.middlewares = [];
-        this.constant('Mesh', this);
+        this.currentScope = new scope_1.Scope(name);
+        this.currentScope.constant('Mesh', this);
     }
-    bind(key, impl) {
-        const k = keyToString(key);
-        if (typeof impl === 'function') {
-            return this._bindService(k, impl);
-        }
-        else if (typeof key === 'function') {
-            return this._bindService(k, key);
-        }
-        throw new errors_1.MeshInvalidBinding(String(key));
-    }
-    _bindService(k, impl) {
-        const binding = new bindings_1.ServiceBinding(this, k, impl);
-        this.bindings.set(k, binding);
-        return new bindings_1.ProxyBinding(this, k, k);
-    }
-    class(key, ctor) {
-        const k = keyToString(key);
-        if (typeof ctor === 'function') {
-            return this._bindClass(k, ctor);
-        }
-        else if (typeof key === 'function') {
-            return this._bindClass(k, key);
-        }
-        throw new errors_1.MeshInvalidBinding(String(key));
-    }
-    _bindClass(k, ctor) {
-        const binding = new _1.ClassBinding(this, k, ctor);
-        this.bindings.set(k, binding);
-        return binding;
+    service(key, impl) {
+        this.currentScope.service(key, impl);
+        return this;
     }
     constant(key, value) {
-        const k = keyToString(key);
-        const binding = new bindings_1.ConstantBinding(this, k, value);
-        this.bindings.set(k, binding);
-        return new bindings_1.ProxyBinding(this, k, k);
+        this.currentScope.constant(key, value);
+        return this;
     }
     alias(key, referenceKey) {
-        const k = keyToString(key);
-        const refK = typeof referenceKey === 'string' ? referenceKey : referenceKey.name;
-        const binding = new bindings_1.ProxyBinding(this, k, refK);
-        this.bindings.set(k, binding);
-        return binding;
+        this.currentScope.alias(key, referenceKey);
+        return this;
     }
     resolve(key) {
-        const k = keyToString(key);
-        const binding = this.bindings.get(k);
+        const k = util_1.keyToString(key);
+        let instance = this.instances.get(k);
+        if (instance) {
+            return instance;
+        }
+        const binding = this.currentScope.bindings.get(k);
         if (binding) {
-            return binding.get();
+            instance = this.instantiate(binding);
+            instance = this.connect(instance);
+            this.instances.set(k, instance);
+            return instance;
         }
         if (this.parent) {
             return this.parent.resolve(key);
         }
-        throw new errors_1.MeshServiceNotFound(this.name, k);
+        throw new errors_1.MeshBindingNotFound(this.name, k);
     }
     connect(value) {
         const res = this.applyMiddleware(value);
@@ -76,11 +54,47 @@ class Mesh {
         this.middlewares.push(fn);
         return this;
     }
+    scope(scopeId) {
+        let scope = this.childScopes.get(scopeId);
+        if (!scope) {
+            scope = new scope_1.Scope(scopeId);
+            this.childScopes.set(scopeId, scope);
+        }
+        return scope;
+    }
+    createScope(scopeId, scopeName = scopeId) {
+        const childScope = this.childScopes.get(scopeId);
+        const newScope = new scope_1.Scope(scopeName, childScope !== null && childScope !== void 0 ? childScope : []);
+        const mesh = new Mesh(scopeId, this);
+        mesh.currentScope = newScope;
+        return mesh;
+    }
+    instantiate(binding) {
+        switch (binding.type) {
+            case 'alias':
+                return this.resolve(binding.key);
+            case 'service': {
+                // A fake derived class is created with Mesh attached to its prototype.
+                // This allows accessing deps in constructor whilst preserving instanceof.
+                const ctor = binding.class;
+                const derived = class extends ctor {
+                };
+                Object.defineProperty(derived, 'name', { value: ctor.name });
+                this.injectRef(derived.prototype);
+                return new derived();
+            }
+            case 'constant':
+                return binding.value;
+        }
+    }
     applyMiddleware(value) {
         let res = value;
         for (const middleware of this.middlewares) {
             res = middleware(res);
         }
+        if (this.parent) {
+            res = this.parent.applyMiddleware(res);
+        }
         return res;
     }
     injectRef(value) {
@@ -95,6 +109,3 @@ class Mesh {
     }
 }
 exports.Mesh = Mesh;
-function keyToString(key) {
-    return typeof key === 'string' ? key : key.name;
-}

package/out/main/scope.d.ts

@@ -0,0 +1,11 @@
+import { AbstractClass, Binding, ServiceConstructor, ServiceKey } from './types';
+export declare class Scope {
+    readonly name: string;
+    bindings: Map<string, Binding<any>>;
+    constructor(name: string, bindings?: Iterable<[string, Binding<any>]>);
+    [Symbol.iterator](): Generator<[string, Binding<any>], void, undefined>;
+    service<T>(impl: ServiceConstructor<T>): this;
+    service<T>(key: AbstractClass<T> | string, impl: ServiceConstructor<T>): this;
+    constant<T>(key: ServiceKey<T>, value: T): this;
+    alias<T>(key: AbstractClass<T> | string, referenceKey: AbstractClass<T> | string): this;
+}

package/out/main/scope.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+const errors_1 = require("./errors");
+const util_1 = require("./util");
+class Scope {
+    constructor(name, bindings = []) {
+        this.name = name;
+        this.bindings = new Map();
+        for (const [k, v] of bindings) {
+            this.bindings.set(k, v);
+        }
+    }
+    *[Symbol.iterator]() {
+        yield* this.bindings.entries();
+    }
+    service(key, impl) {
+        const k = util_1.keyToString(key);
+        if (typeof impl === 'function') {
+            this.bindings.set(k, { type: 'service', class: impl });
+            return this;
+        }
+        else if (typeof key === 'function') {
+            this.bindings.set(k, { type: 'service', class: key });
+            return this;
+        }
+        throw new errors_1.MeshInvalidBinding(String(key));
+    }
+    constant(key, value) {
+        const k = util_1.keyToString(key);
+        this.bindings.set(k, { type: 'constant', value });
+        return this;
+    }
+    alias(key, referenceKey) {
+        const k = util_1.keyToString(key);
+        const refK = util_1.keyToString(referenceKey);
+        this.bindings.set(k, { type: 'alias', key: refK });
+        return this;
+    }
+}
+exports.Scope = Scope;

package/out/main/types.d.ts

@@ -10,3 +10,27 @@ export declare type AbstractClass<T> = {
 };
 export declare type ServiceKey<T> = ServiceConstructor<T> | AbstractClass<T> | string;
 export declare type Middleware = (instance: any) => any;
+export declare type Binding<T> = ConstantBinding<T> | ServiceBinding<T> | AliasBinding;
+export declare type ConstantBinding<T> = {
+    type: 'constant';
+    value: T;
+};
+export declare type ServiceBinding<T> = {
+    type: 'service';
+    class: ServiceConstructor<T>;
+};
+export declare type AliasBinding = {
+    type: 'alias';
+    key: string;
+};
+export interface DepMetadata {
+    className: string;
+    propertyName: string;
+    designTypeName: string;
+    key: string;
+}
+export interface ServiceMetadata {
+    class: ServiceConstructor<any>;
+    alias?: string;
+    metadata?: any;
+}

package/out/main/util.d.ts

@@ -0,0 +1,2 @@
+import { ServiceKey } from './types';
+export declare function keyToString<T>(key: ServiceKey<T>): string;

package/out/main/util.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyToString = void 0;
+function keyToString(key) {
+    return typeof key === 'string' ? key : key.name;
+}
+exports.keyToString = keyToString;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mesh-ioc",
-    "version": "0.3.0",
+    "version": "1.2.0",
     "description": "Mesh: Powerful and Lightweight IoC Library",
     "main": "out/main/index.js",
     "types": "out/main/index.d.ts",