effect-mongodb 0.1.2 → 0.1.4

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/schema.ts

@@ -5,8 +5,8 @@ import type { Document } from "mongodb"
 
 // TODO: there is probably a Schema to do this decode or using typeclass package for traverse
 export const decodeNullableDocument = <A, I, R>(schema: Schema.Schema<A, I, R>, value: Document | null) =>
-  Effect.gen(function*(_) {
+  Effect.gen(function*() {
     if (value === null) return O.none()
-    const decoded = yield* _(Schema.decodeUnknown(schema)(value))
+    const decoded = yield* Schema.decodeUnknown(schema)(value)
     return O.some(decoded)
   })

package/src/internal/version.ts

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