effect-mongodb 0.0.2

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "effect-mongodb",
+  "version": "0.0.2",
+  "description": "A MongoDB toolkit for Effect",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/doubleloop-io/effect-mongodb",
+    "directory": "packages/effect-mongodb"
+  },
+  "sideEffects": [],
+  "author": "doubleloop.io",
+  "homepage": "https://github.com/doubleloop-io/effect-mongodb",
+  "peerDependencies": {
+    "@effect/schema": "^0.73.4",
+    "effect": "^3.8.3",
+    "mongodb": "^6.8.0"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/dts/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/dts/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./Collection": {
+      "types": "./dist/dts/Collection.d.ts",
+      "import": "./dist/esm/Collection.js",
+      "default": "./dist/cjs/Collection.js"
+    },
+    "./Db": {
+      "types": "./dist/dts/Db.d.ts",
+      "import": "./dist/esm/Db.js",
+      "default": "./dist/cjs/Db.js"
+    },
+    "./DocumentCollection": {
+      "types": "./dist/dts/DocumentCollection.d.ts",
+      "import": "./dist/esm/DocumentCollection.js",
+      "default": "./dist/cjs/DocumentCollection.js"
+    },
+    "./DocumentFindCursor": {
+      "types": "./dist/dts/DocumentFindCursor.d.ts",
+      "import": "./dist/esm/DocumentFindCursor.js",
+      "default": "./dist/cjs/DocumentFindCursor.js"
+    },
+    "./FindCursor": {
+      "types": "./dist/dts/FindCursor.d.ts",
+      "import": "./dist/esm/FindCursor.js",
+      "default": "./dist/cjs/FindCursor.js"
+    },
+    "./MongoClient": {
+      "types": "./dist/dts/MongoClient.d.ts",
+      "import": "./dist/esm/MongoClient.js",
+      "default": "./dist/cjs/MongoClient.js"
+    },
+    "./MongoError": {
+      "types": "./dist/dts/MongoError.d.ts",
+      "import": "./dist/esm/MongoError.js",
+      "default": "./dist/cjs/MongoError.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "Collection": [
+        "./dist/dts/Collection.d.ts"
+      ],
+      "Db": [
+        "./dist/dts/Db.d.ts"
+      ],
+      "DocumentCollection": [
+        "./dist/dts/DocumentCollection.d.ts"
+      ],
+      "DocumentFindCursor": [
+        "./dist/dts/DocumentFindCursor.d.ts"
+      ],
+      "FindCursor": [
+        "./dist/dts/FindCursor.d.ts"
+      ],
+      "MongoClient": [
+        "./dist/dts/MongoClient.d.ts"
+      ],
+      "MongoError": [
+        "./dist/dts/MongoError.d.ts"
+      ]
+    }
+  }
+}

package/src/Collection.ts

