9356176728

Committed 03 Jun 2024 07:33PM UTC coverage: 31.909% (-0.03%) from 31.94%

Build # 9356176728

Build Type

Pull #9359

github

Committed by

rjmk

Commit Message

Shorter review bot comments

Pull Request Pull Request #9359: Shorter review bot comments

Run Details

4802 of 39259 branches covered (12.23%)

Branch coverage included in aggregate %.

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

611 existing lines in 31 files now uncovered.

27944 of 63363 relevant lines covered (44.1%)

179.67 hits per line

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

68.81

/packages/lesswrong/lib/vulcan-core/default_resolvers.ts

import { Utils } from '../vulcan-lib/utils';
import { collectionNameToGraphQLType, getCollection } from '../vulcan-lib/collections';
import { restrictViewableFieldsMultiple, restrictViewableFieldsSingle } from '../vulcan-users/permissions';
import { asyncFilter } from '../utils/asyncUtils';
import { loggerConstructor, logGroupConstructor } from '../utils/logging';
import { describeTerms, viewTermsToQuery } from '../utils/viewUtils';
import type { FieldNode, GraphQLResolveInfo } from 'graphql';
import { FragmentSpreadNode } from 'graphql';
import SelectFragmentQuery from '../sql/SelectFragmentQuery';
import { getSqlClientOrThrow } from '../sql/sqlClient';
import { maxAllowedApiSkip } from '../instanceSettings';

interface DefaultResolverOptions {
  cacheMaxAge: number
}

const logMissingFragmentNames = false;

const defaultOptions: DefaultResolverOptions = {
  cacheMaxAge: 300,
};

const getFragmentNameFromInfo = (
  {fieldName, fieldNodes}: GraphQLResolveInfo,
  resultFieldName: string,
): string | null => {
  const query = fieldNodes.find(
    ({name: {value}}) => value === fieldName,
  );
  const mainSelections = query?.selectionSet?.selections;
  const results = mainSelections?.find(
    (node) => node.kind === "Field" && node.name.value === resultFieldName,
  ) as FieldNode | undefined;
  const resultSelections = results?.selectionSet?.selections;
  const fragmentSpread = resultSelections?.find(
    ({kind}) => kind === "FragmentSpread",
  ) as FragmentSpreadNode | undefined;
  const fragmentName = fragmentSpread?.name.value;
  if (!fragmentName) {
    if (logMissingFragmentNames) {
      const data = JSON.stringify(fieldNodes, null, 2);
      // eslint-disable-next-line no-console
      console.error("Fragment name not found for", fieldName, data);
    }
    return null;
  }
  return fragmentName;
}

