predicates: use brand check in production

Author: yaacovCR

src/jsutils/__tests__/instanceOf-test.ts

@@ -6,14 +6,15 @@ import { instanceOf } from '../instanceOf.js';
 describe('instanceOf', () => {
   it('do not throw on values without prototype', () => {
     class Foo {
+      readonly __isFoo = true as const;
       get [Symbol.toStringTag]() {
         return 'Foo';
       }
     }
 
-    expect(instanceOf(true, Foo)).to.equal(false);
-    expect(instanceOf(null, Foo)).to.equal(false);
-    expect(instanceOf(Object.create(null), Foo)).to.equal(false);
+    expect(instanceOf(undefined, true, Foo)).to.equal(false);
+    expect(instanceOf(undefined, null, Foo)).to.equal(false);
+    expect(instanceOf(undefined, Object.create(null), Foo)).to.equal(false);
   });
 
   it('detect name clashes with older versions of this lib', () => {
@@ -24,6 +25,7 @@ describe('instanceOf', () => {
 
     function newVersion() {
       class Foo {
+        readonly __isFoo = true as const;
         get [Symbol.toStringTag]() {
           return 'Foo';
         }
@@ -33,13 +35,17 @@ describe('instanceOf', () => {
 
     const NewClass = newVersion();
     const OldClass = oldVersion();
-    expect(instanceOf(new NewClass(), NewClass)).to.equal(true);
-    expect(() => instanceOf(new OldClass(), NewClass)).to.throw();
+    const newInstance = new NewClass();
+    expect(instanceOf(newInstance.__isFoo, newInstance, NewClass)).to.equal(
+      true,
+    );
+    expect(() => instanceOf(undefined, new OldClass(), NewClass)).to.throw();
   });
 
   it('allows instances to have share the same constructor name', () => {
     function getMinifiedClass(tag: string) {
       class SomeNameAfterMinification {
+        readonly [tag] = true as const;
         get [Symbol.toStringTag]() {
           return tag;
         }
@@ -49,17 +55,25 @@ describe('instanceOf', () => {
 
     const Foo = getMinifiedClass('Foo');
     const Bar = getMinifiedClass('Bar');
-    expect(instanceOf(new Foo(), Bar)).to.equal(false);
-    expect(instanceOf(new Bar(), Foo)).to.equal(false);
+    const fooInstance = new Foo();
+    const barInstance = new Bar();
+    expect(instanceOf(fooInstance.foo, fooInstance, Bar)).to.equal(false);
+    expect(instanceOf(barInstance.bar, barInstance, Foo)).to.equal(false);
 
     const DuplicateOfFoo = getMinifiedClass('Foo');
-    expect(() => instanceOf(new DuplicateOfFoo(), Foo)).to.throw();
-    expect(() => instanceOf(new Foo(), DuplicateOfFoo)).to.throw();
+    const duplicateOfFooInstance = new DuplicateOfFoo();
+    expect(() =>
+      instanceOf(duplicateOfFooInstance.foo, new DuplicateOfFoo(), Foo),
+    ).to.throw();
+    expect(() =>
+      instanceOf(fooInstance.foo, fooInstance, DuplicateOfFoo),
+    ).to.throw();
   });
 
   it('fails with descriptive error message', () => {
     function getFoo() {
       class Foo {
+        readonly __isFoo = true as const;
         get [Symbol.toStringTag]() {
           return 'Foo';
         }
@@ -69,11 +83,14 @@ describe('instanceOf', () => {
     const Foo1 = getFoo();
     const Foo2 = getFoo();
 
-    expect(() => instanceOf(new Foo1(), Foo2)).to.throw(
-      /^Cannot use Foo "{}" from another module or realm./m,
+    const foo1Instance = new Foo1();
+    const foo2Instance = new Foo2();
+
+    expect(() => instanceOf(foo1Instance.__isFoo, foo1Instance, Foo2)).to.throw(
+      /^Cannot use Foo "{ __isFoo: true }" from another module or realm./m,
     );
-    expect(() => instanceOf(new Foo2(), Foo1)).to.throw(
-      /^Cannot use Foo "{}" from another module or realm./m,
+    expect(() => instanceOf(foo2Instance.__isFoo, foo2Instance, Foo1)).to.throw(
+      /^Cannot use Foo "{ __isFoo: true }" from another module or realm./m,
     );
   });
 });

src/jsutils/instanceOf.ts

@@ -7,19 +7,30 @@ const isProduction =
   process.env.NODE_ENV === 'production';
 
 /**
- * A replacement for instanceof which includes an error warning when multi-realm
- * constructors are detected.
+ * A utility which throws an error warning when multi-realm constructors are detected,
+ * triggered by a positive brand check and a negative instanceof (for an object).
+ *
+ * When not in development mode, only the brand check is used.
+ *
  * See: https://expressjs.com/en/advanced/best-practice-performance.html#set-node_env-to-production
  * See: https://webpack.js.org/guides/production/
  */
-export const instanceOf: (value: unknown, constructor: Constructor) => boolean =
-  /* c8 ignore next 6 */
+export const instanceOf: (
+  brandCheck: true | undefined,
+  value: unknown,
+  constructor: Constructor,
+) => boolean =
+  /* c8 ignore next 9 */
   // FIXME: https://github.com/graphql/graphql-js/issues/2317
   isProduction
-    ? function instanceOf(value: unknown, constructor: Constructor): boolean {
-        return value instanceof constructor;
+    ? function instanceOf(brandCheck: true | undefined): boolean {
+        return brandCheck === true;
       }
-    : function instanceOf(value: unknown, constructor: Constructor): boolean {
+    : function instanceOf(
+        _brandCheck: true | undefined,
+        value: unknown,
+        constructor: Constructor,
+      ): boolean {
         if (value instanceof constructor) {
           return true;
         }

src/language/source.ts

@@ -14,6 +14,8 @@ interface Location {
  * The `line` and `column` properties in `locationOffset` are 1-indexed.
  */
 export class Source {
+  readonly __isSource = true as const;
+
   body: string;
   name: string;
   locationOffset: Location;
@@ -47,5 +49,5 @@ export class Source {
  * @internal
  */
 export function isSource(source: unknown): source is Source {
-  return instanceOf(source, Source);
+  return instanceOf((source as any)?.__isSource, source, Source);
 }