@effect-app/vue 2.75.6 → 2.77.0

package/src/experimental/commander.ts

@@ -16,7 +16,7 @@ import { I18n } from "./intl.js"
 import { WithToast } from "./withToast.js"
 
 type IntlRecord = Record<string, PrimitiveType | FormatXMLElementFn<string, string>>
-type FnOptions<I18nCustomKey extends string, State extends IntlRecord> = {
+type FnOptions<I18nCustomKey extends string, State extends IntlRecord | undefined> = {
   i18nCustomKey?: I18nCustomKey
   /**
    * passed to the i18n formatMessage calls so you can use it in translation messagee
@@ -45,7 +45,8 @@ export const DefaultIntl = {
     "handle.request_error": "Die Anfrage konnte nicht gesendet werden:\n{error}",
     "handle.unexpected_error2": "{action} unerwarteter Fehler, probieren sie es in kurze nochmals.",
 
-    "handle.unexpected_error": "Unerwarteter Fehler:\n{error}"
+    "handle.unexpected_error": "Unerwarteter Fehler:\n{error}",
+    "handle.not_found": "Das gesuchte war nicht gefunden"
   },
   en: {
     "handle.confirmation": "Confirm {action}?",
@@ -59,13 +60,21 @@ export const DefaultIntl = {
     "handle.response_error": "The request was not successful:\n{error}",
     "handle.unexpected_error2": "{action} unexpected error, please try again shortly.",
 
-    "handle.unexpected_error": "Unexpected Error:\n{error}"
+    "handle.unexpected_error": "Unexpected Error:\n{error}",
+    "handle.not_found": "The requested item was not found."
   }
 }
 
 export class CommandContext extends Effect.Tag("CommandContext")<
   CommandContext,
-  { id: string; i18nKey: string; action: string; namespace: string; namespaced: (key: string) => string }
+  {
+    id: string
+    i18nKey: string
+    action: string
+    namespace: string
+    namespaced: (key: string) => string
+    state?: IntlRecord | undefined
+  }
 >() {}
 
 export type EmitWithCallback<A, Event extends string> = (event: Event, value: A, onDone: () => void) => void
@@ -86,11 +95,11 @@ export declare namespace Commander {
     i18nKey: I18nKey
     namespace: `action.${I18nKey}`
     namespaced: <K extends string>(k: K) => `action.${I18nKey}.${K}`
-    action: string
   }
   export interface CommandProps<A, E, Id extends string, I18nKey extends string>
     extends CommandContextLocal<Id, I18nKey>
   {
+    action: string
     result: Result<A, E>
     waiting: boolean
   }
@@ -937,7 +946,7 @@ const renderErrorMaker = I18n.use(
   (e: E, ...args: Args): string => {
     if (errorRenderer) {
       const m = errorRenderer(e, action, ...args)
-      if (m) {
+      if (m !== undefined) {
         return m
       }
     }
@@ -955,6 +964,9 @@ const renderErrorMaker = I18n.use(
     const e2: SupportedErrors | S.ParseResult.ParseError = e
     return Match.value(e2).pipe(
       Match.tags({
+        NotFoundError: (e) => {
+          return intl.formatMessage({ id: "handle.not_found" }, { type: e.type, id: e.id })
+        },
         ParseError: (e) => {
           console.warn(e.toString())
           return intl.formatMessage({ id: "validation.failed" })
@@ -1046,7 +1058,17 @@ export const CommanderStatic = {
       ),
   defaultFailureMessageHandler,
   renderError: renderErrorMaker,
-  /** Version of withDefaultToast that automatically includes the action name in the default messages and uses intl */
+  /**
+   * Version of withDefaultToast that automatically includes the action name in the default messages and uses intl.
+   * uses the Command id as i18n namespace.  `action.{id}` is the main action name,
+   * and `action.{id}.waiting`, `action.{id}.success`, `action.{id}.failure` can be used to override the default messages for the respective states.
+   *
+   * the computed `state` provided to the Command can be used for interpolation in the i18n messages. (the state is captured at the start of each command execution and remains stable throughout)
+   *
+   * Note: if you provide `onWaiting` or `onSuccess` as `null`, no toast will be shown for that state.
+   * If you provide a string or function, it will be used instead of the i18n message.
+   * If you provide an `errorRenderer`, it will be used to render errors in the failure message.
+   */
   withDefaultToast: <A, E, R, Args extends Array<unknown>>(
     options?: {
       errorRenderer?: ErrorRenderer<E, Args>
@@ -1062,19 +1084,37 @@ export const CommanderStatic = {
       const cc = yield* CommandContext
       const { intl } = yield* I18n
       const withToast = yield* WithToast
+      const customWaiting = cc.namespaced("waiting")
+      const hasCustomWaiting = !!intl.messages[customWaiting]
+      const customSuccess = cc.namespaced("success")
+      const hasCustomSuccess = !!intl.messages[customSuccess]
+      const customFailure = cc.namespaced("failure")
+      const hasCustomFailure = !!intl.messages[customFailure]
       return yield* self.pipe(
         (_) =>
           withToast<A, E, Args, R, never, never, I18n>({
-            onWaiting: options?.onWaiting === null ? null : intl.formatMessage(
-              { id: "handle.waiting" },
-              { action: cc.action }
-            ),
+            onWaiting: options?.onWaiting === null ? null : hasCustomWaiting
+              ? intl.formatMessage({
+                id: customWaiting
+              }, cc.state)
+              : intl.formatMessage(
+                { id: "handle.waiting" },
+                { action: cc.action }
+              ),
             onSuccess: options?.onSuccess === null
               ? null
               : (a, ..._args) =>
-                intl.formatMessage({ id: "handle.success" }, { action: cc.action })
-                + (S.is(OperationSuccess)(a) && a.message ? "\n" + a.message : ""),
-            onFailure: defaultFailureMessageHandler(cc.action, options?.errorRenderer)
+                hasCustomSuccess
+                  ? intl.formatMessage(
+                    { id: customSuccess },
+                    cc.state
+                  )
+                  : (intl.formatMessage({ id: "handle.success" }, { action: cc.action })
+                    + (S.is(OperationSuccess)(a) && a.message ? "\n" + a.message : "")),
+            onFailure: defaultFailureMessageHandler(
+              hasCustomFailure ? intl.formatMessage({ id: customFailure }, cc.state) : cc.action,
+              options?.errorRenderer
+            )
           })(_, ...args)
       )
     })
@@ -1086,6 +1126,25 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
   effect: Effect.gen(function*() {
     const { intl } = yield* I18n
 
+    const makeBaseInfo = <const Id extends string, const I18nKey extends string = Id>(
+      id: Id,
+      options?: Pick<FnOptionsInternal<I18nKey>, "i18nCustomKey">
+    ) => {
+      if (!id) throw new Error("must specify an id")
+      const i18nKey: I18nKey = options?.i18nCustomKey ?? id as unknown as I18nKey
+
+      const namespace = `action.${i18nKey}` as const
+
+      const context = {
+        id,
+        i18nKey,
+        namespace,
+        namespaced: <const K extends string>(k: K) => `${namespace}.${k}` as const
+      }
+
+      return context
+    }
+
     const makeContext = <const Id extends string, const I18nKey extends string = Id>(
       id: Id,
       options?: FnOptionsInternal<I18nKey>
@@ -1100,27 +1159,28 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
         id: namespace,
         defaultMessage: id
       }, options?.state)
-      const context = {
+      const context = CommandContext.of({
+        ...makeBaseInfo(id, options),
         action,
-        id,
-        i18nKey,
-        namespace,
-        namespaced: <const K extends string>(k: K) => `${namespace}.${k}` as const
-      }
+        state: options?.state
+      })
 
       return context
     }
 
-    const getStateValues = <const I18nKey extends string>(options?: FnOptions<I18nKey, any>) => {
-      const state = !options?.state ? undefined : typeof options.state === "function"
-        ? computed(options.state)
-        : options.state
+    const getStateValues = <const I18nKey extends string, State extends IntlRecord | undefined>(
+      options?: FnOptions<I18nKey, State>
+    ): ComputedRef<State> => {
+      const state_ = options?.state
+      const state = !state_ ? computed(() => undefined as State) : typeof state_ === "function"
+        ? computed(state_)
+        : state_
       return state
     }
 
     const makeCommand = <RT>(runtime: Runtime.Runtime<RT>) => {
       const runFork = Runtime.runFork(runtime)
-      return <const Id extends string, const State extends IntlRecord, const I18nKey extends string = Id>(
+      return <const Id extends string, const State extends IntlRecord | undefined, const I18nKey extends string = Id>(
         id_: Id | { id: Id },
         options?: FnOptions<I18nKey, State>,
         errorDef?: Error
@@ -1184,19 +1244,20 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
                 )
               )
 
+            const currentState = Effect.sync(() => state.value)
+
             const theHandler = flow(
               handler,
               errorReporter,
               // all must be within the Effect.fn to fit within the Span
               Effect.provideServiceEffect(
-                CommandContext,
-                Effect.sync(() => makeContext_())
+                stateTag,
+                currentState
               ),
               Effect.provideServiceEffect(
-                stateTag,
-                Effect.sync(() => state?.value)
-              ), // todo; service make errors?
-              (_) => Effect.annotateCurrentSpan({ action }).pipe(Effect.zipRight(_))
+                CommandContext,
+                Effect.sync(() => makeContext_())
+              )
             )
 
             const [result, exec] = asResult(theHandler)
@@ -1234,11 +1295,22 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
                 }
               }
 
-              const command = Effect.withSpan(
-                exec(...args),
-                id,
-                { captureStackTrace }
-              )
+              const command = currentState.pipe(Effect.flatMap((state) =>
+                Effect.withSpan(
+                  exec(...args),
+                  id,
+                  {
+                    captureStackTrace,
+                    attributes: {
+                      input: args,
+                      state,
+                      action: initialContext.action,
+                      id: initialContext.id,
+                      i18nKey: initialContext.i18nKey
+                    }
+                  }
+                )
+              ))
 
               return runFork(command)
             }, { action })
