effect-mongodb 0.1.3 → 0.2.0

package/src/DocumentFindCursor.ts

@@ -4,6 +4,8 @@
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
+import type { Pipeable } from "effect/Pipeable"
+import { pipeArguments } from "effect/Pipeable"
 import type * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import type { Document, Filter, FindCursor as MongoFindCursor, Sort, SortDirection } from "mongodb"
@@ -11,9 +13,21 @@ import * as FindCursor from "./FindCursor.js"
 import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export class DocumentFindCursor extends Data.TaggedClass("DocumentFindCursor")<{
+type DocumentFindCursorFields = {
   cursor: MongoFindCursor<Document>
-}> {
+}
+
+export interface DocumentFindCursor extends DocumentFindCursorFields, Pipeable {
+  _tag: "DocumentFindCursor"
+}
+
+/** @internal */
+export class DocumentFindCursorImpl extends Data.TaggedClass("DocumentFindCursor")<DocumentFindCursorFields>
+  implements DocumentFindCursor
+{
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const filter: {
@@ -22,7 +36,7 @@ export const filter: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, filter: Filter<Document>): DocumentFindCursor =>
-    new DocumentFindCursor({ cursor: cursor.cursor.filter(filter) })
+    new DocumentFindCursorImpl({ cursor: cursor.cursor.filter(filter) })
 )
 
 export const project: {
@@ -31,7 +45,7 @@ export const project: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, value: Document): DocumentFindCursor =>
-    new DocumentFindCursor({ cursor: cursor.cursor.project(value) })
+    new DocumentFindCursorImpl({ cursor: cursor.cursor.project(value) })
 )
 
 export const sort: {
@@ -40,7 +54,7 @@ export const sort: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, sort: Sort | string, direction?: SortDirection): DocumentFindCursor =>
-    new DocumentFindCursor({ cursor: cursor.cursor.sort(sort, direction) })
+    new DocumentFindCursorImpl({ cursor: cursor.cursor.sort(sort, direction) })
 )
 
 export const limit: {
@@ -49,7 +63,7 @@ export const limit: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, value: number): DocumentFindCursor =>
-    new DocumentFindCursor({ cursor: cursor.cursor.limit(value) })
+    new DocumentFindCursorImpl({ cursor: cursor.cursor.limit(value) })
 )
 
 export const toArray = (cursor: DocumentFindCursor): Effect.Effect<Array<Document>, MongoError.MongoError> =>
@@ -72,13 +86,13 @@ export const typed: {
 } = F.dual((args) => isDocumentFindCursor(args[0]), <A, I = A, R = never>(
   cursor: DocumentFindCursor,
   schema: Schema.Schema<A, I, R>
-): FindCursor.FindCursor<A, I, R> => new FindCursor.FindCursor<A, I, R>({ cursor: cursor.cursor, schema }))
+): FindCursor.FindCursor<A, I, R> => new FindCursor.FindCursorImpl<A, I, R>({ cursor: cursor.cursor, schema }))
 
