effect-mongodb 0.0.2 → 0.0.3

package/src/FindCursor.ts

@@ -1,18 +1,17 @@
 /**
  * @since 0.0.1
  */
-import type * as ParseResult from "@effect/schema/ParseResult"
-import * as Schema from "@effect/schema/Schema"
 import * as Data from "effect/Data"
 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 * 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 * as MongoError from "./MongoError.js"
 
-import type * as E from "effect/Either"
-
 export class FindCursor<A, I = A, R = never> extends Data.TaggedClass("FindCursor")<{
   cursor: FindCursor_<unknown>
   schema: Schema.Schema<A, I, R>
@@ -21,32 +20,32 @@ export class FindCursor<A, I = A, R = never> extends Data.TaggedClass("FindCurso
 export const filter: {
   <T extends Document = Document>(
     filter: T
-  ): <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
-  <A, I = A, R = never, T extends Document = Document>(
+  ): <A, I, R>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  <A, I, R, T extends Document = Document>(
     cursor: FindCursor<A, I, R>,
     filter: T
   ): FindCursor<A, I, R>
 } = F.dual(
   (args) => isFindCursor(args[0]),
-  <A, I = A, R = never, T extends Document = Document>(
+  <A, I, R, T extends Document = Document>(
     cursor: FindCursor<A, I, R>,
     filter: T
   ): FindCursor<A, I, R> => new FindCursor({ cursor: cursor.cursor.filter(filter), schema: cursor.schema })
 )
 
 export const project: {
-  <B, BI = B, BR = never, T extends Document = Document>(
+  <B, BI, BR, T extends Document = Document>(
     newSchema: Schema.Schema<B, BI, BR>,
     value: T
-  ): <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => FindCursor<B, BI, BR>
-  <A, B, I = A, R = never, BI = B, BR = never, T extends Document = Document>(
+  ): <A, I, R>(cursor: FindCursor<A, I, R>) => FindCursor<B, BI, BR>
+  <A, B, I, R, BI, BR, T extends Document = Document>(
     cursor: FindCursor<A, I, R>,
     newSchema: Schema.Schema<B, BI, BR>,
     value: T
   ): FindCursor<B, BI, BR>
 } = F.dual(
   (args) => isFindCursor(args[0]),
-  <A, B, I = A, R = never, BI = B, BR = never, T extends Document = Document>(
+  <A, B, I, R, BI, BR, T extends Document = Document>(
     cursor: FindCursor<A, I, R>,
     newSchema: Schema.Schema<B, BI, BR>,
     value: T
@@ -57,15 +56,15 @@ export const sort: {
   (
     sort: Sort | string,
     direction?: SortDirection
-  ): <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
-  <A, I = A, R = never>(
+  ): <A, I, R>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
+  <A, I, R>(
     cursor: FindCursor<A, I, R>,
     sort: Sort | string,
     direction?: SortDirection
   ): FindCursor<A, I, R>
 } = F.dual(
   (args) => isFindCursor(args[0]),
-  <A, I = A, R = never>(
+  <A, I, R>(
     cursor: FindCursor<A, I, R>,
     sort: Sort | string,
     direction?: SortDirection
@@ -75,15 +74,16 @@ export const sort: {
 export const limit: {
   (
     value: number
-  ): <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => FindCursor<A, I, R>
-  <A, I = A, R = never>(cursor: FindCursor<A, I, R>, value: number): FindCursor<A, I, R>
+  ): <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]),
-  <A, I = A, R = never>(cursor: FindCursor<A, I, R>, value: number): FindCursor<A, I, R> =>
+  <A, I, R>(cursor: FindCursor<A, I, R>, value: number): FindCursor<A, I, R> =>
     new FindCursor({ cursor: cursor.cursor.limit(value), schema: cursor.schema })
 )
 
-export const toArray = <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => {
+// TODO: add explicit return type for public API
+export const toArray = <A, I, R>(cursor: FindCursor<A, I, 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,7 +91,8 @@ export const toArray = <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => {
   )
 }
 
-export const toArrayEither = <A, I = A, R = never>(cursor: FindCursor<A, I, R>) => {
+// TODO: add explicit return type for public API
+export const toArrayEither = <A, I, R>(cursor: FindCursor<A, I, 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")),
@@ -106,7 +107,7 @@ export const toArrayEither = <A, I = A, R = never>(cursor: FindCursor<A, I, R>)
   )
 }
 
-export const toStream = <A, I = A, R = never>(
+export const toStream = <A, I, R>(
   cursor: FindCursor<A, I, R>
 ): Stream.Stream<A, MongoError.MongoError | ParseResult.ParseError, R> => {
   const decode = Schema.decodeUnknown(cursor.schema)
@@ -117,7 +118,7 @@ export const toStream = <A, I = A, R = never>(
   )
 }
 
-export const toStreamEither = <A, I = A, R = never>(
+export const toStreamEither = <A, I, R>(
   cursor: FindCursor<A, I, R>
 ): Stream.Stream<E.Either<A, [document: unknown, error: ParseResult.ParseError]>, MongoError.MongoError, R> => {
   const decode = Schema.decodeUnknown(cursor.schema)

package/src/ListCollectionsCursor.ts

@@ -0,0 +1,45 @@
+/**
+ * @since 0.0.1
+ */
+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 {
+  CollectionInfo as MongoCollectionInfo,
+  ListCollectionsCursor as MongoListCollectionsCursor
+} from "mongodb"
+import * as MongoError from "./MongoError.js"
+
+export type NameOnlyCollectionInfo = Pick<MongoCollectionInfo, "name" | "type">
+export type FullCollectionInfo = MongoCollectionInfo
+
+type DefaultCollectionInfo = NameOnlyCollectionInfo | FullCollectionInfo
+
+export class ListCollectionsCursor<
+  T extends DefaultCollectionInfo = DefaultCollectionInfo
+> extends Data.TaggedClass("ListCollectionsCursor")<{
+  cursor: MongoListCollectionsCursor<T>
+}> {}
+
+export type NameOnlyListCollectionsCursor = ListCollectionsCursor<
+  Pick<MongoCollectionInfo, "name" | "type">
+>
+
+export type FullListCollectionsCursor = ListCollectionsCursor<MongoCollectionInfo>
+
+export const toArray = <T extends DefaultCollectionInfo>(
+  cursor: ListCollectionsCursor<T>
+): Effect.Effect<ReadonlyArray<T>, MongoError.MongoError> =>
+  F.pipe(
+    Effect.tryPromise({ try: () => cursor.cursor.toArray(), catch: F.identity }),
+    Effect.catchAll(MongoError.mongoErrorDie<ReadonlyArray<T>>(`${cursor._tag}.toArray error`))
+  )
+
+export const toStream = <T extends DefaultCollectionInfo>(
+  cursor: ListCollectionsCursor<T>
+): Stream.Stream<T, MongoError.MongoError> =>
+  F.pipe(
+    Stream.fromAsyncIterable(cursor.cursor, F.identity),
+    Stream.catchAll(MongoError.mongoErrorStream<T>(`${cursor._tag}.toStream error`))
+  )

package/src/index.ts

@@ -1,3 +1,8 @@
+/**
+ * @since 0.0.1
+ */
+export * as AggregationCursor from "./AggregationCursor.js"
+
 /**
  * @since 0.0.1
  */
@@ -8,6 +13,11 @@ export * as Collection from "./Collection.js"
  */
 export * as Db from "./Db.js"
 
+/**
+ * @since 0.0.1
+ */
+export * as DocumentAggregationCursor from "./DocumentAggregationCursor.js"
+
 /**
  * @since 0.0.1
  */
@@ -23,6 +33,11 @@ export * as DocumentFindCursor from "./DocumentFindCursor.js"
  */
 export * as FindCursor from "./FindCursor.js"
 
+/**
+ * @since 0.0.1
+ */
+export * as ListCollectionsCursor from "./ListCollectionsCursor.js"
+
 /**
  * @since 0.0.1
  */

package/src/internal/filter.ts

@@ -0,0 +1,9 @@
+import type { Condition, RootFilterOperators as MongoRootFilterOperators, WithId } from "mongodb"
+
+export type RootFilterOperators<TSchema> = Omit<MongoRootFilterOperators<TSchema>, "$where"> & { $where?: string }
+
+export type Filter<TSchema> =
+  & {
+    [P in keyof WithId<TSchema>]?: Condition<WithId<TSchema>[P]>
+  }
+  & RootFilterOperators<WithId<TSchema>>

package/src/internal/version.ts

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