@effect-app/vue 4.0.0-beta.22 → 4.0.0-beta.220

package/src/{experimental/withToast.ts → withToast.ts}

@@ -1,10 +1,12 @@
-import { Cause, Effect, Layer, type Option, ServiceMap } from "effect-app"
+import { Cause, Context, Effect, Fiber, Layer, type Option, S } from "effect-app"
 import { wrapEffect } from "effect-app/utils"
-import { CurrentToastId, Toast } from "./toast.js"
+import { CurrentToastId, Toast, type ToastId } from "./toast.js"
 
 export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
   stableToastId?: undefined | string | ((...args: Args) => string | undefined)
   timeout?: number
+  showSpanInfo?: false
+  groupId?: string
   onWaiting:
     | string
     | ((...args: Args) => string | null)
@@ -33,10 +35,10 @@ export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, S
 }
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class WithToast extends ServiceMap.Service<WithToast>()("WithToast", {
+export class WithToast extends Context.Service<WithToast>()("WithToast", {
   make: Effect.gen(function*() {
     const toast = yield* Toast
-    return <A, E, Args extends Array<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
+    return <A, E, Args extends readonly unknown[], R, WaiR = never, SucR = never, ErrR = never>(
       options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
     ) =>
       Effect.fnUntraced(function*(self: Effect.Effect<A, E, R>, ...args: Args) {
@@ -46,23 +48,41 @@ export class WithToast extends ServiceMap.Service<WithToast>()("WithToast", {
           ? options.stableToastId(...args)
           : options.stableToastId
 
+        const requestId: string = yield* Effect.currentSpan.pipe(
+          Effect.map((span) => span.traceId),
+          Effect.orElseSucceed(() => S.StringId.make())
+        )
+        const groupId = options.groupId
+        const meta = { ...(groupId !== undefined ? { groupId } : {}), requestId }
+
         const t = yield* wrapEffect(options.onWaiting)(...args)
-        const toastId = t === null ? stableToastId : yield* toast.info(
-          t,
-          { id: stableToastId ?? null } // TODO: timeout forever?
+        const toastId: ToastId | undefined = t === null
+          ? stableToastId
+          : stableToastId ?? `wait-${Math.random().toString(36).slice(2)}`
+
+        const waitingFiber = t === null ? undefined : yield* Effect.forkChild(
+          Effect.sleep("1 seconds").pipe(
+            Effect.andThen(toast.info(t, { id: toastId!, timeout: Infinity, ...meta }))
+          )
         )
+        const interruptWaiting = waitingFiber ? Fiber.interrupt(waitingFiber) : Effect.void
+
         return yield* self.pipe(
           Effect.tap(Effect.fnUntraced(function*(a) {
+            yield* interruptWaiting
             const t = yield* wrapEffect(options.onSuccess)(a, ...args)
             if (t === null) {
               return
             }
             yield* toast.success(
               t,
-              toastId !== undefined ? { id: toastId, timeout: baseTimeout } : { timeout: baseTimeout }
+              toastId !== undefined
+                ? { id: toastId, timeout: baseTimeout, ...meta }
+                : { timeout: baseTimeout, ...meta }
             )
           })),
           Effect.tapCause(Effect.fnUntraced(function*(cause) {
+            yield* interruptWaiting
             yield* Effect.logDebug(
               "WithToast - caught error cause: " + Cause.squash(cause),
               Cause.hasInterruptsOnly(cause),
@@ -74,15 +94,23 @@ export class WithToast extends ServiceMap.Service<WithToast>()("WithToast", {
               return
             }
 
+            const spanInfo = options.showSpanInfo !== false
+              ? yield* Effect.currentSpan.pipe(
+                Effect.map((span) => `\nTrace: ${span.traceId}\nSpan: ${span.spanId}`),
+                Effect.orElseSucceed(() => "")
+              )
+              : ""
+
             const t = yield* wrapEffect(options.onFailure)(Cause.findErrorOption(cause), ...args)
-            const opts = { timeout: baseTimeout * 2 }
+            const opts = { timeout: baseTimeout * 2, ...meta }
 
             if (typeof t === "object") {
+              const message = t.message + spanInfo
               return t.level === "warn"
-                ? yield* toast.warning(t.message, toastId !== undefined ? { ...opts, id: toastId } : opts)
-                : yield* toast.error(t.message, toastId !== undefined ? { ...opts, id: toastId } : opts)
+                ? yield* toast.warning(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
+                : yield* toast.error(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
             }
-            yield* toast.error(t, toastId !== undefined ? { ...opts, id: toastId } : opts)
+            yield* toast.error(t + spanInfo, toastId !== undefined ? { ...opts, id: toastId } : opts)
           }, Effect.uninterruptible)),
           toastId !== undefined ? Effect.provideService(CurrentToastId, CurrentToastId.of({ toastId })) : (_) => _
         )

package/test/Mutation.test.ts

@@ -1,9 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { it } from "@effect/vitest"
 import { Cause, Effect, Exit, Fiber, Option } from "effect-app"
-import { CommandContext, DefaultIntl } from "../src/experimental/commander.js"
+import { TestClock } from "effect/testing"
+import { CommandContext, DefaultIntl } from "../src/commander.js"
 import { AsyncResult } from "../src/lib.js"
-import { useExperimental } from "./stubs.js"
+import { useExperimental, useExperimentalE } from "./stubs.js"
 
 const unwrap = <A, E>(r: Fiber.Fiber<Exit.Exit<A, E>, never>) => Fiber.join(r).pipe(Effect.flatten)
 
@@ -71,7 +72,10 @@ describe("alt2", () => {
               expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
             })),
             Effect.tap(() =>
-              Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
+              Effect.currentSpan.pipe(
+                Effect.map((_) => _.name),
+                Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action")))
+              )
             ),
             Effect.tap(() => Effect.sync(() => executed = true))
           )
@@ -125,7 +129,10 @@ it.live("works", () =>
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
         })),
         Effect.tap(() =>
-          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
+          Effect.currentSpan.pipe(
+            Effect.map((_) => _.name),
+            Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action")))
+          )
         ),
         Effect.tap(() => Effect.sync(() => executed = true))
       )
@@ -175,7 +182,10 @@ it.live("works non-gen", () =>
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
         })),
         Effect.tap(() =>
-          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
+          Effect.currentSpan.pipe(
+            Effect.map((_) => _.name),
+            Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action")))
+          )
         ),
         Effect.tap(() => Effect.sync(() => executed = true))
       )
@@ -308,8 +318,8 @@ it.live("with toasts", () =>
         function*() {
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
 
-          expect(toasts.length).toBe(1)
-          expect(toasts[0].message).toBe("Test Action executing...")
+          // fast actions complete before the 1s waiting-toast delay, so no waiting toast is shown
+          expect(toasts.length).toBe(0)
 
           return "test-value"
         },
@@ -317,7 +327,10 @@ it.live("with toasts", () =>
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
         })),
         Effect.tap(() =>
-          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
+          Effect.currentSpan.pipe(
+            Effect.map((_) => _.name),
+            Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action")))
+          )
         ),
         // WithToast.handle({
         //   onFailure: "failed",
@@ -346,7 +359,7 @@ it.live("interrupted", () =>
 
       const command = Command.fn("Test Action")(
         function*() {
-          expect(toasts.length).toBe(1)
+          expect(toasts.length).toBe(0)
           yield* Effect.interrupt
           return "test-value"
         },
@@ -373,7 +386,7 @@ it.live("fail", () =>
 
       const command = Command.fn("Test Action")(
         function*() {
-          expect(toasts.length).toBe(1)
+          expect(toasts.length).toBe(0)
           return yield* Effect.fail({ message: "Boom!" })
         },
         Command.withDefaultToast(),
@@ -388,9 +401,30 @@ it.live("fail", () =>
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
-      expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
+      expect(toasts[0].type).toBe("warning")
+      expect(toasts[0].message).toContain("Test Action Failed:\nBoom!")
+      expect(toasts[0].message).toMatch(/Trace: [a-f0-9]{32}/)
+      expect(toasts[0].message).toMatch(/Span: [a-f0-9]{16}/)
     }))
 
+it.live("fail with showSpanInfo disabled", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const Command = useExperimental({ toasts, messages: DefaultIntl.en })
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          return yield* Effect.fail({ message: "Boom!" })
+        },
+        Command.withDefaultToast({ showSpanInfo: false })
+      )
+
+      yield* Fiber.join(command.handle())
+
+      expect(toasts.length).toBe(1)
+      expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
+    }))
 it.live("fail and recover", () =>
   Effect
     .gen(function*() {
@@ -400,7 +434,7 @@ it.live("fail and recover", () =>
 
       const command = Command.fn("Test Action")(
         function*() {
-          expect(toasts.length).toBe(1)
+          expect(toasts.length).toBe(0)
           return yield* Effect.fail({ message: "Boom!" })
         },
         Effect.orElseSucceed(() => "recovered"), // we recover from the error here, so the final result is success
@@ -428,7 +462,7 @@ it.live("defect", () =>
 
       const command = Command.fn("Test Action")(
         function*() {
-          expect(toasts.length).toBe(1)
+          expect(toasts.length).toBe(0)
           return yield* Effect.die({ message: "Boom!" })
         },
         Command.withDefaultToast(),
@@ -444,7 +478,8 @@ it.live("defect", () =>
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
-      expect(toasts[0].message).toBe("Test Action unexpected error, please try again shortly.")
+      expect(toasts[0].type).toBe("error")
+      expect(toasts[0].message).toContain("Test Action unexpected error, please try again shortly.")
     }))
 
 it.live("works with alt", () =>
@@ -471,7 +506,10 @@ it.live("works with alt", () =>
             expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
           })),
           Effect.tap(() =>
-            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
+            Effect.currentSpan.pipe(
+              Effect.map((_) => _.name),
+              Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action")))
+            )
           ),
           Effect.tap(() => Effect.sync(() => executed = true))
         )
@@ -615,8 +653,8 @@ it.live("with toasts with alt", () =>
           function*() {
             expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
 
-            expect(toasts.length).toBe(1)
-            expect(toasts[0].message).toBe("Test Action executing...")
+            // fast actions complete before the 1s waiting-toast delay, so no waiting toast is shown
+            expect(toasts.length).toBe(0)
 
             return "test-value"
           },
@@ -624,7 +662,10 @@ it.live("with toasts with alt", () =>
             expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
           })),
           Effect.tap(() =>
-            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
+            Effect.currentSpan.pipe(
+              Effect.map((_) => _.name),
+              Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action")))
+            )
           ),
           Command.withDefaultToast(),
           Effect.tap(() => Effect.sync(() => executed = true))
@@ -650,7 +691,7 @@ it.live("interrupted with alt", () =>
       const command = Command.alt("Test Action")(
         Effect.fnUntraced(
           function*() {
-            expect(toasts.length).toBe(1)
+            expect(toasts.length).toBe(0)
             // @effect-diagnostics-next-line missingReturnYieldStar:off
             yield* Effect.interrupt
             return "test-value"
@@ -680,7 +721,7 @@ it.live("fail with alt", () =>
       const command = Command.alt("Test Action")(
         Effect.fnUntraced(
           function*() {
-            expect(toasts.length).toBe(1)
+            expect(toasts.length).toBe(0)
             return yield* Effect.fail({ message: "Boom!" })
           },
           Command.withDefaultToast(),
@@ -696,7 +737,8 @@ it.live("fail with alt", () =>
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
-      expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
+      expect(toasts[0].type).toBe("warning")
+      expect(toasts[0].message).toContain("Test Action Failed:\nBoom!")
     }))
 
 it.live("fail and recover with alt", () =>
@@ -709,7 +751,7 @@ it.live("fail and recover with alt", () =>
       const command = Command.alt("Test Action")(
         Effect.fnUntraced(
           function*() {
-            expect(toasts.length).toBe(1)
+            expect(toasts.length).toBe(0)
             return yield* Effect.fail({ message: "Boom!" })
           },
           Effect.orElseSucceed(() => "recovered"), // we recover from the error here, so the final result is success
@@ -729,6 +771,64 @@ it.live("fail and recover with alt", () =>
       expect(toasts[0].message).toBe("Test Action Success")
     }))
 
+it.effect("slow action shows waiting toast after the 1s delay", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const Command = yield* useExperimentalE({ toasts, messages: DefaultIntl.en })
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          // before 1s the waiting toast must NOT have surfaced yet
+          expect(toasts.length).toBe(0)
+          yield* Effect.sleep("1100 millis")
+          // after the delay window the waiting info toast should be visible
+          expect(toasts.length).toBe(1)
+          expect(toasts[0].type).toBe("info")
+          expect(toasts[0].message).toBe("Test Action executing...")
+          return "test-value"
+        },
+        Command.withDefaultToast()
+      )
+
+      const fiber = command.handle()
+      yield* TestClock.adjust("2 seconds")
+      const r = yield* unwrap(fiber)
+
+      expect(r).toBe("test-value")
+      // waiting toast is replaced (same id) with the success toast
+      expect(toasts.length).toBe(1)
+      expect(toasts[0].type).toBe("success")
+      expect(toasts[0].message).toBe("Test Action Success")
+    }))
+
+it.effect("slow failing action surfaces waiting toast then shows error", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const Command = yield* useExperimentalE({ toasts, messages: DefaultIntl.en })
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(toasts.length).toBe(0)
+          yield* Effect.sleep("1100 millis")
+          expect(toasts.length).toBe(1)
+          expect(toasts[0].type).toBe("info")
+          return yield* Effect.fail({ message: "Boom!" })
+        },
+        Command.withDefaultToast()
+      )
+
+      const fiber = command.handle()
+      yield* TestClock.adjust("2 seconds")
+      const r = yield* Fiber.join(fiber)
+
+      expect(Exit.isFailure(r) && Cause.hasFails(r.cause)).toBe(true)
+      expect(toasts.length).toBe(1)
+      expect(toasts[0].type).toBe("warning")
+      expect(toasts[0].message).toContain("Test Action Failed:\nBoom!")
+    }))
+
 it.live("defect with alt", () =>
   Effect
     .gen(function*() {
@@ -756,5 +856,58 @@ it.live("defect with alt", () =>
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
-      expect(toasts[0].message).toBe("Test Action unexpected error, please try again shortly.")
+      expect(toasts[0].type).toBe("error")
+      expect(toasts[0].message).toContain("Test Action unexpected error, please try again shortly.")
     }))
+
+describe("state-in-toast", () => {
+  it("works", () => {
+    const toasts: any[] = []
+    const removeMutation = Object.assign(
+      Effect.fn(function*(_item: string) {
+        yield* Effect.sleep(1000)
+      }),
+      { id: "remove_thing" }
+    )
+
+    const item = "x"
+
+    const Command = useExperimental({ toasts, messages: DefaultIntl.en })
+
+    Command.fn(removeMutation, {
+      state: () => ({ item }),
+      waitKey: (id) => `${id}.${item}`,
+      blockKey: () => `modify_thing.${item}`
+      //  allowed: () => role.value === "admin"
+    })(
+      function*() {
+        //        yield* Command.confirmOrInterrupt(yield* I18n.formatMessage({ id: "confirm.remove_item" }, { item }))
+        yield* removeMutation(item)
+      },
+      Command.withDefaultToast({
+        onSuccess: (a, b, c, d) => {
+          console.log("Success", { a, b, c, d })
+          expectTypeOf(d.state).toEqualTypeOf<{ readonly item: "x" }>()
+        }
+      })
+    )
+
+    Command.fn(removeMutation, {
+      state: () => ({ item }),
+      waitKey: (id) => `${id}.${item}`,
+      blockKey: () => `modify_thing.${item}`
+      //  allowed: () => role.value === "admin"
+    })(
+      function*() {
+        //        yield* Command.confirmOrInterrupt(yield* I18n.formatMessage({ id: "confirm.remove_item" }, { item }))
+        yield* removeMutation(item)
+      },
+      Command.withDefaultToast({
+        onSuccess: (a, b, c) => {
+          console.log("Success", { a, b, c })
+          expectTypeOf(c).toEqualTypeOf<undefined>()
+        }
+      })
+    )
+  })
+})

package/test/dist/form.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"form.test.d.ts","sourceRoot":"","sources":["../form.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;AAGtC,qBAAa,YAAa,SAAQ,iBAShC;CAAG;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAK/B;CAAG;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;;;;AAEL,cAAM,QAAS,SAAQ,aAGrB;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG"}
+{"version":3,"file":"form.test.d.ts","sourceRoot":"","sources":["../form.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGtC,qBAAa,YAAa,SAAQ,iBAahC;CAAG;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAK/B;CAAG;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;;;;;AAEL,cAAM,QAAS,SAAQ,aAGrB;CAAG;;;;;;;;;;;;;;;;;;;;;;;;AAqBL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG"}

package/test/dist/lib.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.test.d.ts","sourceRoot":"","sources":["../lib.test.ts"],"names":[],"mappings":""}

package/test/dist/streamFinal.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamFinal.test.d.ts","sourceRoot":"","sources":["../streamFinal.test.ts"],"names":[],"mappings":""}

package/test/dist/streamFn.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamFn.test.d.ts","sourceRoot":"","sources":["../streamFn.test.ts"],"names":[],"mappings":""}