@isograph/react 0.4.3 → 0.5.1

package/src/react/LoadableFieldRenderer.tsx

@@ -1,33 +1,49 @@
 import * as React from 'react';
 import { type FetchOptions } from '../core/check';
-import {
-  ExtractParameters,
-  type UnknownTReadFromStore,
-} from '../core/FragmentReference';
+import type { ExtractParameters } from '../core/FragmentReference';
+import { type UnknownTReadFromStore } from '../core/FragmentReference';
 import { type NetworkRequestReaderOptions } from '../core/read';
 import { type LoadableField } from '../core/reader';
 import { useClientSideDefer } from '../loadable-hooks/useClientSideDefer';
 import { useResult } from './useResult';
 
+type ArgsWithoutProvidedArgs<
+  TReadFromStore extends UnknownTReadFromStore,
+  TProvidedArgs extends object,
+> = Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>;
+
+type MaybeRequiredArgs<
+  TReadFromStore extends UnknownTReadFromStore,
+  TProvidedArgs extends object,
+> =
+  {} extends ArgsWithoutProvidedArgs<TReadFromStore, TProvidedArgs>
+    ? {
+        args?: ArgsWithoutProvidedArgs<TReadFromStore, TProvidedArgs>;
+      }
+    : {
+        args: ArgsWithoutProvidedArgs<TReadFromStore, TProvidedArgs>;
+      };
+
 export function LoadableFieldRenderer<
   TReadFromStore extends UnknownTReadFromStore,
   TProvidedArgs extends object,
   TChildrenResult,
   TProps,
