effect-mongodb 0.1.2 → 0.1.4

package/src/Db.ts

@@ -8,6 +8,7 @@ import type { Document, DropCollectionOptions, ListCollectionsOptions } from "mo
 import { Db } from "mongodb"
 import type * as Collection from "./Collection.js"
 import * as DocumentCollection from "./DocumentCollection.js"
+import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as ListCollectionsCursor from "./ListCollectionsCursor.js"
 import * as MongoError from "./MongoError.js"
 
@@ -17,7 +18,7 @@ export const documentCollection: {
 } = F.dual(
   (args) => isDb(args[0]),
   (db: Db, name: string): DocumentCollection.DocumentCollection =>
-    new DocumentCollection.DocumentCollection({
+    new DocumentCollection.DocumentCollectionImpl({
       collection: db.collection(name)
     })
 )
@@ -66,7 +67,7 @@ export const listCollections: {
 } = F.dual(
   (args) => isDb(args[0]),
   (db: Db, filter?: Document, options?: ListCollectionsOptions): ListCollectionsCursor.ListCollectionsCursor =>
-    new ListCollectionsCursor.ListCollectionsCursor({ cursor: db.listCollections(filter, options) })
+    new ListCollectionsCursor.ListCollectionsCursorImpl({ cursor: db.listCollections(filter, options) })
 )
 
 export const dropCollection: {
@@ -79,8 +80,11 @@ export const dropCollection: {
   (db: Db, name: string, options?: DropCollectionOptions): Effect.Effect<boolean, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => db.dropCollection(name, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<boolean>("dropCollection error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(db, "dropCollection")))
     )
 )
 
 const isDb = (x: unknown) => x instanceof Db
+
+const errorSource = (db: Db, functionName: string) =>
+  new MongoError.DbErrorSource({ module: "Db", functionName, db: db.databaseName })

package/src/DocumentAggregationCursor.ts

@@ -4,21 +4,35 @@
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
+import type { Pipeable } from "effect/Pipeable"
+import { pipeArguments } from "effect/Pipeable"
 import * as Stream from "effect/Stream"
 import type { AggregationCursor as MongoAggregationCursor, Document } from "mongodb"
+import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export class DocumentAggregationCursor
-  extends Data.TaggedClass("DocumentAggregationCursor")<{ cursor: MongoAggregationCursor<Document> }>
+type DocumentAggregationCursorFields = { cursor: MongoAggregationCursor<Document> }
+
+export interface DocumentAggregationCursor extends DocumentAggregationCursorFields, Pipeable {
+  _tag: "DocumentAggregationCursor"
+}
+
+/** @internal */
+export class DocumentAggregationCursorImpl
+  extends Data.TaggedClass("DocumentAggregationCursor")<DocumentAggregationCursorFields>
+  implements DocumentAggregationCursor
 {
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const toArray = (
   cursor: DocumentAggregationCursor
 ): Effect.Effect<Array<Document>, MongoError.MongoError> =>
   F.pipe(
-    Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }),
-    Effect.catchAll(MongoError.mongoErrorDie<Array<Document>>(`${cursor._tag}.toArray error`))
+    Effect.promise(() => cursor.cursor.toArray()),
+    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray")))
   )
 
 export const toStream = (
@@ -26,5 +40,13 @@ export const toStream = (
 ): Stream.Stream<Document, MongoError.MongoError> =>
   F.pipe(
     Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(MongoError.mongoErrorStream<Document>(`${cursor._tag}.toStream error`))
+    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream")))
   )
+
+const errorSource = (cursor: DocumentAggregationCursor, functionName: string) =>
+  new MongoError.CollectionErrorSource({
+    module: DocumentAggregationCursorImpl.name,
+    functionName,
+    db: cursor.cursor.namespace.db,
+    collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"
+  })

package/src/DocumentCollection.ts

@@ -6,6 +6,8 @@ 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 { Pipeable } from "effect/Pipeable"
+import { pipeArguments } from "effect/Pipeable"
 import type * as Schema from "effect/Schema"
 import type {
   AggregateOptions,
@@ -40,11 +42,24 @@ import * as Collection from "./Collection.js"
 import * as DocumentAggregationCursor from "./DocumentAggregationCursor.js"
 import * as DocumentFindCursor from "./DocumentFindCursor.js"
 import type { ModifyResult } from "./internal/modify-result.js"
+import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export class DocumentCollection extends Data.TaggedClass("DocumentCollection")<{
+type DocumentCollectionFields = {
   collection: MongoCollection
-}> {
+}
+
+export interface DocumentCollection extends DocumentCollectionFields, Pipeable {
+  _tag: "DocumentCollection"
+}
+
+/** @internal */
+export class DocumentCollectionImpl extends Data.TaggedClass("DocumentCollection")<DocumentCollectionFields>
+  implements DocumentCollection
+{
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const find: {
@@ -60,7 +75,7 @@ export const find: {
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
   (collection: DocumentCollection, filter?: Filter<Document>, options?: FindOptions) =>
-    new DocumentFindCursor.DocumentFindCursor(
+    new DocumentFindCursor.DocumentFindCursorImpl(
       {
         cursor: collection.collection.find(filter ?? {}, options)
       }
@@ -86,7 +101,7 @@ export const findOne: {
     F.pipe(
       Effect.promise(() => collection.collection.findOne(filter, options)),
       Effect.map((value) => O.fromNullable(value)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<O.Option<Document>>("findOne error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "findOne")))
     )
 )
 
@@ -110,7 +125,7 @@ export const insertOne: {
 ): Effect.Effect<InsertOneResult, MongoError.MongoError> =>
   F.pipe(
     Effect.promise(() => collection.collection.insertOne(doc, options)),
-    Effect.catchAllDefect(MongoError.mongoErrorDie<InsertOneResult>("insertOne error"))
+    Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "insertOne")))
   ))
 
 export const insertMany: {
@@ -132,7 +147,7 @@ export const insertMany: {
 ): Effect.Effect<InsertManyResult, MongoError.MongoError> =>
   F.pipe(
     Effect.promise(() => collection.collection.insertMany(docs, options)),
-    Effect.catchAllDefect(MongoError.mongoErrorDie<InsertManyResult>("insertMany error"))
+    Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "insertMany")))
   ))
 
 export const deleteOne: {
@@ -153,7 +168,7 @@ export const deleteOne: {
   ): Effect.Effect<DeleteResult, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.deleteOne(filter, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<DeleteResult>("deleteOne error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "deleteOne")))
     )
 )
 
@@ -175,7 +190,7 @@ export const deleteMany: {
   ): Effect.Effect<DeleteResult, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.deleteMany(filter, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<DeleteResult>("deleteMany error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "deleteMany")))
     )
 )
 
@@ -205,7 +220,7 @@ export const updateMany: {
       Effect.promise(() =>
         collection.collection.updateMany(filter, Array.isArray(update) ? [...update] : update, options)
       ),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<UpdateResult>("updateMany error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "updateMany")))
     )
 )
 
@@ -233,7 +248,7 @@ export const replaceOne: {
   ): Effect.Effect<UpdateResult | Document, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.replaceOne(filter, replacement, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<UpdateResult | Document>("replaceOne error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "replaceOne")))
     )
 )
 
@@ -303,7 +318,7 @@ export const findOneAndReplace: {
         return O.fromNullable(value)
       }),
       Effect.catchAllDefect(
-        MongoError.mongoErrorDie<O.Option<Document> | ModifyResult<Document>>("findOneAndReplace error")
+        mongoErrorOrDie(errorSource(collection, "findOneAndReplace"))
       )
     )
 )
@@ -326,8 +341,8 @@ export const rename: {
   ): Effect.Effect<DocumentCollection, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.rename(newName, options)),
-      Effect.map((collection) => new DocumentCollection({ collection })),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<DocumentCollection>("rename error"))
+      Effect.map((collection) => new DocumentCollectionImpl({ collection })),
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "rename")))
     )
 )
 