@@ -1491,7 +1563,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
                 ) as any
               )
             },
-            makeContext(typeof id === "string" ? id : id.id, { ...options, state: getStateValues(options)?.value }),
+            makeBaseInfo(typeof id === "string" ? id : id.id, options),
             {
               state: Context.GenericTag<`Commander.Command.${Id}.state`, State>(
                 `Commander.Command.${typeof id === "string" ? id : id.id}.state`
@@ -1505,7 +1577,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
         return (_id: any, options?: FnOptions<string, IntlRecord>) => {
           const isObject = typeof _id === "object" || typeof _id === "function"
           const id = isObject ? _id.id : _id
-          const context = makeContext(id, { ...options, state: getStateValues(options)?.value })
+          const baseInfo = makeBaseInfo(id, options)
           const idCmd = cmd(id, options)
           // TODO: implement proper tracing stack
           return Object.assign((cb: any) =>
@@ -1519,12 +1591,12 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
                     },
                     ...combinators as [any]
                   ),
-                context,
+                baseInfo,
                 isObject
                   ? { mutate: "mutate" in _id ? _id.mutate : typeof _id === "function" ? _id : undefined }
                   : {}
               )
-            )), context)
+            )), baseInfo)
         }
       }) as unknown as <RT>(
         runtime: Runtime.Runtime<RT>
@@ -1604,7 +1676,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
                 ...combinators as [any]
               ) as any
             )
