Enhance asset upload handling to support bundles

- Updated the `/upload-assets` endpoint to differentiate between assets and bundles, allowing for more flexible uploads.
- Introduced logic to extract bundles prefixed with 'bundle_' and handle them separately.
- Integrated the `handleNewBundlesProvided` function to manage the processing of new bundles.
- Added comprehensive tests to verify the correct handling of uploads with various combinations of assets and bundles, including edge cases for empty requests and duplicate bundle hashes.

Author: AbanoubGhadban

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

@@ -16,7 +16,11 @@ import fileExistsAsync from './shared/fileExistsAsync';
 import type { FastifyInstance, FastifyReply } from './worker/types';
 import { performRequestPrechecks } from './worker/requestPrechecks';
 import { AuthBody, authenticate } from './worker/authHandler';
-import { handleRenderRequest, type ProvidedNewBundle } from './worker/handleRenderRequest';
+import {
+  handleRenderRequest,
+  type ProvidedNewBundle,
+  handleNewBundlesProvided,
+} from './worker/handleRenderRequest';
 import handleGracefulShutdown from './worker/handleGracefulShutdown';
 import {
   handleIncrementalRenderRequest,
@@ -357,7 +361,20 @@ export default function run(config: Partial<Config>) {
     }
     let lockAcquired = false;
     let lockfileName: string | undefined;
-    const assets: Asset[] = Object.values(req.body).filter(isAsset);
+    const assets: Asset[] = [];
+
+    // Extract bundles that start with 'bundle_' prefix
+    const bundles: Array<{ timestamp: string; bundle: Asset }> = [];
+    Object.entries(req.body).forEach(([key, value]) => {
+      if (isAsset(value)) {
+        if (key.startsWith('bundle_')) {
+          const timestamp = key.replace('bundle_', '');
+          bundles.push({ timestamp, bundle: value });
+        } else {
+          assets.push(value);
+        }
+      }
+    });
 
     // Handle targetBundles as either a string or an array
     const targetBundles = extractBodyArrayField(req.body, 'targetBundles');
@@ -369,7 +386,9 @@ export default function run(config: Partial<Config>) {
     }
 
     const assetsDescription = JSON.stringify(assets.map((asset) => asset.filename));
-    const taskDescription = `Uploading files ${assetsDescription} to bundle directories: ${targetBundles.join(', ')}`;
+    const bundlesDescription =
+      bundles.length > 0 ? ` and bundles ${JSON.stringify(bundles.map((b) => b.bundle.filename))}` : '';
+    const taskDescription = `Uploading files ${assetsDescription}${bundlesDescription} to bundle directories: ${targetBundles.join(', ')}`;
 
     try {
       const { lockfileName: name, wasLockAcquired, errorMessage } = await lock('transferring-assets');
@@ -408,7 +427,24 @@ export default function run(config: Partial<Config>) {
 
           await Promise.all(assetCopyPromises);
 
-          // Delete assets from uploads directory
+          // Handle bundles using the existing logic from handleRenderRequest
+          if (bundles.length > 0) {
+            const providedNewBundles = bundles.map(({ timestamp, bundle }) => ({
+              timestamp,
+              bundle,
+            }));
+
+            // Use the existing bundle handling logic
+            // Note: handleNewBundlesProvided will handle deleting the uploaded bundle files
+            // Pass null for assetsToCopy since we handle assets separately in this endpoint
+            const bundleResult = await handleNewBundlesProvided('upload-assets', providedNewBundles, null);
+            if (bundleResult) {
+              await setResponse(bundleResult, res);
+              return;
+            }
+          }
+
+          // Delete assets from uploads directory (bundles are already handled by handleNewBundlesProvided)
           await deleteUploadedAssets(assets);
 
           await setResponse(
@@ -419,7 +455,7 @@ export default function run(config: Partial<Config>) {
             res,
           );
         } catch (err) {
-          const msg = 'ERROR when trying to copy assets';
+          const msg = 'ERROR when trying to copy assets and bundles';
           const message = `${msg}. ${err}. Task: ${taskDescription}`;
           log.error({
             msg,

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

@@ -154,7 +154,7 @@ to ${bundleFilePathPerTimestamp})`,
   }
 }
 
-async function handleNewBundlesProvided(
+export async function handleNewBundlesProvided(
   renderingRequest: string,
   providedNewBundles: ProvidedNewBundle[],
   assetsToCopy: Asset[] | null | undefined,

react_on_rails_pro/packages/node-renderer/tests/worker.test.ts

@@ -1,5 +1,6 @@
 import formAutoContent from 'form-auto-content';
 import fs from 'fs';
+import path from 'path';
 import querystring from 'querystring';
 import { createReadStream } from 'fs-extra';
 import worker, { disableHttp2 } from '../src/worker';
@@ -468,4 +469,64 @@ describe('worker', () => {
       expect(res.payload).toBe('{"html":"Dummy Object"}');
     });
   });
+
+  test('post /upload-assets with bundles and assets', async () => {
+    const bundleHash = 'some-bundle-hash';
+    const secondaryBundleHash = 'secondary-bundle-hash';
+
+    const app = worker({
+      serverBundleCachePath: serverBundleCachePathForTest(),
+      password: 'my_password',
+    });
+
+    const form = formAutoContent({
+      gemVersion,
+      protocolVersion,
+      password: 'my_password',
+      targetBundles: [bundleHash, secondaryBundleHash],
+      [`bundle_${bundleHash}`]: createReadStream(getFixtureBundle()),
+      [`bundle_${secondaryBundleHash}`]: createReadStream(getFixtureSecondaryBundle()),
+      asset1: createReadStream(getFixtureAsset()),
+      asset2: createReadStream(getOtherFixtureAsset()),
+    });
+
+    const res = await app.inject().post(`/upload-assets`).payload(form.payload).headers(form.headers).end();
+    expect(res.statusCode).toBe(200);
+
+    // Verify assets are copied to both bundle directories
+    expect(fs.existsSync(assetPath(testName, bundleHash))).toBe(true);
+    expect(fs.existsSync(assetPathOther(testName, bundleHash))).toBe(true);
+    expect(fs.existsSync(assetPath(testName, secondaryBundleHash))).toBe(true);
+    expect(fs.existsSync(assetPathOther(testName, secondaryBundleHash))).toBe(true);
+
+    // Verify bundles are placed in their correct directories
+    const bundle1Path = path.join(serverBundleCachePathForTest(), bundleHash, `${bundleHash}.js`);
+    const bundle2Path = path.join(serverBundleCachePathForTest(), secondaryBundleHash, `${secondaryBundleHash}.js`);
+    expect(fs.existsSync(bundle1Path)).toBe(true);
+    expect(fs.existsSync(bundle2Path)).toBe(true);
+  });
+
+  test('post /upload-assets with only bundles (no assets)', async () => {
+    const bundleHash = 'bundle-only-hash';
+
+    const app = worker({
+      serverBundleCachePath: serverBundleCachePathForTest(),
+      password: 'my_password',
+    });
+
+    const form = formAutoContent({
+      gemVersion,
+      protocolVersion,
+      password: 'my_password',
+      targetBundles: [bundleHash],
+      [`bundle_${bundleHash}`]: createReadStream(getFixtureBundle()),
+    });
+
+    const res = await app.inject().post(`/upload-assets`).payload(form.payload).headers(form.headers).end();
+    expect(res.statusCode).toBe(200);
+
+    // Verify bundle is placed in the correct directory
+    const bundleFilePath = path.join(serverBundleCachePathForTest(), bundleHash, `${bundleHash}.js`);
+    expect(fs.existsSync(bundleFilePath)).toBe(true);
+  });
 });