@@ -0,0 +1,130 @@
+/**
+ * @since 0.0.1
+ */
+import type * as ParseResult from "@effect/schema/ParseResult"
+import * as Schema from "@effect/schema/Schema"
+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 {
+  BulkWriteOptions,
+  Collection as MongoCollection,
+  Document,
+  Filter,
+  FindOptions as MongoFindOptions,
+  InsertManyResult,
+  InsertOneOptions,
+  InsertOneResult
+} from "mongodb"
+import * as FindCursor from "./FindCursor.js"
+import * as MongoError from "./MongoError.js"
+
+export class Collection<A extends Document, I extends Document = A, R = never> extends Data.TaggedClass("Collection")<{
+  collection: MongoCollection
+  schema: Schema.Schema<A, I, R>
+}> {
+}
+
+export type FindOptions = Omit<MongoFindOptions, "projection">
+
+export const find: {
+  (
+    options?: FindOptions
+  ): <A extends Document, I extends Document = A, R = never>(
+    collection: Collection<A, I, R>
+  ) => FindCursor.FindCursor<A, I, R>
+  <A extends Document, I extends Document = A, R = never>(
+    collection: Collection<A, I, R>,
+    options?: FindOptions
+  ): FindCursor.FindCursor<A, I, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document = A, R = never>(
+    collection: Collection<A, I, R>,
+    options?: FindOptions
+  ): FindCursor.FindCursor<A, I, R> =>
+    new FindCursor.FindCursor<A, I, R>({
+      cursor: collection.collection.find({}, options),
+      schema: collection.schema
+    })
+)
+
+export const findOne: {
+  <A extends Document, I extends Document = A, R = never>(
+    filter: Filter<I>,
+    options?: FindOptions
+  ): (
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<O.Option<Document>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document = A, R = never>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    options?: FindOptions
+  ): Effect.Effect<O.Option<Document>, MongoError.MongoError | ParseResult.ParseError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document = A, R = never>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    options?: FindOptions
+  ): Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R> =>
+    Effect.gen(function*(_) {
+      const value = yield* _(Effect.promise(() => collection.collection.findOne(filter as Filter<Document>, options)))
+      if (value !== null) return O.some(yield* _(Schema.decodeUnknown(collection.schema)(value)))
+      return O.none()
+    }).pipe(
+      Effect.catchAllDefect(MongoError.mongoErrorDie<O.Option<A>>("findOne error"))
+    )
+)
+
+export const insertOne: {
+  <A extends Document, I extends Document = A, R = never>(
+    doc: A,
+    options?: InsertOneOptions
+  ): (
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<InsertOneResult, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document = A, R = never>(
+    collection: Collection<A, I, R>,
+    doc: A,
+    options?: InsertOneOptions
+  ): Effect.Effect<InsertOneResult, MongoError.MongoError | ParseResult.ParseError, R>
+} = F.dual((args) => isCollection(args[0]), <A extends Document, I extends Document = A, R = never>(
+  collection: Collection<A, I, R>,
+  doc: A,
+  options?: InsertOneOptions
+): Effect.Effect<InsertOneResult, MongoError.MongoError | ParseResult.ParseError, R> =>
+  F.pipe(
+    Schema.encode(collection.schema)(doc),
+    Effect.flatMap((doc) => Effect.promise(() => collection.collection.insertOne(doc, options))),
+    Effect.catchAllDefect(MongoError.mongoErrorDie<InsertOneResult>("insertOne error"))
+  ))
+
+export const insertMany: {
+  <A extends Document, I extends Document = A, R = never>(
+    docs: Array<A>,
+    options?: BulkWriteOptions
+  ): (
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<InsertManyResult, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document = A, R = never>(
+    collection: Collection<A, I, R>,
+    docs: Array<A>,
+    options?: BulkWriteOptions
+  ): Effect.Effect<InsertManyResult, MongoError.MongoError | ParseResult.ParseError, R>
+} = F.dual((args) => isCollection(args[0]), <A extends Document, I extends Document = A, R = never>(
+  collection: Collection<A, I, R>,
+  docs: Array<A>,
+  options?: BulkWriteOptions
+): Effect.Effect<InsertManyResult, MongoError.MongoError | ParseResult.ParseError, R> => {
+  const encode = Schema.encode(collection.schema)
+  return F.pipe(
+    docs,
+    Effect.forEach((doc) => encode(doc)),
+    Effect.flatMap((docs) => Effect.promise(() => collection.collection.insertMany(docs, options))),
+    Effect.catchAllDefect(MongoError.mongoErrorDie<InsertManyResult>("insertMany error"))
+  )
+})
+
+const isCollection = (x: unknown) => x instanceof Collection

package/src/Db.ts

@@ -0,0 +1,79 @@
+/**
+ * @since 0.0.1
+ */
+import type * as Schema from "@effect/schema/Schema"
+import type * as Brand from "effect/Brand"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as F from "effect/Function"
+import * as Layer from "effect/Layer"
+import type { Document } from "mongodb"
+import { Db } from "mongodb"
+import type * as Collection from "./Collection.js"
+import * as DocumentCollection from "./DocumentCollection.js"
+import * as MongoClient from "./MongoClient.js"
+import type * as MongoError from "./MongoError.js"
+
+export const documentCollection: {
+  (name: string): (db: Db) => DocumentCollection.DocumentCollection
+  (db: Db, name: string): DocumentCollection.DocumentCollection
+} = F.dual(
+  (args) => isDb(args[0]),
+  (db: Db, name: string): DocumentCollection.DocumentCollection =>
+    new DocumentCollection.DocumentCollection({
+      collection: db.collection(name)
+    })
+)
+
+export const collection: {
+  <A extends Document, I extends Document = A, R = never>(
+    name: string,
+    schema: Schema.Schema<A, I, R>
+  ): (db: Db) => Collection.Collection<A, I, R>
+  <A extends Document, I extends Document = A, R = never>(
+    db: Db,
+    name: string,
+    schema: Schema.Schema<A, I, R>
+  ): Collection.Collection<A, I, R>
+} = F.dual(
+  (args) => isDb(args[0]),
+  <A extends Document, I extends Document = A, R = never>(
+    db: Db,
+    name: string,
+    schema: Schema.Schema<A, I, R>
+  ): Collection.Collection<A, I, R> => DocumentCollection.typed(documentCollection(db, name), schema)
+)
+
+const isDb = (x: unknown) => x instanceof Db
+
+export type DbService<K extends string> = {
+  db: Effect.Effect<Db, MongoError.MongoError>
+} & Brand.Brand<K>
+
+export const Tag = <K extends string>(key: K) => Context.GenericTag<DbService<K>>(key)
+export type TagType<K extends string> = ReturnType<typeof Tag<K>>
+
+export const fromEffect = <DbK extends string, MongoClientK extends string, E = never, R = never>(
+  dbTag: TagType<DbK>,
+  clientTag: MongoClient.TagType<MongoClientK>,
+  dbName: Effect.Effect<string, E, R>
+) =>
+  Layer.effect(
+    dbTag,
+    Effect.gen(function*(_) {
+      const { client } = yield* _(clientTag)
+      const dbName_ = yield* _(dbName)
+      const db = yield* _(
+        client,
+        Effect.map((client) => MongoClient.db(client, dbName_)),
+        Effect.cached
+      )
+      return dbTag.of({ db } as DbService<DbK>) // TODO fix cast using branded ctor
+    })
+  )
+
+export const fromConst = <DbK extends string, MongoClientK extends string>(
+  dbTag: TagType<DbK>,
+  clientTag: MongoClient.TagType<MongoClientK>,
+  dbName: string
+) => fromEffect(dbTag, clientTag, Effect.succeed(dbName))

package/src/DocumentCollection.ts

@@ -0,0 +1,128 @@
+/**
+ * @since 0.0.1
+ */
+import type * as Schema from "@effect/schema/Schema"
+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 {
+  BulkWriteOptions,
+  Collection as MongoCollection,
+  Document,
+  Filter,
+  FindOptions,
+  InsertManyResult,
+  InsertOneOptions,
+  InsertOneResult,
+  OptionalUnlessRequiredId
+} from "mongodb"
+import * as Collection from "./Collection.js"
+import * as DocumentFindCursor from "./DocumentFindCursor.js"
+import * as MongoError from "./MongoError.js"
+
+export class DocumentCollection extends Data.TaggedClass("DocumentCollection")<{
+  collection: MongoCollection
+}> {
+}
+
+export const find: {
+  (options?: FindOptions): (collection: DocumentCollection) => DocumentFindCursor.DocumentFindCursor
+  (
+    collection: DocumentCollection,
+    options?: FindOptions
+  ): DocumentFindCursor.DocumentFindCursor
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (collection: DocumentCollection, options?: FindOptions) =>
+    new DocumentFindCursor.DocumentFindCursor(
+      {
+        cursor: collection.collection.find({}, options)
+      }
+    )
+)
+
+export const findOne: {
+  (
+    filter: Filter<Document>,
+    options?: FindOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    options?: FindOptions
+  ): Effect.Effect<O.Option<Document>, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    options?: FindOptions
+  ): Effect.Effect<O.Option<Document>, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.findOne(filter, options)),
+      Effect.map((value) => O.fromNullable(value)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<O.Option<Document>>("findOne error"))
+    )
+)
+
+export const insertOne: {
+  (
+    doc: OptionalUnlessRequiredId<Document>,
+    options?: InsertOneOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<InsertOneResult, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    doc: OptionalUnlessRequiredId<Document>,
+    options?: InsertOneOptions
+  ): Effect.Effect<InsertOneResult, MongoError.MongoError>
+} = F.dual((args) => isDocumentCollection(args[0]), (
+  collection: DocumentCollection,
+  doc: OptionalUnlessRequiredId<Document>,
+  options?: InsertOneOptions
+): Effect.Effect<InsertOneResult, MongoError.MongoError> =>
+  F.pipe(
+    Effect.promise(() => collection.collection.insertOne(doc, options)),
+    Effect.catchAllDefect(MongoError.mongoErrorDie<InsertOneResult>("insertOne error"))
+  ))
+
+export const insertMany: {
+  (
+    docs: Array<OptionalUnlessRequiredId<Document>>,
+    options?: BulkWriteOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<InsertOneResult, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    docs: Array<OptionalUnlessRequiredId<Document>>,
+    options?: BulkWriteOptions
+  ): Effect.Effect<InsertOneResult, MongoError.MongoError>
+} = F.dual((args) => isDocumentCollection(args[0]), (
+  collection: DocumentCollection,
+  docs: Array<OptionalUnlessRequiredId<Document>>,
+  options?: BulkWriteOptions
+): Effect.Effect<InsertManyResult, MongoError.MongoError> =>
+  F.pipe(
+    Effect.promise(() => collection.collection.insertMany(docs, options)),
+    Effect.catchAllDefect(MongoError.mongoErrorDie<InsertManyResult>("insertMany error"))
+  ))
+
+export const typed: {
+  <A extends Document, I extends Document = A, R = never>(
+    schema: Schema.Schema<A, I, R>
+  ): (collection: DocumentCollection) => Collection.Collection<A, I, R>
+  <A extends Document, I extends Document = A, R = never>(
+    collection: DocumentCollection,
+    schema: Schema.Schema<A, I, R>
+  ): Collection.Collection<A, I, R>
+} = 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 }))
+
+const isDocumentCollection = (x: unknown) => x instanceof DocumentCollection

