10730337621

Committed 06 Sep 2024 12:36AM UTC coverage: 31.837% (-0.02%) from 31.854%

Build # 10730337621

Build Type

Pull #9721

github

Committed by

b0b3rt

Commit Message

clean up types

Pull Request Pull Request #9721: Llm chat post drafts

Run Details

5025 of 41223 branches covered (12.19%)

Branch coverage included in aggregate %.

25 of 76 new or added lines in 15 files covered. (32.89%)

34 existing lines in 5 files now uncovered.

29359 of 66777 relevant lines covered (43.97%)

187.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.62

/packages/lesswrong/lib/crud/withSingle.ts

import { ApolloClient, NormalizedCacheObject, ApolloError, gql, useQuery, WatchQueryFetchPolicy } from '@apollo/client';
import * as _ from 'underscore';
import { extractFragmentInfo } from '../vulcan-lib/handleOptions';
import { collectionNameToTypeName } from '../vulcan-lib/getCollection';
import { camelCaseify } from '../vulcan-lib/utils';
import { apolloSSRFlag } from '../helpers';
import { PrimitiveGraphQLType } from './types';

// Template of a GraphQL query for useSingle. A sample query might look
// like:
//
// query singleMovieQuery($input: SingleMovieInput) {
//   movie(input: $input) {
//     result {
//       _id
//       name
//       __typename
//     }
//     __typename
//   }
// }
const singleClientTemplate = ({ typeName, fragmentName, extraVariablesString }: {
  typeName: string,
  fragmentName: FragmentName,
  extraVariablesString: string,
}) =>
`query single${typeName}Query($input: Single${typeName}Input, ${extraVariablesString || ''}) {
  ${camelCaseify(typeName)}(input: $input) {
    result {
      ...${fragmentName}
    }
    __typename
  }
}`;

/**
 * Given terms/etc for a useSingle query, generate corresponding GraphQL. Exported
 * for use in crossposting-related integrations. You probably don't want to use
 * this directly; in most cases you should use the useSingle hook instead.
 */
export function getGraphQLSingleQueryFromOptions({ collectionName, fragment, fragmentName, extraVariables }: {
  collectionName: CollectionNameString,
  fragment: any,
  fragmentName: FragmentName|undefined,
  extraVariables?: Record<string, PrimitiveGraphQLType>,
}) {
  ({ fragmentName, fragment } = extractFragmentInfo({ fragment, fragmentName }, collectionName));
  const typeName = collectionNameToTypeName(collectionName);

  // LESSWRONG MODIFICATION: Allow the passing of extraVariables so that you can have field-specific queries
  let extraVariablesString = ''
  if (extraVariables) {
    extraVariablesString = Object.keys(extraVariables).map(k => `$${k}: ${extraVariables[k]}`).join(', ')
  }

  const query = gql`
    ${singleClientTemplate({ typeName, fragmentName, extraVariablesString })}
    ${fragment}
  `;
  
  return query
}

/**
 * Get the name of the GraphQL resolver to use for useSingle on a collection
 * (which is the type name, camel-caseified). Note that this functino might not
 * be getting used everywhere that uses the resolver name, and the resolver name
 * is part of the API given to external sites like GreaterWrong, so this should
 * not be changed.
 */
export function getResolverNameFromOptions(collectionName: CollectionNameString): string {
  const typeName = collectionNameToTypeName(collectionName);
  return camelCaseify(typeName);
}

type TSuccessReturn<FragmentTypeName extends keyof FragmentTypes> = {loading: false, error: undefined, document: FragmentTypes[FragmentTypeName]};
type TErrorReturn = {loading: false, error: ApolloError, document: undefined};
type TLoadingReturn = {loading: true, error: undefined, document: undefined};

type TReturn<FragmentTypeName extends keyof FragmentTypes> = (TSuccessReturn<FragmentTypeName> | TErrorReturn | TLoadingReturn) & {
  refetch: any,
  networkStatus?: number,
  data?: {
    refetch: any,
  }
}

// You can pass either `documentId` or `slug`, but not both. The must pass one;
// you pass undefined, in which case the query is skipped.
export type DocumentIdOrSlug =
   {documentId: string|undefined, slug?: never}
  |{slug: string|undefined, documentId?: never};

export type UseSingleProps<FragmentTypeName extends keyof FragmentTypes> = (
  DocumentIdOrSlug & {
    collectionName: CollectionNameString,
    fragmentName?: FragmentTypeName,
    fragment?: any,
    extraVariables?: Record<string,any>,
    extraVariablesValues?: any,
    fetchPolicy?: WatchQueryFetchPolicy,
    nextFetchPolicy?: WatchQueryFetchPolicy,
    notifyOnNetworkStatusChange?: boolean,
    allowNull?: boolean,
    skip?: boolean,
    ssr?: boolean,
    /**
     * Optional Apollo client instance to use for this request. If not provided,
     * uses the default client provided by React context. This should only be
     * overriden for crossposting or similar foreign-DB operations.
     */
    apolloClient?: ApolloClient<NormalizedCacheObject>,
  }
);

