@effect-app/infra 2.0.1 → 2.1.0

package/src/services/adapters/SQL.ts

@@ -0,0 +1 @@
+export * as Model from "./SQL/Model.js"

package/src/services/adapters/ServiceBus.ts

@@ -0,0 +1,140 @@
+import type {
+  OperationOptionsBase,
+  ProcessErrorArgs,
+  ServiceBusMessage,
+  ServiceBusMessageBatch,
+  ServiceBusReceivedMessage,
+  ServiceBusReceiver,
+  ServiceBusSender
+} from "@azure/service-bus"
+import { ServiceBusClient } from "@azure/service-bus"
+import type { Scope } from "effect-app"
+import { Cause, Context, Effect, Exit, FiberSet, Layer } from "effect-app"
+import { InfraLogger } from "./logger.js"
+
+function makeClient(url: string) {
+  return Effect.acquireRelease(
+    Effect.sync(() => new ServiceBusClient(url)),
+    (client) => Effect.promise(() => client.close())
+  )
+}
+
+const Client = Context.GenericTag<ServiceBusClient>("@services/Client")
+export const LiveServiceBusClient = (url: string) => Layer.scoped(Client)(makeClient(url))
+
+function makeSender(queueName: string) {
+  return Effect.gen(function*() {
+    const serviceBusClient = yield* Client
+
+    return yield* Effect.acquireRelease(
+      Effect.sync(() => serviceBusClient.createSender(queueName)),
+      (subscription) => Effect.promise(() => subscription.close())
+    )
+  })
+}
+export const Sender = Context.GenericTag<ServiceBusSender>("@services/Sender")
+
+export function LiveSender(queueName: string) {
+  return Layer
+    .scoped(Sender, makeSender(queueName))
+}
+
+function makeReceiver(queueName: string, waitTillEmpty: Effect<void>, sessionId?: string) {
+  return Effect.gen(function*() {
+    const serviceBusClient = yield* Client
+
+    return yield* Effect.acquireRelease(
+      sessionId
+        ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
+        : Effect.sync(() => serviceBusClient.createReceiver(queueName)),
+      (r) => waitTillEmpty.pipe(Effect.andThen(Effect.promise(() => r.close())))
+    )
+  })
+}
+
+export class ServiceBusReceiverFactory extends Context.TagId(
+  "ServiceBusReceiverFactory"
+)<ServiceBusReceiverFactory, {
+  make: (waitTillEmpty: Effect<void>) => Effect<ServiceBusReceiver, never, Scope>
+  makeSession: (sessionId: string, waitTillEmpty: Effect<void>) => Effect<ServiceBusReceiver, never, Scope>
+}>() {
+  static readonly Live = (queueName: string) =>
+    this.toLayer(Client.pipe(Effect.andThen((cl) => ({
+      make: (waitTillEmpty: Effect<void>) =>
+        makeReceiver(queueName, waitTillEmpty).pipe(Effect.provideService(Client, cl)),
+      makeSession: (sessionId: string, waitTillEmpty: Effect<void>) =>
+        makeReceiver(queueName, waitTillEmpty, sessionId).pipe(Effect.provideService(Client, cl))
+    }))))
+}
+
+export function sendMessages(
+  messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
+  options?: OperationOptionsBase
+) {
+  return Effect.gen(function*() {
+    const s = yield* Sender
+    return yield* Effect.promise(() => s.sendMessages(messages, options))
+  })
+}
+
+export function subscribe<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
+  return Effect.gen(function*() {
+    const rf = yield* ServiceBusReceiverFactory
+    const fs = yield* FiberSet.make()
+    const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
+    const wait = Effect.gen(function*() {
+      if ((yield* FiberSet.size(fs)) > 0) {
+        yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
+      }
+      while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
+    })
+    const r = yield* sessionId
+      ? rf.makeSession(
+        sessionId,
+        wait
+      )
+      : rf.make(wait)
+
+    const runEffect = <E>(effect: Effect<void, E, RMsg | RErr>) =>
+      new Promise<void>((resolve, reject) =>
+        fr(effect)
+          .addObserver((exit) => {
+            if (Exit.isSuccess(exit)) {
+              resolve(exit.value)
+            } else {
+              reject(Cause.pretty(exit.cause, { renderErrorCause: true }))
+            }
+          })
+      )
+    yield* Effect.acquireRelease(
+      Effect.sync(() =>
+        r.subscribe({
+          processError: (err) =>
+            runEffect(
+              hndlr
+                .processError(err)
+                .pipe(Effect.catchAllCause((cause) => Effect.logError("ServiceBus Error", cause)))
+            ),
+          processMessage: (msg) => runEffect(hndlr.processMessage(msg))
+          // DO NOT CATCH ERRORS here as they should return to the queue!
+        })
+      ),
+      (subscription) => Effect.promise(() => subscription.close())
+    )
+  })
+}
+
+export interface MessageHandlers<RMsg, RErr> {
+  /**
+   * Handler that processes messages from service bus.
+   *
+   * @param message - A message received from Service Bus.
+   */
+  processMessage(message: ServiceBusReceivedMessage): Effect<void, never, RMsg>
+  /**
+   * Handler that processes errors that occur during receiving.
+   * @param args - The error and additional context to indicate where
+   * the error originated.
+   */
+  processError(args: ProcessErrorArgs): Effect<void, never, RErr>
+}

