react-on-rails-pro-node-renderer 16.6.0-rc.0 → 16.6.0

package/src/shared/workerMessages.ts

@@ -0,0 +1,34 @@
+export const WORKER_STARTUP_FAILURE = 'NODE_RENDERER_WORKER_STARTUP_FAILURE' as const;
+
+export interface WorkerStartupFailureMessage {
+  type: typeof WORKER_STARTUP_FAILURE;
+  stage: 'listen';
+  code?: string;
+  errno?: number;
+  syscall?: string;
+  host: string;
+  port: number;
+  message: string;
+}
+
+export function isWorkerStartupFailureMessage(value: unknown): value is WorkerStartupFailureMessage {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+
+  const message = value as Partial<WorkerStartupFailureMessage>;
+
+  // stage: 'listen' is the only supported stage today. To handle pre-listen
+  // failures (e.g. plugin registration), add a new stage value here and
+  // update the master handler accordingly.
+  return (
+    message.type === WORKER_STARTUP_FAILURE &&
+    message.stage === 'listen' &&
+    typeof message.host === 'string' &&
+    typeof message.port === 'number' &&
+    Number.isInteger(message.port) &&
+    message.port >= 0 &&
+    message.port <= 65535 &&
+    typeof message.message === 'string'
+  );
+}

package/src/worker/handleRenderRequest.ts

@@ -22,6 +22,7 @@ import {
   isReadableStream,
   isErrorRenderResult,
   getRequestBundleFilePath,
+  type RequestInfo,
 } from '../shared/utils.js';
 import { getConfig } from '../shared/configBuilder.js';
 import type { TracingContext } from '../shared/tracing.js';
@@ -41,8 +42,14 @@ async function prepareResult(
 
     let exceptionMessage = null;
     if (!result) {
-      const error = new Error('INVALID NIL or NULL result for rendering');
-      exceptionMessage = formatExceptionMessage(renderingRequest, error, 'INVALID result for prepareResult');
+      const error = new Error(
+        'INVALID NIL or NULL result for rendering. Ensure renderingRequest is a valid string and returns a value.',
+      );
+      exceptionMessage = formatExceptionMessage(
+        { renderingRequest },
+        error,
+        'INVALID result for prepareResult',
+      );
     } else if (isErrorRenderResult(result)) {
       ({ exceptionMessage } = result);
     }
@@ -65,7 +72,11 @@ async function prepareResult(
       data: result,
     };
   } catch (err) {
-    const exceptionMessage = formatExceptionMessage(renderingRequest, err, 'Unknown error calling runInVM');
+    const exceptionMessage = formatExceptionMessage(
+      { renderingRequest },
+      err,
+      'Unknown error calling runInVM',
+    );
     return errorResponseResult(exceptionMessage);
   }
 }
