effect-app 4.0.0-beta.3 → 4.0.0-beta.300

package/src/withToast.ts

@@ -0,0 +1,133 @@
+import * as Cause from "effect/Cause"
+import * as Fiber from "effect/Fiber"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+import type * as Option from "./Option.ts"
+import * as S from "./Schema.ts"
+import { CurrentToastId, Toast, type ToastId } from "./toast.ts"
+import { wrapEffect } from "./utils.ts"
+
+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))
+}

package/test/dist/moreStrings.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moreStrings.test.d.ts","sourceRoot":"","sources":["../moreStrings.test.ts"],"names":[],"mappings":""}

package/test/dist/rpc.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAI0B,KAAK;;;;AAKpC,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}

package/test/dist/rpcMiddlewareContext.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpcMiddlewareContext.test.d.ts","sourceRoot":"","sources":["../rpcMiddlewareContext.test.ts"],"names":[],"mappings":""}

package/test/dist/secretURL.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secretURL.test.d.ts","sourceRoot":"","sources":["../secretURL.test.ts"],"names":[],"mappings":""}

package/test/dist/special.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"special.test.d.ts","sourceRoot":"","sources":["../special.test.ts"],"names":[],"mappings":""}

package/test/moreStrings.test.ts

@@ -0,0 +1,17 @@
+import * as S from "effect-app/Schema"
+import * as fc from "fast-check"
+import { urlAlphabet } from "nanoid"
+import { test } from "vitest"
+
+const nanoidAlphabet = new Set(urlAlphabet)
+
+const isNanoId = (value: string) => value.length === 21 && Array.from(value).every((char) => nanoidAlphabet.has(char))
+
+test("StringId arbitrary generates nanoid-shaped values", () => {
+  fc.assert(
+    fc.property(S.toArbitrary(S.StringId), (value) => {
+      expect(isNanoId(value)).toBe(true)
+      expect(S.is(S.StringId)(value)).toBe(true)
+    })
+  )
+})

package/test/rpc.test.ts

@@ -1,3 +1,6 @@
+import type * as Effect from "effect/Effect"
+import type * as Option from "effect/Option"
+import { expect, test } from "vitest"
 import { makeRpcClient, NotLoggedInError, UnauthorizedError } from "../src/client.js"
 import { S } from "../src/index.js"
 import { RpcContextMap } from "../src/rpc.js"
@@ -8,16 +11,52 @@ export class RequestContextMap extends RpcContextMap.makeMap({
   test: RpcContextMap.make()(S.Never)
 }) {}
 
-const { TaggedRequest } = makeRpcClient(RequestContextMap)
+const stubMiddleware = {
+  requestContextMap: RequestContextMap.config,
+  requestContext: undefined as never
+}
+const { TaggedRequestFor } = makeRpcClient(stubMiddleware)
+const TaggedRequest = TaggedRequestFor("Test").Query
 
 export class Stats extends TaggedRequest<Stats>()("Stats", {}, {
   allowedRoles: ["manager"],
   success: {
-    usersActive24Hours: S.Number,
-    usersActiveLastWeek: S.Number,
-    newUsersLast24Hours: S.Number,
-    newUsersLastWeek: S.Number
+    usersActive24Hours: S.Finite,
+    usersActiveLastWeek: S.Finite,
+    newUsersLast24Hours: S.Finite,
+    newUsersLastWeek: S.Finite
   }
 }) {}
 
-declare const _stats: typeof Stats.success.Type
+declare const _stats: typeof Stats.Type
+declare const _statsSuccess: typeof Stats.success.Type
+declare const _statsError: typeof Stats.error.Type
+declare const _statsRequestType: typeof Stats.type
+
+test("Void decodes and encodes as void", () => {
+  const statsFromMake = Stats.make({})
+  const statsFromMakeOption = Stats.makeOption({})
+  const statsFromMakeEffect = Stats.makeEffect({})
+
+  expect(S.decodeUnknownSync(S.Void)(undefined)).toBe(undefined)
+  expect(S.is(S.Void)(undefined)).toBe(true)
+  expect(S.decodeUnknownSync(S.Void)("test")).toBe(undefined)
+  expect(S.is(S.Void)("test")).toBe(true)
+  expect(S.encodeUnknownSync(S.Void)("test")).toBe(undefined)
+  expect(S.encodeUnknownSync(S.toCodecJson(S.Void))("test")).toBe(null)
+  expectTypeOf<typeof _stats>().toEqualTypeOf<Stats>()
+  expectTypeOf<typeof _statsSuccess>().toEqualTypeOf<{
+    readonly usersActive24Hours: number
+    readonly usersActiveLastWeek: number
+    readonly newUsersLast24Hours: number
+    readonly newUsersLastWeek: number
+  }>()
+  // Resource error carries only `config.error` (and optional `generalErrors`); rcm-derived
+  // middleware errors no longer leak into `resource.error` — they reach the wire via the
+  // middleware tag attached to the rpc group (`rpc.middlewares[*].error` failure-union).
+  expectTypeOf<typeof _statsError>().toEqualTypeOf<never>()
+  expectTypeOf<typeof _statsRequestType>().toEqualTypeOf<"query">()
+  expectTypeOf(statsFromMake).toEqualTypeOf<Stats>()
+  expectTypeOf(statsFromMakeOption).toEqualTypeOf<Option.Option<Stats>>()
+  expectTypeOf(statsFromMakeEffect).toEqualTypeOf<Effect.Effect<Stats, S.SchemaError>>()
+})

