react-on-rails-pro-node-renderer 16.4.0 → 16.5.1

package/src/worker.ts

@@ -6,7 +6,7 @@
 import path from 'path';
 import cluster from 'cluster';
 import { randomUUID } from 'crypto';
-import { mkdir, rm } from 'fs/promises';
+import { rm } from 'fs/promises';
 import fastify from 'fastify';
 import fastifyFormbody from '@fastify/formbody';
 import fastifyMultipart from '@fastify/multipart';
@@ -17,21 +17,20 @@ import fileExistsAsync from './shared/fileExistsAsync.js';
 import type { FastifyInstance, FastifyReply, FastifyRequest } from './worker/types.js';
 import checkProtocolVersion from './worker/checkProtocolVersionHandler.js';
 import authenticate from './worker/authHandler.js';
-import { handleRenderRequest, type ProvidedNewBundle } from './worker/handleRenderRequest.js';
+import {
+  handleRenderRequest,
+  handleNewBundlesProvided,
+  type ProvidedNewBundle,
+} from './worker/handleRenderRequest.js';
 import handleGracefulShutdown from './worker/handleGracefulShutdown.js';
 import {
   errorResponseResult,
   formatExceptionMessage,
-  copyUploadedAssets,
   ResponseResult,
-  workerIdLabel,
   saveMultipartFile,
   Asset,
   getAssetPath,
-  getBundleDirectory,
-  getRequestBundleFilePath,
 } from './shared/utils.js';
-import { lock, unlock } from './shared/locks.js';
 import { startSsrRequestOptions, trace } from './shared/tracing.js';
 
 // Uncomment the below for testing timeouts:
@@ -96,6 +95,42 @@ function assertAsset(value: unknown, key: string): asserts value is Asset {
   }
 }
 
+/**
+ * Parses the multipart form body to separate bundle files from shared assets.
+ * Used by both the render and /upload-assets endpoints to avoid duplicating
+ * bundle-vs-asset classification logic.
+ *
+ * @param body  The parsed multipart request body.
+ * @param primaryBundleTimestamp  If provided, a field with key `"bundle"` is
+ *   treated as a bundle for this timestamp (render endpoint convention).
+ */
+function extractBundlesAndAssets(
+  body: Record<string, unknown>,
+  primaryBundleTimestamp?: string | number,
+): { providedNewBundles: ProvidedNewBundle[]; assetsToCopy: Asset[] } {
+  const providedNewBundles: ProvidedNewBundle[] = [];
+  const assetsToCopy: Asset[] = [];
+  Object.entries(body).forEach(([key, value]) => {
+    if (key === 'bundle' && primaryBundleTimestamp != null) {
+      assertAsset(value, key);
+      providedNewBundles.push({ timestamp: primaryBundleTimestamp, bundle: value });
+    } else if (key.startsWith('bundle_')) {
+      const timestamp = key.slice('bundle_'.length);
+      if (!timestamp) {
+        log.warn(
+          'Received form field with key "bundle_" but no hash suffix — possible bug in the Ruby client',
+        );
+      } else {
+        assertAsset(value, key);
+        providedNewBundles.push({ timestamp, bundle: value });
+      }
+    } else if (isAsset(value)) {
+      assetsToCopy.push(value);
+    }
+  });
+  return { providedNewBundles, assetsToCopy };
+}
+
 // Remove after this issue is resolved: https://github.com/fastify/light-my-request/issues/315
 let useHttp2 = true;
 