-const isDocumentFindCursor = (x: unknown) => x instanceof DocumentFindCursor
+const isDocumentFindCursor = (x: unknown) => x instanceof DocumentFindCursorImpl
 
 const errorSource = (cursor: DocumentFindCursor, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: DocumentFindCursor.name,
+    module: DocumentFindCursorImpl.name,
     functionName,
     db: cursor.cursor.namespace.db,
     collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"

package/src/FindCursor.ts

@@ -6,6 +6,8 @@ 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 type { Pipeable } from "effect/Pipeable"
+import { pipeArguments } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import * as Tuple from "effect/Tuple"
@@ -14,10 +16,22 @@ import type { Filter } from "./internal/filter.js"
 import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export class FindCursor<A, I = A, R = never> extends Data.TaggedClass("FindCursor")<{
+type FindCursorFields<A, I = A, R = never> = {
   cursor: FindCursor_<unknown>
   schema: Schema.Schema<A, I, R>
-}> {
+}
+
+export interface FindCursor<A, I = A, R = never> extends FindCursorFields<A, I, R>, Pipeable {
+  _tag: "FindCursor"
+}
+
+/** @internal */
+export class FindCursorImpl<A, I = A, R = never> extends Data.TaggedClass("FindCursor")<FindCursorFields<A, I, R>>
+  implements FindCursor<A, I, R>
+{
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const filter: {
@@ -28,7 +42,7 @@ export const filter: {
   <A, I extends Document, R>(
     cursor: FindCursor<A, I, R>,
     filter: Filter<I>
-  ): FindCursor<A, I, R> => new FindCursor({ cursor: cursor.cursor.filter(filter), schema: cursor.schema })
+  ): FindCursor<A, I, R> => new FindCursorImpl({ cursor: cursor.cursor.filter(filter), schema: cursor.schema })
 )
 
 export const project: {
@@ -47,7 +61,7 @@ export const project: {
     cursor: FindCursor<A, I, R>,
     newSchema: Schema.Schema<B, BI, BR>,
     value: T
-  ): FindCursor<B, BI, BR> => new FindCursor({ cursor: cursor.cursor.project(value), schema: newSchema })
+  ): FindCursor<B, BI, BR> => new FindCursorImpl({ cursor: cursor.cursor.project(value), schema: newSchema })
 )
 
 export const sort: {
@@ -63,7 +77,7 @@ export const sort: {
     cursor: FindCursor<A, I, R>,
     sort: Sort | string,
     direction?: SortDirection
-  ): FindCursor<A, I, R> => new FindCursor({ cursor: cursor.cursor.sort(sort, direction), schema: cursor.schema })
+  ): FindCursor<A, I, R> => new FindCursorImpl({ cursor: cursor.cursor.sort(sort, direction), schema: cursor.schema })
 )
 
 export const limit: {
@@ -72,7 +86,7 @@ export const limit: {
 } = F.dual(
   (args) => isFindCursor(args[0]),
   <A, I, R>(cursor: FindCursor<A, I, R>, value: number): FindCursor<A, I, R> =>
-    new FindCursor({ cursor: cursor.cursor.limit(value), schema: cursor.schema })
+    new FindCursorImpl({ cursor: cursor.cursor.limit(value), schema: cursor.schema })
 )
 
 export const toArray = <A, I, R>(
@@ -134,11 +148,11 @@ export const toStreamEither = <A, I, R>(
   )
 }
 
-const isFindCursor = (x: unknown): x is FindCursor<unknown> => x instanceof FindCursor
+const isFindCursor = (x: unknown): x is FindCursor<unknown> => x instanceof FindCursorImpl
 
 const errorSource = <A, I, R>(cursor: FindCursor<A, I, R>, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: FindCursor.name,
+    module: FindCursorImpl.name,
     functionName,
     db: cursor.cursor.namespace.db,
     collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"

package/src/ListCollectionsCursor.ts

@@ -4,6 +4,8 @@
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
+import type { Pipeable } from "effect/Pipeable"
+import { pipeArguments } from "effect/Pipeable"
 import * as Stream from "effect/Stream"
 import type {
   CollectionInfo as MongoCollectionInfo,
@@ -17,11 +19,24 @@ export type FullCollectionInfo = MongoCollectionInfo
 
 type DefaultCollectionInfo = NameOnlyCollectionInfo | FullCollectionInfo
 
-export class ListCollectionsCursor<
-  T extends DefaultCollectionInfo = DefaultCollectionInfo
-> extends Data.TaggedClass("ListCollectionsCursor")<{
+type ListCollectionsCursorFields<T extends DefaultCollectionInfo = DefaultCollectionInfo> = {
   cursor: MongoListCollectionsCursor<T>
-}> {}
+}
+
+export interface ListCollectionsCursor<T extends DefaultCollectionInfo = DefaultCollectionInfo>
+  extends ListCollectionsCursorFields<T>, Pipeable
+{
+  _tag: "ListCollectionsCursor"
+}
+
+/** @internal */
+export class ListCollectionsCursorImpl<
+  T extends DefaultCollectionInfo = DefaultCollectionInfo
+> extends Data.TaggedClass("ListCollectionsCursor")<ListCollectionsCursorFields<T>> implements Pipeable {
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
 
 export type NameOnlyListCollectionsCursor = ListCollectionsCursor<
   Pick<MongoCollectionInfo, "name" | "type">
@@ -47,7 +62,7 @@ export const toStream = <T extends DefaultCollectionInfo>(
 
 const errorSource = (cursor: ListCollectionsCursor, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: ListCollectionsCursor.name,
+    module: ListCollectionsCursorImpl.name,
     functionName,
     db: cursor.cursor.namespace.db,
     collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"

package/src/MongoClient.ts

@@ -1,21 +1,24 @@
 /**
  * @since 0.0.1
  */
+import * as Data from "effect/Data"
 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 type { DbOptions, MongoClientOptions } from "mongodb"
 import { MongoClient as MongoClient_ } from "mongodb"
+import * as Db from "./Db.js"
 import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export type MongoClient = MongoClient_
+export class MongoClient extends Data.TaggedClass("MongoClient")<{ client: MongoClient_ }> {}
 
 export const connect = (
   url: string,
   options?: MongoClientOptions
 ): Effect.Effect<MongoClient, MongoError.MongoError> =>
   Effect.promise(() => MongoClient_.connect(url, options)).pipe(
+    Effect.map((client) => new MongoClient({ client })),
     Effect.catchAllDefect(mongoErrorOrDie(errorSource([new URL(url).host], "connect")))
   )
 
@@ -24,15 +27,17 @@ export const close: {
   (client: MongoClient, force?: boolean): Effect.Effect<void, MongoError.MongoError>
 } = F.dual(
   (args) => isMongoClient(args[0]),
-  (client: MongoClient, force?: boolean): Effect.Effect<void, MongoError.MongoError> =>
+  ({ client }: MongoClient, force?: boolean): Effect.Effect<void, MongoError.MongoError> =>
     Effect.promise(() => client.close(force)).pipe(
       Effect.catchAllDefect(mongoErrorOrDie(errorSource(client.options.hosts.map((x) => x.host ?? "NO_HOST"), "close")))
     )
 )
 
+export type MongoClientScopedOptions = MongoClientOptions & { forceClose?: boolean }
+
 export const connectScoped = (
   url: string,
-  options?: MongoClientOptions & { forceClose?: boolean }
+  options?: MongoClientScopedOptions
 ): Effect.Effect<MongoClient, MongoError.MongoError, Scope.Scope> =>
   Effect.acquireRelease(
     connect(url, options),
@@ -40,14 +45,15 @@ export const connectScoped = (
   )
 
 export const db: {
-  (dbName?: string, options?: DbOptions): (client: MongoClient) => Db
-  (client: MongoClient, dbName?: string, options?: DbOptions): Db
+  (dbName?: string, options?: DbOptions): (client: MongoClient) => Db.Db
+  (client: MongoClient, dbName?: string, options?: DbOptions): Db.Db
 } = F.dual(
   (args) => isMongoClient(args[0]),
-  (client: MongoClient, dbName?: string, options?: DbOptions): Db => client.db(dbName, options)
+  ({ client }: MongoClient, dbName?: string, options?: DbOptions): Db.Db =>
+    new Db.Db({ db: client.db(dbName, options) })
 )
 
-const isMongoClient = (x: unknown) => x instanceof MongoClient_
+const isMongoClient = (x: unknown) => x instanceof MongoClient
 
 const errorSource = (hosts: Array<string>, functionName: string) =>
   new MongoError.ClientErrorSource({ module: "MongoClient", functionName, hosts })

package/src/internal/schema.ts

@@ -5,8 +5,8 @@ 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*(_) {
+  Effect.gen(function*() {
     if (value === null) return O.none()
-    const decoded = yield* _(Schema.decodeUnknown(schema)(value))
+    const decoded = yield* Schema.decodeUnknown(schema)(value)
     return O.some(decoded)
   })

package/src/internal/version.ts

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