@@ -342,7 +357,7 @@ export const drop: {
   ): Effect.Effect<boolean, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.drop(options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<boolean>("drop error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "drop")))
     )
 )
 
@@ -364,7 +379,7 @@ export const createIndexes: {
   ): Effect.Effect<Array<string>, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.createIndexes([...indexSpecs], options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<Array<string>>("createIndexes error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "createIndexes")))
     )
 )
 
@@ -387,32 +402,30 @@ export const createIndex: {
   ): Effect.Effect<string, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.createIndex(indexSpec, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<string>("createIndex error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "createIndex")))
     )
 )
 
-// TODO: review return type. Should we return Document like mongodb driver?
 export const dropIndex: {
   (
     indexName: string,
     options?: DropIndexesOptions
-  ): (collection: DocumentCollection) => Effect.Effect<void, MongoError.MongoError>
+  ): (collection: DocumentCollection) => Effect.Effect<Document, MongoError.MongoError>
   (
     collection: DocumentCollection,
     indexName: string,
     options?: DropIndexesOptions
-  ): Effect.Effect<void, MongoError.MongoError>
+  ): Effect.Effect<Document, MongoError.MongoError>
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
   (
     collection: DocumentCollection,
     indexName: string,
     options?: DropIndexesOptions
-  ): Effect.Effect<void, MongoError.MongoError> =>
+  ): Effect.Effect<Document, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.dropIndex(indexName, options)),
-      Effect.asVoid,
-      Effect.catchAllDefect(MongoError.mongoErrorDie<void>("dropIndex error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "dropIndex")))
     )
 )
 
