effect-app 4.0.0-beta.32 → 4.0.0-beta.320

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

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAErF,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

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

package/test/rpc.test.ts

@@ -1,6 +1,7 @@
+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 { ForceVoid } from "../src/client/makeClient.js"
 import { S } from "../src/index.js"
 import { RpcContextMap } from "../src/rpc.js"
 
@@ -10,25 +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("ForceVoid decodes and encodes as void", () => {
-  expect(S.decodeUnknownSync(ForceVoid)(undefined)).toBe(undefined)
-  expect(S.is(ForceVoid)(undefined)).toBe(true)
-  expect(S.decodeUnknownSync(ForceVoid)("test")).toBe(undefined)
-  expect(S.is(ForceVoid)("test")).toBe(true)
-  expect(S.encodeUnknownSync(ForceVoid)("test")).toBe(undefined)
-  expect(S.encodeUnknownSync(S.toCodecJson(ForceVoid))("test")).toBe(null)
+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.SchemaIssue.Issue>>()
 })

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>()
+})