effect-mongodb 0.0.3 → 0.0.4

package/src/Collection.ts

@@ -15,11 +15,16 @@ import type {
   DeleteOptions,
   DeleteResult,
   Document,
+  DropCollectionOptions,
+  DropIndexesOptions,
+  FindOneAndReplaceOptions,
   FindOptions as MongoFindOptions,
   IndexDescription,
+  IndexSpecification,
   InsertManyResult,
   InsertOneOptions,
   InsertOneResult,
+  ModifyResult as MongoModifyResult,
   RenameOptions,
   ReplaceOptions,
   UpdateFilter,
@@ -29,6 +34,8 @@ import type {
 import * as AggregationCursor from "./AggregationCursor.js"
 import * as FindCursor from "./FindCursor.js"
 import type { Filter } from "./internal/filter.js"
+import type { ModifyResult } from "./internal/modify-result.js"
+import * as SchemaExt from "./internal/schema.js"
 import * as MongoError from "./MongoError.js"
 
 export class Collection<A extends Document, I extends Document = A, R = never> extends Data.TaggedClass("Collection")<{
@@ -40,21 +47,24 @@ export class Collection<A extends Document, I extends Document = A, R = never> e
 export type FindOptions = Omit<MongoFindOptions, "projection">
 
 export const find: {
-  (
+  <I extends Document>(
+    filter?: Filter<I>,
     options?: FindOptions
-  ): <A extends Document, I extends Document, R>(collection: Collection<A, I, R>) => FindCursor.FindCursor<A, I, R>
+  ): <A extends Document, R>(collection: Collection<A, I, R>) => FindCursor.FindCursor<A, I, R>
   <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
+    filter?: Filter<I>,
     options?: FindOptions
   ): FindCursor.FindCursor<A, I, R>
 } = F.dual(
   (args) => isCollection(args[0]),
   <A extends Document, I extends Document, R>(
     collection: Collection<A, I, R>,
+    filter?: Filter<I>,
     options?: FindOptions
   ): FindCursor.FindCursor<A, I, R> =>
     new FindCursor.FindCursor<A, I, R>({
-      cursor: collection.collection.find({}, options),
+      cursor: collection.collection.find(filter ?? {}, options),
       schema: collection.schema
     })
 )
@@ -250,6 +260,87 @@ export const replaceOne: {
     )
 )
 
+export const findOneAndReplace: {
+  <A extends Document, I extends Document>(
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: true }
+  ): <R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<ModifyResult<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document>(
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: false }
+  ): <R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document>(
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions
+  ): <R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document>(
+    filter: Filter<I>,
+    replacement: A
+  ): <R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: true }
+  ): Effect.Effect<ModifyResult<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions & { includeResultMetadata: false }
+  ): Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    options: FindOneAndReplaceOptions
+  ): Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A
+  ): Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    filter: Filter<I>,
+    replacement: A,
+    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),
+      Effect.flatMap((replacement) =>
+        Effect.promise(() => collection.collection.findOneAndReplace(filter, replacement, options ?? {}))
+      ),
+      Effect.flatMap((value) =>
+        Effect.gen(function*(_) {
+          if (options?.includeResultMetadata && !!value) {
+            const result = value as unknown as MongoModifyResult<I>
+            const maybeValue = yield* _(SchemaExt.decodeNullableDocument(collection.schema, result.value))
+            return { ...result, value: maybeValue }
+          }
+          return yield* _(SchemaExt.decodeNullableDocument(collection.schema, value))
+        })
+      ),
+      Effect.catchAllDefect(
+        MongoError.mongoErrorDie<O.Option<A> | ModifyResult<A>>("findOneAndReplace error")
+      )
+    )
+)
+
 export const rename: {
   (
     newName: string,
@@ -276,6 +367,28 @@ export const rename: {
     )
 )
 
+export const drop: {
+  (
+    options?: DropCollectionOptions
+  ): <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<boolean, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    options?: DropCollectionOptions
+  ): Effect.Effect<boolean, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    options?: DropCollectionOptions
+  ): Effect.Effect<boolean, MongoError.MongoError, R> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.drop(options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<boolean>("drop error"))
+    )
+)
+
 export const createIndexes: {
   (
     indexSpecs: Array<IndexDescription>,
@@ -301,6 +414,57 @@ export const createIndexes: {
     )
 )
 
+export const createIndex: {
+  (
+    indexSpec: IndexSpecification,
+    options?: CreateIndexesOptions
+  ): <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<string, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexSpec: IndexSpecification,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<string, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexSpec: IndexSpecification,
+    options?: CreateIndexesOptions
+  ): Effect.Effect<string, MongoError.MongoError, R> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.createIndex(indexSpec, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<string>("createIndex error"))
+    )
+)
+
+export const dropIndex: {
+  (
+    indexName: string,
+    options?: DropIndexesOptions
+  ): <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>
+  ) => Effect.Effect<void, MongoError.MongoError, R>
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexName: string,
+    options?: DropIndexesOptions
+  ): Effect.Effect<void, MongoError.MongoError, R>
+} = F.dual(
+  (args) => isCollection(args[0]),
+  <A extends Document, I extends Document, R>(
+    collection: Collection<A, I, R>,
+    indexName: string,
+    options?: DropIndexesOptions
+  ): Effect.Effect<void, MongoError.MongoError, R> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.dropIndex(indexName, options)),
+      Effect.asVoid,
+      Effect.catchAllDefect(MongoError.mongoErrorDie<void>("dropIndex error"))
+    )
+)
+
 export const aggregate: {
   <B extends Document, BI extends Document, BR>(
     pipeline: Array<Document>,

package/src/DocumentCollection.ts

@@ -14,12 +14,17 @@ import type {
   DeleteOptions,
   DeleteResult,
   Document,
+  DropCollectionOptions,
+  DropIndexesOptions,
   Filter,
+  FindOneAndReplaceOptions,
   FindOptions,
   IndexDescription,
+  IndexSpecification,
   InsertManyResult,
   InsertOneOptions,
   InsertOneResult,
+  ModifyResult as MongoModifyResult,
   OptionalUnlessRequiredId,
   RenameOptions,
   ReplaceOptions,
@@ -31,6 +36,7 @@ import type {
 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")<{
@@ -39,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)
       }
     )
 )
