smartdi 0.4.0 → 0.4.1

package/README.md

@@ -232,6 +232,17 @@ Decorate a method as a lifecycle hook, which will be invoked when `SmartDI.initi
 Decorate a method as a lifecycle hook, which will be invoked when `SmartDI.uninitialize()` is called.
 将方法装饰为生命周期钩子，在调用 `SmartDI.uninitialize()` 时执行。
 
+## Inheritance | 继承
+
+Injected properties and lifecycle hooks declared on base classes apply to subclass instances. Decorators write only the metadata of the class they decorate; the prototype chain is merged when an instance is created.
+
+基类声明的注入属性与生命周期钩子会对子类实例生效。装饰器只写入所在类自己的元数据，实例创建时再沿原型链合并。
+
+- Injected properties are merged base-first, so a subclass property with the same name overrides the base one.
+  注入属性按基类在前合并，子类同名字段覆盖基类字段。
+- `@PostConstruct` / `@PreDestroy` methods run once per instance, base-class hooks first.
+  每个实例的 `@PostConstruct` / `@PreDestroy` 各执行一次，基类钩子在前。
+
 ## Limitations
 
 Injection is processed after construction, so do not access injectable values in the constructor.

package/index.js

@@ -10,9 +10,73 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PreDestroy = exports.PostConstruct = exports.InjectArray = exports.Inject = exports.Injectable = exports.SmartDI = void 0;
+exports.SmartDI = void 0;
+exports.Injectable = Injectable;
+exports.Inject = Inject;
+exports.InjectArray = InjectArray;
+exports.PostConstruct = PostConstruct;
+exports.PreDestroy = PreDestroy;
 const $registry = Symbol('registry');
 const $singletons = Symbol('singletons');
+const METADATA_INJECTS = 'smartdi:injects';
+const METADATA_POST_CONSTRUCT = 'smartdi:post-construct';
+const METADATA_PRE_DESTROY = 'smartdi:pre-destroy';
+function prototypeChain(instance) {
+    const chain = [];
+    let proto = Object.getPrototypeOf(instance);
+    while (proto && proto !== Object.prototype) {
+        chain.push(proto);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return chain.reverse();
+}
+function isSubclass(sub, sup) {
+    let proto = Object.getPrototypeOf(sub);
+    while (proto) {
+        if (proto === sup)
+            return true;
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+}
+const injectsCache = new WeakMap();
+function collectInjects(instance) {
+    const prototype = Object.getPrototypeOf(instance);
+    let merged = injectsCache.get(prototype);
+    if (merged)
+        return merged;
+    merged = {};
+    for (const proto of prototypeChain(instance))
+        Object.assign(merged, Reflect.getOwnMetadata(METADATA_INJECTS, proto));
+    injectsCache.set(prototype, merged);
+    return merged;
+}
+function collectLifecycle(instance, key) {
+    var _c;
+    const methods = [];
+    const seen = new Set();
+    for (const proto of prototypeChain(instance)) {
+        for (const method of (_c = Reflect.getOwnMetadata(key, proto)) !== null && _c !== void 0 ? _c : []) {
+            if (seen.has(method))
+                continue;
+            seen.add(method);
+            methods.push(method);
+        }
+    }
+    return methods;
+}
+function defineInject(target, prop, item) {
+    var _c;
+    const injects = (_c = Reflect.getOwnMetadata(METADATA_INJECTS, target)) !== null && _c !== void 0 ? _c : {};
+    injects[prop] = item;
+    Reflect.defineMetadata(METADATA_INJECTS, injects, target);
+}
+function appendLifecycle(target, key, method) {
+    var _c;
+    const methods = (_c = Reflect.getOwnMetadata(key, target)) !== null && _c !== void 0 ? _c : [];
+    methods.push(method);
+    Reflect.defineMetadata(key, methods, target);
+}
 class SmartDI {
     static register(clazz, options) {
         const name = (options === null || options === void 0 ? void 0 : options.name) || clazz.name;
@@ -44,8 +108,8 @@ class SmartDI {
                 instances.push(SmartDI.obtainInstance(item, new Set()));
             const promises = [];
             for (const instance of instances) {
-                let methods = Reflect.getMetadata('smartdi:post-construct', instance);
-                if (!(methods === null || methods === void 0 ? void 0 : methods.length))
+                const methods = collectLifecycle(instance, METADATA_POST_CONSTRUCT);
+                if (!methods.length)
                     continue;
                 for (const method of methods) {
                     const result = instance[method]();
@@ -67,8 +131,8 @@ class SmartDI {
                 if (!instance)
                     continue;
                 item.instance = undefined;
-                let methods = Reflect.getMetadata('smartdi:pre-destroy', instance);
-                if (!(methods === null || methods === void 0 ? void 0 : methods.length))
+                const methods = collectLifecycle(instance, METADATA_PRE_DESTROY);
+                if (!methods.length)
                     continue;
                 for (const method of methods) {
                     const result = instance[method]();
@@ -115,14 +179,15 @@ class SmartDI {
         const instance = new item.class(...args);
         if (item.singleton)
             item.instance = instance;
-        const injects = Reflect.getMetadata('smartdi:injects', instance);
-        if (!injects)
+        const injects = collectInjects(instance);
+        const injectKeys = Reflect.ownKeys(injects);
+        if (!injectKeys.length)
             return instance;
         if (!item.singleton && creatings.has(item.name))
             throw new Error('Circular dependency detected!');
         creatings.add(item.name);
         try {
-            for (const prop of Reflect.ownKeys(injects))
+            for (const prop of injectKeys)
                 instance[prop] = injects[prop].array
                     ? SmartDI.internalGetArray(injects[prop].clue, creatings, ...injects[prop].args)
                     : SmartDI.internalGet(injects[prop].clue, creatings, ...injects[prop].args);
@@ -135,28 +200,24 @@ class SmartDI {
         return instance;
     }
     static resolveByConstructor(constructor) {
-        let matched = [];
-        function isSubclass(sub, sup) {
-            let proto = Object.getPrototypeOf(sub);
-            while (proto) {
-                if (proto === sup)
-                    return true;
-                proto = Object.getPrototypeOf(proto);
-            }
-            return false;
-        }
+        const matched = [];
         for (const item of Object.values(SmartDI[$registry])) {
-            if (!isSubclass(item.class, constructor))
-                continue;
-            matched.push(item);
+            if (isSubclass(item.class, constructor))
+                matched.push(item);
         }
         return matched;
     }
     static resolveOneByConstructor(constructor) {
-        const items = SmartDI.resolveByConstructor(constructor);
-        if (items.length > 1)
-            throw new Error(`Multiple injectable classes found for '${constructor.name}': ${items.map(item => item.name).join(', ')}`);
-        return items[0];
+        const matched = [];
+        for (const item of Object.values(SmartDI[$registry])) {
+            if (item.class === constructor)
+                return item;
+            if (isSubclass(item.class, constructor))
+                matched.push(item);
+        }
+        if (matched.length > 1)
+            throw new Error(`Multiple injectable classes found for '${constructor.name}': ${matched.map(item => item.name).join(', ')}`);
+        return matched[0];
     }
 }
 exports.SmartDI = SmartDI;
@@ -168,36 +229,23 @@ function Injectable(options) {
         SmartDI.register(target, options);
     };
 }
-exports.Injectable = Injectable;
 function Inject(clue, ...args) {
     return function (target, prop) {
-        let injects = Reflect.getMetadata('smartdi:injects', target) || {};
-        injects[prop] = { array: false, clue, args };
-        Reflect.defineMetadata('smartdi:injects', injects, target);
+        defineInject(target, prop, { array: false, clue, args });
     };
 }
-exports.Inject = Inject;
 function InjectArray(clue, ...args) {
     return function (target, prop) {
-        let injects = Reflect.getMetadata('smartdi:injects', target) || {};
-        injects[prop] = { array: true, clue, args };
-        Reflect.defineMetadata('smartdi:injects', injects, target);
+        defineInject(target, prop, { array: true, clue, args });
     };
 }
-exports.InjectArray = InjectArray;
 function PostConstruct() {
     return function (target, key, _descriptor) {
-        let methods = Reflect.getMetadata('smartdi:post-construct', target) || [];
-        methods.push(key);
-        Reflect.defineMetadata('smartdi:post-construct', methods, target);
+        appendLifecycle(target, METADATA_POST_CONSTRUCT, key);
     };
 }
-exports.PostConstruct = PostConstruct;
 function PreDestroy() {
     return function (target, key, _descriptor) {
-        let methods = Reflect.getMetadata('smartdi:pre-destroy', target) || [];
-        methods.push(key);
-        Reflect.defineMetadata('smartdi:pre-destroy', methods, target);
+        appendLifecycle(target, METADATA_PRE_DESTROY, key);
     };
 }
-exports.PreDestroy = PreDestroy;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "smartdi",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "A simple dependency injector based on decorators.",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc -p tsconfig.build.json",
+    "test": "jest"
   },
   "keywords": [
     "DI",
@@ -27,8 +28,11 @@
   },
   "homepage": "https://github.com/iwares/smartdi#readme",
   "devDependencies": {
+    "@types/jest": "^30.0.0",
     "@types/node": "^22.13.10",
+    "jest": "^30.5.2",
     "reflect-metadata": "^0.2.2",
-    "typescript": "^5.1.6"
+    "ts-jest": "^29.4.15",
+    "typescript": "^6.0.3"
   }
 }