10731053370

Committed 06 Sep 2024 01:52AM UTC coverage: 31.835% (-0.02%) from 31.854%

Build # 10731053370

Build Type

Pull #9721

github

Committed by

b0b3rt

Commit Message

some prompt adjustments for the possibility the user is editing a post

Pull Request Pull Request #9721: Llm chat post drafts

Run Details

5025 of 41226 branches covered (12.19%)

Branch coverage included in aggregate %.

28 of 99 new or added lines in 15 files covered. (28.28%)

37 existing lines in 6 files now uncovered.

29360 of 66783 relevant lines covered (43.96%)

187.72 hits per line

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

9.32

/packages/lesswrong/lib/crud/withMulti.ts

import { WatchQueryFetchPolicy, ApolloError, useQuery, NetworkStatus, gql, useApolloClient } from '@apollo/client';
import qs from 'qs';
import { useCallback, useMemo, useState } from 'react';
import * as _ from 'underscore';
import { extractFragmentInfo, getFragment, pluralize, camelCaseify, collectionNameToTypeName } from '../vulcan-lib';
import { useLocation } from '../routeUtil';
import { invalidateQuery } from './cacheUpdates';
import { useNavigate } from '../reactRouterWrapper';
import { apolloSSRFlag } from '../helpers';
import { getMultiResolverName } from './utils';
import type { PrimitiveGraphQLType } from './types';

// Template of a GraphQL query for useMulti. A sample query might look
// like:
//
// mutation multiMovieQuery($input: MultiMovieInput) {
//   movies(input: $input) {
//     results {
//       _id
//       name
//       __typename
//     }
//     totalCount
//     __typename
//   }
// }
const multiClientTemplate = ({ typeName, fragmentName, extraVariablesString }: {
  typeName: string,
  fragmentName: FragmentName,
  extraVariablesString: string,
}) => `query multi${typeName}Query($input: Multi${typeName}Input, ${extraVariablesString || ''}) {
  ${camelCaseify(pluralize(typeName))}(input: $input) {
    results {
      ...${fragmentName}
    }
    totalCount
    __typename
  }
}`;

interface GetGraphQLMultiQueryFromOptionsArgs {
  collectionName: CollectionNameString,
  typeName: string,
  fragmentName: FragmentName,
  fragment: any,
  extraVariables?: Record<string, PrimitiveGraphQLType>,
}

export function getGraphQLMultiQueryFromOptions({collectionName, typeName, fragmentName, fragment, extraVariables}: GetGraphQLMultiQueryFromOptionsArgs) {
  ({ fragmentName, fragment } = extractFragmentInfo({ fragmentName, fragment }, collectionName));

  let extraVariablesString = ''
  if (extraVariables) {
    extraVariablesString = Object.keys(extraVariables).map(k => `$${k}: ${extraVariables[k]}`).join(', ')
  }
  // build graphql query from options
  return gql`
    ${multiClientTemplate({ typeName, fragmentName, extraVariablesString })}
    ${fragment}
  `;
}

export interface UseMultiOptions<
  FragmentTypeName extends keyof FragmentTypes,
  CollectionName extends CollectionNameString
> {
  terms?: ViewTermsByCollectionName[CollectionName],
  extraVariablesValues?: any,
  pollInterval?: number,
  enableTotal?: boolean,
  enableCache?: boolean,
  extraVariables?: Record<string, PrimitiveGraphQLType>,
  fetchPolicy?: WatchQueryFetchPolicy,
  nextFetchPolicy?: WatchQueryFetchPolicy,
  collectionName: CollectionNameString,
  fragmentName: FragmentTypeName,
  limit?: number,
  itemsPerPage?: number,
  skip?: boolean,
  queryLimitName?: string,
  alwaysShowLoadMore?: boolean,
  createIfMissing?: Partial<ObjectsByCollectionName[CollectionName]>,
  ssr?: boolean,
}

export type LoadMoreCallback = (limitOverride?: number) => void

export type LoadMoreProps = {
  loadMore: LoadMoreCallback
  count: number,
  totalCount?: number,
  loading: boolean,
  hidden?: boolean,
}

export type UseMultiResult<
  FragmentTypeName extends keyof FragmentTypes,
> = {
  loading: boolean,
  loadingInitial: boolean,
  loadingMore: boolean,
  results?: Array<FragmentTypes[FragmentTypeName]>,
  totalCount?: number,
  refetch: any,
  invalidateCache: () => void,
  error: ApolloError|undefined,
  count?: number,
  showLoadMore: boolean,
  loadMoreProps: LoadMoreProps,
  loadMore: any,
  limit: number,
}