->(props: {
-  loadableField: LoadableField<
-    TReadFromStore,
-    React.FC<TProps>,
-    Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>
-  >;
-  // TODO we can improve this to not require args if its an empty object
-  args: Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>;
-  fetchOptions?: FetchOptions<React.FC<TProps>>;
-  networkRequestOptions?: Partial<NetworkRequestReaderOptions>;
-  additionalProps: Omit<TProps, keyof JSX.IntrinsicAttributes>;
-}): TChildrenResult {
+>(
+  props: {
+    loadableField: LoadableField<
+      TReadFromStore,
+      React.FC<TProps>,
+      Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>
+    >;
+    fetchOptions?: FetchOptions<React.FC<TProps>, never>;
+    networkRequestOptions?: Partial<NetworkRequestReaderOptions>;
+    additionalProps: Omit<TProps, keyof JSX.IntrinsicAttributes>;
+  } & MaybeRequiredArgs<TReadFromStore, TProvidedArgs>,
+): TChildrenResult {
   const { fragmentReference } = useClientSideDefer(
     props.loadableField,
+    // @ts-expect-error
     props.args,
     props.fetchOptions,
   );
@@ -39,3 +55,95 @@ export function LoadableFieldRenderer<
   // @ts-expect-error
   return <Component {...props.additionalProps} />;
 }
+
+// @ts-ignore
+function tsTests() {
+  let neverArgs!: LoadableField<
+    {
+      parameters: Record<string, never>;
+      data: {};
+    },
+    () => React.ReactNode
+  >;
+
+  let optionalArgs!: LoadableField<
+    {
+      parameters: {
+        foo?: string;
+      };
+      data: {};
+    },
+    () => React.ReactNode
+  >;
+
+  let requiredArgs!: LoadableField<
+    {
+      parameters: {
+        foo: string;
+      };
+      data: {};
+    },
+    () => React.ReactNode
+  >;
+
+  <LoadableFieldRenderer loadableField={neverArgs} additionalProps={{}} />;
+  <LoadableFieldRenderer
+    loadableField={neverArgs}
+    additionalProps={{}}
+    args={{}}
+  />;
+  <LoadableFieldRenderer
+    loadableField={neverArgs}
+    additionalProps={{}}
+    args={{
+      // @ts-expect-error
+      foo: 'bar',
+    }}
+  />;
+
+  <LoadableFieldRenderer loadableField={optionalArgs} additionalProps={{}} />;
+  <LoadableFieldRenderer
+    loadableField={optionalArgs}
+    additionalProps={{}}
+    args={{}}
+  />;
+  <LoadableFieldRenderer
+    loadableField={optionalArgs}
+    additionalProps={{}}
+    args={{
+      foo: 'bar',
+    }}
+  />;
+  <LoadableFieldRenderer
+    loadableField={optionalArgs}
+    additionalProps={{}}
+    args={{
+      // @ts-expect-error
+      foo: 12,
+    }}
+  />;
+
+  // @ts-expect-error
+  <LoadableFieldRenderer loadableField={requiredArgs} additionalProps={{}} />;
+  <LoadableFieldRenderer
+    loadableField={requiredArgs}
+    additionalProps={{}}
+    // @ts-expect-error
+    args={{}}
+  />;
+  <LoadableFieldRenderer
+    loadableField={requiredArgs}
+    additionalProps={{}}
+    args={{
+      foo: 'bar',
+    }}
+  />;
+  <LoadableFieldRenderer
+    loadableField={requiredArgs}
+    additionalProps={{}}
+    args={{
+      // @ts-expect-error
+      foo: 12,
+    }}
+  />;
+}

package/src/react/createIsographEnvironment.ts

@@ -0,0 +1,23 @@
+import {
+  createIsographEnvironmentCore,
+  type BaseStoreLayerData,
+  type IsographNetworkFunction,
+  type MissingFieldHandler,
+} from '../core/IsographEnvironment';
+import type { LogFunction } from '../core/logging';
+import { componentFunction } from './useReadAndSubscribe';
+
+export function createIsographEnvironment(
+  baseStoreLayerData: BaseStoreLayerData,
+  networkFunction: IsographNetworkFunction,
+  missingFieldHandler?: MissingFieldHandler | null,
+  logFunction?: LogFunction | null,
+) {
+  return createIsographEnvironmentCore(
+    baseStoreLayerData,
+    networkFunction,
+    componentFunction,
+    missingFieldHandler,
+    logFunction,
+  );
+}

package/src/react/maybeUnwrapNetworkRequest.ts

@@ -0,0 +1,17 @@
+import { type PromiseWrapper, getPromiseState } from '../core/PromiseWrapper';
+import type { NetworkRequestReaderOptions } from '../core/read';
+
+export function maybeUnwrapNetworkRequest(
+  networkRequest: PromiseWrapper<void, any>,
+  networkRequestOptions: NetworkRequestReaderOptions,
+) {
+  const state = getPromiseState(networkRequest);
+  if (state.kind === 'Err' && networkRequestOptions.throwOnNetworkError) {
+    throw state.error;
+  } else if (
+    state.kind === 'Pending' &&
+    networkRequestOptions.suspendIfInFlight
+  ) {
+    throw state.promise;
+  }
+}

package/src/react/useImperativeReference.ts

@@ -2,26 +2,31 @@ import {
   UNASSIGNED_STATE,
   useUpdatableDisposableState,
 } from '@isograph/react-disposable-state';
-import { FetchOptions, type RequiredFetchOptions } from '../core/check';
+import type { NetworkResponseObject } from '../core/cache';
+import type { FetchOptions } from '../core/check';
+import { type RequiredFetchOptions } from '../core/check';
+import type { IsographEntrypoint } from '../core/entrypoint';
 import {
-  IsographEntrypoint,
   type NormalizationAst,
   type NormalizationAstLoader,
 } from '../core/entrypoint';
-import {
+import type {
   ExtractParameters,
   FragmentReference,
-  type UnknownTReadFromStore,
 } from '../core/FragmentReference';
-import { ROOT_ID } from '../core/IsographEnvironment';
+import { type UnknownTReadFromStore } from '../core/FragmentReference';
+import {
+  getOrLoadReaderWithRefetchQueries,
+  ROOT_ID,
+} from '../core/IsographEnvironment';
 import { maybeMakeNetworkRequest } from '../core/makeNetworkRequest';
-import { wrapPromise, wrapResolvedValue } from '../core/PromiseWrapper';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
 
 export type UseImperativeReferenceResult<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType,
 > = {
   fragmentReference: FragmentReference<
     TReadFromStore,
@@ -31,7 +36,7 @@ export type UseImperativeReferenceResult<
     variables: ExtractParameters<TReadFromStore>,
     ...[fetchOptions]: NormalizationAstLoader extends TNormalizationAst
       ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>]
-      : [fetchOptions?: FetchOptions<TClientFieldValue>]
+      : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]
   ) => void;
 };
 
