@effect-app/vue 4.0.0-beta.247 → 4.0.0-beta.249

package/src/makeClient.ts

@@ -160,16 +160,16 @@ export interface MutationExt<
     RT,
     Id,
     I,
-    S.Schema.Type<ProjSchema>,
+    ProjSchema["Type"],
     E | S.SchemaError,
     R | ProjSchema["DecodingServices"],
-    S.Codec.Encoded<ProjSchema>
+    ProjSchema["Encoded"]
   >
 }
 
 export type MutationWithExtensions<RT, Req> = Req extends
   RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id>
-  ? MutationExt<RT, Id, I, A, E, R, S.Codec.Encoded<Request["success"]>>
+  ? MutationExt<RT, Id, I, A, E, R, Request["success"]["Encoded"]>
   : never
 
 /**
@@ -217,11 +217,11 @@ export type QueryProjection<RT, HandlerReq> = HandlerReq extends
   RequestHandlerWithInput<infer I, infer _A, infer E, infer R, infer Request, infer Id>
   ? Request["type"] extends "query" ? {
       project: <ProjSchema extends S.Top>(
-        schema: S.Codec.Encoded<Request["success"]> extends ProjSchema["Encoded"] ? ProjSchema : never
+        schema: Request["success"]["Encoded"] extends ProjSchema["Encoded"] ? ProjSchema : never
       ) => ProjectResult<
         RT,
         I,
-        S.Schema.Type<ProjSchema>,
+        ProjSchema["Type"],
         E | S.SchemaError,
         R | ProjSchema["DecodingServices"],
         Request,

package/src/routeParams.ts

@@ -1,6 +1,5 @@
 import * as Option from "effect-app/Option"
 import * as S from "effect-app/Schema"
-import type { Schema } from "effect-app/Schema"
 import { typedKeysOf } from "effect-app/utils"
 import { flow } from "effect/Function"
 import type { ParsedQuery } from "query-string"
@@ -17,7 +16,7 @@ export const getQueryParamO = flow(getQueryParam, Option.fromNullishOr)
 
 export function parseRouteParamsOption<NER extends Record<string, S.Codec<any, any>>>(query: Record<string, any>, t: NER // enforce non empty
 ): {
-  [K in keyof NER]: Option.Option<Schema.Type<NER[K]>>
+  [K in keyof NER]: Option.Option<NER[K]["Type"]>
 } {
   return typedKeysOf(t).reduce(
     (prev, cur) => {
@@ -29,7 +28,7 @@ export function parseRouteParamsOption<NER extends Record<string, S.Codec<any, a
       return prev
     },
     {} as {
-      [K in keyof NER]: Option.Option<Schema.Type<NER[K]>>
+      [K in keyof NER]: Option.Option<NER[K]["Type"]>
     }
   )
 }
@@ -38,7 +37,7 @@ export function parseRouteParams<NER extends Record<string, S.Codec<any, any>>>(
   query: Record<string, any>,
   t: NER // enforce non empty
 ): {
-  [K in keyof NER]: Schema.Type<NER[K]>
+  [K in keyof NER]: NER[K]["Type"]
 } {
   return typedKeysOf(t).reduce(
     (prev, cur) => {
@@ -50,7 +49,7 @@ export function parseRouteParams<NER extends Record<string, S.Codec<any, any>>>(
       return prev
     },
     {} as {
-      [K in keyof NER]: Schema.Type<NER[K]>
+      [K in keyof NER]: NER[K]["Type"]
     }
   )
 }

package/src/runtime.ts

@@ -1,56 +1 @@
-import { CauseException } from "effect-app/client/errors"
-import { type Context } from "effect-app/Context"
-import * as Effect from "effect-app/Effect"
-import * as Layer from "effect-app/Layer"
-import * as Exit from "effect/Exit"
-import { flow } from "effect/Function"
-import * as Logger from "effect/Logger"
-import * as ManagedRuntime from "effect/ManagedRuntime"
-
-export const makeAppRuntime = Effect.fnUntraced(function*<A, E>(layer: Layer.Layer<A, E>) {
-  const l = layer.pipe(
-    Layer.provide(Logger.layer([Logger.consolePretty()]))
-  ) as Layer.Layer<A>
-  const mrt = ManagedRuntime.make(l)
-  yield* mrt.contextEffect
-  return Object.assign(mrt, {
-    [Symbol.dispose]() {
-      return Effect.runSync(mrt.disposeEffect)
-    },
-
-    [Symbol.asyncDispose]() {
-      return mrt.dispose()
-    }
-  }) // as we initialise here, there is no more error left.
-})
-
-export function initializeSync<A, E>(layer: Layer.Layer<A, E>) {
-  const runtime = Effect.runSync(makeAppRuntime(layer))
-  return runtime
-}
-
-export function initializeAsync<A, E>(layer: Layer.Layer<A, E>) {
-  return Effect
-    .runPromise(makeAppRuntime(layer))
-}
-
-// we wrap into CauseException because we want to keep the full cause of the failure.
-export const makeRunPromise = <T>(services: Context<T>) =>
-  flow(Effect.runPromiseExitWith(services), (_) =>
-    _.then(
-      Exit.match({
-        onFailure: (cause) => Promise.reject(new CauseException(cause, "runPromise")),
-        onSuccess: (value) => Promise.resolve(value)
-      })
-    ))
-
-export const makeRunSync = <T>(services: Context<T>) =>
-  flow(
-    Effect.runSyncExitWith(services),
-    Exit.match({
-      onFailure: (cause) => {
-        throw new CauseException(cause, "runSync")
-      },
-      onSuccess: (value) => value
-    })
-  )
+export * from "effect-app/runtime"

package/src/toast.ts

@@ -1,54 +1 @@
-import * as Context from "effect-app/Context"
-import { accessEffectFn } from "effect-app/Context"
-import * as Effect from "effect-app/Effect"
-import * as Option from "effect-app/Option"
-
-export type ToastId = string | number
-export type ToastOpts = { id?: ToastId; timeout?: number; groupId?: string; requestId?: string }
-export type ToastOptsInternal = { id?: ToastId | null; timeout?: number; groupId?: string; requestId?: string }
-
-export type UseToast = () => {
-  error: (this: void, message: string, options?: ToastOpts) => ToastId
-  warning: (this: void, message: string, options?: ToastOpts) => ToastId
-  success: (this: void, message: string, options?: ToastOpts) => ToastId
-  info: (this: void, message: string, options?: ToastOpts) => ToastId
-  dismiss: (this: void, id: ToastId) => void
-}
-
-export class CurrentToastId extends Context.Opaque<CurrentToastId, { toastId: ToastId }>()("CurrentToastId") {}
-
-/** fallback to CurrentToastId when available unless id is explicitly set to a value or null */
-export const wrap = (toast: ReturnType<UseToast>) => {
-  const wrap = (toastHandler: (message: string, options?: ToastOpts) => ToastId) => {
-    return (message: string, options?: ToastOptsInternal) =>
-      Effect.serviceOption(CurrentToastId).pipe(
-        Effect.flatMap((currentToast) =>
-          Effect.sync(() => {
-            const { id: _id, ...rest } = options ?? {}
-            const id = _id !== undefined
-              ? _id ?? undefined
-              : Option.getOrUndefined(Option.map(currentToast, (_) => _.toastId))
-            // when id is undefined, we may end up with no toast at all..
-            return toastHandler(message, id !== undefined ? { ...rest, id } : rest)
-          })
-        )
-      )
-  }
-  return {
-    error: wrap(toast.error),
-    info: wrap(toast.info),
-    success: wrap(toast.success),
-    warning: wrap(toast.warning),
-    dismiss: (toastId: ToastId) => Effect.sync(() => toast.dismiss(toastId))
-  }
-}
-
-type ToastShape = ReturnType<typeof wrap>
-
-export class Toast extends Context.Opaque<Toast, ToastShape>()("Toast") {
-  static readonly error = accessEffectFn(this, "error")
-  static readonly info = accessEffectFn(this, "info")
-  static readonly success = accessEffectFn(this, "success")
-  static readonly warning = accessEffectFn(this, "warning")
-  static readonly dismiss = accessEffectFn(this, "dismiss")
-}
+export * from "effect-app/toast"

