effect-mongodb 0.0.4 → 0.1.0

package/src/Db.ts

@@ -1,18 +1,14 @@
 /**
  * @since 0.0.1
  */
-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 * 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 * as MongoError from "./MongoError.js"
 
 export const documentCollection: {
@@ -46,7 +42,7 @@ export const collection: {
 )
 
 export const listCollections: {
-  (): (db: Db) => ListCollectionsCursor.ListCollectionsCursor
+  (db: Db): ListCollectionsCursor.ListCollectionsCursor
   (filter: Document): (db: Db) => ListCollectionsCursor.ListCollectionsCursor
   (
     filter: Document,
@@ -56,7 +52,6 @@ export const listCollections: {
     filter: Document,
     options: Exclude<ListCollectionsOptions, "nameOnly"> & { nameOnly: false }
   ): (db: Db) => ListCollectionsCursor.FullListCollectionsCursor
-  (db: Db): ListCollectionsCursor.ListCollectionsCursor
   (db: Db, filter: Document): ListCollectionsCursor.ListCollectionsCursor
   (
     db: Db,
@@ -75,7 +70,7 @@ export const listCollections: {
 )
 
 export const dropCollection: {
-  (name: string): (db: Db) => Effect.Effect<boolean>
+  (name: string): (db: Db) => Effect.Effect<boolean, MongoError.MongoError>
   (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>
@@ -89,35 +84,3 @@ export const dropCollection: {
 )
 
 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

@@ -10,12 +10,14 @@ import type {
   AggregateOptions,
   BulkWriteOptions,
   Collection as MongoCollection,
+  CountDocumentsOptions,
   CreateIndexesOptions,
   DeleteOptions,
   DeleteResult,
   Document,
   DropCollectionOptions,
   DropIndexesOptions,
+  EstimatedDocumentCountOptions,
   Filter,
   FindOneAndReplaceOptions,
   FindOptions,
@@ -65,10 +67,7 @@ export const find: {
 )
 
 export const findOne: {
-  (
-    filter: Filter<Document>,
-    options?: FindOptions
-  ): (
+  (filter: Filter<Document>, options?: FindOptions): (
     collection: DocumentCollection
   ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
   (
@@ -91,10 +90,7 @@ export const findOne: {
 )
 
 export const insertOne: {
-  (
-    doc: OptionalUnlessRequiredId<Document>,
-    options?: InsertOneOptions
-  ): (
+  (doc: OptionalUnlessRequiredId<Document>, options?: InsertOneOptions): (
     collection: DocumentCollection
   ) => Effect.Effect<InsertOneResult, MongoError.MongoError>
   (
@@ -135,10 +131,7 @@ export const insertMany: {
   ))
 
 export const deleteOne: {
-  (
-    filter: Filter<Document>,
-    options?: DeleteOptions
-  ): (
+  (filter: Filter<Document>, options?: DeleteOptions): (
     collection: DocumentCollection
   ) => Effect.Effect<DeleteResult, MongoError.MongoError>
   (
@@ -160,10 +153,7 @@ export const deleteOne: {
 )
 
 export const deleteMany: {
-  (
-    filter: Filter<Document>,
-    options?: DeleteOptions
-  ): (
+  (filter: Filter<Document>, options?: DeleteOptions): (
     collection: DocumentCollection
   ) => Effect.Effect<DeleteResult, MongoError.MongoError>
   (
@@ -262,10 +252,7 @@ export const findOneAndReplace: {
   ): (
     collection: DocumentCollection
   ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
-  (
-    filter: Filter<Document>,
-    replacement: WithoutId<Document>
-  ): (
+  (filter: Filter<Document>, replacement: WithoutId<Document>): (
     collection: DocumentCollection
   ) => Effect.Effect<O.Option<Document>, MongoError.MongoError>
   (
@@ -315,10 +302,7 @@ export const findOneAndReplace: {
 )
 
 export const rename: {
-  (
-    newName: string,
-    options?: RenameOptions
-  ): (
+  (newName: string, options?: RenameOptions): (
     collection: DocumentCollection
   ) => Effect.Effect<MongoCollection, MongoError.MongoError>
   (
@@ -355,10 +339,7 @@ export const drop: {
 )
 
 export const createIndexes: {
-  (
-    indexSpecs: Array<IndexDescription>,
-    options?: CreateIndexesOptions
-  ): (
+  (indexSpecs: Array<IndexDescription>, options?: CreateIndexesOptions): (
     collection: DocumentCollection
   ) => Effect.Effect<Array<string>, MongoError.MongoError>
   (
@@ -426,10 +407,7 @@ export const dropIndex: {
 )
 
 export const aggregate: {
-  (
-    pipeline?: Array<Document>,
-    options?: AggregateOptions
-  ): (
+  (pipeline?: Array<Document>, options?: AggregateOptions): (
     collection: DocumentCollection
   ) => DocumentAggregationCursor.DocumentAggregationCursor
   (
@@ -449,6 +427,48 @@ export const aggregate: {
     })
 )
 
+export const estimatedDocumentCount: {
+  (options?: EstimatedDocumentCountOptions): (
+    collection: DocumentCollection
+  ) => Effect.Effect<number, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    options?: EstimatedDocumentCountOptions
+  ): Effect.Effect<number, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    options?: EstimatedDocumentCountOptions
+  ): Effect.Effect<number, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.estimatedDocumentCount(options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<number>("estimatedDocumentCount error"))
+    )
+)
+
+export const countDocuments: {
+  (filter?: Filter<Document>, options?: CountDocumentsOptions): (
+    collection: DocumentCollection
+  ) => Effect.Effect<number, MongoError.MongoError>
+  (
+    collection: DocumentCollection,
+    filter?: Filter<Document>,
+    options?: CountDocumentsOptions
+  ): Effect.Effect<number, MongoError.MongoError>
+} = F.dual(
+  (args) => isDocumentCollection(args[0]),
+  (
+    collection: DocumentCollection,
+    filter?: Filter<Document>,
+    options?: CountDocumentsOptions
+  ): Effect.Effect<number, MongoError.MongoError> =>
+    F.pipe(
+      Effect.promise(() => collection.collection.countDocuments(filter, options)),
+      Effect.catchAllDefect(MongoError.mongoErrorDie<number>("countDocuments error"))
+    )
+)
+
 export const typed: {
   <A extends Document, I extends Document = A, R = never>(
     schema: Schema.Schema<A, I, R>

package/src/DocumentFindCursor.ts

@@ -16,9 +16,7 @@ export class DocumentFindCursor extends Data.TaggedClass("DocumentFindCursor")<{
 }
 
 export const filter: {
-  (
-    filter: Filter<Document>
-  ): (cursor: DocumentFindCursor) => DocumentFindCursor
+  (filter: Filter<Document>): (cursor: DocumentFindCursor) => DocumentFindCursor
   (cursor: DocumentFindCursor, filter: Filter<Document>): DocumentFindCursor
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
@@ -27,9 +25,7 @@ export const filter: {
 )
 
 export const project: {
-  (
-    value: Document
-  ): (cursor: DocumentFindCursor) => DocumentFindCursor
+  (value: Document): (cursor: DocumentFindCursor) => DocumentFindCursor
   (cursor: DocumentFindCursor, value: Document): DocumentFindCursor
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
@@ -38,10 +34,7 @@ export const project: {
 )
 
 export const sort: {
-  (
-    sort: Sort | string,
-    direction?: SortDirection
-  ): (cursor: DocumentFindCursor) => DocumentFindCursor
+  (sort: Sort | string, direction?: SortDirection): (cursor: DocumentFindCursor) => DocumentFindCursor
   (cursor: DocumentFindCursor, sort: Sort | string, direction?: SortDirection): DocumentFindCursor
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
@@ -50,9 +43,7 @@ export const sort: {
 )
 
 export const limit: {
-  (
-    value: number
-  ): (cursor: DocumentFindCursor) => DocumentFindCursor
+  (value: number): (cursor: DocumentFindCursor) => DocumentFindCursor
   (cursor: DocumentFindCursor, value: number): DocumentFindCursor
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
@@ -75,13 +66,8 @@ export const toStream = (
   )
 
 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>
+  <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>

package/src/FindCursor.ts

@@ -20,13 +20,8 @@ export class FindCursor<A, I = A, R = never> extends Data.TaggedClass("FindCurso
 }
 
 export const filter: {
-  <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: Filter<I>
-  ): FindCursor<A, I, R>
+  <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: Filter<I>): FindCursor<A, I, R>
 } = F.dual(
   (args) => isFindCursor(args[0]),
   <A, I extends Document, R>(
@@ -55,10 +50,7 @@ export const project: {
 )
 
 export const sort: {
-  (
-    sort: Sort | string,
-    direction?: SortDirection
-  ): <A, I, R>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  (sort: Sort | string, direction?: SortDirection): <A, I, R>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
   <A, I, R>(
     cursor: FindCursor<A, I, R>,
     sort: Sort | string,
@@ -74,9 +66,7 @@ export const sort: {
 )
 
 export const limit: {
-  (
-    value: number
-  ): <A, I, R>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  (value: number): <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]),

package/src/MongoClient.ts

@@ -1,15 +1,12 @@
 /**
  * @since 0.0.1
  */
-import type * as Brand from "effect/Brand"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
 import type { Db, DbOptions, MongoClientOptions } from "mongodb"
 import { MongoClient as MongoClient_ } from "mongodb"
 import * as MongoError from "./MongoError.js"
 
-import * as Context from "effect/Context"
-
 export type MongoClient = MongoClient_
 
 export const connect = (
@@ -29,10 +26,3 @@ export const db: {
 )
 
 const isMongoClient = (x: unknown) => x instanceof MongoClient_
-
-export type MongoClientService<K extends string> = {
-  client: Effect.Effect<MongoClient, MongoError.MongoError>
-} & Brand.Brand<K>
-
-export const Tag = <K extends string>(key: K) => Context.GenericTag<MongoClientService<K>>(key)
-export type TagType<K extends string> = ReturnType<typeof Tag<K>>

package/src/internal/version.ts

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