package/src/services/adapters/cosmos-client.ts

@@ -0,0 +1,16 @@
+import { CosmosClient as ComosClient_ } from "@azure/cosmos"
+import { Context, Effect, Layer } from "effect-app"
+
+const withClient = (url: string) => Effect.sync(() => new ComosClient_(url))
+
+export const makeCosmosClient = (url: string, dbName: string) =>
+  Effect.map(withClient(url), (x) => ({ db: x.database(dbName) }))
+
+export interface CosmosClient extends Effect.Success<ReturnType<typeof makeCosmosClient>> {}
+
+export const CosmosClient = Context.GenericTag<CosmosClient>("@services/CosmosClient")
+
+export const db = Effect.map(CosmosClient, (_) => _.db)
+
+export const CosmosClientLayer = (cosmosUrl: string, dbName: string) =>
+  Layer.effect(CosmosClient, makeCosmosClient(cosmosUrl, dbName))

package/src/services/adapters/logger.ts

@@ -0,0 +1,3 @@
+import { makeLog } from "effect-app/utils/logger"
+
+export const InfraLogger = makeLog("@effect-app/infra", "info")

package/src/services/adapters/memQueue.ts

@@ -0,0 +1,26 @@
+import { Context, Effect, type Queue } from "effect-app"
+import * as Q from "effect/Queue"
+
+const make = Effect
+  .gen(function*() {
+    const store = yield* Effect.sync(() => new Map<string, Queue.Queue<string>>())
+
+    return {
+      getOrCreateQueue: (k: string) =>
+        Effect.gen(function*() {
+          const q = store.get(k)
+          if (q) return q
+          const newQ = yield* Q.unbounded<string>()
+          store.set(k, newQ)
+          return newQ
+        })
+    }
+  })
+
+/**
+ * @tsplus type MemQueue
+ * @tsplus companion MemQueue.Ops
+ */
+export class MemQueue extends Context.TagMakeId("effect-app/MemQueue", make)<MemQueue>() {
+  static readonly Live = this.toLayer()
+}

package/src/services/adapters/mongo-client.ts

@@ -0,0 +1,23 @@
+import { Context, Effect, Layer } from "effect-app"
+import { MongoClient as MongoClient_ } from "mongodb"
+
+// TODO: we should probably share a single client...
+
+const withClient = (url: string) =>
+  Effect.acquireRelease(
+    Effect
+      .promise(() => {
+        const client = new MongoClient_(url)
+        return client.connect()
+      }),
+    (cl) => Effect.promise(() => cl.close()).pipe(Effect.uninterruptible, Effect.orDie)
+  )
+
+const makeMongoClient = (url: string, dbName?: string) => Effect.map(withClient(url), (x) => ({ db: x.db(dbName) }))
+
+export interface MongoClient extends Effect.Success<ReturnType<typeof makeMongoClient>> {}
+
+export const MongoClient = Context.GenericTag<MongoClient>("@services/MongoClient")
+
+export const MongoClientLive = (mongoUrl: string, dbName?: string) =>
+  Layer.scoped(MongoClient, makeMongoClient(mongoUrl, dbName))

package/src/services/adapters/redis-client.ts

@@ -0,0 +1,123 @@
+import { Context, Data, Effect, Layer, Option } from "effect-app"
+import type { RedisClient as Client } from "redis"
+import Redlock from "redlock"
+
+export class ConnectionException extends Data.TaggedError("ConnectionException")<{ cause: Error; message: string }> {
+  constructor(cause: Error) {
+    super({ message: "A connection error ocurred", cause })
+  }
+}
+
+export const makeRedisClient = (makeClient: () => Client) =>
+  Effect.acquireRelease(
+    Effect
+      .sync(() => {
+        const client = createClient(makeClient)
+        const lock = new Redlock([client])
+
+        function get(key: string) {
+          return Effect
+            .async<Option<string>, ConnectionException>((res) => {
+              client.get(key, (err, v) =>
+                err
+                  ? res(new ConnectionException(err))
+                  : res(Effect.sync(() => Option.fromNullable(v))))
+            })
+            .pipe(Effect.uninterruptible)
+        }
+
+        function set(key: string, val: string) {
+          return Effect
+            .async<void, ConnectionException>((res) => {
+              client.set(key, val, (err) =>
+                err
+                  ? res(new ConnectionException(err))
+                  : res(Effect.sync(() => void 0)))
+            })
+            .pipe(Effect.uninterruptible)
+        }
+
+        function hset(key: string, field: string, value: string) {
+          return Effect
+            .async<void, ConnectionException>((res) => {
+              client.hset(key, field, value, (err) =>
+                err
+                  ? res(new ConnectionException(err))
+                  : res(Effect.sync(() => void 0)))
+            })
+            .pipe(Effect.uninterruptible)
+        }
+
+        function hget(key: string, field: string) {
+          return Effect
+            .async<Option<string>, ConnectionException>((res) => {
+              client.hget(key, field, (err, v) =>
+                err
+                  ? res(new ConnectionException(err))
+                  : res(Effect.sync(() => Option.fromNullable(v))))
+            })
+            .pipe(Effect.uninterruptible)
+        }
+        function hmgetAll(key: string) {
+          return Effect
+            .async<Option<{ [key: string]: string }>, ConnectionException>(
+              (res) => {
+                client.hgetall(key, (err, v) =>
+                  err
+                    ? res(new ConnectionException(err))
+                    : res(Effect.sync(() => Option.fromNullable(v))))
+              }
+            )
+            .pipe(Effect.uninterruptible)
+        }
+
+        return {
+          client,
+          lock,
+
+          get,
+          hget,
+          hset,
+          hmgetAll,
+          set
+        }
+      }),
+    (cl) =>
+      Effect
+        .async<void, Error>((res) => {
+          cl.client.quit((err) => res(err ? Effect.fail(err) : Effect.void))
+        })
+        .pipe(Effect.uninterruptible, Effect.orDie)
+  )
+
+export interface RedisClient extends Effect.Success<ReturnType<typeof makeRedisClient>> {}
+
+export const RedisClient = Context.GenericTag<RedisClient>("@services/RedisClient")
+
+export const RedisClientLayer = (storageUrl: string) =>
+  Layer.scoped(RedisClient, makeRedisClient(makeRedis(storageUrl)))
+
+function createClient(makeClient: () => Client) {
+  const client = makeClient()
+  client.on("error", (error) => {
+    console.error(error)
+  })
+  return client
+}
+
+function makeRedis(storageUrl: string) {
+  const url = new URL(storageUrl)
+  const hostname = url.hostname
+  const password = url.password
+  return () =>
+    createClient(
+      storageUrl === "redis://"
+        ? ({
+          host: hostname,
+          port: 6380,
+          auth_pass: password,
+          tls: { servername: hostname }
+        } as any)
+        : (storageUrl as any)
+    )
+}

package/tsconfig.src.json