package/src/DocumentFindCursor.ts

@@ -0,0 +1,90 @@
+/**
+ * @since 0.0.1
+ */
+import type * as Schema from "@effect/schema/Schema"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as F from "effect/Function"
+import * as Stream from "effect/Stream"
+import type { Document, FindCursor as MongoFindCursor, Sort, SortDirection } from "mongodb"
+import * as FindCursor from "./FindCursor.js"
+import * as MongoError from "./MongoError.js"
+
+export class DocumentFindCursor extends Data.TaggedClass("DocumentFindCursor")<{
+  cursor: MongoFindCursor<Document>
+}> {
+}
+
+export const filter: {
+  (
+    filter: Document
+  ): (cursor: DocumentFindCursor) => DocumentFindCursor
+  (cursor: DocumentFindCursor, filter: Document): DocumentFindCursor
+} = F.dual(
+  (args) => isDocumentFindCursor(args[0]),
+  (cursor: DocumentFindCursor, filter: Document): DocumentFindCursor =>
+    new DocumentFindCursor({ cursor: cursor.cursor.filter(filter) })
+)
+
+export const project: {
+  (
+    value: Document
+  ): (cursor: DocumentFindCursor) => DocumentFindCursor
+  (cursor: DocumentFindCursor, value: Document): DocumentFindCursor
+} = F.dual(
+  (args) => isDocumentFindCursor(args[0]),
+  (cursor: DocumentFindCursor, value: Document): DocumentFindCursor =>
+    new DocumentFindCursor({ cursor: cursor.cursor.project(value) })
+)
+
+export const sort: {
+  (
+    sort: Sort | string,
+    direction?: SortDirection
+  ): (cursor: DocumentFindCursor) => DocumentFindCursor
+  (cursor: DocumentFindCursor, sort: Sort | string, direction?: SortDirection): DocumentFindCursor
+} = F.dual(
+  (args) => isDocumentFindCursor(args[0]),
+  (cursor: DocumentFindCursor, sort: Sort | string, direction?: SortDirection): DocumentFindCursor =>
+    new DocumentFindCursor({ cursor: cursor.cursor.sort(sort, direction) })
+)
+
+export const limit: {
+  (
+    value: number
+  ): (cursor: DocumentFindCursor) => DocumentFindCursor
+  (cursor: DocumentFindCursor, value: number): DocumentFindCursor
+} = F.dual(
+  (args) => isDocumentFindCursor(args[0]),
+  (cursor: DocumentFindCursor, value: number): DocumentFindCursor =>
+    new DocumentFindCursor({ cursor: cursor.cursor.limit(value) })
+)
+
+export const toArray = (cursor: DocumentFindCursor): Effect.Effect<ReadonlyArray<Document>, MongoError.MongoError> =>
+  F.pipe(
+    Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }),
+    Effect.catchAll(MongoError.mongoErrorDie<ReadonlyArray<Document>>("toArray error"))
+  )
+
+export const toStream = (
+  cursor: DocumentFindCursor
+): Stream.Stream<Document, MongoError.MongoError> =>
+  F.pipe(
+    Stream.fromAsyncIterable(cursor.cursor, F.identity),
+    Stream.catchAll(MongoError.mongoErrorStream<Document>("Unable to read from mongodb cursor"))
+  )
+
+export const typed: {
+  <A, I = A, R = never>(
+    schema: Schema.Schema<A, I, R>
+  ): (cursor: DocumentFindCursor) => FindCursor.FindCursor<A, I, R>
+  <A, I = A, R = never>(
+    cursor: DocumentFindCursor,
+    schema: Schema.Schema<A, I, R>
+  ): FindCursor.FindCursor<A, I, R>
+} = 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 }))
+
+const isDocumentFindCursor = (x: unknown) => x instanceof DocumentFindCursor

