bridge: naming-clarity refactor for broker/webhook payloads (#132)

Author: benvinegar

bin/broker-register.mjs

@@ -173,32 +173,32 @@ export async function generateServerKeyMaterial() {
 export async function fetchBrokerPubkeys(brokerUrl, fetchImpl = fetch) {
   const endpoint = new URL("/api/broker-pubkey", brokerUrl);
 
-  let response;
+  let brokerPubkeyResponse;
   try {
-    response = await fetchImpl(endpoint, { method: "GET" });
+    brokerPubkeyResponse = await fetchImpl(endpoint, { method: "GET" });
   } catch (err) {
     throw new Error(`network failure fetching broker pubkey: ${err instanceof Error ? err.message : "unknown error"}`);
   }
 
-  let body;
+  let brokerPubkeyResponseBody;
   try {
-    body = await response.json();
+    brokerPubkeyResponseBody = await brokerPubkeyResponse.json();
   } catch {
     throw new Error("broker pubkey endpoint returned invalid JSON");
   }
 
-  if (!response.ok || !body?.ok) {
-    const errorMessage = body?.error || `HTTP ${response.status}`;
+  if (!brokerPubkeyResponse.ok || !brokerPubkeyResponseBody?.ok) {
+    const errorMessage = brokerPubkeyResponseBody?.error || `HTTP ${brokerPubkeyResponse.status}`;
     throw new Error(`failed to fetch broker pubkey: ${errorMessage}`);
   }
 
-  if (!isLikelyBase64(body.broker_pubkey) || !isLikelyBase64(body.broker_signing_pubkey)) {
+  if (!isLikelyBase64(brokerPubkeyResponseBody.broker_pubkey) || !isLikelyBase64(brokerPubkeyResponseBody.broker_signing_pubkey)) {
     throw new Error("broker pubkey endpoint returned malformed keys");
   }
 
   return {
-    broker_pubkey: body.broker_pubkey,
-    broker_signing_pubkey: body.broker_signing_pubkey,
+    broker_pubkey: brokerPubkeyResponseBody.broker_pubkey,
+    broker_signing_pubkey: brokerPubkeyResponseBody.broker_signing_pubkey,
   };
 }
 
@@ -279,7 +279,7 @@ export async function registerWithBroker({
   const fetchedBrokerKeys = await fetchBrokerPubkeys(brokerUrl, fetchImpl);
 
   const endpoint = new URL("/api/register", brokerUrl);
-  const payload = {
+  const registerRequestBody = {
     workspace_id: workspaceId,
     server_pubkey: serverKeys.server_pubkey,
     server_signing_pubkey: serverKeys.server_signing_pubkey,
@@ -288,30 +288,30 @@ export async function registerWithBroker({
 
   logger(`Registering workspace ${workspaceId} at ${endpoint}`);
 
-  let response;
+  let registerResponse;
   try {
-    response = await fetchImpl(endpoint, {
+    registerResponse = await fetchImpl(endpoint, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload),
+      body: JSON.stringify(registerRequestBody),
     });
   } catch (err) {
     throw new Error(`network failure registering workspace: ${err instanceof Error ? err.message : "unknown error"}`);
   }
 
-  let body = {};
+  let registerResponseBody = {};
   try {
-    body = await response.json();
+    registerResponseBody = await registerResponse.json();
   } catch {
     // keep default empty body for error handling
   }
 
-  if (!response.ok || !body?.ok) {
-    throw new Error(mapRegisterError(response.status, body?.error));
+  if (!registerResponse.ok || !registerResponseBody?.ok) {
+    throw new Error(mapRegisterError(registerResponse.status, registerResponseBody?.error));
   }
 
-  const registerBrokerPubkey = body?.broker_pubkey;
-  const registerBrokerSigningPubkey = body?.broker_signing_pubkey;
+  const registerBrokerPubkey = registerResponseBody?.broker_pubkey;
+  const registerBrokerSigningPubkey = registerResponseBody?.broker_signing_pubkey;
 
   if (
     registerBrokerPubkey &&
@@ -328,11 +328,11 @@ export async function registerWithBroker({
   }
 
   let decryptedBotToken = null;
-  if (body?.encrypted_bot_token) {
+  if (registerResponseBody?.encrypted_bot_token) {
     logger("Decrypting bot token from broker response...");
     try {
       decryptedBotToken = await decryptSealedBox(
-        body.encrypted_bot_token,
+        registerResponseBody.encrypted_bot_token,
         serverKeys.server_private_key,
         serverKeys.server_pubkey,
       );
@@ -350,13 +350,13 @@ export async function registerWithBroker({
   return {
     broker_pubkey: registerBrokerPubkey || fetchedBrokerKeys.broker_pubkey,
     broker_signing_pubkey: registerBrokerSigningPubkey || fetchedBrokerKeys.broker_signing_pubkey,
-    broker_access_token: body?.broker_access_token,
-    broker_access_token_expires_at: body?.broker_access_token_expires_at,
-    broker_access_token_scopes: Array.isArray(body?.broker_access_token_scopes)
-      ? body.broker_access_token_scopes.filter((scope) => typeof scope === "string")
+    broker_access_token: registerResponseBody?.broker_access_token,
+    broker_access_token_expires_at: registerResponseBody?.broker_access_token_expires_at,
+    broker_access_token_scopes: Array.isArray(registerResponseBody?.broker_access_token_scopes)
+      ? registerResponseBody.broker_access_token_scopes.filter((scope) => typeof scope === "string")
       : undefined,
     decrypted_bot_token: decryptedBotToken,
-    request_payload: payload,
+    request_payload: registerRequestBody,
   };
 }
 

slack-bridge/bridge.mjs

@@ -389,12 +389,12 @@ function startApiServer() {
     }
 
     // Read body
-    let body = "";
-    for await (const chunk of req) body += chunk;
+    let rawApiRequestBody = "";
+    for await (const chunk of req) rawApiRequestBody += chunk;
 
-    let params;
+    let apiRequestBody;
     try {
-      params = JSON.parse(body);
+      apiRequestBody = JSON.parse(rawApiRequestBody);
     } catch {
       res.writeHead(400, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Invalid JSON" }));
@@ -406,14 +406,14 @@ function startApiServer() {
       const pathname = url.pathname;
 
       if (pathname === "/send") {
-        const validationError = validateSendParams(params);
+        const validationError = validateSendParams(apiRequestBody);
         if (validationError) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: validationError }));
           return;
         }
 
-        const { channel, text, thread_ts } = params;
+        const { channel, text, thread_ts } = apiRequestBody;
         const result = await app.client.chat.postMessage({
           token: process.env.SLACK_BOT_TOKEN,
           channel,
@@ -427,7 +427,7 @@ function startApiServer() {
 
       } else if (pathname === "/reply") {
         // Look up thread by friendly ID and post a reply
-        const { thread_id, text } = params;
+        const { thread_id, text } = apiRequestBody;
 
         if (typeof thread_id !== "string" || !thread_id) {
           res.writeHead(400, { "Content-Type": "application/json" });
@@ -464,14 +464,14 @@ function startApiServer() {
         res.end(JSON.stringify({ ok: true, ts: result.ts, channel: result.channel }));
 
       } else if (pathname === "/react") {
-        const validationError = validateReactParams(params);
+        const validationError = validateReactParams(apiRequestBody);
         if (validationError) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: validationError }));
           return;
         }
 
-        const { channel, timestamp, emoji } = params;
+        const { channel, timestamp, emoji } = apiRequestBody;
         await app.client.reactions.add({
           token: process.env.SLACK_BOT_TOKEN,
           channel,