Refactor request handling by consolidating prechecks

- Removed individual protocol version and authentication checks from the request handling flow.
- Introduced a new `performRequestPrechecks` function to streamline the validation process for incoming requests.
- Updated the `authenticate` and `checkProtocolVersion` functions to accept request bodies directly, enhancing modularity.
- Improved error handling by ensuring consistent response structures across precheck validations.

Author: AbanoubGhadban

react_on_rails_pro/packages/node-renderer/src/worker.ts

@@ -13,9 +13,8 @@ import log, { sharedLoggerOptions } from './shared/log';
 import packageJson from './shared/packageJson';
 import { buildConfig, Config, getConfig } from './shared/configBuilder';
 import fileExistsAsync from './shared/fileExistsAsync';
-import type { FastifyInstance, FastifyReply, FastifyRequest } from './worker/types';
-import checkProtocolVersion from './worker/checkProtocolVersionHandler';
-import authenticate from './worker/authHandler';
+import type { FastifyInstance, FastifyReply } from './worker/types';
+import { performRequestPrechecks } from './worker/requestPrechecks';
 import { handleRenderRequest, type ProvidedNewBundle } from './worker/handleRenderRequest';
 import handleGracefulShutdown from './worker/handleGracefulShutdown';
 import {
@@ -174,42 +173,6 @@ export default function run(config: Partial<Config>) {
     done(null, payload);
   });
 
-  const isProtocolVersionMatch = async (req: FastifyRequest, res: FastifyReply) => {
-    // Check protocol version
-    const protocolVersionCheckingResult = checkProtocolVersion(req);
-
-    if (typeof protocolVersionCheckingResult === 'object') {
-      await setResponse(protocolVersionCheckingResult, res);
-      return false;
-    }
-
-    return true;
-  };
-
-  const isAuthenticated = async (req: FastifyRequest, res: FastifyReply) => {
-    // Authenticate Ruby client
-    const authResult = authenticate(req);
-
-    if (typeof authResult === 'object') {
-      await setResponse(authResult, res);
-      return false;
-    }
-
-    return true;
-  };
-
-  const requestPrechecks = async (req: FastifyRequest, res: FastifyReply) => {
-    if (!(await isProtocolVersionMatch(req, res))) {
-      return false;
-    }
-
-    if (!(await isAuthenticated(req, res))) {
-      return false;
-    }
-
-    return true;
-  };
-
   // See https://github.com/shakacode/react_on_rails_pro/issues/119 for why
   // the digest is part of the request URL. Yes, it's not used here, but the
   // server logs might show it to distinguish different requests.
