effect-mongodb 0.4.0 → 0.5.0

package/src/DocumentCollection.ts

@@ -25,6 +25,7 @@ import type {
   EstimatedDocumentCountOptions,
   Filter,
   FindOneAndReplaceOptions,
+  FindOneAndUpdateOptions,
   FindOptions,
   IndexDescription,
   IndexSpecification,
@@ -44,7 +45,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 { mongoOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 type DocumentCollectionFields = {
@@ -103,7 +104,7 @@ export const findOne: {
     F.pipe(
       Effect.promise(() => collection.collection.findOne(filter, options)),
       Effect.map((value) => O.fromNullable(value)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "findOne")))
+      mongoOperation(errorSource(collection, "findOne"))
     )
 )
 
@@ -127,7 +128,7 @@ export const insertOne: {
 ): Effect.Effect<InsertOneResult, MongoError.MongoError> =>
   F.pipe(
     Effect.promise(() => collection.collection.insertOne(doc, options)),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "insertOne")))
+    mongoOperation(errorSource(collection, "insertOne"))
   ))
 
 export const insertMany: {
@@ -149,7 +150,7 @@ export const insertMany: {
 ): Effect.Effect<InsertManyResult, MongoError.MongoError> =>
   F.pipe(
     Effect.promise(() => collection.collection.insertMany(docs, options)),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "insertMany")))
+    mongoOperation(errorSource(collection, "insertMany"))
   ))
 
 export const deleteOne: {
@@ -170,7 +171,7 @@ export const deleteOne: {
   ): Effect.Effect<DeleteResult, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.deleteOne(filter, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "deleteOne")))
+      mongoOperation(errorSource(collection, "deleteOne"))
     )
 )
 
@@ -192,7 +193,7 @@ export const deleteMany: {
   ): Effect.Effect<DeleteResult, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.deleteMany(filter, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "deleteMany")))
+      mongoOperation(errorSource(collection, "deleteMany"))
     )
 )
 
@@ -222,7 +223,7 @@ export const updateOne: {
       Effect.promise(() =>
         collection.collection.updateOne(filter, Array.isArray(update) ? [...update] : update, options)
       ),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "updateOne")))
+      mongoOperation(errorSource(collection, "updateOne"))
     )
 )
 
@@ -252,7 +253,7 @@ export const updateMany: {
       Effect.promise(() =>
         collection.collection.updateMany(filter, Array.isArray(update) ? [...update] : update, options)
       ),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "updateMany")))
+      mongoOperation(errorSource(collection, "updateMany"))
     )
 )
 
@@ -280,7 +281,7 @@ export const replaceOne: {
   ): Effect.Effect<UpdateResult | Document, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.replaceOne(filter, replacement, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "replaceOne")))
+      mongoOperation(errorSource(collection, "replaceOne"))
     )
 )
 
@@ -349,9 +350,82 @@ export const findOneAndReplace: {
         }
         return O.fromNullable(value)
       }),
-      Effect.catchAllDefect(
-        mongoErrorOrDie(errorSource(collection, "findOneAndReplace"))
-      )
+      mongoOperation(errorSource(collection, "findOneAndReplace"))
+    )
+)
+
+export const findOneAndUpdate: {
+  (
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
+    options: FindOneAndUpdateOptions & { includeResultMetadata: true }
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<ModifyResult<Document>, MongoError.MongoError>
+  (
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
+    options: FindOneAndUpdateOptions & { includeResultMetadata: false }
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
+    options: FindOneAndUpdateOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (filter: Filter<Document>, update: UpdateFilter<Document> | ReadonlyArray<Document>): (
+    collection: DocumentCollection
+  ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
+    options: FindOneAndUpdateOptions & { includeResultMetadata: true }
+  ): Effect.Effect<ModifyResult<Document>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
+    options: FindOneAndUpdateOptions & { includeResultMetadata: false }
+  ): Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
+    options: FindOneAndUpdateOptions
+  ): Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>
+  ): Effect.Effect<O.Option<Document>, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
+    options?: FindOneAndUpdateOptions
+  ): Effect.Effect<O.Option<Document> | ModifyResult<Document>, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() =>
+        collection.collection.findOneAndUpdate(
+          filter,
+          Array.isArray(update) ? [...update] : update,
+          options ?? {}
+        )
+      ),
+      Effect.map((value) => {
+        if (options?.includeResultMetadata && !!value) {
+          const result = value as unknown as MongoModifyResult<Document>
+          return { ...result, value: O.fromNullable(result.value) }
+        }
+        return O.fromNullable(value)
+      }),
+      mongoOperation(errorSource(collection, "findOneAndUpdate"))
     )
 )
 