@@ -432,7 +445,7 @@ export const aggregate: {
     pipeline?: ReadonlyArray<Document>,
     options?: AggregateOptions
   ): DocumentAggregationCursor.DocumentAggregationCursor =>
-    new DocumentAggregationCursor.DocumentAggregationCursor({
+    new DocumentAggregationCursor.DocumentAggregationCursorImpl({
       cursor: collection.collection.aggregate(pipeline ? [...pipeline] : undefined, options)
     })
 )
@@ -453,7 +466,7 @@ export const estimatedDocumentCount: {
   ): Effect.Effect<number, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.estimatedDocumentCount(options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<number>("estimatedDocumentCount error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "estimatedDocumentCount")))
     )
 )
 
@@ -475,7 +488,7 @@ export const countDocuments: {
   ): Effect.Effect<number, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.countDocuments(filter, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<number>("countDocuments error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "countDocuments")))
     )
 )
 
@@ -490,6 +503,18 @@ export const typed: {
 } = F.dual((args) => isDocumentCollection(args[0]), <A extends Document, I extends Document = A, R = never>(
   collection: DocumentCollection,
   schema: Schema.Schema<A, I, R>
-): Collection.Collection<A, I, R> => new Collection.Collection<A, I, R>({ collection: collection.collection, schema }))
+): Collection.Collection<A, I, R> =>
+  new Collection.CollectionImpl<A, I, R>({ collection: collection.collection, schema }))
+
+const isDocumentCollection = (x: unknown) => x instanceof DocumentCollectionImpl
 
-const isDocumentCollection = (x: unknown) => x instanceof DocumentCollection
+const errorSource = (
+  collection: DocumentCollection,
+  functionName: string
+) =>
+  new MongoError.CollectionErrorSource({
+    module: DocumentCollectionImpl.name,
+    functionName,
+    db: collection.collection.dbName,
+    collection: collection.collection.collectionName
+  })

package/src/DocumentFindCursor.ts

@@ -4,15 +4,30 @@
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
+import type { Pipeable } from "effect/Pipeable"
+import { pipeArguments } from "effect/Pipeable"
 import type * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import type { Document, Filter, FindCursor as MongoFindCursor, Sort, SortDirection } from "mongodb"
 import * as FindCursor from "./FindCursor.js"
