Extremely Popular
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379import { Bson } from "../../deps.ts";import { MongoDriverError, MongoInvalidArgumentError } from "../error.ts";import { WireProtocol } from "../protocol/mod.ts";import { AggregateOptions, AggregatePipeline, CountOptions, CreateIndexOptions, DeleteOptions, DistinctOptions, Document, DropIndexOptions, DropOptions, Filter, FindAndModifyOptions, FindOptions, InsertDocument, InsertOptions, UpdateFilter, UpdateOptions,} from "../types.ts";import { AggregateCursor } from "./commands/aggregate.ts";import { FindCursor } from "./commands/find.ts";import { ListIndexesCursor } from "./commands/list_indexes.ts";import { update } from "./commands/update.ts";
export class Collection<T> { #protocol: WireProtocol; #dbName: string;
constructor(protocol: WireProtocol, dbName: string, readonly name: string) { this.#protocol = protocol; this.#dbName = dbName; }
find( filter?: Filter<T>, options?: FindOptions, ): FindCursor<T> { return new FindCursor<T>({ filter, protocol: this.#protocol, collectionName: this.name, dbName: this.#dbName, options: options ?? {}, }); }
findOne( filter?: Filter<T>, options?: FindOptions, ): Promise<T | undefined> { const cursor = this.find(filter, options); return cursor.next(); }
/** * Find and modify a document in one, returning the matching document. * * @param query The query used to match documents * @param options Additional options for the operation (e.g. containing update * or remove parameters) * @returns The document matched and modified */ async findAndModify( filter?: Filter<T>, options?: FindAndModifyOptions<T>, ): Promise<T | undefined> { const result = await this.#protocol.commandSingle<{ value: T; ok: number; // deno-lint-ignore no-explicit-any lastErrorObject: any; }>(this.#dbName, { findAndModify: this.name, query: filter, ...options, }); if (result.ok === 0) { throw new MongoDriverError("Could not execute findAndModify operation"); } return result.value; }
/** * @deprecated Use `countDocuments` or `estimatedDocumentCount` instead */ async count( filter?: Filter<T>, options?: CountOptions, ): Promise<number> { const res = await this.#protocol.commandSingle(this.#dbName, { count: this.name, query: filter, ...options, }); const { n, ok } = res; if (ok === 1) { return n; } else { return 0; } }
async countDocuments( filter?: Filter<T>, options?: CountOptions, ): Promise<number> { const pipeline: AggregatePipeline<T>[] = []; if (filter) { pipeline.push({ $match: filter }); }
if (typeof options?.skip === "number") { pipeline.push({ $skip: options.limit }); delete options.skip; }
if (typeof options?.limit === "number") { pipeline.push({ $limit: options.limit }); delete options.limit; }
pipeline.push({ $group: { _id: 1, n: { $sum: 1 } } });
const result = await this.aggregate<{ n: number }>( pipeline, options as AggregateOptions, ).next(); if (result) return result.n; return 0; }
async estimatedDocumentCount(): Promise<number> { const pipeline = [ { $collStats: { count: {} } }, { $group: { _id: 1, n: { $sum: "$count" } } }, ];
const result = await this.aggregate<{ n: number }>(pipeline).next(); if (result) return result.n; return 0; }
async insertOne(doc: InsertDocument<T>, options?: InsertOptions) { const { insertedIds } = await this.insertMany([doc], options); return insertedIds[0]; }
/** * @deprecated Use `insertOne, insertMany` or `bulkWrite` instead. */ insert( docs: InsertDocument<T> | InsertDocument<T>[], options?: InsertOptions, ) { docs = Array.isArray(docs) ? docs : [docs]; return this.insertMany(docs, options); }
async insertMany( docs: InsertDocument<T>[], options?: InsertOptions, ): Promise< { insertedIds: (Bson.ObjectId | Required<InsertDocument<T>>["_id"])[]; insertedCount: number; } > { const insertedIds = docs.map((doc) => { if (!doc._id) { doc._id = new Bson.ObjectId(); }
return doc._id; });
const res = await this.#protocol.commandSingle(this.#dbName, { insert: this.name, documents: docs, ordered: options?.ordered ?? true, writeConcern: options?.writeConcern, bypassDocumentValidation: options?.bypassDocumentValidation, comment: options?.comment, }); const { writeErrors } = res; if (writeErrors) { const [{ errmsg }] = writeErrors; throw new Error(errmsg); } return { insertedIds, insertedCount: res.n, }; }
async updateOne( filter: Filter<T>, update: UpdateFilter<T>, options?: UpdateOptions, ) { const { upsertedIds = [], upsertedCount, matchedCount, modifiedCount, } = await this.updateMany(filter, update, { ...options, multi: false, }); return { upsertedId: upsertedIds?.[0], upsertedCount, matchedCount, modifiedCount, }; }
updateMany( filter: Filter<T>, doc: UpdateFilter<T>, options?: UpdateOptions, ) { if (!hasAtomicOperators(doc)) { throw new MongoInvalidArgumentError( "Update document requires atomic operators", ); }
return update(this.#protocol, this.#dbName, this.name, filter, doc, { ...options, multi: options?.multi ?? true, }); }
async replaceOne( filter: Filter<T>, replacement: InsertDocument<T>, options?: UpdateOptions, ) { if (hasAtomicOperators(replacement)) { throw new MongoInvalidArgumentError( "Replacement document must not contain atomic operators", ); }
const { upsertedIds = [], upsertedCount, matchedCount, modifiedCount } = await update( this.#protocol, this.#dbName, this.name, filter, replacement, { ...options, multi: false, }, );
return { upsertedId: upsertedIds?.[0], upsertedCount, matchedCount, modifiedCount, }; }
async deleteMany( filter: Filter<T>, options?: DeleteOptions, ): Promise<number> { const res = await this.#protocol.commandSingle(this.#dbName, { delete: this.name, deletes: [ { q: filter, limit: options?.limit ?? 0, collation: options?.collation, hint: options?.hint, comment: options?.comment, }, ], ordered: options?.ordered ?? true, writeConcern: options?.writeConcern, }); return res.n; }
delete = this.deleteMany;
deleteOne( filter: Filter<T>, options?: DeleteOptions, ) { return this.delete(filter, { ...options, limit: 1 }); }
async drop(options?: DropOptions): Promise<void> { const _res = await this.#protocol.commandSingle(this.#dbName, { drop: this.name, ...options, }); }
async distinct(key: string, query?: Filter<T>, options?: DistinctOptions) { const { values } = await this.#protocol.commandSingle(this.#dbName, { distinct: this.name, key, query, ...options, }); return values; }
aggregate<U = T>( pipeline: AggregatePipeline<U>[], options?: AggregateOptions, ): AggregateCursor<U> { return new AggregateCursor<U>({ pipeline, protocol: this.#protocol, dbName: this.#dbName, collectionName: this.name, options, }); }
async createIndexes(options: CreateIndexOptions) { const res = await this.#protocol.commandSingle<{ ok: number; createdCollectionAutomatically: boolean; numIndexesBefore: number; numIndexesAfter: number; }>(this.#dbName, { createIndexes: this.name, ...options, }); return res; }
async dropIndexes(options: DropIndexOptions) { const res = await this.#protocol.commandSingle<{ ok: number; nIndexesWas: number; }>( this.#dbName, { dropIndexes: this.name, ...options, }, );
return res; }
listIndexes() { return new ListIndexesCursor< { v: number; key: Document; name: string; ns?: string } >({ protocol: this.#protocol, dbName: this.#dbName, collectionName: this.name, }); }}
export function hasAtomicOperators(doc: Bson.Document | Bson.Document[]) { if (Array.isArray(doc)) { for (const document of doc) { if (hasAtomicOperators(document)) { return true; } } return false; } const keys = Object.keys(doc); return keys.length > 0 && keys[0][0] === "$";}