albatross 3.4.1 → 4.0.0-rc.1

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Linus Unnebäck
+Copyright (c) 2014-2021 Linus Unnebäck
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/index.d.ts

@@ -1,95 +1,86 @@
 import * as mongodb from 'mongodb'
 
-type FlattenIfArray<T> = T extends Array<infer R> ? R : T
+export { Binary, Code, Decimal128, Double, Int32, Long, MaxKey, MinKey, ObjectId, Timestamp } from 'mongodb'
+
+type DeepReadonly<T> = T extends Date | RegExp | string | number | boolean | bigint | symbol | undefined | null
+  ? T
+  : T extends {}
+  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
+  : Readonly<T>
+
 type SpecificProjection<T, TProjection> = Omit<T, 'projection'> & { projection: TProjection }
 type WithoutProjection<T> = T & { fields?: undefined, projection?: undefined }
 
-declare function albatross (uri: string): albatross.Albatross
-
-declare namespace albatross {
-  interface Collection<TSchema extends { _id: any }> {
-    readonly parent: Albatross
-    id (hexString?: mongodb.ObjectId | string): mongodb.ObjectId
-
-    findOne (filter: mongodb.FilterQuery<TSchema>, options?: WithoutProjection<mongodb.FindOneOptions<TSchema>>): Promise<TSchema | null>
-    findOne<TKey extends keyof TSchema> (filter: mongodb.FilterQuery<TSchema>, options: SpecificProjection<mongodb.FindOneOptions<TSchema>, { [key in TKey]: 1 | true } & { _id: 0 | false }>): Promise<Pick<TSchema, TKey> | null>
-    findOne<TKey extends keyof TSchema> (filter: mongodb.FilterQuery<TSchema>, options: SpecificProjection<mongodb.FindOneOptions<TSchema>, { [key in TKey]: 1 | true } & { _id?: 1 | true }>): Promise<Pick<TSchema, '_id' | TKey> | null>
-    findOne (filter: mongodb.FilterQuery<TSchema>, options: mongodb.FindOneOptions<TSchema>): Promise<object | null>
-
-    find (query: mongodb.FilterQuery<TSchema>, options?: WithoutProjection<mongodb.FindOneOptions<TSchema>>): Promise<TSchema[]>
-    find<TKey extends keyof TSchema> (query: mongodb.FilterQuery<TSchema>, options: SpecificProjection<mongodb.FindOneOptions<TSchema>, { [key in TKey]: 1 | true } & { _id: 0 | false }>): Promise<Array<Pick<TSchema, TKey>>>
-    find<TKey extends keyof TSchema> (query: mongodb.FilterQuery<TSchema>, options: SpecificProjection<mongodb.FindOneOptions<TSchema>, { [key in TKey]: 1 | true } & { _id?: 1 | true }>): Promise<Array<Pick<TSchema, '_id' | TKey>>>
-    find (query: mongodb.FilterQuery<TSchema>, options: mongodb.FindOneOptions<TSchema>): Promise<object[]>
-
-    count (query?: mongodb.FilterQuery<TSchema>, options?: mongodb.MongoCountPreferences): Promise<number>
-
-    distinct<TKey extends keyof mongodb.WithId<TSchema>> (key: TKey, query?: mongodb.FilterQuery<TSchema>, options?: { readPreference?: mongodb.ReadPreference | string, maxTimeMS?: number, session?: mongodb.ClientSession }): Promise<Array<FlattenIfArray<mongodb.WithId<TSchema>[TKey]>>>
-    distinct (key: string, query?: mongodb.FilterQuery<TSchema>, options?: { readPreference?: mongodb.ReadPreference | string, maxTimeMS?: number, session?: mongodb.ClientSession }): Promise<any[]>
-
-    exists (query?: mongodb.FilterQuery<TSchema>): Promise<boolean>
-
-    insert (doc: mongodb.OptionalId<TSchema>, options?: mongodb.CollectionInsertOneOptions): Promise<mongodb.WithId<TSchema>>
-    insert (docs: mongodb.OptionalId<TSchema>[], options?: mongodb.CollectionInsertManyOptions): Promise<mongodb.WithId<TSchema>[]>
-
-    findOneAndUpdate (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options: WithoutProjection<mongodb.FindOneAndUpdateOption<TSchema> & { returnOriginal: false, upsert: true }>): Promise<TSchema>
-    findOneAndUpdate (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options?: WithoutProjection<mongodb.FindOneAndUpdateOption<TSchema>>): Promise<TSchema | null>
-
-    findOneAndUpdate<TKey extends keyof TSchema> (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options: SpecificProjection<mongodb.FindOneAndUpdateOption<TSchema> & { returnOriginal: false, upsert: true }, { [key in TKey]: 1 | true } & { _id: 0 | false }>): Promise<Pick<TSchema, TKey>>
-    findOneAndUpdate<TKey extends keyof TSchema> (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options: SpecificProjection<mongodb.FindOneAndUpdateOption<TSchema>, { [key in TKey]: 1 | true } & { _id: 0 | false }>): Promise<Pick<TSchema, TKey> | null>
-
-    findOneAndUpdate<TKey extends keyof TSchema> (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options: SpecificProjection<mongodb.FindOneAndUpdateOption<TSchema> & { returnOriginal: false, upsert: true }, { [key in TKey]: 1 | true } & { _id?: 1 | true }>): Promise<Pick<TSchema, '_id' | TKey>>
-    findOneAndUpdate<TKey extends keyof TSchema> (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options: SpecificProjection<mongodb.FindOneAndUpdateOption<TSchema>, { [key in TKey]: 1 | true } & { _id?: 1 | true }>): Promise<Pick<TSchema, '_id' | TKey> | null>
-
-    findOneAndUpdate (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options: mongodb.FindOneAndUpdateOption<TSchema> & { returnOriginal: false, upsert: true }): Promise<object>
-    findOneAndUpdate (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options?: mongodb.FindOneAndUpdateOption<TSchema>): Promise<object | null>
-
-    updateOne (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options?: mongodb.UpdateOneOptions): Promise<{ matched: 0 | 1, modified: 0 | 1 }>
-    updateMany (filter: mongodb.FilterQuery<TSchema>, update: mongodb.UpdateQuery<TSchema> | Partial<TSchema>, options?: mongodb.UpdateManyOptions): Promise<{ matched: number, modified: number }>
-
-    deleteOne (filter: mongodb.FilterQuery<TSchema>, options?: mongodb.CommonOptions & { bypassDocumentValidation?: boolean }): Promise<0 | 1>
-    deleteMany (filter: mongodb.FilterQuery<TSchema>, options?: mongodb.CommonOptions): Promise<number>
-
-    aggregate (pipeline: object[], options?: mongodb.CollectionAggregationOptions): Promise<object[]>
-  }
-
-  interface FileInfo {
-    id: mongodb.ObjectId
-    md5: string
-    length: number
-    chunkSize: number
-    uploadDate: Date
-    contentType: string
-    filename: string
-    metadata: any
-  }
-
-  interface Grid {
-    readonly parent: Albatross
-    id (hexString?: mongodb.ObjectId | string): mongodb.ObjectId
-    upload (stream: NodeJS.ReadableStream, options?: mongodb.GridFSBucketOpenUploadStreamOptions & { filename?: string }): Promise<FileInfo>
-    download (id: mongodb.ObjectId): Promise<FileInfo & { stream: NodeJS.ReadableStream }>
-    delete (id: mongodb.ObjectId): Promise<void>
-  }
-
-  interface Albatross {
-    id (hexString?: mongodb.ObjectId | string): mongodb.ObjectId
-    collection<TSchema extends { _id: any }> (name: string): Collection<TSchema>
-    grid (name?: string): Grid
-    ping (timeout?: number): Promise<void>
-    close (force?: boolean): Promise<void>
-  }
-
-  const Binary: typeof mongodb.Binary
-  const Code: typeof mongodb.Code
-  const DBRef: typeof mongodb.DBRef
-  const Decimal128: typeof mongodb.Decimal128
-  const Double: typeof mongodb.Double
-  const Int32: typeof mongodb.Int32
-  const Long: typeof mongodb.Long
-  const MaxKey: typeof mongodb.MaxKey
-  const MinKey: typeof mongodb.MinKey
-  const ObjectId: typeof mongodb.ObjectId
-  const Timestamp: typeof mongodb.Timestamp
+export interface Collection<TSchema extends { _id: any }> {
+  readonly parent: Albatross
+  id (hexString?: mongodb.ObjectId | string): mongodb.ObjectId
+
+  findOne (filter: mongodb.Filter<TSchema>, options?: WithoutProjection<mongodb.FindOptions<TSchema>>): Promise<TSchema | null>
+  findOne<TKey extends keyof TSchema> (filter: mongodb.Filter<TSchema>, options: SpecificProjection<mongodb.FindOptions<TSchema>, { [key in TKey]: 1 | true } & { _id: 0 | false }>): Promise<Pick<TSchema, TKey> | null>
+  findOne<TKey extends keyof TSchema> (filter: mongodb.Filter<TSchema>, options: SpecificProjection<mongodb.FindOptions<TSchema>, { [key in TKey]: 1 | true } & { _id?: 1 | true }>): Promise<Pick<TSchema, '_id' | TKey> | null>
+  findOne (filter: mongodb.Filter<TSchema>, options: mongodb.FindOptions<TSchema>): Promise<object | null>
+
+  find (query: mongodb.Filter<TSchema>, options?: WithoutProjection<mongodb.FindOptions<TSchema>>): Promise<TSchema[]>
+  find<TKey extends keyof TSchema> (query: mongodb.Filter<TSchema>, options: SpecificProjection<mongodb.FindOptions<TSchema>, { [key in TKey]: 1 | true } & { _id: 0 | false }>): Promise<Array<Pick<TSchema, TKey>>>
+  find<TKey extends keyof TSchema> (query: mongodb.Filter<TSchema>, options: SpecificProjection<mongodb.FindOptions<TSchema>, { [key in TKey]: 1 | true } & { _id?: 1 | true }>): Promise<Array<Pick<TSchema, '_id' | TKey>>>
+  find (query: mongodb.Filter<TSchema>, options: mongodb.FindOptions<TSchema>): Promise<object[]>
+
+  count (query?: mongodb.Filter<TSchema>, options?: mongodb.CountOptions): Promise<number>
+
+  distinct<TKey extends keyof mongodb.WithId<TSchema>> (key: TKey, query?: mongodb.Filter<TSchema>, options?: mongodb.DistinctOptions): Promise<Array<mongodb.Flatten<mongodb.WithId<TSchema>[TKey]>>>
+  distinct (key: string, query?: mongodb.Filter<TSchema>, options?: mongodb.DistinctOptions): Promise<any[]>
+
+  exists (query?: mongodb.Filter<TSchema>): Promise<boolean>
+
+  insert (doc: DeepReadonly<mongodb.OptionalId<TSchema>>, options?: mongodb.InsertOneOptions): Promise<mongodb.WithId<TSchema>>
+  insert (docs: DeepReadonly<mongodb.OptionalId<TSchema>>[], options?: mongodb.BulkWriteOptions): Promise<mongodb.WithId<TSchema>[]>
+
+  findOneAndUpdate (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options: WithoutProjection<mongodb.FindOneAndUpdateOptions & { returnDocument: 'after', upsert: true }>): Promise<TSchema>
+  findOneAndUpdate (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options?: WithoutProjection<mongodb.FindOneAndUpdateOptions>): Promise<TSchema | null>
+
+  findOneAndUpdate<TKey extends keyof TSchema> (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options: SpecificProjection<mongodb.FindOneAndUpdateOptions & { returnDocument: 'after', upsert: true }, { [key in TKey]: 1 | true } & { _id: 0 | false }>): Promise<Pick<TSchema, TKey>>
+  findOneAndUpdate<TKey extends keyof TSchema> (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options: SpecificProjection<mongodb.FindOneAndUpdateOptions, { [key in TKey]: 1 | true } & { _id: 0 | false }>): Promise<Pick<TSchema, TKey> | null>
+
+  findOneAndUpdate<TKey extends keyof TSchema> (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options: SpecificProjection<mongodb.FindOneAndUpdateOptions & { returnDocument: 'after', upsert: true }, { [key in TKey]: 1 | true } & { _id?: 1 | true }>): Promise<Pick<TSchema, '_id' | TKey>>
+  findOneAndUpdate<TKey extends keyof TSchema> (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options: SpecificProjection<mongodb.FindOneAndUpdateOptions, { [key in TKey]: 1 | true } & { _id?: 1 | true }>): Promise<Pick<TSchema, '_id' | TKey> | null>
+
+  findOneAndUpdate (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options: mongodb.FindOneAndUpdateOptions & { returnDocument: 'after', upsert: true }): Promise<object>
+  findOneAndUpdate (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options?: mongodb.FindOneAndUpdateOptions): Promise<object | null>
+
+  updateOne (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options?: mongodb.UpdateOptions): Promise<{ matched: 0 | 1, modified: 0 | 1 }>
+  updateMany (filter: mongodb.Filter<TSchema>, update: mongodb.UpdateFilter<TSchema> | Partial<TSchema>, options?: mongodb.UpdateOptions): Promise<{ matched: number, modified: number }>
+
+  deleteOne (filter: mongodb.Filter<TSchema>, options?: mongodb.DeleteOptions): Promise<0 | 1>
+  deleteMany (filter: mongodb.Filter<TSchema>, options?: mongodb.DeleteOptions): Promise<number>
+
+  aggregate (pipeline: object[], options?: mongodb.AggregateOptions): Promise<object[]>
+}
+
+export interface FileInfo {
+  id: mongodb.ObjectId
+  length: number
+  chunkSize: number
+  uploadDate: Date
+  contentType: string
+  filename: string
+  metadata: any
+}
+
+export interface Grid {
+  readonly parent: Albatross
+  id (hexString?: mongodb.ObjectId | string): mongodb.ObjectId
+  upload (stream: NodeJS.ReadableStream, options?: mongodb.GridFSBucketWriteStreamOptions & { filename?: string }): Promise<FileInfo>
+  download (id: mongodb.ObjectId): Promise<FileInfo & { stream: NodeJS.ReadableStream }>
+  delete (id: mongodb.ObjectId): Promise<void>
+}
+
+export interface Albatross {
+  id (hexString?: mongodb.ObjectId | string): mongodb.ObjectId
+  collection<TSchema extends { _id: any }> (name: string): Collection<TSchema>
+  grid (name?: string): Grid
+  ping (timeout?: number): Promise<void>
+  transaction<T> (fn: (session: mongodb.ClientSession) => PromiseLike<T>): Promise<T>
+  close (force?: boolean): Promise<void>
 }
 
-export = albatross
+export default function albatross (uri: string): Albatross

package/index.js

@@ -1,16 +1,11 @@
-const mongodb = require('mongodb')
-const Albatross = require('./lib/albatross')
+import Albatross from './lib/albatross.js'
 
-module.exports = (uri) => new Albatross(uri)
+import mongodb from 'mongodb'
 
-module.exports.Binary = mongodb.Binary
-module.exports.Code = mongodb.Code
-module.exports.DBRef = mongodb.DBRef
-module.exports.Decimal128 = mongodb.Decimal128
-module.exports.Double = mongodb.Double
-module.exports.Int32 = mongodb.Int32
-module.exports.Long = mongodb.Long
-module.exports.MaxKey = mongodb.MaxKey
-module.exports.MinKey = mongodb.MinKey
-module.exports.ObjectId = mongodb.ObjectId
-module.exports.Timestamp = mongodb.Timestamp
+const { Binary, Code, Decimal128, Double, Int32, Long, MaxKey, MinKey, ObjectId, Timestamp } = mongodb
+
+export { Binary, Code, Decimal128, Double, Int32, Long, MaxKey, MinKey, ObjectId, Timestamp }
+
+export default function albatross (uri) {
+  return new Albatross(uri)
+}

package/lib/albatross.js

@@ -1,50 +1,28 @@
-const { GridStore, MongoClient, ObjectId } = require('mongodb')
+import mongodb from 'mongodb'
 
-const Collection = require('./collection')
-const Grid = require('./grid')
+import Collection from './collection.js'
+import Grid from './grid.js'
+
+const DEFAULT_ROOT_COLLECTION = 'fs'
 
 const kClient = Symbol('client')
 const kCollections = Symbol('collections')
-const kConnect = Symbol('connect')
 const kGrids = Symbol('grids')
-const kURI = Symbol('uri')
 
-class Albatross {
+export default class Albatross {
   constructor (uri) {
-    this[kClient] = null
+    this[kClient] = new mongodb.MongoClient(uri, { ignoreUndefined: true })
     this[kCollections] = new Map()
     this[kGrids] = new Map()
-    this[kURI] = uri
-  }
-
-  async [kConnect] () {
-    if (this[kClient] == null) {
-      this[kClient] = MongoClient.connect(this[kURI], { useNewUrlParser: true, useUnifiedTopology: true, ignoreUndefined: true })
-
-      try {
-        return await this[kClient]
-      } catch (err) {
-        this[kClient] = null
-        throw err
-      }
-    }
-
-    const client = await this[kClient]
-
-    if (!client.isConnected()) {
-      this[kClient] = null
-      return this[kConnect]()
-    }
-
-    return client
   }
 
   async db () {
-    return (await this[kConnect]()).db()
+    await this[kClient].connect()
+    return this[kClient].db()
   }
 
   id (hexString) {
-    return (hexString instanceof ObjectId) ? hexString : new ObjectId(hexString)
+    return (hexString instanceof mongodb.ObjectId) ? hexString : new mongodb.ObjectId(hexString)
   }
 
   collection (name) {
@@ -55,7 +33,7 @@ class Albatross {
     return this[kCollections].get(name)
   }
 
-  grid (bucketName = GridStore.DEFAULT_ROOT_COLLECTION) {
+  grid (bucketName = DEFAULT_ROOT_COLLECTION) {
     if (!this[kGrids].has(bucketName)) {
       this[kGrids].set(bucketName, new Grid(this, bucketName))
     }
@@ -64,12 +42,11 @@ class Albatross {
   }
 
   async ping (timeout) {
-    let client
     let timeoutHandle
 
     const ping = async () => {
-      client = await this[kConnect]()
-      return client.db().command({ ping: 1 })
+      await this[kClient].connect()
+      await this[kClient].db().command({ ping: 1 })
     }
 
     try {
@@ -85,13 +62,6 @@ class Albatross {
       } else {
         await ping()
       }
-    } catch (err) {
-      if (client) {
-        client.close(true).catch(() => {})
-      }
-
-      this[kClient] = null
-      throw err
     } finally {
       if (timeoutHandle) {
         clearTimeout(timeoutHandle)
@@ -99,13 +69,23 @@ class Albatross {
     }
   }
 
-  async close (force) {
-    if (this[kClient] == null) return
+  async transaction (fn) {
+    const session = this[kClient].startSession()
+
+    let result
 
-    const client = await this[kClient]
-    await client.close(force)
-    this[kClient] = null
+    try {
+      await session.withTransaction(async (...args) => {
+        result = await fn(...args)
+      })
+    } finally {
+      session.endSession()
+    }
+
+    return result
   }
-}
 
-module.exports = Albatross
+  async close (force) {
+    await this[kClient].close(force)
+  }
+}

package/lib/collection.js

@@ -1,15 +1,13 @@
-const debug = require('debug')
-const { BSON } = require('bson')
+import BSON from 'bson'
+import debug from 'debug'
 
 const kDebug = Symbol('debug')
 
-const bsonParser = new BSON()
-
 function prepareDocument (document) {
-  return bsonParser.deserialize(bsonParser.serialize(document), { promoteValues: true })
+  return BSON.deserialize(BSON.serialize(document), { promoteValues: true })
 }
 
-class Collection {
+export default class Collection {
   constructor (parent, name) {
     this.name = name
     this.parent = parent
@@ -53,7 +51,7 @@ class Collection {
 
     try {
       this[kDebug]('count(%o)', query)
-      const res = await db.collection(this.name).countDocuments(query, { ignoreUndefined: true, ...opts })
+      const res = await db.collection(this.name).countDocuments(query, opts)
       this[kDebug]('reply OK')
       return res
     } catch (err) {
@@ -100,15 +98,17 @@ class Collection {
 
     try {
       if (Array.isArray(docs)) {
-        this[kDebug]('insertMany(%o)', docs)
-        const res = await db.collection(this.name).insertMany(docs.map(prepareDocument), opts)
+        const documents = docs.map(prepareDocument)
+        this[kDebug]('insertMany(%o)', documents)
+        await db.collection(this.name).insertMany(documents, opts)
         this[kDebug]('reply OK')
-        return res.ops
+        return documents
       } else {
-        this[kDebug]('insertOne(%o)', docs)
-        const res = await db.collection(this.name).insertOne(prepareDocument(docs), opts)
+        const document = prepareDocument(docs)
+        this[kDebug]('insertOne(%o)', document)
+        await db.collection(this.name).insertOne(document, opts)
         this[kDebug]('reply OK')
-        return res.ops[0]
+        return document
       }
     } catch (err) {
       this[kDebug]('reply ERR')
@@ -121,7 +121,7 @@ class Collection {
 
     try {
       this[kDebug]('findOneAndUpdate(%o, %o)', filter, update)
-      const res = await db.collection(this.name).findOneAndUpdate(filter, update, { ignoreUndefined: true, ...opts })
+      const res = await db.collection(this.name).findOneAndUpdate(filter, update, opts)
       this[kDebug]('reply OK')
       return res.value
     } catch (err) {
@@ -136,8 +136,8 @@ class Collection {
     try {
       this[kDebug]('updateOne(%o, %o)', filter, update)
       const res = await db.collection(this.name).updateOne(filter, update, opts)
-      this[kDebug](`reply OK ${res.result.n} ${res.result.nModified}`)
-      return { matched: res.result.n, modified: res.result.nModified }
+      this[kDebug](`reply OK ${res.matchedCount} ${res.modifiedCount}`)
+      return { matched: res.matchedCount, modified: res.modifiedCount }
     } catch (err) {
       this[kDebug]('reply ERR')
       throw err
@@ -150,8 +150,8 @@ class Collection {
     try {
       this[kDebug]('updateMany(%o, %o)', filter, update)
       const res = await db.collection(this.name).updateMany(filter, update, opts)
-      this[kDebug](`reply OK ${res.result.n} ${res.result.nModified}`)
-      return { matched: res.result.n, modified: res.result.nModified }
+      this[kDebug](`reply OK ${res.matchedCount} ${res.modifiedCount}`)
+      return { matched: res.matchedCount, modified: res.modifiedCount }
     } catch (err) {
       this[kDebug]('reply ERR')
       throw err
@@ -164,8 +164,8 @@ class Collection {
     try {
       this[kDebug]('deleteOne(%o)', filter)
       const res = await db.collection(this.name).deleteOne(filter, opts)
-      this[kDebug](`reply OK ${res.result.n}`)
-      return res.result.n
+      this[kDebug](`reply OK ${res.deletedCount}`)
+      return res.deletedCount
     } catch (err) {
       this[kDebug]('reply ERR')
       throw err
@@ -178,8 +178,8 @@ class Collection {
     try {
       this[kDebug]('deleteMany(%o)', filter)
       const res = await db.collection(this.name).deleteMany(filter, opts)
-      this[kDebug](`reply OK ${res.result.n}`)
-      return res.result.n
+      this[kDebug](`reply OK ${res.deletedCount}`)
+      return res.deletedCount
     } catch (err) {
       this[kDebug]('reply ERR')
       throw err
@@ -191,7 +191,7 @@ class Collection {
 
     try {
       this[kDebug]('aggregate(%o)', pipeline)
-      const res = await db.collection(this.name).aggregate(pipeline, { ignoreUndefined: true, ...opts }).toArray()
+      const res = await db.collection(this.name).aggregate(pipeline, opts).toArray()
       this[kDebug]('reply OK')
       return res
     } catch (err) {
@@ -200,5 +200,3 @@ class Collection {
     }
   }
 }
-
-module.exports = Collection

package/lib/grid.js

@@ -1,6 +1,6 @@
-const debug = require('debug')
-const { GridFSBucket } = require('mongodb')
-const stream = require('stream')
+import debug from 'debug'
+import mongodb from 'mongodb'
+import { PassThrough } from 'node:stream'
 
 const reFileNotFound = /^FileNotFound: /
 
@@ -9,7 +9,6 @@ const kDebug = Symbol('debug')
 function fileInfo (file) {
   return {
     id: file._id,
-    md5: file.md5,
     length: file.length,
     chunkSize: file.chunkSize,
     uploadDate: file.uploadDate,
@@ -19,7 +18,7 @@ function fileInfo (file) {
   }
 }
 
-class Grid {
+export default class Grid {
   constructor (parent, name) {
     this.name = name
     this.parent = parent
@@ -34,8 +33,8 @@ class Grid {
     const db = await this.parent.db()
 
     return new Promise((resolve, reject) => {
-      const bucket = new GridFSBucket(db, { bucketName: this.name })
-      const upload = bucket.openUploadStream(opts.filename, opts)
+      const bucket = new mongodb.GridFSBucket(db, { bucketName: this.name })
+      const upload = bucket.openUploadStream(opts.filename || '', opts)
 
       upload.on('error', reject)
       upload.on('finish', (file) => resolve(fileInfo(file)))
@@ -48,9 +47,9 @@ class Grid {
     const db = await this.parent.db()
 
     return new Promise((resolve, reject) => {
-      const bucket = new GridFSBucket(db, { bucketName: this.name })
+      const bucket = new mongodb.GridFSBucket(db, { bucketName: this.name })
       const download = bucket.openDownloadStream(this.id(id))
-      const through = new stream.PassThrough()
+      const through = new PassThrough()
 
       // the download stream won't query the db until piped
       download.pipe(through)
@@ -73,10 +72,8 @@ class Grid {
     const db = await this.parent.db()
 
     return new Promise((resolve, reject) => {
-      const bucket = new GridFSBucket(db, { bucketName: this.name })
+      const bucket = new mongodb.GridFSBucket(db, { bucketName: this.name })
       bucket.delete(this.id(id), (err) => err ? reject(err) : resolve())
     })
   }
 }
-
-module.exports = Grid

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "albatross",
-  "version": "3.4.1",
+  "version": "4.0.0-rc.1",
   "license": "MIT",
-  "author": "Linus Unnebäck <linus@folkdatorn.se>",
   "repository": "LinusU/node-albatross",
+  "type": "module",
+  "exports": "./index.js",
   "files": [
     "index.d.ts",
     "index.js",
@@ -11,25 +12,22 @@
   ],
   "scripts": {
     "test": "standard && mocha && npm run tsc",
-    "tsc": "tsc --noEmit --allowJs --checkJs index.d.ts test/*.js"
+    "tsc": "tsc --allowSyntheticDefaultImports --noEmit --allowJs --checkJs index.d.ts test/*.js"
   },
   "dependencies": {
-    "@types/bson": "1.0.11",
-    "@types/mongodb": "3.6.12",
-    "bson": "^1.1.4",
-    "debug": "^4.1.1",
-    "mongodb": "^3.6.0"
+    "bson": "^4.7.0",
+    "debug": "^4.3.4",
+    "mongodb": "^4.9.0"
   },
   "devDependencies": {
-    "@types/mocha": "^5.2.7",
-    "@types/node": "^8.10.54",
-    "assert-rejects": "^1.0.0",
-    "get-stream": "^5.1.0",
-    "mocha": "^6.2.1",
-    "standard": "^14.3.1",
-    "typescript": "^3.7.3"
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^16.4.13",
+    "get-stream": "^6.0.1",
+    "mocha": "^9.0.3",
+    "standard": "^17.0.0",
+    "typescript": "^4.8.2"
   },
   "engines": {
-    "node": ">=8.3"
+    "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
   }
 }

package/readme.md

@@ -1,8 +1,6 @@
 # ![Albatross](/header.png?raw=true "Albatross")
 
-Albatross is a small library that makes accessing MongoDB from Node.js a
-breeze. It's goal is to be a thin wrapper that enables you to forget about
-connection state and get right to accessing your data.
+Albatross is a small library that makes accessing MongoDB from Node.js a breeze. It's goal is to be a thin wrapper that enables you to forget about connection state and get right to accessing your data.
 
 ## Installation
 
@@ -13,7 +11,8 @@ npm install --save albatross
 ## Usage
 
 ```js
-const albatross = require('albatross')
+import albatross from 'albatross'
+import fs from 'node:fs'
 
 const db = albatross('mongodb://localhost/test')
 const user = db.collection('user')
@@ -25,7 +24,6 @@ const doc = await user.findOne({ born: 1992 })
 console.log('Hello ' + doc.name)
 //=> Hello Linus
 
-const fs = require('fs')
 const grid = db.grid()
 
 const input = fs.createReadStream('readme.md')
@@ -40,15 +38,13 @@ result.contentType // 'text/plain'
 result.stream.pipe(process.stdout)
 ```
 
-You can start querying the database right away, as soon as a connection is
-established it will start sending your commands to the server.
+You can start querying the database right away, as soon as a connection is established it will start sending your commands to the server.
 
 ## API
 
 ### Module
 
-The module exposes a single function to create a new `Albatross` instance. It
-also exposes the BSON Binary API on this function.
+The module default exports a single function to create a new `Albatross` instance. It also exports the BSON Binary API as named exports.
 
 #### `albatross(uri)`
 
@@ -58,12 +54,11 @@ Creates a new instance of `Albatross` and connect to the specified uri.
 
 #### BSON Binary API
 
-The following functions are exposed on the module:
+The following functions are exported from the module:
 
 ```text
 Binary
 Code
-DBRef
 Decimal128
 Double
 Int32
@@ -82,8 +77,7 @@ Returns a new instance of Collection bound to the collection named `name`.
 
 #### `.grid([name])`
 
-Returns a new instance of Grid, optionally using the supplied `name` as the
-name of the root collection.
+Returns a new instance of Grid, optionally using the supplied `name` as the name of the root collection.
 
 #### `.id(strOrObjectId)`
 
@@ -95,6 +89,26 @@ Send the `ping` command to the server, to check that the connection is still int
 
 Optionally accepts a timeout in milliseconds.
 
+#### `.transaction(fn): Promise`
+
+Runs a provided function within a transaction, retrying either the commit operation or entire transaction as needed (and when the error permits) to better ensure that the transaction can complete successfully.
+
+Example:
+
+```js
+const user = db.collection('user')
+
+const result = await db.transaction(async (session) => {
+    await user.insert({ name: 'Linus', born: 1992 }, { session })
+    await user.insert({ name: 'Steve', born: 1955 }, { session })
+
+    return await user.findOne({ born: 1992 }, { session })
+})
+
+console.log('Hello ' + result.name)
+//=> Hello Linus
+```
+
 #### `.close(): Promise<void>`
 
 Closes the connection to the server.
@@ -131,9 +145,7 @@ Check if at least one document is matching the query.
 
 Inserts a single document or a an array of documents.
 
-The Promise will resolve with the documents that was inserted. When called
-with an object instead of an array as the first argument, the Promise resolves
-with an object instead of an array as well.
+The Promise will resolve with the documents that was inserted. When called with an object instead of an array as the first argument, the Promise resolves with an object instead of an array as well.
 
 **Note:** Contrary to the standard MongoDB Node.js driver, this function will *not modify* any objects that are passed in. Instead, the returned documents from this function are what was saved in the database.
 
@@ -141,7 +153,7 @@ with an object instead of an array as well.
 
 Finds a document and updates it in one atomic operation.
 
-By default, the document _before_ the update is returned. To return the document _after_ the update, pass `returnOriginal: false` in the options.
+By default, the document _before_ the update is returned. To return the document _after_ the update, pass `returnDocument: 'after'` in the options.
 
 #### `updateOne(filter, update[, opts]): Promise<UpdateResult>`
 
@@ -177,8 +189,7 @@ Makes sure that the given argument is an ObjectId.
 
 #### `upload(stream[, opts]): Promise<FileInfo>`
 
-Store the `stream` as a file in the grid store, `opts` is a object with the
-following properties. All options are optionally.
+Store the `stream` as a file in the grid store, `opts` is a object with the following properties. All options are optionally.
 
 - `filename`: The value of the `filename` key in the files doc
 - `chunkSizeBytes`: Overwrite this bucket's `chunkSizeBytes` for this file
@@ -189,7 +200,6 @@ following properties. All options are optionally.
 The `FileInfo` object has the following properties:
 
 - `id`: The id of the file
-- `md5`: The md5 hash of the file
 - `length`: The length of the file
 - `chunkSize`: The size of each chunk in bytes
 - `filename`: The value of the `filename` key in the files doc
@@ -198,12 +208,9 @@ The `FileInfo` object has the following properties:
 
 #### `download(id): Promise<FileInfo>`
 
-Get the file with the specified `id` from the grid store. The Promise will
-resolve with an object with the following properties. If no file with the
-indicated `id` was found, the Promise will resolve to `null`.
+Get the file with the specified `id` from the grid store. The Promise will resolve with an object with the following properties. If no file with the indicated `id` was found, the Promise will resolve to `null`.
 
 - `id`: The id of the file
-- `md5`: The md5 hash of the file
 - `length`: The length of the file
 - `chunkSize`: The size of each chunk in bytes
 - `filename`: The value of the `filename` key in the files doc
@@ -217,13 +224,11 @@ Delete the file with the specified `id` from the grid store.
 
 ## In depth documentation
 
-For more in depth documentation please see the [mongodb module](http://mongodb.github.io/node-mongodb-native/)
-which Albatross wraps, especially the [Collection object](http://mongodb.github.io/node-mongodb-native/api-generated/collection.html).
+For more in depth documentation please see the [mongodb module](http://mongodb.github.io/node-mongodb-native/) which Albatross wraps, especially the [Collection object](http://mongodb.github.io/node-mongodb-native/api-generated/collection.html).
 
 ## Contributing
 
-Pull requests are always welcome, please make sure to add tests and run
-`mocha` before submitting.
+Pull requests are always welcome, please make sure to add tests and run `mocha` before submitting.
 
 The tests requiers a MongoDB server running at `localhost`.