effect-mongodb 0.1.1 → 0.1.3

package/src/DocumentCollection.ts

@@ -40,6 +40,7 @@ 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")<{
@@ -86,11 +87,15 @@ 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")))
     )
 )
 
 export const insertOne: {
+  (
+    collection: DocumentCollection,
+    doc: OptionalUnlessRequiredId<Document>
+  ): Effect.Effect<InsertOneResult, MongoError.MongoError>
   (doc: OptionalUnlessRequiredId<Document>, options?: InsertOneOptions): (
     collection: DocumentCollection
   ) => Effect.Effect<InsertOneResult, MongoError.MongoError>
@@ -106,7 +111,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: {
@@ -115,12 +120,12 @@ export const insertMany: {
     options?: BulkWriteOptions
   ): (
     collection: DocumentCollection
-  ) => Effect.Effect<InsertOneResult, MongoError.MongoError>
+  ) => Effect.Effect<InsertManyResult, MongoError.MongoError>
   (
     collection: DocumentCollection,
     docs: ReadonlyArray<OptionalUnlessRequiredId<Document>>,
     options?: BulkWriteOptions
-  ): Effect.Effect<InsertOneResult, MongoError.MongoError>
+  ): Effect.Effect<InsertManyResult, MongoError.MongoError>
 } = F.dual((args) => isDocumentCollection(args[0]), (
   collection: DocumentCollection,
   docs: ReadonlyArray<OptionalUnlessRequiredId<Document>>,
@@ -128,7 +133,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: {
@@ -149,7 +154,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")))
     )
 )
 
@@ -171,7 +176,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")))
     )
 )
 
@@ -201,7 +206,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")))
     )
 )
 
@@ -229,7 +234,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")))
     )
 )
 
@@ -299,7 +304,7 @@ export const findOneAndReplace: {
         return O.fromNullable(value)
       }),
       Effect.catchAllDefect(
-        MongoError.mongoErrorDie<O.Option<Document> | ModifyResult<Document>>("findOneAndReplace error")
+        mongoErrorOrDie(errorSource(collection, "findOneAndReplace"))
       )
     )
 )
@@ -307,22 +312,23 @@ export const findOneAndReplace: {
 export const rename: {
   (newName: string, options?: RenameOptions): (
     collection: DocumentCollection
-  ) => Effect.Effect<MongoCollection, MongoError.MongoError>
+  ) => Effect.Effect<DocumentCollection, MongoError.MongoError>
   (
     collection: DocumentCollection,
     newName: string,
     options?: RenameOptions
-  ): Effect.Effect<MongoCollection, MongoError.MongoError>
+  ): Effect.Effect<DocumentCollection, MongoError.MongoError>
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
   (
     collection: DocumentCollection,
     newName: string,
     options?: RenameOptions
-  ): Effect.Effect<MongoCollection, MongoError.MongoError> =>
+  ): Effect.Effect<DocumentCollection, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.rename(newName, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<MongoCollection>("rename error"))
+      Effect.map((collection) => new DocumentCollection({ collection })),
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "rename")))
     )
 )
 
@@ -337,7 +343,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")))
     )
 )
 
@@ -359,7 +365,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")))
     )
 )
 
@@ -382,7 +388,7 @@ 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")))
     )
 )
 
@@ -405,7 +411,7 @@ export const dropIndex: {
   ): Effect.Effect<Document, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.dropIndex(indexName, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<Document>("dropIndex error"))
+      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "dropIndex")))
     )
 )
 
@@ -446,7 +452,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")))
     )
 )
 
@@ -468,7 +474,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")))
     )
 )
 
@@ -486,3 +492,14 @@ export const typed: {
 ): Collection.Collection<A, I, R> => new Collection.Collection<A, I, R>({ collection: collection.collection, schema }))
 
 const isDocumentCollection = (x: unknown) => x instanceof DocumentCollection
+
+const errorSource = (
+  collection: DocumentCollection,
+  functionName: string
+) =>
+  new MongoError.CollectionErrorSource({
+    module: DocumentCollection.name,
+    functionName,
+    db: collection.collection.dbName,
+    collection: collection.collection.collectionName
+  })

package/src/DocumentFindCursor.ts

@@ -8,6 +8,7 @@ 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")<{
@@ -53,8 +54,8 @@ export const limit: {
 
 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 +63,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: {
@@ -74,3 +75,11 @@ export const typed: {
 ): FindCursor.FindCursor<A, I, R> => new FindCursor.FindCursor<A, I, R>({ cursor: cursor.cursor, schema }))
 
 const isDocumentFindCursor = (x: unknown) => x instanceof DocumentFindCursor
+
+const errorSource = (cursor: DocumentFindCursor, functionName: string) =>
+  new MongoError.CollectionErrorSource({
+    module: DocumentFindCursor.name,
+    functionName,
+    db: cursor.cursor.namespace.db,
+    collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"
+  })

package/src/FindCursor.ts

@@ -11,6 +11,7 @@ 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")<{
@@ -78,8 +79,8 @@ 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 +93,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 +111,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 +122,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
@@ -134,3 +135,11 @@ export const toStreamEither = <A, I, R>(
 }
 
 const isFindCursor = (x: unknown): x is FindCursor<unknown> => x instanceof FindCursor
+
+const errorSource = <A, I, R>(cursor: FindCursor<A, I, R>, functionName: string) =>
+  new MongoError.CollectionErrorSource({
+    module: FindCursor.name,
+    functionName,
+    db: cursor.cursor.namespace.db,
+    collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"
+  })

package/src/ListCollectionsCursor.ts

@@ -9,6 +9,7 @@ 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">
@@ -32,8 +33,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 +42,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: ListCollectionsCursor.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 })

