fix: narrow isClass fallback to exclude native constructors

The prototype-based fallback incorrectly treated native constructors
(Object, Array, Function, etc.) as user-defined classes because they
also have non-writable prototype. Add a [native code] check to the
fallback condition to skip these.

This caused CI failures in validation/validation-zod tests because
MetadataManager.formatTarget() would normalize targets incorrectly,
leading to lost metadata on PickDto/OmitDto.

Also use jest.isolateModules in tests so the toString mock takes
effect after module-level caching.

Author: nobu121

packages/core/src/util/types.ts

@@ -13,14 +13,20 @@ export function isClass(fn) {
     return false;
   }
 
-  if (/^class[\s{]/.test(ToString.call(fn))) {
+  const fnSource = ToString.call(fn);
+  if (/^class[\s{]/.test(fnSource)) {
     return true;
   }
 
   // Tools like Bytenode replace function source text, so Function#toString is
   // unreliable. ECMAScript class constructors have a non-writable `prototype`.
+  // Native constructors also satisfy this shape, so skip "[native code]" here.
   const descriptor = Object.getOwnPropertyDescriptor(fn, 'prototype');
-  if (descriptor && descriptor.writable === false) {
+  if (
+    descriptor &&
+    descriptor.writable === false &&
+    !/\[native code\]/.test(fnSource)
+  ) {
     return true;
   }
 

packages/core/test/decorator/util/index.test.ts

@@ -24,27 +24,41 @@ describe('/test/util/index.test.ts', () => {
     expect(Types.isString(undefined)).toBeFalsy();
     expect(Types.isString({})).toBeFalsy();
 
-    expect(Types.isClass(class B {})).toBeTruthy();
+    function plainFn() {}
+    const asyncFn = async function () {};
+    expect(Types.isClass(plainFn)).toBeFalsy();
+    expect(Types.isClass(asyncFn)).toBeFalsy();
+    expect(Types.isClass(() => {})).toBeFalsy();
+    expect(Types.isClass(Object)).toBeFalsy();
+    expect(Types.isClass(Array)).toBeFalsy();
+    expect(Types.isClass(Function)).toBeFalsy();
+  });
 
+  it('should detect class when toString source is obscured', () => {
     class ObscuredCtor {}
     const origToString = Function.prototype.toString;
     try {
-      Function.prototype.toString = function (this: unknown) {
+      jest.resetModules();
+      Function.prototype.toString = function () {
         if (this === ObscuredCtor) {
           return 'function () {}';
         }
         return origToString.call(this);
       };
-      expect(Types.isClass(ObscuredCtor)).toBeTruthy();
+
+      let isolatedTypes!: typeof Types;
+      jest.isolateModules(() => {
+        isolatedTypes = require('../../../src/util/types').Types;
+      });
+
+      expect(isolatedTypes.isClass(ObscuredCtor)).toBeTruthy();
+      expect(isolatedTypes.isClass(Object)).toBeFalsy();
+      expect(isolatedTypes.isClass(Array)).toBeFalsy();
+      expect(isolatedTypes.isClass(Function)).toBeFalsy();
     } finally {
       Function.prototype.toString = origToString;
+      jest.resetModules();
     }
-
-    function plainFn() {}
-    const asyncFn = async function () {};
-    expect(Types.isClass(plainFn)).toBeFalsy();
-    expect(Types.isClass(asyncFn)).toBeFalsy();
-    expect(Types.isClass(() => {})).toBeFalsy();
   });
 
   it('should test toAsyncFunction', async () => {