@effect-app/vue 2.52.0 → 2.52.1

package/src/experimental/useCommand.ts

@@ -43,6 +43,12 @@ export class CommandContext extends Context.Tag("CommandContext")<
   { action: string }
 >() {}
 
+export interface CommandProps<A, E> {
+  action: string
+  result: Result<A, E>
+  waiting: boolean
+}
+
 export const makeUseCommand = <Locale extends string, RT>(
   // NOTE: underscores to not collide with auto exports in nuxt apps
   _useIntl: MakeIntlReturn<Locale>["useIntl"],
@@ -58,11 +64,7 @@ export const makeUseCommand = <Locale extends string, RT>(
   const runFork = Runtime.runFork(runtime)
 
   type CommandOut<Args extends Array<any>, A, E> = ComputedRef<
-    ((...a: Args) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
-      action: string
-      result: Result<A, E>
-      waiting: boolean
-    }
+    ((...a: Args) => RuntimeFiber<Exit.Exit<A, E>, never>) & CommandProps<A, E>
   >
 
   type CommandOutHelper<Args extends Array<any>, Eff extends Effect.Effect<any, any, any>> = CommandOut<
@@ -71,6 +73,108 @@ export const makeUseCommand = <Locale extends string, RT>(
     Effect.Effect.Error<Eff>
   >
 
+  const makeCommand =
+    (actionName: string, errorDef?: Error) =>
+    <Args extends ReadonlyArray<any>, A, E, R extends RT | CommandContext>(
+      handler: (...args: Args) => Effect.Effect<A, E, R>
+    ) => {
+      const limit = Error.stackTraceLimit
+      Error.stackTraceLimit = 2
+      const localErrorDef = new Error()
+      Error.stackTraceLimit = limit
+      if (!errorDef) {
+        errorDef = localErrorDef
+      }
+      const action = intl.value.formatMessage({
+        id: `action.${actionName}`,
+        defaultMessage: actionName
+      })
+      const context = { action }
+
+      const errorReporter = <A, E, R>(self: Effect.Effect<A, E, R>) =>
+        self.pipe(
+          Effect.tapErrorCause(
+            Effect.fnUntraced(function*(cause) {
+              if (Cause.isInterruptedOnly(cause)) {
+                console.info(`Interrupted while trying to ${actionName}`)
+                return
+              }
+
+              const fail = Cause.failureOption(cause)
+              if (Option.isSome(fail)) {
+                // if (fail.value._tag === "SuppressErrors") {
+                //   console.info(
+                //     `Suppressed error trying to ${action}`,
+                //     fail.value,
+                //   )
+                //   return
+                // }
+                const message = `Failure trying to ${actionName}`
+                yield* reportMessage(message, {
+                  action: actionName,
+                  error: fail.value
+                })
+                return
+              }
+
+              const extra = {
+                action,
+                message: `Unexpected Error trying to ${actionName}`
+              }
+              yield* reportRuntimeError(cause, extra)
+            })
+          )
+        )
+
+      const theHandler = flow(
+        handler,
+        // all must be within the Effect.fn to fit within the Span
+        Effect.provideService(CommandContext, context),
+        (_) => Effect.annotateCurrentSpan({ action }).pipe(Effect.zipRight(_)),
+        errorReporter
+      )
+
+      const [result, mut] = asResult(theHandler)
+
+      return computed(() =>
+        Object.assign(
+          (...args: Args) => {
+            const limit = Error.stackTraceLimit
+            Error.stackTraceLimit = 2
+            const errorCall = new Error()
+            Error.stackTraceLimit = limit
+
+            let cache: false | string = false
+            const captureStackTrace = () => {
+              if (cache !== false) {
+                return cache
+              }
+              if (errorCall.stack) {
+                const stackDef = errorDef!.stack!.trim().split("\n")
+                const stackCall = errorCall.stack.trim().split("\n")
+                let endStackDef = stackDef.slice(2).join("\n").trim()
+                if (!endStackDef.includes(`(`)) {
+                  endStackDef = endStackDef.replace(/at (.*)/, "at ($1)")
+                }
+                let endStackCall = stackCall.slice(2).join("\n").trim()
+                if (!endStackCall.includes(`(`)) {
+                  endStackCall = endStackCall.replace(/at (.*)/, "at ($1)")
+                }
+                cache = `${endStackDef}\n${endStackCall}`
+                return cache
+              }
+            }
+            return runFork(Effect.withSpan(mut(...args), actionName, { captureStackTrace }))
+          }, /* make sure always create a new one, or the state won't properly propagate */
+          {
+            action,
+            result: result.value,
+            waiting: result.value.waiting
+          } as CommandProps<A, E>
+        )
+      )
+    }
+
   return {
     /** Version of confirmOrInterrupt that automatically includes the action name in the default messages */
     confirmOrInterrupt: Effect.fnUntraced(function*(
@@ -440,74 +544,18 @@ export const makeUseCommand = <Locale extends string, RT>(
       // TODO: combinators can freely take A, E, R and change it to whatever they want, as long as the end result Requires not more than CommandContext | R
       ...combinators: any[]
     ): any => {
-      const action = intl.value.formatMessage({
-        id: `action.${actionName}`,
-        defaultMessage: actionName
-      })
-      const context = { action }
+      const limit = Error.stackTraceLimit
+      Error.stackTraceLimit = 2
+      const errorDef = new Error()
+      Error.stackTraceLimit = limit
 
-      const errorReporter = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-        self.pipe(
-          Effect.tapErrorCause(
-            Effect.fnUntraced(function*(cause) {
-              if (Cause.isInterruptedOnly(cause)) {
-                console.info(`Interrupted while trying to ${actionName}`)
-                return
-              }
+      return makeCommand(actionName, errorDef)(Effect.fnUntraced(fn, ...combinators as [any]) as any)
+    },
 
-              const fail = Cause.failureOption(cause)
-              if (Option.isSome(fail)) {
-                // if (fail.value._tag === "SuppressErrors") {
-                //   console.info(
-                //     `Suppressed error trying to ${action}`,
-                //     fail.value,
-                //   )
-                //   return
-                // }
-                const message = `Failure trying to ${actionName}`
-                yield* reportMessage(message, {
-                  action: actionName,
-                  error: fail.value
-                })
-                return
-              }
-
-              const extra = {
-                action,
-                message: `Unexpected Error trying to ${actionName}`
-              }
-              yield* reportRuntimeError(cause, extra)
-            })
-          )
-        )
-
-      // TODO: override span stack set by Effect.fn as it points here instead of to the caller of Command.fn.
-      // perhaps copying Effect.fn implementation is better than using it?
-      const handler = Effect.fn(actionName)(
-        fn,
-        ...(combinators as [any]),
-        // all must be within the Effect.fn to fit within the Span
-        Effect.provideService(CommandContext, context) as any, /* TODO */
-        ((_: any) => Effect.annotateCurrentSpan({ action }).pipe(Effect.zipRight(_))) as any, /* TODO */
-        errorReporter as any /* TODO */
-      ) as any // (...args: Args) => Effect.Effect<AEff, $WrappedEffectError, R>
-
-      const [result, mut] = asResult(handler)
-
-      return computed(() =>
-        Object.assign(
-          flow(
-            mut as any,
-            runFork
-            // (_) => {}
-          ), /* make sure always create a new one, or the state won't properly propagate */
-          {
-            action,
-            result: result.value,
-            waiting: result.value.waiting
-          }
-        )
-      )
-    }
+    alt: makeCommand as (
+      actionName: string
+    ) => <Args extends ReadonlyArray<any>, A, E, R extends RT | CommandContext>(
+      handler: (...args: Args) => Effect.Effect<A, E, R>
+    ) => ComputedRef<((...a: Args) => RuntimeFiber<Exit.Exit<A, E>, never>) & CommandProps<A, E>>
   }
 }

package/src/mutate.ts

@@ -88,7 +88,7 @@ export interface MutationOptions<A, E, R, A2 = A, E2 = E, R2 = R, I = void> {
 //   predicate: (_) => nses.includes(_.queryKey.filter((_) => _.startsWith("$")).join("/"))
 // }))
 /*
-            // const nses: string[] = []
+            // const nses: string[] = []`
                 // for (let i = 0; i < ns.length; i++) {
                 //   nses.push(ns.slice(0, i + 1).join("/"))
                 // }

package/test/Mutation.test.ts

@@ -49,7 +49,10 @@ it.live("has custom action name", () =>
   Effect
     .gen(function*() {
       const toasts: any[] = []
-      const { useCommand } = useExperimental({ toasts, messages: { "action.Test Action": "Test Action Translated" } })
+      const { useCommand } = useExperimental({
+        toasts,
+        messages: { "action.Test Action": "Test Action Translated" }
+      })
       const Command = useCommand()
 
       let executed = false
@@ -121,7 +124,10 @@ it.live("can replace the result", () =>
   Effect
     .gen(function*() {
       const toasts: any[] = []
-      const { useCommand } = useExperimental({ toasts, messages: { "action.Test Action": "Test Action Translated" } })
+      const { useCommand } = useExperimental({
+        toasts,
+        messages: { "action.Test Action": "Test Action Translated" }
+      })
       const Command = useCommand()
 
       let executed = false
@@ -294,3 +300,319 @@ it.live("defect", () =>
       expect(toasts.length).toBe(1) // toast should show error
       expect(toasts[0].message).toBe("Test Action unexpected error, please try again shortly.")
     }))
+
+it.live("works with alt", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.alt("Test Action")(
+        Effect.fnUntraced(
+          function*() {
+            expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+            expect(command.value.waiting).toBe(true)
+
+            expect(yield* CommandContext).toEqual({ action: "Test Action" })
+
+            expect(toasts.length).toBe(0)
+
+            return "test-value"
+          },
+          Effect.tap(Effect.fnUntraced(function*() {
+            expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+          })),
+          Effect.tap(() =>
+            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+          ),
+          Effect.tap(() => executed = true)
+        )
+      )
+      expect(command.value.action).toBe("Test Action")
+
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+      expect(command.value.waiting).toBe(false)
+
+      expect(r).toBe("test-value") // to confirm that the initial function has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+
+      expect(command.value.result.pipe(Result.value)).toEqual(Option.some("test-value"))
+
+      expect(toasts.length).toBe(0)
+    }))
+
+it.live("has custom action name with alt", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({
+        toasts,
+        messages: { "action.Test Action": "Test Action Translated" }
+      })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.alt("Test Action")(
+        Effect.fnUntraced(
+          function*() {
+            expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+
+            expect(yield* CommandContext).toEqual({ action: "Test Action Translated" })
+            return "test-value"
+          },
+          Effect.tap(() => executed = true)
+        )
+      )
+      expect(command.value.action).toBe("Test Action Translated")
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toBe("test-value") // to confirm that the initial function has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+    }))
+
+it.live("can map the result with alt", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.alt("Test Action")(Effect.fnUntraced(
+        function*() {
+          expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+
+          return "test-value"
+        },
+        Effect.map((_) => _ + _),
+        Effect.tap(() => executed = true)
+      ))
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toBe("test-valuetest-value") // to confirm that the initial function and map has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+    }))
+
+it.live("can receive and use input with alt", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.alt("Test Action")(
+        Effect.fnUntraced(
+          function*(input1: number, input2: string) {
+            expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+
+            return { input1, input2 }
+          },
+          Effect.tap(() => executed = true)
+        )
+      )
+      const r = yield* Fiber.join(command.value(1, "2")).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toEqual({ input1: 1, input2: "2" }) // to confirm that the initial function has ran and received input.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+    }))
+
+it.live("can replace the result with alt", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({
+        toasts,
+        messages: { "action.Test Action": "Test Action Translated" }
+      })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.alt("Test Action")(
+        Effect.fnUntraced(
+          function*() {
+            expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+
+            return "test-value"
+          },
+          Effect.zipRight(Effect.succeed(42)),
+          Effect.tap(() => executed = true)
+        )
+      )
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toBe(42) // to confirm that the initial function and zipRight has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+    }))
+
+it.live("with toasts with alt", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({
+        toasts,
+        messages: DefaultIntl.en
+      })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.alt("Test Action")(
+        Effect.fnUntraced(
+          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...")
+
+            return "test-value"
+          },
+          Effect.tap(Effect.fnUntraced(function*() {
+            expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+          })),
+          Effect.tap(() =>
+            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+          ),
+          Command.withDefaultToast,
+          Effect.tap(() => executed = true)
+        )
+      )
+
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toBe("test-value") // to confirm that the initial function has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+
+      expect(toasts.length).toBe(1)
+      expect(toasts[0].message).toBe("Test Action Success")
+    }))
+
+it.live("interrupted with alt", () =>
+  Effect
+    .gen(function*() {
+      let executed = false
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: DefaultIntl.en })
+      const Command = useCommand()
+
+      const command = Command.alt("Test Action")(
+        Effect.fnUntraced(
+          function*() {
+            expect(toasts.length).toBe(1)
+            // @effect-diagnostics-next-line missingReturnYieldStar:off
+            yield* Effect.interrupt
+            return "test-value"
+          },
+          Command.withDefaultToast,
+          Effect.tap(() => executed = true)
+        )
+      )
+
+      const r = yield* Fiber.join(command.value()) // we receive an Exit as errors/results are processed
+
+      expect(executed).toBe(false) // we were interrupted after all :)
+      expect(Exit.isInterrupted(r)).toBe(true) // to confirm that the initial function has interrupted
+
+      expect(command.value.waiting).toBe(false)
+      expect(Exit.isInterrupted(Result.toExit(command.value.result))).toBe(true)
+      expect(toasts.length).toBe(0) // toast is removed on interruption. TODO: maybe a nicer user experience can be had?
+    }))
+
+it.live("fail with alt", () =>
+  Effect
+    .gen(function*() {
+      let executed = false
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: DefaultIntl.en })
+      const Command = useCommand()
+
+      const command = Command.alt("Test Action")(
+        Effect.fnUntraced(
+          function*() {
+            expect(toasts.length).toBe(1)
+            return yield* Effect.fail({ message: "Boom!" })
+          },
+          Command.withDefaultToast,
+          Effect.tap(() => executed = true)
+        )
+      )
+
+      const r = yield* Fiber.join(command.value()) // we receive an Exit as errors/results are processed
+
+      expect(executed).toBe(false) // we failed after all :)
+      expect(Exit.isFailure(r) && Cause.isFailure(r.cause)).toBe(true) // to confirm that the initial function has failed
+
+      expect(command.value.waiting).toBe(false)
+      expect(Exit.isFailure(Result.toExit(command.value.result))).toBe(true)
+      expect(toasts.length).toBe(1) // toast should show error
+      expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
+    }))
+
+it.live("fail and recover with alt", () =>
+  Effect
+    .gen(function*() {
+      let executed = false
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: DefaultIntl.en })
+      const Command = useCommand()
+
+      const command = Command.alt("Test Action")(
+        Effect.fnUntraced(
+          function*() {
+            expect(toasts.length).toBe(1)
+            return yield* Effect.fail({ message: "Boom!" })
+          },
+          Effect.catchAll(() => Effect.succeed("recovered")), // we recover from the error here, so the final result is success
+          Command.withDefaultToast,
+          Effect.tap(() => executed = true)
+        )
+      )
+
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed
+
+      expect(executed).toBe(true) // we recovered after all :)
+      expect(r).toBe("recovered") // to confirm that the initial function has failed but we recovered
+
+      expect(command.value.waiting).toBe(false)
+      expect(Result.toExit(command.value.result)).toEqual(Exit.succeed("recovered"))
+      expect(toasts.length).toBe(1) // toast should show error
+      expect(toasts[0].message).toBe("Test Action Success")
+    }))
+
+it.live("defect with alt", () =>
+  Effect
+    .gen(function*() {
+      let executed = false
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: DefaultIntl.en })
+      const Command = useCommand()
+
+      const command = Command.alt("Test Action")(
+        Effect.fnUntraced(
+          function*() {
+            expect(toasts.length).toBe(1)
+            return yield* Effect.die({ message: "Boom!" })
+          },
+          Command.withDefaultToast,
+          Effect.tap(() => executed = true)
+        )
+      )
+
+      const r = yield* Fiber.join(command.value()) // we receive an Exit as errors/results are processed
+      // TODO: confirm we reported error
+
+      expect(executed).toBe(false) // we died after all :)
+      expect(Exit.isFailure(r) && Cause.isDie(r.cause)).toBe(true) // to confirm that the initial function has died
+
+      expect(command.value.waiting).toBe(false)
+      expect(Exit.isFailure(Result.toExit(command.value.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.")
+    }))