effect-mongodb 0.0.2 → 0.0.4

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/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/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/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.2"
+let moduleVersion = "0.0.4"
 
 export const getCurrentVersion = () => moduleVersion