9033381252

Committed 10 May 2024 08:47AM UTC coverage: 31.922% (+0.02%) from 31.899%

Build # 9033381252

Build Type

Pull #9209

github

Committed by

Will-Howard

Commit Message

remove allowConcurrent option

Pull Request Pull Request #9209: Make clientId field in ClientIds non-nullable and unique

Run Details

4767 of 38939 branches covered (12.24%)

Branch coverage included in aggregate %.

26 of 31 new or added lines in 7 files covered. (83.87%)

382 existing lines in 19 files now uncovered.

27736 of 62881 relevant lines covered (44.11%)

178.64 hits per line

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

56.47

/packages/lesswrong/lib/sql/PgCollection.ts

import { getSqlClient, getSqlClientOrThrow } from "../sql/sqlClient";
import Table from "./Table";
import Query from "./Query";
import InsertQuery from "./InsertQuery";
import SelectQuery from "./SelectQuery";
import UpdateQuery from "./UpdateQuery";
import DeleteQuery from "./DeleteQuery";
import CreateIndexQuery from "./CreateIndexQuery";
import DropIndexQuery from "./DropIndexQuery";
import Pipeline from "./Pipeline";
import BulkWriter, { BulkWriterResult } from "./BulkWriter";
import util from "util";

let executingQueries = 0;

export const isAnyQueryPending = () => executingQueries > 0;

export type DbTarget = "read" | "write" | "noTransaction";

type ExecuteQueryData<T extends DbObject> = {
  selector: MongoSelector<T> | string;
  projection: MongoProjection<T>;
  data: T;
  modifier: MongoModifier<T>;
  fieldOrSpec: MongoIndexFieldOrKey<T>;
  pipeline: MongoAggregationPipeline<T>;
  operations: MongoBulkWriteOperations<T>;
  indexName: string;
  options: MongoFindOptions<T>
    | MongoUpdateOptions<T>
    | MongoUpdateOptions<T>
    | MongoRemoveOptions<T>
    | MongoEnsureIndexOptions<T>
    | MongoAggregationOptions
    | MongoBulkWriteOptions
    | MongoDropIndexOptions;
}

/**
 * PgCollection is the main external interface for other parts of the codebase to
 * access data inside of Postgres.
 */
class PgCollection<
  N extends CollectionNameString = CollectionNameString