+import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export class DocumentFindCursor extends Data.TaggedClass("DocumentFindCursor")<{
+type DocumentFindCursorFields = {
   cursor: MongoFindCursor<Document>
-}> {
+}
+
+export interface DocumentFindCursor extends DocumentFindCursorFields, Pipeable {
+  _tag: "DocumentFindCursor"
+}
+
+/** @internal */
+export class DocumentFindCursorImpl extends Data.TaggedClass("DocumentFindCursor")<DocumentFindCursorFields>
+  implements DocumentFindCursor
+{
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const filter: {
@@ -21,7 +36,7 @@ export const filter: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, filter: Filter<Document>): DocumentFindCursor =>
-    new DocumentFindCursor({ cursor: cursor.cursor.filter(filter) })
+    new DocumentFindCursorImpl({ cursor: cursor.cursor.filter(filter) })
 )
 
 export const project: {
@@ -30,7 +45,7 @@ export const project: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, value: Document): DocumentFindCursor =>
-    new DocumentFindCursor({ cursor: cursor.cursor.project(value) })
+    new DocumentFindCursorImpl({ cursor: cursor.cursor.project(value) })
 )
 
 export const sort: {
@@ -39,7 +54,7 @@ export const sort: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, sort: Sort | string, direction?: SortDirection): DocumentFindCursor =>
-    new DocumentFindCursor({ cursor: cursor.cursor.sort(sort, direction) })
+    new DocumentFindCursorImpl({ cursor: cursor.cursor.sort(sort, direction) })
 )
 
 export const limit: {
@@ -48,13 +63,13 @@ export const limit: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, value: number): DocumentFindCursor =>
-    new DocumentFindCursor({ cursor: cursor.cursor.limit(value) })
+    new DocumentFindCursorImpl({ cursor: cursor.cursor.limit(value) })
 )
 
 export const toArray = (cursor: DocumentFindCursor): Effect.Effect<Array<Document>, MongoError.MongoError> =>
   F.pipe(
-    Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }),
-    Effect.catchAll(MongoError.mongoErrorDie<Array<Document>>("toArray error"))
+    Effect.promise(() => cursor.cursor.toArray()),
+    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray")))
   )
 
 export const toStream = (
@@ -62,7 +77,7 @@ export const toStream = (
 ): Stream.Stream<Document, MongoError.MongoError> =>
   F.pipe(
     Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(MongoError.mongoErrorStream<Document>("Unable to read from mongodb cursor"))
+    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream")))
   )
 
 export const typed: {
@@ -71,6 +86,14 @@ export const typed: {
 } = F.dual((args) => isDocumentFindCursor(args[0]), <A, I = A, R = never>(
   cursor: DocumentFindCursor,
   schema: Schema.Schema<A, I, R>
-): FindCursor.FindCursor<A, I, R> => new FindCursor.FindCursor<A, I, R>({ cursor: cursor.cursor, schema }))
+): FindCursor.FindCursor<A, I, R> => new FindCursor.FindCursorImpl<A, I, R>({ cursor: cursor.cursor, schema }))
+
+const isDocumentFindCursor = (x: unknown) => x instanceof DocumentFindCursorImpl
 
-const isDocumentFindCursor = (x: unknown) => x instanceof DocumentFindCursor
+const errorSource = (cursor: DocumentFindCursor, functionName: string) =>
+  new MongoError.CollectionErrorSource({
+    module: DocumentFindCursorImpl.name,
+    functionName,
+    db: cursor.cursor.namespace.db,
+    collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"
+  })

package/src/FindCursor.ts

@@ -6,17 +6,32 @@ import * as Effect from "effect/Effect"
 import type * as E from "effect/Either"
 import * as F from "effect/Function"
 import type * as ParseResult from "effect/ParseResult"
+import type { Pipeable } from "effect/Pipeable"
+import { pipeArguments } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import * as Tuple from "effect/Tuple"
 import type { Document, FindCursor as FindCursor_, Sort, SortDirection } from "mongodb"
 import type { Filter } from "./internal/filter.js"