package/src/MongoError.ts

@@ -2,39 +2,31 @@
  * @since 0.0.1
  */
 import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import * as F from "effect/Function"
-import * as Match from "effect/Match"
-import * as Stream from "effect/Stream"
-import { MongoError as MongoError_ } from "mongodb"
+import type { MongoError as MongoError_ } from "mongodb"
 
-export class MongoError extends Data.TaggedError("MongoError")<{
-  message: string
-  innerError: MongoError_
+export class ClientErrorSource extends Data.TaggedClass("ClientErrorSource")<{
+  module: string
+  functionName: string
+  hosts: Array<string>
 }> {}
 
-export const mongoErrorDie: {
-  <A>(message: string): (error: unknown) => Effect.Effect<A, MongoError>
-  <A>(error: unknown, message: string): Effect.Effect<A, MongoError>
-} = F.dual(2, <A>(error: unknown, message: string): Effect.Effect<A, MongoError> =>
-  F.pipe(
-    Match.value(error),
-    Match.when(Match.instanceOf(MongoError_), (innerError) => Effect.fail(new MongoError({ message, innerError }))),
-    Match.orElse((cause) =>
-      Effect.die(
-        new Error(message, {
-          cause
-        })
-      )
-    )
-  ))
+export class DbErrorSource extends Data.TaggedClass("DbErrorSource")<{
+  module: string
+  functionName: string
+  db: string
+}> {}
+
+export class CollectionErrorSource extends Data.TaggedClass("CollectionErrorSource")<{
+  module: string
+  functionName: string
+  db: string
+  collection: string
+}> {}
 
-export const mongoErrorStream: {
-  <A>(message: string): (error: unknown) => Stream.Stream<A, MongoError>
-  <A>(error: unknown, message: string): Stream.Stream<A, MongoError>
-} = F.dual(2, <A>(error: unknown, message: string): Stream.Stream<A, MongoError> =>
-  F.pipe(
-    Match.value(error),
-    Match.when(Match.instanceOf(MongoError_), (innerError) => Stream.fail(new MongoError({ message, innerError }))),
-    Match.orElse((cause) => Stream.die(new Error(message, { cause })))
-  ))
+export type ErrorSource = ClientErrorSource | DbErrorSource | CollectionErrorSource
+
+export class MongoError extends Data.TaggedError("MongoError")<{
+  message: string
+  cause: MongoError_
+  source?: ErrorSource
+}> {}

package/src/internal/mongo-error.ts

@@ -0,0 +1,34 @@
+import * as Effect from "effect/Effect"
+import * as F from "effect/Function"
+import * as Match from "effect/Match"
+import { MongoError as MongoError_ } from "mongodb"
+import type { ErrorSource } from "../MongoError.js"
+import { MongoError } from "../MongoError.js"
+
+export const mongoErrorOrDie =
+  (source: ErrorSource, message?: string) => (error: unknown): Effect.Effect<never, MongoError> =>
+    F.pipe(
+      Match.value(error),
+      Match.when(Match.instanceOf(MongoError_), F.flow(makeMongoError(source, message), Effect.fail)),
+      Match.orElse(F.flow(makeError(source, message), Effect.die))
+    )
+
+const makeMongoError = (source: ErrorSource, message: string | undefined) => (cause: MongoError_) =>
+  new MongoError({ message: messageFrom(source, message), cause, source })
+
+const makeError = (source: ErrorSource, message: string | undefined) => (cause: unknown) =>
+  new Error(messageFrom(source, message), { cause })
+
+const messageFrom = (source: ErrorSource, message?: string) =>
+  message ? `${messageFromSource(source)} - ${message}` : messageFromSource(source)
+
+const messageFromSource = (source: ErrorSource) =>
+  F.pipe(
+    Match.value(source),
+    Match.tag("ClientErrorSource", (s) => `${baseMessage(s)} - hosts ${s.hosts.join(", ")}`),
+    Match.tag("DbErrorSource", (s) => `${baseMessage(s)} - ${s.db}`),
+    Match.tag("CollectionErrorSource", (s) => `${baseMessage(s)} - ${s.db}.${s.collection}`),
+    Match.exhaustive
+  )
+
+const baseMessage = (s: { module: string; functionName: string }) => `Error in ${s.module}.${s.functionName}`

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "0.1.1"
+let moduleVersion = "0.1.3"
 
 export const getCurrentVersion = () => moduleVersion