@effect-app/vue 2.77.4 → 2.77.6

package/src/makeClient.ts

@@ -8,7 +8,7 @@ import type { RequestHandler, RequestHandlers, RequestHandlerWithInput, Requests
 import { ErrorSilenced, type SupportedErrors } from "effect-app/client/errors"
 import { constant, identity, pipe, tuple } from "effect-app/Function"
 import { type OperationFailure, OperationSuccess } from "effect-app/Operations"
-import type { Schema } from "effect-app/Schema"
+import { type Schema } from "effect-app/Schema"
 import { dropUndefinedT } from "effect-app/utils"
 import { type RuntimeFiber } from "effect/Fiber"
 import { computed, type ComputedRef, onBeforeUnmount, type Ref, ref, watch, type WatchSource } from "vue"
@@ -241,644 +241,645 @@ export const useMutationInt = (): typeof _useMutation => {
     )
 }
 
-// @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class LegacyMutation extends Effect.Service<LegacyMutation>()("LegacyMutation", {
-  effect: Effect.gen(function*() {
-    const intl = yield* I18n
-    const toast = yield* Toast
+export class LegacyMutationImpl<RT> {
+  constructor(
+    private readonly getRuntime: () => Runtime.Runtime<RT>,
+    private readonly toast: Toast,
+    private readonly intl: I18n
+  ) {}
 
-    return <R>(getRuntime: () => Runtime.Runtime<R>) => {
-      /**
-       * Effect results are converted to Exit, so errors are ignored by default.
-       * you should use the result ref to render errors!
-       */
-      const _useSafeMutation: {
-        <I, E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
-          self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
-          options?: MutationOptions<A, E, R, A2, E2, R2, I>
-        ): readonly [
-          ComputedRef<Result.Result<A2, E2>>,
-          (i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>
-        ]
-        <E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
-          self: RequestHandler<A, E, R, Request, Name>,
-          options?: MutationOptions<A, E, R, A2, E2, R2>
-        ): readonly [
-          ComputedRef<Result.Result<A2, E2>>,
-          Effect.Effect<Exit.Exit<A2, E2>, never, R2>
-        ]
-      } = <I, E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
-        self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>,
-        options?: MutationOptions<A, E, R, A2, E2, R2, I>
-      ) => {
-        const unsafe = _useMutation(self as any, options)
-
-        type MH = NonNullable<NonNullable<typeof options>["mapHandler"]>
-        const mh = options?.mapHandler ?? identity as MH
-
-        const [a, b] = asResult(mapHandler(mapHandler(unsafe as any, mh), Effect.tapDefect(reportRuntimeError)) as any)
-        return [
-          a,
-          mapHandler(
-            b,
-            Effect.withSpan(`mutation ${self.id}`, { captureStackTrace: false })
-          )
-        ] as const as any
-      }
+  /**
+   * Effect results are converted to Exit, so errors are ignored by default.
+   * you should use the result ref to render errors!
+   * @deprecated use `Command.fn` and friends instead
+   */
+  readonly useSafeMutation: {
+    <I, E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
+      self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
+      options?: MutationOptions<A, E, R, A2, E2, R2, I>
+    ): readonly [
+      ComputedRef<Result.Result<A2, E2>>,
+      (i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>
+    ]
+    <E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
+      self: RequestHandler<A, E, R, Request, Name>,
+      options?: MutationOptions<A, E, R, A2, E2, R2>
+    ): readonly [
+      ComputedRef<Result.Result<A2, E2>>,
+      Effect.Effect<Exit.Exit<A2, E2>, never, R2>
+    ]
+  } = <I, E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
+    self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>,
+    options?: MutationOptions<A, E, R, A2, E2, R2, I>
+  ) => {
+    const unsafe = _useMutation(self as any, options)
 
-      /** handles errors as toasts and reports defects */
-      const _useHandleRequestWithToast = () => {
-        return handleRequestWithToast
-        /**
-         * Pass a function that returns a Promise.
-         * Returns an execution function which reports errors as Toast.
-         */
-        function handleRequestWithToast<
-          A,
-          E extends ResponseErrors,
-          R,
-          I = void,
-          A2 = A,
-          E2 extends ResponseErrors = E,
-          R2 = R,
-          ESuccess = never,
-          RSuccess = never,
-          EError = never,
-          RError = never,
-          EDefect = never,
-          RDefect = never
-        >(
-          f: Effect.Effect<Exit.Exit<A2, E2>, never, R2> | ((i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>),
-          id: string,
-          action: string,
-          options: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect> = {}
-        ) {
-          const actionMessage = intl.formatMessage({ id: `action.${action}`, defaultMessage: action })
-          const defaultWarnMessage = intl.formatMessage(
-            { id: "handle.with_warnings" },
-            { action: actionMessage }
-          )
-          const defaultSuccessMessage = intl.formatMessage(
-            { id: "handle.success" },
-            { action: actionMessage }
-          )
-          const defaultErrorMessage = intl.formatMessage(
-            { id: "handle.with_errors" },
-            { action: actionMessage }
-          )
+    type MH = NonNullable<NonNullable<typeof options>["mapHandler"]>
+    const mh = options?.mapHandler ?? identity as MH
 
-          return handleRequest<E2, A2, R2, any, ESuccess, RSuccess, EError, RError, EDefect, RDefect>(f, id, action, {
-            onSuccess: Effect.fnUntraced(function*(a, i) {
-              const message = options.successMessage ? yield* options.successMessage(a, i) : defaultSuccessMessage
-                + (S.is(OperationSuccess)(a) && a.message
-                  ? "\n" + a.message
-                  : "")
-              if (message) {
-                yield* toast.success(message)
-              }
-            }),
-            onFail: Effect.fnUntraced(function*(e, i) {
-              if (!options.failMessage && e._tag === "OperationFailure") {
-                yield* toast.warning(
-                  defaultWarnMessage + e.message
-                    ? "\n" + e.message
-                    : ""
-                )
-                return
-              }
+    const [a, b] = asResult(mapHandler(mapHandler(unsafe as any, mh), Effect.tapDefect(reportRuntimeError)) as any)
+    return [
+      a,
+      mapHandler(
+        b,
+        Effect.withSpan(`mutation ${self.id}`, { captureStackTrace: false })
+      )
+    ] as const as any
+  }
 
-              const message = options.failMessage
-                ? yield* options.failMessage(e, i)
-                : `${defaultErrorMessage}:\n` + renderError(e)
-              if (message) {
-                yield* toast.error(message)
-              }
-            }),
-            onDefect: Effect.fnUntraced(function*(cause, i) {
-              const message = options.defectMessage
-                ? yield* options.defectMessage(cause, i)
-                : intl.formatMessage(
-                  { id: "handle.unexpected_error" },
-                  {
-                    action: actionMessage,
-                    error: Cause.pretty(cause)
-                  }
-                )
-              if (message) {
-                yield* toast.error(message)
-              }
-            })
-          })
-        }
+  /** handles errors as toasts and reports defects
+   * @deprecated use `Command.fn` and friends instead
+   */
+  readonly useHandleRequestWithToast = () => {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this
+    return handleRequestWithToast
+    /**
+     * Pass a function that returns a Promise.
+     * Returns an execution function which reports errors as Toast.
+     */
+    function handleRequestWithToast<
+      A,
+      E extends ResponseErrors,
+      R,
+      I = void,
+      A2 = A,
+      E2 extends ResponseErrors = E,
+      R2 = R,
+      ESuccess = never,
+      RSuccess = never,
+      EError = never,
+      RError = never,
+      EDefect = never,
+      RDefect = never
+    >(
+      f: Effect.Effect<Exit.Exit<A2, E2>, never, R2> | ((i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>),
+      id: string,
+      action: string,
+      options: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect> = {}
+    ) {
+      const actionMessage = self.intl.formatMessage({ id: `action.${action}`, defaultMessage: action })
+      const defaultWarnMessage = self.intl.formatMessage(
+        { id: "handle.with_warnings" },
+        { action: actionMessage }
+      )
+      const defaultSuccessMessage = self.intl.formatMessage(
+        { id: "handle.success" },
+        { action: actionMessage }
+      )
+      const defaultErrorMessage = self.intl.formatMessage(
+        { id: "handle.with_errors" },
+        { action: actionMessage }
+      )
 
-        function renderError(e: ResponseErrors): string {
-          return Match.value(e).pipe(
-            Match.tags({
-              // HttpErrorRequest: e =>
-              //   intl.value.formatMessage(
-              //     { id: "handle.request_error" },
-              //     { error: `${e.error}` },
-              //   ),
-              // HttpErrorResponse: e =>
-              //   e.response.status >= 500 ||
-              //   e.response.body._tag !== "Some" ||
-              //   !e.response.body.value
-              //     ? intl.value.formatMessage(
-              //         { id: "handle.error_response" },
-              //         {
-              //           error: `${
-              //             e.response.body._tag === "Some" && e.response.body.value
-              //               ? parseError(e.response.body.value)
-              //               : "Unknown"
-              //           } (${e.response.status})`,
-              //         },
-              //       )
-              //     : intl.value.formatMessage(
-              //         { id: "handle.unexpected_error" },
-              //         {
-              //           error:
-              //             JSON.stringify(e.response.body, undefined, 2) +
-              //             "( " +
-              //             e.response.status +
-              //             ")",
-              //         },
-              //       ),
-              // ResponseError: e =>
-              //   intl.value.formatMessage(
-              //     { id: "handle.response_error" },
-              //     { error: `${e.error}` },
-              //   ),
-              ParseError: (e) => {
-                console.warn(e.toString())
-                return intl.formatMessage({ id: "validation.failed" })
+      return handleRequest<E2, A2, R2, any, ESuccess, RSuccess, EError, RError, EDefect, RDefect>(f, id, action, {
+        onSuccess: Effect.fnUntraced(function*(a, i) {
+          const message = options.successMessage ? yield* options.successMessage(a, i) : defaultSuccessMessage
+            + (S.is(OperationSuccess)(a) && a.message
+              ? "\n" + a.message
+              : "")
+          if (message) {
+            yield* self.toast.success(message)
+          }
+        }),
+        onFail: Effect.fnUntraced(function*(e, i) {
+          if (!options.failMessage && e._tag === "OperationFailure") {
+            yield* self.toast.warning(
+              defaultWarnMessage + e.message
+                ? "\n" + e.message
+                : ""
+            )
+            return
+          }
+
+          const message = options.failMessage
+            ? yield* options.failMessage(e, i)
+            : `${defaultErrorMessage}:\n` + renderError(e)
+          if (message) {
+            yield* self.toast.error(message)
+          }
+        }),
+        onDefect: Effect.fnUntraced(function*(cause, i) {
+          const message = options.defectMessage
+            ? yield* options.defectMessage(cause, i)
+            : self.intl.formatMessage(
+              { id: "handle.unexpected_error" },
+              {
+                action: actionMessage,
+                error: Cause.pretty(cause)
               }
-            }),
-            Match.orElse((e) => `${e.message ?? e._tag ?? e}`)
-          )
-        }
-      }
+            )
+          if (message) {
+            yield* self.toast.error(message)
+          }
+        })
+      })
+    }
 
-      /**
-       * Pass a function that returns an Effect, e.g from a client action, give it a name.
-       * Returns a tuple with raw Result and execution function which reports success and errors as Toast.
-       */
-      const _useAndHandleMutationResult: {
-        <
-          I,
-          E extends ResponseErrors,
-          A,
-          R,
-          Request extends TaggedRequestClassAny,
-          Name extends string,
-          A2 = A,
-          E2 extends ResponseErrors = E,
-          R2 = R,
-          ESuccess = never,
-          RSuccess = never,
-          EError = never,
-          RError = never,
-          EDefect = never,
-          RDefect = never
-        >(
-          self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
-          action: string,
-          options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-        ): Resp<I, A2, E2, R2, ComputedRef<Result.Result<A2, E2>>>
-        <
-          E extends ResponseErrors,
-          A,
-          R,
-          Request extends TaggedRequestClassAny,
-          Name extends string,
-          A2 = A,
-          E2 extends ResponseErrors = E,
-          R2 = R,
-          ESuccess = never,
-          RSuccess = never,
-          EError = never,
-          RError = never,
-          EDefect = never,
-          RDefect = never
-        >(
-          self: RequestHandler<A, E, R, Request, Name>,
-          action: string,
-          options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-        ): ActResp<A2, E2, R2, ComputedRef<Result.Result<A2, E2>>>
-      } = <E extends ResponseErrors, A, R, Request extends TaggedRequestClassAny, Name extends string, I>(
-        self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>,
-        action: any,
-        options?: Opts<any, any, any, any, any, any, any, any, any, any, any, any, any>
-      ): any => {
-        const handleRequestWithToast = _useHandleRequestWithToast()
-        const handler = self.handler
-        const unsafe = _useMutation({
-          ...self,
-          handler: Effect.isEffect(handler)
-            ? (pipe(
-              Effect.annotateCurrentSpan({ action }),
-              Effect.zipRight(handler)
-            ) as any)
-            : (...args: [any]) =>
-              pipe(
-                Effect.annotateCurrentSpan({ action }),
-                Effect.zipRight(handler(...args))
-              )
-        }, options ? dropUndefinedT(options) : undefined)
-
-        type MH = NonNullable<NonNullable<typeof options>["mapHandler"]>
-        const mh = options?.mapHandler ?? identity as MH
-
-        // Effect.tapDefect(reportRuntimeError) handled in toast handler,
-        const [a, b] = asResult(mapHandler(unsafe, mh) as any)
-
-        return tuple(
-          a,
-          handleRequestWithToast(b as any, self.id, action, options)
-        )
-      }
-      //
-
-      /**
-       * Pass a function that returns an Effect, e.g from a client action, give it a name.
-       * Returns a tuple with state ref and execution function which reports success and errors as Toast.
-       */
-      const _useAndHandleMutation: {
-        <
-          I,
-          E extends ResponseErrors,
-          A,
-          R,
-          Request extends TaggedRequestClassAny,
-          Name extends string,
-          A2 = A,
-          E2 extends ResponseErrors = E,
-          R2 = R,
-          ESuccess = never,
-          RSuccess = never,
-          EError = never,
-          RError = never,
-          EDefect = never,
-          RDefect = never
-        >(
-          self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
-          action: string,
-          options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-        ): Resp<I, A2, E2, R2>
-        <
-          E extends ResponseErrors,
-          A,
-          R,
-          Request extends TaggedRequestClassAny,
-          Name extends string,
-          A2 = A,
-          E2 extends ResponseErrors = E,
-          R2 = R,
-          ESuccess = never,
-          RSuccess = never,
-          EError = never,
-          RError = never,
-          EDefect = never,
-          RDefect = never
-        >(
-          self: RequestHandler<A, E, R, Request, Name>,
-          action: string,
-          options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-        ): ActResp<A2, E2, R2>
-      } = (
-        self: any,
-        action: any,
-        options?: Opts<any, any, any, any, any, any, any, any, any, any, any, any, any>
-      ): any => {
-        const [a, b] = _useAndHandleMutationResult(self, action, options)
-
-        return tuple(
-          computed(() => mutationResultToVue(a.value)),
-          b
-        )
-      }
+    function renderError(e: ResponseErrors): string {
+      return Match.value(e).pipe(
+        Match.tags({
+          // HttpErrorRequest: e =>
+          //   this.intl.value.formatMessage(
+          //     { id: "handle.request_error" },
+          //     { error: `${e.error}` },
+          //   ),
+          // HttpErrorResponse: e =>
+          //   e.response.status >= 500 ||
+          //   e.response.body._tag !== "Some" ||
+          //   !e.response.body.value
+          //     ? this.intl.value.formatMessage(
+          //         { id: "handle.error_response" },
+          //         {
+          //           error: `${
+          //             e.response.body._tag === "Some" && e.response.body.value
+          //               ? parseError(e.response.body.value)
+          //               : "Unknown"
+          //           } (${e.response.status})`,
+          //         },
+          //       )
+          //     : this.intl.value.formatMessage(
+          //         { id: "handle.unexpected_error" },
+          //         {
+          //           error:
+          //             JSON.stringify(e.response.body, undefined, 2) +
+          //             "( " +
+          //             e.response.status +
+          //             ")",
+          //         },
+          //       ),
+          // ResponseError: e =>
+          //   this.intl.value.formatMessage(
+          //     { id: "handle.response_error" },
+          //     { error: `${e.error}` },
+          //   ),
+          ParseError: (e) => {
+            console.warn(e.toString())
+            return self.intl.formatMessage({ id: "validation.failed" })
+          }
+        }),
+        Match.orElse((e) => `${e.message ?? e._tag ?? e}`)
+      )
+    }
+  }
 
-      function _makeUseAndHandleMutation(
-        defaultOptions?: Opts<any, any, any, any, any, any, any, any, any>
-      ) {
-        return ((self: any, action: any, options: any) => {
-          return _useAndHandleMutation(
-            self,
-            action,
-            { ...defaultOptions, ...options }
+  /**
+   * Pass a function that returns an Effect, e.g from a client action, give it a name.
+   * Returns a tuple with raw Result and execution function which reports success and errors as Toast.
+   * @deprecated use `Command.fn` and friends instead
+   */
+  readonly useAndHandleMutationResult: {
+    <
+      I,
+      E extends ResponseErrors,
+      A,
+      R,
+      Request extends TaggedRequestClassAny,
+      Name extends string,
+      A2 = A,
+      E2 extends ResponseErrors = E,
+      R2 = R,
+      ESuccess = never,
+      RSuccess = never,
+      EError = never,
+      RError = never,
+      EDefect = never,
+      RDefect = never
+    >(
+      self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
+      action: string,
+      options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+    ): Resp<I, A2, E2, R2, ComputedRef<Result.Result<A2, E2>>>
+    <
+      E extends ResponseErrors,
+      A,
+      R,
+      Request extends TaggedRequestClassAny,
+      Name extends string,
+      A2 = A,
+      E2 extends ResponseErrors = E,
+      R2 = R,
+      ESuccess = never,
+      RSuccess = never,
+      EError = never,
+      RError = never,
+      EDefect = never,
+      RDefect = never
+    >(
+      self: RequestHandler<A, E, R, Request, Name>,
+      action: string,
+      options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+    ): ActResp<A2, E2, R2, ComputedRef<Result.Result<A2, E2>>>
+  } = <E extends ResponseErrors, A, R, Request extends TaggedRequestClassAny, Name extends string, I>(
+    self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>,
+    action: any,
+    options?: Opts<any, any, any, any, any, any, any, any, any, any, any, any, any>
+  ): any => {
+    const handleRequestWithToast = this.useHandleRequestWithToast()
+    const handler = self.handler
+    const unsafe = _useMutation({
+      ...self,
+      handler: Effect.isEffect(handler)
+        ? (pipe(
+          Effect.annotateCurrentSpan({ action }),
+          Effect.zipRight(handler)
+        ) as any)
+        : (...args: [any]) =>
+          pipe(
+            Effect.annotateCurrentSpan({ action }),
+            Effect.zipRight(handler(...args))
           )
-        }) as unknown as {
-          <
-            I,
-            E extends ResponseErrors,
-            A,
-            R,
-            Request extends TaggedRequestClassAny,
-            Name extends string,
-            A2 = A,
-            E2 extends ResponseErrors = E,
-            R2 = R,
-            ESuccess = never,
-            RSuccess = never,
-            EError = never,
-            RError = never,
-            EDefect = never,
-            RDefect = never
-          >(
-            self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
-            action: string,
-            options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-          ): Resp<I, A2, E2, R2>
-          <
-            E extends ResponseErrors,
-            A,
-            Request extends TaggedRequestClassAny,
-            Name extends string,
-            A2 = A,
-            E2 extends ResponseErrors = E,
-            R2 = R,
-            ESuccess = never,
-            RSuccess = never,
-            EError = never,
-            RError = never,
-            EDefect = never,
-            RDefect = never
-          >(
-            self: RequestHandler<A, E, R, Request, Name>,
-            action: string,
-            options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-          ): ActResp<A2, E2, R2>
-        }
-      }
+    }, options ? dropUndefinedT(options) : undefined)
 
-      /**
-       * The same as @see useAndHandleMutation, but does not display any toasts by default.
-       * Messages for success, error and defect toasts can be provided in the Options.
-       */
-      const _useAndHandleMutationSilently: {
-        <
-          I,
-          E extends ResponseErrors,
-          A,
-          R,
-          Request extends TaggedRequestClassAny,
-          Name extends string,
-          A2 = A,
-          E2 extends ResponseErrors = E,
-          R2 = R,
-          ESuccess = never,
-          RSuccess = never,
-          EError = never,
-          RError = never,
-          EDefect = never,
-          RDefect = never
-        >(
-          self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
-          action: string,
-          options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-        ): Resp<I, A2, E2, R>
-        <
-          E extends ResponseErrors,
-          A,
-          R,
-          Request extends TaggedRequestClassAny,
-          Name extends string,
-          A2 = A,
-          E2 extends ResponseErrors = E,
-          R2 = R,
-          ESuccess = never,
-          RSuccess = never,
-          EError = never,
-          RError = never,
-          EDefect = never,
-          RDefect = never
-        >(
-          self: RequestHandler<A, E, R, Request, Name>,
-          action: string,
-          options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-        ): ActResp<void, never, R>
-      } = _makeUseAndHandleMutation({
-        successMessage: suppressToast,
-        failMessage: suppressToast,
-        defectMessage: suppressToast
-      }) as any
+    type MH = NonNullable<NonNullable<typeof options>["mapHandler"]>
+    const mh = options?.mapHandler ?? identity as MH
 
-      /**
-       * The same as @see useAndHandleMutation, but does not act on success, error or defect by default.
-       * Actions for success, error and defect can be provided in the Options.
-       */
-      const _useAndHandleMutationCustom: {
-        <
-          I,
-          E extends ResponseErrors,
-          A,
-          R,
-          Request extends TaggedRequestClassAny,
-          Name extends string,
-          A2 = A,
-          E2 extends ResponseErrors = E,
-          R2 = R,
-          ESuccess = never,
-          RSuccess = never,
-          EError = never,
-          RError = never,
-          EDefect = never,
-          RDefect = never
-        >(
-          self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
-          action: string,
-          options?: LowOptsOptional<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-        ): Resp<I, A2, E2, R2>
-        <
-          E extends ResponseErrors,
-          A,
-          R,
-          Request extends TaggedRequestClassAny,
-          Name extends string,
-          A2 = A,
-          E2 extends ResponseErrors = E,
-          R2 = R,
-          ESuccess = never,
-          RSuccess = never,
-          EError = never,
-          RError = never,
-          EDefect = never,
-          RDefect = never
-        >(
-          self: RequestHandler<A, E, R, Request, Name>,
-          action: string,
-          options?: LowOptsOptional<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
-        ): ActResp<A2, E2, R2>
-      } = (self: any, action: string, options: any) => {
-        const unsafe = _useMutation({
-          ...self,
-          handler: Effect.isEffect(self.handler)
-            ? (pipe(
-              Effect.annotateCurrentSpan({ action }),
-              Effect.andThen(self.handler)
-            ) as any)
-            : (...args: any[]) =>
-              pipe(
-                Effect.annotateCurrentSpan({ action }),
-                Effect.andThen(self.handler(...args))
-              )
-        }, options ? dropUndefinedT(options) : undefined)
-
-        type MH = NonNullable<NonNullable<typeof options>["mapHandler"]>
-        const mh = options?.mapHandler ?? identity as MH
-
-        const [a, b] = asResult(mapHandler(mapHandler(unsafe as any, mh), Effect.tapDefect(reportRuntimeError)) as any)
-
-        return tuple(
-          computed(() => mutationResultToVue(a.value)),
-          handleRequest(b as any, self.id, action, {
-            onSuccess: suppressToast,
-            onDefect: suppressToast,
-            onFail: suppressToast,
-            ...options
-          })
-        ) as any
-      }
+    // Effect.tapDefect(reportRuntimeError) handled in toast handler,
+    const [a, b] = asResult(mapHandler(unsafe, mh) as any)
 
-      /**
-       * Effect results are converted to Exit, so errors are ignored by default.
-       * you should use the result ref to render errors!
-       */
-      const _useSafeMutationWithState: {
-        <I, E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
-          self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
-          options?: MutationOptions<A, E, R, A2, E2, R2, I>
-        ): readonly [
-          ComputedRef<Res<A, E>>,
-          (i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>
-        ]
-        <E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
-          self: RequestHandler<A, E, R, Request, Name>,
-          options?: MutationOptions<A, E, R, A2, E2, R2>
-        ): readonly [
-          ComputedRef<Res<A, E>>,
-          Effect.Effect<Exit.Exit<A2, E2>, never, R2>
-        ]
-      } = <I, E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
-        self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>,
-        options?: MutationOptions<A, E, R, A2, E2, R2, I>
-      ) => {
-        const [a, b] = _useSafeMutation(self as any, options)
-
-        return tuple(
-          computed(() => mutationResultToVue(a.value)),
-          b
-        ) as any
-      }
+    return tuple(
+      a,
+      handleRequestWithToast(b as any, self.id, action, options)
+    )
+  }
+  //
 
-      /** @deprecated use OmegaForm */
-      const _buildFormFromSchema = <
-        From extends Record<PropertyKey, any>,
-        To extends Record<PropertyKey, any>,
-        C extends Record<PropertyKey, any>,
-        OnSubmitA
+  /**
+   * Pass a function that returns an Effect, e.g from a client action, give it a name.
+   * Returns a tuple with state ref and execution function which reports success and errors as Toast.
+   *
+   * @deprecated use `Command.fn` and friends instead
+   */
+  readonly useAndHandleMutation: {
+    <
+      I,
+      E extends ResponseErrors,
+      A,
+      R,
+      Request extends TaggedRequestClassAny,
+      Name extends string,
+      A2 = A,
+      E2 extends ResponseErrors = E,
+      R2 = R,
+      ESuccess = never,
+      RSuccess = never,
+      EError = never,
+      RError = never,
+      EDefect = never,
+      RDefect = never
+    >(
+      self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
+      action: string,
+      options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+    ): Resp<I, A2, E2, R2>
+    <
+      E extends ResponseErrors,
+      A,
+      R,
+      Request extends TaggedRequestClassAny,
+      Name extends string,
+      A2 = A,
+      E2 extends ResponseErrors = E,
+      R2 = R,
+      ESuccess = never,
+      RSuccess = never,
+      EError = never,
+      RError = never,
+      EDefect = never,
+      RDefect = never
+    >(
+      self: RequestHandler<A, E, R, Request, Name>,
+      action: string,
+      options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+    ): ActResp<A2, E2, R2>
+  } = (
+    self: any,
+    action: any,
+    options?: Opts<any, any, any, any, any, any, any, any, any, any, any, any, any>
+  ): any => {
+    const [a, b] = this.useAndHandleMutationResult(self, action, options)
+
+    return tuple(
+      computed(() => mutationResultToVue(a.value)),
+      b
+    )
+  }
+
+  /** @deprecated use `Command.fn` and friends instead */
+  readonly makeUseAndHandleMutation = (
+    defaultOptions?: Opts<any, any, any, any, any, any, any, any, any>
+  ) =>
+    ((self: any, action: any, options: any) => {
+      return this.useAndHandleMutation(
+        self,
+        action,
+        { ...defaultOptions, ...options }
+      )
+    }) as unknown as {
+      <
+        I,
+        E extends ResponseErrors,
+        A,
+        R,
+        Request extends TaggedRequestClassAny,
+        Name extends string,
+        A2 = A,
+        E2 extends ResponseErrors = E,
+        R2 = R,
+        ESuccess = never,
+        RSuccess = never,
+        EError = never,
+        RError = never,
+        EDefect = never,
+        RDefect = never
       >(
-        s:
-          & Schema<
-            To,
-            From,
-            R
-          >
-          & { new(c: C): any; extend: any; fields: S.Struct.Fields },
-        state: Ref<Omit<From, "_tag">>,
-        onSubmit: (a: To) => Effect.Effect<OnSubmitA, never, R>
-      ) => {
-        const fields = buildFieldInfoFromFieldsRoot(s).fields
-        const schema = S.Struct(Struct.omit(s.fields, "_tag")) as any
-        const parse = S.decodeUnknown<any, any, R>(schema)
-        const isDirty = ref(false)
-        const isValid = ref(true)
-        const isLoading = ref(false)
-        const runPromise = Runtime.runPromise(getRuntime())
-
-        const submit1 =
-          (onSubmit: (a: To) => Effect.Effect<OnSubmitA, never, R>) =>
-          async <T extends Promise<{ valid: boolean }>>(e: T) => {
-            isLoading.value = true
-            try {
-              const r = await e
-              if (!r.valid) return
-              return await runPromise(onSubmit(new s(await runPromise(parse(state.value)))))
-            } finally {
-              isLoading.value = false
-            }
-          }
-        const submit = submit1(onSubmit)
-
-        watch(
-          state,
-          (v) => {
-            // TODO: do better
-            isDirty.value = JSON.stringify(v) !== JSON.stringify(state.value)
-          },
-          { deep: true }
-        )
+        self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
+        action: string,
+        options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+      ): Resp<I, A2, E2, R2>
+      <
+        E extends ResponseErrors,
+        A,
+        R,
+        Request extends TaggedRequestClassAny,
+        Name extends string,
+        A2 = A,
+        E2 extends ResponseErrors = E,
+        R2 = R,
+        ESuccess = never,
+        RSuccess = never,
+        EError = never,
+        RError = never,
+        EDefect = never,
+        RDefect = never
+      >(
+        self: RequestHandler<A, E, R, Request, Name>,
+        action: string,
+        options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+      ): ActResp<A2, E2, R2>
+    }
 
-        const submitFromState = Effect.gen(function*() {
-          return yield* onSubmit(yield* parse(state.value))
-        })
+  /**
+   * The same as @see useAndHandleMutation, but does not display any toasts by default.
+   * Messages for success, error and defect toasts can be provided in the Options.
+   * @deprecated use `Command.fn` and friends instead
+   */
+  readonly useAndHandleMutationSilently: {
+    <
+      I,
+      E extends ResponseErrors,
+      A,
+      R,
+      Request extends TaggedRequestClassAny,
+      Name extends string,
+      A2 = A,
+      E2 extends ResponseErrors = E,
+      R2 = R,
+      ESuccess = never,
+      RSuccess = never,
+      EError = never,
+      RError = never,
+      EDefect = never,
+      RDefect = never
+    >(
+      self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
+      action: string,
+      options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+    ): Resp<I, A2, E2, R>
+    <
+      E extends ResponseErrors,
+      A,
+      R,
+      Request extends TaggedRequestClassAny,
+      Name extends string,
+      A2 = A,
+      E2 extends ResponseErrors = E,
+      R2 = R,
+      ESuccess = never,
+      RSuccess = never,
+      EError = never,
+      RError = never,
+      EDefect = never,
+      RDefect = never
+    >(
+      self: RequestHandler<A, E, R, Request, Name>,
+      action: string,
+      options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+    ): ActResp<void, never, R>
+  } = this.makeUseAndHandleMutation({
+    successMessage: suppressToast,
+    failMessage: suppressToast,
+    defectMessage: suppressToast
+  }) as any
 
-        const submitFromStatePromise = () => runPromise(submitFromState)
-
-        return {
-          fields,
-          /** optimized for Vuetify v-form submit callback */
-          submit,
-          /** optimized for Native form submit callback or general use */
-          submitFromState,
-          submitFromStatePromise,
-          isDirty,
-          isValid,
-          isLoading
+  /**
+   * The same as @see useAndHandleMutation, but does not act on success, error or defect by default.
+   * Actions for success, error and defect can be provided in the Options.
+   * @deprecated use `Command.fn` and friends instead
+   */
+  readonly useAndHandleMutationCustom: {
+    <
+      I,
+      E extends ResponseErrors,
+      A,
+      R,
+      Request extends TaggedRequestClassAny,
+      Name extends string,
+      A2 = A,
+      E2 extends ResponseErrors = E,
+      R2 = R,
+      ESuccess = never,
+      RSuccess = never,
+      EError = never,
+      RError = never,
+      EDefect = never,
+      RDefect = never
+    >(
+      self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
+      action: string,
+      options?: LowOptsOptional<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+    ): Resp<I, A2, E2, R2>
+    <
+      E extends ResponseErrors,
+      A,
+      R,
+      Request extends TaggedRequestClassAny,
+      Name extends string,
+      A2 = A,
+      E2 extends ResponseErrors = E,
+      R2 = R,
+      ESuccess = never,
+      RSuccess = never,
+      EError = never,
+      RError = never,
+      EDefect = never,
+      RDefect = never
+    >(
+      self: RequestHandler<A, E, R, Request, Name>,
+      action: string,
+      options?: LowOptsOptional<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>
+    ): ActResp<A2, E2, R2>
+  } = (self: any, action: string, options: any) => {
+    const unsafe = _useMutation({
+      ...self,
+      handler: Effect.isEffect(self.handler)
+        ? (pipe(
+          Effect.annotateCurrentSpan({ action }),
+          Effect.andThen(self.handler)
+        ) as any)
+        : (...args: any[]) =>
+          pipe(
+            Effect.annotateCurrentSpan({ action }),
+            Effect.andThen(self.handler(...args))
+          )
+    }, options ? dropUndefinedT(options) : undefined)
+
+    type MH = NonNullable<NonNullable<typeof options>["mapHandler"]>
+    const mh = options?.mapHandler ?? identity as MH
+
+    const [a, b] = asResult(mapHandler(mapHandler(unsafe as any, mh), Effect.tapDefect(reportRuntimeError)) as any)
+
+    return tuple(
+      computed(() => mutationResultToVue(a.value)),
+      handleRequest(b as any, self.id, action, {
+        onSuccess: suppressToast,
+        onDefect: suppressToast,
+        onFail: suppressToast,
+        ...options
+      })
+    ) as any
+  }
+
+  /**
+   * Effect results are converted to Exit, so errors are ignored by default.
+   * you should use the result ref to render errors!
+   * @deprecated use `Command.fn` and friends instead
+   */
+  readonly useSafeMutationWithState: {
+    <I, E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
+      self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
+      options?: MutationOptions<A, E, R, A2, E2, R2, I>
+    ): readonly [
+      ComputedRef<Res<A, E>>,
+      (i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>
+    ]
+    <E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
+      self: RequestHandler<A, E, R, Request, Name>,
+      options?: MutationOptions<A, E, R, A2, E2, R2>
+    ): readonly [
+      ComputedRef<Res<A, E>>,
+      Effect.Effect<Exit.Exit<A2, E2>, never, R2>
+    ]
+  } = <I, E, A, R, Request extends TaggedRequestClassAny, Name extends string, A2 = A, E2 = E, R2 = R>(
+    self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>,
+    options?: MutationOptions<A, E, R, A2, E2, R2, I>
+  ) => {
+    const [a, b] = this.useSafeMutation(self as any, options)
+
+    return tuple(
+      computed(() => mutationResultToVue(a.value)),
+      b
+    ) as any
+  }
+
+  /** @deprecated use OmegaForm */
+  readonly buildFormFromSchema = <
+    From extends Record<PropertyKey, any>,
+    To extends Record<PropertyKey, any>,
+    C extends Record<PropertyKey, any>,
+    OnSubmitA
+  >(
+    s:
+      & Schema<
+        To,
+        From,
+        RT
+      >
+      & { new(c: C): any; extend: any; fields: S.Struct.Fields },
+    state: Ref<Omit<From, "_tag">>,
+    onSubmit: (a: To) => Effect.Effect<OnSubmitA, never, RT>
+  ) => {
+    const fields = buildFieldInfoFromFieldsRoot(s).fields
+    const schema = S.Struct(Struct.omit(s.fields, "_tag")) as any
+    const parse = S.decodeUnknown<any, any, RT>(schema)
+    const isDirty = ref(false)
+    const isValid = ref(true)
+    const isLoading = ref(false)
+    const runPromise = Runtime.runPromise(this.getRuntime())
+
+    const submit1 =
+      (onSubmit: (a: To) => Effect.Effect<OnSubmitA, never, RT>) =>
+      async <T extends Promise<{ valid: boolean }>>(e: T) => {
+        isLoading.value = true
+        try {
+          const r = await e
+          if (!r.valid) return
+          return await runPromise(onSubmit(new s(await runPromise(parse(state.value)))))
+        } finally {
+          isLoading.value = false
         }
       }
-      return {
-        /** @deprecated use Command.fn */
-        useSafeMutationWithState: _useSafeMutationWithState,
-        /** @deprecated use Command.fn */
-        useAndHandleMutation: _useAndHandleMutation,
-        /** @deprecated use Command.fn */
-        useAndHandleMutationResult: _useAndHandleMutationResult,
-        /** @deprecated use Command.fn */
-        useAndHandleMutationSilently: _useAndHandleMutationSilently,
-        /** @deprecated use Command.fn */
-        useAndHandleMutationCustom: _useAndHandleMutationCustom,
-        /** @deprecated use Command.fn */
-        makeUseAndHandleMutation: _makeUseAndHandleMutation,
-        /**
-         * handles errors as toasts and reports defects
-         * @deprecated use Command.fn
-         */
-        useHandleRequestWithToast: _useHandleRequestWithToast,
-        /** @deprecated use OmegaForm */
-        buildFormFromSchema: _buildFormFromSchema,
-        /** @deprecated use Command.fn */
-        useSafeMutation: _useSafeMutation
-      }
+    const submit = submit1(onSubmit)
+
+    watch(
+      state,
+      (v) => {
+        // TODO: do better
+        isDirty.value = JSON.stringify(v) !== JSON.stringify(state.value)
+      },
+      { deep: true }
+    )
+
+    const submitFromState = Effect.gen(function*() {
+      return yield* onSubmit(yield* parse(state.value))
+    })
+
+    const submitFromStatePromise = () => runPromise(submitFromState)
+
+    return {
+      fields,
+      /** optimized for Vuetify v-form submit callback */
+      submit,
+      /** optimized for Native form submit callback or general use */
+      submitFromState,
+      submitFromStatePromise,
+      isDirty,
+      isValid,
+      isLoading
     }
+  }
+}
+
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class LegacyMutation extends Effect.Service<LegacyMutation>()("LegacyMutation", {
+  effect: Effect.gen(function*() {
+    const intl = yield* I18n
+    const toast = yield* Toast
+
+    return <R>(getRuntime: () => Runtime.Runtime<R>) => new LegacyMutationImpl(getRuntime, toast, intl)
   })
 }) {}
 
 export type ClientFrom<M extends Requests> = RequestHandlers<never, never, Omit<M, "meta">, M["meta"]["moduleName"]>
 
-const mkQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
-  // making sure names do not collide with auto exports in nuxt apps, please do not rename..
+export class QueryImpl<R> {
+  constructor(readonly getRuntime: () => Runtime.Runtime<R>) {
+    this.useQuery = makeQuery(this.getRuntime)
+  }
   /**
    * Effect results are passed to the caller, including errors.
+   * @deprecated use client helpers instead (.query())
    */
   // TODO
-  const _useQuery = makeQuery(getRuntime)
+  readonly useQuery: ReturnType<typeof makeQuery<R>>
 
   /**
    * The difference with useQuery is that this function will return a Promise you can await in the Setup,
    * which ensures that either there always is a latest value, or an error occurs on load.
    * So that Suspense and error boundaries can be used.
+   * @deprecated use client helpers instead (.suspense())
    */
-  const useSuspenseQuery: {
+  readonly useSuspenseQuery: {
     <
       E,
       A,
@@ -948,8 +949,8 @@ const mkQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
   } = <Arg, E, A, Request extends TaggedRequestClassAny, Name extends string>(
     self: RequestHandlerWithInput<Arg, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>
   ) => {
-    const runPromise = Runtime.runPromise(getRuntime())
-    const q = _useQuery(self as any) as any
+    const runPromise = Runtime.runPromise(this.getRuntime())
+    const q = this.useQuery(self as any) as any
     return (argOrOptions?: any, options?: any) => {
       const [resultRef, latestRef, fetch, uqrt] = q(argOrOptions, { ...options, suspense: true } // experimental_prefetchInRender: true }
       )
@@ -998,8 +999,6 @@ const mkQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
       return runPromise(eff)
     }
   }
-
-  return { useQuery: _useQuery, useSuspenseQuery }
 }
 
 // somehow mrt.runtimeEffect doesnt work sync, but this workaround works fine? not sure why though as the layers are generally only sync
@@ -1028,7 +1027,7 @@ export const makeClient = <RT>(
   let m: ReturnType<typeof useMutationInt>
   const useMutation = () => m ??= useMutationInt()
 
-  const keys: readonly (keyof ReturnType<typeof getMutation>)[] = [
+  const keys = [
     "useSafeMutationWithState",
     "useAndHandleMutation",
     "useAndHandleMutationResult",
@@ -1038,20 +1037,20 @@ export const makeClient = <RT>(
     "useHandleRequestWithToast",
     "buildFormFromSchema",
     "useSafeMutation"
-  ]
-  type mut = ReturnType<typeof getMutation>
+  ] as const satisfies readonly (keyof ReturnType<typeof getMutation>)[]
+  type mut = Pick<LegacyMutationImpl<R>, typeof keys[number]>
 
   const mutations = keys.reduce(
     (prev, cur) => {
-      prev[cur] = ((...args: [any]) => {
+      ;(prev as any)[cur] = ((...args: [any]) => {
         return (getMutation() as any)[cur](...args)
       }) as any
       return prev
     },
-    {} as { [K in keyof mut]: mut[K] }
+    {} as Pick<LegacyMutationImpl<R>, typeof keys[number]>
   )
 
-  const query = mkQuery(getBaseRt)
+  const query = new QueryImpl(getBaseRt)
   const useQuery = query.useQuery
   const useSuspenseQuery = query.useSuspenseQuery
 
@@ -1284,15 +1283,12 @@ export const makeClient = <RT>(
     return proxy
   }
 
-  const legacy = {
+  const legacy: Legacy<R> = {
     ...mutations,
-    /** @deprecated use .query on the clientFor(x).Action */
-    useQuery,
-    /** @deprecated use .suspense on the clientFor(x).Action */
-    useSuspenseQuery
+    ...query
   }
 
-  const Command: CommanderResolved<RT> = {
+  const Command: CommanderResolved<R> = {
     ...{
       // delay initialisation until first use...
       fn: (...args: [any]) => useCommand().fn(...args),
@@ -1311,6 +1307,12 @@ export const makeClient = <RT>(
   }
 }
 
+export interface Legacy<R>
+  extends
+    Pick<QueryImpl<R>, "useQuery" | "useSuspenseQuery">,
+    Omit<LegacyMutationImpl<R>, "getRuntime" | "toast" | "intl">
+{}
+
 export type QueryInvalidation<M> = {
   [K in keyof M]?: (defaultKey: string[], name: string) => {
     filters?: InvalidateQueryFilters | undefined