@effect-app/vue 4.0.0-beta.175 → 4.0.0-beta.177

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue",
-  "version": "4.0.0-beta.175",
+  "version": "4.0.0-beta.177",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/effect-ts-app/libs/tree/main/packages/vue",
@@ -11,7 +11,7 @@
     "@vueuse/core": "^14.2.1",
     "change-case": "^5.4.4",
     "query-string": "^9.3.1",
-    "effect-app": "4.0.0-beta.175"
+    "effect-app": "4.0.0-beta.177"
   },
   "peerDependencies": {
     "@effect/atom-vue": "^4.0.0-beta.59",

package/src/makeClient.ts

@@ -148,8 +148,15 @@ export interface MutationExtWithInput<
    * Namespace invalidation targets parent namespace keys
    * (for example `$project/$configuration.get` invalidates `$project`).
    * Override invalidation in client options via `queryInvalidation`.
+   *
+   * Pass `options` to attach a `select` Effect that runs after the mutation
+   * succeeds (its output is returned to the caller) and/or override the default
+   * `queryInvalidation`.
    */
-  (i: I): Effect.Effect<A, E, R>
+  <B = A, E2 = never, R2 = never>(
+    input: I,
+    options?: MutationOptionsBase<A, B, E2, R2>
+  ): Effect.Effect<B, E | E2, R | R2>
 
   project: <ProjSchema extends S.Top>(
     schema: EA extends ProjSchema["Encoded"] ? ProjSchema : never
@@ -178,7 +185,19 @@ export interface MutationExt<
   E,
   R,
   EA = unknown
-> extends MutationExtensions<RT, Id, void, A, E, R>, Effect.Effect<A, E, R> {
+> extends MutationExtensions<RT, Id, void, A, E, R> {
+  /**
+   * Send the request to the endpoint and return the raw Effect response.
+   * Also invalidates query caches using the request namespace by default.
+   *
+   * Pass `options` to attach a `select` Effect that runs after the mutation
+   * succeeds (its output is returned to the caller) and/or override the default
+   * `queryInvalidation`.
+   */
+  <B = A, E2 = never, R2 = never>(
+    options?: MutationOptionsBase<A, B, E2, R2>
+  ): Effect.Effect<B, E | E2, R | R2>
+
   project: <ProjSchema extends S.Top>(
     schema: EA extends ProjSchema["Encoded"] ? ProjSchema : never
   ) => MutationExt<
@@ -295,32 +314,33 @@ export type Queries<RT, Req> = Req extends
 
 const _useMutation = makeMutation()
 
+const wrapWithSpan = (self: { id: string; handler: any }, mut: any) => {
+  const span = (eff: Effect.Effect<any, any, any>) =>
+    Effect.withSpan(`mutation ${self.id}`, {}, { captureStackTrace: false })(eff)
+  return Effect.isEffect(self.handler)
+    ? (options?: MutationOptionsBase) => span(mut(options))
+    : (input: any, options?: MutationOptionsBase) => span(mut(input, options))
+}
+
 /**
  * Pass an Effect or a function that returns an Effect, e.g from a client action
  * Executes query cache invalidation based on default rules or provided option.
  * adds a span with the mutation id
  */
-export const useMutation: typeof _useMutation = <
+export const useMutation: typeof _useMutation = (<
   I,
   E,
   A,
   R,
   Request extends Req,
-  Name extends string,
-  B = A,
-  E2 = never,
-  R2 = never
+  Name extends string
 >(
-  self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>,
-  options?: MutationOptionsBase<A, B, E2, R2>
+  self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>
 ) =>
   Object.assign(
-    mapHandler(
-      _useMutation(self as any, options),
-      Effect.withSpan(`mutation ${self.id}`, {}, { captureStackTrace: false })
-    ) as any,
+    wrapWithSpan(self, _useMutation(self as any)),
     { id: self.id }
-  )
+  )) as any
 
 /**
  * Pass an Effect or a function that returns an Effect, e.g from a client action
@@ -329,27 +349,20 @@ export const useMutation: typeof _useMutation = <
  */
 export const useMutationInt = (): typeof _useMutation => {
   const _useMutation = useMakeMutation()
-  return <
+  return (<
     I,
     E,
     A,
     R,
     Request extends Req,
-    Name extends string,
-    B = A,
-    E2 = never,
-    R2 = never
+    Name extends string
   >(
-    self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>,
-    options?: MutationOptionsBase<A, B, E2, R2>
+    self: RequestHandlerWithInput<I, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>
   ) =>
     Object.assign(
-      mapHandler(
-        _useMutation(self as any, options),
-        Effect.withSpan(`mutation ${self.id}`, {}, { captureStackTrace: false })
-      ) as any,
+      wrapWithSpan(self, _useMutation(self as any)),
       { id: self.id }
-    )
+    )) as any
 }
 
 export type ClientFrom<M extends RequestsAny> = RequestHandlers<never, never, M, ExtractModuleName<M>>
@@ -575,6 +588,23 @@ export const makeClient = <RT_, RTHooks>(
     ]
   }
 
+  const withDefaultInvalidation = (
+    mut: any,
+    isWithInput: boolean,
+    defaultInvalidation?: MutationOptionsBase["queryInvalidation"]
+  ) => {
+    if (!defaultInvalidation) return mut
+    const apply = (callerOpts?: MutationOptionsBase) => ({
+      ...callerOpts,
+      queryInvalidation: callerOpts?.queryInvalidation
+        ? mergeInvalidation(defaultInvalidation, callerOpts.queryInvalidation)
+        : defaultInvalidation
+    })
+    return isWithInput
+      ? (input: any, callerOpts?: MutationOptionsBase) => mut(input, apply(callerOpts))
+      : (callerOpts?: MutationOptionsBase) => mut(apply(callerOpts))
+  }
+
   const makeQueryResources = <Resources extends InvalidationResources>(resources: Resources | undefined) => {
     if (!resources) {
       return {} as Record<string, Record<string, unknown>>
@@ -667,7 +697,7 @@ export const makeClient = <RT_, RTHooks>(
         if (client[key].Request.type !== "command") {
           return acc
         }
-        const fromRequestConfig = client[key].Request.config?.invalidatesQueries as
+        const fromRequestConfig = client[key].Request.config?.["invalidatesQueries"] as
           | InvalidationCallback<InvalidationResourcesFor<M>>
           | undefined
         const fromRequest = fromRequestConfig
@@ -679,11 +709,9 @@ export const makeClient = <RT_, RTHooks>(
           : undefined
         const mergedInvalidation = mergeInvalidation(fromRequest, invalidation?.[key])
         const makeProjectedMutation = (handler: any): any => {
-          const mut: any = mutation(
-            handler,
-            mergedInvalidation ? { queryInvalidation: mergedInvalidation } : undefined
-          )
-          const wrap = Command.wrap({ mutate: Effect.isEffect(mut) ? () => mut : mut, id: client[key].id })
+          const isWithInput = !Effect.isEffect(handler.handler)
+          const mut: any = withDefaultInvalidation(mutation(handler), isWithInput, mergedInvalidation)
+          const wrap = Command.wrap({ mutate: mut, id: client[key].id })
           return Object.assign(mut, {
             wrap,
             project: (projectionSchema: any) => {
@@ -760,7 +788,7 @@ export const makeClient = <RT_, RTHooks>(
             }
             : {
               mutate: ((handler: any) => {
-                const fromRequestConfig = client[key].Request.config?.invalidatesQueries as
+                const fromRequestConfig = client[key].Request.config?.["invalidatesQueries"] as
                   | InvalidationCallback<InvalidationResourcesFor<M>>
                   | undefined
                 const fromRequest = fromRequestConfig
@@ -774,15 +802,13 @@ export const makeClient = <RT_, RTHooks>(
                   : undefined
                 const mergedInvalidation = mergeInvalidation(fromRequest, invalidation?.[key])
                 const makeProjectedMutation = (h: any): any => {
-                  const mutate = mutation(
-                    h,
-                    mergedInvalidation ? { queryInvalidation: mergedInvalidation } : undefined
-                  ) as any
+                  const isWithInput = !Effect.isEffect(h.handler)
+                  const mutate = withDefaultInvalidation(mutation(h), isWithInput, mergedInvalidation)
                   return Object.assign(
                     mutate,
                     {
                       wrap: Command.wrap({
-                        mutate: Effect.isEffect(mutate) ? () => mutate : mutate,
+                        mutate,
                         id: client[key].id
                       }),
                       project: (projectionSchema: any) => {

package/src/mutate.ts

@@ -269,32 +269,45 @@ export const invalidateQueries = (
   return handle
 }
 
+export interface MutationFnWithInput<I, A, E, R, Id extends string> {
+  <B = A, E2 = never, R2 = never>(
+    input: I,
+    options?: MutationOptionsBase<A, B, E2, R2>
+  ): Effect.Effect<B, E | E2, R | R2>
+  readonly id: Id
+}
+
+export interface MutationFn<A, E, R, Id extends string> {
+  <B = A, E2 = never, R2 = never>(
+    options?: MutationOptionsBase<A, B, E2, R2>
+  ): Effect.Effect<B, E | E2, R | R2>
+  readonly id: Id
+}
+
 export const makeMutation = () => {
   const useMutation: {
     /**
      * Pass a function that returns an Effect, e.g from a client action
      * Executes query cache invalidation based on default rules or provided option.
      */
-    <I, E, A, R, Request extends Req, Id extends string, B = A, E2 = never, R2 = never>(
-      self: RequestHandlerWithInput<I, A, E, R, Request, Id>,
-      options?: MutationOptionsBase<A, B, E2, R2>
-    ): ((i: I) => Effect.Effect<B, E | E2, R | R2>) & { readonly id: Id }
+    <I, E, A, R, Request extends Req, Id extends string>(
+      self: RequestHandlerWithInput<I, A, E, R, Request, Id>
+    ): MutationFnWithInput<I, A, E, R, Id>
     /**
      * Pass an Effect, e.g from a client action
      * Executes query cache invalidation based on default rules or provided option.
      */
-    <E, A, R, Request extends Req, Id extends string, B = A, E2 = never, R2 = never>(
-      self: RequestHandler<A, E, R, Request, Id>,
-      options?: MutationOptionsBase<A, B, E2, R2>
-    ): Effect.Effect<B, E | E2, R | R2> & { readonly id: Id }
-  } = <I, E, A, R, Request extends Req, Id extends string, B = A, E2 = never, R2 = never>(
-    self: RequestHandlerWithInput<I, A, E, R, Request, Id> | RequestHandler<A, E, R, Request, Id>,
-    options?: MutationOptionsBase<A, B, E2, R2>
+    <E, A, R, Request extends Req, Id extends string>(
+      self: RequestHandler<A, E, R, Request, Id>
+    ): MutationFn<A, E, R, Id>
+  } = <I, E, A, R, Request extends Req, Id extends string>(
+    self: RequestHandlerWithInput<I, A, E, R, Request, Id> | RequestHandler<A, E, R, Request, Id>
   ) => {
     const queryClient = useQueryClient()
-    const handle = invalidateQueries(queryClient, self, options as any)
     const handler = self.handler
-    const r = Effect.isEffect(handler) ? handle(handler) : (i: I) => handle(handler(i), i)
+    const r = Effect.isEffect(handler)
+      ? (options?: MutationOptionsBase) => invalidateQueries(queryClient, self, options)(handler)
+      : (i: I, options?: MutationOptionsBase) => invalidateQueries(queryClient, self, options)(handler(i), i)
 
     return Object.assign(r, { id: self.id }) as any
   }
@@ -310,25 +323,23 @@ export const useMakeMutation = () => {
      * Pass a function that returns an Effect, e.g from a client action
      * Executes query cache invalidation based on default rules or provided option.
      */
-    <I, E, A, R, Request extends Req, Id extends string, B = A, E2 = never, R2 = never>(
-      self: RequestHandlerWithInput<I, A, E, R, Request, Id>,
-      options?: MutationOptionsBase<A, B, E2, R2>
-    ): ((i: I) => Effect.Effect<B, E | E2, R | R2>) & { readonly id: Id }
+    <I, E, A, R, Request extends Req, Id extends string>(
+      self: RequestHandlerWithInput<I, A, E, R, Request, Id>
+    ): MutationFnWithInput<I, A, E, R, Id>
     /**
      * Pass an Effect, e.g from a client action
      * Executes query cache invalidation based on default rules or provided option.
      */
-    <E, A, R, Request extends Req, Id extends string, B = A, E2 = never, R2 = never>(
-      self: RequestHandler<A, E, R, Request, Id>,
-      options?: MutationOptionsBase<A, B, E2, R2>
-    ): Effect.Effect<B, E | E2, R | R2> & { readonly id: Id }
-  } = <I, E, A, R, Request extends Req, Id extends string, B = A, E2 = never, R2 = never>(
-    self: RequestHandlerWithInput<I, A, E, R, Request, Id> | RequestHandler<A, E, R, Request, Id>,
-    options?: MutationOptionsBase<A, B, E2, R2>
+    <E, A, R, Request extends Req, Id extends string>(
+      self: RequestHandler<A, E, R, Request, Id>
+    ): MutationFn<A, E, R, Id>
+  } = <I, E, A, R, Request extends Req, Id extends string>(
+    self: RequestHandlerWithInput<I, A, E, R, Request, Id> | RequestHandler<A, E, R, Request, Id>
   ) => {
-    const handle = invalidateQueries(queryClient, self, options as any)
     const handler = self.handler
-    const r = Effect.isEffect(handler) ? handle(handler) : (i: I) => handle(handler(i), i)
+    const r = Effect.isEffect(handler)
+      ? (options?: MutationOptionsBase) => invalidateQueries(queryClient, self, options)(handler)
+      : (i: I, options?: MutationOptionsBase) => invalidateQueries(queryClient, self, options)(handler(i), i)
 
     return Object.assign(r, { id: self.id }) as any
   }