@@ -77,7 +88,7 @@ async function prepareResult(
  * @param assetsToCopy might be null
  */
 async function handleNewBundleProvided(
-  requestContext: string,
+  requestContext: RequestInfo,
   providedNewBundle: ProvidedNewBundle,
   assetsToCopy: Asset[] | null | undefined,
 ): Promise<ResponseResult | undefined> {
@@ -154,7 +165,7 @@ to ${bundleFilePathPerTimestamp})`,
 }
 
 export async function handleNewBundlesProvided(
-  requestContext: string,
+  requestContext: RequestInfo,
   providedNewBundles: ProvidedNewBundle[],
   assetsToCopy: Asset[] | null | undefined,
 ): Promise<ResponseResult | undefined> {
@@ -226,7 +237,7 @@ export async function handleRenderRequest({
 
     // If gem has posted updated bundle:
     if (providedNewBundles && providedNewBundles.length > 0) {
-      const result = await handleNewBundlesProvided(renderingRequest, providedNewBundles, assetsToCopy);
+      const result = await handleNewBundlesProvided({ renderingRequest }, providedNewBundles, assetsToCopy);
       if (result) {
         return result;
       }
@@ -261,7 +272,7 @@ export async function handleRenderRequest({
     return await prepareResult(renderingRequest, entryBundleFilePath);
   } catch (error) {
     const msg = formatExceptionMessage(
-      renderingRequest,
+      { renderingRequest },
       error,
       'Caught top level error in handleRenderRequest',
     );

package/src/worker/startupErrorHandler.ts

@@ -0,0 +1,65 @@
+import cluster from 'cluster';
+import log from '../shared/log.js';
+import { WORKER_STARTUP_FAILURE, type WorkerStartupFailureMessage } from '../shared/workerMessages.js';
+
+export type StartupListenErrorHandlerOptions = {
+  err: Error;
+  host: string;
+  port: number;
+  isWorker?: boolean;
+  send?: NodeJS.Process['send'];
+  exit?: NodeJS.Process['exit'];
+};
+
+export function handleStartupListenError({
+  err,
+  host,
+  port,
+  isWorker = cluster.isWorker,
+  send,
+  exit,
+}: StartupListenErrorHandlerOptions) {
+  const sendFn = send ?? process.send?.bind(process);
+  const exitFn = exit ?? ((code?: number) => process.exit(code));
+
+  log.error({ err, host, port }, 'Node renderer failed to start');
+
+  if (isWorker) {
+    if (!sendFn) {
+      log.error('Cluster worker has no IPC channel; cannot notify master of startup failure');
+      exitFn(1);
+      return;
+    }
+
+    const startupFailure: WorkerStartupFailureMessage = {
+      type: WORKER_STARTUP_FAILURE,
+      stage: 'listen',
+      code: (err as NodeJS.ErrnoException).code,
+      errno: (err as NodeJS.ErrnoException).errno,
+      syscall: (err as NodeJS.ErrnoException).syscall,
+      host,
+      port,
+      message: err.message,
+    };
+    try {
+      let exited = false;
+      const doExit = (sendErr?: Error | null) => {
+        if (exited) return;
+        exited = true;
+        if (sendErr) log.error({ err: sendErr }, 'Failed to send startup failure message to master');
+        exitFn(1);
+      };
+      sendFn(startupFailure, undefined, undefined, doExit);
+      // Safety net: if the IPC channel is half-broken the callback may never
+      // fire, leaving this worker alive indefinitely. Force exit after a timeout.
+      const IPC_SEND_TIMEOUT_MS = 2000;
+      const timer = setTimeout(() => doExit(), IPC_SEND_TIMEOUT_MS);
+      if (typeof timer.unref === 'function') timer.unref();
+    } catch (sendErr) {
+      log.error({ err: sendErr as Error }, 'Failed to send startup failure message to master');
+      exitFn(1);
+    }
+  } else {
+    exitFn(1);
+  }
+}

package/src/worker/vm.ts

@@ -153,7 +153,7 @@ ${smartTrim(renderingRequest)}`);
 
     if (isReadableStream(result)) {
       const newStreamAfterHandlingError = handleStreamError(result, (error) => {
-        const msg = formatExceptionMessage(renderingRequest, error, 'Error in a rendering stream');
+        const msg = formatExceptionMessage({ renderingRequest }, error, 'Error in a rendering stream');
         errorReporter.message(msg);
       });
       return newStreamAfterHandlingError;
@@ -172,7 +172,7 @@ ${smartTrim(result)}`);
 
     return result;
   } catch (exception) {
-    const exceptionMessage = formatExceptionMessage(renderingRequest, exception);
+    const exceptionMessage = formatExceptionMessage({ renderingRequest }, exception);
     log.debug('Caught exception in rendering request: %s', exceptionMessage);
     return Promise.resolve({ exceptionMessage });
   }

package/src/worker.ts

@@ -23,7 +23,9 @@ import {
   type ProvidedNewBundle,
 } from './worker/handleRenderRequest.js';
 import handleGracefulShutdown from './worker/handleGracefulShutdown.js';
+import { handleStartupListenError } from './worker/startupErrorHandler.js';
 import {
+  badRequestResponseResult,
   errorResponseResult,
   formatExceptionMessage,
   ResponseResult,
@@ -141,6 +143,56 @@ export const disableHttp2 = () => {
 
 type WithBodyArrayField<T, K extends string> = T & { [P in K | `${K}[]`]?: string | string[] };
 
+const INVALID_CONTENT_LENGTH_ERROR_CODE = 'FST_ERR_CTP_INVALID_CONTENT_LENGTH';
+
+const errorCode = (error: unknown): string | undefined => {
+  const code = (error as { code?: unknown })?.code;
+  return typeof code === 'string' ? code : undefined;
+};
+
+const isValidRenderingRequest = (value: unknown): value is string =>
+  typeof value === 'string' && value.length > 0;
+
+const SENSITIVE_REQUEST_BODY_KEYS = new Set([
+  'password',
+  'token',
+  'secret',
+  'api_key',
+  'api-key',
+  'apikey',
+  'authorization',
+  'auth_token',
+  'auth-token',
+  'authtoken',
+  'access_token',
+  'accesstoken',
+  'bearer',
+  'credentials',
+]);
+
+const invalidRenderingRequestMessage = (body: Record<string, unknown>) => {
+  const { renderingRequest } = body;
+  let renderingRequestType: string = typeof renderingRequest;
+  if (renderingRequest === null) {
+    renderingRequestType = 'null';
+  } else if (Array.isArray(renderingRequest)) {
+    renderingRequestType = 'array';
+  } else if (renderingRequest === '') {
+    renderingRequestType = 'empty string';
+  }
+  const bodyKeys = Object.keys(body).filter(
+    (key) => key !== 'renderingRequest' && !SENSITIVE_REQUEST_BODY_KEYS.has(key.toLowerCase()),
+  );
+
+  return [
+    'Invalid "renderingRequest" field in render request.',
+    'Expected a non-empty string of JavaScript to execute in the SSR VM.',
+    `Received type: ${renderingRequestType}.`,
+    `Received body keys: ${bodyKeys.length > 0 ? bodyKeys.join(', ') : '(none)'}.`,
+    'Likely causes: request body truncation, malformed multipart form data, or Content-Length mismatch in a proxy/client.',
+  ].join('\n');
+};
+
 const extractBodyArrayField = <Key extends string>(
   body: WithBodyArrayField<Record<string, unknown>, Key>,
   key: Key,
@@ -178,7 +230,17 @@ export default function run(config: Partial<Config>) {
   // We shouldn't have unhandled errors here, but just in case
   app.addHook('onError', (req, res, err, done) => {
     // Not errorReporter.error so that integrations can decide how to log the errors.
-    app.log.error({ msg: 'Unhandled Fastify error', err, req, res });
+    if (errorCode(err) === INVALID_CONTENT_LENGTH_ERROR_CODE) {
+      app.log.error({
+        msg: 'Invalid request body framing',
+        hint: 'Body size did not match Content-Length. Check client/proxy truncation and Content-Length handling.',
+        err,
+        req,
+        res,
+      });
+    } else {
+      app.log.error({ msg: 'Unhandled Fastify error', err, req, res });
+    }
     done();
   });
 
@@ -283,12 +345,7 @@ export default function run(config: Partial<Config>) {
   // 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.
   app.post<{
-    Body: WithBodyArrayField<
-      {
-        renderingRequest: string;
-      },
-      'dependencyBundleTimestamps'
-    >;
+    Body: WithBodyArrayField<Record<string, unknown>, 'dependencyBundleTimestamps'>;
     // Can't infer from the route like Express can
     Params: { bundleTimestamp: string; renderRequestDigest: string };
   }>('/bundles/:bundleTimestamp/render/:renderRequestDigest', async (req, res) => {
@@ -307,12 +364,22 @@ export default function run(config: Partial<Config>) {
     //   await delay(100000);
     // }
 
-    const { renderingRequest } = req.body;
+    const { body } = req;
+    if (!body || typeof body !== 'object') {
+      await setResponse(badRequestResponseResult('Invalid or missing request body.'), res);
+      return;
+    }
+    const { renderingRequest } = body;
+    if (!isValidRenderingRequest(renderingRequest)) {
+      await setResponse(badRequestResponseResult(invalidRenderingRequestMessage(body)), res);
+      return;
+    }
+
     const { bundleTimestamp } = req.params;
-    const { providedNewBundles, assetsToCopy } = extractBundlesAndAssets(req.body, bundleTimestamp);
+    const { providedNewBundles, assetsToCopy } = extractBundlesAndAssets(body, bundleTimestamp);
 
     try {
-      const dependencyBundleTimestamps = extractBodyArrayField(req.body, 'dependencyBundleTimestamps');
+      const dependencyBundleTimestamps = extractBodyArrayField(body, 'dependencyBundleTimestamps');
       await trace(async (context) => {
         try {
           const result = await handleRenderRequest({
@@ -326,7 +393,7 @@ export default function run(config: Partial<Config>) {
           await setResponse(result, res);
         } catch (err) {
           const exceptionMessage = formatExceptionMessage(
-            renderingRequest,
+            { renderingRequest },
             err,
             'UNHANDLED error in handleRenderRequest',
           );
@@ -334,7 +401,7 @@ export default function run(config: Partial<Config>) {
         }
       }, startSsrRequestOptions({ renderingRequest }));
     } catch (theErr) {
-      const exceptionMessage = formatExceptionMessage(renderingRequest, theErr);
+      const exceptionMessage = formatExceptionMessage({ renderingRequest }, theErr);
       await setResponse(errorResponseResult(`Unhandled top level error: ${exceptionMessage}`), res);
     }
   });
@@ -371,7 +438,11 @@ export default function run(config: Partial<Config>) {
       // endpoint so that concurrent /upload-assets and render requests
       // targeting the same bundle directory are mutually exclusive.
       // See https://github.com/shakacode/react_on_rails/issues/2463
-      const result = await handleNewBundlesProvided(taskDescription, providedNewBundles, assetsToCopy);
+      const result = await handleNewBundlesProvided(
+        { label: 'Request:', content: taskDescription },
+        providedNewBundles,
+        assetsToCopy,
+      );
       if (result) {
         await setResponse(result, res);
         return;
@@ -449,8 +520,8 @@ export default function run(config: Partial<Config>) {
   if (workersCount === 0 || cluster.isWorker) {
     app.listen({ port, host }, (err, address) => {
       if (err) {
-        log.error({ err, host, port }, 'Node renderer failed to start');
-        process.exit(1);
+        handleStartupListenError({ err, host, port });
+        return;
       }
       const workerName = worker ? `worker #${worker.id}` : 'master (single-process)';
       log.info({ workerName, address }, 'Node renderer listening');

package/tests/configBuilder.test.ts

@@ -1,6 +1,7 @@
 describe('configBuilder', () => {
   const envVarsToRestore = [
     'RENDERER_HOST',
+    'RENDERER_PORT',
     'NODE_ENV',
     'RENDERER_PASSWORD',
     'RAILS_ENV',
@@ -113,6 +114,39 @@ describe('configBuilder', () => {
     expect(finalSettings.password).toBe('<EMPTY STRING>');
   });
 
+  describe('port validation', () => {
+    it('throws when configured port is outside the valid TCP range', () => {
+      process.env.NODE_ENV = 'development';
+      process.env.RAILS_ENV = 'development';
+      const processExit = mockProcessExit();
+      const { buildConfig, error } = loadConfigBuilderWithMockedLogger();
+
+      expect(() => buildConfig({ port: 70000 })).toThrow('process.exit: 1');
+      expect(processExit).toHaveBeenCalledWith(1);
+      expect(error).toHaveBeenCalledWith(
+        'RENDERER_PORT must be an integer between 0 and 65535. Received: 70000',
+      );
+    });
+
+    it('allows port 0 for ephemeral-port test setups', () => {
+      process.env.NODE_ENV = 'development';
+      process.env.RAILS_ENV = 'development';
+      const { buildConfig } = loadConfigBuilderWithMockedLogger();
+
+      expect(buildConfig({ port: 0 }).port).toBe(0);
+    });
+
+    it('coerces a string port from env vars to a number', () => {
+      process.env.NODE_ENV = 'development';
+      process.env.RAILS_ENV = 'development';
+      const { buildConfig } = loadConfigBuilderWithMockedLogger();
+
+      // Simulates `port: env.RENDERER_PORT || 3800` where env var is the string "3800"
+      const config = buildConfig({ port: '3800' as unknown as number });
+      expect(config.port).toBe(3800);
+    });
+  });
+
   describe('password validation in production-like environments', () => {
     it('throws when no password is set in production', () => {
       process.env.NODE_ENV = 'production';