refactor value injection for turbopack

Author: chargome

packages/nextjs/src/config/turbopack/constructTurbopackConfig.ts

@@ -1,8 +1,8 @@
 import { debug } from '@sentry/core';
 import * as chalk from 'chalk';
-import * as path from 'path';
 import type { RouteManifest } from '../manifest/types';
-import type { NextConfigObject, TurbopackOptions, TurbopackRuleConfigItemOrShortcut } from '../types';
+import type { NextConfigObject, TurbopackMatcherWithRule, TurbopackOptions } from '../types';
+import { generateValueInjectionRules } from './generateValueInjectionRules';
 
 /**
  * Construct a Turbopack config object from a Next.js config object and a Turbopack options object.
@@ -24,48 +24,14 @@ export function constructTurbopackConfig({
     ...userNextConfig.turbopack,
   };
 
-  const isomorphicValues = {
-    _sentryNextJsVersion: nextJsVersion || '',
-  };
-
-  const clientValues = {
-    ...isomorphicValues,
-    _sentryRouteManifest: JSON.stringify(routeManifest),
-  };
-
-  const serverValues = {
-    ...isomorphicValues,
-  };
-
-  // Client value injection
-  newConfig.rules = safelyAddTurbopackRule(newConfig.rules, {
-    matcher: '**/instrumentation-client.*',
-    rule: {
-      loaders: [
-        {
-          loader: path.resolve(__dirname, '..', 'loaders', 'valueInjectionLoader.js'),
-          options: {
-            ...clientValues,
-          },
-        },
-      ],
-    },
+  const valueInjectionRules = generateValueInjectionRules({
+    routeManifest,
+    nextJsVersion,
   });
 
-  // Server value injection
-  newConfig.rules = safelyAddTurbopackRule(newConfig.rules, {
-    matcher: '**/instrumentation.*',
-    rule: {
-      loaders: [
-        {
-          loader: path.resolve(__dirname, '..', 'loaders', 'valueInjectionLoader.js'),
-          options: {
-            ...serverValues,
-          },
-        },
-      ],
-    },
-  });
+  for (const { matcher, rule } of valueInjectionRules) {
+    newConfig.rules = safelyAddTurbopackRule(newConfig.rules, { matcher, rule });
+  }
 
   return newConfig;
 }
@@ -80,7 +46,7 @@ export function constructTurbopackConfig({
  */
 export function safelyAddTurbopackRule(
   existingRules: TurbopackOptions['rules'],
-  { matcher, rule }: { matcher: string; rule: TurbopackRuleConfigItemOrShortcut },
+  { matcher, rule }: TurbopackMatcherWithRule,
 ): TurbopackOptions['rules'] {
   if (!existingRules) {
     return {

packages/nextjs/src/config/turbopack/generateValueInjectionRules.ts

@@ -0,0 +1,68 @@
+import * as path from 'path';
+import type { RouteManifest } from '../manifest/types';
+import type { JSONValue, TurbopackMatcherWithRule } from '../types';
+
+/**
+ * Generate the value injection rules for client and server in turbopack config.
+ */
+export function generateValueInjectionRules({
+  routeManifest,
+  nextJsVersion,
+}: {
+  routeManifest?: RouteManifest;
+  nextJsVersion?: string;
+}): TurbopackMatcherWithRule[] {
+  const rules: TurbopackMatcherWithRule[] = [];
+  const isomorphicValues: Record<string, JSONValue> = {};
+  let clientValues: Record<string, JSONValue> = {};
+  let serverValues: Record<string, JSONValue> = {};
+
+  if (nextJsVersion) {
+    isomorphicValues._sentryNextJsVersion = nextJsVersion;
+  }
+
+  if (routeManifest) {
+    serverValues._sentryRouteManifest = routeManifest;
+  }
+
+  if (Object.keys(isomorphicValues).length > 0) {
+    clientValues = { ...clientValues, ...isomorphicValues };
+    serverValues = { ...serverValues, ...isomorphicValues };
+  }
+
+  // Client value injection
+  if (Object.keys(clientValues).length > 0) {
+    rules.push({
+      matcher: '**/instrumentation-client.*',
+      rule: {
+        loaders: [
+          {
+            loader: path.resolve(__dirname, '..', 'loaders', 'valueInjectionLoader.js'),
+            options: {
+              values: clientValues,
+            },
+          },
+        ],
+      },
+    });
+  }
+
+  // Server value injection
+  if (Object.keys(serverValues).length > 0) {
+    rules.push({
+      matcher: '**/instrumentation.*',
+      rule: {
+        loaders: [
+          {
+            loader: path.resolve(__dirname, '..', 'loaders', 'valueInjectionLoader.js'),
+            options: {
+              values: serverValues,
+            },
+          },
+        ],
+      },
+    });
+  }
+
+  return rules;
+}

packages/nextjs/src/config/types.ts

@@ -621,7 +621,7 @@ export type EnhancedGlobal = typeof GLOBAL_OBJ & {
   SENTRY_RELEASES?: { [key: string]: { id: string } };
 };
 
-type JSONValue = string | number | boolean | JSONValue[] | { [k: string]: JSONValue };
+export type JSONValue = string | number | boolean | JSONValue[] | { [k: string]: JSONValue };
 
 type TurbopackLoaderItem =
   | string
@@ -637,6 +637,11 @@ type TurbopackRuleCondition = {
 
 export type TurbopackRuleConfigItemOrShortcut = TurbopackLoaderItem[] | TurbopackRuleConfigItem;
 
+export type TurbopackMatcherWithRule = {
+  matcher: string;
+  rule: TurbopackRuleConfigItemOrShortcut;
+};
+
 type TurbopackRuleConfigItemOptions = {
   loaders: TurbopackLoaderItem[];
   as?: string;