effect-mongodb 0.1.3 → 0.1.4

package/src/AggregationCursor.ts

@@ -5,15 +5,31 @@ import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 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 type { AggregationCursor as MongoAggregationCursor } from "mongodb"
 import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export class AggregationCursor<A, I = A, R = never> extends Data.TaggedClass("AggregationCursor")<
-  { cursor: MongoAggregationCursor<unknown>; schema: Schema.Schema<A, I, R> }
-> {
+interface AggregationCursorFields<A, I = A, R = never> {
+  cursor: MongoAggregationCursor<unknown>
+  schema: Schema.Schema<A, I, R>
+}
+
+export interface AggregationCursor<A, I = A, R = never> extends AggregationCursorFields<A, I, R>, Pipeable {
+  _tag: "AggregationCursor"
+}
+
+/** @internal */
+export class AggregationCursorImpl<A, I = A, R = never>
+  extends Data.TaggedClass("AggregationCursor")<AggregationCursorFields<A, I, R>>
+  implements AggregationCursor<A, I, R>
+{
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const toArray = <A, I, R>(
@@ -39,7 +55,7 @@ export const toStream = <A, I, R>(
 
 const errorSource = <A, I, R>(cursor: AggregationCursor<A, I, R>, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: AggregationCursor.name,
+    module: AggregationCursorImpl.name,
     functionName,
     db: cursor.cursor.namespace.db,
     collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"

package/src/Collection.ts

@@ -7,6 +7,8 @@ import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
 import type * as O from "effect/Option"
 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 type {
   AggregateOptions,
@@ -42,11 +44,28 @@ import { mongoErrorOrDie } from "./internal/mongo-error.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")<{
+type CollectionFields<A extends Document, I extends Document = A, R = never> = {
   collection: MongoCollection
   schema: Schema.Schema<A, I, R>
-}> {
+}
+
+export interface Collection<A extends Document, I extends Document = A, R = never>
+  extends CollectionFields<A, I, R>, Pipeable
+{
+  _tag: "Collection"
+  /** @internal */
+  encode: ReturnType<typeof Schema.encode<A, I, R>>
+}
+
+/** @internal */
+export class CollectionImpl<A extends Document, I extends Document = A, R = never>
+  extends Data.TaggedClass("Collection")<CollectionFields<A, I, R>>
+  implements Collection<A, I, R>
+{
   readonly encode = Schema.encode(this.schema)
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export type FindOptions = Omit<MongoFindOptions, "projection">
@@ -68,7 +87,7 @@ export const find: {
     filter?: Filter<I>,
     options?: FindOptions
   ): FindCursor.FindCursor<A, I, R> =>
-    new FindCursor.FindCursor<A, I, R>({
+    new FindCursor.FindCursorImpl<A, I, R>({
       cursor: collection.collection.find(filter ?? {}, options),
       schema: collection.schema
     })
@@ -90,9 +109,9 @@ export const findOne: {
     filter: Filter<I>,
     options?: FindOptions
   ): Effect.Effect<O.Option<A>, MongoError.MongoError | ParseResult.ParseError, R> =>
-    Effect.gen(function*(_) {
-      const value = yield* _(Effect.promise(() => collection.collection.findOne(filter, options)))
-      return yield* _(SchemaExt.decodeNullableDocument(collection.schema, value))
+    Effect.gen(function*() {
+      const value = yield* Effect.promise(() => collection.collection.findOne(filter, options))
+      return yield* SchemaExt.decodeNullableDocument(collection.schema, value)
     }).pipe(
       Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "findOne")))
     )
@@ -306,13 +325,13 @@ export const findOneAndReplace: {
         Effect.promise(() => collection.collection.findOneAndReplace(filter, replacement, options ?? {}))
       ),
       Effect.flatMap((value) =>
-        Effect.gen(function*(_) {
+        Effect.gen(function*() {
           if (options?.includeResultMetadata && !!value) {
             const result = value as unknown as MongoModifyResult<I>
-            const maybeValue = yield* _(SchemaExt.decodeNullableDocument(collection.schema, result.value))
+            const maybeValue = yield* SchemaExt.decodeNullableDocument(collection.schema, result.value)
             return { ...result, value: maybeValue }
           }
-          return yield* _(SchemaExt.decodeNullableDocument(collection.schema, value))
+          return yield* SchemaExt.decodeNullableDocument(collection.schema, value)
         })
       ),
       Effect.catchAllDefect(
@@ -339,7 +358,9 @@ export const rename: {
   ): Effect.Effect<Collection<A, I, R>, MongoError.MongoError, R> =>
     F.pipe(
       Effect.promise(() => collection.collection.rename(newName, options)),
-      Effect.map((newCollection) => new Collection<A, I, R>({ collection: newCollection, schema: collection.schema })),
+      Effect.map((newCollection) =>
+        new CollectionImpl<A, I, R>({ collection: newCollection, schema: collection.schema })
+      ),
       Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "rename")))
     )
 )
@@ -455,7 +476,7 @@ export const aggregate: {
     pipeline: ReadonlyArray<Document>,
     options?: AggregateOptions
   ): AggregationCursor.AggregationCursor<B, BI, BR> =>
-    new AggregationCursor.AggregationCursor<B, BI, BR>({
+    new AggregationCursor.AggregationCursorImpl<B, BI, BR>({
       cursor: collection.collection.aggregate([...pipeline], options),
       schema
     })
@@ -503,14 +524,14 @@ export const countDocuments: {
     )
 )
 
-const isCollection = (x: unknown) => x instanceof Collection
+const isCollection = (x: unknown) => x instanceof CollectionImpl
 
 const errorSource = <A extends Document, I extends Document = A, R = never>(
   collection: Collection<A, I, R>,
   functionName: string
 ) =>
   new MongoError.CollectionErrorSource({
-    module: Collection.name,
+    module: CollectionImpl.name,
     functionName,
     db: collection.collection.dbName,
     collection: collection.collection.collectionName

package/src/Db.ts

@@ -18,7 +18,7 @@ export const documentCollection: {
 } = F.dual(
   (args) => isDb(args[0]),
   (db: Db, name: string): DocumentCollection.DocumentCollection =>
-    new DocumentCollection.DocumentCollection({
+    new DocumentCollection.DocumentCollectionImpl({
       collection: db.collection(name)
     })
 )
@@ -67,7 +67,7 @@ export const listCollections: {
 } = F.dual(
   (args) => isDb(args[0]),
   (db: Db, filter?: Document, options?: ListCollectionsOptions): ListCollectionsCursor.ListCollectionsCursor =>
-    new ListCollectionsCursor.ListCollectionsCursor({ cursor: db.listCollections(filter, options) })
+    new ListCollectionsCursor.ListCollectionsCursorImpl({ cursor: db.listCollections(filter, options) })
 )
 
 export const dropCollection: {

package/src/DocumentAggregationCursor.ts

@@ -4,14 +4,27 @@
 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 { AggregationCursor as MongoAggregationCursor, Document } from "mongodb"
 import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export class DocumentAggregationCursor
-  extends Data.TaggedClass("DocumentAggregationCursor")<{ cursor: MongoAggregationCursor<Document> }>
+type DocumentAggregationCursorFields = { cursor: MongoAggregationCursor<Document> }
+
+export interface DocumentAggregationCursor extends DocumentAggregationCursorFields, Pipeable {
+  _tag: "DocumentAggregationCursor"
+}
+
+/** @internal */
+export class DocumentAggregationCursorImpl
+  extends Data.TaggedClass("DocumentAggregationCursor")<DocumentAggregationCursorFields>
+  implements DocumentAggregationCursor
 {
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const toArray = (
@@ -32,7 +45,7 @@ export const toStream = (
 
 const errorSource = (cursor: DocumentAggregationCursor, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: DocumentAggregationCursor.name,
+    module: DocumentAggregationCursorImpl.name,
     functionName,
     db: cursor.cursor.namespace.db,
     collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"

package/src/DocumentCollection.ts

@@ -6,6 +6,8 @@ import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as F from "effect/Function"
 import * as O from "effect/Option"
+import type { Pipeable } from "effect/Pipeable"
+import { pipeArguments } from "effect/Pipeable"
 import type * as Schema from "effect/Schema"
 import type {
   AggregateOptions,
@@ -43,9 +45,21 @@ import type { ModifyResult } from "./internal/modify-result.js"
 import { mongoErrorOrDie } from "./internal/mongo-error.js"
 import * as MongoError from "./MongoError.js"
 
-export class DocumentCollection extends Data.TaggedClass("DocumentCollection")<{
+type DocumentCollectionFields = {
   collection: MongoCollection
-}> {
+}
+
+export interface DocumentCollection extends DocumentCollectionFields, Pipeable {
+  _tag: "DocumentCollection"
+}
+
+/** @internal */
+export class DocumentCollectionImpl extends Data.TaggedClass("DocumentCollection")<DocumentCollectionFields>
+  implements DocumentCollection
+{
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const find: {
@@ -61,7 +75,7 @@ export const find: {
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
   (collection: DocumentCollection, filter?: Filter<Document>, options?: FindOptions) =>
-    new DocumentFindCursor.DocumentFindCursor(
+    new DocumentFindCursor.DocumentFindCursorImpl(
       {
         cursor: collection.collection.find(filter ?? {}, options)
       }
@@ -327,7 +341,7 @@ export const rename: {
   ): Effect.Effect<DocumentCollection, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.rename(newName, options)),
-      Effect.map((collection) => new DocumentCollection({ collection })),
+      Effect.map((collection) => new DocumentCollectionImpl({ collection })),
       Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "rename")))
     )
 )
@@ -431,7 +445,7 @@ export const aggregate: {
     pipeline?: ReadonlyArray<Document>,
     options?: AggregateOptions
   ): DocumentAggregationCursor.DocumentAggregationCursor =>
-    new DocumentAggregationCursor.DocumentAggregationCursor({
+    new DocumentAggregationCursor.DocumentAggregationCursorImpl({
       cursor: collection.collection.aggregate(pipeline ? [...pipeline] : undefined, options)
     })
 )
@@ -489,16 +503,17 @@ export const typed: {
 } = F.dual((args) => isDocumentCollection(args[0]), <A extends Document, I extends Document = A, R = never>(
   collection: DocumentCollection,
   schema: Schema.Schema<A, I, R>
-): Collection.Collection<A, I, R> => new Collection.Collection<A, I, R>({ collection: collection.collection, schema }))
+): Collection.Collection<A, I, R> =>
+  new Collection.CollectionImpl<A, I, R>({ collection: collection.collection, schema }))
 
-const isDocumentCollection = (x: unknown) => x instanceof DocumentCollection
+const isDocumentCollection = (x: unknown) => x instanceof DocumentCollectionImpl
 
 const errorSource = (
   collection: DocumentCollection,
   functionName: string
 ) =>
   new MongoError.CollectionErrorSource({
-    module: DocumentCollection.name,
+    module: DocumentCollectionImpl.name,
     functionName,
     db: collection.collection.dbName,
     collection: collection.collection.collectionName

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/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.1.4"
 
 export const getCurrentVersion = () => moduleVersion