proxydi 0.0.3 → 0.0.4

package/dist/Proxy.utils.d.ts

@@ -0,0 +1,3 @@
+import { ServiceId } from './types';
+export declare const makeProxy: <T>(serviceId: ServiceId, instance: any) => T;
+export declare function isProxy(value: any): boolean;

package/dist/ProxyDI.d.ts

@@ -1,32 +1,27 @@
+import { ProxyDI as IProxyDI, ProxydiedInstance } from './types';
 import { ProxyDISettings, ServiceClass, ServiceId } from './types';
-export declare const PROXYDI: unique symbol;
-export declare const PROXYDI_ID: unique symbol;
-export declare class ProxyDI {
+export declare class ProxyDI implements IProxyDI {
     private static idCounter;
     readonly id: number;
     readonly parent?: ProxyDI;
     private children;
-    private instances;
-    private classes;
-    private proxies;
-    private proxyFactory;
-    protected allowRewriteClasses: boolean;
-    protected allowRewriteInstances: boolean;
-    constructor(settings?: ProxyDISettings);
+    private serviceInstances;
+    private serviceClasses;
+    private settings;
+    constructor(settings?: ProxyDISettings, parent?: ProxyDI);
     registerInstance<T>(serviceId: ServiceId, instance: T extends {
         new (...args: any[]): any;
     } ? never : T): void;
     registerClass<T>(serviceId: ServiceId, serviceClass: ServiceClass<T>): void;
-    private findInstance;
     isKnown(serviceId: ServiceId): boolean;
     resolve<T>(serviceId: ServiceId): T;
-    private findDefiner;
     injectDependencies(instance: any): void;
-    private getProxy;
-    createChildContainer(settings?: ProxyDISettings): ProxyDI;
-    removeInstance(serviceId: ServiceId): void;
+    createChildContainer(): ProxyDI;
+    removeInstance(serviceId: ServiceId | ProxydiedInstance): void;
     removeClass(serviceId: ServiceId): void;
     destroy(): void;
-    addChild(child: ProxyDI): void;
+    private findInstance;
+    private findServiceClass;
+    private addChild;
     private removeChild;
 }

package/dist/index.cjs

@@ -1,122 +1,119 @@
 'use strict';
 
 const INJECTS = Symbol('injects');
-const inject = (serviceId) => {
-    return function (_value, context) {
-        if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
+const PROXYDI = Symbol('ProxyDI');
+const SERVICE_ID = Symbol('ServiceId');
+const IS_PROXY = Symbol('isProxy');
+const INSTANCE = Symbol('instance');
+
+const injectableClasses = {};
+const injectable = (serviceId) => {
+    return function (value, context) {
+        if ((context === null || context === undefined ? undefined : context.kind) === 'class') {
             const name = serviceId ? serviceId : context.name;
-            const inject = {
-                property: context.name,
-                serviceId: name,
-                set: context.access.set,
-            };
-            context.addInitializer(function () {
-                if (!this[INJECTS]) {
-                    this[INJECTS] = [];
-                }
-                this[INJECTS].push(inject);
-            });
+            if (injectableClasses[name]) {
+                throw new Error(`ProxyDI injectable classes already has service ID: ${name}`);
+            }
+            injectableClasses[name] = value;
+        }
+        else {
+            throw new Error('@injectable decorator should decorate classes');
         }
     };
 };
 
-const injectableClasses = {};
+const DEFAULT_SETTINGS = {
+    allowRegisterAnythingAsInstance: false,
+    allowRewriteClasses: false,
+    allowRewriteInstances: false,
+};
 
-const IS_PROXY = Symbol('isProxy');
-class ProxyFactory {
-    constructor(container) {
-        this.container = container;
-    }
-    makeProxy(serviceId) {
-        const self = this;
-        const proxy = new Proxy({ [IS_PROXY]: true }, {
-            get: function (target, prop, receiver) {
-                if (target[prop]) {
-                    return target[prop];
-                }
-                if (self.container.isKnown(serviceId)) {
-                    const instance = self.container.resolve(serviceId);
-                    return Reflect.get(instance, prop, receiver);
-                }
-                else {
-                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
-                }
-            },
-            set: function (target, prop, value) {
-                if (self.container.isKnown(serviceId)) {
-                    const instance = self.container.resolve(serviceId);
-                    return Reflect.set(instance, prop, value);
-                }
-                else {
-                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
-                }
-            },
-            has: function (target, prop) {
-                if (self.container.isKnown(serviceId)) {
-                    const instance = self.container.resolve(serviceId);
-                    return Reflect.has(instance, prop);
-                }
-                else {
-                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
-                }
-            },
-        });
-        return proxy;
+var _a;
+class InstanceProxy {
+    constructor(instance) {
+        this[_a] = true;
+        this[INSTANCE] = instance;
     }
 }
+_a = IS_PROXY;
+const makeProxy = (serviceId, instance) => {
+    return new Proxy(new InstanceProxy(instance), {
+        get: function (target, prop, receiver) {
+            if (target[prop]) {
+                return target[prop];
+            }
+            const container = target[INSTANCE][PROXYDI];
+            if (container.isKnown(serviceId)) {
+                const instance = container.resolve(serviceId);
+                return Reflect.get(instance, prop, receiver);
+            }
+            else {
+                throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+            }
+        },
+        set: function (target, prop, value) {
+            const container = target[INSTANCE][PROXYDI];
+            if (container.isKnown(serviceId)) {
+                const instance = container.resolve(serviceId);
+                return Reflect.set(instance, prop, value);
+            }
+            else {
+                throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+            }
+        },
+        has: function (target, prop) {
+            const container = target[INSTANCE][PROXYDI];
+            if (container.isKnown(serviceId)) {
+                const instance = container.resolve(serviceId);
+                return Reflect.has(instance, prop);
+            }
+            else {
+                throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+            }
+        },
+    });
+};
 
-const PROXYDI = Symbol('ProxyDI');
-const PROXYDI_ID = Symbol('ProxyDI_ID');
 class ProxyDI {
-    constructor(settings) {
+    constructor(settings, parent) {
         this.children = {};
-        this.instances = {};
-        this.classes = {};
-        this.proxies = {};
-        this.allowRewriteClasses = false;
-        this.allowRewriteInstances = false;
-        this.proxyFactory = new ProxyFactory(this);
+        this.serviceInstances = {};
+        this.serviceClasses = {};
         this.id = ProxyDI.idCounter++;
-        if (settings === null || settings === undefined ? undefined : settings.parent) {
-            this.parent = settings.parent;
+        if (parent) {
+            this.parent = parent;
             this.parent.addChild(this);
         }
-        if ((settings === null || settings === undefined ? undefined : settings.allowRewriteClasses) !== undefined) {
-            this.allowRewriteClasses = settings.allowRewriteClasses;
-        }
-        if ((settings === null || settings === undefined ? undefined : settings.allowRewriteInstances) !== undefined) {
-            this.allowRewriteInstances = settings.allowRewriteInstances;
-        }
+        this.settings = Object.assign(Object.assign({}, DEFAULT_SETTINGS), settings);
     }
     registerInstance(serviceId, instance) {
-        if (this.instances[serviceId]) {
-            if (!this.allowRewriteInstances) {
+        if (this.serviceInstances[serviceId]) {
+            if (!this.settings.allowRewriteInstances) {
                 throw new Error(`ProxyDI already has registered instance for ${serviceId}`);
             }
         }
+        const isObject = typeof instance === 'object';
+        if (!isObject && !this.settings.allowRegisterAnythingAsInstance) {
+            throw new Error(`Can't register as instance (allowRegisterAnythingAsInstance is off for this ProxyDI contatiner): ${instance}`);
+        }
         this.injectDependencies(instance);
-        if (typeof instance === 'object') {
-            instance[PROXYDI_ID] = serviceId;
+        if (isObject) {
+            instance[SERVICE_ID] = serviceId;
         }
-        this.instances[serviceId] = instance;
+        this.serviceInstances[serviceId] = instance;
     }
     registerClass(serviceId, serviceClass) {
-        if (this.classes[serviceId]) {
-            if (!this.allowRewriteClasses) {
+        if (this.serviceClasses[serviceId]) {
+            if (!this.settings.allowRewriteClasses) {
                 throw new Error(`ProxyDI already has registered class for ${serviceId}`);
             }
         }
-        this.classes[serviceId] = serviceClass;
-    }
-    findInstance(serviceId) {
-        const instance = this.instances[serviceId];
-        if (!instance && this.parent) {
-            return this.parent.findInstance(serviceId);
-        }
-        return instance;
+        this.serviceClasses[serviceId] = serviceClass;
     }
     isKnown(serviceId) {
-        return !!(this.findInstance(serviceId) || this.findDefiner(serviceId));
+        return !!(this.findInstance(serviceId) ||
+            this.findServiceClass(serviceId) ||
+            injectableClasses[serviceId]);
     }
     resolve(serviceId) {
         if (!this.isKnown(serviceId)) {
@@ -126,34 +123,21 @@ class ProxyDI {
         if (instance) {
             return instance;
         }
-        const definer = this.findDefiner(serviceId);
-        if (definer) {
-            let instance = new definer();
-            this.injectDependencies(instance);
-            instance[PROXYDI_ID] = serviceId;
-            this.instances[serviceId] = instance;
-            return instance;
-        }
         else {
-            return this.getProxy(serviceId);
-        }
-    }
-    findDefiner(serviceId) {
-        let definer = this.classes[serviceId];
-        if (!definer && this.parent) {
-            return this.parent.findDefiner(serviceId);
-        }
-        if (!definer) {
-            return injectableClasses[serviceId];
+            const ServiceClass = this.findServiceClass(serviceId);
+            const newInstance = new ServiceClass();
+            this.registerInstance(serviceId, newInstance);
+            return newInstance;
         }
-        return definer;
     }
     injectDependencies(instance) {
         const serviceInjects = instance[INJECTS] || [];
         serviceInjects.forEach((inject) => {
+            // TODO: Return only proxies
+            //const value = makeProxy(inject.serviceId, instance);
             let value = this.findInstance(inject.serviceId);
             if (!value) {
-                value = this.getProxy(inject.serviceId);
+                value = makeProxy(inject.serviceId, instance);
             }
             inject.set(instance, value);
         });
@@ -161,56 +145,62 @@ class ProxyDI {
             instance[PROXYDI] = this;
         }
     }
-    getProxy(serviceId) {
-        let proxy = this.proxies[serviceId];
-        if (!proxy) {
-            proxy = this.proxyFactory.makeProxy(serviceId);
-            this.proxies[serviceId] = proxy;
-        }
-        return proxy;
-    }
-    createChildContainer(settings) {
-        const childSettings = Object.assign(Object.assign({}, settings), { parent: this });
-        return new ProxyDI(childSettings);
+    createChildContainer() {
+        return new ProxyDI(this.settings, this);
     }
     removeInstance(serviceId) {
-        const id = serviceId[PROXYDI_ID]
-            ? serviceId[PROXYDI_ID]
-            : serviceId;
-        const instance = this.instances[id];
+        const id = isInstance(serviceId) ? serviceId[SERVICE_ID] : serviceId;
+        const instance = this.serviceInstances[id];
         if (instance) {
             const serviceInjects = instance[INJECTS] || [];
             serviceInjects.forEach((inject) => {
                 inject.set(instance, undefined);
             });
             delete instance[PROXYDI];
-            delete instance[PROXYDI_ID];
-            delete this.instances[serviceId];
+            delete instance[SERVICE_ID];
+            delete this.serviceInstances[id];
         }
     }
     removeClass(serviceId) {
-        delete this.classes[serviceId];
+        delete this.serviceClasses[serviceId];
     }
     destroy() {
-        const allServices = Object.keys(this.instances);
+        const allServices = Object.keys(this.serviceInstances);
         for (const serviceId of allServices) {
-            const instance = this.instances[serviceId];
+            const instance = this.serviceInstances[serviceId];
             this.removeInstance(instance);
         }
-        this.instances = {};
-        this.proxies = {};
-        this.classes = {};
+        this.serviceInstances = {};
+        this.serviceClasses = {};
         for (const id of Object.keys(this.children)) {
             const child = this.children[+id];
             child.destroy();
         }
         this.children = {};
-        this.proxyFactory = undefined;
         if (this.parent) {
             this.parent.removeChild(this.id);
             this.parent = undefined;
         }
     }
+    findInstance(serviceId) {
+        const instance = this.serviceInstances[serviceId];
+        if (!instance && this.parent) {
+            const parentInstance = this.parent.findInstance(serviceId);
+            // TODO: Make copy, inject container dependencies?
+            return parentInstance;
+        }
+        return instance;
+    }
+    findServiceClass(serviceId) {
+        let ServiceClass = this.serviceClasses[serviceId];
+        if (!ServiceClass && !!this.parent) {
+            return this.parent.findServiceClass(serviceId);
+        }
+        if (!ServiceClass) {
+            return injectableClasses[serviceId];
+        }
+        return ServiceClass;
+    }
     addChild(child) {
         if (this.children[child.id]) {
             throw new Error(`ProxyDI already has child with id ${child.id}`);
@@ -225,6 +215,33 @@ class ProxyDI {
     }
 }
 ProxyDI.idCounter = 0;
+function isInstance(service) {
+    return (typeof service === 'object' &&
+        !!service[SERVICE_ID]);
+}
+
+const inject = (serviceId) => {
+    return function (_value, context) {
+        if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
+            const name = serviceId ? serviceId : context.name;
+            const inject = {
+                property: context.name,
+                serviceId: name,
+                set: context.access.set,
+            };
+            context.addInitializer(function () {
+                if (!this[INJECTS]) {
+                    this[INJECTS] = [];
+                }
+                this[INJECTS].push(inject);
+            });
+        }
+        else {
+            throw new Error('@inject decorator should decorate fields');
+        }
+    };
+};
 
 exports.ProxyDI = ProxyDI;
 exports.inject = inject;
+exports.injectable = injectable;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { ProxyDI } from './ProxyDI';
 export { inject } from './inject';
+export { injectable } from './injectable';
 export { Inject, ServiceId, ServiceClass, ProxyDISettings } from './types';

package/dist/index.js

@@ -1,120 +1,117 @@
 const INJECTS = Symbol('injects');
-const inject = (serviceId) => {
-    return function (_value, context) {
-        if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
+const PROXYDI = Symbol('ProxyDI');
+const SERVICE_ID = Symbol('ServiceId');
+const IS_PROXY = Symbol('isProxy');
+const INSTANCE = Symbol('instance');
+
+const injectableClasses = {};
+const injectable = (serviceId) => {
+    return function (value, context) {
+        if ((context === null || context === undefined ? undefined : context.kind) === 'class') {
             const name = serviceId ? serviceId : context.name;
-            const inject = {
-                property: context.name,
-                serviceId: name,
-                set: context.access.set,
-            };
-            context.addInitializer(function () {
-                if (!this[INJECTS]) {
-                    this[INJECTS] = [];
-                }
-                this[INJECTS].push(inject);
-            });
+            if (injectableClasses[name]) {
+                throw new Error(`ProxyDI injectable classes already has service ID: ${name}`);
+            }
+            injectableClasses[name] = value;
+        }
+        else {
+            throw new Error('@injectable decorator should decorate classes');
         }
     };
 };
 
-const injectableClasses = {};
+const DEFAULT_SETTINGS = {
+    allowRegisterAnythingAsInstance: false,
+    allowRewriteClasses: false,
+    allowRewriteInstances: false,
+};
 
-const IS_PROXY = Symbol('isProxy');
-class ProxyFactory {
-    constructor(container) {
-        this.container = container;
-    }
-    makeProxy(serviceId) {
-        const self = this;
-        const proxy = new Proxy({ [IS_PROXY]: true }, {
-            get: function (target, prop, receiver) {
-                if (target[prop]) {
-                    return target[prop];
-                }
-                if (self.container.isKnown(serviceId)) {
-                    const instance = self.container.resolve(serviceId);
-                    return Reflect.get(instance, prop, receiver);
-                }
-                else {
-                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
-                }
-            },
-            set: function (target, prop, value) {
-                if (self.container.isKnown(serviceId)) {
-                    const instance = self.container.resolve(serviceId);
-                    return Reflect.set(instance, prop, value);
-                }
-                else {
-                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
-                }
-            },
-            has: function (target, prop) {
-                if (self.container.isKnown(serviceId)) {
-                    const instance = self.container.resolve(serviceId);
-                    return Reflect.has(instance, prop);
-                }
-                else {
-                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
-                }
-            },
-        });
-        return proxy;
+var _a;
+class InstanceProxy {
+    constructor(instance) {
+        this[_a] = true;
+        this[INSTANCE] = instance;
     }
 }
+_a = IS_PROXY;
+const makeProxy = (serviceId, instance) => {
+    return new Proxy(new InstanceProxy(instance), {
+        get: function (target, prop, receiver) {
+            if (target[prop]) {
+                return target[prop];
+            }
+            const container = target[INSTANCE][PROXYDI];
+            if (container.isKnown(serviceId)) {
+                const instance = container.resolve(serviceId);
+                return Reflect.get(instance, prop, receiver);
+            }
+            else {
+                throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+            }
+        },
+        set: function (target, prop, value) {
+            const container = target[INSTANCE][PROXYDI];
+            if (container.isKnown(serviceId)) {
+                const instance = container.resolve(serviceId);
+                return Reflect.set(instance, prop, value);
+            }
+            else {
+                throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+            }
+        },
+        has: function (target, prop) {
+            const container = target[INSTANCE][PROXYDI];
+            if (container.isKnown(serviceId)) {
+                const instance = container.resolve(serviceId);
+                return Reflect.has(instance, prop);
+            }
+            else {
+                throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+            }
+        },
+    });
+};
 
-const PROXYDI = Symbol('ProxyDI');
-const PROXYDI_ID = Symbol('ProxyDI_ID');
 class ProxyDI {
-    constructor(settings) {
+    constructor(settings, parent) {
         this.children = {};
-        this.instances = {};
-        this.classes = {};
-        this.proxies = {};
-        this.allowRewriteClasses = false;
-        this.allowRewriteInstances = false;
-        this.proxyFactory = new ProxyFactory(this);
+        this.serviceInstances = {};
+        this.serviceClasses = {};
         this.id = ProxyDI.idCounter++;
-        if (settings === null || settings === undefined ? undefined : settings.parent) {
-            this.parent = settings.parent;
+        if (parent) {
+            this.parent = parent;
             this.parent.addChild(this);
         }
-        if ((settings === null || settings === undefined ? undefined : settings.allowRewriteClasses) !== undefined) {
-            this.allowRewriteClasses = settings.allowRewriteClasses;
-        }
-        if ((settings === null || settings === undefined ? undefined : settings.allowRewriteInstances) !== undefined) {
-            this.allowRewriteInstances = settings.allowRewriteInstances;
-        }
+        this.settings = Object.assign(Object.assign({}, DEFAULT_SETTINGS), settings);
     }
     registerInstance(serviceId, instance) {
-        if (this.instances[serviceId]) {
-            if (!this.allowRewriteInstances) {
+        if (this.serviceInstances[serviceId]) {
+            if (!this.settings.allowRewriteInstances) {
                 throw new Error(`ProxyDI already has registered instance for ${serviceId}`);
             }
         }
+        const isObject = typeof instance === 'object';
+        if (!isObject && !this.settings.allowRegisterAnythingAsInstance) {
+            throw new Error(`Can't register as instance (allowRegisterAnythingAsInstance is off for this ProxyDI contatiner): ${instance}`);
+        }
         this.injectDependencies(instance);
-        if (typeof instance === 'object') {
-            instance[PROXYDI_ID] = serviceId;
+        if (isObject) {
+            instance[SERVICE_ID] = serviceId;
         }
-        this.instances[serviceId] = instance;
+        this.serviceInstances[serviceId] = instance;
     }
     registerClass(serviceId, serviceClass) {
-        if (this.classes[serviceId]) {
-            if (!this.allowRewriteClasses) {
+        if (this.serviceClasses[serviceId]) {
+            if (!this.settings.allowRewriteClasses) {
                 throw new Error(`ProxyDI already has registered class for ${serviceId}`);
             }
         }
-        this.classes[serviceId] = serviceClass;
-    }
-    findInstance(serviceId) {
-        const instance = this.instances[serviceId];
-        if (!instance && this.parent) {
-            return this.parent.findInstance(serviceId);
-        }
-        return instance;
+        this.serviceClasses[serviceId] = serviceClass;
     }
     isKnown(serviceId) {
-        return !!(this.findInstance(serviceId) || this.findDefiner(serviceId));
+        return !!(this.findInstance(serviceId) ||
+            this.findServiceClass(serviceId) ||
+            injectableClasses[serviceId]);
     }
     resolve(serviceId) {
         if (!this.isKnown(serviceId)) {
@@ -124,34 +121,21 @@ class ProxyDI {
         if (instance) {
             return instance;
         }
-        const definer = this.findDefiner(serviceId);
-        if (definer) {
-            let instance = new definer();
-            this.injectDependencies(instance);
-            instance[PROXYDI_ID] = serviceId;
-            this.instances[serviceId] = instance;
-            return instance;
-        }
         else {
-            return this.getProxy(serviceId);
-        }
-    }
-    findDefiner(serviceId) {
-        let definer = this.classes[serviceId];
-        if (!definer && this.parent) {
-            return this.parent.findDefiner(serviceId);
-        }
-        if (!definer) {
-            return injectableClasses[serviceId];
+            const ServiceClass = this.findServiceClass(serviceId);
+            const newInstance = new ServiceClass();
+            this.registerInstance(serviceId, newInstance);
+            return newInstance;
         }
-        return definer;
     }
     injectDependencies(instance) {
         const serviceInjects = instance[INJECTS] || [];
         serviceInjects.forEach((inject) => {
+            // TODO: Return only proxies
+            //const value = makeProxy(inject.serviceId, instance);
             let value = this.findInstance(inject.serviceId);
             if (!value) {
-                value = this.getProxy(inject.serviceId);
+                value = makeProxy(inject.serviceId, instance);
             }
             inject.set(instance, value);
         });
@@ -159,56 +143,62 @@ class ProxyDI {
             instance[PROXYDI] = this;
         }
     }
-    getProxy(serviceId) {
-        let proxy = this.proxies[serviceId];
-        if (!proxy) {
-            proxy = this.proxyFactory.makeProxy(serviceId);
-            this.proxies[serviceId] = proxy;
-        }
-        return proxy;
-    }
-    createChildContainer(settings) {
-        const childSettings = Object.assign(Object.assign({}, settings), { parent: this });
-        return new ProxyDI(childSettings);
+    createChildContainer() {
+        return new ProxyDI(this.settings, this);
     }
     removeInstance(serviceId) {
-        const id = serviceId[PROXYDI_ID]
-            ? serviceId[PROXYDI_ID]
-            : serviceId;
-        const instance = this.instances[id];
+        const id = isInstance(serviceId) ? serviceId[SERVICE_ID] : serviceId;
+        const instance = this.serviceInstances[id];
         if (instance) {
             const serviceInjects = instance[INJECTS] || [];
             serviceInjects.forEach((inject) => {
                 inject.set(instance, undefined);
             });
             delete instance[PROXYDI];
-            delete instance[PROXYDI_ID];
-            delete this.instances[serviceId];
+            delete instance[SERVICE_ID];
+            delete this.serviceInstances[id];
         }
     }
     removeClass(serviceId) {
-        delete this.classes[serviceId];
+        delete this.serviceClasses[serviceId];
     }
     destroy() {
-        const allServices = Object.keys(this.instances);
+        const allServices = Object.keys(this.serviceInstances);
         for (const serviceId of allServices) {
-            const instance = this.instances[serviceId];
+            const instance = this.serviceInstances[serviceId];
             this.removeInstance(instance);
         }
-        this.instances = {};
-        this.proxies = {};
-        this.classes = {};
+        this.serviceInstances = {};
+        this.serviceClasses = {};
         for (const id of Object.keys(this.children)) {
             const child = this.children[+id];
             child.destroy();
         }
         this.children = {};
-        this.proxyFactory = undefined;
         if (this.parent) {
             this.parent.removeChild(this.id);
             this.parent = undefined;
         }
     }
+    findInstance(serviceId) {
+        const instance = this.serviceInstances[serviceId];
+        if (!instance && this.parent) {
+            const parentInstance = this.parent.findInstance(serviceId);
+            // TODO: Make copy, inject container dependencies?
+            return parentInstance;
+        }
+        return instance;
+    }
+    findServiceClass(serviceId) {
+        let ServiceClass = this.serviceClasses[serviceId];
+        if (!ServiceClass && !!this.parent) {
+            return this.parent.findServiceClass(serviceId);
+        }
+        if (!ServiceClass) {
+            return injectableClasses[serviceId];
+        }
+        return ServiceClass;
+    }
     addChild(child) {
         if (this.children[child.id]) {
             throw new Error(`ProxyDI already has child with id ${child.id}`);
@@ -223,5 +213,31 @@ class ProxyDI {
     }
 }
 ProxyDI.idCounter = 0;
+function isInstance(service) {
+    return (typeof service === 'object' &&
+        !!service[SERVICE_ID]);
+}
+
+const inject = (serviceId) => {
+    return function (_value, context) {
+        if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
+            const name = serviceId ? serviceId : context.name;
+            const inject = {
+                property: context.name,
+                serviceId: name,
+                set: context.access.set,
+            };
+            context.addInitializer(function () {
+                if (!this[INJECTS]) {
+                    this[INJECTS] = [];
+                }
+                this[INJECTS].push(inject);
+            });
+        }
+        else {
+            throw new Error('@inject decorator should decorate fields');
+        }
+    };
+};
 
-export { ProxyDI, inject };
+export { ProxyDI, inject, injectable };

package/dist/index.umd.js

@@ -5,122 +5,119 @@
 })(this, (function (exports) { 'use strict';
 
     const INJECTS = Symbol('injects');
-    const inject = (serviceId) => {
-        return function (_value, context) {
-            if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
+    const PROXYDI = Symbol('ProxyDI');
+    const SERVICE_ID = Symbol('ServiceId');
+    const IS_PROXY = Symbol('isProxy');
+    const INSTANCE = Symbol('instance');
+
+    const injectableClasses = {};
+    const injectable = (serviceId) => {
+        return function (value, context) {
+            if ((context === null || context === undefined ? undefined : context.kind) === 'class') {
                 const name = serviceId ? serviceId : context.name;
-                const inject = {
-                    property: context.name,
-                    serviceId: name,
-                    set: context.access.set,
-                };
-                context.addInitializer(function () {
-                    if (!this[INJECTS]) {
-                        this[INJECTS] = [];
-                    }
-                    this[INJECTS].push(inject);
-                });
+                if (injectableClasses[name]) {
+                    throw new Error(`ProxyDI injectable classes already has service ID: ${name}`);
+                }
+                injectableClasses[name] = value;
+            }
+            else {
+                throw new Error('@injectable decorator should decorate classes');
             }
         };
     };
 
-    const injectableClasses = {};
+    const DEFAULT_SETTINGS = {
+        allowRegisterAnythingAsInstance: false,
+        allowRewriteClasses: false,
+        allowRewriteInstances: false,
+    };
 
-    const IS_PROXY = Symbol('isProxy');
-    class ProxyFactory {
-        constructor(container) {
-            this.container = container;
-        }
-        makeProxy(serviceId) {
-            const self = this;
-            const proxy = new Proxy({ [IS_PROXY]: true }, {
-                get: function (target, prop, receiver) {
-                    if (target[prop]) {
-                        return target[prop];
-                    }
-                    if (self.container.isKnown(serviceId)) {
-                        const instance = self.container.resolve(serviceId);
-                        return Reflect.get(instance, prop, receiver);
-                    }
-                    else {
-                        throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
-                    }
-                },
-                set: function (target, prop, value) {
-                    if (self.container.isKnown(serviceId)) {
-                        const instance = self.container.resolve(serviceId);
-                        return Reflect.set(instance, prop, value);
-                    }
-                    else {
-                        throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
-                    }
-                },
-                has: function (target, prop) {
-                    if (self.container.isKnown(serviceId)) {
-                        const instance = self.container.resolve(serviceId);
-                        return Reflect.has(instance, prop);
-                    }
-                    else {
-                        throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
-                    }
-                },
-            });
-            return proxy;
+    var _a;
+    class InstanceProxy {
+        constructor(instance) {
+            this[_a] = true;
+            this[INSTANCE] = instance;
         }
     }
+    _a = IS_PROXY;
+    const makeProxy = (serviceId, instance) => {
+        return new Proxy(new InstanceProxy(instance), {
+            get: function (target, prop, receiver) {
+                if (target[prop]) {
+                    return target[prop];
+                }
+                const container = target[INSTANCE][PROXYDI];
+                if (container.isKnown(serviceId)) {
+                    const instance = container.resolve(serviceId);
+                    return Reflect.get(instance, prop, receiver);
+                }
+                else {
+                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                }
+            },
+            set: function (target, prop, value) {
+                const container = target[INSTANCE][PROXYDI];
+                if (container.isKnown(serviceId)) {
+                    const instance = container.resolve(serviceId);
+                    return Reflect.set(instance, prop, value);
+                }
+                else {
+                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                }
+            },
+            has: function (target, prop) {
+                const container = target[INSTANCE][PROXYDI];
+                if (container.isKnown(serviceId)) {
+                    const instance = container.resolve(serviceId);
+                    return Reflect.has(instance, prop);
+                }
+                else {
+                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                }
+            },
+        });
+    };
 
-    const PROXYDI = Symbol('ProxyDI');
-    const PROXYDI_ID = Symbol('ProxyDI_ID');
     class ProxyDI {
-        constructor(settings) {
+        constructor(settings, parent) {
             this.children = {};
-            this.instances = {};
-            this.classes = {};
-            this.proxies = {};
-            this.allowRewriteClasses = false;
-            this.allowRewriteInstances = false;
-            this.proxyFactory = new ProxyFactory(this);
+            this.serviceInstances = {};
+            this.serviceClasses = {};
             this.id = ProxyDI.idCounter++;
-            if (settings === null || settings === undefined ? undefined : settings.parent) {
-                this.parent = settings.parent;
+            if (parent) {
+                this.parent = parent;
                 this.parent.addChild(this);
             }
-            if ((settings === null || settings === undefined ? undefined : settings.allowRewriteClasses) !== undefined) {
-                this.allowRewriteClasses = settings.allowRewriteClasses;
-            }
-            if ((settings === null || settings === undefined ? undefined : settings.allowRewriteInstances) !== undefined) {
-                this.allowRewriteInstances = settings.allowRewriteInstances;
-            }
+            this.settings = Object.assign(Object.assign({}, DEFAULT_SETTINGS), settings);
         }
         registerInstance(serviceId, instance) {
-            if (this.instances[serviceId]) {
-                if (!this.allowRewriteInstances) {
+            if (this.serviceInstances[serviceId]) {
+                if (!this.settings.allowRewriteInstances) {
                     throw new Error(`ProxyDI already has registered instance for ${serviceId}`);
                 }
             }
+            const isObject = typeof instance === 'object';
+            if (!isObject && !this.settings.allowRegisterAnythingAsInstance) {
+                throw new Error(`Can't register as instance (allowRegisterAnythingAsInstance is off for this ProxyDI contatiner): ${instance}`);
+            }
             this.injectDependencies(instance);
-            if (typeof instance === 'object') {
-                instance[PROXYDI_ID] = serviceId;
+            if (isObject) {
+                instance[SERVICE_ID] = serviceId;
             }
-            this.instances[serviceId] = instance;
+            this.serviceInstances[serviceId] = instance;
         }
         registerClass(serviceId, serviceClass) {
-            if (this.classes[serviceId]) {
-                if (!this.allowRewriteClasses) {
+            if (this.serviceClasses[serviceId]) {
+                if (!this.settings.allowRewriteClasses) {
                     throw new Error(`ProxyDI already has registered class for ${serviceId}`);
                 }
             }
-            this.classes[serviceId] = serviceClass;
-        }
-        findInstance(serviceId) {
-            const instance = this.instances[serviceId];
-            if (!instance && this.parent) {
-                return this.parent.findInstance(serviceId);
-            }
-            return instance;
+            this.serviceClasses[serviceId] = serviceClass;
         }
         isKnown(serviceId) {
-            return !!(this.findInstance(serviceId) || this.findDefiner(serviceId));
+            return !!(this.findInstance(serviceId) ||
+                this.findServiceClass(serviceId) ||
+                injectableClasses[serviceId]);
         }
         resolve(serviceId) {
             if (!this.isKnown(serviceId)) {
@@ -130,34 +127,21 @@
             if (instance) {
                 return instance;
             }
-            const definer = this.findDefiner(serviceId);
-            if (definer) {
-                let instance = new definer();
-                this.injectDependencies(instance);
-                instance[PROXYDI_ID] = serviceId;
-                this.instances[serviceId] = instance;
-                return instance;
-            }
             else {
-                return this.getProxy(serviceId);
-            }
-        }
-        findDefiner(serviceId) {
-            let definer = this.classes[serviceId];
-            if (!definer && this.parent) {
-                return this.parent.findDefiner(serviceId);
-            }
-            if (!definer) {
-                return injectableClasses[serviceId];
+                const ServiceClass = this.findServiceClass(serviceId);
+                const newInstance = new ServiceClass();
+                this.registerInstance(serviceId, newInstance);
+                return newInstance;
             }
-            return definer;
         }
         injectDependencies(instance) {
             const serviceInjects = instance[INJECTS] || [];
             serviceInjects.forEach((inject) => {
+                // TODO: Return only proxies
+                //const value = makeProxy(inject.serviceId, instance);
                 let value = this.findInstance(inject.serviceId);
                 if (!value) {
-                    value = this.getProxy(inject.serviceId);
+                    value = makeProxy(inject.serviceId, instance);
                 }
                 inject.set(instance, value);
             });
@@ -165,56 +149,62 @@
                 instance[PROXYDI] = this;
             }
         }
-        getProxy(serviceId) {
-            let proxy = this.proxies[serviceId];
-            if (!proxy) {
-                proxy = this.proxyFactory.makeProxy(serviceId);
-                this.proxies[serviceId] = proxy;
-            }
-            return proxy;
-        }
-        createChildContainer(settings) {
-            const childSettings = Object.assign(Object.assign({}, settings), { parent: this });
-            return new ProxyDI(childSettings);
+        createChildContainer() {
+            return new ProxyDI(this.settings, this);
         }
         removeInstance(serviceId) {
-            const id = serviceId[PROXYDI_ID]
-                ? serviceId[PROXYDI_ID]
-                : serviceId;
-            const instance = this.instances[id];
+            const id = isInstance(serviceId) ? serviceId[SERVICE_ID] : serviceId;
+            const instance = this.serviceInstances[id];
             if (instance) {
                 const serviceInjects = instance[INJECTS] || [];
                 serviceInjects.forEach((inject) => {
                     inject.set(instance, undefined);
                 });
                 delete instance[PROXYDI];
-                delete instance[PROXYDI_ID];
-                delete this.instances[serviceId];
+                delete instance[SERVICE_ID];
+                delete this.serviceInstances[id];
             }
         }
         removeClass(serviceId) {
-            delete this.classes[serviceId];
+            delete this.serviceClasses[serviceId];
         }
         destroy() {
-            const allServices = Object.keys(this.instances);
+            const allServices = Object.keys(this.serviceInstances);
             for (const serviceId of allServices) {
-                const instance = this.instances[serviceId];
+                const instance = this.serviceInstances[serviceId];
                 this.removeInstance(instance);
             }
-            this.instances = {};
-            this.proxies = {};
-            this.classes = {};
+            this.serviceInstances = {};
+            this.serviceClasses = {};
             for (const id of Object.keys(this.children)) {
                 const child = this.children[+id];
                 child.destroy();
             }
             this.children = {};
-            this.proxyFactory = undefined;
             if (this.parent) {
                 this.parent.removeChild(this.id);
                 this.parent = undefined;
             }
         }
+        findInstance(serviceId) {
+            const instance = this.serviceInstances[serviceId];
+            if (!instance && this.parent) {
+                const parentInstance = this.parent.findInstance(serviceId);
+                // TODO: Make copy, inject container dependencies?
+                return parentInstance;
+            }
+            return instance;
+        }
+        findServiceClass(serviceId) {
+            let ServiceClass = this.serviceClasses[serviceId];
+            if (!ServiceClass && !!this.parent) {
+                return this.parent.findServiceClass(serviceId);
+            }
+            if (!ServiceClass) {
+                return injectableClasses[serviceId];
+            }
+            return ServiceClass;
+        }
         addChild(child) {
             if (this.children[child.id]) {
                 throw new Error(`ProxyDI already has child with id ${child.id}`);
@@ -229,8 +219,35 @@
         }
     }
     ProxyDI.idCounter = 0;
+    function isInstance(service) {
+        return (typeof service === 'object' &&
+            !!service[SERVICE_ID]);
+    }
+
+    const inject = (serviceId) => {
+        return function (_value, context) {
+            if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
+                const name = serviceId ? serviceId : context.name;
+                const inject = {
+                    property: context.name,
+                    serviceId: name,
+                    set: context.access.set,
+                };
+                context.addInitializer(function () {
+                    if (!this[INJECTS]) {
+                        this[INJECTS] = [];
+                    }
+                    this[INJECTS].push(inject);
+                });
+            }
+            else {
+                throw new Error('@inject decorator should decorate fields');
+            }
+        };
+    };
 
     exports.ProxyDI = ProxyDI;
     exports.inject = inject;
+    exports.injectable = injectable;
 
 }));

package/dist/inject.d.ts

@@ -1,3 +1,2 @@
 import { ServiceId } from './types';
-export declare const INJECTS: unique symbol;
 export declare const inject: (serviceId?: ServiceId) => (_value: unknown, context: ClassFieldDecoratorContext) => void;

package/dist/presets.d.ts

@@ -0,0 +1,3 @@
+import { ProxyDISettings } from './types';
+export declare const DEFAULT_SETTINGS: Required<ProxyDISettings>;
+export declare const TESTS_SETTINGS: Required<ProxyDISettings>;

package/dist/types.d.ts

@@ -1,4 +1,3 @@
-import { ProxyDI } from './ProxyDI';
 export type ServiceId = any;
 export type ServiceConstructor<T extends unknown> = new () => T;
 export type Setter = (object: unknown, value: unknown) => void;
@@ -7,9 +6,40 @@ export type Inject = {
     serviceId: ServiceId;
     set: Setter;
 };
+export type ProxyDI = {
+    isKnown: (serviceId: ServiceId) => boolean;
+    injectDependencies: (instance: any) => void;
+    registerInstance: <T>(serviceId: ServiceId, instance: T extends {
+        new (...args: any[]): any;
+    } ? never : T) => void;
+    registerClass: <T>(serviceId: ServiceId, serviceClass: ServiceClass<T>) => void;
+    resolve: <T>(serviceId: ServiceId) => T;
+    createChildContainer: () => ProxyDI;
+    removeInstance: (serviceId: ServiceId | ProxydiedInstance) => void;
+    removeClass: (serviceId: ServiceId) => void;
+    destroy: () => void;
+};
+export declare const INJECTS: unique symbol;
+export declare const PROXYDI: unique symbol;
+export declare const SERVICE_ID: unique symbol;
+export type ReadyForProxidyInstance = {
+    [INJECTS]: Inject[];
+};
+export type InjectedInstance = ReadyForProxidyInstance & {
+    [PROXYDI]: ProxyDI;
+};
+export type ProxydiedInstance = InjectedInstance & {
+    [SERVICE_ID]: ServiceId;
+};
 export type ServiceClass<T> = new (...args: any[]) => T;
 export type ProxyDISettings = {
-    parent?: ProxyDI;
+    allowRegisterAnythingAsInstance?: boolean;
     allowRewriteClasses?: boolean;
     allowRewriteInstances?: boolean;
 };
+export declare const IS_PROXY: unique symbol;
+export declare const INSTANCE: unique symbol;
+export type InstanceProxy = {
+    [IS_PROXY]: true;
+    [INSTANCE]: ProxydiedInstance;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "proxydi",
-    "version": "0.0.3",
+    "version": "0.0.4",
     "description": "A typed DI container that resolves circular dependencies via Proxy",
     "type": "module",
     "main": "./dist/index.cjs",