/**
 * React hook that queries a collection, returning a single document with the
 * given ID, along with metadata about loading status and errors.
 *
 * In most cases, you will provide a documentId, collectionName, and
 * fragmentName. If any resolvers in the fragment have arguments attached, you
 * will also need to pass `extraVariables`, which contains the GraphQL types
 * of those arguments, and extraVariablesValues, which contains their values.
 */
export function useSingle<FragmentTypeName extends keyof FragmentTypes>({
  documentId, slug,
  collectionName,
  fragmentName, fragment,
  extraVariables,
  extraVariablesValues,
  fetchPolicy,
  nextFetchPolicy,
  notifyOnNetworkStatusChange,
  allowNull,
  skip=false,
  ssr=true,
  apolloClient,
}: UseSingleProps<FragmentTypeName>): TReturn<FragmentTypeName> {
  const query = getGraphQLSingleQueryFromOptions({ extraVariables, collectionName, fragment, fragmentName })
  const resolverName = getResolverNameFromOptions(collectionName)
  // TODO: Properly type this generic query
  const { data, error, ...rest } = useQuery(query, {
    variables: {
      input: {
        selector: { documentId, slug },
        resolverArgs: extraVariablesValues,
        ...(allowNull && {allowNull: true})
      },
      ...extraVariablesValues,
    },
    fetchPolicy,
    nextFetchPolicy,
    notifyOnNetworkStatusChange,
    ssr: apolloSSRFlag(ssr),
    skip: skip || (!documentId && !slug),
    client: apolloClient,
  })
  if (error) {
    // This error was already caught by the apollo middleware, but the
    // middleware had no idea who  made the query. To aid in debugging, log a
    // stack trace here.
    // eslint-disable-next-line no-console
    console.error(error.message)
  }
  const document: FragmentTypes[FragmentTypeName] | undefined = data && data[resolverName] && data[resolverName].result
  // TS can't deduce that either the document or the error are set and thus loading is inferred to be of type boolean always (instead of either true or false)
  return { document, data, error, ...rest } as TReturn<FragmentTypeName>
}