@@ -230,6 +240,80 @@ export const replaceOne: {
     )
 )
 
+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,
@@ -255,6 +339,21 @@ export const rename: {
     )
 )
 
+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>,
@@ -280,6 +379,52 @@ export const createIndexes: {
     )
 )
 
+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>,

package/src/DocumentFindCursor.ts

@@ -6,7 +6,7 @@ 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

@@ -10,26 +10,28 @@ 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"
 
 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, R>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
-  <A, I, R, 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, R, 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 })
 )
 
@@ -82,8 +84,9 @@ export const limit: {
     new FindCursor({ cursor: cursor.cursor.limit(value), schema: cursor.schema })
 )
 
-// TODO: add explicit return type for public API
-export const toArray = <A, I, R>(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,14 +94,14 @@ export const toArray = <A, I, R>(cursor: FindCursor<A, I, R>) => {
   )
 }
 
-// TODO: add explicit return type for public API
-export const toArrayEither = <A, I, R>(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

package/src/MongoClient.ts

@@ -12,7 +12,10 @@ import * as Context from "effect/Context"
 
 export type MongoClient = MongoClient_
 
-export const connect = (url: string, options?: MongoClientOptions) =>
+export const connect = (
+  url: string,
+  options?: MongoClientOptions
+): Effect.Effect<MongoClient, MongoError.MongoError> =>
   Effect.promise(() => MongoClient_.connect(url, options)).pipe(
     Effect.catchAll(MongoError.mongoErrorDie<MongoClient_>("connect error"))
   )
@@ -22,7 +25,7 @@ export const db: {
   (client: MongoClient, dbName?: string, options?: DbOptions): Db
 } = F.dual(
   (args) => isMongoClient(args[0]),
-  (client: MongoClient, dbName?: string, options?: DbOptions) => client.db(dbName, options)
+  (client: MongoClient, dbName?: string, options?: DbOptions): Db => client.db(dbName, options)
 )
 
 const isMongoClient = (x: unknown) => x instanceof MongoClient_

package/src/internal/modify-result.ts

@@ -0,0 +1,6 @@
+import type * as O from "effect/Option"
+import type { ModifyResult as MongoModifyResult } from "mongodb"
+
+export type ModifyResult<TSchema> = Omit<MongoModifyResult<TSchema>, "value"> & {
+  value: O.Option<TSchema>
+}

package/src/internal/schema.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect"
+import * as O from "effect/Option"
+import * as Schema from "effect/Schema"
+import type { Document } from "mongodb"
+
+// TODO: there is probably a Schema to do this decode or using typeclass package for traverse
+export const decodeNullableDocument = <A, I, R>(schema: Schema.Schema<A, I, R>, value: Document | null) =>
+  Effect.gen(function*(_) {
+    if (value === null) return O.none()
+    const decoded = yield* _(Schema.decodeUnknown(schema)(value))
+    return O.some(decoded)
+  })

package/src/internal/version.ts

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