effect-mongodb 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-mongodb",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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"
@@ -110,19 +111,19 @@ export const insertOne: {
 
 export const insertMany: {
   (
-    docs: Array<OptionalUnlessRequiredId<Document>>,
+    docs: ReadonlyArray<OptionalUnlessRequiredId<Document>>,
     options?: BulkWriteOptions
   ): (
     collection: DocumentCollection
   ) => Effect.Effect<InsertOneResult, MongoError.MongoError>
   (
     collection: DocumentCollection,
-    docs: Array<OptionalUnlessRequiredId<Document>>,
+    docs: ReadonlyArray<OptionalUnlessRequiredId<Document>>,
     options?: BulkWriteOptions
   ): Effect.Effect<InsertOneResult, 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 +178,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 +186,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 +194,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"))
     )
 )
@@ -339,23 +342,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"))
     )
 )
@@ -407,23 +410,23 @@ export const dropIndex: {
 )
 
 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.1"
 
 export const getCurrentVersion = () => moduleVersion