/**
 * React hook that queries a collection, and returns those results along with
 * some metadata about the query's progress and some options for refetching and
 * loading additional results.
 *
 * The preferred way to handle a Load More button is to take loadMoreProps from
 * the return value and pass it to Components.LoadMore, ie:
 *   <LoadMore {...loadMoreProps}/>
 * This will automatically take care of details like hiding the Load More button
 * if there are no more results, showing a result count if enableTotal is true,
 * showing a loading indicator, etc.
 */
export function useMulti<
  FragmentTypeName extends keyof FragmentTypes,
  CollectionName extends CollectionNameString = CollectionNamesByFragmentName[FragmentTypeName]
>({
  terms,
  extraVariablesValues,
  pollInterval = 0, //LESSWRONG: Polling defaults disabled
  enableTotal = false, //LESSWRONG: enableTotal defaults false
  enableCache = false,
  extraVariables,
  fetchPolicy,
  nextFetchPolicy,
  collectionName,
  fragmentName, //fragment,
  limit:initialLimit = 10, // Only used as a fallback if terms.limit is not specified
  itemsPerPage = 10,
  skip = false,
  queryLimitName,
  alwaysShowLoadMore = false,
  createIfMissing,
  ssr = true,
}: UseMultiOptions<FragmentTypeName,CollectionName>): UseMultiResult<FragmentTypeName> {
  const { query: locationQuery, location } = useLocation();
  const navigate = useNavigate();

  const locationQueryLimit = locationQuery && queryLimitName && !isNaN(parseInt(locationQuery[queryLimitName])) ? parseInt(locationQuery[queryLimitName]) : undefined;
  const termsLimit = terms?.limit; // FIXME despite the type definition, terms can actually be undefined
  const defaultLimit: number = locationQueryLimit ?? termsLimit ?? initialLimit

  const [ limit, setLimit ] = useState(defaultLimit);
  const [ lastTerms, setLastTerms ] = useState(_.clone(terms));
  
  const typeName = collectionNameToTypeName(collectionName);
  const fragment = getFragment(fragmentName);
  
  const query = getGraphQLMultiQueryFromOptions({ collectionName, typeName, fragmentName, fragment, extraVariables });
  const resolverName = getMultiResolverName(typeName);

  const graphQLVariables = useMemo(() => ({
    input: {
      terms: { ...terms, limit: defaultLimit },
      resolverArgs: extraVariablesValues,
      enableCache, enableTotal, createIfMissing
    },
    ...extraVariablesValues
  }), [terms, defaultLimit, enableCache, enableTotal, createIfMissing, extraVariablesValues]);

  let effectiveLimit = limit;
  if (!_.isEqual(terms, lastTerms)) {
    setLastTerms(terms);
    setLimit(defaultLimit);
    effectiveLimit = defaultLimit;
  }

  // Due to https://github.com/apollographql/apollo-client/issues/6760 this is necessary to restore the Apollo 2.0 behavior for cache-and-network policies
  const newNextFetchPolicy = nextFetchPolicy || (fetchPolicy === "cache-and-network" || fetchPolicy === "network-only") ? "cache-only" : undefined
  
  const useQueryArgument = {
    variables: graphQLVariables,
    pollInterval, 
    fetchPolicy,
    nextFetchPolicy: newNextFetchPolicy as WatchQueryFetchPolicy,
    // This is a workaround for a bug in apollo where setting `ssr: false` makes it not fetch
    // the query on the client (see https://github.com/apollographql/apollo-client/issues/5918)
    ssr: apolloSSRFlag(ssr),
    skip,
    notifyOnNetworkStatusChange: true
  }
  const {data, error, loading, refetch, fetchMore, networkStatus} = useQuery(query, useQueryArgument);

  const client = useApolloClient();
  const invalidateCache = useCallback(() => invalidateQuery({
    client,
    query,
    variables: graphQLVariables,
  }), [client, query, graphQLVariables]);

  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 count = (data && data[resolverName] && data[resolverName].results && data[resolverName].results.length) || 0;
  const totalCount = data && data[resolverName] && data[resolverName].totalCount;
  
  // If we did a query to count the total number of results (enableTotal),
  // show a Load More if we have fewer than that many results. If we didn't do
  // that, show a Load More if we got at least as many results as requested.
  // This means that if the total number of results exactly matches the limit,
  // the last click of Load More won't get any more documents.
  //
  // The caller of this function is responsible for showing a Load More button
  // if showLoadMore returned true.
  const showLoadMore = alwaysShowLoadMore || (enableTotal ? (count < totalCount) : (count >= effectiveLimit));
  
  const loadMore: LoadMoreCallback = async (limitOverride?: number) => {
    const newLimit = limitOverride || (effectiveLimit+itemsPerPage)
    if (queryLimitName) {
      const newQuery = {...locationQuery, [queryLimitName]: newLimit}
      navigate({...location, search: `?${qs.stringify(newQuery)}`})
    }
    void fetchMore({
      variables: {
        ...graphQLVariables,
        input: {
          ...graphQLVariables.input,
          terms: {...graphQLVariables.input.terms, limit: newLimit}
        }
      },
      updateQuery: (prev, { fetchMoreResult }) => {
        if (!fetchMoreResult) return prev;
        return fetchMoreResult
      }
    })
    setLimit(newLimit)
  };
  
  // A bundle of props that you can pass to Components.LoadMore, to make
  // everything just work.
  const loadMoreProps = {
    loadMore, count, totalCount, loading,
    hidden: !showLoadMore,
  };
  
  let results = data?.[resolverName]?.results;
  if (results && results.length > limit) {
    results = _.take(results, limit);
  }
  
  return {
    loading: loading || networkStatus === NetworkStatus.fetchMore,
    loadingInitial: networkStatus === NetworkStatus.loading,
    loadingMore: networkStatus === NetworkStatus.fetchMore,
    results,
    totalCount: totalCount,
    refetch,
    invalidateCache,
    error,
    count,
    showLoadMore,
    loadMoreProps,
    loadMore,
    limit: effectiveLimit,
  };
}

