10412967337

Committed 16 Aug 2024 01:10AM UTC coverage: 32.185% (+0.001%) from 32.184%

Build # 10412967337

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9591 from ForumMagnum/master

Merge master into lw-deploy

Run Details

5015 of 40305 branches covered (12.44%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

28958 of 65249 relevant lines covered (44.38%)

190.54 hits per line

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

13.48

/packages/lesswrong/server/utils/feedUtil.ts

import _ from 'underscore';
import { addGraphQLResolvers, addGraphQLQuery, addGraphQLSchema } from '../../lib/vulcan-lib/graphql';
import { accessFilterMultiple } from '../../lib/utils/schemaUtils';
import { getDefaultViewSelector, mergeSelectors, replaceSpecialFieldSelectors } from '../../lib/utils/viewUtils';
import { isLWorAF } from '@/lib/instanceSettings';

type FeedSubquery<ResultType extends DbObject, SortKeyType> = {
  type: string,
  getSortKey: (item: ResultType) => SortKeyType,
  isNumericallyPositioned?: boolean,
  doQuery: (limit: number, cutoff?: SortKeyType) => Promise<Partial<ResultType>[]>,
}

export type SortDirection = "asc" | "desc";

export type SubquerySortField<ResultType extends DbObject, SortFieldName extends keyof ResultType> = {
  sortField: SortFieldName,
  sortDirection?: SortDirection,
}

type Sortable<SortKey extends number | Date> = { sortKey: SortKey };

type ViewBasedSubqueryProps<
  N extends CollectionNameString,
  SortFieldName extends keyof ObjectsByCollectionName[N]
> = {
  type: string,
  collection: CollectionBase<N>,
  context: ResolverContext,
  selector: MongoSelector<ObjectsByCollectionName[N]>,
  sticky?: boolean,
} & SubquerySortField<ObjectsByCollectionName[N], SortFieldName>;

export function viewBasedSubquery<
  N extends CollectionNameString,
  SortKeyType,
  SortFieldName extends keyof ObjectsByCollectionName[N]
>(props: ViewBasedSubqueryProps<N, SortFieldName>): FeedSubquery<ObjectsByCollectionName[N], SortKeyType> {
  props.sortDirection ??= "desc";
  const {type, collection, context, selector, sticky, sortField, sortDirection} = props;
  return {
    type,
    getSortKey: (item: ObjectsByCollectionName[N]) => item[props.sortField] as unknown as SortKeyType,
    isNumericallyPositioned: !!sticky,
    doQuery: async (limit: number, cutoff: SortKeyType): Promise<Partial<ObjectsByCollectionName[N]>[]> => {
      return queryWithCutoff({context, collection, selector, limit, cutoffField: sortField, cutoff, sortDirection});
    }
  };
}

export function fixedResultSubquery<ResultType extends DbObject, SortKeyType>({type, result, sortKey}: {
  type: string,
  result: Partial<ResultType>,
  sortKey: SortKeyType,
}): FeedSubquery<ResultType, SortKeyType> {
  return {
    type,
    getSortKey: (_item: ResultType): SortKeyType => sortKey,
    doQuery: async (_limit: number, _cutoff: SortKeyType): Promise<Partial<ResultType>[]> => {
      return [result];
    }
  };
}

export function fixedIndexSubquery<ResultType extends DbObject>({type, index, result}: {
  type: string,
  index: number,
  result: any,
}): FeedSubquery<ResultType, number> {
  return {
    type,
    getSortKey: () => index,
    isNumericallyPositioned: true,
    doQuery: async () => [result],
  };
}

export function defineFeedResolver<CutoffType>({name, resolver, args, cutoffTypeGraphQL, resultTypesGraphQL}: {
  name: string,
  resolver: ({limit, cutoff, args, context}: {
    limit?: number,
    cutoff?: CutoffType|null,
    offset?: number,
    args: any, context: ResolverContext
  }) => Promise<{
    cutoff: CutoffType|null,
    results: Array<any>
  }>,
  args: string,
  cutoffTypeGraphQL: string,
  resultTypesGraphQL: string,
}) {
  addGraphQLSchema(`
    type ${name}QueryResults {
      cutoff: ${cutoffTypeGraphQL}
      endOffset: Int!
      results: [${name}EntryType!]
    }
    type ${name}EntryType {
      type: String!
      ${resultTypesGraphQL}
    }
  `);
  addGraphQLQuery(`${name}(
    limit: Int,
    cutoff: ${cutoffTypeGraphQL},
    offset: Int
    ${(args && args.length>0) ? ", " : ""}${args}
  ): ${name}QueryResults!`);
  
  addGraphQLResolvers({
    Query: {
      [name]: async (_root: void, args: any, context: ResolverContext) => {
        const {limit, cutoff, offset, ...rest} = args;
        return {
          __typename: `${name}QueryResults`,
          ...await resolver({
            limit, cutoff, offset,
            args: rest,
            context
          })
        };
      }
    },
  });
}

const applyCutoff = <T extends Sortable<SortKeyType>, SortKeyType extends number | Date>(
  sortedResults: T[],
  cutoff: SortKeyType,
  sortDirection: SortDirection,
) => {
  const cutoffFilter = sortDirection === "asc"
    ? ({sortKey}: { sortKey: SortKeyType }) => sortKey > cutoff
    : ({sortKey}: { sortKey: SortKeyType }) => sortKey < cutoff;
  return _.filter<T>(sortedResults, cutoffFilter);
}

export async function mergeFeedQueries<SortKeyType extends number | Date>({limit, cutoff, offset, sortDirection, subqueries}: {
  limit: number
  cutoff?: SortKeyType,
  offset?: number,
  sortDirection?: SortDirection,
  subqueries: Array<FeedSubquery<DbObject, any>>,
}) {
  sortDirection ??= "desc";

  // Perform the subqueries
  const unsortedSubqueryResults = await Promise.all(
    subqueries.map(async (subquery) => {
      const subqueryResults = await subquery.doQuery(limit, cutoff)
      return subqueryResults.map((result: DbObject) => ({
        type: subquery.type,
        sortKey: subquery.getSortKey(result),
        isNumericallyPositioned: subquery.isNumericallyPositioned,
        [subquery.type]: result,
      }))
    })
  );
  
  // Merge the result lists
  const unsortedResults = unsortedSubqueryResults.flat();
  
  // Split into results with numeric indexes and results with sort-key indexes
  const [
    numericallyPositionedResults,
    orderedResults,
  ] = _.partition(unsortedResults, ({isNumericallyPositioned}) => !!isNumericallyPositioned);
  
  // Sort by shared sort key
  const sortedResults = _.sortBy(orderedResults, r=>r.sortKey);
  if (sortDirection === "desc") {
    sortedResults.reverse();
  }
  
  // Apply cutoff
  const withCutoffApplied = cutoff
    ? applyCutoff(sortedResults, cutoff, sortDirection)
    : sortedResults;
  
  // Merge in the numerically positioned results
  const bothResultKinds = mergeSortedAndNumericallyPositionedResults(withCutoffApplied, numericallyPositionedResults, offset||0);
  
  // Apply limit
  const withLimitApplied = _.first(bothResultKinds, limit);
  
  // Find the last result that wasn't numerically positioned (after the limit
  // is applied), and get its sortKey to use as the page cutoff
  const nonNumericallyPositionedResults = _.filter(withLimitApplied, r => !_.some(numericallyPositionedResults, r2=>r===r2)) as Sortable<SortKeyType>[];
  const nextCutoff = (nonNumericallyPositionedResults.length>0) ? nonNumericallyPositionedResults[nonNumericallyPositionedResults.length-1].sortKey : null;
  
  return {
    results: withLimitApplied,
    cutoff: nextCutoff,
    endOffset: (offset||0)+withLimitApplied.length
  };
}

// Take a list of results that are sorted by a sort key (ie a date), and a list
// of results that have numeric indexes instead, and merge them. Eg, Recent
// Discussion contains posts sorted by date, but with some things mixed in
// with their position defined as "index 5".
function mergeSortedAndNumericallyPositionedResults(sortedResults: Array<Sortable<Date>>, numericallyPositionedResults: Array<Sortable<number>>, offset: number) {
  // Take the numerically positioned results. Sort them by index, discard ones
  // from below the offset, and resolve collisions.
  const sortedNumericallyPositionedResults = _.sortBy(numericallyPositionedResults, r=>r.sortKey);
  
  let mergedResults: Sortable<number | Date>[] = [...sortedResults];
  for (let i=0; i<sortedNumericallyPositionedResults.length; i++) {
    const insertedResult = sortedNumericallyPositionedResults[i];
    const insertionPosition = insertedResult.sortKey-offset;
    
    if (insertionPosition >= 0) {
      if (insertionPosition < mergedResults.length) {
        mergedResults.splice(insertionPosition, 0, insertedResult);
      } else {
        mergedResults.push(insertedResult);
      }
    }
  }
  
  return mergedResults;
}

function isNonEmptyObject(obj: {}): boolean {
  return Object.keys(obj).length > 0;
}

async function queryWithCutoff<N extends CollectionNameString>({
  context, collection, selector, limit, cutoffField, cutoff, sortDirection,
}: {
  context: ResolverContext,
  collection: CollectionBase<N>,
  selector: MongoSelector<ObjectsByCollectionName[N]>,
  limit: number,
  cutoffField: keyof ObjectsByCollectionName[N],
  cutoff: any,
  sortDirection: SortDirection,
}) {
  const collectionName = collection.collectionName;
  const {currentUser} = context;

  const sort = {[cutoffField]: sortDirection === "asc" ? 1 : -1, _id: 1};
  const cutoffSelector = cutoff
    ? {[cutoffField]: {[sortDirection === "asc" ? "$gt" : "$lt"]: cutoff}}
    : {};
  const mergedSelector = mergeSelectors(
    getDefaultViewSelector(collectionName),
    selector,
    cutoffSelector
  )
  const finalizedSelector = replaceSpecialFieldSelectors(mergedSelector);
  const resultsRaw = await collection.find(finalizedSelector, {
    sort: sort as Partial<Record<keyof ObjectsByCollectionName[N], number>>,
    limit,
  }).fetch();

  return await accessFilterMultiple(currentUser, collection, resultsRaw, context);
}

1	import _ from 'underscore';	216✔
2	import { addGraphQLResolvers, addGraphQLQuery, addGraphQLSchema } from '../../lib/vulcan-lib/graphql';	18✔
3	import { accessFilterMultiple } from '../../lib/utils/schemaUtils';	18✔
4	import { getDefaultViewSelector, mergeSelectors, replaceSpecialFieldSelectors } from '../../lib/utils/viewUtils';	18✔
5	import { isLWorAF } from '@/lib/instanceSettings';
6
7	type FeedSubquery<ResultType extends DbObject, SortKeyType> = {
8	type: string,
9	getSortKey: (item: ResultType) => SortKeyType,
10	isNumericallyPositioned?: boolean,
11	doQuery: (limit: number, cutoff?: SortKeyType) => Promise<Partial<ResultType>[]>,
12	}
13
14	export type SortDirection = "asc" \| "desc";
15
16	export type SubquerySortField<ResultType extends DbObject, SortFieldName extends keyof ResultType> = {
17	sortField: SortFieldName,
18	sortDirection?: SortDirection,
19	}
20
21	type Sortable<SortKey extends number \| Date> = { sortKey: SortKey };
22
23	type ViewBasedSubqueryProps<
24	N extends CollectionNameString,
25	SortFieldName extends keyof ObjectsByCollectionName[N]
26	> = {
27	type: string,
28	collection: CollectionBase<N>,
29	context: ResolverContext,
30	selector: MongoSelector<ObjectsByCollectionName[N]>,
31	sticky?: boolean,
32	} & SubquerySortField<ObjectsByCollectionName[N], SortFieldName>;
33
34	export function viewBasedSubquery<
35	N extends CollectionNameString,
36	SortKeyType,
37	SortFieldName extends keyof ObjectsByCollectionName[N]
38	>(props: ViewBasedSubqueryProps<N, SortFieldName>): FeedSubquery<ObjectsByCollectionName[N], SortKeyType> {
39	props.sortDirection ??= "desc";	×
40	const {type, collection, context, selector, sticky, sortField, sortDirection} = props;	×
41	return {	×
42	type,
43	getSortKey: (item: ObjectsByCollectionName[N]) => item[props.sortField] as unknown as SortKeyType,	×
44	isNumericallyPositioned: !!sticky,
45	doQuery: async (limit: number, cutoff: SortKeyType): Promise<Partial<ObjectsByCollectionName[N]>[]> => {
46	return queryWithCutoff({context, collection, selector, limit, cutoffField: sortField, cutoff, sortDirection});	×
47	}
48	};
49	}
50
51	export function fixedResultSubquery<ResultType extends DbObject, SortKeyType>({type, result, sortKey}: {
52	type: string,
53	result: Partial<ResultType>,
54	sortKey: SortKeyType,
55	}): FeedSubquery<ResultType, SortKeyType> {
56	return {	×
57	type,
58	getSortKey: (_item: ResultType): SortKeyType => sortKey,	×
59	doQuery: async (_limit: number, _cutoff: SortKeyType): Promise<Partial<ResultType>[]> => {
60	return [result];	×
61	}
62	};
63	}
64
65	export function fixedIndexSubquery<ResultType extends DbObject>({type, index, result}: {
66	type: string,
67	index: number,
68	result: any,
69	}): FeedSubquery<ResultType, number> {
70	return {	×
71	type,
72	getSortKey: () => index,	×
73	isNumericallyPositioned: true,
74	doQuery: async () => [result],	×
75	};
76	}
77
78	export function defineFeedResolver<CutoffType>({name, resolver, args, cutoffTypeGraphQL, resultTypesGraphQL}: {
79	name: string,
80	resolver: ({limit, cutoff, args, context}: {
81	limit?: number,
82	cutoff?: CutoffType\|null,
83	offset?: number,
84	args: any, context: ResolverContext
85	}) => Promise<{
86	cutoff: CutoffType\|null,
87	results: Array<any>
88	}>,
89	args: string,
90	cutoffTypeGraphQL: string,
91	resultTypesGraphQL: string,
92	}) {
93	addGraphQLSchema(`	162✔
94	type ${name}QueryResults {
95	cutoff: ${cutoffTypeGraphQL}
96	endOffset: Int!
97	results: [${name}EntryType!]
98	}
99	type ${name}EntryType {
100	type: String!
101	${resultTypesGraphQL}
102	}
103	`);
104	addGraphQLQuery(`${name}(	162✔
105	limit: Int,
106	cutoff: ${cutoffTypeGraphQL},
107	offset: Int
108	${(args && args.length>0) ? ", " : ""}${args}	468✔
109	): ${name}QueryResults!`);
110
111	addGraphQLResolvers({	162✔
112	Query: {
113	[name]: async (_root: void, args: any, context: ResolverContext) => {
114	const {limit, cutoff, offset, ...rest} = args;	×
115	return {	×
116	__typename: `${name}QueryResults`,
117	...await resolver({
118	limit, cutoff, offset,
119	args: rest,
120	context
121	})
122	};
123	}
124	},
125	});
126	}
127
128	const applyCutoff = <T extends Sortable<SortKeyType>, SortKeyType extends number \| Date>(	18✔
129	sortedResults: T[],
130	cutoff: SortKeyType,
131	sortDirection: SortDirection,
132	) => {
133	const cutoffFilter = sortDirection === "asc"	×
134	? ({sortKey}: { sortKey: SortKeyType }) => sortKey > cutoff	×
135	: ({sortKey}: { sortKey: SortKeyType }) => sortKey < cutoff;	×
136	return _.filter<T>(sortedResults, cutoffFilter);	×
137	}
138
139	export async function mergeFeedQueries<SortKeyType extends number \| Date>({limit, cutoff, offset, sortDirection, subqueries}: {
140	limit: number
141	cutoff?: SortKeyType,
142	offset?: number,
143	sortDirection?: SortDirection,
144	subqueries: Array<FeedSubquery<DbObject, any>>,
145	}) {
146	sortDirection ??= "desc";	×
147
148	// Perform the subqueries
149	const unsortedSubqueryResults = await Promise.all(	×
150	subqueries.map(async (subquery) => {
151	const subqueryResults = await subquery.doQuery(limit, cutoff)	×
152	return subqueryResults.map((result: DbObject) => ({	×
153	type: subquery.type,
154	sortKey: subquery.getSortKey(result),
155	isNumericallyPositioned: subquery.isNumericallyPositioned,
156	[subquery.type]: result,
157	}))
158	})
159	);
160
161	// Merge the result lists
162	const unsortedResults = unsortedSubqueryResults.flat();	×
163
164	// Split into results with numeric indexes and results with sort-key indexes
165	const [
166	numericallyPositionedResults,
167	orderedResults,
168	] = _.partition(unsortedResults, ({isNumericallyPositioned}) => !!isNumericallyPositioned);	×
169
170	// Sort by shared sort key
171	const sortedResults = _.sortBy(orderedResults, r=>r.sortKey);	×
172	if (sortDirection === "desc") {	×
173	sortedResults.reverse();	×
174	}
175
176	// Apply cutoff
177	const withCutoffApplied = cutoff	×
178	? applyCutoff(sortedResults, cutoff, sortDirection)	×
179	: sortedResults;
180
181	// Merge in the numerically positioned results
182	const bothResultKinds = mergeSortedAndNumericallyPositionedResults(withCutoffApplied, numericallyPositionedResults, offset\|\|0);	×
183
184	// Apply limit
185	const withLimitApplied = _.first(bothResultKinds, limit);	×
186
187	// Find the last result that wasn't numerically positioned (after the limit
188	// is applied), and get its sortKey to use as the page cutoff
189	const nonNumericallyPositionedResults = _.filter(withLimitApplied, r => !_.some(numericallyPositionedResults, r2=>r===r2)) as Sortable<SortKeyType>[];	×
190	const nextCutoff = (nonNumericallyPositionedResults.length>0) ? nonNumericallyPositionedResults[nonNumericallyPositionedResults.length-1].sortKey : null;	×
191
UNCOV 192	return {	×
193	results: withLimitApplied,
194	cutoff: nextCutoff,
195	endOffset: (offset\|\|0)+withLimitApplied.length	×
196	};
197	}
198
199	// Take a list of results that are sorted by a sort key (ie a date), and a list
200	// of results that have numeric indexes instead, and merge them. Eg, Recent
201	// Discussion contains posts sorted by date, but with some things mixed in
202	// with their position defined as "index 5".
203	function mergeSortedAndNumericallyPositionedResults(sortedResults: Array<Sortable<Date>>, numericallyPositionedResults: Array<Sortable<number>>, offset: number) {
204	// Take the numerically positioned results. Sort them by index, discard ones
205	// from below the offset, and resolve collisions.
206	const sortedNumericallyPositionedResults = _.sortBy(numericallyPositionedResults, r=>r.sortKey);	×
207
208	let mergedResults: Sortable<number \| Date>[] = [...sortedResults];	×
209	for (let i=0; i<sortedNumericallyPositionedResults.length; i++) {	×
210	const insertedResult = sortedNumericallyPositionedResults[i];	×
211	const insertionPosition = insertedResult.sortKey-offset;	×
212
213	if (insertionPosition >= 0) {	×
214	if (insertionPosition < mergedResults.length) {	×
215	mergedResults.splice(insertionPosition, 0, insertedResult);	×
216	} else {
217	mergedResults.push(insertedResult);	×
218	}
219	}
220	}
221
222	return mergedResults;	×
223	}
224
225	function isNonEmptyObject(obj: {}): boolean {
226	return Object.keys(obj).length > 0;	×
227	}
228
229	async function queryWithCutoff<N extends CollectionNameString>({
230	context, collection, selector, limit, cutoffField, cutoff, sortDirection,
231	}: {
232	context: ResolverContext,
233	collection: CollectionBase<N>,
234	selector: MongoSelector<ObjectsByCollectionName[N]>,
235	limit: number,
236	cutoffField: keyof ObjectsByCollectionName[N],
237	cutoff: any,
238	sortDirection: SortDirection,
239	}) {
240	const collectionName = collection.collectionName;	×
241	const {currentUser} = context;	×
242
243	const sort = {[cutoffField]: sortDirection === "asc" ? 1 : -1, _id: 1};	×
244	const cutoffSelector = cutoff	×
245	? {[cutoffField]: {[sortDirection === "asc" ? "$gt" : "$lt"]: cutoff}}	×
246	: {};
247	const mergedSelector = mergeSelectors(	×
248	getDefaultViewSelector(collectionName),
249	selector,
250	cutoffSelector
251	)
252	const finalizedSelector = replaceSpecialFieldSelectors(mergedSelector);	×
253	const resultsRaw = await collection.find(finalizedSelector, {	×
254	sort: sort as Partial<Record<keyof ObjectsByCollectionName[N], number>>,
255	limit,
256	}).fetch();
257
258	return await accessFilterMultiple(currentUser, collection, resultsRaw, context);	×
259	}

ForumMagnum / ForumMagnum / 10412967337

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