effect-mongodb 0.1.0 → 0.1.2

package/dist/esm/ListCollectionsCursor.js.map

@@ -1 +1 @@
-{"version":3,"file":"ListCollectionsCursor.js","names":["Data","Effect","F","Stream","MongoError","ListCollectionsCursor","TaggedClass","toArray","cursor","pipe","tryPromise","try","catch","identity","catchAll","mongoErrorDie","_tag","toStream","fromAsyncIterable","mongoErrorStream"],"sources":["../../src/ListCollectionsCursor.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,IAAI,MAAM,aAAa;AACnC,OAAO,KAAKC,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,CAAC,MAAM,iBAAiB;AACpC,OAAO,KAAKC,MAAM,MAAM,eAAe;AAKvC,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAO7C,OAAM,MAAOC,qBAEX,sBAAQL,IAAI,CAACM,WAAW,CAAC,uBAAuB,CAEhD;AAQF,OAAO,MAAMC,OAAO,GAClBC,MAAgC,IAEhCN,CAAC,CAACO,IAAI,CACJR,MAAM,CAACS,UAAU,CAAC;EAAEC,GAAG,EAAEA,CAAA,KAAMH,MAAM,CAACA,MAAM,CAACD,OAAO,EAAE;EAAEK,KAAK,EAAEV,CAAC,CAACW;AAAQ,CAAE,CAAC,EAC5EZ,MAAM,CAACa,QAAQ,CAACV,UAAU,CAACW,aAAa,CAAmB,GAAGP,MAAM,CAACQ,IAAI,gBAAgB,CAAC,CAAC,CAC5F;AAEH,OAAO,MAAMC,QAAQ,GACnBT,MAAgC,IAEhCN,CAAC,CAACO,IAAI,CACJN,MAAM,CAACe,iBAAiB,CAACV,MAAM,CAACA,MAAM,EAAEN,CAAC,CAACW,QAAQ,CAAC,EACnDV,MAAM,CAACW,QAAQ,CAACV,UAAU,CAACe,gBAAgB,CAAI,GAAGX,MAAM,CAACQ,IAAI,iBAAiB,CAAC,CAAC,CACjF","ignoreList":[]}
+{"version":3,"file":"ListCollectionsCursor.js","names":["Data","Effect","F","Stream","MongoError","ListCollectionsCursor","TaggedClass","toArray","cursor","pipe","tryPromise","try","catch","identity","catchAll","mongoErrorDie","_tag","toStream","fromAsyncIterable","mongoErrorStream"],"sources":["../../src/ListCollectionsCursor.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,IAAI,MAAM,aAAa;AACnC,OAAO,KAAKC,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,CAAC,MAAM,iBAAiB;AACpC,OAAO,KAAKC,MAAM,MAAM,eAAe;AAKvC,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAO7C,OAAM,MAAOC,qBAEX,sBAAQL,IAAI,CAACM,WAAW,CAAC,uBAAuB,CAEhD;AAQF,OAAO,MAAMC,OAAO,GAClBC,MAAgC,IAEhCN,CAAC,CAACO,IAAI,CACJR,MAAM,CAACS,UAAU,CAAC;EAAEC,GAAG,EAAEA,CAAA,KAAMH,MAAM,CAACA,MAAM,CAACD,OAAO,EAAE;EAAEK,KAAK,EAAEV,CAAC,CAACW;AAAQ,CAAE,CAAC,EAC5EZ,MAAM,CAACa,QAAQ,CAACV,UAAU,CAACW,aAAa,CAAW,GAAGP,MAAM,CAACQ,IAAI,gBAAgB,CAAC,CAAC,CACpF;AAEH,OAAO,MAAMC,QAAQ,GACnBT,MAAgC,IAEhCN,CAAC,CAACO,IAAI,CACJN,MAAM,CAACe,iBAAiB,CAACV,MAAM,CAACA,MAAM,EAAEN,CAAC,CAACW,QAAQ,CAAC,EACnDV,MAAM,CAACW,QAAQ,CAACV,UAAU,CAACe,gBAAgB,CAAI,GAAGX,MAAM,CAACQ,IAAI,iBAAiB,CAAC,CAAC,CACjF","ignoreList":[]}

package/dist/esm/MongoClient.js

@@ -6,6 +6,8 @@ import * as F from "effect/Function";
 import { MongoClient as MongoClient_ } from "mongodb";
 import * as MongoError from "./MongoError.js";
 export const connect = (url, options) => Effect.promise(() => MongoClient_.connect(url, options)).pipe(Effect.catchAll(MongoError.mongoErrorDie("connect error")));
+export const close = /*#__PURE__*/F.dual(args => isMongoClient(args[0]), (client, force) => Effect.promise(() => client.close(force)).pipe(Effect.catchAll(MongoError.mongoErrorDie("close error"))));
+export const connectScoped = (url, options) => Effect.acquireRelease(connect(url, options), client => close(client, options?.forceClose).pipe(Effect.orDie));
 export const db = /*#__PURE__*/F.dual(args => isMongoClient(args[0]), (client, dbName, options) => client.db(dbName, options));
 const isMongoClient = x => x instanceof MongoClient_;
 //# sourceMappingURL=MongoClient.js.map

package/dist/esm/MongoClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"MongoClient.js","names":["Effect","F","MongoClient","MongoClient_","MongoError","connect","url","options","promise","pipe","catchAll","mongoErrorDie","db","dual","args","isMongoClient","client","dbName","x"],"sources":["../../src/MongoClient.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,CAAC,MAAM,iBAAiB;AAEpC,SAASC,WAAW,IAAIC,YAAY,QAAQ,SAAS;AACrD,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAI7C,OAAO,MAAMC,OAAO,GAAGA,CACrBC,GAAW,EACXC,OAA4B,KAE5BP,MAAM,CAACQ,OAAO,CAAC,MAAML,YAAY,CAACE,OAAO,CAACC,GAAG,EAAEC,OAAO,CAAC,CAAC,CAACE,IAAI,CAC3DT,MAAM,CAACU,QAAQ,CAACN,UAAU,CAACO,aAAa,CAAe,eAAe,CAAC,CAAC,CACzE;AAEH,OAAO,MAAMC,EAAE,gBAGXX,CAAC,CAACY,IAAI,CACPC,IAAI,IAAKC,aAAa,CAACD,IAAI,CAAC,CAAC,CAAC,CAAC,EAChC,CAACE,MAAmB,EAAEC,MAAe,EAAEV,OAAmB,KAASS,MAAM,CAACJ,EAAE,CAACK,MAAM,EAAEV,OAAO,CAAC,CAC9F;AAED,MAAMQ,aAAa,GAAIG,CAAU,IAAKA,CAAC,YAAYf,YAAY","ignoreList":[]}
+{"version":3,"file":"MongoClient.js","names":["Effect","F","MongoClient","MongoClient_","MongoError","connect","url","options","promise","pipe","catchAll","mongoErrorDie","close","dual","args","isMongoClient","client","force","connectScoped","acquireRelease","forceClose","orDie","db","dbName","x"],"sources":["../../src/MongoClient.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,CAAC,MAAM,iBAAiB;AAGpC,SAASC,WAAW,IAAIC,YAAY,QAAQ,SAAS;AACrD,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAI7C,OAAO,MAAMC,OAAO,GAAGA,CACrBC,GAAW,EACXC,OAA4B,KAE5BP,MAAM,CAACQ,OAAO,CAAC,MAAML,YAAY,CAACE,OAAO,CAACC,GAAG,EAAEC,OAAO,CAAC,CAAC,CAACE,IAAI,CAC3DT,MAAM,CAACU,QAAQ,CAACN,UAAU,CAACO,aAAa,CAAe,eAAe,CAAC,CAAC,CACzE;AAEH,OAAO,MAAMC,KAAK,gBAGdX,CAAC,CAACY,IAAI,CACPC,IAAI,IAAKC,aAAa,CAACD,IAAI,CAAC,CAAC,CAAC,CAAC,EAChC,CAACE,MAAmB,EAAEC,KAAe,KACnCjB,MAAM,CAACQ,OAAO,CAAC,MAAMQ,MAAM,CAACJ,KAAK,CAACK,KAAK,CAAC,CAAC,CAACR,IAAI,CAC5CT,MAAM,CAACU,QAAQ,CAACN,UAAU,CAACO,aAAa,CAAO,aAAa,CAAC,CAAC,CAC/D,CACJ;AAED,OAAO,MAAMO,aAAa,GAAGA,CAC3BZ,GAAW,EACXC,OAAuD,KAEvDP,MAAM,CAACmB,cAAc,CACnBd,OAAO,CAACC,GAAG,EAAEC,OAAO,CAAC,EACpBS,MAAM,IAAKJ,KAAK,CAACI,MAAM,EAAET,OAAO,EAAEa,UAAU,CAAC,CAACX,IAAI,CAACT,MAAM,CAACqB,KAAK,CAAC,CAClE;AAEH,OAAO,MAAMC,EAAE,gBAGXrB,CAAC,CAACY,IAAI,CACPC,IAAI,IAAKC,aAAa,CAACD,IAAI,CAAC,CAAC,CAAC,CAAC,EAChC,CAACE,MAAmB,EAAEO,MAAe,EAAEhB,OAAmB,KAASS,MAAM,CAACM,EAAE,CAACC,MAAM,EAAEhB,OAAO,CAAC,CAC9F;AAED,MAAMQ,aAAa,GAAIS,CAAU,IAAKA,CAAC,YAAYrB,YAAY","ignoreList":[]}

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "0.1.0";
+let moduleVersion = "0.1.2";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-mongodb",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A MongoDB toolkit for Effect",
   "license": "MIT",
   "repository": {

package/src/AggregationCursor.ts

@@ -17,10 +17,10 @@ export class AggregationCursor<A, I = A, R = never> extends Data.TaggedClass("Ag
 
 export const toArray = <A, I, R>(
   cursor: AggregationCursor<A, I, R>
-): Effect.Effect<ReadonlyArray<A>, MongoError.MongoError | ParseResult.ParseError, 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 aggregate cursor")),
+    Effect.catchAll(MongoError.mongoErrorDie<Array<A>>("Unable to get array from mongodb aggregate cursor")),
     Effect.flatMap(Effect.forEach((x) => decode(x)))
   )
 }

package/src/Collection.ts

@@ -1,6 +1,7 @@
 /**
  * @since 0.0.1
  */
+import * as Array from "effect/Array"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
@@ -44,6 +45,7 @@ export class Collection<A extends Document, I extends Document = A, R = never> e
   collection: MongoCollection
   schema: Schema.Schema<A, I, R>
 }> {
+  readonly encode = Schema.encode(this.schema)
 }
 
 export type FindOptions = Omit<MongoFindOptions, "projection">
@@ -110,29 +112,28 @@ export const insertOne: {
   options?: InsertOneOptions
 ): Effect.Effect<InsertOneResult, MongoError.MongoError | ParseResult.ParseError, R> =>
   F.pipe(
-    Schema.encode(collection.schema)(doc),
+    collection.encode(doc),
     Effect.flatMap((doc) => Effect.promise(() => collection.collection.insertOne(doc, options))),
     Effect.catchAllDefect(MongoError.mongoErrorDie<InsertOneResult>("insertOne error"))
   ))
 
 export const insertMany: {
-  <A extends Document>(docs: Array<A>, options?: BulkWriteOptions): <I extends Document, R>(
+  <A extends Document>(docs: ReadonlyArray<A>, options?: BulkWriteOptions): <I extends Document, R>(
     collection: Collection<A, I, R>
   ) => Effect.Effect<InsertManyResult, MongoError.MongoError | ParseResult.ParseError, R>
   <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
-    docs: Array<A>,
+    docs: ReadonlyArray<A>,
     options?: BulkWriteOptions
   ): Effect.Effect<InsertManyResult, MongoError.MongoError | ParseResult.ParseError, R>
 } = F.dual((args) => isCollection(args[0]), <A extends Document, I extends Document, R>(
   collection: Collection<A, I, R>,
-  docs: Array<A>,
+  docs: ReadonlyArray<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.forEach((doc) => collection.encode(doc)),
     Effect.flatMap((docs) => Effect.promise(() => collection.collection.insertMany(docs, options))),
     Effect.catchAllDefect(MongoError.mongoErrorDie<InsertManyResult>("insertMany error"))
   )
@@ -183,7 +184,7 @@ export const deleteMany: {
 export const updateMany: {
   <I extends Document>(
     filter: Filter<I>,
-    update: UpdateFilter<I> | Array<Document>,
+    update: UpdateFilter<I> | ReadonlyArray<Document>,
     options?: UpdateOptions
   ): <A extends Document, R>(
     collection: Collection<A, I, R>
@@ -191,7 +192,7 @@ export const updateMany: {
   <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
     filter: Filter<I>,
-    update: UpdateFilter<I> | Array<Document>,
+    update: UpdateFilter<I> | ReadonlyArray<Document>,
     options?: UpdateOptions
   ): Effect.Effect<UpdateResult, MongoError.MongoError, R>
 } = F.dual(
@@ -199,14 +200,16 @@ export const updateMany: {
   <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
     filter: Filter<I>,
-    update: UpdateFilter<I> | Array<Document>,
+    update: UpdateFilter<I> | ReadonlyArray<Document>,
     options?: UpdateOptions
   ): Effect.Effect<UpdateResult, MongoError.MongoError, R> =>
     Effect.promise(() =>
-      collection.collection.updateMany(filter, update as UpdateFilter<Document> | Array<Document>, options)
-    ).pipe(
-      Effect.catchAllDefect(MongoError.mongoErrorDie<UpdateResult>("updateMany error"))
-    )
+      collection.collection.updateMany(
+        filter,
+        Array.isArray(update) ? [...update] : update as UpdateFilter<Document>,
+        options
+      )
+    ).pipe(Effect.catchAllDefect(MongoError.mongoErrorDie<UpdateResult>("updateMany error")))
 )
 
 export const replaceOne: {
@@ -237,8 +240,7 @@ export const replaceOne: {
     R
   > =>
     F.pipe(
-      // TODO: extract function in Collection
-      Schema.encode(collection.schema)(replacement),
+      collection.encode(replacement),
       Effect.flatMap((replacement) =>
         Effect.promise(() => collection.collection.replaceOne(filter, replacement, options))
       ),
@@ -299,8 +301,7 @@ export const findOneAndReplace: {
     options?: FindOneAndReplaceOptions
   ): Effect.Effect<O.Option<A> | ModifyResult<A>, MongoError.MongoError | ParseResult.ParseError, R> =>
     F.pipe(
-      // TODO: extract function in Collection
-      Schema.encode(collection.schema)(replacement),
+      collection.encode(replacement),
       Effect.flatMap((replacement) =>
         Effect.promise(() => collection.collection.findOneAndReplace(filter, replacement, options ?? {}))
       ),
@@ -364,23 +365,26 @@ export const drop: {
 )
 
 export const createIndexes: {
-  (indexSpecs: Array<IndexDescription>, options?: CreateIndexesOptions): <A extends Document, I extends Document, R>(
+  (
+    indexSpecs: ReadonlyArray<IndexDescription>,
+    options?: CreateIndexesOptions
+  ): <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>
   ) => Effect.Effect<Array<string>, MongoError.MongoError, R>
   <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
-    indexSpecs: Array<IndexDescription>,
+    indexSpecs: ReadonlyArray<IndexDescription>,
     options?: CreateIndexesOptions
   ): Effect.Effect<Array<string>, MongoError.MongoError, R>
 } = F.dual(
   (args) => isCollection(args[0]),
   <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
-    indexSpecs: Array<IndexDescription>,
+    indexSpecs: ReadonlyArray<IndexDescription>,
     options?: CreateIndexesOptions
   ): Effect.Effect<Array<string>, MongoError.MongoError, R> =>
     F.pipe(
-      Effect.promise(() => collection.collection.createIndexes(indexSpecs, options)),
+      Effect.promise(() => collection.collection.createIndexes([...indexSpecs], options)),
       Effect.catchAllDefect(MongoError.mongoErrorDie<Array<string>>("createIndexes error"))
     )
 )
@@ -433,7 +437,7 @@ export const dropIndex: {
 
 export const aggregate: {
   <B extends Document, BI extends Document, BR>(
-    pipeline: Array<Document>,
+    pipeline: ReadonlyArray<Document>,
     schema: Schema.Schema<B, BI, BR>,
     options?: AggregateOptions
   ): <A extends Document, I extends Document, R>(
@@ -441,7 +445,7 @@ export const aggregate: {
   ) => AggregationCursor.AggregationCursor<B, BI, BR>
   <A extends Document, I extends Document, R, B extends Document, BI extends Document, BR>(
     collection: Collection<A, I, R>,
-    pipeline: Array<Document>,
+    pipeline: ReadonlyArray<Document>,
     schema: Schema.Schema<B, BI, BR>,
     options?: AggregateOptions
   ): AggregationCursor.AggregationCursor<B, BI, BR>
@@ -449,12 +453,12 @@ export const aggregate: {
   (args) => isCollection(args[0]),
   <A extends Document, I extends Document, R, B extends Document, BI extends Document, BR>(
     collection: Collection<A, I, R>,
-    pipeline: Array<Document>,
+    pipeline: ReadonlyArray<Document>,
     schema: Schema.Schema<B, BI, BR>,
     options?: AggregateOptions
   ): AggregationCursor.AggregationCursor<B, BI, BR> =>
     new AggregationCursor.AggregationCursor<B, BI, BR>({
-      cursor: collection.collection.aggregate(pipeline, options),
+      cursor: collection.collection.aggregate([...pipeline], options),
       schema
     })
 )

package/src/DocumentAggregationCursor.ts

@@ -5,7 +5,7 @@ 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 type { AggregationCursor as MongoAggregationCursor, Document } from "mongodb"
 import * as MongoError from "./MongoError.js"
 
 export class DocumentAggregationCursor
@@ -15,10 +15,10 @@ export class DocumentAggregationCursor
 
 export const toArray = (
   cursor: DocumentAggregationCursor
-): Effect.Effect<ReadonlyArray<Document>, MongoError.MongoError> =>
+): Effect.Effect<Array<Document>, MongoError.MongoError> =>
   F.pipe(
     Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }),
-    Effect.catchAll(MongoError.mongoErrorDie<ReadonlyArray<Document>>(`${cursor._tag}.toArray error`))
+    Effect.catchAll(MongoError.mongoErrorDie<Array<Document>>(`${cursor._tag}.toArray error`))
   )
 
 export const toStream = (

package/src/DocumentCollection.ts

@@ -1,6 +1,7 @@
 /**
  * @since 0.0.1
  */
+import * as Array from "effect/Array"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
@@ -90,6 +91,10 @@ export const findOne: {
 )
 
 export const insertOne: {
+  (
+    collection: DocumentCollection,
+    doc: OptionalUnlessRequiredId<Document>
+  ): Effect.Effect<InsertOneResult, MongoError.MongoError>
   (doc: OptionalUnlessRequiredId<Document>, options?: InsertOneOptions): (
     collection: DocumentCollection
   ) => Effect.Effect<InsertOneResult, MongoError.MongoError>
@@ -110,19 +115,19 @@ export const insertOne: {
 
 export const insertMany: {
   (
-    docs: Array<OptionalUnlessRequiredId<Document>>,
+    docs: ReadonlyArray<OptionalUnlessRequiredId<Document>>,
     options?: BulkWriteOptions
   ): (
     collection: DocumentCollection
-  ) => Effect.Effect<InsertOneResult, MongoError.MongoError>
+  ) => Effect.Effect<InsertManyResult, MongoError.MongoError>
   (
     collection: DocumentCollection,
-    docs: Array<OptionalUnlessRequiredId<Document>>,
+    docs: ReadonlyArray<OptionalUnlessRequiredId<Document>>,
     options?: BulkWriteOptions
-  ): Effect.Effect<InsertOneResult, MongoError.MongoError>
+  ): Effect.Effect<InsertManyResult, MongoError.MongoError>
 } = F.dual((args) => isDocumentCollection(args[0]), (
   collection: DocumentCollection,
-  docs: Array<OptionalUnlessRequiredId<Document>>,
+  docs: ReadonlyArray<OptionalUnlessRequiredId<Document>>,
   options?: BulkWriteOptions
 ): Effect.Effect<InsertManyResult, MongoError.MongoError> =>
   F.pipe(
@@ -177,7 +182,7 @@ export const deleteMany: {
 export const updateMany: {
   (
     filter: Filter<Document>,
-    update: UpdateFilter<Document> | Array<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
     options?: UpdateOptions
   ): (
     collection: DocumentCollection
@@ -185,7 +190,7 @@ export const updateMany: {
   (
     collection: DocumentCollection,
     filter: Filter<Document>,
-    update: UpdateFilter<Document> | Array<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
     options?: UpdateOptions
   ): Effect.Effect<UpdateResult, MongoError.MongoError>
 } = F.dual(
@@ -193,11 +198,13 @@ export const updateMany: {
   (
     collection: DocumentCollection,
     filter: Filter<Document>,
-    update: UpdateFilter<Document> | Array<Document>,
+    update: UpdateFilter<Document> | ReadonlyArray<Document>,
     options?: UpdateOptions
   ): Effect.Effect<UpdateResult, MongoError.MongoError> =>
     F.pipe(
-      Effect.promise(() => collection.collection.updateMany(filter, update, options)),
+      Effect.promise(() =>
+        collection.collection.updateMany(filter, Array.isArray(update) ? [...update] : update, options)
+      ),
       Effect.catchAllDefect(MongoError.mongoErrorDie<UpdateResult>("updateMany error"))
     )
 )
@@ -304,22 +311,23 @@ export const findOneAndReplace: {
 export const rename: {
   (newName: string, options?: RenameOptions): (
     collection: DocumentCollection
-  ) => Effect.Effect<MongoCollection, MongoError.MongoError>
+  ) => Effect.Effect<DocumentCollection, MongoError.MongoError>
   (
     collection: DocumentCollection,
     newName: string,
     options?: RenameOptions
-  ): Effect.Effect<MongoCollection, MongoError.MongoError>
+  ): Effect.Effect<DocumentCollection, MongoError.MongoError>
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
   (
     collection: DocumentCollection,
     newName: string,
     options?: RenameOptions
-  ): Effect.Effect<MongoCollection, MongoError.MongoError> =>
+  ): Effect.Effect<DocumentCollection, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.rename(newName, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<MongoCollection>("rename error"))
+      Effect.map((collection) => new DocumentCollection({ collection })),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<DocumentCollection>("rename error"))
     )
 )
 
@@ -339,23 +347,23 @@ export const drop: {
 )
 
 export const createIndexes: {
-  (indexSpecs: Array<IndexDescription>, options?: CreateIndexesOptions): (
+  (indexSpecs: ReadonlyArray<IndexDescription>, options?: CreateIndexesOptions): (
     collection: DocumentCollection
   ) => Effect.Effect<Array<string>, MongoError.MongoError>
   (
     collection: DocumentCollection,
-    indexSpecs: Array<IndexDescription>,
+    indexSpecs: ReadonlyArray<IndexDescription>,
     options?: CreateIndexesOptions
   ): Effect.Effect<Array<string>, MongoError.MongoError>
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
   (
     collection: DocumentCollection,
-    indexSpecs: Array<IndexDescription>,
+    indexSpecs: ReadonlyArray<IndexDescription>,
     options?: CreateIndexesOptions
   ): Effect.Effect<Array<string>, MongoError.MongoError> =>
     F.pipe(
-      Effect.promise(() => collection.collection.createIndexes(indexSpecs, options)),
+      Effect.promise(() => collection.collection.createIndexes([...indexSpecs], options)),
       Effect.catchAllDefect(MongoError.mongoErrorDie<Array<string>>("createIndexes error"))
     )
 )
@@ -383,47 +391,49 @@ export const createIndex: {
     )
 )
 
+// TODO: review return type. Should we return Document like mongodb driver?
 export const dropIndex: {
   (
     indexName: string,
     options?: DropIndexesOptions
-  ): (collection: DocumentCollection) => Effect.Effect<Document, MongoError.MongoError>
+  ): (collection: DocumentCollection) => Effect.Effect<void, MongoError.MongoError>
   (
     collection: DocumentCollection,
     indexName: string,
     options?: DropIndexesOptions
-  ): Effect.Effect<Document, MongoError.MongoError>
+  ): Effect.Effect<void, MongoError.MongoError>
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
   (
     collection: DocumentCollection,
     indexName: string,
     options?: DropIndexesOptions
-  ): Effect.Effect<Document, MongoError.MongoError> =>
+  ): Effect.Effect<void, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.dropIndex(indexName, options)),
-      Effect.catchAllDefect(MongoError.mongoErrorDie<Document>("dropIndex error"))
+      Effect.asVoid,
+      Effect.catchAllDefect(MongoError.mongoErrorDie<void>("dropIndex error"))
     )
 )
 
 export const aggregate: {
-  (pipeline?: Array<Document>, options?: AggregateOptions): (
+  (pipeline?: ReadonlyArray<Document>, options?: AggregateOptions): (
     collection: DocumentCollection
   ) => DocumentAggregationCursor.DocumentAggregationCursor
   (
     collection: DocumentCollection,
-    pipeline?: Array<Document>,
+    pipeline?: ReadonlyArray<Document>,
     options?: AggregateOptions
   ): DocumentAggregationCursor.DocumentAggregationCursor
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
   (
     collection: DocumentCollection,
-    pipeline?: Array<Document>,
+    pipeline?: ReadonlyArray<Document>,
     options?: AggregateOptions
   ): DocumentAggregationCursor.DocumentAggregationCursor =>
     new DocumentAggregationCursor.DocumentAggregationCursor({
-      cursor: collection.collection.aggregate(pipeline, options)
+      cursor: collection.collection.aggregate(pipeline ? [...pipeline] : undefined, options)
     })
 )
 

package/src/DocumentFindCursor.ts

@@ -51,10 +51,10 @@ export const limit: {
     new DocumentFindCursor({ cursor: cursor.cursor.limit(value) })
 )
 
-export const toArray = (cursor: DocumentFindCursor): Effect.Effect<ReadonlyArray<Document>, MongoError.MongoError> =>
+export const toArray = (cursor: DocumentFindCursor): Effect.Effect<Array<Document>, MongoError.MongoError> =>
   F.pipe(
     Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }),
-    Effect.catchAll(MongoError.mongoErrorDie<ReadonlyArray<Document>>("toArray error"))
+    Effect.catchAll(MongoError.mongoErrorDie<Array<Document>>("toArray error"))
   )
 
 export const toStream = (

package/src/FindCursor.ts

@@ -79,17 +79,21 @@ export const toArray = <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")),
+    Effect.catchAll(MongoError.mongoErrorDie<Array<A>>("Unable to get array from mongodb cursor")),
     Effect.flatMap(Effect.forEach((x) => decode(x)))
   )
 }
 
 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> => {
+): 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.catchAll(MongoError.mongoErrorDie<Array<unknown>>("Unable to get array from mongodb cursor")),
     Effect.flatMap(Effect.forEach((x) =>
       F.pipe(
         decode(x),

package/src/ListCollectionsCursor.ts

@@ -30,10 +30,10 @@ export type FullListCollectionsCursor = ListCollectionsCursor<MongoCollectionInf
 
 export const toArray = <T extends DefaultCollectionInfo>(
   cursor: ListCollectionsCursor<T>
-): Effect.Effect<ReadonlyArray<T>, MongoError.MongoError> =>
+): Effect.Effect<Array<T>, MongoError.MongoError> =>
   F.pipe(
     Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }),
-    Effect.catchAll(MongoError.mongoErrorDie<ReadonlyArray<T>>(`${cursor._tag}.toArray error`))
+    Effect.catchAll(MongoError.mongoErrorDie<Array<T>>(`${cursor._tag}.toArray error`))
   )
 
 export const toStream = <T extends DefaultCollectionInfo>(

package/src/MongoClient.ts

@@ -3,6 +3,7 @@
  */
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
+import type * as Scope from "effect/Scope"
 import type { Db, DbOptions, MongoClientOptions } from "mongodb"
 import { MongoClient as MongoClient_ } from "mongodb"
 import * as MongoError from "./MongoError.js"
@@ -17,6 +18,26 @@ export const connect = (
     Effect.catchAll(MongoError.mongoErrorDie<MongoClient_>("connect error"))
   )
 
+export const close: {
+  (force?: boolean): (client: MongoClient) => Effect.Effect<void, MongoError.MongoError>
+  (client: MongoClient, force?: boolean): Effect.Effect<void, MongoError.MongoError>
+} = F.dual(
+  (args) => isMongoClient(args[0]),
+  (client: MongoClient, force?: boolean): Effect.Effect<void, MongoError.MongoError> =>
+    Effect.promise(() => client.close(force)).pipe(
+      Effect.catchAll(MongoError.mongoErrorDie<void>("close error"))
+    )
+)
+
+export const connectScoped = (
+  url: string,
+  options?: MongoClientOptions & { forceClose?: boolean }
+): Effect.Effect<MongoClient, MongoError.MongoError, Scope.Scope> =>
+  Effect.acquireRelease(
+    connect(url, options),
+    (client) => close(client, options?.forceClose).pipe(Effect.orDie)
+  )
+
 export const db: {
   (dbName?: string, options?: DbOptions): (client: MongoClient) => Db
   (client: MongoClient, dbName?: string, options?: DbOptions): Db

package/src/internal/version.ts

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