+import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export class FindCursor<A, I = A, R = never> extends Data.TaggedClass("FindCursor")<{
+type FindCursorFields<A, I = A, R = never> = {
   cursor: FindCursor_<unknown>
   schema: Schema.Schema<A, I, R>
-}> {
+}
+
+export interface FindCursor<A, I = A, R = never> extends FindCursorFields<A, I, R>, Pipeable {
+  _tag: "FindCursor"
+}
+
+/** @internal */
+export class FindCursorImpl<A, I = A, R = never> extends Data.TaggedClass("FindCursor")<FindCursorFields<A, I, R>>
+  implements FindCursor<A, I, R>
+{
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const filter: {
@@ -27,7 +42,7 @@ export const filter: {
   <A, I extends Document, R>(
     cursor: FindCursor<A, I, R>,
     filter: Filter<I>
-  ): FindCursor<A, I, R> => new FindCursor({ cursor: cursor.cursor.filter(filter), schema: cursor.schema })
+  ): FindCursor<A, I, R> => new FindCursorImpl({ cursor: cursor.cursor.filter(filter), schema: cursor.schema })
 )
 
 export const project: {
@@ -46,7 +61,7 @@ export const project: {
     cursor: FindCursor<A, I, R>,
     newSchema: Schema.Schema<B, BI, BR>,
     value: T
-  ): FindCursor<B, BI, BR> => new FindCursor({ cursor: cursor.cursor.project(value), schema: newSchema })
+  ): FindCursor<B, BI, BR> => new FindCursorImpl({ cursor: cursor.cursor.project(value), schema: newSchema })
 )
 
 export const sort: {
@@ -62,7 +77,7 @@ export const sort: {
     cursor: FindCursor<A, I, R>,
     sort: Sort | string,
     direction?: SortDirection
-  ): FindCursor<A, I, R> => new FindCursor({ cursor: cursor.cursor.sort(sort, direction), schema: cursor.schema })
+  ): FindCursor<A, I, R> => new FindCursorImpl({ cursor: cursor.cursor.sort(sort, direction), schema: cursor.schema })
 )
 
 export const limit: {
@@ -71,15 +86,15 @@ export const limit: {
 } = F.dual(
   (args) => isFindCursor(args[0]),
   <A, I, R>(cursor: FindCursor<A, I, R>, value: number): FindCursor<A, I, R> =>
-    new FindCursor({ cursor: cursor.cursor.limit(value), schema: cursor.schema })
+    new FindCursorImpl({ cursor: cursor.cursor.limit(value), schema: cursor.schema })
 )
 
 export const toArray = <A, I, R>(
   cursor: FindCursor<A, I, R>
 ): Effect.Effect<Array<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<Array<A>>("Unable to get array from mongodb cursor")),
+  return Effect.promise(() => cursor.cursor.toArray()).pipe(
+    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray"))),
     Effect.flatMap(Effect.forEach((x) => decode(x)))
   )
 }
