@effect-app/vue 2.94.0 → 4.0.0-beta.0

package/src/form.ts

@@ -1,8 +1,6 @@
 import { createIntl, type IntlFormatters } from "@formatjs/intl"
-import * as JSONSchema from "effect/JSONSchema"
-import type { ParseError } from "effect/ParseResult"
 import type {} from "intl-messageformat"
-import { Either, Option, pipe, S } from "effect-app"
+import { Cause, Exit, Option, pipe, S } from "effect-app"
 import type { Schema } from "effect-app/Schema"
 import type { Unbranded } from "effect-app/Schema/brand"
 import type { IsUnion } from "effect-app/utils"
@@ -11,23 +9,18 @@ import { capitalize, ref } from "vue"
 // type GetSchemaFromProp<T> = T extends Field<infer S, any, any, any> ? S
 //   : never
 
-function getTypeLiteralAST(ast: S.AST.AST): S.AST.TypeLiteral | null {
-  switch (ast._tag) {
-    case "TypeLiteral": {
-      return ast
-    }
-    case "Transformation": {
-      // this may be not correct for transformations from a type literal to something
-      // that is not a type literal nor a class because we would prefer the from AST
-      return getTypeLiteralAST(ast.to) ?? getTypeLiteralAST(ast.from)
-    }
-    case "Refinement": {
-      return getTypeLiteralAST(ast.from)
-    }
-    default: {
-      return null
+function getObjectsAST(ast: S.AST.AST): S.AST.Objects | null {
+  if (S.AST.isObjects(ast)) {
+    return ast
+  }
+  if (S.AST.isDeclaration(ast)) {
+    for (const typeParam of ast.typeParameters) {
+      const result = getObjectsAST(typeParam)
+      if (result) return result
     }
+    return null
   }
+  return null
 }
 
 export function convertIn(v: string | null, type?: "text" | "float" | "int") {
@@ -114,29 +107,26 @@ function handlePropertySignature(
 {
   const schema = S.make(propertySignature.type)
 
-  switch (schema.ast._tag) {
-    case "Transformation": {
-      const tl = getTypeLiteralAST(schema.ast)
-
-      return tl
-        ? handlePropertySignature(
-          new S.AST.PropertySignature(
-            propertySignature.name,
-            tl,
-            propertySignature.isOptional,
-            propertySignature.isReadonly,
-            propertySignature.annotations
-          )
+  if (S.AST.isDeclaration(schema.ast)) {
+    const tl = getObjectsAST(schema.ast)
+    return tl
+      ? handlePropertySignature(
+        new S.AST.PropertySignature(
+          propertySignature.name,
+          tl
         )
-        : buildFieldInfo(propertySignature)
-    }
-    case "TypeLiteral": {
+      )
+      : buildFieldInfo(propertySignature)
+  }
+
+  switch (schema.ast._tag) {
+    case "Objects": {
       return buildFieldInfoFromFieldsRoot(
-        schema as S.Schema<Record<PropertyKey, any>, Record<PropertyKey, any>, never>
+        schema as S.Schema<Record<PropertyKey, any>>
       )
     }
     case "Union": {
-      const allTypeLiterals = schema.ast.types.every(getTypeLiteralAST)
+      const allTypeLiterals = schema.ast.types.every(getObjectsAST)
 
       if (allTypeLiterals) {
         const members = schema
@@ -146,15 +136,12 @@ function handlePropertySignature(
             // syntehtic property signature as if each union member were the only member
             new S.AST.PropertySignature(
               propertySignature.name,
-              elAst,
-              propertySignature.isOptional,
-              propertySignature.isReadonly,
-              propertySignature.annotations
+              elAst
             )
           )
           .flatMap((ps) => {
             // try to retrieve the _tag literal to set _infoTag later
-            const typeLiteral = getTypeLiteralAST(ps.type)
+            const typeLiteral = getObjectsAST(ps.type)
 
             const tagPropertySignature = typeLiteral?.propertySignatures.find((_) => _.name === "_tag")
             const tagLiteral = tagPropertySignature
@@ -207,7 +194,7 @@ export function buildFieldInfoFromFields<
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>
 >(
-  schema: Schema<To, From, never> & { fields?: S.Struct.Fields }
+  schema: (Schema<To> | S.Codec<To, From>) & { fields?: S.Struct.Fields }
 ) {
   return buildFieldInfoFromFieldsRoot(schema).fields
 }
@@ -217,9 +204,9 @@ export function buildFieldInfoFromFieldsRoot<
   To extends Record<PropertyKey, any>,
   R
 >(
-  schema: Schema<To, From, R> & { fields?: S.Struct.Fields }
+  schema: (Schema<To> | S.Codec<To, From, R>) & { fields?: S.Struct.Fields }
 ): NestedFieldInfo<To> {
-  const ast = getTypeLiteralAST(schema.ast)
+  const ast = getObjectsAST(schema.ast)
 
   if (!ast) throw new Error("not a struct type")
   return ast.propertySignatures.reduce(
@@ -258,25 +245,25 @@ function buildFieldInfo(
   property: S.AST.PropertySignature
 ): FieldInfo<any> {
   const propertyKey = property.name
-  const schema = S.make<unknown, unknown, never>(property.type)
-  const metadata = getMetadataFromSchema(property.type) // TODO
-  const parse = S.decodeUnknownEither(schema)
+  const schema = S.make<S.Schema<unknown>>(property.type)
+  const metadata = getMetadataFromSchema(property.type)
+  const parse = S.decodeUnknownExit(schema as S.Schema<unknown> & { readonly DecodingServices: never })
 
   const nullableOrUndefined = S.AST.isUnion(property.type)
-    && (property.type.types.includes(S.Null.ast) || property.type.types.some((_) => _._tag === "UndefinedKeyword"))
+    && (property.type.types.includes(S.Null.ast) || property.type.types.some((_) => _._tag === "Undefined"))
   const realSelf = nullableOrUndefined && S.AST.isUnion(property.type)
-    ? property.type.types.filter((_) => _ !== S.Null.ast && _._tag !== "UndefinedKeyword")[0]!
+    ? property.type.types.filter((_) => _ !== S.Null.ast && _._tag !== "Undefined")[0]!
     : property.type
-  const id = S.AST.getIdentifierAnnotation(property.type)
-  const id2 = S.AST.getIdentifierAnnotation(realSelf)
+  const id = S.AST.resolveIdentifier(property.type)
+  const id2 = S.AST.resolveIdentifier(realSelf)
 
-  function renderError(e: ParseError, v: unknown) {
+  function renderError(e: S.SchemaError, v: unknown) {
     const err = e.toString()
 
     const custom = customSchemaErrors.value.get(property.type)
       ?? customSchemaErrors.value.get(realSelf)
-      ?? (Option.isSome(id) ? customSchemaErrors.value.get(id.value) : undefined)
-      ?? (Option.isSome(id2) ? customSchemaErrors.value.get(id2.value) : undefined)
+      ?? (id ? customSchemaErrors.value.get(id) : undefined)
+      ?? (id2 ? customSchemaErrors.value.get(id2) : undefined)
 
     if (custom) {
       return custom(err, e, v)
@@ -366,9 +353,12 @@ function buildFieldInfo(
   const parseRule = (v: unknown) =>
     pipe(
       parse(v),
-      Either.match({
-        onLeft: (_) => renderError(_, v),
-        onRight: () => true
+      Exit.match({
+        onFailure: (cause) => {
+          const err = Cause.findErrorOption(cause)
+          return Option.isSome(err) ? renderError(err.value, v) : "Unknown error"
+        },
+        onSuccess: () => true
       })
     )
 
@@ -429,14 +419,16 @@ export function getMetadataFromSchema(
 
   let jschema: any
   try {
-    jschema = JSONSchema.make(S.make(realSelf)) as any
-  } catch (err) {
+    const doc = S.toJsonSchemaDocument(S.make<S.Schema<unknown>>(realSelf))
+    jschema = doc.schema as any
+    const defs = doc.definitions as Record<string, any>
+    // resolve $ref against definitions
+    while (jschema["$ref"] && jschema["$ref"].startsWith("#/$defs/")) {
+      const { $ref: _, ...rest } = jschema
+      jschema = { ...defs[jschema["$ref"].replace("#/$defs/", "")], ...rest }
+    }
+  } catch (_err) {
     jschema = {}
-    // console.warn("error getting jsonschema from ", err, ast)
-  }
-  while (jschema["$ref"] && jschema["$ref"].startsWith("#/$defs/")) {
-    const { $ref: _, ...rest } = jschema
-    jschema = { ...jschema["$defs"][jschema["$ref"].replace("#/$defs/", "")], ...rest }
   }
   // or we need to add these info directly in the refinement like the minimum
   // or find a jsonschema parser whojoins all of them

package/src/lib.ts

@@ -1,8 +1,8 @@
-import { isHttpClientError } from "@effect/platform/HttpClientError"
 import { type Pausable, useIntervalFn, type UseIntervalFnOptions } from "@vueuse/core"
-import { Cause, type Effect, LogLevel, pipe } from "effect-app"
+import { Cause, type Effect, pipe } from "effect-app"
 import { type Req } from "effect-app/client"
 import type { ClientForOptions, RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
+import { isHttpClientError } from "effect/unstable/http/HttpClientError"
 import type { MaybeRefOrGetter } from "vue"
 import { reportError } from "./errorReporter.js"
 
@@ -17,12 +17,14 @@ const determineLevel = (cause: Cause.Cause<unknown>) => {
   if (!isHttpClientError(sq)) {
     return undefined
   }
-  const causeStr = sq.cause?.toString().toLowerCase()
-  switch (sq._tag) {
-    case "RequestError":
-      return sq.reason === "Transport" ? LogLevel.Info : undefined
-    case "ResponseError":
-      return sq.reason === "Decode" && filters.some((_) => causeStr?.includes(_)) ? LogLevel.Info : undefined
+  const causeStr = sq.reason.message?.toLowerCase()
+  switch (sq.reason._tag) {
+    case "TransportError":
+      return "Info" as const
+    case "DecodeError":
+      return filters.some((_) => causeStr?.includes(_)) ? "Info" as const : undefined
+    default:
+      return undefined
   }
 }
 

package/src/makeClient.ts

@@ -2,15 +2,14 @@
 import * as Result from "@effect-atom/atom/Result"
 import { type InvalidateOptions, type InvalidateQueryFilters, isCancelledError, type QueryObserverResult, type RefetchOptions, type UseQueryReturnType } from "@tanstack/vue-query"
 import { camelCase } from "change-case"
-import { Cause, Effect, Exit, type Layer, type ManagedRuntime, Match, Option, Runtime, S, Struct } from "effect-app"
+import { Cause, Data, Effect, Exit, Layer, type ManagedRuntime, Match, Option, S, ServiceMap, Struct } from "effect-app"
 import { type ApiClientFactory, type Req } from "effect-app/client"
 import type { RequestHandler, RequestHandlers, RequestHandlerWithInput, Requests } from "effect-app/client/clientFor"
 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 { dropUndefinedT, extendM } from "effect-app/utils"
-import { type RuntimeFiber } from "effect/Fiber"
+import { type Fiber } from "effect/Fiber"
 import { computed, type ComputedRef, onBeforeUnmount, type Ref, ref, watch, type WatchSource } from "vue"
 import { reportMessage } from "./errorReporter.js"
 import { type Commander, CommanderStatic } from "./experimental/commander.js"
@@ -20,7 +19,7 @@ import { Toast } from "./experimental/toast.js"
 import { buildFieldInfoFromFieldsRoot } from "./form.js"
 import { reportRuntimeError } from "./lib.js"
 import { asResult, makeMutation, type MutationOptions, type MutationOptionsBase, mutationResultToVue, type Res, useMakeMutation } from "./mutate.js"
-import { type CustomUndefinedInitialQueryOptions, type KnownFiberFailure, makeQuery } from "./query.js"
+import { type CustomUndefinedInitialQueryOptions, makeQuery } from "./query.js"
 
 const mapHandler = <A, E, R, I = void, A2 = A, E2 = E, R2 = R>(
   handler: Effect.Effect<A, E, R> | ((i: I) => Effect.Effect<A, E, R>),
@@ -180,12 +179,11 @@ export type Queries<RT, Req> = Req extends
 /**
  * Use this after handling an error yourself, still continueing on the Error track, but the error will not be reported.
  */
-export class SuppressErrors extends Cause.YieldableError {
-  readonly _tag = "SuppressErrors"
-  readonly [ErrorSilenced] = true
+export class SuppressErrors extends Data.TaggedError("SuppressErrors")<{}> {
+  readonly [ErrorSilenced] = true as const
 }
 
-export type ResponseErrors = S.ParseResult.ParseError | SupportedErrors | SuppressErrors | OperationFailure
+export type ResponseErrors = S.SchemaError | SupportedErrors | SuppressErrors | OperationFailure
 
 export interface Opts<
   A,
@@ -290,16 +288,16 @@ function handleRequest<
   const handleEffect = (i: any) => (self: Effect.Effect<Exit.Exit<A, E>, never, R>) =>
     self.pipe(
       Effect.tap(
-        Exit.matchEffect({
+        Effect.matchCauseEffect({
           onSuccess: (r) => options.onSuccess(r, i),
           onFailure: (cause) =>
             Effect.gen(function*() {
-              if (Cause.isInterruptedOnly(cause)) {
+              if (Cause.hasInterruptsOnly(cause)) {
                 console.info(`Interrupted while trying to ${action}`)
                 return
               }
 
-              const fail = Cause.failureOption(cause)
+              const fail = Cause.findErrorOption(cause)
               if (Option.isSome(fail)) {
                 if (fail.value._tag === "SuppressErrors") {
                   console.info(`Suppressed error trying to ${action}`, fail.value)
@@ -321,7 +319,7 @@ function handleRequest<
             })
         })
       ),
-      Effect.withSpan(`mutation ${id}`, { captureStackTrace: false })
+      Effect.withSpan(`mutation ${id}`, {}, { captureStackTrace: false })
     )
   return Object.assign(
     Effect.isEffect(f)
@@ -359,7 +357,7 @@ export const useMutation: typeof _useMutation = <
   Object.assign(
     mapHandler(
       _useMutation(self as any, options),
-      Effect.withSpan(`mutation ${self.id}`, { captureStackTrace: false })
+      Effect.withSpan(`mutation ${self.id}`, {}, { captureStackTrace: false })
     ) as any,
     { id: self.id }
   )
@@ -385,7 +383,7 @@ export const useMutationInt = (): typeof _useMutation => {
     Object.assign(
       mapHandler(
         _useMutation(self as any, options),
-        Effect.withSpan(`mutation ${self.id}`, { captureStackTrace: false })
+        Effect.withSpan(`mutation ${self.id}`, {}, { captureStackTrace: false })
       ) as any,
       { id: self.id }
     )
@@ -393,7 +391,7 @@ export const useMutationInt = (): typeof _useMutation => {
 
 export class LegacyMutationImpl<RT> {
   constructor(
-    private readonly getRuntime: () => Runtime.Runtime<RT>,
+    private readonly getRuntime: () => ServiceMap.ServiceMap<RT>,
     private readonly toast: Toast,
     private readonly intl: I18n
   ) {}
@@ -437,12 +435,17 @@ export class LegacyMutationImpl<RT> {
     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)
+    const [a, b] = asResult(
+      mapHandler(
+        mapHandler(unsafe as any, mh),
+        Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause))
+      ) as any
+    )
     return [
       a,
       mapHandler(
         b,
-        Effect.withSpan(`mutation ${self.id}`, { captureStackTrace: false })
+        Effect.withSpan(`mutation ${self.id}`, {}, { captureStackTrace: false })
       )
     ] as const as any
   }
@@ -537,7 +540,7 @@ export class LegacyMutationImpl<RT> {
     }
 
     function renderError(e: ResponseErrors): string {
-      return Match.value(e).pipe(
+      return Match.value(e as any).pipe(
         Match.tags({
           // HttpErrorRequest: e =>
           //   this.intl.value.formatMessage(
@@ -573,12 +576,12 @@ export class LegacyMutationImpl<RT> {
           //     { id: "handle.response_error" },
           //     { error: `${e.error}` },
           //   ),
-          ParseError: (e) => {
+          SchemaError: (e: any) => {
             console.warn(e.toString())
             return self.intl.formatMessage({ id: "validation.failed" })
           }
         }),
-        Match.orElse((e) => `${e.message ?? e._tag ?? e}`)
+        Match.orElse((e: any) => `${e.message ?? e._tag ?? e}`)
       )
     }
   }
@@ -652,12 +655,12 @@ export class LegacyMutationImpl<RT> {
       handler: Effect.isEffect(handler)
         ? (pipe(
           Effect.annotateCurrentSpan({ action }),
-          Effect.zipRight(handler)
+          Effect.andThen(handler)
         ) as any)
         : (...args: [any]) =>
           pipe(
             Effect.annotateCurrentSpan({ action }),
-            Effect.zipRight(handler(...args))
+            Effect.andThen(handler(...args))
           )
     }, options ? dropUndefinedT(options) : undefined)
 
@@ -939,7 +942,12 @@ export class LegacyMutationImpl<RT> {
     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)
+    const [a, b] = asResult(
+      mapHandler(
+        mapHandler(unsafe as any, mh),
+        Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause))
+      ) as any
+    )
 
     return tuple(
       computed(() => mutationResultToVue(a.value)),
@@ -1002,36 +1010,34 @@ export class LegacyMutationImpl<RT> {
     OnSubmitA
   >(
     s:
-      & Schema<
-        To,
-        From,
-        RT
-      >
+      & S.Schema<To>
       & { 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 schema = S.Struct(Struct.omit(s.fields, ["_tag"])) as unknown as S.Schema<any> & {
+      readonly DecodingServices: never
+    }
+    const parse = S.decodeUnknownSync(schema)
     const isDirty = ref(false)
     const isValid = ref(true)
     const isLoading = ref(false)
-    const runPromise = Runtime.runPromise(this.getRuntime())
+    const runPromise = Effect.runPromiseWith(this.getRuntime())
 
     const submit1 =
-      (onSubmit: (a: To) => Effect.Effect<OnSubmitA, never, RT>) =>
+      (onSubmit: (a: To) => Effect.Effect<OnSubmitA, never, never>) =>
       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)))))
+          return await runPromise(onSubmit(new (s as any)(await runPromise(parse(state.value)))) as any)
         } finally {
           isLoading.value = false
         }
       }
-    const submit = submit1(onSubmit)
+    const submit = submit1(onSubmit as any)
 
     watch(
       state,
@@ -1043,10 +1049,10 @@ export class LegacyMutationImpl<RT> {
     )
 
     const submitFromState = Effect.gen(function*() {
-      return yield* onSubmit(yield* parse(state.value))
+      return yield* (onSubmit(yield* parse(state.value)) as any)
     })
 
-    const submitFromStatePromise = () => runPromise(submitFromState)
+    const submitFromStatePromise = () => runPromise(submitFromState as any)
 
     return {
       fields,
@@ -1063,19 +1069,22 @@ export class LegacyMutationImpl<RT> {
 }
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class LegacyMutation extends Effect.Service<LegacyMutation>()("LegacyMutation", {
-  effect: Effect.gen(function*() {
+export class LegacyMutation extends ServiceMap.Service<LegacyMutation>()("LegacyMutation", {
+  make: Effect.gen(function*() {
     const intl = yield* I18n
     const toast = yield* Toast
 
-    return <R>(getRuntime: () => Runtime.Runtime<R>) => new LegacyMutationImpl(getRuntime, toast, intl)
+    return <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => new LegacyMutationImpl(getRuntime, toast, intl)
   })
-}) {}
+}) {
+  static readonly DefaultWithoutDependencies = Layer.effect(this, this.make)
+  static readonly Default = this.DefaultWithoutDependencies
+}
 
 export type ClientFrom<M extends Requests> = RequestHandlers<never, never, M, M["meta"]["moduleName"]>
 
 export class QueryImpl<R> {
-  constructor(readonly getRuntime: () => Runtime.Runtime<R>) {
+  constructor(readonly getRuntime: () => ServiceMap.ServiceMap<R>) {
     this.useQuery = makeQuery(this.getRuntime)
   }
   /**
@@ -1116,7 +1125,7 @@ export class QueryImpl<R> {
           ComputedRef<TData>,
           (
             options?: RefetchOptions
-          ) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
+          ) => Effect.Effect<QueryObserverResult<TData, E>>,
           UseQueryReturnType<any, any>
         ]
       >
@@ -1146,7 +1155,7 @@ export class QueryImpl<R> {
           ComputedRef<TData>,
           (
             options?: RefetchOptions
-          ) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
+          ) => Effect.Effect<QueryObserverResult<TData, E>>,
           UseQueryReturnType<any, any>
         ]
       >
@@ -1154,7 +1163,7 @@ export class QueryImpl<R> {
   } = <Arg, E, A, Request extends Req, Name extends string>(
     self: RequestHandlerWithInput<Arg, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>
   ) => {
-    const runPromise = Runtime.runPromise(this.getRuntime())
+    const runPromise = Effect.runPromiseWith(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 }
@@ -1171,12 +1180,10 @@ export class QueryImpl<R> {
         // what's the difference with just calling `fetch` ?
         // we will receive a CancelledError which we will have to ignore in our ErrorBoundary, otherwise the user ends up on an error page even if the user e.g cancelled a navigation
         const r = yield* Effect.tryPromise(() => uqrt.suspense()).pipe(
-          Effect.catchTag("UnknownException", (err) =>
-            Runtime.isFiberFailure(err.error)
-              ? Effect.failCause(err.error[Runtime.FiberFailureCauseId])
-              : isCancelledError(err.error)
+          Effect.catchTag("UnknownError", (err) =>
+            isCancelledError(err.cause)
               ? Effect.interrupt
-              : Effect.die(err.error))
+              : Effect.die(err.cause))
         )
         if (!isMounted.value) {
           return yield* Effect.interrupt
@@ -1207,7 +1214,7 @@ export class QueryImpl<R> {
 }
 
 // somehow mrt.runtimeEffect doesnt work sync, but this workaround works fine? not sure why though as the layers are generally only sync
-const managedRuntimeRt = <A, E>(mrt: ManagedRuntime.ManagedRuntime<A, E>) => mrt.runSync(Effect.runtime<A>())
+const managedRuntimeRt = <A, E>(mrt: ManagedRuntime.ManagedRuntime<A, E>) => mrt.runSync(Effect.services<A>())
 
 type Base = I18n | Toast
 type Mix = ApiClientFactory | Commander | LegacyMutation | Base
@@ -1218,7 +1225,7 @@ export const makeClient = <RT_, RTHooks>(
   rtHooks: Layer.Layer<RTHooks, never, Mix>
 ) => {
   type RT = RT_ | Mix
-  const getRt = Effect.runtime<RT>()
+  const getRt = Effect.services<RT>()
   const getBaseRt = () => managedRuntimeRt(getBaseMrt())
   const makeCommand = makeUseCommand<RT, RTHooks>(rtHooks)
   const makeMutation = Effect.gen(function*() {
@@ -1226,9 +1233,9 @@ export const makeClient = <RT_, RTHooks>(
 
     return mut(() => getBaseMrt().runSync(getRt))
   })
-  let cmd: Effect.Effect.Success<typeof makeCommand>
+  let cmd: Effect.Success<typeof makeCommand>
   const useCommand = () => cmd ??= getBaseMrt().runSync(makeCommand)
-  let mut: Effect.Effect.Success<typeof makeMutation>
+  let mut: Effect.Success<typeof makeMutation>
   const getMutation = () => mut ??= getBaseMrt().runSync(makeMutation)
 
   let m: ReturnType<typeof useMutationInt>
@@ -1488,7 +1495,7 @@ export interface CommandBase<I = void, A = void> {
   label: string
 }
 
-export interface EffectCommand<I = void, A = unknown, E = unknown> extends CommandBase<I, RuntimeFiber<A, E>> {}
+export interface EffectCommand<I = void, A = unknown, E = unknown> extends CommandBase<I, Fiber<A, E>> {}
 
 export interface CommandFromRequest<I extends abstract new(...args: any) => any, A = unknown, E = unknown>
   extends EffectCommand<ConstructorParameters<I>[0], A, E>

package/src/mutate.ts

@@ -58,7 +58,7 @@ export function make<A, E, R>(self: Effect.Effect<A, E, R>) {
     .pipe(
       Effect.andThen(self),
       Effect.exit,
-      Effect.andThen(Result.fromExit),
+      Effect.map(Result.fromExit),
       Effect.flatMap((r) => Effect.sync(() => result.value = r))
     )
 
@@ -118,7 +118,7 @@ export const asResult: {
         state.value = Result.initial(true)
       })
       .pipe(
-        Effect.zipRight(Effect.suspend(() =>
+        Effect.andThen(Effect.suspend(() =>
           handler.pipe(
             Effect.exit,
             Effect.tap((exit) => Effect.sync(() => (state.value = Result.fromExit(exit))))
@@ -131,7 +131,7 @@ export const asResult: {
           state.value = Result.initial(true)
         })
         .pipe(
-          Effect.zipRight(Effect.suspend(() =>
+          Effect.andThen(Effect.suspend(() =>
             handler(...args).pipe(
               Effect.exit,
               Effect.tap((exit) => Effect.sync(() => (state.value = Result.fromExit(exit))))
@@ -171,7 +171,7 @@ export const invalidateQueries = (
           Effect.annotateCurrentSpan({ queryKey, opts }),
           Effect.forEach(opts, (_) => invalidateQueries(_.filters, _.options), { concurrency: "inherit" })
         )
-        .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
+        .pipe(Effect.withSpan("client.query.invalidation", {}, { captureStackTrace: false }))
     }
 
     if (!queryKey) return Effect.void
@@ -187,12 +187,11 @@ export const invalidateQueries = (
           // TODO: should we do this in general on any mutation, regardless of invalidation?
           Effect.sleep(0)
         ),
-        Effect.withSpan("client.query.invalidation", { captureStackTrace: false })
+        Effect.withSpan("client.query.invalidation", {}, { captureStackTrace: false })
       )
   })
 
-  const handle = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    Effect.tapBoth(self, { onFailure: () => invalidateCache, onSuccess: () => invalidateCache })
+  const handle = <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.ensuring(self, invalidateCache)
 
   return handle
 }