effect-mongodb 0.0.2

package/src/MongoClient.ts

@@ -0,0 +1,35 @@
+/**
+ * @since 0.0.1
+ */
+import type * as Brand from "effect/Brand"
+import * as Effect from "effect/Effect"
+import * as F from "effect/Function"
+import type { Db, DbOptions, MongoClientOptions } from "mongodb"
+import { MongoClient as MongoClient_ } from "mongodb"
+import * as MongoError from "./MongoError.js"
+
+import * as Context from "effect/Context"
+
+export type MongoClient = MongoClient_
+
+export const connect = (url: string, options?: MongoClientOptions) =>
+  Effect.promise(() => MongoClient_.connect(url, options)).pipe(
+    Effect.catchAll(MongoError.mongoErrorDie<MongoClient_>("connect error"))
+  )
+
+export const db: {
+  (dbName?: string, options?: DbOptions): (client: MongoClient) => Db
+  (client: MongoClient, dbName?: string, options?: DbOptions): Db
+} = F.dual(
+  (args) => isMongoClient(args[0]),
+  (client: MongoClient, dbName?: string, options?: DbOptions) => client.db(dbName, options)
+)
+
+const isMongoClient = (x: unknown) => x instanceof MongoClient_
+
+export type MongoClientService<K extends string> = {
+  client: Effect.Effect<MongoClient, MongoError.MongoError>
+} & Brand.Brand<K>
+
+export const Tag = <K extends string>(key: K) => Context.GenericTag<MongoClientService<K>>(key)
+export type TagType<K extends string> = ReturnType<typeof Tag<K>>

package/src/MongoError.ts

@@ -0,0 +1,40 @@
+/**
+ * @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"
+
+export class MongoError extends Data.TaggedError("MongoError")<{
+  message: string
+  innerError: MongoError_
+}> {}
+
+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 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 })))
+  ))

package/src/index.ts

@@ -0,0 +1,34 @@
+/**
+ * @since 0.0.1
+ */
+export * as Collection from "./Collection.js"
+
+/**
+ * @since 0.0.1
+ */
+export * as Db from "./Db.js"
+
+/**
+ * @since 0.0.1
+ */
+export * as DocumentCollection from "./DocumentCollection.js"
+
+/**
+ * @since 0.0.1
+ */
+export * as DocumentFindCursor from "./DocumentFindCursor.js"
+
+/**
+ * @since 0.0.1
+ */
+export * as FindCursor from "./FindCursor.js"
+
+/**
+ * @since 0.0.1
+ */
+export * as MongoClient from "./MongoClient.js"
+
+/**
+ * @since 0.0.1
+ */
+export * as MongoError from "./MongoError.js"

package/src/internal/version.ts

@@ -0,0 +1,7 @@
+let moduleVersion = "0.0.2"
+
+export const getCurrentVersion = () => moduleVersion
+
+export const setCurrentVersion = (version: string) => {
+  moduleVersion = version
+}