@@ -374,7 +448,7 @@ export const rename: {
     F.pipe(
       Effect.promise(() => collection.collection.rename(newName, options)),
       Effect.map((collection) => new DocumentCollectionImpl({ collection })),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "rename")))
+      mongoOperation(errorSource(collection, "rename"))
     )
 )
 
@@ -389,7 +463,7 @@ export const drop: {
   ): Effect.Effect<boolean, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.drop(options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "drop")))
+      mongoOperation(errorSource(collection, "drop"))
     )
 )
 
@@ -411,7 +485,7 @@ export const createIndexes: {
   ): Effect.Effect<Array<string>, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.createIndexes([...indexSpecs], options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "createIndexes")))
+      mongoOperation(errorSource(collection, "createIndexes"))
     )
 )
 
@@ -434,7 +508,7 @@ export const createIndex: {
   ): Effect.Effect<string, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.createIndex(indexSpec, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "createIndex")))
+      mongoOperation(errorSource(collection, "createIndex"))
     )
 )
 
@@ -457,7 +531,7 @@ export const dropIndex: {
   ): Effect.Effect<Document, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.dropIndex(indexName, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "dropIndex")))
+      mongoOperation(errorSource(collection, "dropIndex"))
     )
 )
 
@@ -477,7 +551,7 @@ export const dropIndexes: {
   ): Effect.Effect<boolean, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.dropIndexes(options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "dropIndexes")))
+      mongoOperation(errorSource(collection, "dropIndexes"))
     )
 )
 
@@ -518,7 +592,7 @@ export const estimatedDocumentCount: {
   ): Effect.Effect<number, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.estimatedDocumentCount(options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "estimatedDocumentCount")))
+      mongoOperation(errorSource(collection, "estimatedDocumentCount"))
     )
 )
 
@@ -540,7 +614,7 @@ export const countDocuments: {
   ): Effect.Effect<number, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.countDocuments(filter, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "countDocuments")))
+      mongoOperation(errorSource(collection, "countDocuments"))
     )
 )
 
@@ -575,8 +649,8 @@ export const bulkWrite: {
     operations: ReadonlyArray<AnyBulkWriteOperation<Document>>,
     options?: BulkWriteOptions
   ): Effect.Effect<BulkWriteResult, MongoError.MongoError> =>
-    Effect.tryPromise(() => collection.collection.bulkWrite(operations, options)).pipe(
-      Effect.catchAll(mongoErrorOrDie(errorSource(collection, "bulkWrite")))
+    Effect.promise(() => collection.collection.bulkWrite(operations, options)).pipe(
+      mongoOperation(errorSource(collection, "bulkWrite"))
     )
 )
 
