@effect-app/vue-components 4.0.0-beta.22 → 4.0.0-beta.221

package/src/components/OmegaForm/submit.ts

@@ -0,0 +1,131 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as api from "@opentelemetry/api"
+import type { DeepKeys, StandardSchemaV1Issue, ValidationError, ValidationErrorMap } from "@tanstack/vue-form"
+import * as Effect from "effect-app/Effect"
+import * as Option from "effect-app/Option"
+import { runtimeFiberAsPromise } from "effect-app/utils"
+import * as Data from "effect/Data"
+import * as Fiber from "effect/Fiber"
+import type { Fiber as EffectFiber } from "effect/Fiber"
+import type { OmegaFormApi, OmegaFormParams } from "./types"
+
+export class FormErrors<From> extends Data.TaggedError("FormErrors")<{
+  form: {
+    // TODO: error shapes seem off, with `undefined` etc..
+    errors: (Record<string, StandardSchemaV1Issue[]> | undefined)[]
+    errorMap: ValidationErrorMap<
+      undefined,
+      undefined,
+      Record<string, StandardSchemaV1Issue[]>,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined
+    >
+  }
+  fields: Record<DeepKeys<From>, {
+    errors: ValidationError[]
+    errorMap: ValidationErrorMap
+  }>
+}> {}
+
+export const wrapWithSpan = (span: api.Span | undefined, toWrap: () => any) => {
+  return span ? api.context.with(api.trace.setSpan(api.context.active(), span), toWrap) : toWrap()
+}
+
+export type UserOnSubmit<From, To> = (props: {
+  formApi: OmegaFormParams<From, To>
+  meta: any
+  value: To
+}) => Promise<any> | EffectFiber<any, any> | Effect.Effect<unknown, any>
+
+export type RunPromise = <A, E>(eff: Effect.Effect<A, E>) => Promise<A>
+
+/**
+ * Wraps the user's `onSubmit` to:
+ * - run inside the OpenTelemetry span passed via `meta.currentSpan`
+ * - decode the raw form `value` (validators only validate, they don't transform)
+ * - normalize Promise / Effect / Fiber return values to a Promise
+ *
+ * Returns `undefined` when `userOnSubmit` is `undefined` (so callers can pass it
+ * directly to `useForm({ onSubmit })` without changing semantics).
+ */
+export const wrapOnSubmit = <From, To>(
+  userOnSubmit: UserOnSubmit<From, To> | undefined,
+  decode: (value: From) => Effect.Effect<To, any>,
+  runPromise: RunPromise
+) => {
+  if (!userOnSubmit) return undefined
+  return ({ formApi, meta, value }: { formApi: OmegaFormParams<From, To>; meta: any; value: From }) =>
+    wrapWithSpan(meta?.currentSpan, async () => {
+      // validators only validate, they don't actually transform, so we have to do that manually here.
+      const parsedValue = await runPromise(decode(value))
+      const r = userOnSubmit({
+        formApi: formApi as OmegaFormApi<From, To>,
+        meta,
+        value: parsedValue
+      })
+      if (Fiber.isFiber(r)) {
+        return await runtimeFiberAsPromise(r)
+      }
+      if (Effect.isEffect(r)) {
+        const effectResult = await runPromise(r)
+        return Fiber.isFiber(effectResult)
+          ? await runtimeFiberAsPromise(effectResult)
+          : effectResult
+      }
+      return r
+    })
+}
+
+/**
+ * Builds the public submit handlers from a `useForm`-returned `form`:
+ * - `handleSubmit` injects the current OpenTelemetry span as `meta.currentSpan`.
+ * - `handleSubmitEffect` runs `handleSubmit` inside an Effect that picks up the
+ *   ambient `Effect.currentSpan`. With `checkErrors: true`, it fails with
+ *   `FormErrors<From>` when validation produced errors.
+ */
+export const makeSubmitHandlers = <From, To>(
+  form: OmegaFormApi<From, To>
+) => {
+  const hs = form.handleSubmit.bind(form)
+
+  const handleSubmitInner: typeof form.handleSubmit = async (meta?: Record<string, any>) => {
+    return await hs(meta)
+  }
+
+  const handleSubmit = (meta?: Record<string, any>) => {
+    const span = api.trace.getSpan(api.context.active())
+    return handleSubmitInner({ currentSpan: span, ...meta })
+  }
+
+  const handleSubmitEffect_ = (meta?: Record<string, any>) =>
+    Effect.currentSpan.pipe(
+      Effect.option,
+      Effect
+        .flatMap((span) =>
+          Effect.promise(() => handleSubmitInner(Option.isSome(span) ? { currentSpan: span.value, ...meta } : meta))
+        )
+    )
+
+  const handleSubmitEffect: {
+    (options: { checkErrors: true; meta?: Record<string, any> }): Effect.Effect<void, FormErrors<From>>
+    (options?: { meta?: Record<string, any> }): Effect.Effect<void>
+  } = (
+    options?: { meta?: Record<string, any>; checkErrors?: true }
+  ): any =>
+    options?.checkErrors
+      ? handleSubmitEffect_(options?.meta).pipe(Effect.flatMap(Effect.fnUntraced(function*() {
+        const errors = form.getAllErrors()
+        if (Object.keys(errors.fields).length || errors.form.errors.length) {
+          return yield* Effect.fail(new FormErrors({ form: errors.form, fields: errors.fields }))
+        }
+      })))
+      : handleSubmitEffect_(options?.meta)
+
+  return { handleSubmit, handleSubmitEffect }
+}