@@ -92,8 +107,8 @@ export const toArrayEither = <A, I, R>(
   R
 > => {
   const decode = Schema.decodeUnknown(cursor.schema)
-  return Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }).pipe(
-    Effect.catchAll(MongoError.mongoErrorDie<Array<unknown>>("Unable to get array from mongodb cursor")),
+  return Effect.promise(() => cursor.cursor.toArray()).pipe(
+    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArrayEither"))),
     Effect.flatMap(Effect.forEach((x) =>
       F.pipe(
         decode(x),
@@ -110,7 +125,7 @@ export const toStream = <A, I, 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 cursor")),
+    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream"))),
     Stream.mapEffect((x) => decode(x))
   )
 }
@@ -121,7 +136,7 @@ export const toStreamEither = <A, I, 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 either from mongodb cursor")),
+    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStreamEither"))),
     Stream.mapEffect((x) =>
       F.pipe(
         // keep new line
@@ -133,4 +148,12 @@ export const toStreamEither = <A, I, R>(
   )
 }
 
-const isFindCursor = (x: unknown): x is FindCursor<unknown> => x instanceof FindCursor
+const isFindCursor = (x: unknown): x is FindCursor<unknown> => x instanceof FindCursorImpl
+
+const errorSource = <A, I, R>(cursor: FindCursor<A, I, R>, functionName: string) =>
+  new MongoError.CollectionErrorSource({
+    module: FindCursorImpl.name,
+    functionName,
+    db: cursor.cursor.namespace.db,
+    collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"
+  })

package/src/ListCollectionsCursor.ts

@@ -4,11 +4,14 @@
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
+import type { Pipeable } from "effect/Pipeable"
+import { pipeArguments } from "effect/Pipeable"
 import * as Stream from "effect/Stream"
 import type {
   CollectionInfo as MongoCollectionInfo,
   ListCollectionsCursor as MongoListCollectionsCursor
 } from "mongodb"
+import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
 export type NameOnlyCollectionInfo = Pick<MongoCollectionInfo, "name" | "type">
@@ -16,11 +19,24 @@ export type FullCollectionInfo = MongoCollectionInfo
 
 type DefaultCollectionInfo = NameOnlyCollectionInfo | FullCollectionInfo
 
-export class ListCollectionsCursor<
-  T extends DefaultCollectionInfo = DefaultCollectionInfo
-> extends Data.TaggedClass("ListCollectionsCursor")<{
+type ListCollectionsCursorFields<T extends DefaultCollectionInfo = DefaultCollectionInfo> = {
   cursor: MongoListCollectionsCursor<T>
-}> {}
+}
+
+export interface ListCollectionsCursor<T extends DefaultCollectionInfo = DefaultCollectionInfo>
+  extends ListCollectionsCursorFields<T>, Pipeable
+{
+  _tag: "ListCollectionsCursor"
+}
+
+/** @internal */
+export class ListCollectionsCursorImpl<
+  T extends DefaultCollectionInfo = DefaultCollectionInfo
+> extends Data.TaggedClass("ListCollectionsCursor")<ListCollectionsCursorFields<T>> implements Pipeable {
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
 
 export type NameOnlyListCollectionsCursor = ListCollectionsCursor<
   Pick<MongoCollectionInfo, "name" | "type">
@@ -32,8 +48,8 @@ export const toArray = <T extends DefaultCollectionInfo>(
   cursor: ListCollectionsCursor<T>
 ): Effect.Effect<Array<T>, MongoError.MongoError> =>
   F.pipe(
-    Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }),
-    Effect.catchAll(MongoError.mongoErrorDie<Array<T>>(`${cursor._tag}.toArray error`))
+    Effect.promise(() => cursor.cursor.toArray()),
+    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray")))
   )
 
 export const toStream = <T extends DefaultCollectionInfo>(
@@ -41,5 +57,13 @@ export const toStream = <T extends DefaultCollectionInfo>(
 ): Stream.Stream<T, MongoError.MongoError> =>
   F.pipe(
     Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(MongoError.mongoErrorStream<T>(`${cursor._tag}.toStream error`))
+    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream")))
   )
+
+const errorSource = (cursor: ListCollectionsCursor, functionName: string) =>
+  new MongoError.CollectionErrorSource({
+    module: ListCollectionsCursorImpl.name,
+    functionName,
+    db: cursor.cursor.namespace.db,
+    collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"
+  })

package/src/MongoClient.ts

@@ -6,6 +6,7 @@ import * as F from "effect/Function"
 import type * as Scope from "effect/Scope"
 import type { Db, DbOptions, MongoClientOptions } from "mongodb"
 import { MongoClient as MongoClient_ } from "mongodb"
+import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
 export type MongoClient = MongoClient_
@@ -15,7 +16,7 @@ export const connect = (
   options?: MongoClientOptions
 ): Effect.Effect<MongoClient, MongoError.MongoError> =>
   Effect.promise(() => MongoClient_.connect(url, options)).pipe(
-    Effect.catchAll(MongoError.mongoErrorDie<MongoClient_>("connect error"))
+    Effect.catchAllDefect(mongoErrorOrDie(errorSource([new URL(url).host], "connect")))
   )
 
 export const close: {
@@ -25,7 +26,7 @@ export const close: {
   (args) => isMongoClient(args[0]),
   (client: MongoClient, force?: boolean): Effect.Effect<void, MongoError.MongoError> =>
     Effect.promise(() => client.close(force)).pipe(
-      Effect.catchAll(MongoError.mongoErrorDie<void>("close error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(client.options.hosts.map((x) => x.host ?? "NO_HOST"), "close")))
     )
 )
 
@@ -47,3 +48,6 @@ export const db: {
 )
 
 const isMongoClient = (x: unknown) => x instanceof MongoClient_
+
+const errorSource = (hosts: Array<string>, functionName: string) =>
+  new MongoError.ClientErrorSource({ module: "MongoClient", functionName, hosts })