@khanacademy/wonder-blocks-data 12.0.0 → 13.0.0

package/src/hooks/__tests__/use-request-interception.test.tsx

@@ -68,7 +68,7 @@ describe("#useRequestInterception", () => {
         const handler = jest.fn();
         const interceptor1 = jest.fn();
         const interceptor2 = jest.fn();
-        const Wrapper = ({children, interceptor}: any) => (
+        const Wrapper = ({children, interceptor}: any): React.ReactElement => (
             <InterceptRequests interceptor={interceptor}>
                 {children}
             </InterceptRequests>
@@ -80,8 +80,7 @@ describe("#useRequestInterception", () => {
             {wrapper: Wrapper, initialProps: {interceptor: interceptor1}},
         );
         const result1 = wrapper.result.current;
-        // @ts-expect-error [FEI-5019] - TS2345 - Argument of type '{ wrapper: ({ children, interceptor, }: any) => JSX.Element; interceptor: jest.Mock<any, any, any>; }' is not assignable to parameter of type '{ interceptor: jest.Mock<any, any, any>; }'.
-        wrapper.rerender({wrapper: Wrapper, interceptor: interceptor2});
+        wrapper.rerender({interceptor: interceptor2});
         const result2 = wrapper.result.current;
 
         // Assert
@@ -126,7 +125,6 @@ describe("#useRequestInterception", () => {
             interceptedHandler();
 
             // Assert
-            // @ts-expect-error [FEI-5019] - TS2339 - Property 'toHaveBeenCalledBefore' does not exist on type 'JestMatchers<Mock<null, [], any>>'.
             expect(interceptorNearest).toHaveBeenCalledBefore(
                 interceptorFurthest,
             );
@@ -154,7 +152,6 @@ describe("#useRequestInterception", () => {
             interceptedHandler();
 
             // Assert
-            // @ts-expect-error [FEI-5019] - TS2339 - Property 'toHaveBeenCalledBefore' does not exist on type 'JestMatchers<Mock<null, [], any>>'.
             expect(interceptorFurthest).toHaveBeenCalledBefore(handler);
         });
 

package/src/hooks/__tests__/use-server-effect.test.ts

@@ -139,8 +139,7 @@ describe("#useServerEffect", () => {
             const interceptedHandler = jest.fn();
             jest.spyOn(SsrCache.Default, "getEntry").mockReturnValueOnce({
                 data: "DATA",
-                // @ts-expect-error [FEI-5019] - TS2322 - Type 'null' is not assignable to type 'undefined'.
-                error: null,
+                error: undefined,
             });
             jest.spyOn(
                 UseRequestInterception,
@@ -165,8 +164,7 @@ describe("#useServerEffect", () => {
             const fakeHandler = jest.fn();
             jest.spyOn(SsrCache.Default, "getEntry").mockReturnValueOnce({
                 data: "DATA",
-                // @ts-expect-error [FEI-5019] - TS2322 - Type 'null' is not assignable to type 'undefined'.
-                error: null,
+                error: undefined,
             });
 
             // Act
@@ -221,8 +219,7 @@ describe("#useServerEffect", () => {
             const fakeHandler = jest.fn();
             jest.spyOn(SsrCache.Default, "getEntry").mockReturnValueOnce({
                 data: "DATA",
-                // @ts-expect-error [FEI-5019] - TS2322 - Type 'null' is not assignable to type 'undefined'.
-                error: null,
+                error: undefined,
             });
 
             // Act

package/src/hooks/__tests__/use-shared-cache.test.ts

@@ -1,3 +1,5 @@
+// eslint-disable-next-line import/no-unassigned-import
+import "jest-extended";
 import {renderHook as clientRenderHook} from "@testing-library/react-hooks";
 
 import {useSharedCache, SharedCache} from "../use-shared-cache";
@@ -48,7 +50,6 @@ describe("#useSharedCache", () => {
         } = clientRenderHook(() => useSharedCache("id", "scope"));
 
         // Assert
-        // @ts-expect-error [FEI-5019] - TS2339 - Property 'toBeArrayOfSize' does not exist on type 'JestMatchers<[ValidCacheData | null | undefined, CacheValueFn<ValidCacheData>]>'.
         expect(result).toBeArrayOfSize(2);
     });
 
@@ -119,12 +120,13 @@ describe("#useSharedCache", () => {
                 id: "id",
                 scope: "scope",
             });
-            const result1 = wrapper.result.all[wrapper.result.all.length - 2];
-            const result2 = wrapper.result.current;
+            const value1 = wrapper.result.all[wrapper.result.all.length - 2];
+            const value2 = wrapper.result.current;
+            const result1 = Array.isArray(value1) ? value1[1] : "BAD1";
+            const result2 = Array.isArray(value2) ? value2[1] : "BAD2";
 
             // Assert
-            // @ts-expect-error [FEI-5019] - TS7053 - Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'Error | [ValidCacheData | null | undefined, CacheValueFn<ValidCacheData>]'.
-            expect(result1[1]).toBe(result2[1]);
+            expect(result1).toBe(result2);
         });
 
         it("should be a new function if the id changes", () => {
@@ -138,12 +140,13 @@ describe("#useSharedCache", () => {
 
             // Act
             wrapper.rerender({id: "new-id"});
-            const result1 = wrapper.result.all[wrapper.result.all.length - 2];
-            const result2 = wrapper.result.current;
+            const value1 = wrapper.result.all[wrapper.result.all.length - 2];
+            const value2 = wrapper.result.current;
+            const result1 = Array.isArray(value1) ? value1[1] : "BAD1";
+            const result2 = Array.isArray(value2) ? value2[1] : "BAD2";
 
             // Assert
-            // @ts-expect-error [FEI-5019] - TS7053 - Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'Error | [ValidCacheData | null | undefined, CacheValueFn<ValidCacheData>]'.
-            expect(result1[1]).not.toBe(result2[1]);
+            expect(result1).not.toBe(result2);
         });
 
         it("should be a new function if the scope changes", () => {
@@ -157,12 +160,13 @@ describe("#useSharedCache", () => {
 
             // Act
             wrapper.rerender({scope: "new-scope"});
-            const result1 = wrapper.result.all[wrapper.result.all.length - 2];
-            const result2 = wrapper.result.current;
+            const value1 = wrapper.result.all[wrapper.result.all.length - 2];
+            const value2 = wrapper.result.current;
+            const result1 = Array.isArray(value1) ? value1[1] : "BAD1";
+            const result2 = Array.isArray(value2) ? value2[1] : "BAD2";
 
             // Assert
-            // @ts-expect-error [FEI-5019] - TS7053 - Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'Error | [ValidCacheData | null | undefined, CacheValueFn<ValidCacheData>]'.
-            expect(result1[1]).not.toBe(result2[1]);
+            expect(result1).not.toBe(result2);
         });
 
         it("should set the value in the cache", () => {

package/src/hooks/use-cached-effect.ts

@@ -63,6 +63,12 @@ type CachedEffectOptions<TData extends ValidCacheData> = {
     scope?: string;
 };
 
+type InflightRequest<TData extends ValidCacheData> = {
+    requestId: string;
+    request: Promise<Result<TData>>;
+    cancel(): void;
+};
+
 const DefaultScope = "useCachedEffect";
 
 /**
@@ -114,19 +120,16 @@ export const useCachedEffect = <TData extends ValidCacheData>(
     const forceUpdate = useForceUpdate();
     // For the NetworkOnly fetch policy, we ignore the cached value.
     // So we need somewhere else to store the network value.
-    const networkResultRef = React.useRef();
+    const networkResultRef = React.useRef<Result<TData> | null>();
 
     // Set up the function that will do the fetching.
-    const currentRequestRef = React.useRef();
+    const currentRequestRef = React.useRef<InflightRequest<TData> | null>();
     const fetchRequest = React.useMemo(() => {
         // We aren't using useCallback here because we need to make sure that
         // if we are rememo-izing, we cancel any inflight request for the old
         // callback.
-        // @ts-expect-error [FEI-5019] - TS2339 - Property 'cancel' does not exist on type 'never'.
         currentRequestRef.current?.cancel();
-        // @ts-expect-error [FEI-5019] - TS2322 - Type 'null' is not assignable to type 'undefined'.
         currentRequestRef.current = null;
-        // @ts-expect-error [FEI-5019] - TS2322 - Type 'null' is not assignable to type 'undefined'.
         networkResultRef.current = null;
 
         const fetchFn = () => {
@@ -153,7 +156,6 @@ export const useCachedEffect = <TData extends ValidCacheData>(
                 },
             );
 
-            // @ts-expect-error [FEI-5019] - TS2339 - Property 'request' does not exist on type 'never'.
             if (request === currentRequestRef.current?.request) {
                 // The request inflight is the same, so do nothing.
                 // NOTE: Perhaps if invoked via a refetch, we will want to
@@ -162,11 +164,9 @@ export const useCachedEffect = <TData extends ValidCacheData>(
             }
 
             // Clear the last network result.
-            // @ts-expect-error [FEI-5019] - TS2322 - Type 'null' is not assignable to type 'undefined'.
             networkResultRef.current = null;
 
             // Cancel the previous request.
-            // @ts-expect-error [FEI-5019] - TS2339 - Property 'cancel' does not exist on type 'never'.
             currentRequestRef.current?.cancel();
 
             // TODO(somewhatabstract, FEI-4276):
@@ -178,7 +178,6 @@ export const useCachedEffect = <TData extends ValidCacheData>(
             // Catching shouldn't serve a purpose.
             // eslint-disable-next-line promise/catch-or-return
             request.then((result) => {
-                // @ts-expect-error [FEI-5019] - TS2322 - Type 'null' is not assignable to type 'undefined'.
                 currentRequestRef.current = null;
                 if (cancel) {
                     // We don't modify our result if the request was cancelled
@@ -189,7 +188,6 @@ export const useCachedEffect = <TData extends ValidCacheData>(
 
                 // Now we need to update the cache and notify or force a rerender.
                 setMostRecentResult(result);
-                // @ts-expect-error [FEI-5019] - TS2322 - Type 'Result<TData>' is not assignable to type 'undefined'.
                 networkResultRef.current = result;
 
                 if (onResultChanged != null) {
@@ -204,7 +202,6 @@ export const useCachedEffect = <TData extends ValidCacheData>(
                 return; // Shut up eslint always-return rule.
             });
 
-            // @ts-expect-error [FEI-5019] - TS2322 - Type '{ requestId: string; request: Promise<Result<TData>>; cancel(): void; }' is not assignable to type 'undefined'.
             currentRequestRef.current = {
                 requestId,
                 request,
@@ -265,29 +262,36 @@ export const useCachedEffect = <TData extends ValidCacheData>(
         }
         fetchRequest();
         return () => {
-            // @ts-expect-error [FEI-5019] - TS2339 - Property 'cancel' does not exist on type 'never'.
             currentRequestRef.current?.cancel();
-            // @ts-expect-error [FEI-5019] - TS2322 - Type 'null' is not assignable to type 'undefined'.
             currentRequestRef.current = null;
         };
     }, [shouldFetch, fetchRequest]);
 
     // We track the last result we returned in order to support the
-    // "retainResultOnChange" option.
-    const lastResultAgnosticOfIdRef = React.useRef(Status.loading());
+    // "retainResultOnChange" option. To begin, the last result is no-data.
+    const lastResultAgnosticOfIdRef = React.useRef<Result<TData>>(
+        Status.noData<TData>(),
+    );
+    // The default return value is:
+    // - The last result we returned if we're retaining results on change.
+    // - The no-data state if shouldFetch is false, and therefore there is no
+    //   in-flight request.
+    // - Otherwise, the loading state (we can assume there's an inflight
+    //   request if skip is not true).
     const loadingResult = retainResultOnChange
         ? lastResultAgnosticOfIdRef.current
-        : Status.loading();
+        : shouldFetch
+        ? Status.loading<TData>()
+        : Status.noData<TData>();
 
-    // Loading is a transient state, so we only use it here; it's not something
-    // we cache.
-    const result =
+    // Loading and no-data are transient states, so we only use them here;
+    // they're not something we cache.
+    const result: Result<TData> =
         (fetchPolicy === FetchPolicy.NetworkOnly
             ? networkResultRef.current
             : mostRecentResult) ?? loadingResult;
     lastResultAgnosticOfIdRef.current = result;
 
     // We return the result and a function for triggering a refetch.
-    // @ts-expect-error [FEI-5019] - TS2322 - Type '{ status: "loading"; } | { status: "error"; error: Error; } | { status: "aborted"; } | { status: "success"; data: ValidCacheData; }' is not assignable to type 'Result<TData>'.
     return [result, fetchRequest];
 };

package/src/hooks/use-gql.ts

@@ -10,6 +10,13 @@ import type {
     GqlFetchOptions,
 } from "../util/gql-types";
 
+interface GqlFetchFn<TContext extends GqlContext> {
+    <TData, TVariables extends Record<any, any>>(
+        operation: GqlOperation<TData, TVariables>,
+        options?: GqlFetchOptions<TVariables, TContext>,
+    ): Promise<TData>;
+}
+
 /**
  * Hook to obtain a gqlFetch function for performing GraphQL requests.
  *
@@ -22,10 +29,7 @@ import type {
  */
 export const useGql = <TContext extends GqlContext>(
     context: Partial<TContext> = {} as Partial<TContext>,
-): (<TData, TVariables extends Record<any, any>>(
-    operation: GqlOperation<TData, TVariables>,
-    options?: GqlFetchOptions<TVariables, TContext>,
-) => Promise<TData>) => {
+): GqlFetchFn<TContext> => {
     // This hook only works if the `GqlRouter` has been used to setup context.
     const gqlRouterContext = useGqlRouterContext(context);
 
@@ -34,22 +38,21 @@ export const useGql = <TContext extends GqlContext>(
     // we give the same function instance back to our callers instead of
     // making a new one. That then means they can safely use the return value
     // in hooks deps without fear of it triggering extra renders.
-    const gqlFetch = useCallback(
+    const gqlFetch: GqlFetchFn<TContext> = useCallback(
         <TData, TVariables extends Record<any, any>>(
             operation: GqlOperation<TData, TVariables>,
             options: GqlFetchOptions<TVariables, TContext> = Object.freeze({}),
-        ) => {
+        ): Promise<TData> => {
             const {fetch, defaultContext} = gqlRouterContext;
             const {variables, context = {}} = options;
             const finalContext = mergeGqlContext(defaultContext, context);
 
             // Invoke the fetch and extract the data.
-            return fetch(operation, variables, finalContext).then(
-                getGqlDataFromResponse,
+            return fetch(operation, variables, finalContext).then((response) =>
+                getGqlDataFromResponse<TData>(response),
             );
         },
         [gqlRouterContext],
     );
-    // @ts-expect-error [FEI-5019] - TS2322 - Type '<TData, TVariables extends Record<any, any>>(operation: GqlOperation<TData, TVariables>, options?: GqlFetchOptions<TVariables, TContext>) => Promise<unknown>' is not assignable to type '<TData, TVariables extends Record<any, any>>(operation: GqlOperation<TData, TVariables>, options?: GqlFetchOptions<TVariables, TContext> | undefined) => Promise<...>'.
     return gqlFetch;
 };

package/src/hooks/use-request-interception.ts

@@ -30,20 +30,22 @@ export const useRequestInterception = <TData extends ValidCacheData>(
     const interceptedHandler = React.useCallback((): Promise<TData> => {
         // Call the interceptors from closest to furthest.
         // If one returns a non-null result, then we keep that.
-        const interceptResponse = interceptors.reduceRight(
-            // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-            (prev, interceptor) => {
-                if (prev != null) {
-                    return prev;
-                }
-                return interceptor(requestId);
-            },
-            null,
-        );
+        const interceptResponse: Promise<TData> | null | undefined =
+            interceptors.reduceRight(
+                (prev: Promise<TData> | null | undefined, interceptor) => {
+                    if (prev != null) {
+                        return prev;
+                    }
+                    return interceptor(requestId) as
+                        | Promise<TData>
+                        | null
+                        | undefined;
+                },
+                null,
+            );
         // If nothing intercepted this request, invoke the original handler.
         // NOTE: We can't guarantee all interceptors return the same type
         // as our handler, so how can TypeScript know? Let's just suppress that.
-        // @ts-expect-error [FEI-5019] - TS2739 - Type '(requestId: string) => Promise<ValidCacheData | null | undefined> | null | undefined' is missing the following properties from type 'Promise<TData>': then, catch, finally, [Symbol.toStringTag]
         return interceptResponse ?? handler();
     }, [handler, interceptors, requestId]);
 

package/src/hooks/use-shared-cache.ts

@@ -81,8 +81,10 @@ export const useSharedCache = <TValue extends ValidCacheData>(
     // since our last run through. Also, our cache does not know what type it
     // stores, so we have to cast it to the type we're exporting. This is a
     // dev time courtesy, rather than a runtime thing.
-    // @ts-expect-error [FEI-5019] - TS2322 - Type 'ValidCacheData | null | undefined' is not assignable to type 'TValue | null | undefined'.
-    let currentValue: TValue | null | undefined = cache.get(scope, id);
+    let currentValue: TValue | null | undefined = cache.get(scope, id) as
+        | TValue
+        | null
+        | undefined;
 
     // If we have an initial value, we need to add it to the cache
     // and use it as our current value.

package/src/util/__tests__/request-api.test.ts

@@ -1,3 +1,5 @@
+// eslint-disable-next-line import/no-unassigned-import
+import "jest-extended";
 import {Server} from "@khanacademy/wonder-blocks-core";
 import {RequestFulfillment} from "../request-fulfillment";
 import {RequestTracker} from "../request-tracking";
@@ -123,7 +125,6 @@ describe("#hasTrackedRequestsToBeFetched", () => {
             const result = hasTrackedRequestsToBeFetched();
 
             // Assert
-            // @ts-expect-error [FEI-5019] - TS2339 - Property 'toBeTrue' does not exist on type 'JestMatchers<boolean>'.
             expect(result).toBeTrue();
         });
     });

package/src/util/__tests__/request-tracking.test.tsx

@@ -162,13 +162,12 @@ describe("../request-tracking.js", () => {
             it("should cache errors occurring in promises", async () => {
                 // Arrange
                 const requestTracker = createRequestTracker();
-                const fakeBadRequestHandler = () =>
+                const fakeBadRequestHandler = (): Promise<any> =>
                     new Promise((resolve: any, reject: any) =>
                         reject("OH NO!"),
                     );
                 requestTracker.trackDataRequest(
                     "ID",
-                    // @ts-expect-error [FEI-5019] - TS2345 - Argument of type '() => Promise<unknown>' is not assignable to parameter of type '() => Promise<ValidCacheData>'.
                     fakeBadRequestHandler,
                     true,
                 );
@@ -192,23 +191,22 @@ describe("../request-tracking.js", () => {
                  * - Handlers that reject the promise
                  * - Handlers that resolve
                  */
-                const fakeBadRequestHandler = () =>
+                const fakeBadRequestHandler = (): Promise<any> =>
                     new Promise((resolve: any, reject: any) =>
                         reject("OH NO!"),
                     );
-                const fakeBadHandler = () => {
+                const fakeBadHandler = (): Promise<any> => {
                     throw new Error("OH NO!");
                 };
-                const fakeValidHandler = (() => {
+                const fakeValidHandler = ((): (() => Promise<any>) => {
                     let counter = 0;
-                    return (o: any) => {
+                    return () => {
                         counter++;
                         return Promise.resolve(`DATA:${counter}`);
                     };
                 })();
                 requestTracker.trackDataRequest(
                     "BAD_REQUEST",
-                    // @ts-expect-error [FEI-5019] - TS2345 - Argument of type '() => Promise<unknown>' is not assignable to parameter of type '() => Promise<ValidCacheData>'.
                     fakeBadRequestHandler,
                     true,
                 );
@@ -219,13 +217,11 @@ describe("../request-tracking.js", () => {
                 );
                 requestTracker.trackDataRequest(
                     "VALID_HANDLER1",
-                    // @ts-expect-error [FEI-5019] - TS2345 - Argument of type '(o: any) => Promise<string>' is not assignable to parameter of type '() => Promise<string>'.
                     fakeValidHandler,
                     true,
                 );
                 requestTracker.trackDataRequest(
                     "VALID_HANDLER2",
-                    // @ts-expect-error [FEI-5019] - TS2345 - Argument of type '(o: any) => Promise<string>' is not assignable to parameter of type '() => Promise<string>'.
                     fakeValidHandler,
                     true,
                 );

package/src/util/__tests__/result-from-cache-response.test.ts

@@ -70,8 +70,8 @@ describe("#resultFromCachedResponse", () => {
         };
 
         // Act
-        // @ts-expect-error [FEI-5019] - TS2339 - Property 'error' does not exist on type 'Result<ValidCacheData> | null | undefined'.
-        const {error} = resultFromCachedResponse(cacheEntry);
+        const cacheResult = resultFromCachedResponse(cacheEntry);
+        const error = cacheResult?.status === "error" && cacheResult.error;
 
         // Assert
         expect(error).toMatchInlineSnapshot(`[HydratedDataError: ERROR]`);

package/src/util/__tests__/serializable-in-memory-cache.test.ts

@@ -9,12 +9,11 @@ describe("SerializableInMemoryCache", () => {
                 scope: {
                     key: "value",
                 },
-            } as const;
+            };
 
             // Act
             const cache = new SerializableInMemoryCache(sourceData);
             // Try to mutate the cache.
-            // @ts-expect-error [FEI-5019] - TS2540 - Cannot assign to 'scope' because it is a read-only property.
             sourceData["scope"] = {key: "SOME_NEW_DATA"};
             const result = cache.get("scope", "key");
 

package/src/util/__tests__/ssr-cache.test.ts

@@ -125,12 +125,11 @@ describe("../ssr-cache.js", () => {
             const cache = new SsrCache();
             const sourceData = {
                 MY_KEY: {data: "THE_DATA"},
-            } as const;
+            };
 
             // Act
             cache.initialize(sourceData);
             // Try to mutate the cache.
-            // @ts-expect-error [FEI-5019] - TS2540 - Cannot assign to 'MY_KEY' because it is a read-only property.
             sourceData["MY_KEY"] = {data: "SOME_NEW_DATA"};
             const result = cache.getEntry("MY_KEY");
 
@@ -448,8 +447,7 @@ describe("../ssr-cache.js", () => {
             const cloneSpy = jest
                 .spyOn(hydrationCache, "clone")
                 .mockReturnValue({
-                    // @ts-expect-error [FEI-5019] - TS2322 - Type 'string' is not assignable to type '{ [id: string]: ValidCacheData; }'.
-                    default: "CLONE!",
+                    default: "CLONE!" as any,
                 });
             const cache = new SsrCache(hydrationCache);
             // Let's add to the initialized state to check that everything

package/src/util/__tests__/to-gql-operation.test.ts

@@ -9,11 +9,10 @@ describe("#toGqlOperation", () => {
         const documentNode: any = {};
         const parserSpy = jest
             .spyOn(GDNP, "graphQLDocumentNodeParser")
-            // @ts-expect-error [FEI-5019] - TS2345 - Argument of type '{ name: string; type: string; }' is not assignable to parameter of type 'IDocumentDefinition'.
             .mockReturnValue({
                 name: "operationName",
                 type: "query",
-            });
+            } as any);
 
         // Act
         toGqlOperation(documentNode);
@@ -25,11 +24,10 @@ describe("#toGqlOperation", () => {
     it("should return the Wonder Blocks Data representation of the given document node", () => {
         // Arrange
         const documentNode: any = {};
-        // @ts-expect-error [FEI-5019] - TS2345 - Argument of type '{ name: string; type: string; }' is not assignable to parameter of type 'IDocumentDefinition'.
         jest.spyOn(GDNP, "graphQLDocumentNodeParser").mockReturnValue({
             name: "operationName",
             type: "mutation",
-        });
+        } as any);
 
         // Act
         const result = toGqlOperation(documentNode);

package/src/util/graphql-document-node-parser.ts

@@ -59,20 +59,20 @@ export function graphQLDocumentNodeParser(
 
     const queries = document.definitions.filter(
         (x: DefinitionNode) =>
-            // @ts-expect-error [FEI-5019] - TS2339 - Property 'operation' does not exist on type 'DefinitionNode'.
-            x.kind === "OperationDefinition" && x.operation === "query",
+            x.kind === "OperationDefinition" &&
+            (x as OperationDefinitionNode).operation === "query",
     );
 
     const mutations = document.definitions.filter(
         (x: DefinitionNode) =>
-            // @ts-expect-error [FEI-5019] - TS2339 - Property 'operation' does not exist on type 'DefinitionNode'.
-            x.kind === "OperationDefinition" && x.operation === "mutation",
+            x.kind === "OperationDefinition" &&
+            (x as OperationDefinitionNode).operation === "mutation",
     );
 
     const subscriptions = document.definitions.filter(
         (x: DefinitionNode) =>
-            // @ts-expect-error [FEI-5019] - TS2339 - Property 'operation' does not exist on type 'DefinitionNode'.
-            x.kind === "OperationDefinition" && x.operation === "subscription",
+            x.kind === "OperationDefinition" &&
+            (x as OperationDefinitionNode).operation === "subscription",
     );
 
     if (fragments.length && !queries.length && !mutations.length) {

package/src/util/merge-gql-context.ts

@@ -23,7 +23,8 @@ export const mergeGqlContext = <TContext extends GqlContext>(
                     delete acc[key];
                 } else {
                     // Otherwise, we set it.
-                    // @ts-expect-error [FEI-5019] - TS2536 - Type 'string' cannot be used to index type 'TContext'.
+                    // @ts-expect-error TypeScript doesn't seem to see that
+                    // TContext can have string keys.
                     acc[key] = overrides[key];
                 }
             }

package/src/util/request-tracking.ts

@@ -53,8 +53,7 @@ export class RequestTracker {
     _responseCache: SsrCache;
     _requestFulfillment: RequestFulfillment;
 
-    // @ts-expect-error [FEI-5019] - TS2322 - Type 'undefined' is not assignable to type 'SsrCache | null'.
-    constructor(responseCache: SsrCache | null = undefined) {
+    constructor(responseCache?: SsrCache | null) {
         this._responseCache = responseCache || SsrCache.Default;
         this._requestFulfillment = new RequestFulfillment();
     }
@@ -160,6 +159,11 @@ export class RequestTracker {
                                 // the code wrong. Rather than bloat
                                 // code with useless error, just ignore.
 
+                                // For status === "no-data":
+                                // Could never get here unless we wrote
+                                // the code wrong. Rather than bloat
+                                // code with useless error, just ignore.
+
                                 // For status === "aborted":
                                 // We won't cache this.
                                 // We don't hydrate aborted requests,

package/src/util/ssr-cache.ts

@@ -124,7 +124,7 @@ export class SsrCache {
             : null;
 
         // Now we defer to the SSR value, and fallback to the hydration cache.
-        const internalEntry =
+        const internalEntry: ValidCacheData | null | undefined =
             ssrEntry ?? this._hydrationCache.get(DefaultScope, id);
 
         // If we are not server-side and we hydrated something, let's clear
@@ -140,8 +140,10 @@ export class SsrCache {
         }
         // Getting the typing right between the in-memory cache and this
         // is hard. Just telling TypeScript it's OK.
-        // @ts-expect-error [FEI-5019] - TS2322 - Type 'string | number | boolean | Record<any, any> | null | undefined' is not assignable to type 'Readonly<CachedResponse<TData>> | null | undefined'.
-        return internalEntry;
+        return internalEntry as
+            | Readonly<CachedResponse<TData>>
+            | null
+            | undefined;
     };
 
     /**
@@ -161,9 +163,11 @@ export class SsrCache {
         const realPredicate = predicate
             ? // We know what we're putting into the cache so let's assume it
               // conforms.
-              // @ts-expect-error [FEI-5019] - TS7006 - Parameter 'cachedEntry' implicitly has an 'any' type.
-              (_: string, key: string, cachedEntry) =>
-                  predicate(key, cachedEntry)
+              (_: string, key: string, cachedEntry: ValidCacheData) =>
+                  predicate(
+                      key,
+                      cachedEntry as Readonly<CachedResponse<ValidCacheData>>,
+                  )
             : undefined;
 
         // Apply the predicate to what we have in our caches.
@@ -184,7 +188,6 @@ export class SsrCache {
         // to an empty object.
         // We only need the default scope out of our scoped in-memory cache.
         // We know that it conforms to our expectations.
-        // @ts-expect-error [FEI-5019] - TS2322 - Type '{ [id: string]: ValidCacheData; }' is not assignable to type 'ResponseCache'.
-        return cache[DefaultScope] ?? {};
+        return (cache[DefaultScope] as ResponseCache) ?? {};
     };
 }

package/src/util/status.ts

@@ -4,6 +4,10 @@ const loadingStatus = Object.freeze({
     status: "loading",
 });
 
+const noDataStatus = Object.freeze({
+    status: "no-data",
+});
+
 const abortedStatus = Object.freeze({
     status: "aborted",
 });
@@ -14,6 +18,8 @@ const abortedStatus = Object.freeze({
 export const Status = Object.freeze({
     loading: <TData extends ValidCacheData = ValidCacheData>(): Result<TData> =>
         loadingStatus,
+    noData: <TData extends ValidCacheData = ValidCacheData>(): Result<TData> =>
+        noDataStatus,
     aborted: <TData extends ValidCacheData = ValidCacheData>(): Result<TData> =>
         abortedStatus,
     success: <TData extends ValidCacheData>(data: TData): Result<TData> => ({