@midwayjs/core 4.0.0-beta.5 → 4.0.0-beta.6

package/dist/decorator/metadataManager.d.ts

@@ -13,7 +13,7 @@ declare enum ObjectType {
  * @since 4.0.0
  */
 export declare class MetadataManager {
-    protected static readonly metadataSymbol: unique symbol;
+    private static _metadataStore;
     protected static readonly metadataClassSymbol: unique symbol;
     protected static readonly metadataPropertySymbol: unique symbol;
     protected static readonly cacheSymbol: unique symbol;
@@ -45,15 +45,15 @@ export declare class MetadataManager {
     /**
      * Checks if metadata exists for a target class or property
      */
-    static hasMetadata(metadataKey: string | symbol, target: ClassType, propertyKey?: string | symbol): boolean;
+    static hasMetadata(metadataKey: string | symbol, target: ClassType | object, propertyKey?: string | symbol): boolean;
     /**
      * Checks if own metadata exists for a target class or property
      */
-    static hasOwnMetadata(metadataKey: string | symbol, target: ClassType, propertyKey?: string | symbol): boolean;
+    static hasOwnMetadata(metadataKey: string | symbol, target: ClassType | object, propertyKey?: string | symbol): boolean;
     /**
      * Deletes metadata for a target class or property
      */
-    static deleteMetadata(metadataKey: string | symbol, target: ClassType, propertyKey?: string | symbol): void;
+    static deleteMetadata(metadataKey: string | symbol, target: ClassType | object, propertyKey?: string | symbol): void;
     /**
      * Get all metadata keys on the entire prototype chain
      * Because we need to get metadata on the entire prototype chain, we do not use cache here, so the performance is poor
@@ -126,6 +126,10 @@ export declare class MetadataManager {
     private static getUnionKey;
     private static formatTarget;
     static ensureTargetType(target: any, type: ObjectType): void;
+    private static getOwnProperty;
+    private static hasOwnProperty;
+    private static setOwnProperty;
+    static clear(): void;
 }
 export {};
 //# sourceMappingURL=metadataManager.d.ts.map

package/dist/decorator/metadataManager.js

@@ -335,33 +335,26 @@ class MetadataManager {
          *    }
          *  }
          */
-        // eslint-disable-next-line no-prototype-builtins
-        if (!target.hasOwnProperty(this.metadataSymbol)) {
-            const _metadata = {
+        if (!this._metadataStore.has(target)) {
+            this._metadataStore.set(target, {
                 [this.metadataClassSymbol]: Object.create(null),
                 [this.metadataPropertySymbol]: Object.create(null),
-            };
-            Object.defineProperty(target, this.metadataSymbol, {
-                value: _metadata,
-                enumerable: false,
-                configurable: false,
             });
-            return _metadata;
         }
-        return target[this.metadataSymbol];
+        return this._metadataStore.get(target);
     }
     static invalidateCache(metadataKey, target, propertyKey) {
         // remove current cache
         const unionKey = this.getUnionKey(metadataKey, propertyKey);
         // Remove the specific cache
         // eslint-disable-next-line no-prototype-builtins
-        if (target.hasOwnProperty(this.cacheSymbol)) {
-            delete target[this.cacheSymbol]?.[unionKey];
+        if (this.hasOwnProperty(target, this.cacheSymbol)) {
+            delete this.getOwnProperty(target, this.cacheSymbol)?.[unionKey];
         }
         // Execute hooks, passing the unionKey to clear
-        const cleanHooks = target[this.cleanHooksSymbol];
+        const cleanHooks = this.getOwnProperty(target, this.cleanHooksSymbol);
         if (cleanHooks) {
-            target[this.cleanHooksSymbol] = cleanHooks.filter(hook => !hook(unionKey));
+            this.setOwnProperty(target, this.cleanHooksSymbol, cleanHooks.filter(hook => !hook(unionKey)));
         }
     }
     static setCache(metadataKey, target, protoTarget, value, propertyKey) {
@@ -370,42 +363,30 @@ class MetadataManager {
         if (target !== protoTarget) {
             this.validCacheConstruct(protoTarget);
             // Register a clean hook to the prototype target and clean the cache when the prototype target value is changed
-            protoTarget[this.cleanHooksSymbol].push((keyToClear) => {
+            this.getOwnProperty(protoTarget, this.cleanHooksSymbol).push((keyToClear) => {
                 // Only delete cache if the key matches
                 if (keyToClear === unionKey) {
-                    delete target[this.cacheSymbol]?.[unionKey];
+                    delete this.getOwnProperty(target, this.cacheSymbol)?.[unionKey];
                     // Indicates that this hook can be removed
                     return true;
                 }
                 return false;
             });
         }
-        target[this.cacheSymbol][unionKey] = value;
+        this.getOwnProperty(target, this.cacheSymbol)[unionKey] = value;
     }
     static validCacheConstruct(target) {
+        const metadata = this.getOrCreateMetaObject(target);
         // eslint-disable-next-line no-prototype-builtins
-        if (!target.hasOwnProperty(this.cacheSymbol)) {
-            Object.defineProperty(target, this.cacheSymbol, {
-                value: Object.create(null),
-                enumerable: false,
-                configurable: false,
-            });
+        if (!metadata[this.cacheSymbol]) {
+            metadata[this.cacheSymbol] = Object.create(null);
         }
-        // eslint-disable-next-line no-prototype-builtins
-        if (!target.hasOwnProperty(this.cleanHooksSymbol)) {
-            Object.defineProperty(target, this.cleanHooksSymbol, {
-                value: [],
-                enumerable: false,
-                configurable: false,
-                writable: true,
-            });
+        if (!metadata[this.cleanHooksSymbol]) {
+            metadata[this.cleanHooksSymbol] = [];
         }
     }
     static getCache(metadataKey, target, propertyKey) {
-        // eslint-disable-next-line no-prototype-builtins
-        if (target.hasOwnProperty(this.cacheSymbol)) {
-            return target[this.cacheSymbol]?.[this.getUnionKey(metadataKey, propertyKey)];
-        }
+        return this.getOwnProperty(target, this.cacheSymbol)?.[this.getUnionKey(metadataKey, propertyKey)];
     }
     static getUnionKey(metadataKey, propertyKey) {
         return propertyKey
@@ -413,10 +394,7 @@ class MetadataManager {
             : metadataKey.toString();
     }
     static formatTarget(target) {
-        // eslint-disable-next-line no-prototype-builtins
-        let ret = target.hasOwnProperty(this.isClassSymbol)
-            ? target[this.isClassSymbol]
-            : undefined;
+        let ret = this.getOwnProperty(target, this.isClassSymbol);
         if (!ret) {
             const isClassRet = (0, types_1.isClass)(target);
             if (isClassRet) {
@@ -428,30 +406,38 @@ class MetadataManager {
             else {
                 ret = ObjectType.Object;
             }
-            Object.defineProperty(target, this.isClassSymbol, {
-                value: ret,
-                enumerable: false,
-                configurable: false,
-            });
+            this.setOwnProperty(target, this.isClassSymbol, ret);
         }
         return ret === ObjectType.Instance ? target.constructor : target;
     }
     static ensureTargetType(target, type) {
         // eslint-disable-next-line no-prototype-builtins
-        const ret = target.hasOwnProperty(this.isClassSymbol)
-            ? target[this.isClassSymbol]
-            : undefined;
+        const ret = this.getOwnProperty(target, this.isClassSymbol);
         if (!ret) {
-            Object.defineProperty(target, this.isClassSymbol, {
-                value: type,
-                enumerable: false,
-                configurable: false,
-            });
+            this.setOwnProperty(target, this.isClassSymbol, type);
+        }
+    }
+    static getOwnProperty(target, propertyKey) {
+        const _metadata = this.getOrCreateMetaObject(target);
+        return _metadata[propertyKey] ?? undefined;
+    }
+    static hasOwnProperty(target, propertyKey) {
+        if (!this._metadataStore.has(target)) {
+            return false;
         }
+        const _metadata = this._metadataStore.get(target);
+        return _metadata[propertyKey] !== undefined;
+    }
+    static setOwnProperty(target, propertyKey, value) {
+        const _metadata = this.getOrCreateMetaObject(target);
+        _metadata[propertyKey] = value;
+    }
+    static clear() {
+        this._metadataStore = new WeakMap();
     }
 }
 exports.MetadataManager = MetadataManager;
-MetadataManager.metadataSymbol = Symbol.for('midway.metadata');
+MetadataManager._metadataStore = new WeakMap();
 MetadataManager.metadataClassSymbol = Symbol.for('midway.metadata.class');
 MetadataManager.metadataPropertySymbol = Symbol.for('midway.metadata.property');
 MetadataManager.cacheSymbol = Symbol.for('midway.metadata.cache');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "4.0.0-beta.5",
+  "version": "4.0.0-beta.6",
   "description": "midway core",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -24,7 +24,7 @@
   "devDependencies": {
     "@midwayjs/logger": "^3.0.0",
     "eventsource": "2.0.2",
-    "koa": "2.16.2",
+    "koa": "3.0.3",
     "mm": "3.4.0",
     "raw-body": "2.5.2",
     "sinon": "17.0.2"
@@ -61,5 +61,5 @@
       "types": "./dist/functional/index.d.ts"
     }
   },
-  "gitHead": "bfbab99fabbecd15a21df8c003cbd35d4c6ba3ff"
+  "gitHead": "a02425777d044ec502d050993bc256dc26d5b586"
 }