package/src/FindCursor.ts

@@ -0,0 +1,138 @@
+/**
+ * @since 0.0.1
+ */
+import type * as ParseResult from "@effect/schema/ParseResult"
+import * as Schema from "@effect/schema/Schema"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as F from "effect/Function"
+import * as Stream from "effect/Stream"
+import * as Tuple from "effect/Tuple"
+import type { Document, FindCursor as FindCursor_, Sort, SortDirection } from "mongodb"
+import * as MongoError from "./MongoError.js"
+
+import type * as E from "effect/Either"
+
+export class FindCursor<A, I = A, R = never> extends Data.TaggedClass("FindCursor")<{
+  cursor: FindCursor_<unknown>
+  schema: Schema.Schema<A, I, R>
+}> {}
+
+export const filter: {
+  <T extends Document = Document>(
+    filter: T
+  ): <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  <A, I = A, R = never, T extends Document = Document>(
+    cursor: FindCursor<A, I, R>,
+    filter: T
+  ): FindCursor<A, I, R>
+} = F.dual(
+  (args) => isFindCursor(args[0]),
+  <A, I = A, R = never, T extends Document = Document>(
+    cursor: FindCursor<A, I, R>,
+    filter: T
+  ): FindCursor<A, I, R> => new FindCursor({ cursor: cursor.cursor.filter(filter), schema: cursor.schema })
+)
+
+export const project: {
+  <B, BI = B, BR = never, T extends Document = Document>(
+    newSchema: Schema.Schema<B, BI, BR>,
+    value: T
+  ): <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => FindCursor<B, BI, BR>
+  <A, B, I = A, R = never, BI = B, BR = never, T extends Document = Document>(
+    cursor: FindCursor<A, I, R>,
+    newSchema: Schema.Schema<B, BI, BR>,
+    value: T
+  ): FindCursor<B, BI, BR>
+} = F.dual(
+  (args) => isFindCursor(args[0]),
+  <A, B, I = A, R = never, BI = B, BR = never, T extends Document = Document>(
+    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 })
+)
+
+export const sort: {
+  (
+    sort: Sort | string,
+    direction?: SortDirection
+  ): <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  <A, I = A, R = never>(
+    cursor: FindCursor<A, I, R>,
+    sort: Sort | string,
+    direction?: SortDirection
+  ): FindCursor<A, I, R>
+} = F.dual(
+  (args) => isFindCursor(args[0]),
+  <A, I = A, R = never>(
+    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 })
+)
+
+export const limit: {
+  (
+    value: number
+  ): <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  <A, I = A, R = never>(cursor: FindCursor<A, I, R>, value: number): FindCursor<A, I, R>
+} = F.dual(
+  (args) => isFindCursor(args[0]),
+  <A, I = A, R = never>(cursor: FindCursor<A, I, R>, value: number): FindCursor<A, I, R> =>
+    new FindCursor({ cursor: cursor.cursor.limit(value), schema: cursor.schema })
+)
+
+export const toArray = <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => {
+  const decode = Schema.decodeUnknown(cursor.schema)
+  return Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }).pipe(
+    Effect.catchAll(MongoError.mongoErrorDie<ReadonlyArray<A>>("Unable to get array from mongodb cursor")),
+    Effect.flatMap(Effect.forEach((x) => decode(x)))
+  )
+}
+
+export const toArrayEither = <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => {
+  const decode = Schema.decodeUnknown(cursor.schema)
+  return Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }).pipe(
+    Effect.catchAll(MongoError.mongoErrorDie<ReadonlyArray<A>>("Unable to get array from mongodb cursor")),
+    Effect.flatMap(Effect.forEach((x) =>
+      F.pipe(
+        // keep new line
+        decode(x),
+        Effect.mapError((error) => Tuple.make(x, error)),
+        Effect.either
+      )
+    ))
+  )
+}
+
+export const toStream = <A, I = A, R = never>(
+  cursor: FindCursor<A, I, R>
+): Stream.Stream<A, MongoError.MongoError | ParseResult.ParseError, 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.mapEffect((x) => decode(x))
+  )
+}
+
+export const toStreamEither = <A, I = A, R = never>(
+  cursor: FindCursor<A, I, R>
+): Stream.Stream<E.Either<A, [document: unknown, error: ParseResult.ParseError]>, MongoError.MongoError, 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.mapEffect((x) =>
+      F.pipe(
+        // keep new line
+        decode(x),
+        Effect.mapError((error) => Tuple.make(x, error)),
+        Effect.either
+      )
+    )
+  )
+}
+
+const isFindCursor = (x: unknown): x is FindCursor<unknown> => x instanceof FindCursor