Allow for async injected values

Author: yoannmoinet

packages/core/src/types.ts

@@ -76,7 +76,8 @@ export type BundlerReport = {
     version: string;
 };
 
-export type ToInjectItem = { type: 'file' | 'code'; value: string; fallback?: ToInjectItem };
+type InjectedValue = string | (() => Promise<string>);
+export type ToInjectItem = { type: 'file' | 'code'; value: InjectedValue; fallback?: ToInjectItem };
 
 export type GetLogger = (name: string) => Logger;
 export type Logger = {

packages/plugins/injection/src/helpers.ts

@@ -11,13 +11,21 @@ import { DISTANT_FILE_RX } from './constants';
 
 const MAX_TIMEOUT_IN_MS = 5000;
 
+export const getInjectedValue = async (item: ToInjectItem): Promise<string> => {
+    if (typeof item.value === 'function') {
+        return item.value();
+    }
+
+    return item.value;
+};
+
 export const processDistantFile = async (
     item: ToInjectItem,
     timeout: number = MAX_TIMEOUT_IN_MS,
 ): Promise<string> => {
     let timeoutId: ReturnType<typeof setTimeout> | undefined;
     return Promise.race([
-        doRequest<string>({ url: item.value }).finally(() => {
+        doRequest<string>({ url: await getInjectedValue(item) }).finally(() => {
             if (timeout) {
                 clearTimeout(timeoutId);
             }
@@ -31,20 +39,24 @@ export const processDistantFile = async (
 };
 
 export const processLocalFile = async (item: ToInjectItem): Promise<string> => {
-    const absolutePath = getAbsolutePath(process.cwd(), item.value);
+    const absolutePath = getAbsolutePath(process.cwd(), await getInjectedValue(item));
     return readFile(absolutePath, { encoding: 'utf-8' });
 };
 
 export const processRawCode = async (item: ToInjectItem): Promise<string> => {
     // TODO: Confirm the code actually executes without errors.
+    if (typeof item.value === 'function') {
+        return item.value();
+    }
     return item.value;
 };
 
 export const processItem = async (item: ToInjectItem, log: Logger): Promise<string> => {
     let result: string;
+    const value = await getInjectedValue(item);
     try {
         if (item.type === 'file') {
-            if (item.value.match(DISTANT_FILE_RX)) {
+            if (value.match(DISTANT_FILE_RX)) {
                 result = await processDistantFile(item);
             } else {
                 result = await processLocalFile(item);
@@ -55,7 +67,7 @@ export const processItem = async (item: ToInjectItem, log: Logger): Promise<stri
             throw new Error(`Invalid item type "${item.type}", only accepts "code" or "file".`);
         }
     } catch (error: any) {
-        const itemId = `${item.type} - ${truncateString(item.value)}`;
+        const itemId = `${item.type} - ${truncateString(value)}`;
         if (item.fallback) {
             // In case of any error, we'll fallback to next item in queue.
             log.warn(`Fallback for "${itemId}": ${error.toString()}`);

packages/tests/src/plugins/injection/helpers.test.ts

@@ -8,6 +8,7 @@ import {
     processItem,
     processLocalFile,
     processDistantFile,
+    getInjectedValue,
 } from '@dd/internal-injection-plugin/helpers';
 import { mockLogger } from '@dd/tests/_jest/helpers/mocks';
 import { vol } from 'memfs';
@@ -39,13 +40,13 @@ const nonExistingDistantFile: ToInjectItem = {
 describe('Injection Plugin Helpers', () => {
     let nockScope: nock.Scope;
 
-    beforeEach(() => {
+    beforeEach(async () => {
         nockScope = nock('https://example.com')
             .get('/distant-file.js')
             .reply(200, distantFileContent);
         // Emulate some fixtures.
         vol.fromJSON({
-            [existingFile.value]: localFileContent,
+            [await getInjectedValue(existingFile)]: localFileContent,
         });
     });