@remit/doctor 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/doctor",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/cli.ts

@@ -6,6 +6,7 @@ import {
 	NO_VERDICT_EXIT_CODE,
 	renderJson,
 	renderLines,
+	writeVerdict,
 } from "./report.js";
 import { readState } from "./state.js";
 
@@ -31,7 +32,10 @@ const check = async (): Promise<number> => {
 	setLogLevel(config.logLevel);
 	const state = await readState(config.stateDir);
 	const result = await runCheck(config, state.counters);
-	process.stdout.write(json ? renderJson(result) : renderLines(result));
+	await writeVerdict(
+		process.stdout,
+		json ? renderJson(result) : renderLines(result),
+	);
 	return exitCodeFor(result);
 };
 

package/src/index.ts

@@ -10,6 +10,7 @@ export {
 	NO_VERDICT_EXIT_CODE,
 	renderJson,
 	renderLines,
+	writeVerdict,
 } from "./report.js";
 export type { DoctorState } from "./state.js";
 export { initialState, readState, writeState } from "./state.js";

package/src/report.test.ts

@@ -1,6 +1,11 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { exitCodeFor, renderJson, renderLines } from "./report.js";
+import {
+	exitCodeFor,
+	renderJson,
+	renderLines,
+	writeVerdict,
+} from "./report.js";
 import type { CheckResult } from "./verdict.js";
 
 const degraded: CheckResult = {
@@ -163,3 +168,56 @@ describe("exit codes", () => {
 		assert.equal(exitCodeFor(degraded), 1);
 	});
 });
+
+describe("writeVerdict", () => {
+	// The whole point: `process.exit` discards a write the kernel could not
+	// take, so the verdict has to be out of the process before the code is
+	// returned. A stream that reports back-pressure and drains later is what a
+	// pipe under `compose exec -T` does with a long degraded verdict.
+	const backPressured = () => {
+		const chunks: string[] = [];
+		let drain: (() => void) | undefined;
+		return {
+			chunks,
+			release: () => drain?.(),
+			stream: {
+				write(text: string) {
+					chunks.push(text);
+					return false;
+				},
+				once(event: string, listener: () => void) {
+					if (event === "drain") drain = listener;
+					return this;
+				},
+			} as unknown as NodeJS.WritableStream,
+		};
+	};
+
+	it("does not resolve until the stream drains", async () => {
+		const sink = backPressured();
+		let settled = false;
+		const done = writeVerdict(sink.stream, renderLines(degraded)).then(() => {
+			settled = true;
+		});
+		await new Promise((resolve) => setImmediate(resolve));
+		assert.equal(settled, false, "resolved before the stream drained");
+		sink.release();
+		await done;
+		assert.equal(sink.chunks.join(""), renderLines(degraded));
+	});
+
+	it("resolves straight away when the write was taken", async () => {
+		const chunks: string[] = [];
+		const stream = {
+			write(text: string) {
+				chunks.push(text);
+				return true;
+			},
+			once() {
+				assert.fail("waited on drain after a write that was taken");
+			},
+		} as unknown as NodeJS.WritableStream;
+		await writeVerdict(stream, renderJson(healthy));
+		assert.equal(chunks.join(""), renderJson(healthy));
+	});
+});

package/src/report.ts

@@ -104,3 +104,26 @@ export const exitCodeFor = (result: CheckResult): number =>
 	result.verdict === "healthy" ? 0 : 1;
 
 export const NO_VERDICT_EXIT_CODE = 2;
+
+/**
+ * The verdict has to have left the process before it exits.
+ *
+ * `process.exit` does not flush a pending write, and stdout is a pipe under
+ * `compose exec -T`, so a write the kernel could not take in one go is
+ * discarded — silently, and only for the verdicts long enough to fill the
+ * buffer, which are the degraded ones carrying several reasons. The reader
+ * then sees a document that stops mid-token with an exit code saying it is
+ * complete. Waiting for the drain and keeping the explicit exit is what closes
+ * that without letting a lingering socket hold the process open instead.
+ */
+export const writeVerdict = (
+	stream: NodeJS.WritableStream,
+	text: string,
+): Promise<void> =>
+	new Promise((resolve) => {
+		if (stream.write(text)) {
+			resolve();
+			return;
+		}
+		stream.once("drain", () => resolve());
+	});