effect-app 4.0.0-beta.33 → 4.0.0-beta.331

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,17 +1,62 @@
-import { S } from "effect-app"
-import * as fc from "fast-check"
-import { urlAlphabet } from "nanoid"
+import * as S from "effect-app/Schema"
+import * as Effect from "effect/Effect"
+import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary"
+import { customRandom, 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)
-    })
-  )
+test("StringId make generates nanoid-shaped values", () => {
+  for (let i = 0; i < 20; i++) {
+    const value = S.StringId.make()
+    expect(isNanoId(value)).toBe(true)
+    expect(S.is(S.StringId)(value)).toBe(true)
+  }
+})
+
+test("StringId native Arbitrary samples unique nanoid-shaped values", () => {
+  const samples = Effect.runSync(Arbitrary.sampleEffect(Arbitrary.schema(S.StringId), { count: 20, seed: 5 }))
+  expect(new Set(samples).size).toBe(20)
+  for (const value of samples) {
+    expect(isNanoId(value)).toBe(true)
+    expect(S.is(S.StringId)(value)).toBe(true)
+  }
+})
+
+// Pre Effect 4.0.0-rc.114 StringIdArb (rc.112, 8bd5bfe64):
+//   fc.uint8Array({ minLength: 10 * 21, maxLength: 10 * 21 })
+//     .map((bytes) => customRandom(urlAlphabet, 21, (n) => bytes.subarray(0, n))())
+test("StringId toCodecArbitrary uses the pre-rc.114 StringIdArb byte map", () => {
+  const size = 21
+  const length = 10 * size
+  const stringIdArbMap = (bytes: Uint8Array) => customRandom(urlAlphabet, size, (n) => bytes.subarray(0, n))()
+  const bytes = Uint8Array.from({ length }, (_, i) => (i * 17 + 3) & 0xff)
+  const fromOld = stringIdArbMap(bytes)
+  expect(isNanoId(fromOld)).toBe(true)
+  // Same mapping the schema's toCodecArbitrary decode runs (customRandom + subarray).
+  expect(customRandom(urlAlphabet, size, (n) => bytes.subarray(0, n))()).toBe(fromOld)
+})
+
+test("prefixedStringId native Arbitrary matches pre-rc.114 prefix + nanoid map", () => {
+  const FooId = S.prefixedStringId<S.StringId>()("foo", "FooId")
+  const samples = Effect.runSync(Arbitrary.sampleEffect(Arbitrary.schema(FooId), { count: 10, seed: 5 }))
+  expect(new Set(samples).size).toBe(10)
+  for (const value of samples) {
+    expect(value.startsWith("foo-")).toBe(true)
+    expect(S.is(FooId)(value)).toBe(true)
+    const rest = value.slice("foo-".length)
+    expect(rest.length).toBeGreaterThan(0)
+    expect(Array.from(rest).every((char) => nanoidAlphabet.has(char))).toBe(true)
+  }
+})
+
+test("Url native Arbitrary samples http(s) URLs", () => {
+  const samples = Effect.runSync(Arbitrary.sampleEffect(Arbitrary.schema(S.Url), { count: 10, seed: 5 }))
+  expect(new Set(samples).size).toBeGreaterThan(1)
+  for (const value of samples) {
+    expect(value.startsWith("https://")).toBe(true)
+    expect(S.is(S.Url)(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,7 +11,12 @@ 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"],
@@ -22,13 +28,35 @@ export class Stats extends TaggedRequest<Stats>()("Stats", {}, {
   }
 }) {}
 
-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>()
+})