9117246995

Committed 16 May 2024 06:19PM UTC coverage: 31.986% (+0.08%) from 31.906%

Build # 9117246995

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9295 from ForumMagnum/master

Deploy LW

Run Details

4792 of 38919 branches covered (12.31%)

Branch coverage included in aggregate %.

17 of 44 new or added lines in 20 files covered. (38.64%)

2 existing lines in 2 files now uncovered.

27792 of 62952 relevant lines covered (44.15%)

180.64 hits per line

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

55.17

/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({ table: this.getTable(), index, ifNotExists: true });

    if (!options?.concurrently) {
      await this.executeQuery(query, {fieldOrSpec, options}, "write")
    } else {
      // eslint-disable-next-line no-console
      console.warn(
        `Running CREATE INDEX CONCURRENTLY query without waiting for it to complete, ` +
        `as this would cause a deadlock. If your code relies on this index existing immediately ` +
        `you should deploy in two stages. This is the query in question: "${query.compile()?.sql}"`
      )
      void this.executeQuery(query, {fieldOrSpec, options}, "noTransaction")
    }
  }

  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,049✔
2	import Table from "./Table";	44✔
3	import Query from "./Query";
4	import InsertQuery from "./InsertQuery";	44✔
5	import SelectQuery from "./SelectQuery";	44✔
6	import UpdateQuery from "./UpdateQuery";	44✔
7	import DeleteQuery from "./DeleteQuery";	44✔
8	import CreateIndexQuery from "./CreateIndexQuery";	44✔
9	import DropIndexQuery from "./DropIndexQuery";	44✔
10	import Pipeline from "./Pipeline";	44✔
11	import BulkWriter, { BulkWriterResult } from "./BulkWriter";	44✔
12	import util from "util";	44✔
13
14	let executingQueries = 0;	44✔
15
16	export const isAnyQueryPending = () => executingQueries > 0;	411✔
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,477✔
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,477✔
58
59	constructor(tableName: string, options: CollectionOptions<N>) {
60	this.tableName = tableName;	1,477✔
61	this.options = options;	1,477✔
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,366!
82	return this.table;	9,366✔
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++;	7,783✔
104	let result: any[];
105	const quiet = data?.options?.quiet ?? false;	7,783!
106	try {	7,783✔
107	const {sql, args} = query.compile();	7,783✔
108	const client = getSqlClientOrThrow(target);	7,783✔
109
110	result = await client.any(sql, args, () => `${sql}: ${JSON.stringify(args)}`, quiet);	7,783✔
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--;	7,783✔
124	}
125	const {postProcess} = this;	7,783✔
126	return postProcess	7,783✔
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");	5,856✔
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");	1,927✔
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,575✔
170	const result = await this.executeReadQuery(select, {selector, options, projection});	4,575✔
171	return result ? result[0] : null;	4,575!
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});	523✔
185	const result = await this.executeWriteQuery(insert, {data, options});	523✔
186	return result[0]._id;	523✔
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,317!
226	return this.upsert(selector, modifier, options);	×
227	}
228	const update = new UpdateQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, modifier, options, {limit: 1});	1,317✔
229	const result = await this.executeWriteQuery(update, {selector, modifier, options});	1,317✔
230	return result.length;	1,317✔
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);	×
NEW 264	const query = new CreateIndexQuery({ table: this.getTable(), index, ifNotExists: true });	×
265
NEW 266	if (!options?.concurrently) {	×
NEW 267	await this.executeQuery(query, {fieldOrSpec, options}, "write")	×
268	} else {
269	// eslint-disable-next-line no-console
NEW 270	console.warn(	×
271	`Running CREATE INDEX CONCURRENTLY query without waiting for it to complete, ` +
272	`as this would cause a deadlock. If your code relies on this index existing immediately ` +
273	`you should deploy in two stages. This is the query in question: "${query.compile()?.sql}"`	×
274	)
NEW 275	void this.executeQuery(query, {fieldOrSpec, options}, "noTransaction")	×
276	}
277	}
278
279	aggregate = (	1,477✔
280	pipeline: MongoAggregationPipeline<ObjectsByCollectionName[N]>,
281	options?: MongoAggregationOptions,
282	comment?: string,
283	) => {
284	return {	3✔
285	toArray: async () => {
286	try {	3✔
287	const query = new Pipeline(this.getTable(), pipeline, options, comment).toQuery();	3✔
288	const result = await this.executeReadQuery(query, {pipeline, options});	3✔
289	return result;	3✔
290	} catch (e) {
291	const {collectionName} = this;	×
292	// If you see this, you probably built a bad aggregation pipeline, or
293	// this file has a bug, or you're using an unsupported aggregation
294	// pipeline operator
295	// eslint-disable-next-line no-console
296	console.error("Aggregate error:", collectionName, ":", e, ":", util.inspect(pipeline, {depth: null}));	×
297	throw e;	×
298	}
299	},
300	};
301	}
302
303	rawCollection = () => ({	1,477✔
304	bulkWrite: async (
305	operations: MongoBulkWriteOperations<ObjectsByCollectionName[N]>,
306	options?: MongoBulkWriteOptions,
307	) => {
308	executingQueries++;	393✔
309	let result: BulkWriterResult;
310	try {	393✔
311	const client = getSqlClientOrThrow();	393✔
312	const writer = new BulkWriter(this.getTable(), operations, options);	393✔
313	result = await writer.execute(client);	393✔
314	} finally {
315	executingQueries--;	393✔
316	}
317	return result;	393✔
318	},
319	findOneAndUpdate: async (
320	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
321	modifier: MongoModifier<ObjectsByCollectionName[N]>,
322	options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
323	) => {
324	const update = new UpdateQuery<ObjectsByCollectionName[N]>(this.getTable(), selector, modifier, options, {limit: 1, returnUpdated: true});	16✔
325	const result = await this.executeWriteQuery(update, {selector, modifier, options});	16✔
326	return {	16✔
327	ok: 1,
328	value: result[0],
329	};
330	},
331	dropIndex: async (indexName: string, options?: MongoDropIndexOptions) => {
332	const dropIndex = new DropIndexQuery(this.getTable(), indexName);	×
333	await this.executeWriteQuery(dropIndex, {indexName, options})	×
334	},
335	indexes: (_options: never) => {
336	return Promise.resolve(this.getTable().getIndexes().map((index) => index.getDetails()));	×
337	},
338	updateOne: async (
339	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
340	modifier: MongoModifier<ObjectsByCollectionName[N]>,
341	options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
342	) => {
343	const result = await this.rawUpdateOne(selector, modifier, options);	×
344	return {	×
345	acknowledged: true,
346	matchedCount: result,
347	modifiedCount: result,
348	};
349	},
350	updateMany: async (
351	selector: string \| MongoSelector<ObjectsByCollectionName[N]>,
352	modifier: MongoModifier<ObjectsByCollectionName[N]>,
353	options: MongoUpdateOptions<ObjectsByCollectionName[N]>,
354	) => {
355	await this.rawUpdateMany(selector, modifier, options);	×
356	return {	×
357	ok: 1,
358	value: null,
359	};
360	},
361	});
362
363	/**
364	* Add a default view function.
365	*/
366	addDefaultView(view: ViewFunction<N>) {
367	this.defaultView = view;	250✔
368	}
369
370	/**
371	* Add a named view function.
372	*/
373	addView(viewName: string, view: ViewFunction<N>) {
374	this.views[viewName] = view;	4,329✔
375	}
376	}
377
378	export default PgCollection;	44✔

ForumMagnum / ForumMagnum / 9117246995

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