1	import { ApolloClient, NormalizedCacheObject, ApolloError, gql, useQuery, WatchQueryFetchPolicy } from '@apollo/client';	66✔
2	import * as _ from 'underscore';
3	import { extractFragmentInfo } from '../vulcan-lib/handleOptions';	20✔
4	import { collectionNameToTypeName } from '../vulcan-lib/getCollection';	20✔
5	import { camelCaseify } from '../vulcan-lib/utils';	20✔
6	import { apolloSSRFlag } from '../helpers';	20✔
7	import { PrimitiveGraphQLType } from './types';
8
9	// Template of a GraphQL query for useSingle. A sample query might look
10	// like:
11	//
12	// query singleMovieQuery($input: SingleMovieInput) {
13	// movie(input: $input) {
14	// result {
15	// _id
16	// name
17	// __typename
18	// }
19	// __typename
20	// }
21	// }
22	const singleClientTemplate = ({ typeName, fragmentName, extraVariablesString }: {	20✔
23	typeName: string,
24	fragmentName: FragmentName,
25	extraVariablesString: string,
26	}) =>
27	`query single${typeName}Query($input: Single${typeName}Input, ${extraVariablesString \|\| ''}) {	6!
28	${camelCaseify(typeName)}(input: $input) {
29	result {
30	...${fragmentName}
31	}
32	__typename
33	}
34	}`;
35
36	/**
37	* Given terms/etc for a useSingle query, generate corresponding GraphQL. Exported
38	* for use in crossposting-related integrations. You probably don't want to use
39	* this directly; in most cases you should use the useSingle hook instead.
40	*/
41	export function getGraphQLSingleQueryFromOptions({ collectionName, fragment, fragmentName, extraVariables }: {
42	collectionName: CollectionNameString,
43	fragment: any,
44	fragmentName: FragmentName\|undefined,
45	extraVariables?: Record<string, PrimitiveGraphQLType>,
46	}) {
47	({ fragmentName, fragment } = extractFragmentInfo({ fragment, fragmentName }, collectionName));	6✔
48	const typeName = collectionNameToTypeName(collectionName);	6✔
49
50	// LESSWRONG MODIFICATION: Allow the passing of extraVariables so that you can have field-specific queries
51	let extraVariablesString = ''	6✔
52	if (extraVariables) {	6!
53	extraVariablesString = Object.keys(extraVariables).map(k => `$${k}: ${extraVariables[k]}`).join(', ')	6✔
54	}
55
56	const query = gql`	6✔
57	${singleClientTemplate({ typeName, fragmentName, extraVariablesString })}
58	${fragment}
59	`;
60
61	return query	6✔
62	}
63
64	/**
65	* Get the name of the GraphQL resolver to use for useSingle on a collection
66	* (which is the type name, camel-caseified). Note that this functino might not
67	* be getting used everywhere that uses the resolver name, and the resolver name
68	* is part of the API given to external sites like GreaterWrong, so this should
69	* not be changed.
70	*/
71	export function getResolverNameFromOptions(collectionName: CollectionNameString): string {
72	const typeName = collectionNameToTypeName(collectionName);	6✔
73	return camelCaseify(typeName);	6✔
74	}
75
76	type TSuccessReturn<FragmentTypeName extends keyof FragmentTypes> = {loading: false, error: undefined, document: FragmentTypes[FragmentTypeName]};
77	type TErrorReturn = {loading: false, error: ApolloError, document: undefined};
78	type TLoadingReturn = {loading: true, error: undefined, document: undefined};
79
80	type TReturn<FragmentTypeName extends keyof FragmentTypes> = (TSuccessReturn<FragmentTypeName> \| TErrorReturn \| TLoadingReturn) & {
81	refetch: any,
82	networkStatus?: number,
83	data?: {
84	refetch: any,
85	}
86	}
87
88	// You can pass either `documentId` or `slug`, but not both. The must pass one;
89	// you pass undefined, in which case the query is skipped.
90	export type DocumentIdOrSlug =
91	{documentId: string\|undefined, slug?: never}
92	\|{slug: string\|undefined, documentId?: never};
93
94	export type UseSingleProps<FragmentTypeName extends keyof FragmentTypes> = (
95	DocumentIdOrSlug & {
96	collectionName: CollectionNameString,
97	fragmentName?: FragmentTypeName,
98	fragment?: any,
99	extraVariables?: Record<string,any>,
100	extraVariablesValues?: any,
101	fetchPolicy?: WatchQueryFetchPolicy,
102	nextFetchPolicy?: WatchQueryFetchPolicy,
103	notifyOnNetworkStatusChange?: boolean,
104	allowNull?: boolean,
105	skip?: boolean,
106	ssr?: boolean,
107	/**
108	* Optional Apollo client instance to use for this request. If not provided,
109	* uses the default client provided by React context. This should only be
110	* overriden for crossposting or similar foreign-DB operations.
111	*/
112	apolloClient?: ApolloClient<NormalizedCacheObject>,
113	}
114	);
115
116	/**
117	* React hook that queries a collection, returning a single document with the
118	* given ID, along with metadata about loading status and errors.
119	*
120	* In most cases, you will provide a documentId, collectionName, and
121	* fragmentName. If any resolvers in the fragment have arguments attached, you
122	* will also need to pass `extraVariables`, which contains the GraphQL types
123	* of those arguments, and extraVariablesValues, which contains their values.
124	*/
125	export function useSingle<FragmentTypeName extends keyof FragmentTypes>({
126	documentId, slug,
127	collectionName,
128	fragmentName, fragment,
129	extraVariables,
130	extraVariablesValues,
131	fetchPolicy,
132	nextFetchPolicy,
133	notifyOnNetworkStatusChange,
134	allowNull,
135	skip=false,	6✔
136	ssr=true,	6✔
137	apolloClient,
138	}: UseSingleProps<FragmentTypeName>): TReturn<FragmentTypeName> {
139	const query = getGraphQLSingleQueryFromOptions({ extraVariables, collectionName, fragment, fragmentName })	6✔
140	const resolverName = getResolverNameFromOptions(collectionName)	6✔
141	// TODO: Properly type this generic query
142	const { data, error, ...rest } = useQuery(query, {	6✔
143	variables: {
144	input: {
145	selector: { documentId, slug },
146	resolverArgs: extraVariablesValues,
147	...(allowNull && {allowNull: true})	6!
148	},
149	...extraVariablesValues,
150	},
151	fetchPolicy,
152	nextFetchPolicy,
153	notifyOnNetworkStatusChange,
154	ssr: apolloSSRFlag(ssr),
155	skip: skip \|\| (!documentId && !slug),	12!
156	client: apolloClient,
157	})
158	if (error) {	6!
159	// This error was already caught by the apollo middleware, but the
160	// middleware had no idea who made the query. To aid in debugging, log a
161	// stack trace here.
162	// eslint-disable-next-line no-console
UNCOV 163	console.error(error.message)	×
164	}
165	const document: FragmentTypes[FragmentTypeName] \| undefined = data && data[resolverName] && data[resolverName].result	6✔
166	// TS can't deduce that either the document or the error are set and thus loading is inferred to be of type boolean always (instead of either true or false)
167	return { document, data, error, ...rest } as TReturn<FragmentTypeName>	6✔
168	}

ForumMagnum / ForumMagnum / 10730337621

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous