@effect-app/infra 4.0.0-beta.17 → 4.0.0-beta.171

package/src/Model/query/new-kid-interpreter.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { Array, identity, Match, Option, pipe, S } from "effect-app"
+import { Array, identity, Match, Option, pipe, S, SchemaAST } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
 import { dropUndefinedT } from "effect-app/utils"
 import type { FilterResult } from "../filter/filterApi.js"
@@ -165,7 +165,7 @@ export const toFilter = <
   let select: (keyof TFieldValues | { key: string; subKeys: string[] })[] = []
   // TODO: support more complex (nested) schemas?
   if (schema) {
-    const t = walkTransformation(schema.ast)
+    const t = walkTransformation(SchemaAST.toEncoded(schema.ast))
     if (S.AST.isObjects(t)) {
       select = t.propertySignatures.map((_) => _.name as string)
       for (const prop of t.propertySignatures) {

package/src/Model.ts

@@ -1,3 +1,4 @@
 export * from "./Model/dsl.js"
 export * as Q from "./Model/query.js"
 export { makeRepo } from "./Model/Repository.js"
+export { type RegisteredRepository, RepositoryRegistry, RepositoryRegistryLive } from "./Model/Repository.js"

package/src/Operations.ts

@@ -1,6 +1,6 @@
 import { reportError } from "@effect-app/infra/errorReporter"
 import { subHours } from "date-fns"
-import { Cause, copy, Duration, Effect, Exit, type Fiber, Layer, Option, S, Schedule, ServiceMap } from "effect-app"
+import { Cause, Context, copy, Duration, Effect, Exit, type Fiber, Layer, Option, S, Schedule } from "effect-app"
 import { annotateLogscoped } from "effect-app/Effect"
 import { dual, pipe } from "effect-app/Function"
 import { Operation, OperationFailure, OperationId, type OperationProgress, OperationSuccess } from "effect-app/Operations"
@@ -20,6 +20,33 @@ const make = Effect.gen(function*() {
   const reqFiberSet = yield* RequestFiberSet
   const makeOp = Effect.sync(() => OperationId.make())
 
+  const addOp = Effect.fnUntraced(function*(id: OperationId, title: NonEmptyString2k) {
+    return yield* repo.save(Operation.make({ id, title })).pipe(Effect.orDie)
+  })
+
+  const finishOp = Effect.fnUntraced(function*(id: OperationId, exit: Exit.Exit<unknown, unknown>) {
+    const op = yield* repo.get(id).pipe(Effect.orDie)
+    const result = Exit.isSuccess(exit)
+      ? OperationSuccess.make({})
+      : OperationFailure.make({
+        message: Cause.hasInterruptsOnly(exit.cause)
+          ? NonEmptyString2k("Interrupted")
+          : Cause.hasDies(exit.cause)
+          ? NonEmptyString2k("Unknown error")
+          : Cause
+            .findErrorOption(exit.cause)
+            .pipe(
+              Option.flatMap((_) =>
+                typeof _ === "object" && _ !== null && "message" in _ && S.is(NonEmptyString2k)(_.message)
+                  ? Option.some(_.message)
+                  : Option.none()
+              ),
+              Option.getOrNull
+            )
+      })
+    return yield* repo.save(copy(op, { updatedAt: new Date(), result })).pipe(Effect.orDie)
+  })
+
   const register = (title: NonEmptyString2k) =>
     Effect.tap(
       makeOp,
@@ -30,53 +57,20 @@ const make = Effect.gen(function*() {
         )
     )
 
-  const cleanup = Effect.sync(() => subHours(new Date(), 1)).pipe(
-    Effect.andThen((before) => repo.query(where("updatedAt", "lt", before.toISOString()))),
-    Effect.andThen((ops) => pipe(ops, batch(100, Effect.succeed, (items) => repo.removeAndPublish(items)))),
-    setupRequestContextFromCurrent("Operations.cleanup")
-  )
+  const cleanup = Effect
+    .gen(function*() {
+      const before = subHours(new Date(), 1)
+      const ops = yield* repo.query(where("updatedAt", "lt", before.toISOString()))
+      return yield* pipe(ops, batch(100, Effect.succeed, (items) => repo.removeAndPublish(items)))
+    })
+    .pipe(setupRequestContextFromCurrent("Operations.cleanup"))
 
-  function addOp(id: OperationId, title: NonEmptyString2k) {
-    return repo.save(new Operation({ id, title })).pipe(Effect.orDie)
-  }
-  function findOp(id: OperationId) {
-    return repo.find(id)
-  }
-  function finishOp(id: OperationId, exit: Exit.Exit<unknown, unknown>) {
-    return Effect
-      .flatMap(repo.get(id).pipe(Effect.orDie), (_) =>
-        repo
-          .save(
-            copy(_, {
-              updatedAt: new Date(),
-              result: Exit.isSuccess(exit)
-                ? new OperationSuccess()
-                : new OperationFailure({
-                  message: Cause.hasInterruptsOnly(exit.cause)
-                    ? NonEmptyString2k("Interrupted")
-                    : Cause.hasDies(exit.cause)
-                    ? NonEmptyString2k("Unknown error")
-                    : Cause
-                      .findErrorOption(exit.cause)
-                      .pipe(
-                        Option.flatMap((_) =>
-                          typeof _ === "object" && _ !== null && "message" in _ && S.is(NonEmptyString2k)(_.message)
-                            ? Option.some(_.message)
-                            : Option.none()
-                        ),
-                        Option.getOrNull
-                      )
-                })
-            })
-          )
-          .pipe(Effect.orDie))
-  }
-  function update(id: OperationId, progress: OperationProgress) {
-    return Effect.flatMap(
-      repo.get(id).pipe(Effect.orDie),
-      (_) => repo.save(copy(_, { updatedAt: new Date(), progress })).pipe(Effect.orDie)
-    )
-  }
+  const findOp = (id: OperationId) => repo.find(id)
+
+  const update = Effect.fnUntraced(function*(id: OperationId, progress: OperationProgress) {
+    const op = yield* repo.get(id).pipe(Effect.orDie)
+    return yield* repo.save(copy(op, { updatedAt: new Date(), progress })).pipe(Effect.orDie)
+  })
 
   function fork<R, R2, E, E2, A, A2>(
     self: (id: OperationId) => Effect.Effect<A, E, R>,
@@ -87,29 +81,18 @@ const make = Effect.gen(function*() {
     never,
     Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>
   > {
-    return Effect
-      .flatMap(
-        Scope.make(),
-        (scope) =>
-          register(title)
-            .pipe(
-              Scope.provide(scope),
-              Effect.flatMap((id) =>
-                reqFiberSet
-                  .forkDaemonReportUnexpected(Scope.use(
-                    self(id).pipe(Effect.withSpan(title, {}, { captureStackTrace: false })),
-                    scope
-                  ))
-                  .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
-              ),
-              Effect.tap(({ id }) =>
-                Effect.interruptible(fnc(id)).pipe(
-                  Effect.forkScoped,
-                  Scope.provide(scope)
-                )
-              )
-            )
+    return Effect.gen(function*() {
+      const scope = yield* Scope.make()
+      const id = yield* Scope.provide(register(title), scope)
+      const fiber = yield* reqFiberSet.forkDaemonReportUnexpected(
+        Scope.use(
+          self(id).pipe(Effect.withSpan(title, {}, { captureStackTrace: false })),
+          scope
+        )
       )
+      yield* Scope.provide(Effect.forkScoped(Effect.interruptible(fnc(id))), scope)
+      return { fiber, id } satisfies RunningOperation<A, E>
+    })
   }
 
   const fork2: {
@@ -122,24 +105,20 @@ const make = Effect.gen(function*() {
     ): Effect.Effect<RunningOperation<A, E>, never, Exclude<R, Scope.Scope>>
   } = dual(
     2,
-    <R, E, A>(self: (opId: OperationId) => Effect.Effect<A, E, R>, title: NonEmptyString2k) =>
-      Effect.flatMap(
-        Scope.make(),
-        (scope) =>
-          register(title)
-            .pipe(
-              Scope.provide(scope),
-              Effect
-                .flatMap((id) =>
-                  reqFiberSet
-                    .forkDaemonReportUnexpected(Scope.use(
-                      self(id).pipe(Effect.withSpan(title, {}, { captureStackTrace: false })),
-                      scope
-                    ))
-                    .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
-                )
-            )
+    Effect.fnUntraced(function*<R, E, A>(
+      self: (opId: OperationId) => Effect.Effect<A, E, R>,
+      title: NonEmptyString2k
+    ) {
+      const scope = yield* Scope.make()
+      const id = yield* Scope.provide(register(title), scope)
+      const fiber = yield* reqFiberSet.forkDaemonReportUnexpected(
+        Scope.use(
+          self(id).pipe(Effect.withSpan(title, {}, { captureStackTrace: false })),
+          scope
+        )
       )
+      return { fiber, id } satisfies RunningOperation<A, E>
+    })
   )
 
   const forkOperation: {
@@ -152,28 +131,21 @@ const make = Effect.gen(function*() {
     ): Effect.Effect<RunningOperation<A, E>, never, Exclude<R, Scope.Scope>>
   } = dual(
     2,
-    <R, E, A>(self: Effect.Effect<A, E, R>, title: NonEmptyString2k) =>
-      Effect.flatMap(
-        Scope.make(),
-        (scope) =>
-          register(title)
-            .pipe(
-              Scope.provide(scope),
-              Effect
-                .flatMap((id) =>
-                  reqFiberSet
-                    .forkDaemonReportUnexpected(Scope.use(
-                      self.pipe(Effect.withSpan(title, {}, { captureStackTrace: false })),
-                      scope
-                    ))
-                    .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
-                )
-            )
+    Effect.fnUntraced(function*<R, E, A>(self: Effect.Effect<A, E, R>, title: NonEmptyString2k) {
+      const scope = yield* Scope.make()
+      const id = yield* Scope.provide(register(title), scope)
+      const fiber = yield* reqFiberSet.forkDaemonReportUnexpected(
+        Scope.use(
+          self.pipe(Effect.withSpan(title, {}, { captureStackTrace: false })),
+          scope
+        )
       )
+      return { fiber, id } satisfies RunningOperation<A, E>
+    })
   )
 
   function forkOperationFunction<R, E, A, Inp>(fnc: (inp: Inp) => Effect.Effect<A, E, R>, title: NonEmptyString2k) {
-    return (inp: Inp) => fnc(inp).pipe((_) => forkOperation(_, title))
+    return (inp: Inp) => forkOperation(fnc(inp), title)
   }
 
   return {
@@ -189,19 +161,12 @@ const make = Effect.gen(function*() {
   }
 })
 
-export class Operations extends ServiceMap.Opaque<Operations>()("effect-app/Operations", { make }) {
+export class Operations extends Context.Opaque<Operations>()("effect-app/Operations", { make }) {
   private static readonly CleanupLive = this
     .use((_) =>
       _.cleanup.pipe(
         Effect.exit,
-        Effect
-          .flatMap((_) => {
-            if (Exit.isSuccess(_)) {
-              return Effect.void
-            } else {
-              return reportAppError(_.cause)
-            }
-          }),
+        Effect.flatMap((exit) => Exit.isSuccess(exit) ? Effect.void : reportAppError(exit.cause)),
         Effect.schedule(Schedule.fixed(Duration.minutes(20))),
         Effect.map((_) => _ as never),
         MainFiberSet.run

package/src/OperationsRepo.ts

@@ -1,8 +1,8 @@
-import { Effect, ServiceMap } from "effect-app"
+import { Context, Effect } from "effect-app"
 import { Operation } from "effect-app/Operations"
 import { makeRepo } from "./Model.js"
 
-export class OperationsRepo extends ServiceMap.Service<OperationsRepo>()(
+export class OperationsRepo extends Context.Service<OperationsRepo>()(
   "OperationRepo",
   {
     make: Effect.gen(function*() {

package/src/QueueMaker/SQLQueue.ts

@@ -3,17 +3,17 @@ import { reportNonInterruptedFailure } from "@effect-app/infra/QueueMaker/errors
 import { type QueueBase, QueueMeta } from "@effect-app/infra/QueueMaker/service"
 import { subMinutes } from "date-fns"
 import { Effect, Fiber, type NonEmptyReadonlyArray, Option, S, Tracer } from "effect-app"
-import type { NonEmptyString255 } from "effect-app/Schema"
+import { type NonEmptyString255 } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
 import { SqlClient } from "effect/unstable/sql"
 import { SQLModel } from "../adapters/SQL.js"
 import { InfraLogger } from "../logger.js"
 
-export const QueueId = S.Number.pipe(S.brand("QueueId"))
+export const QueueId = S.Finite.pipe(S.brand("QueueId"))
 export type QueueId = typeof QueueId.Type
 
 // TODO: let the model track and Auto Generate versionColumn on every update instead
-export function makeSQLQueue<
+export const makeSQLQueue = Effect.fnUntraced(function*<
   Evt extends { id: S.StringId; _tag: string },
   DrainEvt extends { id: S.StringId; _tag: string },
   EvtE,
@@ -24,166 +24,136 @@ export function makeSQLQueue<
   schema: S.Codec<Evt, EvtE>,
   drainSchema: S.Codec<DrainEvt, DrainEvtE>
 ) {
-  return Effect.gen(function*() {
-    const base = {
-      id: SQLModel.Generated(QueueId),
-      meta: SQLModel.JsonFromString(QueueMeta),
-      name: S.NonEmptyString255,
-      createdAt: SQLModel.DateTimeInsert,
-      updatedAt: SQLModel.DateTimeUpdate,
-      // TODO: at+owner
-      processingAt: SQLModel.FieldOption(S.Date),
-      finishedAt: SQLModel.FieldOption(S.Date),
-      etag: S.String // TODO: use a SQLModel thing that auto updates it?
-      // TODO: record locking.. / optimistic locking
-      // rowVersion: SQLModel.DateTimeFromNumberWithNow
-    }
-    class Queue extends SQLModel.Class<Queue>("Queue")({
-      body: SQLModel.JsonFromString(schema),
-      ...base
-    }) {}
-    class Drain extends SQLModel.Class<Drain>("Drain")({
-      body: SQLModel.JsonFromString(drainSchema),
-      ...base
-    }) {}
-    const sql = yield* SqlClient.SqlClient
+  const base = {
+    id: SQLModel.Generated(QueueId),
+    meta: SQLModel.JsonFromString(QueueMeta),
+    name: S.NonEmptyString255,
+    createdAt: SQLModel.DateTimeInsert,
+    updatedAt: SQLModel.DateTimeUpdate,
+    // TODO: at+owner
+    processingAt: SQLModel.FieldOption(S.Date),
+    finishedAt: SQLModel.FieldOption(S.Date),
+    etag: S.String // TODO: use a SQLModel thing that auto updates it?
+    // TODO: record locking.. / optimistic locking
+    // rowVersion: SQLModel.DateTimeFromNumberWithNow
+  }
+  class Queue extends SQLModel.Class<Queue>("Queue")({
+    body: SQLModel.JsonFromString(schema),
+    ...base
+  }) {}
+  class Drain extends SQLModel.Class<Drain>("Drain")({
+    body: SQLModel.JsonFromString(drainSchema),
+    ...base
+  }) {}
+  const sql = yield* SqlClient.SqlClient
 
-    const queueRepo = yield* SQLModel.makeRepository(Queue, {
-      tableName: "queue",
-      spanPrefix: "QueueRepo",
-      idColumn: "id",
-      versionColumn: "etag"
-    })
+  const queueRepo = yield* SQLModel.makeRepository(Queue, {
+    tableName: "queue",
+    spanPrefix: "QueueRepo",
+    idColumn: "id",
+    versionColumn: "etag"
+  })
 
-    const drainRepo = yield* SQLModel.makeRepository(Drain, {
-      tableName: "queue",
-      spanPrefix: "DrainRepo",
-      idColumn: "id",
-      versionColumn: "etag"
-    })
+  const drainRepo = yield* SQLModel.makeRepository(Drain, {
+    tableName: "queue",
+    spanPrefix: "DrainRepo",
+    idColumn: "id",
+    versionColumn: "etag"
+  })
 
-    const decodeDrain = S.decodeEffect(Drain)
+  const decodeDrain = S.decodeEffectConcurrently(Drain)
 
-    const drain = Effect
-      .sync(() => subMinutes(new Date(), 15))
-      .pipe(
-        Effect
-          .andThen((limit) =>
-            sql<typeof Drain.Encoded>`SELECT *
+  const drain = Effect.gen(function*() {
+    const limit = subMinutes(new Date(), 15)
+    return yield* sql<typeof Drain.Encoded>`SELECT *
     FROM queue
     WHERE name = ${queueDrainName} AND finishedAt IS NULL AND (processingAt IS NULL OR processingAt < ${limit.getTime()})
     LIMIT 1`
-          )
-      )
+  })
 
-    const q = {
-      offer: Effect.fnUntraced(function*(body: Evt, meta: typeof QueueMeta.Type) {
-        yield* queueRepo.insertVoid({
-          body,
-          meta,
-          name: queueName,
-          processingAt: Option.none(),
-          finishedAt: Option.none(),
-          etag: crypto.randomUUID()
-        })
-      }),
-      take: Effect.gen(function*() {
-        while (true) {
-          const [first] = yield* drain.pipe(Effect.withTracerEnabled(false)) // disable sql tracer otherwise we spam it..
-          if (first) {
-            const dec = yield* decodeDrain(first)
-            const { createdAt, updatedAt, ...rest } = dec
-            return yield* drainRepo.update(
-              { ...rest, processingAt: Option.some(new Date()) } // auto in lib , etag: crypto.randomUUID()
-            )
-          }
-          if (first) return first
-          yield* Effect.sleep(250)
+  const q = {
+    offer: Effect.fnUntraced(function*(body: Evt, meta: typeof QueueMeta.Type) {
+      yield* queueRepo.insertVoid(Queue.insert.make({
+        body,
+        meta,
+        name: queueName,
+        processingAt: Option.none(),
+        finishedAt: Option.none(),
+        etag: crypto.randomUUID()
+      }))
+    }),
+    take: Effect.gen(function*() {
+      while (true) {
+        const [first] = yield* drain.pipe(Effect.withTracerEnabled(false)) // disable sql tracer otherwise we spam it..
+        if (first) {
+          const dec = yield* decodeDrain(first)
+          const { createdAt, updatedAt, ...rest } = dec
+          return yield* drainRepo.update(
+            Drain.update.make({ ...rest, processingAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
+          )
         }
-      }),
-      finish: ({ createdAt, updatedAt, ...q }: Drain) =>
-        drainRepo.updateVoid({ ...q, finishedAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
-    }
-    const queue = {
-      publish: (...messages: NonEmptyReadonlyArray<Evt>) =>
-        getRequestContext
+        if (first) return first
+        yield* Effect.sleep(250)
+      }
+    }),
+    finish: Effect.fn(function*({ createdAt, updatedAt, ...q }: Drain) {
+      return yield* drainRepo.updateVoid(Drain.update.make({ ...q, finishedAt: Option.some(new Date()) })) // auto in lib , etag: crypto.randomUUID()
+    })
+  }
+  const queue = {
+    publish: Effect.fn("queue.publish: " + queueName, { kind: "producer" })(function*(
+      ...messages: NonEmptyReadonlyArray<Evt>
+    ) {
+      yield* Effect.annotateCurrentSpan({ "message_tags": messages.map((_) => _._tag) })
+      const requestContext = yield* getRequestContext
+      yield* Effect.forEach(messages, (m) => q.offer(m, requestContext), { discard: true })
+    }),
+    drain: <DrainE, DrainR>(
+      handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
+      sessionId?: string
+    ) => {
+      const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
+      const processMessage = Effect.fnUntraced(function*({ body, meta }: Drain) {
+        let effect = InfraLogger
+          .logDebug(`[${queueDrainName}] Processing incoming message`)
           .pipe(
-            Effect.flatMap((requestContext) =>
-              Effect
-                .forEach(
-                  messages,
-                  (m) => q.offer(m, requestContext),
-                  {
-                    discard: true
+            Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
+            Effect.andThen(handleEvent(body)),
+            silenceAndReportError,
+            (_) =>
+              setupRequestContextWithCustomSpan(
+                _,
+                meta,
+                `queue.drain: ${queueDrainName}.${body._tag}`,
+                {
+                  captureStackTrace: false,
+                  kind: "consumer",
+                  attributes: {
+                    "queue.name": queueDrainName,
+                    "queue.sessionId": sessionId,
+                    "queue.input": body
                   }
-                )
-            ),
-            Effect.withSpan("queue.publish: " + queueName, {
-              kind: "producer",
-              attributes: { "message_tags": messages.map((_) => _._tag) }
-            }, { captureStackTrace: false })
-          ),
-      drain: <DrainE, DrainR>(
-        handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-        sessionId?: string
-      ) => {
-        const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
-        const processMessage = (msg: Drain) =>
-          Effect
-            .succeed(msg)
-            .pipe(Effect
-              .flatMap(({ body, meta }) => {
-                let effect = InfraLogger
-                  .logDebug(`[${queueDrainName}] Processing incoming message`)
-                  .pipe(
-                    Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-                    Effect.andThen(handleEvent(body)),
-                    silenceAndReportError,
-                    (_) =>
-                      setupRequestContextWithCustomSpan(
-                        _,
-                        meta,
-                        `queue.drain: ${queueDrainName}.${body._tag}`,
-                        {
-                          captureStackTrace: false,
-                          kind: "consumer",
-                          attributes: {
-                            "queue.name": queueDrainName,
-                            "queue.sessionId": sessionId,
-                            "queue.input": body
-                          }
-                        }
-                      )
-                  )
-                if (meta.span) {
-                  effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
                 }
-                return effect
-              }))
-
-        return q
-          .take
-          .pipe(
-            Effect.flatMap((x) =>
-              processMessage(x).pipe(
-                Effect.uninterruptible,
-                Effect.forkChild,
-                Effect.flatMap(Fiber.join),
-                Effect.tap(q.finish(x))
               )
-            ),
-            silenceAndReportError,
-            Effect.withSpan(`queue.drain: ${queueDrainName}`, {
-              attributes: {
-                "queue.type": "sql",
-                "queue.name": queueDrainName,
-                "queue.sessionId": sessionId
-              }
-            }),
-            Effect.forever
           )
-      }
+        if (meta.span) {
+          effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
+        }
+        return yield* effect
+      })
+
+      return Effect.fn(`queue.drain: ${queueDrainName}`, {
+        attributes: { "queue.type": "sql", "queue.name": queueDrainName, "queue.sessionId": sessionId }
+      })(function*() {
+        const x = yield* q.take
+        yield* processMessage(x).pipe(
+          Effect.uninterruptible,
+          Effect.forkChild,
+          Effect.flatMap(Fiber.join),
+          Effect.tap(q.finish(x))
+        )
+      }, (effect) => effect.pipe(silenceAndReportError, Effect.forever))()
     }
-    return queue as QueueBase<Evt, DrainEvt>
-  })
-}
+  }
+  return queue as QueueBase<Evt, DrainEvt>
+})