effect-mongodb 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-mongodb",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A MongoDB toolkit for Effect",
   "license": "MIT",
   "repository": {
@@ -12,8 +12,7 @@
   "author": "doubleloop.io",
   "homepage": "https://github.com/doubleloop-io/effect-mongodb",
   "peerDependencies": {
-    "@effect/schema": "^0.73.4",
-    "effect": "^3.8.3",
+    "effect": "^3.10.14",
     "mongodb": "^6.8.0"
   },
   "publishConfig": {
@@ -29,6 +28,11 @@
       "import": "./dist/esm/index.js",
       "default": "./dist/cjs/index.js"
     },
+    "./AggregationCursor": {
+      "types": "./dist/dts/AggregationCursor.d.ts",
+      "import": "./dist/esm/AggregationCursor.js",
+      "default": "./dist/cjs/AggregationCursor.js"
+    },
     "./Collection": {
       "types": "./dist/dts/Collection.d.ts",
       "import": "./dist/esm/Collection.js",
@@ -39,6 +43,11 @@
       "import": "./dist/esm/Db.js",
       "default": "./dist/cjs/Db.js"
     },
+    "./DocumentAggregationCursor": {
+      "types": "./dist/dts/DocumentAggregationCursor.d.ts",
+      "import": "./dist/esm/DocumentAggregationCursor.js",
+      "default": "./dist/cjs/DocumentAggregationCursor.js"
+    },
     "./DocumentCollection": {
       "types": "./dist/dts/DocumentCollection.d.ts",
       "import": "./dist/esm/DocumentCollection.js",
@@ -54,6 +63,11 @@
       "import": "./dist/esm/FindCursor.js",
       "default": "./dist/cjs/FindCursor.js"
     },
+    "./ListCollectionsCursor": {
+      "types": "./dist/dts/ListCollectionsCursor.d.ts",
+      "import": "./dist/esm/ListCollectionsCursor.js",
+      "default": "./dist/cjs/ListCollectionsCursor.js"
+    },
     "./MongoClient": {
       "types": "./dist/dts/MongoClient.d.ts",
       "import": "./dist/esm/MongoClient.js",
@@ -67,12 +81,18 @@
   },
   "typesVersions": {
     "*": {
+      "AggregationCursor": [
+        "./dist/dts/AggregationCursor.d.ts"
+      ],
       "Collection": [
         "./dist/dts/Collection.d.ts"
       ],
       "Db": [
         "./dist/dts/Db.d.ts"
       ],
+      "DocumentAggregationCursor": [
+        "./dist/dts/DocumentAggregationCursor.d.ts"
+      ],
       "DocumentCollection": [
         "./dist/dts/DocumentCollection.d.ts"
       ],
@@ -82,6 +102,9 @@
       "FindCursor": [
         "./dist/dts/FindCursor.d.ts"
       ],
+      "ListCollectionsCursor": [
+        "./dist/dts/ListCollectionsCursor.d.ts"
+      ],
       "MongoClient": [
         "./dist/dts/MongoClient.d.ts"
       ],

package/src/AggregationCursor.ts

@@ -0,0 +1,37 @@
+/**
+ * @since 0.0.1
+ */
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as F from "effect/Function"
+import type * as ParseResult from "effect/ParseResult"
+import * as Schema from "effect/Schema"
+import * as Stream from "effect/Stream"
+import type { AggregationCursor as MongoAggregationCursor } from "mongodb"
+import * as MongoError from "./MongoError.js"
+
+export class AggregationCursor<A, I = A, R = never> extends Data.TaggedClass("AggregationCursor")<
+  { cursor: MongoAggregationCursor<unknown>; schema: Schema.Schema<A, I, R> }
+> {
+}
+
+export const toArray = <A, I, R>(
+  cursor: AggregationCursor<A, I, R>
+): Effect.Effect<ReadonlyArray<A>, MongoError.MongoError | ParseResult.ParseError, R> => {
+  const decode = Schema.decodeUnknown(cursor.schema)
+  return Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }).pipe(
+    Effect.catchAll(MongoError.mongoErrorDie<ReadonlyArray<A>>("Unable to get array from mongodb aggregate cursor")),
+    Effect.flatMap(Effect.forEach((x) => decode(x)))
+  )
+}
+
+export const toStream = <A, I, R>(
+  cursor: AggregationCursor<A, I, R>
+): Stream.Stream<A, MongoError.MongoError | ParseResult.ParseError, R> => {
+  const decode = Schema.decodeUnknown(cursor.schema)
+  return F.pipe(
+    Stream.fromAsyncIterable(cursor.cursor, F.identity),
+    Stream.catchAll(MongoError.mongoErrorStream<A>("Unable to get stream from mongodb aggregate cursor")),
+    Stream.mapEffect((x) => decode(x))
+  )
+}

package/src/Collection.ts

@@ -1,23 +1,41 @@
 /**
  * @since 0.0.1
  */
-import type * as ParseResult from "@effect/schema/ParseResult"
-import * as Schema from "@effect/schema/Schema"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
 import * as O from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
+import * as Schema from "effect/Schema"
 import type {
+  AggregateOptions,
   BulkWriteOptions,
   Collection as MongoCollection,
+  CreateIndexesOptions,
+  DeleteOptions,
+  DeleteResult,
   Document,
-  Filter,
+  DropCollectionOptions,
+  DropIndexesOptions,
+  FindOneAndReplaceOptions,
   FindOptions as MongoFindOptions,
+  IndexDescription,
+  IndexSpecification,
   InsertManyResult,
   InsertOneOptions,
-  InsertOneResult
+  InsertOneResult,
+  ModifyResult as MongoModifyResult,
+  RenameOptions,
+  ReplaceOptions,
+  UpdateFilter,
+  UpdateOptions,
+  UpdateResult
 } from "mongodb"
+import * as AggregationCursor from "./AggregationCursor.js"
 import * as FindCursor from "./FindCursor.js"
+import type { Filter } from "./internal/filter.js"
+import type { ModifyResult } from "./internal/modify-result.js"
+import * as SchemaExt from "./internal/schema.js"
 import * as MongoError from "./MongoError.js"
 
 export class Collection<A extends Document, I extends Document = A, R = never> extends Data.TaggedClass("Collection")<{
@@ -29,48 +47,49 @@ export class Collection<A extends Document, I extends Document = A, R = never> e
 export type FindOptions = Omit<MongoFindOptions, "projection">
 
 export const find: {
-  (
+  <I extends Document>(
+    filter?: Filter<I>,
     options?: FindOptions
-  ): <A extends Document, I extends Document = A, R = never>(
-    collection: Collection<A, I, R>
-  ) => FindCursor.FindCursor<A, I, R>
-  <A extends Document, I extends Document = A, R = never>(
+  ): <A extends Document, R>(collection: Collection<A, I, R>) => FindCursor.FindCursor<A, I, R>
+  <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
+    filter?: Filter<I>,
     options?: FindOptions
   ): FindCursor.FindCursor<A, I, R>
 } = F.dual(
   (args) => isCollection(args[0]),
-  <A extends Document, I extends Document = A, R = never>(
+  <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
+    filter?: Filter<I>,
     options?: FindOptions
   ): FindCursor.FindCursor<A, I, R> =>
     new FindCursor.FindCursor<A, I, R>({
-      cursor: collection.collection.find({}, options),
+      cursor: collection.collection.find(filter ?? {}, options),
       schema: collection.schema
     })
 )
 
 export const findOne: {
-  <A extends Document, I extends Document = A, R = never>(
+  <I extends Document>(
     filter: Filter<I>,
     options?: FindOptions
-  ): (
+  ): <A extends Document, R>(
     collection: Collection<A, I, R>
   ) => Effect.Effect<O.Option<Document>, MongoError.MongoError | ParseResult.ParseError, R>
-  <A extends Document, I extends Document = A, R = never>(
+  <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
     filter: Filter<I>,
     options?: FindOptions
   ): Effect.Effect<O.Option<Document>, MongoError.MongoError | ParseResult.ParseError, R>
 } = F.dual(
   (args) => isCollection(args[0]),
-  <A extends Document, I extends Document = A, R = never>(
+  <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
     filter: Filter<I>,
     options?: FindOptions
   ): Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R> =>
     Effect.gen(function*(_) {
-      const value = yield* _(Effect.promise(() => collection.collection.findOne(filter as Filter<Document>, options)))
+      const value = yield* _(Effect.promise(() => collection.collection.findOne(filter, options)))
       if (value !== null) return O.some(yield* _(Schema.decodeUnknown(collection.schema)(value)))
       return O.none()
     }).pipe(
@@ -79,18 +98,18 @@ export const findOne: {
 )
 
 export const insertOne: {
-  <A extends Document, I extends Document = A, R = never>(
+  <A extends Document>(
     doc: A,
     options?: InsertOneOptions
-  ): (
+  ): <I extends Document, R>(
     collection: Collection<A, I, R>
   ) => Effect.Effect<InsertOneResult, MongoError.MongoError | ParseResult.ParseError, R>
-  <A extends Document, I extends Document = A, R = never>(
+  <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
     doc: A,
     options?: InsertOneOptions
   ): Effect.Effect<InsertOneResult, MongoError.MongoError | ParseResult.ParseError, R>
-} = F.dual((args) => isCollection(args[0]), <A extends Document, I extends Document = A, R = never>(
+} = F.dual((args) => isCollection(args[0]), <A extends Document, I extends Document, R>(
   collection: Collection<A, I, R>,
   doc: A,
   options?: InsertOneOptions
@@ -102,18 +121,18 @@ export const insertOne: {
   ))
 
 export const insertMany: {
-  <A extends Document, I extends Document = A, R = never>(
+  <A extends Document>(
     docs: Array<A>,
     options?: BulkWriteOptions
-  ): (
+  ): <I extends Document, R>(
     collection: Collection<A, I, R>
   ) => Effect.Effect<InsertManyResult, MongoError.MongoError | ParseResult.ParseError, R>
-  <A extends Document, I extends Document = A, R = never>(
+  <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
     docs: Array<A>,
     options?: BulkWriteOptions
   ): Effect.Effect<InsertManyResult, MongoError.MongoError | ParseResult.ParseError, R>
-} = F.dual((args) => isCollection(args[0]), <A extends Document, I extends Document = A, R = never>(
+} = F.dual((args) => isCollection(args[0]), <A extends Document, I extends Document, R>(
   collection: Collection<A, I, R>,
   docs: Array<A>,
   options?: BulkWriteOptions
@@ -127,4 +146,351 @@ export const insertMany: {
   )
 })
 
+export const deleteOne: {
+  <I extends Document>(
+    filter: Filter<I>,
+    options?: DeleteOptions
+  ): <A extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<DeleteResult, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    options?: DeleteOptions
+  ): Effect.Effect<DeleteResult, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    options?: DeleteOptions
+  ): Effect.Effect<DeleteResult, MongoError.MongoError, R> =>
+    Effect.promise(() => collection.collection.deleteOne(filter, options)).pipe(
+      Effect.catchAllDefect(MongoError.mongoErrorDie<DeleteResult>("deleteOne error"))
+    )
+)
+
+export const deleteMany: {
+  <I extends Document>(
+    filter: Filter<I>,
+    options?: DeleteOptions
+  ): <A extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<DeleteResult, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    options?: DeleteOptions
+  ): Effect.Effect<DeleteResult, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    options?: DeleteOptions
+  ): Effect.Effect<DeleteResult, MongoError.MongoError, R> =>
+    Effect.promise(() => collection.collection.deleteMany(filter, options)).pipe(
+      Effect.catchAllDefect(MongoError.mongoErrorDie<DeleteResult>("deleteMany error"))
+    )
+)
+
+export const updateMany: {
+  <I extends Document>(
+    filter: Filter<I>,
+    update: UpdateFilter<I> | Array<Document>,
+    options?: UpdateOptions
+  ): <A extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<UpdateResult, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    update: UpdateFilter<I> | Array<Document>,
+    options?: UpdateOptions
+  ): Effect.Effect<UpdateResult, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    update: UpdateFilter<I> | Array<Document>,
+    options?: UpdateOptions
+  ): Effect.Effect<UpdateResult, MongoError.MongoError, R> =>
+    Effect.promise(() =>
+      collection.collection.updateMany(filter, update as UpdateFilter<Document> | Array<Document>, options)
+    ).pipe(
+      Effect.catchAllDefect(MongoError.mongoErrorDie<UpdateResult>("updateMany error"))
+    )
+)
+
+export const replaceOne: {
+  <A extends Document, I extends Document>(
+    filter: Filter<I>,
+    // TODO: should we put WithoutId<A> here like the driver signature?
+    replacement: A,
+    options?: ReplaceOptions
+  ): <R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<UpdateResult | Document, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    options?: ReplaceOptions
+  ): Effect.Effect<UpdateResult | Document, MongoError.MongoError | ParseResult.ParseError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    options?: ReplaceOptions
+  ): Effect.Effect<
+    UpdateResult | Document,
+    MongoError.MongoError | ParseResult.ParseError,
+    R
+  > =>
+    F.pipe(
+      // TODO: extract function in Collection
+      Schema.encode(collection.schema)(replacement),
+      Effect.flatMap((replacement) =>
+        Effect.promise(() => collection.collection.replaceOne(filter, replacement, options))
+      ),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<UpdateResult | Document>("replaceOne error"))
+    )
+)
+
+export const findOneAndReplace: {
+  <A extends Document, I extends Document>(
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: true }
+  ): <R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<ModifyResult<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document>(
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: false }
+  ): <R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document>(
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions
+  ): <R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document>(
+    filter: Filter<I>,
+    replacement: A
+  ): <R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: true }
+  ): Effect.Effect<ModifyResult<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: false }
+  ): Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions
+  ): Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A
+  ): Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    options?: FindOneAndReplaceOptions
+  ): Effect.Effect<O.Option<A> | ModifyResult<A>, MongoError.MongoError | ParseResult.ParseError, R> =>
+    F.pipe(
+      // TODO: extract function in Collection
+      Schema.encode(collection.schema)(replacement),
+      Effect.flatMap((replacement) =>
+        Effect.promise(() => collection.collection.findOneAndReplace(filter, replacement, options ?? {}))
+      ),
+      Effect.flatMap((value) =>
+        Effect.gen(function*(_) {
+          if (options?.includeResultMetadata && !!value) {
+            const result = value as unknown as MongoModifyResult<I>
+            const maybeValue = yield* _(SchemaExt.decodeNullableDocument(collection.schema, result.value))
+            return { ...result, value: maybeValue }
+          }
+          return yield* _(SchemaExt.decodeNullableDocument(collection.schema, value))
+        })
+      ),
+      Effect.catchAllDefect(
+        MongoError.mongoErrorDie<O.Option<A> | ModifyResult<A>>("findOneAndReplace error")
+      )
+    )
+)
+
+export const rename: {
+  (
+    newName: string,
+    options?: RenameOptions
+  ): <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<Collection<A, I, R>, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    newName: string,
+    options?: RenameOptions
+  ): Effect.Effect<Collection<A, I, R>, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    newName: string,
+    options?: RenameOptions
+  ): Effect.Effect<Collection<A, I, R>, MongoError.MongoError, R> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.rename(newName, options)),
+      Effect.map((newCollection) => new Collection<A, I, R>({ collection: newCollection, schema: collection.schema })),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<Collection<A, I, R>>("rename error"))
+    )
+)
+
+export const drop: {
+  (
+    options?: DropCollectionOptions
+  ): <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<boolean, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    options?: DropCollectionOptions
+  ): Effect.Effect<boolean, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    options?: DropCollectionOptions
+  ): Effect.Effect<boolean, MongoError.MongoError, R> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.drop(options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<boolean>("drop error"))
+    )
+)
+
+export const createIndexes: {
+  (
+    indexSpecs: Array<IndexDescription>,
+    options?: CreateIndexesOptions
+  ): <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<Array<string>, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexSpecs: Array<IndexDescription>,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<Array<string>, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexSpecs: Array<IndexDescription>,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<Array<string>, MongoError.MongoError, R> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.createIndexes(indexSpecs, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<Array<string>>("createIndexes error"))
+    )
+)
+
+export const createIndex: {
+  (
+    indexSpec: IndexSpecification,
+    options?: CreateIndexesOptions
+  ): <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<string, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexSpec: IndexSpecification,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<string, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexSpec: IndexSpecification,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<string, MongoError.MongoError, R> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.createIndex(indexSpec, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<string>("createIndex error"))
+    )
+)
+
+export const dropIndex: {
+  (
+    indexName: string,
+    options?: DropIndexesOptions
+  ): <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<void, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexName: string,
+    options?: DropIndexesOptions
+  ): Effect.Effect<void, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexName: string,
+    options?: DropIndexesOptions
+  ): Effect.Effect<void, MongoError.MongoError, R> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.dropIndex(indexName, options)),
+      Effect.asVoid,
+      Effect.catchAllDefect(MongoError.mongoErrorDie<void>("dropIndex error"))
+    )
+)
+
+export const aggregate: {
+  <B extends Document, BI extends Document, BR>(
+    pipeline: Array<Document>,
+    schema: Schema.Schema<B, BI, BR>,
+    options?: AggregateOptions
+  ): <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => AggregationCursor.AggregationCursor<B, BI, BR>
+  <A extends Document, I extends Document, R, B extends Document, BI extends Document, BR>(
+    collection: Collection<A, I, R>,
+    pipeline: Array<Document>,
+    schema: Schema.Schema<B, BI, BR>,
+    options?: AggregateOptions
+  ): AggregationCursor.AggregationCursor<B, BI, BR>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R, B extends Document, BI extends Document, BR>(
+    collection: Collection<A, I, R>,
+    pipeline: Array<Document>,
+    schema: Schema.Schema<B, BI, BR>,
+    options?: AggregateOptions
+  ): AggregationCursor.AggregationCursor<B, BI, BR> =>
+    new AggregationCursor.AggregationCursor<B, BI, BR>({
+      cursor: collection.collection.aggregate(pipeline, options),
+      schema
+    })
+)
+
 const isCollection = (x: unknown) => x instanceof Collection