effect-mongodb 0.0.2 → 0.0.4

package/src/Db.ts

@@ -1,18 +1,19 @@
 /**
  * @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 type * as Schema from "effect/Schema"
+import type { Document, DropCollectionOptions, ListCollectionsOptions } from "mongodb"
 import { Db } from "mongodb"
 import type * as Collection from "./Collection.js"
 import * as DocumentCollection from "./DocumentCollection.js"
+import * as ListCollectionsCursor from "./ListCollectionsCursor.js"
 import * as MongoClient from "./MongoClient.js"
-import type * as MongoError from "./MongoError.js"
+import * as MongoError from "./MongoError.js"
 
 export const documentCollection: {
   (name: string): (db: Db) => DocumentCollection.DocumentCollection
@@ -44,6 +45,49 @@ export const collection: {
   ): Collection.Collection<A, I, R> => DocumentCollection.typed(documentCollection(db, name), schema)
 )
 
+export const listCollections: {
+  (): (db: Db) => ListCollectionsCursor.ListCollectionsCursor
+  (filter: Document): (db: Db) => ListCollectionsCursor.ListCollectionsCursor
+  (
+    filter: Document,
+    options: Exclude<ListCollectionsOptions, "nameOnly"> & { nameOnly: true }
+  ): (db: Db) => ListCollectionsCursor.NameOnlyListCollectionsCursor
+  (
+    filter: Document,
+    options: Exclude<ListCollectionsOptions, "nameOnly"> & { nameOnly: false }
+  ): (db: Db) => ListCollectionsCursor.FullListCollectionsCursor
+  (db: Db): ListCollectionsCursor.ListCollectionsCursor
+  (db: Db, filter: Document): ListCollectionsCursor.ListCollectionsCursor
+  (
+    db: Db,
+    filter: Document,
+    options: Exclude<ListCollectionsOptions, "nameOnly"> & { nameOnly: true }
+  ): ListCollectionsCursor.NameOnlyListCollectionsCursor
+  (
+    db: Db,
+    filter: Document,
+    options: Exclude<ListCollectionsOptions, "nameOnly"> & { nameOnly: false }
+  ): ListCollectionsCursor.FullListCollectionsCursor
+} = F.dual(
+  (args) => isDb(args[0]),
+  (db: Db, filter?: Document, options?: ListCollectionsOptions): ListCollectionsCursor.ListCollectionsCursor =>
+    new ListCollectionsCursor.ListCollectionsCursor({ cursor: db.listCollections(filter, options) })
+)
+
+export const dropCollection: {
+  (name: string): (db: Db) => Effect.Effect<boolean>
+  (name: string, options: DropCollectionOptions): (db: Db) => Effect.Effect<boolean, MongoError.MongoError>
+  (db: Db, name: string): Effect.Effect<boolean, MongoError.MongoError>
+  (db: Db, name: string, options: DropCollectionOptions): Effect.Effect<boolean, MongoError.MongoError>
+} = F.dual(
+  (args) => isDb(args[0]),
+  (db: Db, name: string, options?: DropCollectionOptions): Effect.Effect<boolean, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => db.dropCollection(name, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<boolean>("dropCollection error"))
+    )
+)
+
 const isDb = (x: unknown) => x instanceof Db
 
 export type DbService<K extends string> = {

package/src/DocumentAggregationCursor.ts

@@ -0,0 +1,30 @@
+/**
+ * @since 0.0.1
+ */
+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 { AggregationCursor as MongoAggregationCursor } from "mongodb"
+import * as MongoError from "./MongoError.js"
+
+export class DocumentAggregationCursor
+  extends Data.TaggedClass("DocumentAggregationCursor")<{ cursor: MongoAggregationCursor<Document> }>
+{
+}
+
+export const toArray = (
+  cursor: DocumentAggregationCursor
+): Effect.Effect<ReadonlyArray<Document>, MongoError.MongoError> =>
+  F.pipe(
+    Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }),
+    Effect.catchAll(MongoError.mongoErrorDie<ReadonlyArray<Document>>(`${cursor._tag}.toArray error`))
+  )
+
+export const toStream = (
+  cursor: DocumentAggregationCursor
+): Stream.Stream<Document, MongoError.MongoError> =>
+  F.pipe(
+    Stream.fromAsyncIterable(cursor.cursor, F.identity),
+    Stream.catchAll(MongoError.mongoErrorStream<Document>(`${cursor._tag}.toStream error`))
+  )