@@ -587,7 +661,7 @@ const errorSource = (
   functionName: string
 ) =>
   new MongoError.CollectionErrorSource({
-    module: DocumentCollectionImpl.name,
+    module: "DocumentCollection",
     functionName,
     db: collection.collection.dbName,
     collection: collection.collection.collectionName

package/src/DocumentFindCursor.ts

@@ -10,7 +10,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 { mongoOperation, mongoStreamOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 type DocumentFindCursorFields = {
@@ -69,7 +69,7 @@ export const limit: {
 export const toArray = (cursor: DocumentFindCursor): Effect.Effect<Array<Document>, MongoError.MongoError> =>
   F.pipe(
     Effect.promise(() => cursor.cursor.toArray()),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray")))
+    mongoOperation(errorSource(cursor, "toArray"))
   )
 
 export const toStream = (
@@ -77,7 +77,7 @@ export const toStream = (
 ): Stream.Stream<Document, MongoError.MongoError> =>
   F.pipe(
     Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream")))
+    mongoStreamOperation(errorSource(cursor, "toStream"))
   )
 
 export const typed: {
@@ -92,7 +92,7 @@ const isDocumentFindCursor = (x: unknown) => x instanceof DocumentFindCursorImpl
 
 const errorSource = (cursor: DocumentFindCursor, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: DocumentFindCursorImpl.name,
+    module: "DocumentFindCursor",
     functionName,
     db: cursor.cursor.namespace.db,
     collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"

package/src/FindCursor.ts

@@ -13,7 +13,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 as Filter_ } from "./internal/filter.js"
-import { mongoErrorOrDie } from "./internal/mongo-error.js"
+import { mongoOperation, mongoStreamOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 type FindCursorFields<A, I = A, R = never> = {
@@ -96,7 +96,7 @@ export const toArray = <A, I, R>(
 ): Effect.Effect<Array<A>, MongoError.MongoError | ParseResult.ParseError, R> => {
   const decode = Schema.decodeUnknown(cursor.schema)
   return Effect.promise(() => cursor.cursor.toArray()).pipe(
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray"))),
+    mongoOperation(errorSource(cursor, "toArray")),
     Effect.flatMap(Effect.forEach((x) => decode(x)))
   )
 }
@@ -110,7 +110,7 @@ export const toArrayEither = <A, I, R>(
 > => {
   const decode = Schema.decodeUnknown(cursor.schema)
   return Effect.promise(() => cursor.cursor.toArray()).pipe(
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArrayEither"))),
+    mongoOperation(errorSource(cursor, "toArrayEither")),
     Effect.flatMap(Effect.forEach((x) =>
       F.pipe(
         decode(x),
@@ -127,7 +127,7 @@ export const toStream = <A, I, R>(
   const decode = Schema.decodeUnknown(cursor.schema)
   return F.pipe(
     Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream"))),
+    mongoStreamOperation(errorSource(cursor, "toStream")),
     Stream.mapEffect((x) => decode(x))
   )
 }
@@ -138,7 +138,7 @@ export const toStreamEither = <A, I, R>(
   const decode = Schema.decodeUnknown(cursor.schema)
   return F.pipe(
     Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStreamEither"))),
+    mongoStreamOperation(errorSource(cursor, "toStreamEither")),
     Stream.mapEffect((x) =>
       F.pipe(
         // keep new line
@@ -154,7 +154,7 @@ const isFindCursor = (x: unknown): x is FindCursor<unknown> => x instanceof Find
 
 const errorSource = <A, I, R>(cursor: FindCursor<A, I, R>, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: FindCursorImpl.name,
+    module: "FindCursor",
     functionName,
     db: cursor.cursor.namespace.db,
     collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"

package/src/ListCollectionsCursor.ts

@@ -11,7 +11,7 @@ import type {
   CollectionInfo as MongoCollectionInfo,
   ListCollectionsCursor as MongoListCollectionsCursor
 } from "mongodb"
-import { mongoErrorOrDie } from "./internal/mongo-error.js"
+import { mongoOperation, mongoStreamOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 export type NameOnlyCollectionInfo = Pick<MongoCollectionInfo, "name" | "type">
@@ -49,7 +49,7 @@ export const toArray = <T extends DefaultCollectionInfo>(
 ): Effect.Effect<Array<T>, MongoError.MongoError> =>
   F.pipe(
     Effect.promise(() => cursor.cursor.toArray()),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray")))
+    mongoOperation(errorSource(cursor, "toArray"))
   )
 
 export const toStream = <T extends DefaultCollectionInfo>(
@@ -57,12 +57,12 @@ export const toStream = <T extends DefaultCollectionInfo>(
 ): Stream.Stream<T, MongoError.MongoError> =>
   F.pipe(
     Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream")))
+    mongoStreamOperation(errorSource(cursor, "toStream"))
   )
 
 const errorSource = (cursor: ListCollectionsCursor, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: ListCollectionsCursorImpl.name,
+    module: "ListCollectionsCursor",
     functionName,
     db: cursor.cursor.namespace.db,
     collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"

package/src/MongoClient.ts

@@ -8,7 +8,7 @@ import type * as Scope from "effect/Scope"
 import type { DbOptions, MongoClientOptions } from "mongodb"
 import { MongoClient as MongoClient_ } from "mongodb"
 import * as Db from "./Db.js"
-import { mongoErrorOrDie } from "./internal/mongo-error.js"
+import { mongoOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 export class MongoClient extends Data.TaggedClass("MongoClient")<{ client: MongoClient_ }> {}
@@ -19,7 +19,7 @@ export const connect = (
 ): Effect.Effect<MongoClient, MongoError.MongoError> =>
   Effect.promise(() => MongoClient_.connect(url, options)).pipe(
     Effect.map((client) => new MongoClient({ client })),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(hostsFromUrl(url), "connect")))
+    mongoOperation(errorSource(hostsFromUrl(url), "connect"))
   )
 
 export const close: {
@@ -29,9 +29,7 @@ export const close: {
   (args) => isMongoClient(args[0]),
   ({ client }: MongoClient, force?: boolean): Effect.Effect<void, MongoError.MongoError> =>
     Effect.promise(() => client.close(force)).pipe(
-      Effect.catchAllDefect(
-        mongoErrorOrDie(errorSource(client.options.hosts.map((x) => x.host ?? UNKNOWN_HOST), "close"))
-      )
+      mongoOperation(errorSource(client.options.hosts.map((x) => x.host ?? UNKNOWN_HOST), "close"))
     )
 )
 

package/src/internal/mongo-operation.ts

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect"
+import * as F from "effect/Function"
+import * as Stream from "effect/Stream"
+import type { ErrorSource, MongoError } from "../MongoError.js"
+import { mongoErrorOrDie } from "./mongo-error.js"
+import { withSpan, withSpanStream } from "./tracing.js"
+
+export const mongoOperation =
+  (source: ErrorSource) => <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E | MongoError, R> =>
+    F.pipe(
+      self,
+      Effect.catchAllDefect(mongoErrorOrDie(source)),
+      withSpan(source)
+    )
+
+export const mongoStreamOperation =
+  (source: ErrorSource) => <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, MongoError, R> =>
+    F.pipe(
+      self,
+      Stream.catchAll(mongoErrorOrDie(source)),
+      withSpanStream(source)
+    )

package/src/internal/tracing.ts

@@ -0,0 +1,47 @@
+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 type * as Tracer from "effect/Tracer"
+import type { ErrorSource } from "../MongoError.js"
+
+export const withSpan = (source: ErrorSource) => <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.withSpan(self, spanName(source), spanOptions(source))
+
+export const withSpanStream =
+  (source: ErrorSource) => <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
+    Stream.withSpan(self, spanName(source), spanOptions(source))
+
+const spanName = (source: ErrorSource) => `mongodb.${source.module}.${source.functionName}`
+
+const spanOptions = (source: ErrorSource): Tracer.SpanOptions => ({
+  kind: "client",
+  captureStackTrace: false,
+  attributes: {
+    "db.system.name": "mongodb",
+    "db.operation.name": source.functionName,
+    ...sourceAttributes(source)
+  }
+})
+
+const sourceAttributes = (source: ErrorSource): Record<string, unknown> =>
+  F.pipe(
+    Match.value(source),
+    Match.tag("ClientErrorSource", (s) => serverAttributes(s.hosts)),
+    Match.tag("DbErrorSource", (s) => ({ "db.namespace": s.db })),
+    Match.tag("CollectionErrorSource", (s) => ({ "db.namespace": s.db, "db.collection.name": s.collection })),
+    Match.exhaustive
+  )
+
+const serverAttributes = (hosts: Array<string>): Record<string, unknown> => {
+  if (hosts.length !== 1) return {}
+  const [address, port] = splitHost(hosts[0])
+  return port === undefined ? { "server.address": address } : { "server.address": address, "server.port": port }
+}
+
+const splitHost = (host: string): [address: string, port: number | undefined] => {
+  const separator = host.lastIndexOf(":")
+  if (separator === -1) return [host, undefined]
+  const port = Number(host.slice(separator + 1))
+  return Number.isInteger(port) ? [host.slice(0, separator), port] : [host, undefined]
+}

package/src/internal/version.ts

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