mirror of
https://github.com/Effect-TS/effect.git
synced 2026-11-22 05:03:05 +08:00
442 lines
15 KiB
TypeScript
442 lines
15 KiB
TypeScript
import { NodeHttpServer, NodeSocket, NodeSocketServer } from "@effect/platform-node"
|
|
import { assert, describe, it } from "@effect/vitest"
|
|
import { Cause, Deferred, Effect, Exit, Fiber, Layer, Ref, Schedule, Schema, Stream } from "effect"
|
|
import { Entity, EntityProxy, EntityProxyServer, Sharding } from "effect/cluster"
|
|
import { HttpClient, HttpClientRequest, HttpRouter, HttpServer } from "effect/http"
|
|
import type * as NetAddress from "effect/net/NetAddress"
|
|
import { Rpc, RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/rpc"
|
|
import { SocketServer } from "effect/socket"
|
|
import { e2eSuite, UsersClient } from "./fixtures/rpc-e2e.ts"
|
|
import { RpcLayer, User } from "./fixtures/rpc-schemas.ts"
|
|
|
|
describe("RpcServer", () => {
|
|
describe("request defect isolation over HTTP", () => {
|
|
const Ok = Rpc.make("Ok", { success: Schema.String })
|
|
const serverGroup = RpcGroup.make(
|
|
Ok,
|
|
Rpc.make("Invalid", { payload: { value: Schema.String } })
|
|
)
|
|
const clientGroup = RpcGroup.make(
|
|
Ok,
|
|
Rpc.make("Missing"),
|
|
Rpc.make("MissingWithSchemas", { success: Schema.Number, error: Schema.String }),
|
|
Rpc.make("Invalid", { payload: { value: Schema.Number } })
|
|
)
|
|
const Server = HttpRouter.serve(
|
|
RpcServer.layer(serverGroup).pipe(
|
|
Layer.provide(serverGroup.toLayer({
|
|
Ok: () => Effect.succeed("ok"),
|
|
Invalid: () => Effect.void
|
|
})),
|
|
Layer.provideMerge(RpcServer.layerProtocolHttp({ path: "/rpc" }))
|
|
),
|
|
{ disableListenLog: true, disableLogger: true }
|
|
)
|
|
|
|
// Fingerprinted payloads require both peers to share the schema, so a
|
|
// mismatch is reported as a fingerprint error instead of the original
|
|
// diagnostic. The defect still only fails its own request.
|
|
const fingerprintDiagnostic = "Expected matching layout fingerprint"
|
|
const cases = [
|
|
{
|
|
name: "JSON",
|
|
serialization: RpcSerialization.layerJson,
|
|
invalidPayload: ["Expected string", "at [\"value\"]"]
|
|
},
|
|
{
|
|
name: "SchemaBinary",
|
|
serialization: RpcSerialization.layerSchemaBinary(),
|
|
invalidPayload: ["Missing key", "at [\"value\"]"]
|
|
},
|
|
{
|
|
name: "SchemaBinary with fingerprints",
|
|
serialization: RpcSerialization.layerSchemaBinary({ fingerprintPayloads: true }),
|
|
unknownTag: fingerprintDiagnostic,
|
|
invalidPayload: [fingerprintDiagnostic]
|
|
}
|
|
]
|
|
|
|
const assertDie = (exit: Exit.Exit<unknown, unknown>, diagnostics: ReadonlyArray<string>) => {
|
|
assert(Exit.isFailure(exit))
|
|
assert.strictEqual(exit.cause.reasons.length, 1)
|
|
assert.strictEqual(exit.cause.reasons[0]._tag, "Die")
|
|
const diagnostic = String(Cause.squash(exit.cause))
|
|
for (const expected of diagnostics) {
|
|
assert.include(diagnostic, expected)
|
|
}
|
|
}
|
|
|
|
for (const { invalidPayload, name, serialization, unknownTag } of cases) {
|
|
const ClientProtocol = RpcClient.layerProtocolHttp({
|
|
url: "",
|
|
transformClient: HttpClient.mapRequest(HttpClientRequest.appendUrl("/rpc"))
|
|
}).pipe(
|
|
Layer.provideMerge(Server),
|
|
Layer.provide([NodeHttpServer.layerTest, serialization])
|
|
)
|
|
|
|
for (const tag of ["Missing", "MissingWithSchemas"] as const) {
|
|
it.effect(`${name}: unknown tag ${tag} fails only its request and the client remains reusable`, () =>
|
|
Effect.gen(function*() {
|
|
const client = yield* RpcClient.make(clientGroup)
|
|
assert.strictEqual(yield* client.Ok(), "ok")
|
|
const missing = yield* Effect.exit(client[tag]())
|
|
assert.strictEqual(yield* client.Ok(), "ok")
|
|
if (unknownTag === undefined) {
|
|
assert.deepStrictEqual(missing, Exit.die(`Unknown request tag: ${tag}`))
|
|
} else {
|
|
assertDie(missing, [unknownTag])
|
|
}
|
|
}).pipe(Effect.provide(ClientProtocol)))
|
|
}
|
|
|
|
it.effect(`${name}: an invalid payload fails only its request and the client remains reusable`, () =>
|
|
Effect.gen(function*() {
|
|
const client = yield* RpcClient.make(clientGroup)
|
|
assert.strictEqual(yield* client.Ok(), "ok")
|
|
const invalid = yield* Effect.exit(client.Invalid({ value: 42 }))
|
|
assert.strictEqual(yield* client.Ok(), "ok")
|
|
assertDie(invalid, invalidPayload)
|
|
}).pipe(Effect.provide(ClientProtocol)))
|
|
}
|
|
})
|
|
|
|
// http ndjson
|
|
const HttpProtocol = RpcServer.layerProtocolHttp({ path: "/rpc" })
|
|
const HttpNdjsonServer = HttpRouter.serve(
|
|
RpcLayer.pipe(Layer.provideMerge(HttpProtocol)),
|
|
{ disableListenLog: true, disableLogger: true }
|
|
)
|
|
const HttpNdjsonClient = UsersClient.layer.pipe(
|
|
Layer.provide(
|
|
RpcClient.layerProtocolHttp({
|
|
url: "",
|
|
transformClient: HttpClient.mapRequest(HttpClientRequest.appendUrl("/rpc"))
|
|
})
|
|
)
|
|
)
|
|
const CustomDefectLayer = HttpNdjsonClient.pipe(
|
|
Layer.provideMerge(HttpNdjsonServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerNdjson])
|
|
)
|
|
e2eSuite(
|
|
"e2e http ndjson",
|
|
HttpNdjsonClient.pipe(
|
|
Layer.provideMerge(HttpNdjsonServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerNdjson])
|
|
)
|
|
)
|
|
e2eSuite(
|
|
"e2e http SchemaBinary",
|
|
HttpNdjsonClient.pipe(
|
|
Layer.provideMerge(HttpNdjsonServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerSchemaBinary()])
|
|
)
|
|
)
|
|
e2eSuite(
|
|
"e2e http jsonrpc",
|
|
HttpNdjsonClient.pipe(
|
|
Layer.provideMerge(HttpNdjsonServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerNdJsonRpc()])
|
|
)
|
|
)
|
|
|
|
// websocket
|
|
const WsProtocol = RpcServer.layerProtocolWebsocket({ path: "/rpc" })
|
|
const HttpWsServer = HttpRouter.serve(
|
|
RpcLayer.pipe(Layer.provideMerge(WsProtocol)),
|
|
{ disableListenLog: true, disableLogger: true }
|
|
)
|
|
const HttpWsClient = UsersClient.layer.pipe(
|
|
Layer.provide(RpcClient.layerProtocolSocket()),
|
|
Layer.provide(
|
|
Effect.gen(function*() {
|
|
const server = yield* HttpServer.HttpServer
|
|
const address = server.address as NetAddress.InetAddress
|
|
return NodeSocket.layerWebSocket(`http://127.0.0.1:${address.port}/rpc`)
|
|
}).pipe(Layer.unwrap)
|
|
)
|
|
)
|
|
e2eSuite(
|
|
"e2e ws ndjson",
|
|
HttpWsClient.pipe(
|
|
Layer.provideMerge(HttpWsServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerNdjson])
|
|
)
|
|
)
|
|
e2eSuite(
|
|
"e2e ws json",
|
|
HttpWsClient.pipe(
|
|
Layer.provideMerge(HttpWsServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerJson])
|
|
)
|
|
)
|
|
e2eSuite(
|
|
"e2e ws SchemaBinary",
|
|
HttpWsClient.pipe(
|
|
Layer.provideMerge(HttpWsServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerSchemaBinary()])
|
|
)
|
|
)
|
|
e2eSuite(
|
|
"e2e ws jsonrpc",
|
|
HttpWsClient.pipe(
|
|
Layer.provideMerge(HttpWsServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerJsonRpc()])
|
|
)
|
|
)
|
|
|
|
// tcp
|
|
const TcpServer = RpcLayer.pipe(
|
|
Layer.provideMerge(RpcServer.layerProtocolSocketServer),
|
|
Layer.provideMerge(NodeSocketServer.layer({ port: 0 }))
|
|
)
|
|
const TcpClient = UsersClient.layer.pipe(
|
|
Layer.provide(RpcClient.layerProtocolSocket()),
|
|
Layer.provide(
|
|
Effect.gen(function*() {
|
|
const server = yield* SocketServer.SocketServer
|
|
const address = server.address as NetAddress.InetAddress
|
|
return NodeSocket.layerNet({ port: address.port })
|
|
}).pipe(Layer.unwrap)
|
|
)
|
|
)
|
|
e2eSuite(
|
|
"e2e tcp ndjson",
|
|
TcpClient.pipe(
|
|
Layer.provideMerge(TcpServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerNdjson])
|
|
)
|
|
)
|
|
e2eSuite(
|
|
"e2e tcp SchemaBinary",
|
|
TcpClient.pipe(
|
|
Layer.provideMerge(TcpServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerSchemaBinary()])
|
|
)
|
|
)
|
|
e2eSuite(
|
|
"e2e tcp jsonrpc",
|
|
TcpClient.pipe(
|
|
Layer.provideMerge(TcpServer),
|
|
Layer.provide([NodeHttpServer.layerTest, RpcSerialization.layerNdJsonRpc()])
|
|
)
|
|
)
|
|
|
|
// worker
|
|
// const WorkerClient = UsersClient.layer.pipe(
|
|
// Layer.provide(RpcClient.layerProtocolWorker({ size: 1 })),
|
|
// Layer.provide(
|
|
// NodeWorker.layerPlatform(() =>
|
|
// CP.fork(new URL("./fixtures/rpc-worker.ts", import.meta.url), {
|
|
// execPath: "node"
|
|
// })
|
|
// )
|
|
// ),
|
|
// Layer.merge(Layer.succeed(RpcServer.Protocol, {
|
|
// supportsAck: true
|
|
// } as any))
|
|
// )
|
|
// e2eSuite("e2e worker", WorkerClient)
|
|
|
|
describe("RpcTest", () => {
|
|
it.effect("works", () =>
|
|
Effect.gen(function*() {
|
|
const client = yield* UsersClient
|
|
const user = yield* client.GetUser({ id: "1" })
|
|
assert.deepStrictEqual(user, new User({ id: "1", name: "Logged in user" }))
|
|
}).pipe(Effect.provide(UsersClient.layerTest)))
|
|
})
|
|
|
|
describe("custom defect schema", () => {
|
|
it.effect("preserves full defect with custom schema", () =>
|
|
Effect.gen(function*() {
|
|
const client = yield* UsersClient
|
|
const cause = yield* client.ProduceDefectCustom().pipe(
|
|
Effect.sandbox,
|
|
Effect.flip
|
|
)
|
|
const defect = Cause.squash(cause)
|
|
assert.instanceOf(defect, Error)
|
|
assert.strictEqual(defect.name, "CustomDefect")
|
|
assert.strictEqual(defect.message, "detailed error")
|
|
assert.strictEqual(defect.stack, "Error: detailed error\n at handler.ts:1")
|
|
}).pipe(Effect.provide(CustomDefectLayer)))
|
|
})
|
|
|
|
describe("entity proxy", () => {
|
|
it.effect("provides handler context for generated rpc handlers", () =>
|
|
Effect.gen(function*() {
|
|
const TestEntity = Entity.make("TestEntity", [Rpc.make("NoPayload")])
|
|
const TestEntityRpcs = EntityProxy.toRpcGroup(TestEntity)
|
|
const called = yield* Deferred.make<void>()
|
|
const testClient = (entityId: string) => ({
|
|
NoPayload: Effect.fnUntraced(function*(payload: void, options?: { readonly discard?: boolean }) {
|
|
assert.strictEqual(entityId, "id")
|
|
assert.strictEqual(payload, undefined)
|
|
assert.strictEqual(options?.discard, true)
|
|
yield* Deferred.succeed(called, undefined)
|
|
})
|
|
})
|
|
const sharding = Sharding.Sharding.of({
|
|
...({} as Sharding.Sharding["Service"]),
|
|
isShutdown: Effect.succeed(false),
|
|
makeClient: () => Effect.succeed(testClient) as never,
|
|
pollStorage: Effect.void
|
|
})
|
|
|
|
const client = yield* RpcTest.makeClient(TestEntityRpcs).pipe(
|
|
Effect.provide(EntityProxyServer.layerRpcHandlers(TestEntity)),
|
|
Effect.provideService(Sharding.Sharding, sharding)
|
|
)
|
|
|
|
yield* client["TestEntity.NoPayloadDiscard"]({
|
|
entityId: "id",
|
|
payload: undefined
|
|
})
|
|
yield* Deferred.await(called)
|
|
}))
|
|
})
|
|
|
|
// Asserts a failing sibling call does not affect an in-flight Ticker stream on the same connection
|
|
const Ticker = Rpc.make("Ticker", {
|
|
success: Schema.Number,
|
|
stream: true
|
|
})
|
|
|
|
const IsolationClient = RpcClient.layerProtocolSocket().pipe(
|
|
Layer.provide(
|
|
Effect.gen(function*() {
|
|
const server = yield* SocketServer.SocketServer
|
|
const address = server.address as NetAddress.InetAddress
|
|
return NodeSocket.layerNet({ port: address.port })
|
|
}).pipe(Layer.unwrap)
|
|
),
|
|
Layer.provide(RpcSerialization.layerNdjson)
|
|
)
|
|
|
|
const assertTickerSurvives = Effect.fnUntraced(function*<E, R>(
|
|
setup: Effect.Effect<
|
|
{
|
|
readonly ticker: Stream.Stream<number, E>
|
|
readonly failingCall: Effect.Effect<void>
|
|
},
|
|
never,
|
|
R
|
|
>,
|
|
label: string
|
|
) {
|
|
const { failingCall, ticker } = yield* setup
|
|
|
|
const received = yield* Ref.make<Array<number>>([])
|
|
|
|
const tickerFiber = yield* ticker.pipe(
|
|
Stream.runForEach((value) => Ref.update(received, (xs) => [...xs, value])),
|
|
Effect.forkChild
|
|
)
|
|
|
|
yield* Effect.retry(
|
|
Effect.flatMap(
|
|
Ref.get(received),
|
|
(xs) => xs.length >= 2 ? Effect.void : Effect.fail("not enough ticks yet")
|
|
),
|
|
{ schedule: Schedule.spaced("50 millis"), times: 200 }
|
|
)
|
|
|
|
const ticksBefore = (yield* Ref.get(received)).length
|
|
assert.isAtLeast(ticksBefore, 2)
|
|
|
|
yield* failingCall
|
|
|
|
yield* Effect.sleep("300 millis")
|
|
|
|
const ticksAfter = (yield* Ref.get(received)).length
|
|
const tickerStatus = tickerFiber.pollUnsafe()
|
|
|
|
yield* Fiber.interrupt(tickerFiber)
|
|
|
|
assert.isUndefined(tickerStatus, `Ticker stream must still be running after ${label}`)
|
|
assert.isAbove(ticksAfter, ticksBefore, `Ticker stream must keep emitting after ${label}`)
|
|
})
|
|
|
|
describe("unknown-tag isolation", () => {
|
|
const Ghost = Rpc.make("Ghost", {
|
|
payload: { value: Schema.String },
|
|
success: Schema.String
|
|
})
|
|
|
|
const serverGroup = RpcGroup.make(Ticker)
|
|
const clientGroup = RpcGroup.make(Ticker, Ghost)
|
|
|
|
const TickerHandlers = serverGroup.toLayer({
|
|
Ticker: () => Stream.fromSchedule(Schedule.spaced("60 millis"))
|
|
})
|
|
|
|
const IsolationServer = RpcServer.layer(serverGroup).pipe(
|
|
Layer.provide(TickerHandlers),
|
|
Layer.provideMerge(RpcServer.layerProtocolSocketServer),
|
|
Layer.provideMerge(NodeSocketServer.layer({ port: 0 })),
|
|
Layer.provide(RpcSerialization.layerNdjson)
|
|
)
|
|
|
|
it.live(
|
|
"an unknown request tag fails only its own request, not other in-flight streams on the same connection",
|
|
() =>
|
|
assertTickerSurvives(
|
|
Effect.map(RpcClient.make(clientGroup), (client) => ({
|
|
ticker: client.Ticker(),
|
|
failingCall: Effect.gen(function*() {
|
|
const ghostExit = yield* client.Ghost({ value: "boo" }).pipe(Effect.exit)
|
|
assert.isTrue(Exit.isFailure(ghostExit), "Ghost call should fail with the routing miss")
|
|
})
|
|
})),
|
|
"the unknown-tag failure"
|
|
).pipe(Effect.provide(IsolationClient.pipe(Layer.provideMerge(IsolationServer)))),
|
|
{ timeout: 30_000 }
|
|
)
|
|
})
|
|
|
|
describe("fatal-defect isolation", () => {
|
|
const Boom = Rpc.make("Boom", {
|
|
success: Schema.String
|
|
})
|
|
|
|
const group = RpcGroup.make(Ticker, Boom)
|
|
|
|
const Handlers = group.toLayer({
|
|
Ticker: () => Stream.fromSchedule(Schedule.spaced("60 millis")),
|
|
Boom: () => Effect.die("boom")
|
|
})
|
|
|
|
const DefectServer = RpcServer.layer(group, { disableFatalDefects: true }).pipe(
|
|
Layer.provide(Handlers),
|
|
Layer.provideMerge(RpcServer.layerProtocolSocketServer),
|
|
Layer.provideMerge(NodeSocketServer.layer({ port: 0 })),
|
|
Layer.provide(RpcSerialization.layerNdjson)
|
|
)
|
|
|
|
it.live(
|
|
"with disableFatalDefects a handler defect fails only its own request, not other in-flight streams",
|
|
() =>
|
|
assertTickerSurvives(
|
|
Effect.map(RpcClient.make(group), (client) => ({
|
|
ticker: client.Ticker(),
|
|
failingCall: Effect.gen(function*() {
|
|
const boomExit = yield* client.Boom().pipe(Effect.exit)
|
|
if (!Exit.isFailure(boomExit)) {
|
|
return assert.fail("Boom call must fail with the handler defect")
|
|
}
|
|
assert.include(
|
|
String(Cause.squash(boomExit.cause)),
|
|
"boom",
|
|
"the caller must receive the handler defect"
|
|
)
|
|
})
|
|
})),
|
|
"the handler defect"
|
|
).pipe(Effect.provide(IsolationClient.pipe(Layer.provideMerge(DefectServer)))),
|
|
{ timeout: 30_000 }
|
|
)
|
|
})
|
|
})
|