@remit/backend 0.0.78 → 0.0.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/backend",
-  "version": "0.0.78",
+  "version": "0.0.79",
   "description": "Remit Mail Inspector API backend",
   "license": "MIT",
   "author": "",

package/src/handlers/system-update.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import {
+	existsSync,
 	mkdirSync,
 	mkdtempSync,
 	readFileSync,
@@ -71,6 +72,11 @@ const buildEvent = (sub?: string): APIGatewayProxyEvent =>
 		requestContext: sub ? { authorizer: { claims: { sub } } } : {},
 	}) as unknown as APIGatewayProxyEvent;
 
+// The query as openapi-backend hands it over: validated and coerced against the
+// spec, so `refresh` reaches the handler as a boolean or not at all.
+const getContext = (query: Record<string, unknown> = {}): Context =>
+	({ request: { query } }) as unknown as Context;
+
 const postContext = (targetVersion: string): Context =>
 	({ request: { requestBody: { targetVersion } } }) as unknown as Context;
 
@@ -86,8 +92,10 @@ const applySystemUpdate =
 		event: APIGatewayProxyEvent,
 	) => Promise<unknown>;
 
-const getUpdate = (event: APIGatewayProxyEvent) =>
-	getSystemUpdate({} as unknown as Context, event);
+const getUpdate = (
+	event: APIGatewayProxyEvent,
+	query: Record<string, unknown> = {},
+) => getSystemUpdate(getContext(query), event);
 
 const applyUpdate = (targetVersion: string, event: APIGatewayProxyEvent) =>
 	applySystemUpdate(postContext(targetVersion), event);
@@ -130,6 +138,49 @@ describe("GET /system/update", () => {
 		assert.deepEqual(result, okState);
 	});
 
+	it("records a check request on the control volume when refresh is set (#599)", async () => {
+		writeState(okState);
+
+		const result = await getUpdate(buildEvent(USER), { refresh: true });
+
+		// The press reaches the updater through the seam, and the answer is the
+		// stored state — lastCheckedAt included, so the panel can say how old the
+		// verdict it is still showing is.
+		const file = readFileSync(join(controlDir, "check-request.json"), "utf8");
+		assert.deepEqual(JSON.parse(file), {});
+		assert.deepEqual(result, okState);
+	});
+
+	it("records a check request over an unknown version when no state exists yet", async () => {
+		const result = await getUpdate(buildEvent(USER), { refresh: true });
+
+		assert.equal(existsSync(join(controlDir, "check-request.json")), true);
+		assert.deepEqual(result, {
+			currentVersion: "unknown",
+			check: { status: "disabled" },
+			run: null,
+		});
+	});
+
+	it("records nothing when the query carries no refresh", async () => {
+		// `?refresh=1` is rejected by the spec before it reaches here, so the only
+		// value that records a request is the boolean the validator produced.
+		writeState(okState);
+
+		await getUpdate(buildEvent(USER));
+
+		assert.equal(existsSync(join(controlDir, "check-request.json")), false);
+	});
+
+	it("returns 401 and records nothing when a refresh is not authenticated", async () => {
+		writeState(okState);
+
+		const result = await getUpdate(buildEvent(), { refresh: true });
+
+		assert.ok(hasStatus(result, 401));
+		assert.equal(existsSync(join(controlDir, "check-request.json")), false);
+	});
+
 	it("reports an unknown version, not its own process env, when no state file exists", async () => {
 		// The updater owns the running version and writes it into state.json; with
 		// no state file the backend has nothing authoritative, so it says unknown

package/src/handlers/system-update.ts

@@ -112,6 +112,20 @@ const writeRequest = (request: {
 	renameSync(tmp, join(dir, "request.json"));
 };
 
+/**
+ * Record a check request on the control seam (#599). The updater consumes it on
+ * its watch loop and runs a manifest check immediately, so a press of check in
+ * the panel — not just the updater's own cadence — moves `lastCheckedAt`. Like
+ * request.json it is written atomically and carries no authority: its presence
+ * is the whole message, so it is empty.
+ */
+const writeCheckRequest = (): void => {
+	const dir = controlDir();
+	const tmp = join(dir, `.check-request.json.tmp`);
+	writeFileSync(tmp, JSON.stringify({}), { mode: 0o644 });
+	renameSync(tmp, join(dir, "check-request.json"));
+};
+
 /**
  * The resource returned by the POST. The updater has not yet written the
  * authoritative run — it polls the seam — so this bootstraps the run block with
@@ -148,7 +162,7 @@ export const SystemOperations: Record<
 	OperationHandler<SystemOperationIds>
 > = {
 	SystemOperations_getSystemUpdate: async (
-		_context: Context,
+		context: Context,
 		...args: unknown[]
 	): Promise<SystemUpdateResponse | APIGatewayProxyResult> => {
 		const offSurface = guardManifestConfigured();
@@ -157,6 +171,14 @@ export const SystemOperations: Record<
 		const event = args[0] as APIGatewayProxyEvent;
 		if (!getSubFromEvent(event)) return unauthorized();
 
+		// A refresh asks for a fresh answer, and only the updater can fetch one, so
+		// the request goes on the control seam for its watch loop to pick up (#599).
+		// The answer is the stored state as it stands, `lastCheckedAt` included: the
+		// caller holds its own press and watches that timestamp move, so the
+		// response never has to claim a verdict the updater has not reached.
+		const { refresh } = context.request.query as { refresh?: boolean };
+		if (refresh === true) writeCheckRequest();
+
 		return readState() ?? emptyResource();
 	},