Ensure MaybeMasked doesn't unwrap if it contains any

.changeset/friendly-papayas-breathe.md

@@ -0,0 +1,5 @@
+---
+"@apollo/client": patch
+---
+
+Fix `Unmasked` unwrapping tuple types into an array of their subtypes.

.changeset/happy-weeks-buy.md

@@ -0,0 +1,5 @@
+---
+"@apollo/client": patch
+---
+
+Ensure `MaybeMasked` does not try and unwrap types that contain index signatures.

.changeset/three-pandas-smash.md

@@ -0,0 +1,5 @@
+---
+"@apollo/client": patch
+---
+
+Ensure `MaybeMasked` does not try to unwrap the type as `Unmasked` if the type contains `any`.

src/masking/__benches__/types.bench.ts

@@ -299,7 +299,7 @@ test("MaybeMasked handles odd types", (prefix) => {
 
   bench(prefix + "unknown instantiations", () => {
     attest<unknown, MaybeMasked<unknown>>();
-  }).types([52, "instantiations"]);
+  }).types([54, "instantiations"]);
   bench(prefix + "unknown functionality", () => {
     expectTypeOf<MaybeMasked<unknown>>().toBeUnknown();
   });
@@ -464,3 +464,116 @@ test("base type, multiple fragments on sub-types", (prefix) => {
     }>();
   });
 });
+
+test("does not detect `$fragmentRefs` if type contains `any`", (prefix) => {
+  interface Source {
+    foo: { bar: any[] };
+    " $fragmentName": "foo";
+  }
+
+  bench(prefix + "instantiations", () => {
+    return {} as MaybeMasked<Source>;
+  }).types([6, "instantiations"]);
+
+  bench(prefix + "functionality", () => {
+    const x = {} as MaybeMasked<Source>;
+
+    expectTypeOf(x).branded.toEqualTypeOf<Source>();
+  });
+});
+
+test("leaves tuples alone", (prefix) => {
+  interface Source {
+    coords: [long: number, lat: number];
+  }
+
+  bench(prefix + "instantiations", () => {
+    return {} as Unmasked<Source>;
+  }).types([5, "instantiations"]);
+
+  bench(prefix + "functionality", () => {
+    const x = {} as Unmasked<Source>;
+
+    expectTypeOf(x).branded.toEqualTypeOf<{
+      coords: [long: number, lat: number];
+    }>();
+  });
+});
+
+test("does not detect `$fragmentRefs` if type is a record type", (prefix) => {
+  interface MetadataItem {
+    foo: string;
+  }
+
+  interface Source {
+    metadata: Record<string, MetadataItem>;
+    " $fragmentName": "Source";
+  }
+
+  bench(prefix + "instantiations", () => {
+    return {} as MaybeMasked<Source>;
+  }).types([6, "instantiations"]);
+
+  bench(prefix + "functionality", () => {
+    const x = {} as MaybeMasked<Source>;
+
+    expectTypeOf(x).branded.toEqualTypeOf<Source>();
+  });
+});
+
+test("does not detect `$fragmentRefs` on types with index signatures", (prefix) => {
+  interface Source {
+    foo: string;
+    " $fragmentName": "Source";
+    [key: string]: string;
+  }
+
+  bench(prefix + "instantiations", () => {
+    return {} as MaybeMasked<Source>;
+  }).types([6, "instantiations"]);
+
+  bench(prefix + "functionality", () => {
+    const x = {} as MaybeMasked<Source>;
+
+    expectTypeOf(x).branded.toEqualTypeOf<Source>();
+  });
+});
+
+test("detects `$fragmentRefs` on types with index signatures", (prefix) => {
+  type Source = {
+    __typename: "Foo";
+    id: number;
+    metadata: Record<string, number>;
+    structuredMetadata: StructuredMetadata;
+  } & { " $fragmentName"?: "UserFieldsFragment" } & {
+    " $fragmentRefs"?: {
+      FooFragment: FooFragment;
+    };
+  };
+
+  interface StructuredMetadata {
+    bar: number;
+    [index: string]: number;
+  }
+
+  type FooFragment = {
+    __typename: "Foo";
+    foo: string;
+  } & { " $fragmentName"?: "FooFragment" };
+
+  bench(prefix + "instantiations", () => {
+    return {} as MaybeMasked<Source>;
+  }).types([6, "instantiations"]);
+
+  bench(prefix + "functionality", () => {
+    const x = {} as MaybeMasked<Source>;
+
+    expectTypeOf(x).branded.toEqualTypeOf<{
+      __typename: "Foo";
+      id: number;
+      metadata: Record<string, number>;
+      foo: string;
+      structuredMetadata: StructuredMetadata;
+    }>();
+  });
+});

src/masking/internal/types.ts

@@ -1,4 +1,4 @@
-import type { Prettify } from "../../utilities/index.js";
+import type { Prettify, RemoveIndexSignature } from "../../utilities/index.js";
 
 export type IsAny<T> = 0 extends 1 & T ? true : false;
 
@@ -20,7 +20,6 @@ export type UnwrapFragmentRefs<TData> =
             >
         >
       >
-    : TData extends Array<infer TItem> ? Array<UnwrapFragmentRefs<TItem>>
     : TData extends object ?
       {
         [K in keyof TData]: UnwrapFragmentRefs<TData[K]>;
@@ -184,8 +183,9 @@ export type RemoveFragmentName<T> =
   T extends any ? Omit<T, " $fragmentName"> : T;
 
 export type ContainsFragmentsRefs<TData> =
-  TData extends object ?
-    " $fragmentRefs" extends keyof TData ?
+  true extends IsAny<TData> ? false
+  : TData extends object ?
+    " $fragmentRefs" extends keyof RemoveIndexSignature<TData> ?
       true
     : ContainsFragmentsRefs<TData[keyof TData]>
   : false;

src/utilities/index.ts

@@ -139,6 +139,7 @@ export type { OnlyRequiredProperties } from "./types/OnlyRequiredProperties.js";
 export type { Prettify } from "./types/Prettify.js";
 export type { UnionToIntersection } from "./types/UnionToIntersection.js";
 export type { NoInfer } from "./types/NoInfer.js";
+export type { RemoveIndexSignature } from "./types/RemoveIndexSignature.js";
 
 export {
   AutoCleanedStrongCache,

src/utilities/types/RemoveIndexSignature.ts

@@ -0,0 +1,6 @@
+export type RemoveIndexSignature<T> = {
+  [K in keyof T as string extends K ? never
+  : number extends K ? never
+  : symbol extends K ? never
+  : K]: T[K];
+};