// Default resolvers. Provides `single` and `multi` resolvers, which power the
// useSingle and useMulti hooks.
export function getDefaultResolvers<N extends CollectionNameString>(
  collectionName: N,
  options?: Partial<DefaultResolverOptions>,
) {
  type T = ObjectsByCollectionName[N]
  const typeName = collectionNameToGraphQLType(collectionName);
  const resolverOptions = {...defaultOptions, options};

  return {
    // resolver for returning a list of documents based on a set of query terms

    multi: {
      description: `A list of ${typeName} documents matching a set of query terms`,

      async resolver(
        root: void,
        args: {
          input: {
            terms: ViewTermsBase & Record<string, unknown>,
            enableCache?: boolean,
            enableTotal?: boolean,
            createIfMissing?: Partial<T>,
          },
        },
        context: ResolverContext,
        info: GraphQLResolveInfo,
      ) {
        // const startResolve = Date.now()
        const input = args?.input || {};
        const { terms={}, enableCache = false, enableTotal = false } = input;
        const logger = loggerConstructor(`views-${collectionName.toLowerCase()}-${terms.view?.toLowerCase() ?? 'default'}`)
        logger('multi resolver()')
        logger('multi terms', terms)

        // Don't allow API requests with an arbitrarily large offset. This
        // prevents some extremely-slow queries.
        const maxAllowedSkip = maxAllowedApiSkip.get();
        if (
          terms.offset &&
          maxAllowedSkip !== null &&
          terms.offset > maxAllowedSkip
        ) {
          throw new Error("Exceeded maximum value for skip");
        }

        const {cacheControl} = info;
        if (cacheControl && enableCache) {
          const maxAge = resolverOptions.cacheMaxAge || defaultOptions.cacheMaxAge;
          cacheControl.setCacheHint({ maxAge });
        }

        // get currentUser and Users collection from context
        const { currentUser }: {currentUser: DbUser|null} = context;

        // get collection based on collectionName argument
        const collection = getCollection(collectionName);

        // Get selector and options from terms and perform Mongo query
        // Downcasts terms because there are collection-specific terms but this function isn't collection-specific
        const parameters = viewTermsToQuery(collectionName, terms, {}, context);

        // get fragment from GraphQL AST
        const fragmentName = getFragmentNameFromInfo(info, "results");

        let fetchDocs: () => Promise<T[]>;
        if (fragmentName) {
          const query = new SelectFragmentQuery(
            fragmentName as FragmentName,
            currentUser,
            terms,
            parameters.selector,
            parameters.syntheticFields,
            parameters.options,
          );
          const compiledQuery = query.compile();
          const db = getSqlClientOrThrow();
          fetchDocs = () => db.any(compiledQuery.sql, compiledQuery.args);
        } else {
          fetchDocs = () => performQueryFromViewParameters(
            collection,
            terms,
            parameters,
          );
        }
        let docs = await fetchDocs();

        // Create a doc if none exist, using the actual create mutation to ensure permission checks are run correctly
        if (input.createIfMissing && docs.length === 0) {
          await collection.options.mutations.create.mutation(root, {data: input.createIfMissing}, context)
          docs = await fetchDocs();
        }

        // Were there enough results to reach the limit specified in the query?
        const saturated = parameters.options.limit && docs.length>=parameters.options.limit;

        // if collection has a checkAccess function defined, remove any documents that doesn't pass the check
        const viewableDocs: Array<T> = collection.checkAccess
          ? await asyncFilter(docs, async (doc: T) => await collection.checkAccess(currentUser, doc, context))
          : docs;

        // take the remaining documents and remove any fields that shouldn't be accessible
        const restrictedDocs = restrictViewableFieldsMultiple(currentUser, collection, viewableDocs);

        // prime the cache
        restrictedDocs.forEach((doc: AnyBecauseTodo) => context.loaders[collectionName].prime(doc._id, doc));

        const data: any = { results: restrictedDocs };

        if (enableTotal) {
          // get total count of documents matching the selector
          // TODO: Make this handle synthetic fields
          if (saturated) {
            const { hint } = parameters.options;
            data.totalCount = await Utils.Connectors.count(collection, parameters.selector, { hint });
          } else {
            data.totalCount = viewableDocs.length;
          }
        }

        // const timeElapsed = Date.now() - startResolve;
        // Temporarily disabled to investigate performance issues
        // captureEvent("resolveMultiCompleted", {documentIds: restrictedDocs.map((d: DbObject) => d._id), collectionName, timeElapsed, terms}, true);
        // return results
        return data;
      },
    },

    // resolver for returning a single document queried based on id or slug

    single: {
      description: `A single ${typeName} document fetched by ID or slug`,

      async resolver(
        _root: void,
        {input = {}}: {input: AnyBecauseTodo},
        context: ResolverContext,
        info: GraphQLResolveInfo,
      ) {
        // const startResolve = Date.now();
        const {enableCache = false, allowNull = false, terms} = input;
        // In this context (for reasons I don't fully understand) selector is an object with a null prototype, i.e.
        // it has none of the methods you would usually associate with objects like `toString`. This causes various problems
        // down the line. See https://stackoverflow.com/questions/56298481/how-to-fix-object-null-prototype-title-product
        // So we copy it here to give it back those methoods
        const selector = {...(input.selector || {})}

        const logger = loggerConstructor(`resolvers-${collectionName.toLowerCase()}`)
        const {logGroupStart, logGroupEnd} = logGroupConstructor(`resolvers-${collectionName.toLowerCase()}`)
        logger('');
        logGroupStart(
          `--------------- start \x1b[35m${typeName} Single Resolver\x1b[0m ---------------`
        );
        logger(`Options: ${JSON.stringify(resolverOptions)}`);
        logger(`Selector: ${JSON.stringify(selector)}`);

        const {cacheControl} = info;
        if (cacheControl && enableCache) {
          const maxAge = resolverOptions.cacheMaxAge || defaultOptions.cacheMaxAge;
          cacheControl.setCacheHint({ maxAge });
        }

        const { currentUser }: {currentUser: DbUser|null} = context;
        const collection = getCollection(collectionName);

        // useSingle allows passing in `_id` as `documentId`
        if (selector.documentId) {
          selector._id = selector.documentId;
          delete selector.documentId;
        }
        const documentId = selector._id;

        // get fragment from GraphQL AST
        const fragmentName = getFragmentNameFromInfo(info, "result");

        let doc: ObjectsByCollectionName[N] | null;
        if (fragmentName) {
          const query = new SelectFragmentQuery(
            fragmentName as FragmentName,
            currentUser,
            terms,
            selector,
            undefined,
            {limit: 1},
          );
          const compiledQuery = query.compile();
          const db = getSqlClientOrThrow();
          doc = await db.oneOrNone(compiledQuery.sql, compiledQuery.args);
        } else {
          doc = await Utils.Connectors.get(collection, selector);
        }

        if (!doc) {
          if (allowNull) {
            return { result: null };
          } else {
            Utils.throwError({
              id: 'app.missing_document',
              data: { documentId, selector, collectionName: collection.collectionName },
            });
          }
        }

        // if collection has a checkAccess function defined, use it to perform a check on the current document
        // (will throw an error if check doesn't pass)
        if (collection.checkAccess) {
          const reasonDenied: {reason?: string} = {reason: undefined};
          const canAccess = await collection.checkAccess(currentUser, doc, context, reasonDenied)
          if (!canAccess) {
            if (reasonDenied.reason) {
              Utils.throwError({
                id: reasonDenied.reason,
              });
            } else {
              Utils.throwError({
                id: 'app.operation_not_allowed',
                data: {documentId, operationName: `${typeName}.read.single`}
              });
            }
          }
        }

        const restrictedDoc = restrictViewableFieldsSingle(currentUser, collection, doc);

        logGroupEnd();
        logger(`--------------- end \x1b[35m${typeName} Single Resolver\x1b[0m ---------------`);
        logger('');

        // const timeElapsed = Date.now() - startResolve;
        // Temporarily disabled to investigate performance issues
        // captureEvent("resolveSingleCompleted", {documentId: restrictedDoc._id, collectionName, timeElapsed}, true);

        // filter out disallowed properties and return resulting document
        return { result: restrictedDoc };
      },
    },
  };
}