package/src/withToast.ts

@@ -1,133 +1 @@
-import * as Context from "effect-app/Context"
-import * as Effect from "effect-app/Effect"
-import * as Layer from "effect-app/Layer"
-import type * as Option from "effect-app/Option"
-import * as S from "effect-app/Schema"
-import { wrapEffect } from "effect-app/utils"
-import * as Cause from "effect/Cause"
-import * as Fiber from "effect/Fiber"
-import { CurrentToastId, Toast, type ToastId } from "./toast.js"
-
-export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
-  stableToastId?: undefined | string | ((...args: Args) => string | undefined)
-  timeout?: number
-  showSpanInfo?: false
-  groupId?: string
-  onWaiting:
-    | string
-    | ((...args: Args) => string | null)
-    | null
-    | ((
-      ...args: Args
-    ) => Effect.Effect<string | null, never, WaiR>)
-  onSuccess:
-    | string
-    | ((a: A, ...args: Args) => string | null)
-    | null
-    | ((
-      a: A,
-      ...args: Args
-    ) => Effect.Effect<string | null, never, SucR>)
-  onFailure:
-    | string
-    | ((
-      error: Option.Option<E>,
-      ...args: Args
-    ) => string | { level: "warn" | "error"; message: string })
-    | ((
-      error: Option.Option<E>,
-      ...args: Args
-    ) => Effect.Effect<string | { level: "warn" | "error"; message: string }, never, ErrR>)
-}
-
-// @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class WithToast extends Context.Service<WithToast>()("WithToast", {
-  make: Effect.gen(function*() {
-    const toast = yield* Toast
-    return <A, E, Args extends readonly unknown[], R, WaiR = never, SucR = never, ErrR = never>(
-      options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
-    ) =>
-      Effect.fnUntraced(function*(self: Effect.Effect<A, E, R>, ...args: Args) {
-        const baseTimeout = options.timeout ?? 3_000
-
-        const stableToastId = typeof options.stableToastId === "function"
-          ? options.stableToastId(...args)
-          : options.stableToastId
-
-        const requestId: string = yield* Effect.currentSpan.pipe(
-          Effect.map((span) => span.traceId),
-          Effect.orElseSucceed(() => S.StringId.make())
-        )
-        const groupId = options.groupId
-        const meta = { ...(groupId !== undefined ? { groupId } : {}), requestId }
-
-        const t = yield* wrapEffect(options.onWaiting)(...args)
-        const toastId: ToastId | undefined = t === null
-          ? stableToastId
-          : stableToastId ?? `wait-${Math.random().toString(36).slice(2)}`
-
-        const waitingFiber = t === null ? undefined : yield* Effect.forkChild(
-          Effect.sleep("1 seconds").pipe(
-            Effect.andThen(toast.info(t, { id: toastId!, timeout: Infinity, ...meta }))
-          )
-        )
-        const interruptWaiting = waitingFiber ? Fiber.interrupt(waitingFiber) : Effect.void
-
-        return yield* self.pipe(
-          Effect.tap(Effect.fnUntraced(function*(a) {
-            yield* interruptWaiting
-            const t = yield* wrapEffect(options.onSuccess)(a, ...args)
-            if (t === null) {
-              return
-            }
-            yield* toast.success(
-              t,
-              toastId !== undefined
-                ? { id: toastId, timeout: baseTimeout, ...meta }
-                : { timeout: baseTimeout, ...meta }
-            )
-          })),
-          Effect.tapCause(Effect.fnUntraced(function*(cause) {
-            yield* interruptWaiting
-            yield* Effect.logDebug(
-              "WithToast - caught error cause: " + Cause.squash(cause),
-              Cause.hasInterruptsOnly(cause),
-              cause
-            )
-
-            if (Cause.hasInterruptsOnly(cause)) {
-              if (toastId) yield* toast.dismiss(toastId)
-              return
-            }
-
-            const spanInfo = options.showSpanInfo !== false
-              ? yield* Effect.currentSpan.pipe(
-                Effect.map((span) => `\nTrace: ${span.traceId}\nSpan: ${span.spanId}`),
-                Effect.orElseSucceed(() => "")
-              )
-              : ""
-
-            const t = yield* wrapEffect(options.onFailure)(Cause.findErrorOption(cause), ...args)
-            const opts = { timeout: baseTimeout * 2, ...meta }
-
-            if (typeof t === "object") {
-              const message = t.message + spanInfo
-              return t.level === "warn"
-                ? yield* toast.warning(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
-                : yield* toast.error(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
-            }
-            yield* toast.error(t + spanInfo, toastId !== undefined ? { ...opts, id: toastId } : opts)
-          }, Effect.uninterruptible)),
-          toastId !== undefined ? Effect.provideService(CurrentToastId, CurrentToastId.of({ toastId })) : (_) => _
-        )
-      })
-  })
-}) {
-  static readonly DefaultWithoutDependencies = Layer.effect(this, this.make)
-  static readonly Default = this.DefaultWithoutDependencies
-
-  static readonly handle = <A, E, Args extends Array<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
-    options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
-  ): (self: Effect.Effect<A, E, R>, ...args: Args) => Effect.Effect<A, E, R | WaiR | SucR | ErrR | WithToast> =>
-  (self, ...args) => this.use((_) => _<A, E, Args, R, WaiR, SucR, ErrR>(options)(self, ...args))
-}
+export * from "effect-app/withToast"