> implements CollectionBase<N> {
  collectionName: N;
  tableName: string;
  defaultView: ViewFunction<N> | undefined;
  views: Record<string, ViewFunction<N>> = {};
  postProcess?: (data: ObjectsByCollectionName[N]) => ObjectsByCollectionName[N];
  typeName: string;
  options: CollectionOptions<N>;
  _schemaFields: SchemaType<N>;
  _simpleSchema: any;
  checkAccess: CheckAccessFunction<ObjectsByCollectionName[N]>;
  private table: Table<ObjectsByCollectionName[N]>;
  private voteable = false;

  constructor(tableName: string, options: CollectionOptions<N>) {
    this.tableName = tableName;
    this.options = options;
  }

  isConnected() {
    return !!getSqlClient();
  }

  isVoteable() {
    return this.voteable;
  }

  makeVoteable() {
    this.voteable = true;
  }

  hasSlug() {
    return !!this._schemaFields.slug;
  }

  getTable() {
    if (bundleIsServer) {
      return this.table;
    } else {
      throw new Error("Attempted to run postgres query on the client");
    }
  }

  buildPostgresTable() {
    this.table = Table.fromCollection<N>(this);
  }

  /**
   * Execute the given query
   * The `data` parameter is completely optional and is only used to improve
   * the error message if something goes wrong. It can also be used to disable
   * logging by setting `data.options.quiet` to `true`.
   */
  async executeQuery(
    query: Query<ObjectsByCollectionName[N]>,
    data?: Partial<ExecuteQueryData<ObjectsByCollectionName[N]>>,
    target: DbTarget = "write"
  ): Promise<any[]> {
    executingQueries++;
    let result: any[];
    const quiet = data?.options?.quiet ?? false;
    try {
      const {sql, args} = query.compile();
      const client = getSqlClientOrThrow(target);

      result = await client.any(sql, args, () => `${sql}: ${JSON.stringify(args)}`, quiet);

    } catch (error) {
      // If this error gets triggered, you probably generated a malformed query
      const {collectionName} = this;
      const stringified = util.inspect({collectionName, ...data}, {depth: null});
      const {sql, args} = query.compile();
      if (!quiet) {
        // eslint-disable-next-line no-console
        console.error(`SQL Error for ${collectionName} at position ${error.position}: ${error.message}: \`${sql}\`: ${util.inspect(args)}: ${stringified}`);
      }
      throw error;
    } finally {
      executingQueries--;
    }
    const {postProcess} = this;
    return postProcess
      ? result.map((data) => postProcess(data))
      : result;
  }

  async executeReadQuery(
    query: Query<ObjectsByCollectionName[N]>,
    data?: Partial<ExecuteQueryData<ObjectsByCollectionName[N]>>,
  ): Promise<any[]> {
    return this.executeQuery(query, data, "read");
  }

  async executeWriteQuery(
    query: Query<ObjectsByCollectionName[N]>,
    data?: Partial<ExecuteQueryData<ObjectsByCollectionName[N]>>,
  ): Promise<any[]> {
    return this.executeQuery(query, data, "write");
  }

  find(
    selector?: MongoSelector<ObjectsByCollectionName[N]>,
    options?: MongoFindOptions<ObjectsByCollectionName[N]>,
    projection?: MongoProjection<ObjectsByCollectionName[N]>,
  ): FindResult<ObjectsByCollectionName[N]> {
    return {
      fetch: async () => {
        const select = new SelectQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, { ...options, projection });
        const result = await this.executeReadQuery(select, {selector, options, projection});
        return result;
      },
      count: async () => {
        const select = new SelectQuery(this.getTable(), selector, { ...options, projection }, {count: true});
        const result = await this.executeReadQuery(select, {selector, options, projection});
        return parseInt(result?.[0].count ?? 0);
      },
    };
  }

  async findOne(
    selector?: string | MongoSelector<ObjectsByCollectionName[N]>,
    options?: MongoFindOneOptions<ObjectsByCollectionName[N]>,
    projection?: MongoProjection<ObjectsByCollectionName[N]>,
  ): Promise<ObjectsByCollectionName[N]|null> {
    const select = new SelectQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, {limit: 1, ...options, projection});
    const result = await this.executeReadQuery(select, {selector, options, projection});
    return result ? result[0] : null;
  }

  async findOneArbitrary(): Promise<ObjectsByCollectionName[N]|null> {
    const select = new SelectQuery<ObjectsByCollectionName[N]>(this.getTable(), undefined, {limit: 1});
    const result = await this.executeReadQuery(select, undefined);
    return result ? result[0] : null;
  }

  async rawInsert(
    data: ObjectsByCollectionName[N],
    options: MongoInsertOptions<ObjectsByCollectionName[N]>,
  ) {
    const insert = new InsertQuery<ObjectsByCollectionName[N]>(this.getTable(), data, options, {returnInserted: true});
    const result = await this.executeWriteQuery(insert, {data, options});
    return result[0]._id;
  }

  private async upsert(
    selector: string | MongoSelector<ObjectsByCollectionName[N]>,
    modifier: MongoModifier<ObjectsByCollectionName[N]>,
    options: MongoUpdateOptions<ObjectsByCollectionName[N]> & {upsert: true},
  ) {
    const {$set, ...rest} = modifier;
    const data = {
      ...$set,
      ...rest,
      ...selector,
    };
    const upsert = new InsertQuery<ObjectsByCollectionName[N]>(this.getTable(), data, options, {
      conflictStrategy: "upsert",
      upsertSelector: selector,
    });
    const result = await this.executeWriteQuery(upsert, {selector, modifier, options});
    const action = result[0]?.action;
    if (!action) {
      return 0;
    }
    const returnCount = options?.returnCount ?? "matchedCount";
    switch (returnCount) {
    case "matchedCount":
      return action === "updated" ? 1 : 0;
    case "upsertedCount":
      return action === "inserted" ? 1 : 0;
    default:
      throw new Error(`Invalid upsert return count: ${returnCount}`);
    }
  }

  async rawUpdateOne(
    selector: string | MongoSelector<ObjectsByCollectionName[N]>,
    modifier: MongoModifier<ObjectsByCollectionName[N]>,
    options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
  ) {
    if (options?.upsert) {
      return this.upsert(selector, modifier, options);
    }
    const update = new UpdateQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, modifier, options, {limit: 1});
    const result = await this.executeWriteQuery(update, {selector, modifier, options});
    return result.length;
  }

  async rawUpdateMany(
    selector: string | MongoSelector<ObjectsByCollectionName[N]>,
    modifier: MongoModifier<ObjectsByCollectionName[N]>,
    options?: MongoUpdateOptions<ObjectsByCollectionName[N]>,
  ) {
    const update = new UpdateQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, modifier, options);
    const result = await this.executeWriteQuery(update, {selector, modifier, options});
    return result.length;
  }

  async rawRemove(
    selector: string | MongoSelector<ObjectsByCollectionName[N]>,
    options?: MongoRemoveOptions<ObjectsByCollectionName[N]>,
  ) {
    options = Object.assign({noSafetyHarness: true}, options);
    const query = new DeleteQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, options, options);
    const result = await this.executeWriteQuery(query, {selector, options});
    return {deletedCount: result.length};
  }

  async _ensureIndex(
    fieldOrSpec: MongoIndexFieldOrKey<ObjectsByCollectionName[N]>,
    options?: MongoEnsureIndexOptions<ObjectsByCollectionName[N]>,
  ) {
    if (!this.table) {
      throw new Error("Postgres tables must be initialized before calling ensureIndex");
    }
    const key: MongoIndexKeyObj<ObjectsByCollectionName[N]> = typeof fieldOrSpec === "string"
      ? {[fieldOrSpec as keyof ObjectsByCollectionName[N]]: 1 as const} as MongoIndexKeyObj<ObjectsByCollectionName[N]>
      : fieldOrSpec;
    const index = this.table.getIndex(Object.keys(key), options) ?? this.getTable().addIndex(key, options);
    const query = new CreateIndexQuery(this.getTable(), index, true);
    const target = options?.concurrently ? "noTransaction" : "write";

    await this.executeQuery(query, {fieldOrSpec, options}, target)
  }

  aggregate = (
    pipeline: MongoAggregationPipeline<ObjectsByCollectionName[N]>,
    options?: MongoAggregationOptions,
    comment?: string,
  ) => {
    return {
      toArray: async () => {
        try {
          const query = new Pipeline(this.getTable(), pipeline, options, comment).toQuery();
          const result = await this.executeReadQuery(query, {pipeline, options});
          return result;
        } catch (e) {
          const {collectionName} = this;
          // If you see this, you probably built a bad aggregation pipeline, or
          // this file has a bug, or you're using an unsupported aggregation
          // pipeline operator
          // eslint-disable-next-line no-console
          console.error("Aggregate error:", collectionName, ":", e, ":", util.inspect(pipeline, {depth: null}));
          throw e;
        }
      },
    };
  }

  rawCollection = () => ({
    bulkWrite: async (
      operations: MongoBulkWriteOperations<ObjectsByCollectionName[N]>,
      options?: MongoBulkWriteOptions,
    ) => {
      executingQueries++;
      let result: BulkWriterResult;
      try {
        const client = getSqlClientOrThrow();
        const writer = new BulkWriter(this.getTable(), operations, options);
        result = await writer.execute(client);
      } finally {
        executingQueries--;
      }
      return result;
    },
    findOneAndUpdate: async (
      selector: string | MongoSelector<ObjectsByCollectionName[N]>,
      modifier: MongoModifier<ObjectsByCollectionName[N]>,
      options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
    ) => {
      const update = new UpdateQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, modifier, options, {limit: 1, returnUpdated: true});
      const result = await this.executeWriteQuery(update, {selector, modifier, options});
      return {
        ok: 1,
        value: result[0],
      };
    },
    dropIndex: async (indexName: string, options?: MongoDropIndexOptions) => {
      const dropIndex = new DropIndexQuery(this.getTable(), indexName);
      await this.executeWriteQuery(dropIndex, {indexName, options})
    },
    indexes: (_options: never) => {
      return Promise.resolve(this.getTable().getIndexes().map((index) => index.getDetails()));
    },
    updateOne: async (
      selector: string | MongoSelector<ObjectsByCollectionName[N]>,
      modifier: MongoModifier<ObjectsByCollectionName[N]>,
      options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
    ) => {
      const result = await this.rawUpdateOne(selector, modifier, options);
      return {
        acknowledged: true,
        matchedCount: result,
        modifiedCount: result,
      };
    },
    updateMany: async (
      selector: string | MongoSelector<ObjectsByCollectionName[N]>,
      modifier: MongoModifier<ObjectsByCollectionName[N]>,
      options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
    ) => {
      await this.rawUpdateMany(selector, modifier, options);
      return {
        ok: 1,
        value: null,
      };
    },
  });

  /**
   * Add a default view function.
   */
  addDefaultView(view: ViewFunction<N>) {
    this.defaultView = view;
  }

  /**
   * Add a named view function.
   */
  addView(viewName: string, view: ViewFunction<N>) {
    this.views[viewName] = view;
  }
}