export const performQueryFromViewParameters = async <N extends CollectionNameString>(
  collection: CollectionBase<N>,
  terms: ViewTermsBase,
  parameters: AnyBecauseTodo,
): Promise<ObjectsByCollectionName[N][]> => {
  const logger = loggerConstructor(`views-${collection.collectionName.toLowerCase()}`)
  const selector = parameters.selector;
  const description = describeTerms(collection.collectionName, terms);

  const options: MongoFindOptions<ObjectsByCollectionName[N]> = {
    ...parameters.options,
    skip: terms.offset,
    comment: description
  };

  // I don't know if we ever get a `skip` value in `parameters.options`, but if we do, we've been running on that logic for years
  // So defer to that if it exists, instead of overriding it with the value from `terms.offset`
  parameters.options.skip ??= options.skip;

  if (parameters.syntheticFields && Object.keys(parameters.syntheticFields).length>0) {
    const pipeline = [
      // First stage: Filter by selector
      { $match: {
        ...selector,
        $comment: description,
      }},
      // Second stage: Add computed fields
      { $addFields: parameters.syntheticFields },

      // Third stage: Filter by computed fields (if applicable)
      ...(parameters.syntheticFieldSelector || []),

      // Fourth stage: Sort
      { $sort: parameters.options.sort },
    ];

    // Apply skip and limit (if applicable)
    if (parameters.options.skip) {
      pipeline.push({ $skip: parameters.options.skip });
    }
    if (parameters.options.limit) {
      pipeline.push({ $limit: parameters.options.limit });
    }
    logger('aggregation pipeline', pipeline);
    return await collection.aggregate(pipeline).toArray();
  } else {
    logger('performQueryFromViewParameters connector find', selector, terms, options);
    return await collection.find({
      ...selector,
    }, options).fetch();
  }
}