-          }, makeContext(mutation.id, { ...options, state: getStateValues(options)?.value }))
+          }, makeBaseInfo(mutation.id, options))
       }
     }
   })

package/test/dist/stubs.d.ts

@@ -9,8 +9,8 @@ export declare const useExperimental: (options?: {
     messages?: Record<string, string> | Record<string, MessageFormatElement[]>;
     toasts: any[];
 }) => {
-    confirmOrInterrupt: (message?: string | undefined) => Effect.Effect<void, never, import("../src/experimental/intl.js").I18n | import("../src/experimental/confirm.js").Confirm | import("../src/experimental/commander.js").CommandContext>;
-    confirm: (message?: string | undefined) => Effect.Effect<boolean, never, import("../src/experimental/intl.js").I18n | import("../src/experimental/confirm.js").Confirm | import("../src/experimental/commander.js").CommandContext>;
+    confirmOrInterrupt: (message?: string | undefined) => Effect.Effect<void, never, import("../src/experimental/commander.js").CommandContext | import("../src/experimental/intl.js").I18n | import("../src/experimental/confirm.js").Confirm>;
+    confirm: (message?: string | undefined) => Effect.Effect<boolean, never, import("../src/experimental/commander.js").CommandContext | import("../src/experimental/intl.js").I18n | import("../src/experimental/confirm.js").Confirm>;
     updateAction: <Args extends Array<unknown>>(update: (currentActionId: string, ...args: Args) => string) => <A, E, R_1>(_: Effect.Effect<A, E, R_1>, ...input: Args) => Effect.Effect<A, E, import("../src/experimental/commander.js").CommandContext | R_1>;
     defaultFailureMessageHandler: <E_1, Args extends Array<unknown>, AME, AMR>(actionMaker: string | ((o: import("effect/Option").Option<E_1>, ...args: Args) => string) | ((o: import("effect/Option").Option<E_1>, ...args: Args) => Effect.Effect<string, AME, AMR>), errorRenderer?: (e: E_1, action: string, ...args: Args) => string | undefined) => (o: import("effect/Option").Option<E_1>, ...args: Args) => Effect.Effect<string | {
         level: "warn";
@@ -21,7 +21,7 @@ export declare const useExperimental: (options?: {
         errorRenderer?: (e: E_1, action: string, ...args: Args_2) => string | undefined;
         onWaiting?: null | undefined | string | ((action: string, ...args: Args_2) => string | null | undefined);
         onSuccess?: null | undefined | string | ((a: A, action: string, ...args: Args_2) => string | null | undefined);
-    }) => (self: Effect.Effect<A, E_1, R_2>, ...args: Args_2) => Effect.Effect<A, E_1, import("../src/experimental/intl.js").I18n | import("../src/experimental/withToast.js").WithToast | import("../src/experimental/commander.js").CommandContext | R_2>;
+    }) => (self: Effect.Effect<A, E_1, R_2>, ...args: Args_2) => Effect.Effect<A, E_1, import("../src/experimental/commander.js").CommandContext | import("../src/experimental/intl.js").I18n | R_2 | import("../src/experimental/withToast.js").WithToast>;
     alt: <const Id extends string, const I18nKey extends string = Id>(id: Id, customI18nKey?: I18nKey | undefined) => Commander.CommandContextLocal<Id, I18nKey> & (<Args_3 extends Array<unknown>, A, E_2, R_3 extends Toast.Toast | I18n | WithToast | import("../src/experimental/commander.js").CommandContext | `Commander.Command.${Id}.state`>(handler: (...args: Args_3) => Effect.Effect<A, E_2, R_3>) => Commander.CommandOut<Args_3, A, E_2, R_3, Id, I18nKey>);
     fn: <const Id extends string, const State extends {
         [x: string]: import("intl-messageformat").PrimitiveType | import("intl-messageformat").FormatXMLElementFn<string, string>;