@@ -223,7 +186,9 @@ export default function run(config: Partial<Config>) {
     // Can't infer from the route like Express can
     Params: { bundleTimestamp: string; renderRequestDigest: string };
   }>('/bundles/:bundleTimestamp/render/:renderRequestDigest', async (req, res) => {
-    if (!(await requestPrechecks(req, res))) {
+    const precheckResult = performRequestPrechecks(req.body);
+    if (precheckResult) {
+      await setResponse(precheckResult, res);
       return;
     }
 
@@ -300,26 +265,11 @@ export default function run(config: Partial<Config>) {
           // Build a temporary FastifyRequest shape for protocol/auth check
           const tempReqBody = typeof obj === 'object' && obj !== null ? (obj as Record<string, unknown>) : {};
 
-          // Protocol check
-          const protoResult = checkProtocolVersion({
-            ...req,
-            body: tempReqBody,
-          } as unknown as FastifyRequest);
-          if (typeof protoResult === 'object') {
-            return {
-              response: protoResult,
-              shouldContinue: false,
-            };
-          }
-
-          // Auth check
-          const authResult = authenticate({
-            ...req,
-            body: tempReqBody,
-          } as unknown as FastifyRequest);
-          if (typeof authResult === 'object') {
+          // Perform request prechecks
+          const precheckResult = performRequestPrechecks(tempReqBody);
+          if (precheckResult) {
             return {
-              response: authResult,
+              response: precheckResult,
               shouldContinue: false,
             };
           }
@@ -401,7 +351,9 @@ export default function run(config: Partial<Config>) {
   app.post<{
     Body: WithBodyArrayField<Record<string, Asset>, 'targetBundles'>;
   }>('/upload-assets', async (req, res) => {
-    if (!(await requestPrechecks(req, res))) {
+    const precheckResult = performRequestPrechecks(req.body);
+    if (precheckResult) {
+      await setResponse(precheckResult, res);
       return;
     }
     let lockAcquired = false;
@@ -500,7 +452,9 @@ export default function run(config: Partial<Config>) {
     Querystring: { filename: string };
     Body: WithBodyArrayField<Record<string, unknown>, 'targetBundles'>;
   }>('/asset-exists', async (req, res) => {
-    if (!(await isAuthenticated(req, res))) {
+    const precheckResult = performRequestPrechecks(req.body);
+    if (precheckResult) {
+      await setResponse(precheckResult, res);
       return;
     }
 

react_on_rails_pro/packages/node-renderer/src/worker/authHandler.ts

@@ -6,13 +6,16 @@
  */
 // TODO: Replace with fastify-basic-auth per https://github.com/shakacode/react_on_rails_pro/issues/110
 
-import type { FastifyRequest } from './types';
 import { getConfig } from '../shared/configBuilder';
 
-export = function authenticate(req: FastifyRequest) {
+export interface AuthBody {
+  password?: string;
+}
+
+export function authenticate(body: AuthBody) {
   const { password } = getConfig();
 
-  if (password && password !== (req.body as { password?: string }).password) {
+  if (password && password !== body.password) {
     return {
       headers: { 'Cache-Control': 'no-cache, no-store, max-age=0, must-revalidate' },
       status: 401,
@@ -21,4 +24,4 @@ export = function authenticate(req: FastifyRequest) {
   }
 
   return undefined;
-};
+}

react_on_rails_pro/packages/node-renderer/src/worker/checkProtocolVersionHandler.ts

@@ -2,7 +2,6 @@
  * Logic for checking protocol version.
  * @module worker/checkProtocVersionHandler
  */
-import type { FastifyRequest } from './types';
 import packageJson from '../shared/packageJson';
 import log from '../shared/log';
 
@@ -41,8 +40,8 @@ interface RequestBody {
   railsEnv?: string;
 }
 
-export = function checkProtocolVersion(req: FastifyRequest) {
-  const { protocolVersion: reqProtocolVersion, gemVersion, railsEnv } = req.body as RequestBody;
+export function checkProtocolVersion(body: RequestBody) {
+  const { protocolVersion: reqProtocolVersion, gemVersion, railsEnv } = body;
 
   // Check protocol version
   if (reqProtocolVersion !== packageJson.protocolVersion) {
@@ -52,7 +51,7 @@ export = function checkProtocolVersion(req: FastifyRequest) {
       data: `Unsupported renderer protocol version ${
         reqProtocolVersion
           ? `request protocol ${reqProtocolVersion}`
-          : `MISSING with body ${JSON.stringify(req.body)}`
+          : `MISSING with body ${JSON.stringify(body)}`
       } does not match installed renderer protocol ${packageJson.protocolVersion} for version ${packageJson.version}.
 Update either the renderer or the Rails server`,
     };
@@ -108,4 +107,4 @@ Update either the gem or the node renderer package to match versions.`,
   }
 
   return undefined;
-};
+}

react_on_rails_pro/packages/node-renderer/src/worker/requestPrechecks.ts

@@ -0,0 +1,27 @@
+/**
+ * Request prechecks logic that is independent of the HTTP server framework.
+ * @module worker/requestPrechecks
+ */
+import type { ResponseResult } from '../shared/utils';
+import { checkProtocolVersion, type ProtocolVersionBody } from './checkProtocolVersionHandler';
+import { authenticate, type AuthBody } from './authHandler';
+
+export interface RequestPrechecksBody extends ProtocolVersionBody, AuthBody {
+  [key: string]: unknown;
+}
+
+export function performRequestPrechecks(body: RequestPrechecksBody): ResponseResult | undefined {
+  // Check protocol version
+  const protocolVersionCheckingResult = checkProtocolVersion(body);
+  if (typeof protocolVersionCheckingResult === 'object') {
+    return protocolVersionCheckingResult;
+  }
+
+  // Authenticate Ruby client
+  const authResult = authenticate(body);
+  if (typeof authResult === 'object') {
+    return authResult;
+  }
+
+  return undefined;
+}