@effect-app/infra 3.10.0 → 4.0.0-beta.1

package/src/Model/query/dsl.ts

@@ -115,7 +115,7 @@ export class Initial<TFieldValues extends FieldValues> extends Data.TaggedClass(
   constructor() {
     super({ value: "initial" as const })
   }
-  pipe() {
+  override pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
@@ -129,7 +129,7 @@ export class Where<TFieldValues extends FieldValues> extends Data.TaggedClass("w
 }> implements QueryWhere<TFieldValues> {
   readonly [QId]!: any
 
-  pipe() {
+  override pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
@@ -141,7 +141,7 @@ export class And<TFieldValues extends FieldValues> extends Data.TaggedClass("and
   relation: RelationDirection
 }> implements QueryWhere<TFieldValues> {
   readonly [QId]!: any
-  pipe() {
+  override pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
@@ -153,7 +153,7 @@ export class Or<TFieldValues extends FieldValues> extends Data.TaggedClass("or")
   relation: RelationDirection
 }> implements QueryWhere<TFieldValues> {
   readonly [QId]!: any
-  pipe() {
+  override pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
@@ -165,7 +165,7 @@ export class Page<TFieldValues extends FieldValues> extends Data.TaggedClass("pa
   skip?: number | undefined
 }> implements QueryEnd<TFieldValues> {
   readonly [QId]!: any
-  pipe() {
+  override pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
@@ -175,7 +175,7 @@ export class One<TFieldValues extends FieldValues> extends Data.TaggedClass("one
   current: Query<TFieldValues> | QueryWhere<any, TFieldValues> | QueryEnd<TFieldValues>
 }> implements QueryEnd<TFieldValues, "one"> {
   readonly [QId]!: any
-  pipe() {
+  override pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
@@ -185,7 +185,7 @@ export class Count<TFieldValues extends FieldValues> extends Data.TaggedClass("c
   current: Query<TFieldValues> | QueryWhere<any, TFieldValues> | QueryEnd<TFieldValues>
 }> implements QueryEnd<TFieldValues, "count"> {
   readonly [QId]!: any
-  pipe() {
+  override pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
@@ -200,7 +200,7 @@ export class Order<TFieldValues extends FieldValues, TFieldName extends FieldPat
   implements QueryEnd<TFieldValues>
 {
   readonly [QId]!: any
-  pipe() {
+  override pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
@@ -209,13 +209,13 @@ export class Order<TFieldValues extends FieldValues, TFieldName extends FieldPat
 export class Project<A, TFieldValues extends FieldValues, R, TType extends "one" | "many" = "many">
   extends Data.TaggedClass("project")<{
     current: Query<TFieldValues> | QueryWhere<any, TFieldValues> | QueryEnd<TFieldValues, TType>
-    schema: S.Schema<A, TFieldValues, R>
+    schema: S.Codec<A, TFieldValues, R>
     mode: "collect" | "project" | "transform"
   }>
   implements QueryProjection<TFieldValues, A, R>
 {
   readonly [QId]!: any
-  pipe() {
+  override pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
@@ -307,7 +307,7 @@ export const project: {
     R = never,
     E extends boolean = ExtractExclusiveness<Q>
   >(
-    schema: S.Schema<
+    schema: S.Codec<
       Option.Option<A>,
       {
         [K in keyof I]: K extends keyof ExtractFieldValuesRefined<Q> ? I[K] : never
@@ -326,7 +326,7 @@ export const project: {
     R = never,
     E extends boolean = ExtractExclusiveness<Q>
   >(
-    schema: S.Schema<
+    schema: S.Codec<
       A,
       {
         [K in keyof I]: K extends keyof ExtractFieldValuesRefined<Q> ? I[K] : never
@@ -344,7 +344,7 @@ export const project: {
     R = never,
     E extends boolean = ExtractExclusiveness<Q>
   >(
-    schema: S.Schema<
+    schema: S.Codec<
       A,
       {
         [K in keyof I]: K extends keyof ExtractFieldValuesRefined<Q> ? I[K] : never

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

@@ -10,7 +10,7 @@ import { make, type Q, type QAll } from "../query/dsl.js"
 
 type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
   filter: FilterResult[]
-  schema: S.Schema<A, TFieldValues, R> | undefined
+  schema: S.Codec<A, TFieldValues, R> | undefined
   limit: number | undefined
   skip: number | undefined
   order: { key: FieldPath<TFieldValues>; direction: "ASC" | "DESC" }[]
@@ -144,9 +144,9 @@ const interpret = <
   return data
 }
 
-const walkTransformation = (t: S.AST.AST) => {
-  if (S.AST.isTransformation(t)) {
-    return walkTransformation(t.from)
+const walkTransformation = (t: S.AST.AST): S.AST.AST => {
+  if (S.AST.isDeclaration(t) && t.typeParameters.length > 0) {
+    return walkTransformation(t.typeParameters[0]!)
   }
   return t
 }
@@ -166,10 +166,10 @@ export const toFilter = <
   // TODO: support more complex (nested) schemas?
   if (schema) {
     const t = walkTransformation(schema.ast)
-    if (S.AST.isTypeLiteral(t)) {
+    if (S.AST.isObjects(t)) {
       select = t.propertySignatures.map((_) => _.name as string)
       for (const prop of t.propertySignatures) {
-        if (S.AST.isTupleType(prop.type)) {
+        if (S.AST.isArrays(prop.type)) {
           // make sure we only select when there are actually type literals in the tuple...
           // otherwise we might be dealing with strings etc.
           // TODO; be more strict, can't support arrays with unions that have non TypeLiteral members etc..
@@ -178,8 +178,8 @@ export const toFilter = <
             subKeys: Array.flatMap(
               prop.type.rest,
               (x) => {
-                const t = walkTransformation(x.type)
-                return S.AST.isTypeLiteral(t) ? t.propertySignatures.map((y) => y.name as string) : []
+                const t = walkTransformation(x)
+                return S.AST.isObjects(t) ? t.propertySignatures.map((y) => y.name as string) : []
               }
             )
           }

package/src/Operations.ts

@@ -1,6 +1,6 @@
 import { reportError } from "@effect-app/infra/errorReporter"
 import { subHours } from "date-fns"
-import { Cause, Context, copy, Duration, Effect, Exit, type Fiber, Layer, Option, S, Schedule } from "effect-app"
+import { Cause, copy, Duration, Effect, Exit, type Fiber, Layer, Option, S, Schedule, ServiceMap } 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"
@@ -52,12 +52,12 @@ const make = Effect.gen(function*() {
               result: Exit.isSuccess(exit)
                 ? new OperationSuccess()
                 : new OperationFailure({
-                  message: Cause.isInterrupted(exit.cause)
+                  message: Cause.hasInterruptsOnly(exit.cause)
                     ? NonEmptyString2k("Interrupted")
-                    : Cause.isDie(exit.cause)
+                    : Cause.hasDies(exit.cause)
                     ? NonEmptyString2k("Unknown error")
                     : Cause
-                      .failureOption(exit.cause)
+                      .findErrorOption(exit.cause)
                       .pipe(
                         Option.flatMap((_) =>
                           typeof _ === "object" && _ !== null && "message" in _ && S.is(NonEmptyString2k)(_.message)
@@ -93,11 +93,11 @@ const make = Effect.gen(function*() {
         (scope) =>
           register(title)
             .pipe(
-              Scope.extend(scope),
+              Scope.provide(scope),
               Effect.flatMap((id) =>
                 reqFiberSet
                   .forkDaemonReportUnexpected(Scope.use(
-                    self(id).pipe(Effect.withSpan(title, { captureStackTrace: false })),
+                    self(id).pipe(Effect.withSpan(title, {}, { captureStackTrace: false })),
                     scope
                   ))
                   .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
@@ -105,7 +105,7 @@ const make = Effect.gen(function*() {
               Effect.tap(({ id }) =>
                 Effect.interruptible(fnc(id)).pipe(
                   Effect.forkScoped,
-                  Scope.extend(scope)
+                  Scope.provide(scope)
                 )
               )
             )
@@ -128,12 +128,12 @@ const make = Effect.gen(function*() {
         (scope) =>
           register(title)
             .pipe(
-              Scope.extend(scope),
+              Scope.provide(scope),
               Effect
                 .flatMap((id) =>
                   reqFiberSet
                     .forkDaemonReportUnexpected(Scope.use(
-                      self(id).pipe(Effect.withSpan(title, { captureStackTrace: false })),
+                      self(id).pipe(Effect.withSpan(title, {}, { captureStackTrace: false })),
                       scope
                     ))
                     .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
@@ -158,12 +158,12 @@ const make = Effect.gen(function*() {
         (scope) =>
           register(title)
             .pipe(
-              Scope.extend(scope),
+              Scope.provide(scope),
               Effect
                 .flatMap((id) =>
                   reqFiberSet
                     .forkDaemonReportUnexpected(Scope.use(
-                      self.pipe(Effect.withSpan(title, { captureStackTrace: false })),
+                      self.pipe(Effect.withSpan(title, {}, { captureStackTrace: false })),
                       scope
                     ))
                     .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
@@ -189,7 +189,7 @@ const make = Effect.gen(function*() {
   }
 })
 
-export class Operations extends Context.TagMakeId("effect-app/Operations", make)<Operations>() {
+export class Operations extends ServiceMap.Opaque<Operations>()("effect-app/Operations", { make }) {
   private static readonly CleanupLive = this
     .use((_) =>
       _.cleanup.pipe(
@@ -209,7 +209,10 @@ export class Operations extends Context.TagMakeId("effect-app/Operations", make)
     )
     .pipe(Layer.effectDiscard, Layer.provide(MainFiberSet.Live))
 
-  static readonly Live = this.CleanupLive.pipe(Layer.provideMerge(this.toLayer()), Layer.provide(RequestFiberSet.Live))
+  static readonly Live = this.CleanupLive.pipe(
+    Layer.provideMerge(this.toLayer(this.make)),
+    Layer.provide(RequestFiberSet.Live)
+  )
 
   static readonly forkOperation = (title: NonEmptyString2k) => <R, E, A>(self: Effect.Effect<A, E, R>) =>
     this.use((_) => _.forkOperation(self, title))
@@ -228,5 +231,5 @@ export class Operations extends Context.TagMakeId("effect-app/Operations", make)
 
 export interface RunningOperation<A, E> {
   id: OperationId
-  fiber: Fiber.RuntimeFiber<A, E>
+  fiber: Fiber.Fiber<A, E>
 }

package/src/OperationsRepo.ts

@@ -1,12 +1,11 @@
-import { Effect } from "effect-app"
+import { Effect, ServiceMap } from "effect-app"
 import { Operation } from "effect-app/Operations"
 import { makeRepo } from "./Model.js"
 
-// @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class OperationsRepo extends Effect.Service<OperationsRepo>()(
+export class OperationsRepo extends ServiceMap.Service<OperationsRepo>()(
   "OperationRepo",
   {
-    effect: Effect.gen(function*() {
+    make: Effect.gen(function*() {
       return yield* makeRepo("Operation", Operation, {
         config: {
           allowNamespace: () => true

package/src/QueueMaker/SQLQueue.ts

@@ -1,11 +1,12 @@
 import { getRequestContext, setupRequestContextWithCustomSpan } from "@effect-app/infra/api/setupRequest"
 import { reportNonInterruptedFailure } from "@effect-app/infra/QueueMaker/errors"
 import { type QueueBase, QueueMeta } from "@effect-app/infra/QueueMaker/service"
-import { SqlClient } from "@effect/sql"
+import { SqlClient } from "effect/unstable/sql"
 import { subMinutes } from "date-fns"
 import { Effect, Fiber, Option, S, Tracer } from "effect-app"
 import type { NonEmptyString255 } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
+import type { NonEmptyReadonlyArray } from "effect-app"
 import { SQLModel } from "../adapters/SQL.js"
 import { InfraLogger } from "../logger.js"
 
@@ -21,8 +22,8 @@ export function makeSQLQueue<
 >(
   queueName: NonEmptyString255,
   queueDrainName: NonEmptyString255,
-  schema: S.Schema<Evt, EvtE>,
-  drainSchema: S.Schema<DrainEvt, DrainEvtE>
+  schema: S.Codec<Evt, EvtE>,
+  drainSchema: S.Codec<DrainEvt, DrainEvtE>
 ) {
   return Effect.gen(function*() {
     const base = {
@@ -62,7 +63,7 @@ export function makeSQLQueue<
       versionColumn: "etag"
     })
 
-    const decodeDrain = S.decode(Drain)
+    const decodeDrain = S.decodeEffect(Drain)
 
     const drain = Effect
       .sync(() => subMinutes(new Date(), 15))
@@ -78,16 +79,14 @@ export function makeSQLQueue<
 
     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()
-          })
-        )
+        yield* queueRepo.insertVoid({
+          body,
+          meta,
+          name: queueName,
+          processingAt: Option.none(),
+          finishedAt: Option.none(),
+          etag: crypto.randomUUID()
+        })
       }),
       take: Effect.gen(function*() {
         while (true) {
@@ -96,7 +95,7 @@ export function makeSQLQueue<
             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()
+              { ...rest, processingAt: Option.some(new Date()) } // auto in lib , etag: crypto.randomUUID()
             )
           }
           if (first) return first
@@ -104,90 +103,88 @@ export function makeSQLQueue<
         }
       }),
       finish: ({ createdAt, updatedAt, ...q }: Drain) =>
-        drainRepo.updateVoid(Drain.update.make({ ...q, finishedAt: Option.some(new Date()) })) // auto in lib , etag: crypto.randomUUID()
+        drainRepo.updateVoid({ ...q, finishedAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
     }
-    return {
-      publish: (...messages) =>
-        Effect
-          .gen(function*() {
-            const requestContext = yield* getRequestContext
-            return yield* Effect
-              .forEach(
-                messages,
-                (m) => q.offer(m, requestContext),
-                {
-                  discard: true
-                }
-              )
-          })
+    const queue = {
+      publish: (...messages: NonEmptyReadonlyArray<Evt>) =>
+        getRequestContext
           .pipe(
+            Effect.flatMap((requestContext) =>
+              Effect
+                .forEach(
+                  messages,
+                  (m) => q.offer(m, requestContext),
+                  {
+                    discard: true
+                  }
+                )
+            ),
             Effect.withSpan("queue.publish: " + queueName, {
-              captureStackTrace: false,
               kind: "producer",
               attributes: { "message_tags": messages.map((_) => _._tag) }
-            })
+            }, { captureStackTrace: false })
           ),
       drain: <DrainE, DrainR>(
         handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
         sessionId?: string
-      ) =>
-        Effect.gen(function*() {
-          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.zipRight(handleEvent(body)),
-                      silenceAndReportError,
-                      (_) =>
-                        setupRequestContextWithCustomSpan(
-                          _,
-                          meta,
-                          `queue.drain: ${queueDrainName}.${body._tag}`,
-                          {
-                            captureStackTrace: false,
-                            kind: "consumer",
-                            attributes: {
-                              "queue.name": queueDrainName,
-                              "queue.sessionId": sessionId,
-                              "queue.input": body
-                            }
+      ) => {
+        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 yield* q
-            .take
-            .pipe(
-              Effect.flatMap((x) =>
-                processMessage(x).pipe(
-                  Effect.uninterruptible,
-                  Effect.fork,
-                  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
+                        }
+                      )
+                  )
+                if (meta.span) {
+                  effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
                 }
-              }),
-              Effect.forever
-            )
-        })
-    } satisfies QueueBase<Evt, DrainEvt>
+                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
+          )
+      }
+    }
+    return queue as QueueBase<Evt, DrainEvt>
   })
 }

package/src/QueueMaker/errors.ts

@@ -22,7 +22,7 @@ export function reportNonInterruptedFailure(context?: Record<string, unknown>) {
 
 export function reportNonInterruptedFailureCause(context?: Record<string, unknown>) {
   return <E>(cause: Cause.Cause<E>): Effect.Effect<void> => {
-    if (Cause.isInterruptedOnly(cause)) {
+    if (Cause.hasInterruptsOnly(cause)) {
       return Effect.failCause(cause as Cause.Cause<never>)
     }
     return reportQueueError(cause, context)