1	import { WatchQueryFetchPolicy, ApolloError, useQuery, NetworkStatus, gql, useApolloClient } from '@apollo/client';	63✔
2	import qs from 'qs';	21✔
3	import { useCallback, useMemo, useState } from 'react';	21✔
4	import * as _ from 'underscore';	21✔
5	import { extractFragmentInfo, getFragment, pluralize, camelCaseify, collectionNameToTypeName } from '../vulcan-lib';	21✔
6	import { useLocation } from '../routeUtil';	21✔
7	import { invalidateQuery } from './cacheUpdates';	21✔
8	import { useNavigate } from '../reactRouterWrapper';	21✔
9	import { apolloSSRFlag } from '../helpers';	21✔
10	import { getMultiResolverName } from './utils';	21✔
11	import type { PrimitiveGraphQLType } from './types';
12
13	// Template of a GraphQL query for useMulti. A sample query might look
14	// like:
15	//
16	// mutation multiMovieQuery($input: MultiMovieInput) {
17	// movies(input: $input) {
18	// results {
19	// _id
20	// name
21	// __typename
22	// }
23	// totalCount
24	// __typename
25	// }
26	// }
27	const multiClientTemplate = ({ typeName, fragmentName, extraVariablesString }: {	21✔
28	typeName: string,
29	fragmentName: FragmentName,
30	extraVariablesString: string,
31	}) => `query multi${typeName}Query($input: Multi${typeName}Input, ${extraVariablesString \|\| ''}) {	×
32	${camelCaseify(pluralize(typeName))}(input: $input) {
33	results {
34	...${fragmentName}
35	}
36	totalCount
37	__typename
38	}
39	}`;
40
41	interface GetGraphQLMultiQueryFromOptionsArgs {
42	collectionName: CollectionNameString,
43	typeName: string,
44	fragmentName: FragmentName,
45	fragment: any,
46	extraVariables?: Record<string, PrimitiveGraphQLType>,
47	}
48
49	export function getGraphQLMultiQueryFromOptions({collectionName, typeName, fragmentName, fragment, extraVariables}: GetGraphQLMultiQueryFromOptionsArgs) {
50	({ fragmentName, fragment } = extractFragmentInfo({ fragmentName, fragment }, collectionName));	×
51
52	let extraVariablesString = ''	×
53	if (extraVariables) {	×
54	extraVariablesString = Object.keys(extraVariables).map(k => `$${k}: ${extraVariables[k]}`).join(', ')	×
55	}
56	// build graphql query from options
57	return gql`	×
58	${multiClientTemplate({ typeName, fragmentName, extraVariablesString })}
59	${fragment}
60	`;
61	}
62
63	export interface UseMultiOptions<
64	FragmentTypeName extends keyof FragmentTypes,
65	CollectionName extends CollectionNameString
66	> {
67	terms?: ViewTermsByCollectionName[CollectionName],
68	extraVariablesValues?: any,
69	pollInterval?: number,
70	enableTotal?: boolean,
71	enableCache?: boolean,
72	extraVariables?: Record<string, PrimitiveGraphQLType>,
73	fetchPolicy?: WatchQueryFetchPolicy,
74	nextFetchPolicy?: WatchQueryFetchPolicy,
75	collectionName: CollectionNameString,
76	fragmentName: FragmentTypeName,
77	limit?: number,
78	itemsPerPage?: number,
79	skip?: boolean,
80	queryLimitName?: string,
81	alwaysShowLoadMore?: boolean,
82	createIfMissing?: Partial<ObjectsByCollectionName[CollectionName]>,
83	ssr?: boolean,
84	}
85
86	export type LoadMoreCallback = (limitOverride?: number) => void
87
88	export type LoadMoreProps = {
89	loadMore: LoadMoreCallback
90	count: number,
91	totalCount?: number,
92	loading: boolean,
93	hidden?: boolean,
94	}
95
96	export type UseMultiResult<
97	FragmentTypeName extends keyof FragmentTypes,
98	> = {
99	loading: boolean,
100	loadingInitial: boolean,
101	loadingMore: boolean,
102	results?: Array<FragmentTypes[FragmentTypeName]>,
103	totalCount?: number,
104	refetch: any,
105	invalidateCache: () => void,
106	error: ApolloError\|undefined,
107	count?: number,
108	showLoadMore: boolean,
109	loadMoreProps: LoadMoreProps,
110	loadMore: any,
111	limit: number,
112	}
113
114	/**
115	* React hook that queries a collection, and returns those results along with
116	* some metadata about the query's progress and some options for refetching and
117	* loading additional results.
118	*
119	* The preferred way to handle a Load More button is to take loadMoreProps from
120	* the return value and pass it to Components.LoadMore, ie:
121	* <LoadMore {...loadMoreProps}/>
122	* This will automatically take care of details like hiding the Load More button
123	* if there are no more results, showing a result count if enableTotal is true,
124	* showing a loading indicator, etc.
125	*/
126	export function useMulti<
127	FragmentTypeName extends keyof FragmentTypes,
128	CollectionName extends CollectionNameString = CollectionNamesByFragmentName[FragmentTypeName]
129	>({
130	terms,
131	extraVariablesValues,
132	pollInterval = 0, //LESSWRONG: Polling defaults disabled	×
133	enableTotal = false, //LESSWRONG: enableTotal defaults false	×
134	enableCache = false,	×
135	extraVariables,
136	fetchPolicy,
137	nextFetchPolicy,
138	collectionName,
139	fragmentName, //fragment,
140	limit:initialLimit = 10, // Only used as a fallback if terms.limit is not specified	×
141	itemsPerPage = 10,	×
142	skip = false,	×
143	queryLimitName,
144	alwaysShowLoadMore = false,	×
145	createIfMissing,
146	ssr = true,	×
147	}: UseMultiOptions<FragmentTypeName,CollectionName>): UseMultiResult<FragmentTypeName> {
148	const { query: locationQuery, location } = useLocation();	×
149	const navigate = useNavigate();	×
150
151	const locationQueryLimit = locationQuery && queryLimitName && !isNaN(parseInt(locationQuery[queryLimitName])) ? parseInt(locationQuery[queryLimitName]) : undefined;	×
152	const termsLimit = terms?.limit; // FIXME despite the type definition, terms can actually be undefined	×
153	const defaultLimit: number = locationQueryLimit ?? termsLimit ?? initialLimit	×
154
155	const [ limit, setLimit ] = useState(defaultLimit);	×
156	const [ lastTerms, setLastTerms ] = useState(_.clone(terms));	×
157
158	const typeName = collectionNameToTypeName(collectionName);	×
159	const fragment = getFragment(fragmentName);	×
160
NEW 161	const query = getGraphQLMultiQueryFromOptions({ collectionName, typeName, fragmentName, fragment, extraVariables });	×
162	const resolverName = getMultiResolverName(typeName);	×
163
164	const graphQLVariables = useMemo(() => ({	×
165	input: {
166	terms: { ...terms, limit: defaultLimit },
167	resolverArgs: extraVariablesValues,
168	enableCache, enableTotal, createIfMissing
169	},
170	...extraVariablesValues
171	}), [terms, defaultLimit, enableCache, enableTotal, createIfMissing, extraVariablesValues]);
172
UNCOV 173	let effectiveLimit = limit;	×
174	if (!_.isEqual(terms, lastTerms)) {	×
175	setLastTerms(terms);	×
176	setLimit(defaultLimit);	×
177	effectiveLimit = defaultLimit;	×
178	}
179
180	// Due to https://github.com/apollographql/apollo-client/issues/6760 this is necessary to restore the Apollo 2.0 behavior for cache-and-network policies
UNCOV 181	const newNextFetchPolicy = nextFetchPolicy \|\| (fetchPolicy === "cache-and-network" \|\| fetchPolicy === "network-only") ? "cache-only" : undefined	×
182
UNCOV 183	const useQueryArgument = {	×
184	variables: graphQLVariables,
185	pollInterval,
186	fetchPolicy,
187	nextFetchPolicy: newNextFetchPolicy as WatchQueryFetchPolicy,
188	// This is a workaround for a bug in apollo where setting `ssr: false` makes it not fetch
189	// the query on the client (see https://github.com/apollographql/apollo-client/issues/5918)
190	ssr: apolloSSRFlag(ssr),
191	skip,
192	notifyOnNetworkStatusChange: true
193	}
UNCOV 194	const {data, error, loading, refetch, fetchMore, networkStatus} = useQuery(query, useQueryArgument);	×
195
UNCOV 196	const client = useApolloClient();	×
197	const invalidateCache = useCallback(() => invalidateQuery({	×
198	client,
199	query,
200	variables: graphQLVariables,
201	}), [client, query, graphQLVariables]);
202
UNCOV 203	if (error) {	×
204	// This error was already caught by the apollo middleware, but the
205	// middleware had no idea who made the query. To aid in debugging, log a
206	// stack trace here.
207	// eslint-disable-next-line no-console
UNCOV 208	console.error(error.message)	×
209	}
210
UNCOV 211	const count = (data && data[resolverName] && data[resolverName].results && data[resolverName].results.length) \|\| 0;	×
212	const totalCount = data && data[resolverName] && data[resolverName].totalCount;	×
213
214	// If we did a query to count the total number of results (enableTotal),
215	// show a Load More if we have fewer than that many results. If we didn't do
216	// that, show a Load More if we got at least as many results as requested.
217	// This means that if the total number of results exactly matches the limit,
218	// the last click of Load More won't get any more documents.
219	//
220	// The caller of this function is responsible for showing a Load More button
221	// if showLoadMore returned true.
UNCOV 222	const showLoadMore = alwaysShowLoadMore \|\| (enableTotal ? (count < totalCount) : (count >= effectiveLimit));	×
223
UNCOV 224	const loadMore: LoadMoreCallback = async (limitOverride?: number) => {	×
225	const newLimit = limitOverride \|\| (effectiveLimit+itemsPerPage)	×
226	if (queryLimitName) {	×
227	const newQuery = {...locationQuery, [queryLimitName]: newLimit}	×
228	navigate({...location, search: `?${qs.stringify(newQuery)}`})	×
229	}
UNCOV 230	void fetchMore({	×
231	variables: {
232	...graphQLVariables,
233	input: {
234	...graphQLVariables.input,
235	terms: {...graphQLVariables.input.terms, limit: newLimit}
236	}
237	},
238	updateQuery: (prev, { fetchMoreResult }) => {
UNCOV 239	if (!fetchMoreResult) return prev;	×
240	return fetchMoreResult	×
241	}
242	})
UNCOV 243	setLimit(newLimit)	×
244	};
245
246	// A bundle of props that you can pass to Components.LoadMore, to make
247	// everything just work.
UNCOV 248	const loadMoreProps = {	×
249	loadMore, count, totalCount, loading,
250	hidden: !showLoadMore,
251	};
252
UNCOV 253	let results = data?.[resolverName]?.results;	×
254	if (results && results.length > limit) {	×
255	results = _.take(results, limit);	×
256	}
257
UNCOV 258	return {	×
259	loading: loading \|\| networkStatus === NetworkStatus.fetchMore,	×
260	loadingInitial: networkStatus === NetworkStatus.loading,
261	loadingMore: networkStatus === NetworkStatus.fetchMore,
262	results,
263	totalCount: totalCount,
264	refetch,
265	invalidateCache,
266	error,
267	count,
268	showLoadMore,
269	loadMoreProps,
270	loadMore,
271	limit: effectiveLimit,
272	};
273	}

ForumMagnum / ForumMagnum / 10731053370

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