export default PgCollection;

1	import { getSqlClient, getSqlClientOrThrow } from "../sql/sqlClient";	53,185✔
2	import Table from "./Table";	45✔
3	import Query from "./Query";
4	import InsertQuery from "./InsertQuery";	45✔
5	import SelectQuery from "./SelectQuery";	45✔
6	import UpdateQuery from "./UpdateQuery";	45✔
7	import DeleteQuery from "./DeleteQuery";	45✔
8	import CreateIndexQuery from "./CreateIndexQuery";	45✔
9	import DropIndexQuery from "./DropIndexQuery";	45✔
10	import Pipeline from "./Pipeline";	45✔
11	import BulkWriter, { BulkWriterResult } from "./BulkWriter";	45✔
12	import util from "util";	45✔
13
14	let executingQueries = 0;	45✔
15
16	export const isAnyQueryPending = () => executingQueries > 0;	422✔
17
18	export type DbTarget = "read" \| "write" \| "noTransaction";
19
20	type ExecuteQueryData<T extends DbObject> = {
21	selector: MongoSelector<T> \| string;
22	projection: MongoProjection<T>;
23	data: T;
24	modifier: MongoModifier<T>;
25	fieldOrSpec: MongoIndexFieldOrKey<T>;
26	pipeline: MongoAggregationPipeline<T>;
27	operations: MongoBulkWriteOperations<T>;
28	indexName: string;
29	options: MongoFindOptions<T>
30	\| MongoUpdateOptions<T>
31	\| MongoUpdateOptions<T>
32	\| MongoRemoveOptions<T>
33	\| MongoEnsureIndexOptions<T>
34	\| MongoAggregationOptions
35	\| MongoBulkWriteOptions
36	\| MongoDropIndexOptions;
37	}
38
39	/**
40	* PgCollection is the main external interface for other parts of the codebase to
41	* access data inside of Postgres.
42	*/
43	class PgCollection<
44	N extends CollectionNameString = CollectionNameString
45	> implements CollectionBase<N> {
46	collectionName: N;
47	tableName: string;
48	defaultView: ViewFunction<N> \| undefined;
49	views: Record<string, ViewFunction<N>> = {};	1,479✔
50	postProcess?: (data: ObjectsByCollectionName[N]) => ObjectsByCollectionName[N];
51	typeName: string;
52	options: CollectionOptions<N>;
53	_schemaFields: SchemaType<N>;
54	_simpleSchema: any;
55	checkAccess: CheckAccessFunction<ObjectsByCollectionName[N]>;
56	private table: Table<ObjectsByCollectionName[N]>;
57	private voteable = false;	1,479✔
58
59	constructor(tableName: string, options: CollectionOptions<N>) {
60	this.tableName = tableName;	1,479✔
61	this.options = options;	1,479✔
62	}
63
64	isConnected() {
65	return !!getSqlClient();	×
66	}
67
68	isVoteable() {
69	return this.voteable;	×
70	}
71
72	makeVoteable() {
73	this.voteable = true;	105✔
74	}
75
76	hasSlug() {
77	return !!this._schemaFields.slug;	267✔
78	}
79
80	getTable() {
81	if (bundleIsServer) {	9,657!
82	return this.table;	9,657✔
83	} else {
84	throw new Error("Attempted to run postgres query on the client");	×
85	}
86	}
87
88	buildPostgresTable() {
89	this.table = Table.fromCollection<N>(this);	1,184✔
90	}
91
92	/**
93	* Execute the given query
94	* The `data` parameter is completely optional and is only used to improve
95	* the error message if something goes wrong. It can also be used to disable
96	* logging by setting `data.options.quiet` to `true`.
97	*/
98	async executeQuery(
99	query: Query<ObjectsByCollectionName[N]>,
100	data?: Partial<ExecuteQueryData<ObjectsByCollectionName[N]>>,
101	target: DbTarget = "write"	×
102	): Promise<any[]> {
103	executingQueries++;	8,075✔
104	let result: any[];
105	const quiet = data?.options?.quiet ?? false;	8,075!
106	try {	8,075✔
107	const {sql, args} = query.compile();	8,075✔
108	const client = getSqlClientOrThrow(target);	8,075✔
109
110	result = await client.any(sql, args, () => `${sql}: ${JSON.stringify(args)}`, quiet);	8,075✔
111
112	} catch (error) {
113	// If this error gets triggered, you probably generated a malformed query
114	const {collectionName} = this;	×
115	const stringified = util.inspect({collectionName, ...data}, {depth: null});	×
116	const {sql, args} = query.compile();	×
117	if (!quiet) {	×
118	// eslint-disable-next-line no-console
119	console.error(`SQL Error for ${collectionName} at position ${error.position}: ${error.message}: \`${sql}\`: ${util.inspect(args)}: ${stringified}`);	×
120	}
121	throw error;	×
122	} finally {
123	executingQueries--;	8,075✔
124	}
125	const {postProcess} = this;	8,075✔
126	return postProcess	8,075✔
127	? result.map((data) => postProcess(data))	2,595✔
128	: result;
129	}
130
131	async executeReadQuery(
132	query: Query<ObjectsByCollectionName[N]>,
133	data?: Partial<ExecuteQueryData<ObjectsByCollectionName[N]>>,
134	): Promise<any[]> {
135	return this.executeQuery(query, data, "read");	6,050✔
136	}
137
138	async executeWriteQuery(
139	query: Query<ObjectsByCollectionName[N]>,
140	data?: Partial<ExecuteQueryData<ObjectsByCollectionName[N]>>,
141	): Promise<any[]> {
142	return this.executeQuery(query, data, "write");	2,025✔
143	}
144
145	find(
146	selector?: MongoSelector<ObjectsByCollectionName[N]>,
147	options?: MongoFindOptions<ObjectsByCollectionName[N]>,
148	projection?: MongoProjection<ObjectsByCollectionName[N]>,
149	): FindResult<ObjectsByCollectionName[N]> {
150	return {	1,277✔
151	fetch: async () => {
152	const select = new SelectQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, { ...options, projection });	1,274✔
153	const result = await this.executeReadQuery(select, {selector, options, projection});	1,274✔
154	return result;	1,274✔
155	},
156	count: async () => {
157	const select = new SelectQuery(this.getTable(), selector, { ...options, projection }, {count: true});	3✔
158	const result = await this.executeReadQuery(select, {selector, options, projection});	3✔
159	return parseInt(result?.[0].count ?? 0);	3!
160	},
161	};
162	}
163
164	async findOne(
165	selector?: string \| MongoSelector<ObjectsByCollectionName[N]>,
166	options?: MongoFindOneOptions<ObjectsByCollectionName[N]>,
167	projection?: MongoProjection<ObjectsByCollectionName[N]>,
168	): Promise<ObjectsByCollectionName[N]\|null> {
169	const select = new SelectQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, {limit: 1, ...options, projection});	4,769✔
170	const result = await this.executeReadQuery(select, {selector, options, projection});	4,769✔
171	return result ? result[0] : null;	4,769!
172	}
173
174	async findOneArbitrary(): Promise<ObjectsByCollectionName[N]\|null> {
175	const select = new SelectQuery<ObjectsByCollectionName[N]>(this.getTable(), undefined, {limit: 1});	1✔
176	const result = await this.executeReadQuery(select, undefined);	1✔
177	return result ? result[0] : null;	1!
178	}
179
180	async rawInsert(
181	data: ObjectsByCollectionName[N],
182	options: MongoInsertOptions<ObjectsByCollectionName[N]>,
183	) {
184	const insert = new InsertQuery<ObjectsByCollectionName[N]>(this.getTable(), data, options, {returnInserted: true});	525✔
185	const result = await this.executeWriteQuery(insert, {data, options});	525✔
186	return result[0]._id;	525✔
187	}
188
189	private async upsert(
190	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
191	modifier: MongoModifier<ObjectsByCollectionName[N]>,
192	options: MongoUpdateOptions<ObjectsByCollectionName[N]> & {upsert: true},
193	) {
194	const {$set, ...rest} = modifier;	×
195	const data = {	×
196	...$set,
197	...rest,
198	...selector,
199	};
200	const upsert = new InsertQuery<ObjectsByCollectionName[N]>(this.getTable(), data, options, {	×
201	conflictStrategy: "upsert",
202	upsertSelector: selector,
203	});
204	const result = await this.executeWriteQuery(upsert, {selector, modifier, options});	×
205	const action = result[0]?.action;	×
206	if (!action) {	×
207	return 0;	×
208	}
209	const returnCount = options?.returnCount ?? "matchedCount";	×
210	switch (returnCount) {	×
211	case "matchedCount":
212	return action === "updated" ? 1 : 0;	×
213	case "upsertedCount":
214	return action === "inserted" ? 1 : 0;	×
215	default:
216	throw new Error(`Invalid upsert return count: ${returnCount}`);	×
217	}
218	}
219
220	async rawUpdateOne(
221	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
222	modifier: MongoModifier<ObjectsByCollectionName[N]>,
223	options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
224	) {
225	if (options?.upsert) {	1,413!
226	return this.upsert(selector, modifier, options);	×
227	}
228	const update = new UpdateQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, modifier, options, {limit: 1});	1,413✔
229	const result = await this.executeWriteQuery(update, {selector, modifier, options});	1,413✔
230	return result.length;	1,413✔
231	}
232
233	async rawUpdateMany(
234	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
235	modifier: MongoModifier<ObjectsByCollectionName[N]>,
236	options?: MongoUpdateOptions<ObjectsByCollectionName[N]>,
237	) {
238	const update = new UpdateQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, modifier, options);	66✔
239	const result = await this.executeWriteQuery(update, {selector, modifier, options});	66✔
240	return result.length;	66✔
241	}
242
243	async rawRemove(
244	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
245	options?: MongoRemoveOptions<ObjectsByCollectionName[N]>,
246	) {
247	options = Object.assign({noSafetyHarness: true}, options);	5✔
248	const query = new DeleteQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, options, options);	5✔
249	const result = await this.executeWriteQuery(query, {selector, options});	5✔
250	return {deletedCount: result.length};	5✔
251	}
252
253	async _ensureIndex(
254	fieldOrSpec: MongoIndexFieldOrKey<ObjectsByCollectionName[N]>,
255	options?: MongoEnsureIndexOptions<ObjectsByCollectionName[N]>,
256	) {
257	if (!this.table) {	×
258	throw new Error("Postgres tables must be initialized before calling ensureIndex");	×
259	}
260	const key: MongoIndexKeyObj<ObjectsByCollectionName[N]> = typeof fieldOrSpec === "string"	×
261	? {[fieldOrSpec as keyof ObjectsByCollectionName[N]]: 1 as const} as MongoIndexKeyObj<ObjectsByCollectionName[N]>	×
262	: fieldOrSpec;
263	const index = this.table.getIndex(Object.keys(key), options) ?? this.getTable().addIndex(key, options);	×
264	const query = new CreateIndexQuery(this.getTable(), index, true);	×
NEW 265	const target = options?.concurrently ? "noTransaction" : "write";	×
266
NEW 267	await this.executeQuery(query, {fieldOrSpec, options}, target)	×
268	}
269
270	aggregate = (	1,479✔
271	pipeline: MongoAggregationPipeline<ObjectsByCollectionName[N]>,
272	options?: MongoAggregationOptions,
273	comment?: string,
274	) => {
275	return {	3✔
276	toArray: async () => {
277	try {	3✔
278	const query = new Pipeline(this.getTable(), pipeline, options, comment).toQuery();	3✔
279	const result = await this.executeReadQuery(query, {pipeline, options});	3✔
280	return result;	3✔
281	} catch (e) {
282	const {collectionName} = this;	×
283	// If you see this, you probably built a bad aggregation pipeline, or
284	// this file has a bug, or you're using an unsupported aggregation
285	// pipeline operator
286	// eslint-disable-next-line no-console
287	console.error("Aggregate error:", collectionName, ":", e, ":", util.inspect(pipeline, {depth: null}));	×
288	throw e;	×
289	}
290	},
291	};
292	}
293
294	rawCollection = () => ({	1,479✔
295	bulkWrite: async (
296	operations: MongoBulkWriteOperations<ObjectsByCollectionName[N]>,
297	options?: MongoBulkWriteOptions,
298	) => {
299	executingQueries++;	392✔
300	let result: BulkWriterResult;
301	try {	392✔
302	const client = getSqlClientOrThrow();	392✔
303	const writer = new BulkWriter(this.getTable(), operations, options);	392✔
304	result = await writer.execute(client);	392✔
305	} finally {
306	executingQueries--;	392✔
307	}
308	return result;	392✔
309	},
310	findOneAndUpdate: async (
311	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
312	modifier: MongoModifier<ObjectsByCollectionName[N]>,
313	options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
314	) => {
315	const update = new UpdateQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, modifier, options, {limit: 1, returnUpdated: true});	16✔
316	const result = await this.executeWriteQuery(update, {selector, modifier, options});	16✔
317	return {	16✔
318	ok: 1,
319	value: result[0],
320	};
321	},
322	dropIndex: async (indexName: string, options?: MongoDropIndexOptions) => {
323	const dropIndex = new DropIndexQuery(this.getTable(), indexName);	×
324	await this.executeWriteQuery(dropIndex, {indexName, options})	×
325	},
326	indexes: (_options: never) => {
327	return Promise.resolve(this.getTable().getIndexes().map((index) => index.getDetails()));	×
328	},
329	updateOne: async (
330	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
331	modifier: MongoModifier<ObjectsByCollectionName[N]>,
332	options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
333	) => {
334	const result = await this.rawUpdateOne(selector, modifier, options);	×
335	return {	×
336	acknowledged: true,
337	matchedCount: result,
338	modifiedCount: result,
339	};
340	},
341	updateMany: async (
342	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
343	modifier: MongoModifier<ObjectsByCollectionName[N]>,
344	options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
345	) => {
346	await this.rawUpdateMany(selector, modifier, options);	×
347	return {	×
348	ok: 1,
349	value: null,
350	};
351	},
352	});
353
354	/**
355	* Add a default view function.
356	*/
357	addDefaultView(view: ViewFunction<N>) {
358	this.defaultView = view;	250✔
359	}
360
361	/**
362	* Add a named view function.
363	*/
364	addView(viewName: string, view: ViewFunction<N>) {
365	this.views[viewName] = view;	4,329✔
366	}
367	}
368
369	export default PgCollection;	45✔

ForumMagnum / ForumMagnum / 9033381252

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