@@ -271,19 +306,7 @@ export default function run(config: Partial<Config>) {
 
     const { renderingRequest } = req.body;
     const { bundleTimestamp } = req.params;
-    const providedNewBundles: ProvidedNewBundle[] = [];
-    const assetsToCopy: Asset[] = [];
-    Object.entries(req.body).forEach(([key, value]) => {
-      if (key === 'bundle') {
-        assertAsset(value, key);
-        providedNewBundles.push({ timestamp: bundleTimestamp, bundle: value });
-      } else if (key.startsWith('bundle_')) {
-        assertAsset(value, key);
-        providedNewBundles.push({ timestamp: key.replace('bundle_', ''), bundle: value });
-      } else if (isAsset(value)) {
-        assetsToCopy.push(value);
-      }
-    });
+    const { providedNewBundles, assetsToCopy } = extractBundlesAndAssets(req.body, bundleTimestamp);
 
     try {
       const dependencyBundleTimestamps = extractBodyArrayField(req.body, 'dependencyBundleTimestamps');
@@ -315,88 +338,47 @@ export default function run(config: Partial<Config>) {
 
   // There can be additional files that might be required at the runtime.
   // Since the remote renderer doesn't contain any assets, they must be uploaded manually.
+  // Bundle files use the form key convention "bundle_<hash>" and are placed in
+  // their own directory; remaining assets are copied to every bundle directory.
   app.post<{
-    Body: WithBodyArrayField<Record<string, Asset>, 'targetBundles'>;
+    Body: Record<string, unknown>;
   }>('/upload-assets', async (req, res) => {
     if (!(await requestPrechecks(req, res))) {
       return;
     }
-    const assets: Asset[] = Object.values(req.body).filter(isAsset);
 
-    // Handle targetBundles as either a string or an array
-    const targetBundles = extractBodyArrayField(req.body, 'targetBundles');
-    if (!targetBundles || targetBundles.length === 0) {
-      const errorMsg = 'No targetBundles provided. As of protocol version 2.0.0, targetBundles is required.';
+    const { providedNewBundles, assetsToCopy } = extractBundlesAndAssets(req.body);
+
+    if (providedNewBundles.length === 0) {
+      const errorMsg =
+        'No bundle_<hash> fields provided. ' +
+        'The /upload-assets endpoint requires at least one bundle file with a "bundle_<hash>" form key.';
       log.error(errorMsg);
       await setResponse(errorResponseResult(errorMsg), res);
       return;
     }
 
-    const assetsDescription = JSON.stringify(assets.map((asset) => asset.filename));
-    const taskDescription = `Uploading files ${assetsDescription} to bundle directories: ${targetBundles.join(', ')}`;
-
+    const bundleNames = providedNewBundles.map((b) => b.bundle.filename);
+    const assetNames = assetsToCopy.map((a) => a.filename);
+    const taskDescription = `Uploading bundles [${bundleNames.join(', ')}] with assets [${assetNames.join(', ')}]`;
     log.info(taskDescription);
-    try {
-      // Use per-bundle locks (same lock key as handleRenderRequest) so that
-      // asset copies and render-request bundle writes to the same directory
-      // are mutually exclusive. See https://github.com/shakacode/react_on_rails/issues/2463
-      //
-      // Use allSettled (not Promise.all) to ensure every in-flight copy
-      // finishes before the handler returns. Otherwise the onResponse hook
-      // can delete req.uploadDir while background copies still read from it.
-      const copyPromises = targetBundles.map(async (bundleTimestamp) => {
-        const bundleDirectory = getBundleDirectory(bundleTimestamp);
-        await mkdir(bundleDirectory, { recursive: true });
-
-        const bundleFilePath = getRequestBundleFilePath(bundleTimestamp);
-        const { lockfileName, wasLockAcquired, errorMessage } = await lock(bundleFilePath);
-
-        if (!wasLockAcquired) {
-          const msg = formatExceptionMessage(
-            taskDescription,
-            errorMessage,
-            `Failed to acquire lock ${lockfileName}. Worker: ${workerIdLabel()}.`,
-          );
-          throw new Error(msg);
-        }
 
-        try {
-          await copyUploadedAssets(assets, bundleDirectory);
-          log.info(`Copied assets to bundle directory: ${bundleDirectory}`);
-        } finally {
-          try {
-            await unlock(lockfileName);
-          } catch (error) {
-            log.warn({
-              msg: `Error unlocking ${lockfileName} from worker ${workerIdLabel()}`,
-              err: error,
-              task: taskDescription,
-            });
-          }
-        }
-      });
-
-      const results = await Promise.allSettled(copyPromises);
-      const firstFailure = results.find((r): r is PromiseRejectedResult => r.status === 'rejected');
-      if (firstFailure) {
-        throw firstFailure.reason;
+    try {
+      // Reuses the same per-bundle lock + move/copy logic as the render
+      // 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);
+      if (result) {
+        await setResponse(result, res);
+        return;
       }
 
-      await setResponse(
-        {
-          status: 200,
-          headers: {},
-        },
-        res,
-      );
+      await setResponse({ status: 200, headers: {} }, res);
     } catch (err) {
-      const msg = 'ERROR when trying to copy assets';
+      const msg = 'ERROR when trying to upload bundles and assets';
       const message = `${msg}. ${err}. Task: ${taskDescription}`;
-      log.error({
-        msg,
-        err,
-        task: taskDescription,
-      });
+      log.error({ msg, err, task: taskDescription });
       await setResponse(errorResponseResult(message), res);
     }
   });

package/tests/parseWorkersCount.test.ts

@@ -0,0 +1,31 @@
+import { parseWorkersCount } from '../src/ReactOnRailsProNodeRenderer';
+
+describe('parseWorkersCount', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('returns null for missing and blank values', () => {
+    expect(parseWorkersCount(undefined)).toBeNull();
+    expect(parseWorkersCount(null)).toBeNull();
+    expect(parseWorkersCount('')).toBeNull();
+    expect(parseWorkersCount('   ')).toBeNull();
+  });
+
+  it('parses non-negative integers', () => {
+    expect(parseWorkersCount('0')).toBe(0);
+    expect(parseWorkersCount('3')).toBe(3);
+    expect(parseWorkersCount(' 4 ')).toBe(4);
+  });
+
+  it('warns and returns null for invalid values', () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+
+    expect(parseWorkersCount('workers')).toBeNull();
+    expect(parseWorkersCount('3.5')).toBeNull();
+    expect(parseWorkersCount('-1')).toBeNull();
+
+    expect(warnSpy).toHaveBeenCalledTimes(3);
+    expect(warnSpy.mock.calls[0][0]).toContain('Ignoring invalid worker count');
+  });
+});

package/tests/uploadRaceCondition.test.ts

@@ -23,7 +23,7 @@ import formAutoContent from 'form-auto-content';
 // eslint-disable-next-line import/no-relative-packages
 import packageJson from '../package.json';
 import worker, { disableHttp2 } from '../src/worker';
-import { resetForTest, serverBundleCachePath, getFixtureBundle } from './helper';
+import { resetForTest, serverBundleCachePath, getFixtureBundle, getFixtureSecondaryBundle } from './helper';
 
 const testName = 'uploadRaceCondition';
 const serverBundleCachePathForTest = () => serverBundleCachePath(testName);
@@ -176,14 +176,14 @@ describe('concurrent upload isolation (issue #2449)', () => {
         gemVersion,
         protocolVersion,
         railsEnv,
-        targetBundles: [bundleHashA],
+        [`bundle_${bundleHashA}`]: fs.createReadStream(getFixtureBundle()),
         asset1: fs.createReadStream(path.join(tmpDirA, 'loadable-stats.json')),
       });
       const formB = formAutoContent({
         gemVersion,
         protocolVersion,
         railsEnv,
-        targetBundles: [bundleHashB],
+        [`bundle_${bundleHashB}`]: fs.createReadStream(getFixtureBundle()),
         asset1: fs.createReadStream(path.join(tmpDirB, 'loadable-stats.json')),
       });
 
@@ -282,7 +282,7 @@ describe('concurrent upload isolation (issue #2449)', () => {
         gemVersion,
         protocolVersion,
         railsEnv,
-        targetBundles: [bundleHashA],
+        [`bundle_${bundleHashA}`]: fs.createReadStream(getFixtureBundle()),
         asset1: fs.createReadStream(path.join(tmpDirA, 'loadable-stats.json')),
         asset2: fs.createReadStream(path.join(tmpDirA, 'manifest.json')),
       });
@@ -290,7 +290,7 @@ describe('concurrent upload isolation (issue #2449)', () => {
         gemVersion,
         protocolVersion,
         railsEnv,
-        targetBundles: [bundleHashB],
+        [`bundle_${bundleHashB}`]: fs.createReadStream(getFixtureBundle()),
         asset1: fs.createReadStream(path.join(tmpDirB, 'loadable-stats.json')),
         asset2: fs.createReadStream(path.join(tmpDirB, 'manifest.json')),
       });
@@ -349,14 +349,14 @@ describe('concurrent upload isolation (issue #2449)', () => {
         gemVersion,
         protocolVersion,
         railsEnv,
-        targetBundles: [sharedBundleHash],
+        [`bundle_${sharedBundleHash}`]: fs.createReadStream(getFixtureBundle()),
         asset1: fs.createReadStream(path.join(tmpDirA, 'loadable-stats.json')),
       });
       const formB = formAutoContent({
         gemVersion,
         protocolVersion,
         railsEnv,
-        targetBundles: [sharedBundleHash],
+        [`bundle_${sharedBundleHash}`]: fs.createReadStream(getFixtureBundle()),
         asset1: fs.createReadStream(path.join(tmpDirB, 'loadable-stats.json')),
       });
 
@@ -528,12 +528,12 @@ describe('concurrent upload isolation (issue #2449)', () => {
         asset1: fs.createReadStream(path.join(tmpDirA, 'loadable-stats.json')),
       });
 
-      // Upload-assets request: sends the same-named asset to the same bundle
+      // Upload-assets request: sends bundle + the same-named asset to the same bundle
       const uploadForm = formAutoContent({
         gemVersion,
         protocolVersion,
         railsEnv,
-        targetBundles: [bundleTimestamp],
+        [`bundle_${bundleTimestamp}`]: fs.createReadStream(getFixtureBundle()),
         asset1: fs.createReadStream(path.join(tmpDirB, 'loadable-stats.json')),
       });
 

package/tests/worker.test.ts

@@ -332,7 +332,7 @@ describe('worker', () => {
       protocolVersion,
       railsEnv,
       password: 'my_password',
-      targetBundles: [bundleHash],
+      [`bundle_${bundleHash}`]: createReadStream(getFixtureBundle()),
       asset1: createReadStream(getFixtureAsset()),
       asset2: createReadStream(getOtherFixtureAsset()),
     });
@@ -342,6 +342,30 @@ describe('worker', () => {
     expect(fs.existsSync(assetPathOther(testName, bundleHash))).toBe(true);
   });
 
+  test('post /upload-assets ignores targetBundles when bundle_<hash> fields are present (backward compat)', async () => {
+    const bundleHash = 'compat-bundle-hash';
+
+    const app = worker({
+      serverBundleCachePath: serverBundleCachePathForTest(),
+      password: 'my_password',
+    });
+
+    // Simulates the Ruby client sending both bundle_<hash> (new) and targetBundles (legacy).
+    // The endpoint should derive targets from bundle_<hash> and ignore targetBundles.
+    const form = formAutoContent({
+      gemVersion,
+      protocolVersion,
+      railsEnv,
+      password: 'my_password',
+      [`bundle_${bundleHash}`]: createReadStream(getFixtureBundle()),
+      targetBundles: [bundleHash],
+      asset1: createReadStream(getFixtureAsset()),
+    });
+    const res = await app.inject().post(`/upload-assets`).payload(form.payload).headers(form.headers).end();
+    expect(res.statusCode).toBe(200);
+    expect(fs.existsSync(assetPath(testName, bundleHash))).toBe(true);
+  });
+
   test('post /upload-assets with multiple bundles and assets', async () => {
     const bundleHash = 'some-bundle-hash';
     const bundleHashOther = 'some-other-bundle-hash';
@@ -356,7 +380,8 @@ describe('worker', () => {
       protocolVersion,
       railsEnv,
       password: 'my_password',
-      targetBundles: [bundleHash, bundleHashOther],
+      [`bundle_${bundleHash}`]: createReadStream(getFixtureBundle()),
+      [`bundle_${bundleHashOther}`]: createReadStream(getFixtureSecondaryBundle()),
       asset1: createReadStream(getFixtureAsset()),
       asset2: createReadStream(getOtherFixtureAsset()),
     });