1	import { Utils } from '../vulcan-lib/utils';	1,200✔
2	import { collectionNameToGraphQLType, getCollection } from '../vulcan-lib/collections';	26✔
3	import { restrictViewableFieldsMultiple, restrictViewableFieldsSingle } from '../vulcan-users/permissions';	26✔
4	import { asyncFilter } from '../utils/asyncUtils';	26✔
5	import { loggerConstructor, logGroupConstructor } from '../utils/logging';	26✔
6	import { describeTerms, viewTermsToQuery } from '../utils/viewUtils';	26✔
7	import type { FieldNode, GraphQLResolveInfo } from 'graphql';
8	import { FragmentSpreadNode } from 'graphql';
9	import SelectFragmentQuery from '../sql/SelectFragmentQuery';	26✔
10	import { getSqlClientOrThrow } from '../sql/sqlClient';	26✔
11	import { maxAllowedApiSkip } from '../instanceSettings';	26✔
12
13	interface DefaultResolverOptions {
14	cacheMaxAge: number
15	}
16
17	const logMissingFragmentNames = false;	26✔
18
19	const defaultOptions: DefaultResolverOptions = {	26✔
20	cacheMaxAge: 300,
21	};
22
23	const getFragmentNameFromInfo = (	26✔
24	{fieldName, fieldNodes}: GraphQLResolveInfo,
25	resultFieldName: string,
26	): string \| null => {
27	const query = fieldNodes.find(	8✔
28	({name: {value}}) => value === fieldName,	8✔
29	);
30	const mainSelections = query?.selectionSet?.selections;	8!
31	const results = mainSelections?.find(	8!
32	(node) => node.kind === "Field" && node.name.value === resultFieldName,	8✔
33	) as FieldNode \| undefined;
34	const resultSelections = results?.selectionSet?.selections;	8!
35	const fragmentSpread = resultSelections?.find(	8!
36	({kind}) => kind === "FragmentSpread",	14✔
37	) as FragmentSpreadNode \| undefined;
38	const fragmentName = fragmentSpread?.name.value;	8✔
39	if (!fragmentName) {	8✔
40	if (logMissingFragmentNames) {	6!
UNCOV 41	const data = JSON.stringify(fieldNodes, null, 2);	×
42	// eslint-disable-next-line no-console
UNCOV 43	console.error("Fragment name not found for", fieldName, data);	×
44	}
45	return null;	6✔
46	}
47	return fragmentName;	2✔
48	}
49
50	// Default resolvers. Provides `single` and `multi` resolvers, which power the
51	// useSingle and useMulti hooks.
52	export function getDefaultResolvers<N extends CollectionNameString>(
53	collectionName: N,
54	options?: Partial<DefaultResolverOptions>,
55	) {
56	type T = ObjectsByCollectionName[N]
57	const typeName = collectionNameToGraphQLType(collectionName);	1,122✔
58	const resolverOptions = {...defaultOptions, options};	1,122✔
59
60	return {	1,122✔
61	// resolver for returning a list of documents based on a set of query terms
62
63	multi: {
64	description: `A list of ${typeName} documents matching a set of query terms`,
65
66	async resolver(
67	root: void,
68	args: {
69	input: {
70	terms: ViewTermsBase & Record<string, unknown>,
71	enableCache?: boolean,
72	enableTotal?: boolean,
73	createIfMissing?: Partial<T>,
74	},
75	},
76	context: ResolverContext,
77	info: GraphQLResolveInfo,
78	) {
79	// const startResolve = Date.now()
80	const input = args?.input \|\| {};	3!
81	const { terms={}, enableCache = false, enableTotal = false } = input;	3!
82	const logger = loggerConstructor(`views-${collectionName.toLowerCase()}-${terms.view?.toLowerCase() ?? 'default'}`)	3!
83	logger('multi resolver()')	3✔
84	logger('multi terms', terms)	3✔
85
86	// Don't allow API requests with an arbitrarily large offset. This
87	// prevents some extremely-slow queries.
88	const maxAllowedSkip = maxAllowedApiSkip.get();	3✔
89	if (	3!
90	terms.offset &&	3!
91	maxAllowedSkip !== null &&
92	terms.offset > maxAllowedSkip
93	) {
UNCOV 94	throw new Error("Exceeded maximum value for skip");	×
95	}
96
97	const {cacheControl} = info;	3✔
98	if (cacheControl && enableCache) {	3!
UNCOV 99	const maxAge = resolverOptions.cacheMaxAge \|\| defaultOptions.cacheMaxAge;	×
UNCOV 100	cacheControl.setCacheHint({ maxAge });	×
101	}
102
103	// get currentUser and Users collection from context
104	const { currentUser }: {currentUser: DbUser\|null} = context;	3✔
105
106	// get collection based on collectionName argument
107	const collection = getCollection(collectionName);	3✔
108
109	// Get selector and options from terms and perform Mongo query
110	// Downcasts terms because there are collection-specific terms but this function isn't collection-specific
111	const parameters = viewTermsToQuery(collectionName, terms, {}, context);	3✔
112
113	// get fragment from GraphQL AST
114	const fragmentName = getFragmentNameFromInfo(info, "results");	3✔
115
116	let fetchDocs: () => Promise<T[]>;
117	if (fragmentName) {	3!
UNCOV 118	const query = new SelectFragmentQuery(	×
119	fragmentName as FragmentName,
120	currentUser,
121	terms,
122	parameters.selector,
123	parameters.syntheticFields,
124	parameters.options,
125	);
UNCOV 126	const compiledQuery = query.compile();	×
UNCOV 127	const db = getSqlClientOrThrow();	×
UNCOV 128	fetchDocs = () => db.any(compiledQuery.sql, compiledQuery.args);	×
129	} else {
130	fetchDocs = () => performQueryFromViewParameters(	3✔
131	collection,
132	terms,
133	parameters,
134	);
135	}
136	let docs = await fetchDocs();	3✔
137
138	// Create a doc if none exist, using the actual create mutation to ensure permission checks are run correctly
139	if (input.createIfMissing && docs.length === 0) {	3!
UNCOV 140	await collection.options.mutations.create.mutation(root, {data: input.createIfMissing}, context)	×
UNCOV 141	docs = await fetchDocs();	×
142	}
143
144	// Were there enough results to reach the limit specified in the query?
145	const saturated = parameters.options.limit && docs.length>=parameters.options.limit;	3✔
146
147	// if collection has a checkAccess function defined, remove any documents that doesn't pass the check
148	const viewableDocs: Array<T> = collection.checkAccess	3✔
149	? await asyncFilter(docs, async (doc: T) => await collection.checkAccess(currentUser, doc, context))	23!
150	: docs;
151
152	// take the remaining documents and remove any fields that shouldn't be accessible
153	const restrictedDocs = restrictViewableFieldsMultiple(currentUser, collection, viewableDocs);	3✔
154
155	// prime the cache
156	restrictedDocs.forEach((doc: AnyBecauseTodo) => context.loaders[collectionName].prime(doc._id, doc));	23✔
157
158	const data: any = { results: restrictedDocs };	3✔
159
160	if (enableTotal) {	3!
161	// get total count of documents matching the selector
162	// TODO: Make this handle synthetic fields
UNCOV 163	if (saturated) {	×
UNCOV 164	const { hint } = parameters.options;	×
UNCOV 165	data.totalCount = await Utils.Connectors.count(collection, parameters.selector, { hint });	×
166	} else {
UNCOV 167	data.totalCount = viewableDocs.length;	×
168	}
169	}
170
171	// const timeElapsed = Date.now() - startResolve;
172	// Temporarily disabled to investigate performance issues
173	// captureEvent("resolveMultiCompleted", {documentIds: restrictedDocs.map((d: DbObject) => d._id), collectionName, timeElapsed, terms}, true);
174	// return results
175	return data;	3✔
176	},
177	},
178
179	// resolver for returning a single document queried based on id or slug
180
181	single: {
182	description: `A single ${typeName} document fetched by ID or slug`,
183
184	async resolver(
185	_root: void,
186	{input = {}}: {input: AnyBecauseTodo},	×
187	context: ResolverContext,
188	info: GraphQLResolveInfo,
189	) {
190	// const startResolve = Date.now();
191	const {enableCache = false, allowNull = false, terms} = input;	5✔
192	// In this context (for reasons I don't fully understand) selector is an object with a null prototype, i.e.
193	// it has none of the methods you would usually associate with objects like `toString`. This causes various problems
194	// down the line. See https://stackoverflow.com/questions/56298481/how-to-fix-object-null-prototype-title-product
195	// So we copy it here to give it back those methoods
196	const selector = {...(input.selector \|\| {})}	5!
197
198	const logger = loggerConstructor(`resolvers-${collectionName.toLowerCase()}`)	5✔
199	const {logGroupStart, logGroupEnd} = logGroupConstructor(`resolvers-${collectionName.toLowerCase()}`)	5✔
200	logger('');	5✔
201	logGroupStart(	5✔
202	`--------------- start \x1b[35m${typeName} Single Resolver\x1b[0m ---------------`
203	);
204	logger(`Options: ${JSON.stringify(resolverOptions)}`);	5✔
205	logger(`Selector: ${JSON.stringify(selector)}`);	5✔
206
207	const {cacheControl} = info;	5✔
208	if (cacheControl && enableCache) {	5!
UNCOV 209	const maxAge = resolverOptions.cacheMaxAge \|\| defaultOptions.cacheMaxAge;	×
UNCOV 210	cacheControl.setCacheHint({ maxAge });	×
211	}
212
213	const { currentUser }: {currentUser: DbUser\|null} = context;	5✔
214	const collection = getCollection(collectionName);	5✔
215
216	// useSingle allows passing in `_id` as `documentId`
217	if (selector.documentId) {	5✔
218	selector._id = selector.documentId;	2✔
219	delete selector.documentId;	2✔
220	}
221	const documentId = selector._id;	5✔
222
223	// get fragment from GraphQL AST
224	const fragmentName = getFragmentNameFromInfo(info, "result");	5✔
225
226	let doc: ObjectsByCollectionName[N] \| null;
227	if (fragmentName) {	5✔
228	const query = new SelectFragmentQuery(	2✔
229	fragmentName as FragmentName,
230	currentUser,
231	terms,
232	selector,
233	undefined,
234	{limit: 1},
235	);
236	const compiledQuery = query.compile();	2✔
237	const db = getSqlClientOrThrow();	2✔
238	doc = await db.oneOrNone(compiledQuery.sql, compiledQuery.args);	2✔
239	} else {
240	doc = await Utils.Connectors.get(collection, selector);	3✔
241	}
242
243	if (!doc) {	5!
UNCOV 244	if (allowNull) {	×
UNCOV 245	return { result: null };	×
246	} else {
UNCOV 247	Utils.throwError({	×
248	id: 'app.missing_document',
249	data: { documentId, selector, collectionName: collection.collectionName },
250	});
251	}
252	}
253
254	// if collection has a checkAccess function defined, use it to perform a check on the current document
255	// (will throw an error if check doesn't pass)
256	if (collection.checkAccess) {	5✔
257	const reasonDenied: {reason?: string} = {reason: undefined};	2✔
258	const canAccess = await collection.checkAccess(currentUser, doc, context, reasonDenied)	2✔
259	if (!canAccess) {	2!
UNCOV 260	if (reasonDenied.reason) {	×
UNCOV 261	Utils.throwError({	×
262	id: reasonDenied.reason,
263	});
264	} else {
UNCOV 265	Utils.throwError({	×
266	id: 'app.operation_not_allowed',
267	data: {documentId, operationName: `${typeName}.read.single`}
268	});
269	}
270	}
271	}
272
273	const restrictedDoc = restrictViewableFieldsSingle(currentUser, collection, doc);	5✔
274
275	logGroupEnd();	5✔
276	logger(`--------------- end \x1b[35m${typeName} Single Resolver\x1b[0m ---------------`);	5✔
277	logger('');	5✔
278
279	// const timeElapsed = Date.now() - startResolve;
280	// Temporarily disabled to investigate performance issues
281	// captureEvent("resolveSingleCompleted", {documentId: restrictedDoc._id, collectionName, timeElapsed}, true);
282
283	// filter out disallowed properties and return resulting document
284	return { result: restrictedDoc };	5✔
285	},
286	},
287	};
288	}
289
290	export const performQueryFromViewParameters = async <N extends CollectionNameString>(	26✔
291	collection: CollectionBase<N>,
292	terms: ViewTermsBase,
293	parameters: AnyBecauseTodo,
294	): Promise<ObjectsByCollectionName[N][]> => {
295	const logger = loggerConstructor(`views-${collection.collectionName.toLowerCase()}`)	3✔
296	const selector = parameters.selector;	3✔
297	const description = describeTerms(collection.collectionName, terms);	3✔
298
299	const options: MongoFindOptions<ObjectsByCollectionName[N]> = {	3✔
300	...parameters.options,
301	skip: terms.offset,
302	comment: description
303	};
304
305	// I don't know if we ever get a `skip` value in `parameters.options`, but if we do, we've been running on that logic for years
306	// So defer to that if it exists, instead of overriding it with the value from `terms.offset`
307	parameters.options.skip ??= options.skip;	3!
308
309	if (parameters.syntheticFields && Object.keys(parameters.syntheticFields).length>0) {	3!
310	const pipeline = [	3✔
311	// First stage: Filter by selector
312	{ $match: {
313	...selector,
314	$comment: description,
315	}},
316	// Second stage: Add computed fields
317	{ $addFields: parameters.syntheticFields },
318
319	// Third stage: Filter by computed fields (if applicable)
320	...(parameters.syntheticFieldSelector \|\| []),	6✔
321
322	// Fourth stage: Sort
323	{ $sort: parameters.options.sort },
324	];
325
326	// Apply skip and limit (if applicable)
327	if (parameters.options.skip) {	3!
UNCOV 328	pipeline.push({ $skip: parameters.options.skip });	×
329	}
330	if (parameters.options.limit) {	3!
331	pipeline.push({ $limit: parameters.options.limit });	3✔
332	}
333	logger('aggregation pipeline', pipeline);	3✔
334	return await collection.aggregate(pipeline).toArray();	3✔
335	} else {
UNCOV 336	logger('performQueryFromViewParameters connector find', selector, terms, options);	×
UNCOV 337	return await collection.find({	×
338	...selector,
339	}, options).fetch();
340	}
341	}

ForumMagnum / ForumMagnum / 9356176728

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