Very Popular
Latest
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508import { ObjectId } from "../../deps.ts";import { MongoDriverError, MongoInvalidArgumentError, MongoServerError,} 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";
/** * A collection within a MongoDB Database * @module */
/** A collection within a MongoDB Database */export class Collection<T extends Document> { #protocol: WireProtocol; #dbName: string;
constructor(protocol: WireProtocol, dbName: string, readonly name: string) { this.#protocol = protocol; this.#dbName = dbName; }
/** * Get a FindCursor for the given filter * * @param filter The query used to match documents * @param options Additional options for the operation * @returns A cursor for the query */ find( filter?: Filter<T>, options?: FindOptions, ): FindCursor<T> { return new FindCursor<T>({ filter, protocol: this.#protocol, collectionName: this.name, dbName: this.#dbName, options: options ?? {}, }); }
/** * Find one Document using the given filter * * @param filter The query used to match for a document * @param options Additional options for the operation * @returns The document matched, or undefined if no document was found */ 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 | null> { 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; }
/** * Count the number of documents matching the given filter * * @param filter The query used to match documents * @param options Additional options for the operation * @returns The number of documents matching the filter */ 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; }
/** A function that returns the estimated number of documents in the collection */ 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; }
/** * Insert a single document into the collection * * @param doc The document to insert * @param options Additional options for the operation * @returns The inserted document's ID */ async insertOne( doc: InsertDocument<T>, options?: InsertOptions, ): Promise<Required<InsertDocument<T>>["_id"]> { const { insertedIds } = await this.insertMany([doc], options); return insertedIds[0]; }
/** * Insert multiple documents into the collection * * @param docs An array of documents to insert * @param options Additional options for the operation * @returns The inserted documents' IDs and the number of documents inserted */ async insertMany( docs: InsertDocument<T>[], options?: InsertOptions, ): Promise< { insertedIds: Required<InsertDocument<T>>["_id"][]; insertedCount: number; } > { const insertedIds = docs.map((doc) => { if (!doc._id) { doc._id = new 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 MongoServerError(errmsg); } return { insertedIds, insertedCount: res.n, }; }
/** * Update a single document matching the given filter * * @param filter The query used to match the document * @param update The update to apply to the document * @param options Additional options for the operation * @returns The number of documents matched, modified, and upserted */ async updateOne( filter: Filter<T>, update: UpdateFilter<T>, options?: UpdateOptions, ): Promise< { upsertedId: ObjectId | undefined; upsertedCount: number; matchedCount: number; modifiedCount: number; } > { const { upsertedIds, upsertedCount, matchedCount, modifiedCount, } = await this.updateMany(filter, update, { ...options, multi: false, }); return { upsertedId: upsertedIds?.[0], upsertedCount, matchedCount, modifiedCount, }; }
/** * Update multiple documents matching the given filter * * @param filter The query used to match the documents * @param doc The update to apply to the documents * @param options Additional options for the operation * @returns The number of documents matched, modified, and upserted */ updateMany( filter: Filter<T>, doc: UpdateFilter<T>, options?: UpdateOptions, ): Promise< { upsertedIds: ObjectId[] | undefined; upsertedCount: number; modifiedCount: number; matchedCount: number; } > { 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, }); }
/** * Replace a single document matching the given filter * * @param filter The query used to match the document * @param replacement The replacement document * @param options Additional options for the operation * @returns The number of documents matched, modified, and upserted */ async replaceOne( filter: Filter<T>, replacement: InsertDocument<T>, options?: UpdateOptions, ): Promise< { upsertedId: ObjectId | undefined; upsertedCount: number; matchedCount: number; modifiedCount: number; } > { 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, }; }
/** * Delete multiple documents matching the given filter * * @param filter The query used to match the documents * @param options Additional options for the operation * @returns The number of documents deleted */ 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 a single document matching the given filter * * @param filter The query used to match the document * @param options Additional options for the operation * @returns The number of documents deleted */ deleteOne( filter: Filter<T>, options?: DeleteOptions, ): Promise<number> { return this.deleteMany(filter, { ...options, limit: 1 }); }
/** * Drop the collection from the database * * @param options Additional options for the operation */ 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, // deno-lint-ignore no-explicit-any ): Promise<any> { const { values } = await this.#protocol.commandSingle(this.#dbName, { distinct: this.name, key, query, ...options, }); return values; }
/** * Perform aggregation on the collection * * @param pipeline The aggregation pipeline * @param options Additional options for the operation * @returns A cursor for the aggregation */ 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, }); }
/** * Create an index on the collection * * @param options The options for the operation * @returns The result of the operation */ async createIndexes( options: CreateIndexOptions, ): Promise< { ok: number; createdCollectionAutomatically: boolean; numIndexesBefore: number; numIndexesAfter: number; } > { const res = await this.#protocol.commandSingle<{ ok: number; createdCollectionAutomatically: boolean; numIndexesBefore: number; numIndexesAfter: number; }>(this.#dbName, { createIndexes: this.name, ...options, }); return res; }
/** * Drop an index from the collection * * @param options The options for the operation * @returns The result of the operation */ async dropIndexes(options: DropIndexOptions): Promise<{ ok: number; nIndexesWas: number; }> { const res = await this.#protocol.commandSingle<{ ok: number; nIndexesWas: number; }>( this.#dbName, { dropIndexes: this.name, ...options, }, );
return res; }
/** * List the indexes on the collection * * @returns A cursor for the indexes */ listIndexes(): ListIndexesCursor< { v: number; key: Document; name: string; ns?: string } > { return new ListIndexesCursor< { v: number; key: Document; name: string; ns?: string } >({ protocol: this.#protocol, dbName: this.#dbName, collectionName: this.name, }); }}
/** * Check if a document contains atomic operators * * @param doc The document to check * @returns Whether the document contains atomic operators */export function hasAtomicOperators(doc: Document | Document[]): boolean { 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] === "$";}