@@ -34,8 +34,5 @@
         {
             "path": "../prelude"
         },
-        {
-            "path": "../infra-adapters"
-        }
     ]
 }

package/src/services/Store/Redis.ts.bak

@@ -1,88 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { RedisClient, RedisClientLayer } from "@effect-app/infra-adapters/redis-client"
-import { Effect, Layer, Option, ReadonlyArray, Secret } from "effect-app"
-import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
-import { NotFoundError } from "../../errors.js"
-import { memFilter } from "./Memory.js"
-import type { PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
-import { StoreMaker } from "./service.js"
-import { makeETag, makeUpdateETag } from "./utils.js"
-
-function makeRedisStore({ prefix }: StorageConfig) {
-  return Effect.gen(function*($) {
-    const redis = yield* $(RedisClient)
-    return {
-      make: <Id extends string, PM extends PersistenceModelType<Id>, R = never, E = never>(
-        name: string,
-        seed?: Effect<Iterable<PM>, E, R>,
-        _config?: StoreConfig<PM>
-      ) =>
-        Effect.gen(function*($) {
-          const updateETag = makeUpdateETag(name)
-          // Very naive implementation of course.
-          const key = `${prefix}${name}`
-          const current = yield* $(redis.get(key).orDie)
-          if (!current.isSome()) {
-            const m = yield* $(seed ?? Effect.sync(() => []))
-            yield* $(
-              redis
-                .set(key, JSON.stringify({ data: [...m].map((e) => makeETag(e)) }))
-                .orDie
-            )
-          }
-          const get = redis
-            .get(key)
-            .flatMap((x) => x.mapError(() => new NotFoundError<"data">({ type: "data", id: "" })))
-            .orDie
-            .map((x) => JSON.parse(x) as { data: readonly PM[] })
-            .map((_) => _.data)
-
-          const set = (i: ReadonlyMap<Id, PM>) => redis.set(key, JSON.stringify({ data: [...i.values()] })).orDie
-
-          const sem = Effect.unsafeMakeSemaphore(1)
-          const withPermit = sem.withPermits(1)
-
-          const asMap = get.map((x) => new Map(x.map((x) => [x.id, x] as const)))
-          const all = get.map(Array.fromIterable)
-          const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
-            Effect
-              .forEach(items, (e) => s.find(e.id).flatMap((current) => updateETag(e, current)))
-              .tap((items) =>
-                asMap
-                  .map((m) => {
-                    const mut = m
-                    items.forEach((e) => mut.set(e.id, e))
-                    return mut
-                  })
-                  .flatMap(set)
-              )
-              .map((_) => _ as NonEmptyArray<PM>)
-              .pipe(withPermit)
-          const s: Store<PM, Id> = {
-            all,
-            filter: (f) => all.map(memFilter(f)),
-            find: (id) => asMap.map((_) => Option.fromNullable(_.get(id))),
-            set: (e) =>
-              s
-                .find(e.id)
-                .flatMap((current) => updateETag(e, current))
-                .tap((e) => asMap.map((_) => new Map([..._, [e.id, e]])).flatMap(set))
-                .pipe(withPermit),
-            batchSet,
-            bulkSet: batchSet,
-            remove: (e: PM) =>
-              asMap
-                .map((_) => new Map([..._].filter(([_]) => _ !== e.id)))
-                .flatMap(set)
-                .pipe(withPermit)
-          }
-          return s
-        })
-    }
-  })
-}
-export function RedisStoreLayer(cfg: StorageConfig) {
-  return StoreMaker
-    .toLayer(makeRedisStore(cfg))
-    .pipe(Layer.provide(RedisClientLayer(Secret.value(cfg.url))))
-}

package/src/services/simpledb/cosmosdb.ts.bak

@@ -1,149 +0,0 @@
-import type { IndexingPolicy } from "@azure/cosmos"
-import { typedKeysOf } from "effect-app/utils"
-
-import * as Cosmos from "@effect-app/infra-adapters/cosmos-client"
-import { Data, Effect, Option } from "effect-app"
-import type { CachedRecord, DBRecord } from "./shared.js"
-import { OptimisticLockException } from "./shared.js"
-import * as simpledb from "./simpledb.js"
-import type { Version } from "./simpledb.js"
-
-class CosmosDbOperationError extends Data.TaggedError("CosmosDbOperationError")<{ message: string }> {
-  constructor(message: string) {
-    super({ message })
-  }
-}
-
-const setup = (type: string, indexingPolicy: IndexingPolicy) =>
-  Cosmos.CosmosClient.tap(({ db }) =>
-    Effect.tryPromise(() =>
-      db
-        .containers
-        .create({ id: type, indexingPolicy })
-        .catch((err) => console.warn(err))
-    )
-  )
-// TODO: Error if current indexingPolicy does not match
-// Effect.flatMap((db) => Effect.tryPromise(() => db.container(type).(indexes)))
-export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>() {
-  return <REncode, RDecode, EDecode>(
-    type: string,
-    encode: (record: A) => Effect<EA, never, REncode>,
-    decode: (d: EA) => Effect<A, EDecode, RDecode>,
-    // schemaVersion: string,
-    indexes: IndexingPolicy
-  ) => {
-    return setup(type, indexes).map(() => ({
-      find: simpledb.find(find, decode, type),
-      findBy,
-      save: simpledb.storeDirectly(store, type)
-    }))
-
-    function find(id: string) {
-      return Cosmos
-        .CosmosClient
-        .flatMap(({ db }) => Effect.tryPromise(() => db.container(type).item(id).read<{ data: EA }>()))
-        .map((i) => Option.fromNullable(i.resource))
-        .map(
-          (_) =>
-            _.map(
-              ({ _etag, data }) => ({ version: _etag, data } as CachedRecord<EA>)
-            )
-        )
-    }
-
-    function findBy(parameters: Record<string, string>) {
-      return Cosmos
-        .CosmosClient
-        .flatMap(({ db }) =>
-          Effect.tryPromise(() =>
-            db
-              .container(type)
-              .items
-              .query({
-                query: `
-SELECT TOP 1 ${type}.id
-FROM ${type} i
-WHERE (
-  ${
-                  typedKeysOf(parameters)
-                    .map((k) => `i.${k} = @${k}`)
-                    .join(" and ")
-                }
-)
-`,
-                parameters: typedKeysOf(parameters).map((p) => ({
-                  name: `@${p}`,
-                  value: parameters[p]!
-                }))
-              })
-              .fetchAll()
-          )
-        )
-        .map((x) => x.resources.head)
-        .map((_) => _.map((_) => _.id))
-    }
-
-    function store(record: A, currentVersion: Option<Version>) {
-      return Effect.gen(function*($) {
-        const version = "_etag" // we get this from the etag anyway.
-
-        const { db } = yield* $(Cosmos.CosmosClient)
-        const data = yield* $(encode(record))
-
-        yield* $(
-          currentVersion.match(
-            {
-              onNone: () =>
-                Effect
-                  .tryPromise(() =>
-                    db.container(type).items.create({
-                      id: record.id,
-                      timestamp: new Date(),
-                      data
-                    })
-                  )
-                  .asUnit
-                  .orDie,
-              onSome: (currentVersion) =>
-                Effect
-                  .tryPromise(() =>
-                    db
-                      .container(type)
-                      .item(record.id)
-                      .replace(
-                        {
-                          id: record.id,
-                          timestamp: new Date(),
-                          data
-                        },
-                        {
-                          accessCondition: {
-                            type: "IfMatch",
-                            condition: currentVersion
-                          }
-                        }
-                      )
-                  )
-                  .orDie
-                  .flatMap((x) => {
-                    if (x.statusCode === 412) {
-                      return new OptimisticLockException(type, record.id)
-                    }
-                    if (x.statusCode > 299 || x.statusCode < 200) {
-                      return Effect.die(
-                        new CosmosDbOperationError(
-                          "not able to update record: " + x.statusCode
-                        )
-                      )
-                    }
-                    return Effect.unit
-                  })
-            }
-          )
-        )
-        return { version, data: record } as CachedRecord<A>
-      })
-    }
-  }
-}