package/src/DocumentCollection.ts

@@ -1,24 +1,42 @@
 /**
  * @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 * as Schema from "effect/Schema"
 import type {
+  AggregateOptions,
   BulkWriteOptions,
   Collection as MongoCollection,
+  CreateIndexesOptions,
+  DeleteOptions,
+  DeleteResult,
   Document,
+  DropCollectionOptions,
+  DropIndexesOptions,
   Filter,
+  FindOneAndReplaceOptions,
   FindOptions,
+  IndexDescription,
+  IndexSpecification,
   InsertManyResult,
   InsertOneOptions,
   InsertOneResult,
-  OptionalUnlessRequiredId
+  ModifyResult as MongoModifyResult,
+  OptionalUnlessRequiredId,
+  RenameOptions,
+  ReplaceOptions,
+  UpdateFilter,
+  UpdateOptions,
+  UpdateResult,
+  WithoutId
 } from "mongodb"
 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 * as MongoError from "./MongoError.js"
 
 export class DocumentCollection extends Data.TaggedClass("DocumentCollection")<{
@@ -27,17 +45,21 @@ export class DocumentCollection extends Data.TaggedClass("DocumentCollection")<{
 }
 
 export const find: {
-  (options?: FindOptions): (collection: DocumentCollection) => DocumentFindCursor.DocumentFindCursor
+  (
+    filter?: Filter<Document>,
+    options?: FindOptions
+  ): (collection: DocumentCollection) => DocumentFindCursor.DocumentFindCursor
   (
     collection: DocumentCollection,
+    filter?: Filter<Document>,
     options?: FindOptions
   ): DocumentFindCursor.DocumentFindCursor
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
-  (collection: DocumentCollection, options?: FindOptions) =>
+  (collection: DocumentCollection, filter?: Filter<Document>, options?: FindOptions) =>
     new DocumentFindCursor.DocumentFindCursor(
       {
-        cursor: collection.collection.find({}, options)
+        cursor: collection.collection.find(filter ?? {}, options)
       }
     )
 )
@@ -112,6 +134,321 @@ export const insertMany: {
     Effect.catchAllDefect(MongoError.mongoErrorDie<InsertManyResult>("insertMany error"))
   ))
 
+export const deleteOne: {
+  (
+    filter: Filter<Document>,
+    options?: DeleteOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<DeleteResult, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    options?: DeleteOptions
+  ): Effect.Effect<DeleteResult, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    options?: DeleteOptions
+  ): Effect.Effect<DeleteResult, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.deleteOne(filter, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<DeleteResult>("deleteOne error"))
+    )
+)
+
+export const deleteMany: {
+  (
+    filter: Filter<Document>,
+    options?: DeleteOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<DeleteResult, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    options?: DeleteOptions
+  ): Effect.Effect<DeleteResult, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    options?: DeleteOptions
+  ): Effect.Effect<DeleteResult, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.deleteMany(filter, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<DeleteResult>("deleteMany error"))
+    )
+)
+
+export const updateMany: {
+  (
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | Array<Document>,
+    options?: UpdateOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<UpdateResult, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | Array<Document>,
+    options?: UpdateOptions
+  ): Effect.Effect<UpdateResult, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    update: UpdateFilter<Document> | Array<Document>,
+    options?: UpdateOptions
+  ): Effect.Effect<UpdateResult, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.updateMany(filter, update, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<UpdateResult>("updateMany error"))
+    )
+)
+
+export const replaceOne: {
+  (
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options?: ReplaceOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<UpdateResult | Document, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options?: ReplaceOptions
+  ): Effect.Effect<UpdateResult | Document, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options?: ReplaceOptions
+  ): Effect.Effect<UpdateResult | Document, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.replaceOne(filter, replacement, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<UpdateResult | Document>("replaceOne error"))
+    )
+)
+
+export const findOneAndReplace: {
+  (
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: true }
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<ModifyResult<Document>, MongoError.MongoError>
+  (
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: false }
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options: FindOneAndReplaceOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: true }
+  ): Effect.Effect<ModifyResult<Document>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: false }
+  ): Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options: FindOneAndReplaceOptions
+  ): Effect.Effect<O.Option<Document>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>
+  ): Effect.Effect<O.Option<Document>, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    filter: Filter<Document>,
+    replacement: WithoutId<Document>,
+    options?: FindOneAndReplaceOptions
+  ): Effect.Effect<O.Option<Document> | ModifyResult<Document>, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.findOneAndReplace(filter, replacement, 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)
+      }),
+      Effect.catchAllDefect(
+        MongoError.mongoErrorDie<O.Option<Document> | ModifyResult<Document>>("findOneAndReplace error")
+      )
+    )
+)
+
+export const rename: {
+  (
+    newName: string,
+    options?: RenameOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<MongoCollection, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    newName: string,
+    options?: RenameOptions
+  ): Effect.Effect<MongoCollection, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    newName: string,
+    options?: RenameOptions
+  ): Effect.Effect<MongoCollection, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.rename(newName, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<MongoCollection>("rename error"))
+    )
+)
+
+export const drop: {
+  (options?: DropCollectionOptions): (collection: DocumentCollection) => Effect.Effect<boolean, MongoError.MongoError>
+  (collection: DocumentCollection, options?: DropCollectionOptions): Effect.Effect<boolean, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    options?: DropCollectionOptions
+  ): Effect.Effect<boolean, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.drop(options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<boolean>("drop error"))
+    )
+)
+
+export const createIndexes: {
+  (
+    indexSpecs: Array<IndexDescription>,
+    options?: CreateIndexesOptions
+  ): (
+    collection: DocumentCollection
+  ) => Effect.Effect<Array<string>, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    indexSpecs: Array<IndexDescription>,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<Array<string>, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    indexSpecs: Array<IndexDescription>,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<Array<string>, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.createIndexes(indexSpecs, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<Array<string>>("createIndexes error"))
+    )
+)
+
+export const createIndex: {
+  (
+    indexSpec: IndexSpecification,
+    options?: CreateIndexesOptions
+  ): (collection: DocumentCollection) => Effect.Effect<string, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    indexSpec: IndexSpecification,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<string, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    indexSpec: IndexSpecification,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<string, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.createIndex(indexSpec, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<string>("createIndex error"))
+    )
+)
+
+export const dropIndex: {
+  (
+    indexName: string,
+    options?: DropIndexesOptions
+  ): (collection: DocumentCollection) => Effect.Effect<Document, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    indexName: string,
+    options?: DropIndexesOptions
+  ): Effect.Effect<Document, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    indexName: string,
+    options?: DropIndexesOptions
+  ): Effect.Effect<Document, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.dropIndex(indexName, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<Document>("dropIndex error"))
+    )
+)
+
+export const aggregate: {
+  (
+    pipeline?: Array<Document>,
+    options?: AggregateOptions
+  ): (
+    collection: DocumentCollection
+  ) => DocumentAggregationCursor.DocumentAggregationCursor
+  (
+    collection: DocumentCollection,
+    pipeline?: Array<Document>,
+    options?: AggregateOptions
+  ): DocumentAggregationCursor.DocumentAggregationCursor
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    pipeline?: Array<Document>,
+    options?: AggregateOptions
+  ): DocumentAggregationCursor.DocumentAggregationCursor =>
+    new DocumentAggregationCursor.DocumentAggregationCursor({
+      cursor: collection.collection.aggregate(pipeline, options)
+    })
+)
+
 export const typed: {
   <A extends Document, I extends Document = A, R = never>(
     schema: Schema.Schema<A, I, R>

package/src/DocumentFindCursor.ts

@@ -1,12 +1,12 @@
 /**
  * @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 type * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
-import type { Document, FindCursor as MongoFindCursor, Sort, SortDirection } from "mongodb"
+import type { Document, Filter, FindCursor as MongoFindCursor, Sort, SortDirection } from "mongodb"
 import * as FindCursor from "./FindCursor.js"
 import * as MongoError from "./MongoError.js"
 
@@ -17,12 +17,12 @@ export class DocumentFindCursor extends Data.TaggedClass("DocumentFindCursor")<{
 
 export const filter: {
   (
-    filter: Document
+    filter: Filter<Document>
   ): (cursor: DocumentFindCursor) => DocumentFindCursor
-  (cursor: DocumentFindCursor, filter: Document): DocumentFindCursor
+  (cursor: DocumentFindCursor, filter: Filter<Document>): DocumentFindCursor
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
-  (cursor: DocumentFindCursor, filter: Document): DocumentFindCursor =>
+  (cursor: DocumentFindCursor, filter: Filter<Document>): DocumentFindCursor =>
     new DocumentFindCursor({ cursor: cursor.cursor.filter(filter) })
 )
 

package/src/FindCursor.ts

@@ -1,52 +1,53 @@
 /**
  * @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 type * as E from "effect/Either"
 import * as F from "effect/Function"
+import type * as ParseResult from "effect/ParseResult"
+import * as Schema from "effect/Schema"
 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 * 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>(
+  <I extends Document>(
+    filter: Filter<I>
+  ): <A, R>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  <A, I extends Document, R>(
     cursor: FindCursor<A, I, R>,
-    filter: T
+    filter: Filter<I>
   ): FindCursor<A, I, R>
 } = F.dual(
   (args) => isFindCursor(args[0]),
-  <A, I = A, R = never, T extends Document = Document>(
+  <A, I extends Document, R>(
     cursor: FindCursor<A, I, R>,
-    filter: T
+    filter: Filter<I>
   ): 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>(
+  <B, BI, BR, 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>(
+  ): <A, I, R>(cursor: FindCursor<A, I, R>) => FindCursor<B, BI, BR>
+  <A, B, I, R, BI, BR, 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>(
+  <A, B, I, R, BI, BR, T extends Document = Document>(
     cursor: FindCursor<A, I, R>,
     newSchema: Schema.Schema<B, BI, BR>,
     value: T
@@ -57,15 +58,15 @@ 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>(
+  ): <A, I, R>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  <A, I, R>(
     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>(
+  <A, I, R>(
     cursor: FindCursor<A, I, R>,
     sort: Sort | string,
     direction?: SortDirection
@@ -75,15 +76,17 @@ export const sort: {
 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>
+  ): <A, I, R>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  <A, I, R>(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> =>
+  <A, I, R>(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>) => {
+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<ReadonlyArray<A>>("Unable to get array from mongodb cursor")),
@@ -91,13 +94,14 @@ export const toArray = <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => {
   )
 }
 
-export const toArrayEither = <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => {
+export const toArrayEither = <A, I, R>(
+  cursor: FindCursor<A, I, R>
+): Effect.Effect<Array<E.Either<A, [document: unknown, error: ParseResult.ParseError]>>, MongoError.MongoError, 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
@@ -106,7 +110,7 @@ export const toArrayEither = <A, I = A, R = never>(cursor: FindCursor<A, I, R>)
   )
 }
 
-export const toStream = <A, I = A, R = never>(
+export const toStream = <A, I, R>(
   cursor: FindCursor<A, I, R>
 ): Stream.Stream<A, MongoError.MongoError | ParseResult.ParseError, R> => {
   const decode = Schema.decodeUnknown(cursor.schema)
@@ -117,7 +121,7 @@ export const toStream = <A, I = A, R = never>(
   )
 }
 
-export const toStreamEither = <A, I = A, R = never>(
+export const toStreamEither = <A, I, R>(
   cursor: FindCursor<A, I, R>
 ): Stream.Stream<E.Either<A, [document: unknown, error: ParseResult.ParseError]>, MongoError.MongoError, R> => {
   const decode = Schema.decodeUnknown(cursor.schema)