enricobuehler
10a0ef3283
The kit had NO biome config and no lint script, while every plugin repo that
consumes it has both. So its source quietly drifted — unused imports, unsorted
imports, formatting — with nothing to catch any of it. Running biome here for
the first time reported 20 findings across 8 files.
Adds `plugin-kit/biome.json` mirroring the plugin repos' (tab indent, double
quotes, recommended lint preset, organizeImports), a `check` script, and
`@biomejs/biome` pinned to the same `^2.5.2` the plugins pin — without that pin
`bunx biome` resolved 2.4.6, which rejects the 2.5 `rules.preset` key.
Two deliberate differences from the plugin repos' copy:
* no `vcs.useIgnoreFile` — those are standalone repos with a .gitignore beside
the config; plugin-kit is a directory inside this one, and biome errors with
"couldn't find an ignore file". The `files.includes` exclusions cover it.
* `!examples/**/dist` instead of `!ui/dist` — the kit has examples, not a UI.
`css.parser.tailwindDirectives` is carried over and is load-bearing: without it
biome cannot parse `@theme` in src/theme.css and reports three parse errors on
CSS that is perfectly valid Tailwind v4.
Everything here is formatter/import churn except two real findings, both fixed:
* `Layer` (library/define.ts) and `Cause` (sync-engine.ts) were imported and
never used;
* test/spike-httpapi.test.ts read `(reg?.body as …).ui.secret` one line after
`expect(reg).toBeDefined()`. The optional chain undoes the assertion: had
`reg` been undefined the `.ui` access would throw a TypeError instead of
failing the test readably. Now asserted to the type system too.
Wired into plugin-kit-publish.yml as a `Lint & format` step ahead of Typecheck,
so this cannot rot again.
Gates after: biome clean (42 files), tsc clean, 67/67 tests, build clean.
84 lines
3.0 KiB
TypeScript
84 lines
3.0 KiB
TypeScript
// Regression: the production shape of sseRoute — a long-lived PubSub-backed stream
|
|
// (the engine's status feed) plus the keepalive. The original suite only covered a
|
|
// finite, self-driving stream, which hid the fact that nothing ever reached the wire.
|
|
import { describe, expect, test } from "bun:test";
|
|
import { Effect, Layer, PubSub, Stream } from "effect";
|
|
import { HttpRouter } from "effect/unstable/http";
|
|
import { httpApiEnv, sseRoute } from "../src/index.js";
|
|
|
|
/**
|
|
* Read until the first bytes arrive or `ms` elapses. One sequential read at a time —
|
|
* re-entering read() while a previous read is pending is a spec violation and silently
|
|
* swallows data (which is exactly how this harness first lied about the ping path).
|
|
*/
|
|
const readSome = async (res: Response, ms: number): Promise<string> => {
|
|
const reader = res.body?.getReader();
|
|
if (!reader) return "";
|
|
const decoder = new TextDecoder();
|
|
let out = "";
|
|
const timer = setTimeout(() => void reader.cancel().catch(() => {}), ms);
|
|
try {
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) break;
|
|
if (value) out += decoder.decode(value, { stream: true });
|
|
if (out.length > 0) break;
|
|
}
|
|
} catch {
|
|
// cancelled by the deadline
|
|
} finally {
|
|
clearTimeout(timer);
|
|
await reader.cancel().catch(() => {});
|
|
}
|
|
return out;
|
|
};
|
|
|
|
describe("sseRoute (live, PubSub-backed)", () => {
|
|
test("delivers frames published AFTER the request opened", async () => {
|
|
const program = Effect.gen(function* () {
|
|
const hub = yield* PubSub.unbounded<{ n: number }>();
|
|
const routes = sseRoute("/api/events", Stream.fromPubSub(hub), {
|
|
event: "status",
|
|
pingSeconds: 0,
|
|
});
|
|
const { handler, dispose } = HttpRouter.toWebHandler(
|
|
Layer.provide(routes, httpApiEnv),
|
|
);
|
|
const res = yield* Effect.promise(() =>
|
|
handler(new Request("http://127.0.0.1/api/events")),
|
|
);
|
|
expect(res.status).toBe(200);
|
|
// Publish only once the response is open — the real engine's pattern.
|
|
setTimeout(() => {
|
|
Effect.runFork(PubSub.publish(hub, { n: 1 }));
|
|
}, 50);
|
|
const body = yield* Effect.promise(() => readSome(res, 3000));
|
|
yield* Effect.promise(() => dispose());
|
|
return body;
|
|
});
|
|
const body = await Effect.runPromise(Effect.scoped(program));
|
|
expect(body).toContain('event: status\ndata: {"n":1}');
|
|
});
|
|
|
|
test("emits a keepalive on an otherwise silent stream", async () => {
|
|
const program = Effect.gen(function* () {
|
|
const hub = yield* PubSub.unbounded<{ n: number }>();
|
|
const routes = sseRoute("/api/events", Stream.fromPubSub(hub), {
|
|
event: "status",
|
|
pingSeconds: 1,
|
|
});
|
|
const { handler, dispose } = HttpRouter.toWebHandler(
|
|
Layer.provide(routes, httpApiEnv),
|
|
);
|
|
const res = yield* Effect.promise(() =>
|
|
handler(new Request("http://127.0.0.1/api/events")),
|
|
);
|
|
const body = yield* Effect.promise(() => readSome(res, 4000));
|
|
yield* Effect.promise(() => dispose());
|
|
return body;
|
|
});
|
|
const body = await Effect.runPromise(Effect.scoped(program));
|
|
expect(body).toContain(": ping");
|
|
});
|
|
});
|