package/test/rpcMiddlewareContext.test.ts

@@ -0,0 +1,63 @@
+import { expectTypeOf, test } from "vitest"
+import { makeRpcClient, NotLoggedInError, UnauthorizedError } from "../src/client.js"
+import { RpcContextMap } from "../src/rpc.js"
+
+// A stand-in for an app service (e.g. `UserProfile`) that the `allowAnonymous`
+// inverted middleware provides into the handler context whenever auth is
+// required (i.e. `allowAnonymous` is not `true`).
+interface UserProfile {
+  readonly _tag: "UserProfile"
+}
+
+// Mirrors a real app request-context map: one inverted key providing a service
+// by default (unless opted out), and one custom (role) key.
+class RequestContextMap extends RpcContextMap.makeMap({
+  allowAnonymous: RpcContextMap.makeInverted<UserProfile>()(NotLoggedInError),
+  allowRoles: RpcContextMap.makeCustom()(UnauthorizedError, Array<string>())
+}) {}
+
+type Map = typeof RequestContextMap.config
+
+// The context a handler receives for a given rpc config — exactly the
+// `GetEffectContext<_RC, rpc.config>` the router computes for the handler
+// (see `RpcMiddleware.ts`). Testing it against config literals pins down the
+// middleware semantics directly.
+type CtxFor<Config> = RpcContextMap.GetEffectContext<Map, Config>
+
+test("`GetEffectContext`: the inverted `UserProfile` provision is gated by `allowAnonymous`, not `allowRoles`", () => {
+  // Empty config = nothing opted out → auth required → `UserProfile` provided.
+  expectTypeOf<CtxFor<{}>>().toEqualTypeOf<UserProfile>()
+
+  // `allowRoles` does not gate `UserProfile` — still provided.
+  expectTypeOf<CtxFor<{ allowRoles: ["user"] }>>().toEqualTypeOf<UserProfile>()
+
+  // Negative case: opting into anonymous removes the `UserProfile` provision.
+  expectTypeOf<CtxFor<{ allowAnonymous: true }>>().toBeNever()
+
+  // Anonymous wins over roles for the inverted provision.
+  expectTypeOf<CtxFor<{ allowAnonymous: true; allowRoles: ["user"] }>>().toBeNever()
+
+  // Regression documentation: a config that collapses to `Record<string, never>`
+  // (what the no-config command overload used to produce) WRONGLY drops
+  // `UserProfile` — `keyof Record<string, never>` is `string`, so `allowAnonymous`
+  // satisfies `key extends keyof T`, and `T["allowAnonymous"]` (`never`) `extends
+  // true`, taking the anonymous branch. This is exactly why the overload must
+  // yield `{}` (see the command-builder test below).
+  expectTypeOf<CtxFor<Record<string, never>>>().toBeNever()
+})
+
+// End-to-end guard for the actual fix: a command defined with NO config object
+// must still provide `UserProfile` (auth required by default). This exercises the
+// no-config `Command` overload, which now yields an empty `{}` config instead of
+// `Record<string, never>`.
+const { TaggedRequestFor } = makeRpcClient({
+  requestContextMap: RequestContextMap.config,
+  requestContext: undefined as never
+})
+const Command = TaggedRequestFor("Test").Command
+
+class NoConfigCmd extends Command<NoConfigCmd>()("NoConfigCmd", {}) {}
+
+test("a no-config command still provides the auth-required `UserProfile` service", () => {
+  expectTypeOf<RpcContextMap.GetEffectContext<Map, typeof NoConfigCmd.config>>().toEqualTypeOf<UserProfile>()
+})