@@ -39,16 +44,19 @@ export function useImperativeReference<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
   entrypoint: IsographEntrypoint<
     TReadFromStore,
     TClientFieldValue,
-    TNormalizationAst
+    TNormalizationAst,
+    TRawResponseType
   >,
 ): UseImperativeReferenceResult<
   TReadFromStore,
   TClientFieldValue,
-  TNormalizationAst
+  TNormalizationAst,
+  TRawResponseType
 > {
   const { state, setState } =
     useUpdatableDisposableState<
@@ -59,13 +67,13 @@ export function useImperativeReference<
     fragmentReference: state !== UNASSIGNED_STATE ? state : null,
     loadFragmentReference: (
       variables: ExtractParameters<TReadFromStore>,
-      fetchOptions?: FetchOptions<TClientFieldValue>,
+      fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>,
     ) => {
-      const readerWithRefetchQueries =
-        entrypoint.readerWithRefetchQueries.kind ===
-        'ReaderWithRefetchQueriesLoader'
-          ? wrapPromise(entrypoint.readerWithRefetchQueries.loader())
-          : wrapResolvedValue(entrypoint.readerWithRefetchQueries);
+      const { fieldName, readerArtifactKind, readerWithRefetchQueries } =
+        getOrLoadReaderWithRefetchQueries(
+          environment,
+          entrypoint.readerWithRefetchQueries,
+        );
       const [networkRequest, disposeNetworkRequest] = maybeMakeNetworkRequest(
         environment,
         entrypoint,
@@ -77,6 +85,8 @@ export function useImperativeReference<
         {
           kind: 'FragmentReference',
           readerWithRefetchQueries,
+          fieldName,
+          readerArtifactKind,
           root: { __link: ROOT_ID, __typename: entrypoint.concreteType },
           variables,
           networkRequest,

package/src/react/useLazyReference.ts

@@ -1,33 +1,37 @@
 import { useLazyDisposableState } from '@isograph/react-disposable-state';
-import { getOrCreateCacheForArtifact } from '../core/cache';
-import { FetchOptions, type RequiredFetchOptions } from '../core/check';
+import { type NetworkResponseObject } from '../core/cache';
+import type { FetchOptions } from '../core/check';
+import { type RequiredFetchOptions } from '../core/check';
+import type { IsographEntrypoint } from '../core/entrypoint';
 import {
-  IsographEntrypoint,
   type NormalizationAst,
   type NormalizationAstLoader,
 } from '../core/entrypoint';
-import {
+import type {
   ExtractParameters,
   FragmentReference,
-  type UnknownTReadFromStore,
 } from '../core/FragmentReference';
+import { type UnknownTReadFromStore } from '../core/FragmentReference';
 import { logMessage } from '../core/logging';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
+import { getOrCreateCacheForArtifact } from '../core/getOrCreateCacheForArtifact';
 
 export function useLazyReference<
   TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TNormalizationAst extends NormalizationAst | NormalizationAstLoader,
+  TRawResponseType extends NetworkResponseObject,
 >(
   entrypoint: IsographEntrypoint<
     TReadFromStore,
     TClientFieldValue,
-    TNormalizationAst
+    TNormalizationAst,
+    TRawResponseType
   >,
   variables: ExtractParameters<TReadFromStore>,
   ...[fetchOptions]: TNormalizationAst extends NormalizationAstLoader
     ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>]
-    : [fetchOptions?: FetchOptions<TClientFieldValue>]
+    : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]
 ): NormalizationAst | NormalizationAstLoader extends TNormalizationAst
   ? unknown
   : {
@@ -57,12 +61,18 @@ export function useLazyReference<
 
 // @ts-ignore
 function tsTests() {
-  let withAst!: IsographEntrypoint<any, unknown, NormalizationAst>;
-  let withAstLoader!: IsographEntrypoint<any, unknown, NormalizationAstLoader>;
+  let withAst!: IsographEntrypoint<any, unknown, NormalizationAst, any>;
+  let withAstLoader!: IsographEntrypoint<
+    any,
+    unknown,
+    NormalizationAstLoader,
+    {}
+  >;
   let withAstOrLoader!: IsographEntrypoint<
     any,
     unknown,
-    NormalizationAst | NormalizationAstLoader
+    NormalizationAst | NormalizationAstLoader,
+    {}
   >;
 
   useLazyReference(withAst, {}) satisfies {};

package/src/react/useReadAndSubscribe.ts

@@ -1,19 +1,22 @@
 import { useEffect, useState } from 'react';
-import { subscribe } from '../core/cache';
 import {
-  ExtractData,
-  FragmentReference,
+  type ExtractData,
+  type FragmentReference,
   stableIdForFragmentReference,
   type UnknownTReadFromStore,
 } from '../core/FragmentReference';
+import type { IsographComponentFunction } from '../core/IsographEnvironment';
+import { logMessage } from '../core/logging';
 import { readPromise } from '../core/PromiseWrapper';
 import {
-  NetworkRequestReaderOptions,
+  type NetworkRequestReaderOptions,
   readButDoNotEvaluate,
-  WithEncounteredRecords,
+  type WithEncounteredRecords,
 } from '../core/read';
 import type { ReaderAst } from '../core/reader';
+import { subscribe } from '../core/subscribe';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
+import { maybeUnwrapNetworkRequest } from './maybeUnwrapNetworkRequest';
 import { useRerenderOnChange } from './useRerenderOnChange';
 
 /**
@@ -75,15 +78,53 @@ export function useSubscribeToMultiple<
     [
       items
         .map(({ fragmentReference }) => {
-          const readerWithRefetchQueries = readPromise(
-            fragmentReference.readerWithRefetchQueries,
-          );
-          stableIdForFragmentReference(
-            fragmentReference,
-            readerWithRefetchQueries.readerArtifact.fieldName,
-          );
+          stableIdForFragmentReference(fragmentReference);
         })
         .join('.'),
     ],
   );
 }
+
+export const componentFunction: IsographComponentFunction = (
+  environment,
+  fragmentReference,
+  networkRequestOptions,
+  startUpdate,
+) => {
+  function Component(additionalRuntimeProps: { [key: string]: any }) {
+    maybeUnwrapNetworkRequest(
+      fragmentReference.networkRequest,
+      networkRequestOptions,
+    );
+    const readerWithRefetchQueries = readPromise(
+      fragmentReference.readerWithRefetchQueries,
+    );
+
+    const data = useReadAndSubscribe(
+      fragmentReference,
+      networkRequestOptions,
+      readerWithRefetchQueries.readerArtifact.readerAst,
+    );
+
+    logMessage(environment, () => ({
+      kind: 'ComponentRerendered',
+      componentName: fragmentReference.fieldName,
+      rootLink: fragmentReference.root,
+    }));
+
+    return readerWithRefetchQueries.readerArtifact.resolver(
+      // @ts-expect-error
+      {
+        data,
+        parameters: fragmentReference.variables,
+        startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable
+          ? startUpdate
+          : undefined,
+      },
+      additionalRuntimeProps,
+    );
+  }
+  const idString = `(type: ${fragmentReference.root.__typename}, id: ${fragmentReference.root.__link})`;
+  Component.displayName = `${fragmentReference.fieldName} ${idString} @component`;
+  return Component;
+};

package/src/react/useRerenderOnChange.ts

@@ -1,8 +1,8 @@
 import { useEffect } from 'react';
-import { subscribe } from '../core/cache';
-import { FragmentReference } from '../core/FragmentReference';
-import { WithEncounteredRecords } from '../core/read';
+import type { FragmentReference } from '../core/FragmentReference';
+import type { WithEncounteredRecords } from '../core/read';
 import type { ReaderAst } from '../core/reader';
+import { subscribe } from '../core/subscribe';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
 
 // TODO add unit tests for this. Add integration tests that test

package/src/react/useResult.ts

@@ -1,19 +1,16 @@
 import { getOrCreateCachedComponent } from '../core/componentCache';
-import {
+import type {
   FragmentReference,
-  type UnknownTReadFromStore,
+  UnknownTReadFromStore,
 } from '../core/FragmentReference';
+import { readPromise } from '../core/PromiseWrapper';
 import {
-  getPromiseState,
-  PromiseWrapper,
-  readPromise,
-} from '../core/PromiseWrapper';
-import {
+  type NetworkRequestReaderOptions,
   getNetworkRequestOptionsWithDefaults,
-  NetworkRequestReaderOptions,
 } from '../core/read';
 import { getOrCreateCachedStartUpdate } from '../core/startUpdate';
-import { useIsographEnvironment } from '../react/IsographEnvironmentProvider';
+import { useIsographEnvironment } from './IsographEnvironmentProvider';
+import { maybeUnwrapNetworkRequest } from './maybeUnwrapNetworkRequest';
 import { useReadAndSubscribe } from './useReadAndSubscribe';
 
 export function useResult<
@@ -28,25 +25,23 @@ export function useResult<
     partialNetworkRequestOptions,
   );
 
-  maybeUnwrapNetworkRequest(
-    fragmentReference.networkRequest,
-    networkRequestOptions,
-  );
-  const readerWithRefetchQueries = readPromise(
-    fragmentReference.readerWithRefetchQueries,
-  );
-
-  switch (readerWithRefetchQueries.readerArtifact.kind) {
+  switch (fragmentReference.readerArtifactKind) {
     case 'ComponentReaderArtifact': {
       // @ts-expect-error
       return getOrCreateCachedComponent(
         environment,
-        readerWithRefetchQueries.readerArtifact.fieldName,
         fragmentReference,
         networkRequestOptions,
       );
     }
     case 'EagerReaderArtifact': {
+      maybeUnwrapNetworkRequest(
+        fragmentReference.networkRequest,
+        networkRequestOptions,
+      );
+      const readerWithRefetchQueries = readPromise(
+        fragmentReference.readerWithRefetchQueries,
+      );
       const data = useReadAndSubscribe(
         fragmentReference,
         networkRequestOptions,
@@ -60,28 +55,13 @@ export function useResult<
               startUpdate: getOrCreateCachedStartUpdate(
                 environment,
                 fragmentReference,
-                readerWithRefetchQueries.readerArtifact.fieldName,
                 networkRequestOptions,
               ),
             }
           : undefined),
       };
+      // @ts-expect-error
       return readerWithRefetchQueries.readerArtifact.resolver(param);
     }
   }
 }
-
-export function maybeUnwrapNetworkRequest(
-  networkRequest: PromiseWrapper<void, any>,
-  networkRequestOptions: NetworkRequestReaderOptions,
-) {
-  const state = getPromiseState(networkRequest);
-  if (state.kind === 'Err' && networkRequestOptions.throwOnNetworkError) {
-    throw state.error;
-  } else if (
-    state.kind === 'Pending' &&
-    networkRequestOptions.suspendIfInFlight
-  ) {
-    throw state.promise;
-  }
-}

package/src/tests/__isograph/Node/asEconomist/resolver_reader.ts

@@ -19,7 +19,7 @@ const artifact: EagerReaderArtifact<
   Link<"Economist"> | null
 > = {
   kind: "EagerReaderArtifact",
-  fieldName: "Node.asEconomist",
+  fieldName: "asEconomist",
   resolver: ({ data }) => data.__typename === "Economist" ? data.__link : null,
   readerAst,
   hasUpdatable: false,

package/src/tests/__isograph/Query/linkedUpdate/entrypoint.ts

@@ -1,6 +1,7 @@
 import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__linkedUpdate__param} from './param_type';
 import {Query__linkedUpdate__output_type} from './output_type';
+import type {Query__linkedUpdate__raw_response_type} from './raw_response_type';
 import readerResolver from './resolver_reader';
 import queryText from './query_text';
 import normalizationAst from './normalization_ast';
@@ -9,7 +10,8 @@ const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 const artifact: IsographEntrypoint<
   Query__linkedUpdate__param,
   Query__linkedUpdate__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__linkedUpdate__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {

package/src/tests/__isograph/Query/linkedUpdate/raw_response_type.ts

@@ -0,0 +1,13 @@
+export type Query__linkedUpdate__raw_response_type = {
+  node____id___l_0?: ({
+    __typename: "Economist",
+    id: string,
+    name: string,
+  } | null),
+  node____id___l_1?: ({
+    __typename: "Economist",
+    id: string,
+    name: string,
+  } | null),
+}
+

package/src/tests/__isograph/Query/linkedUpdate/resolver_reader.ts

@@ -84,7 +84,7 @@ const artifact: EagerReaderArtifact<
   Query__linkedUpdate__output_type
 > = {
   kind: "EagerReaderArtifact",
-  fieldName: "Query.linkedUpdate",
+  fieldName: "linkedUpdate",
   resolver,
   readerAst,
   hasUpdatable: true,

package/src/tests/__isograph/Query/meName/entrypoint.ts

@@ -1,6 +1,7 @@
 import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__meName__param} from './param_type';
 import {Query__meName__output_type} from './output_type';
+import type {Query__meName__raw_response_type} from './raw_response_type';
 import readerResolver from './resolver_reader';
 import queryText from './query_text';
 import normalizationAst from './normalization_ast';
@@ -9,7 +10,8 @@ const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 const artifact: IsographEntrypoint<
   Query__meName__param,
   Query__meName__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__meName__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {

package/src/tests/__isograph/Query/meName/raw_response_type.ts

@@ -0,0 +1,7 @@
+export type Query__meName__raw_response_type = {
+  me: {
+    id: string,
+    name: string,
+  },
+}
+

package/src/tests/__isograph/Query/meName/resolver_reader.ts

@@ -29,7 +29,7 @@ const artifact: EagerReaderArtifact<
   Query__meName__output_type
 > = {
   kind: "EagerReaderArtifact",
-  fieldName: "Query.meName",
+  fieldName: "meName",
   resolver,
   readerAst,
   hasUpdatable: false,

package/src/tests/__isograph/Query/meNameSuccessor/entrypoint.ts

@@ -1,6 +1,7 @@
 import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__meNameSuccessor__param} from './param_type';
 import {Query__meNameSuccessor__output_type} from './output_type';
+import type {Query__meNameSuccessor__raw_response_type} from './raw_response_type';
 import readerResolver from './resolver_reader';
 import queryText from './query_text';
 import normalizationAst from './normalization_ast';
@@ -9,7 +10,8 @@ const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 const artifact: IsographEntrypoint<
   Query__meNameSuccessor__param,
   Query__meNameSuccessor__output_type,
-  NormalizationAst
+  NormalizationAst,
+  Query__meNameSuccessor__raw_response_type
 > = {
   kind: "Entrypoint",
   networkRequestInfo: {