@microsoft/power-apps-native-host 0.2.25 → 0.3.3

package/lib/commonjs/auth/AuthContext.js

@@ -36,10 +36,75 @@ const SIGN_IN_SCOPES = ['https://api.powerplatform.com/.default'];
 function getSafeErrorName(error) {
   return error instanceof Error ? error.constructor.name : typeof error;
 }
+function getErrorProperty(error, propertyName) {
+  return error && typeof error === 'object' ? error[propertyName] : undefined;
+}
+function getSafeErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return typeof error === 'string' ? error : String(error);
+}
+function getAuthErrorTelemetry(error) {
+  const errorMessage = getSafeErrorMessage(error);
+  const parsedNSError = /domain=([^\s]+) code=(-?\d+)/.exec(errorMessage);
+  return {
+    errorName: getSafeErrorName(error),
+    errorCode: getErrorProperty(error, 'code'),
+    nativeErrorDomain: getErrorProperty(error, 'nativeErrorDomain') ?? parsedNSError?.[1],
+    nativeErrorCode: getErrorProperty(error, 'nativeErrorCode') ?? parsedNSError?.[2],
+    nativeErrorMessage: errorMessage.slice(0, 512)
+  };
+}
+function getAuthTelemetryProperties(useBroker, useEmbeddedWebView) {
+  return {
+    authMode: useBroker ? 'wrap' : 'nonWrap',
+    platform: _reactNative.Platform.OS,
+    useBroker,
+    useEmbeddedWebView
+  };
+}
+function accountsMatch(left, right) {
+  return left.identifier === right.identifier && left.tenantId === right.tenantId;
+}
+async function validateRequiredScopes(pca, account, scopes) {
+  for (const scope of scopes) {
+    await pca.acquireTokenSilent({
+      scopes: [scope],
+      account
+    });
+  }
+}
+async function acquireRequiredScopesInteractively(pca, scopes) {
+  const [primaryScope, ...additionalScopes] = scopes;
+  const primaryResult = await pca.acquireToken({
+    scopes: [primaryScope],
+    prompt: 'select_account'
+  });
+  const signedInAccount = primaryResult.account;
+  for (const scope of additionalScopes) {
+    try {
+      await pca.acquireTokenSilent({
+        scopes: [scope],
+        account: signedInAccount
+      });
+    } catch {
+      const result = await pca.acquireToken({
+        scopes: [scope],
+        loginHint: signedInAccount.username,
+        prompt: 'login'
+      });
+      if (!accountsMatch(signedInAccount, result.account)) {
+        throw new Error('Sign in with the same account for all required Power Platform permissions.');
+      }
+    }
+  }
+  await validateRequiredScopes(pca, signedInAccount, scopes);
+  return signedInAccount;
+}
 const AuthContext = /*#__PURE__*/(0, _react.createContext)(null);
 function AuthProvider({
   msalConfig,
   intuneConfig,
+  requiredScopes = [],
   children
 }) {
   const [isAuthReady, setIsAuthReady] = (0, _react.useState)(false);
@@ -104,6 +169,8 @@ function AuthProvider({
   // Skip MSAL entirely; treat the session as already signed in so the app
   // renders without requiring credentials.
   const noAuthMode = !effectiveClientId;
+  const requiredScopeKey = [...new Set(requiredScopes)].join('|');
+  const effectiveRequiredScopes = requiredScopeKey ? requiredScopeKey.split('|') : SIGN_IN_SCOPES;
   const pcaRef = (0, _react.useRef)(null);
   (0, _react.useEffect)(() => {
     if (noAuthMode) {
@@ -125,12 +192,22 @@ function AuthProvider({
       } : {})
     });
     pcaRef.current = pca;
-    const authInitScenario = (0, _index.getAppLogger)().trackScenario(_index.HostOperationNames.AuthInit, {
-      useBroker,
-      platform: _reactNative.Platform.OS
-    });
-    pca.init().then(() => pca.getAccounts()).then(accounts => {
-      const restoredAccount = accounts[0] ?? null;
+    const authTelemetryProperties = getAuthTelemetryProperties(useBroker, useEmbeddedWebView);
+    const authInitScenario = (0, _index.getAppLogger)().trackScenario(_index.HostOperationNames.AuthInit, authTelemetryProperties);
+    pca.init().then(() => pca.getAccounts()).then(async accounts => {
+      let restoredAccount = accounts[0] ?? null;
+      if (restoredAccount) {
+        try {
+          await validateRequiredScopes(pca, restoredAccount, effectiveRequiredScopes);
+        } catch (tokenError) {
+          await pca.signOut({
+            account: restoredAccount
+          }).catch(() => undefined);
+          restoredAccount = null;
+          setError(new Error('Your session has expired. Sign in again to continue.'));
+          (0, _logger.debugWarn)('[AuthProvider] restored account is missing a required token:', tokenError);
+        }
+      }
       setAccount(restoredAccount);
       if (restoredAccount) {
         (0, _index.getAppLogger)().identifyUser({
@@ -148,33 +225,28 @@ function AuthProvider({
       setError(e instanceof Error ? e : new Error(String(e)));
       setIsAuthReady(true);
       setIsLoading(false);
-      authInitScenario.fail(undefined, {
-        errorName: getSafeErrorName(e)
-      });
+      authInitScenario.fail(undefined, getAuthErrorTelemetry(e));
     });
     // Re-initialize only when the effective broker/identity settings change.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [effectiveClientId, effectiveTenantId, effectiveRedirectUri, useBroker]);
+  }, [effectiveClientId, effectiveTenantId, effectiveRedirectUri, requiredScopeKey, useBroker]);
   const signIn = (0, _react.useCallback)(async () => {
     const pca = pcaRef.current;
     if (!pca) return;
     setIsLoading(true);
     setError(null);
-    const signInScenario = (0, _index.getAppLogger)().trackScenario(_index.HostOperationNames.AuthSignIn, {
-      useBroker
-    });
+    const authTelemetryProperties = getAuthTelemetryProperties(useBroker, useEmbeddedWebView);
+    const signInScenario = (0, _index.getAppLogger)().trackScenario(_index.HostOperationNames.AuthSignIn, authTelemetryProperties);
     try {
       // If init() failed on mount, retry it now before attempting sign-in.
       if (!pca.isInitialized) {
         await pca.init();
       }
-      const result = await pca.acquireToken({
-        scopes: SIGN_IN_SCOPES
-      });
-      setAccount(result.account);
+      const signedInAccount = await acquireRequiredScopesInteractively(pca, effectiveRequiredScopes);
+      setAccount(signedInAccount);
       (0, _index.getAppLogger)().identifyUser({
-        objectId: result.account.identifier,
-        tenantId: result.account.tenantId
+        objectId: signedInAccount.identifier,
+        tenantId: signedInAccount.tenantId
       });
       // Register the signed-in account with Intune MAM so the SDK can apply
       // app protection policies (PIN, wipe, copy-paste restriction, etc.).
@@ -183,9 +255,9 @@ function AuthProvider({
       if (intuneEnabled) {
         try {
           await (0, _powerAppsNativeAuth.registerAndEnrollAccount)({
-            upn: result.account.username,
-            aadId: result.account.identifier,
-            tenantId: result.account.tenantId
+            upn: signedInAccount.username,
+            aadId: signedInAccount.identifier,
+            tenantId: signedInAccount.tenantId
           });
           (0, _index.getAppLogger)().trackActivityEvent(_index.HostOperationNames.AuthIntuneEnroll);
         } catch (intuneErr) {
@@ -193,20 +265,19 @@ function AuthProvider({
           // Intune Conditional Access on the next token acquisition.
           (0, _logger.debugWarn)('[AuthProvider] Intune enrollment failed:', intuneErr);
           (0, _index.getAppLogger)().trackErrorEvent(_index.HostOperationNames.AuthIntuneEnroll, {
-            errorName: getSafeErrorName(intuneErr)
+            ...authTelemetryProperties,
+            ...getAuthErrorTelemetry(intuneErr)
           });
         }
       }
       signInScenario.complete();
     } catch (e) {
       setError(e instanceof Error ? e : new Error(String(e)));
-      signInScenario.fail(undefined, {
-        errorName: getSafeErrorName(e)
-      });
+      signInScenario.fail(undefined, getAuthErrorTelemetry(e));
     } finally {
       setIsLoading(false);
     }
-  }, [intuneEnabled, useBroker]);
+  }, [intuneEnabled, requiredScopeKey, useBroker]);
   const acquireToken = (0, _react.useCallback)(async scopes => {
     const pca = pcaRef.current;
     if (!pca || !account) return null;
@@ -217,18 +288,24 @@ function AuthProvider({
       });
       return result.accessToken;
     } catch (e) {
-      // Silent acquisition failed — do NOT fall back to interactive here.
-      // Interactive sign-in is handled exclusively by signIn(). Falling back
-      // to interactive from acquireToken triggers an unexpected login webview
-      // whenever a connector needs a token the cache doesn't hold yet.
       (0, _logger.debugWarn)('[AuthContext] acquireTokenSilent failed for scopes:', scopes, e);
       (0, _index.getAppLogger)().trackErrorEvent(_index.HostOperationNames.AuthAcquireTokenSilentFailed, {
+        ...getAuthTelemetryProperties(useBroker, useEmbeddedWebView),
         scopeCount: scopes.length,
-        errorName: getSafeErrorName(e)
+        ...getAuthErrorTelemetry(e)
       });
+      if (scopes.some(scope => effectiveRequiredScopes.includes(scope))) {
+        await pca.signOut({
+          account
+        }).catch(signOutError => {
+          (0, _logger.debugWarn)('[AuthContext] failed to clear an invalid session:', signOutError);
+        });
+        setError(new Error('Your session has expired. Sign in again to continue.'));
+        setAccount(null);
+      }
       return null;
     }
-  }, [account]);
+  }, [account, requiredScopeKey]);
   const signOut = (0, _react.useCallback)(async () => {
     const pca = pcaRef.current;
     if (!pca || !account) return;

package/lib/commonjs/bridge/NativePowerAppsBridge.js

@@ -7,7 +7,9 @@ exports.NativePowerAppsBridge = void 0;
 exports.buildConnectionReferences = buildConnectionReferences;
 var _logger = require("../logger.js");
 var _index = require("../telemetry/index.js");
+var _http = require("@microsoft/power-apps-native-common/http");
 var _powerAppsNativeCommon = require("@microsoft/power-apps-native-common");
+var _bridgeState = require("./bridgeState.js");
 /*!
  * power-apps-native-host — NativePowerAppsBridge
  *
@@ -120,7 +122,7 @@ class NativePowerAppsBridge {
    * via globalThis would have no effect — mutating options is the correct path.
    */
   updateOptions(options) {
-    this._options = options;
+    this._options = (0, _bridgeState.updateBridgeOptionsInPlace)(this._options, options);
   }
   async initialize() {
     // No handshake required for the native path.
@@ -203,10 +205,6 @@ class NativePowerAppsBridge {
       method
     } = requestConfig;
     const urlLabel = (0, _powerAppsNativeCommon.sanitizeUrl)(url.replace(/^https?:\/\/[^/]+/, '').slice(0, 100));
-    const scenario = (0, _index.getAppLogger)().trackScenario(_index.HostOperationNames.BridgeHttpRequest, {
-      httpMethod: method,
-      url: urlLabel
-    });
     const isBlob = bodyParam instanceof Blob;
 
     // The SDK builds Authorization headers with the "paauth" scheme (its web-player
@@ -231,11 +229,12 @@ class NativePowerAppsBridge {
       // SDK passed a plain object — JSON-stringify it as a fallback
       bodyInit = JSON.stringify(bodyParam);
     }
+    bodyInit = (0, _bridgeState.getRequestBodyForMethod)(method, bodyInit);
     headers = normalizeJsonBodyHeaders(headers, bodyInit);
     (0, _logger.debugLog)(`[bridge] → ${method} ${urlLabel}`);
     let response;
     try {
-      response = await fetch(url, {
+      response = await _index.bridgeHttpClient.request(url, {
         method,
         headers: headers,
         body: bodyInit
@@ -243,9 +242,6 @@ class NativePowerAppsBridge {
     } catch (fetchErr) {
       (0, _logger.debugWarn)(`[bridge] fetch THREW for ${method} ${urlLabel}:`, fetchErr);
       (0, _logger.debugLog)(`[bridge] fetch THREW for ${method} ${urlLabel} | req body: ${typeof bodyInit === 'string' ? bodyInit.slice(0, 500) : bodyInit != null ? '<non-string body>' : '<no body>'}`);
-      scenario.fail(undefined, {
-        errorName: getSafeErrorName(fetchErr)
-      });
       throw fetchErr;
     }
     const responseHeaders = {};
@@ -257,14 +253,17 @@ class NativePowerAppsBridge {
       responseHeaders[sdkKey] = value;
     });
     (0, _logger.debugLog)(`[bridge] ${method} ${urlLabel} → ${response.status}`);
+    const correlationProperties = (0, _http.getHttpCorrelationProperties)(response.headers);
     let buffer;
     try {
       buffer = await response.arrayBuffer();
     } catch (readErr) {
       (0, _logger.debugWarn)(`[bridge] HTTP ${response.status} for ${method} ${urlLabel} | failed to read response body:`, readErr);
-      scenario.fail(undefined, {
+      (0, _index.getAppLogger)().trackErrorEvent(_index.HostOperationNames.BridgeHttpRequest, {
+        phase: 'readResponseBody',
         errorName: getSafeErrorName(readErr),
-        httpStatus: response.status
+        httpStatus: response.status,
+        ...correlationProperties
       });
       throw readErr;
     }
@@ -272,14 +271,8 @@ class NativePowerAppsBridge {
       const bodyText = new TextDecoder().decode(buffer).slice(0, 1000);
       (0, _logger.debugWarn)(`[bridge] HTTP ${response.status} for ${method} ${urlLabel} | res: ${bodyText}`);
       (0, _logger.debugLog)(`[bridge] HTTP ${response.status} for ${method} ${urlLabel} | req: ${typeof bodyInit === 'string' ? bodyInit.slice(0, 500) : bodyInit != null ? '<non-string body>' : '<no body>'} | res: ${bodyText}`);
-      scenario.completeWithError({
-        httpStatus: response.status
-      });
-    } else {
-      scenario.complete({
-        httpStatus: response.status
-      });
     }
+    (0, _bridgeState.assertSuccessfulHttpStatus)(response.status, method);
     return [{
       status: response.status,
       headers: responseHeaders

package/lib/commonjs/bridge/PowerPagesBridge.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PowerPagesBridge = void 0;
 exports.setupPowerPagesHost = setupPowerPagesHost;
+var _index = require("../telemetry/index.js");
+var _http = require("@microsoft/power-apps-native-common/http");
 function toPowerPagesUrl(url) {
   const parsedUrl = new URL(url, window.location.origin);
   if (parsedUrl.origin === window.location.origin && parsedUrl.pathname.startsWith('/_api/')) {
@@ -29,7 +31,7 @@ function toPowerPagesUrl(url) {
 let requestVerificationTokenPromise;
 function getRequestVerificationToken() {
   requestVerificationTokenPromise ??= (async () => {
-    const response = await fetch('/_layout/tokenhtml', {
+    const response = await _index.bridgeHttpClient.request('/_layout/tokenhtml', {
       credentials: 'same-origin'
     });
     if (!response.ok) {
@@ -99,17 +101,34 @@ class PowerPagesBridge {
     const body = params[1];
     const powerPagesUrl = toPowerPagesUrl(request.url);
     const token = await getRequestVerificationToken();
-    const response = await fetch(powerPagesUrl, {
-      method: request.method,
-      headers: createHeaders(request.headers, token),
-      body: body || undefined,
-      credentials: 'same-origin'
-    });
+    let response;
+    try {
+      response = await _index.bridgeHttpClient.request(powerPagesUrl, {
+        method: request.method,
+        headers: createHeaders(request.headers, token),
+        body: body || undefined,
+        credentials: 'same-origin'
+      });
+    } catch (error) {
+      throw error;
+    }
+    const correlationProperties = (0, _http.getHttpCorrelationProperties)(response.headers);
     const responseHeaders = {};
     response.headers.forEach((value, name) => {
       responseHeaders[name === 'content-type' ? 'Content-Type' : name] = value;
     });
-    const responseBody = await response.arrayBuffer();
+    let responseBody;
+    try {
+      responseBody = await response.arrayBuffer();
+    } catch (error) {
+      (0, _index.getAppLogger)().trackErrorEvent(_index.HostOperationNames.BridgeHttpRequest, {
+        phase: 'readResponseBody',
+        errorName: error instanceof Error ? error.constructor.name : typeof error,
+        httpStatus: response.status,
+        ...correlationProperties
+      });
+      throw error;
+    }
     if (!response.ok) {
       const responseText = new TextDecoder().decode(responseBody).slice(0, 1000);
       const detail = responseText ? `: ${responseText}` : '';

package/lib/commonjs/bridge/bridgeState.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertSuccessfulHttpStatus = assertSuccessfulHttpStatus;
+exports.getRequestBodyForMethod = getRequestBodyForMethod;
+exports.updateBridgeOptionsInPlace = updateBridgeOptionsInPlace;
+function getRequestBodyForMethod(method, body) {
+  const normalizedMethod = method.toUpperCase();
+  return normalizedMethod === 'GET' || normalizedMethod === 'HEAD' ? null : body;
+}
+function assertSuccessfulHttpStatus(status, method) {
+  if (status >= 200 && status < 300) return;
+  throw new Error(`HTTP ${status} for ${method.toUpperCase()} request`);
+}
+function updateBridgeOptionsInPlace(current, next) {
+  const connections = current.connections;
+  for (const key of Object.keys(connections)) {
+    if (!(key in next.connections)) delete connections[key];
+  }
+  for (const [key, nextConnection] of Object.entries(next.connections)) {
+    const currentConnection = connections[key];
+    if (currentConnection) {
+      for (const property of Object.keys(currentConnection)) {
+        delete currentConnection[property];
+      }
+      Object.assign(currentConnection, nextConnection);
+    } else {
+      connections[key] = nextConnection;
+    }
+  }
+  const dataSources = current.dataSources;
+  dataSources.splice(0, dataSources.length, ...next.dataSources);
+  return {
+    ...next,
+    connections,
+    dataSources
+  };
+}

package/lib/commonjs/config/babelConfig.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPowerAppsBabelConfig = createPowerAppsBabelConfig;
+function createPowerAppsBabelConfig(api, options = {}) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo', ...(options.presets || [])],
+    plugins: [...(options.plugins || []), 'react-native-reanimated/plugin']
+  };
+}

package/lib/commonjs/config/expoConfig.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPowerAppsExpoConfig = createPowerAppsExpoConfig;
+/**
+ * Branding placeholder used when the app supplies no icon/splash of its own.
+ *
+ * Expo only carves out native branding slots for images it knows about at
+ * prebuild time. Passing nothing means no slot is generated, and the wrap
+ * pipeline then has nothing to overwrite — so customer icons and splash
+ * screens silently never appear in the wrapped app. Always supplying a source
+ * guarantees the slots exist and are replaceable:
+ *   Android — res/mipmap-*\/ic_launcher*.png, res/drawable-*\/splashscreen_logo.png
+ *   iOS     — AppIcon and SplashScreenLogo imagesets
+ */
+const PLACEHOLDER_BRANDING_IMAGE = './assets/adaptive-icon.png';
+function createPowerAppsExpoConfig(baseConfig, settings, customize = config => config) {
+  const resolvedIconPath = settings.iconPath || PLACEHOLDER_BRANDING_IMAGE;
+  const resolvedSplashPath = settings.splashPath || process.env.APP_SPLASH_PATH || PLACEHOLDER_BRANDING_IMAGE;
+  const icon = {
+    icon: resolvedIconPath
+  };
+  const adaptiveIcon = {
+    adaptiveIcon: {
+      foregroundImage: resolvedIconPath,
+      backgroundColor: '#ffffff'
+    }
+  };
+  return customize({
+    ...baseConfig,
+    ...icon,
+    name: settings.name,
+    slug: settings.slug,
+    version: settings.version,
+    scheme: settings.scheme,
+    userInterfaceStyle: 'automatic',
+    web: {
+      bundler: 'metro',
+      output: 'static'
+    },
+    platforms: ['ios', 'android', 'web'],
+    experiments: {
+      typedRoutes: true
+    },
+    plugins: [...(settings.isDevClient ? ['expo-dev-client'] : []), 'expo-asset', 'expo-audio', 'expo-font', 'expo-image', 'expo-mail-composer', 'expo-router', 'expo-secure-store', 'expo-sharing', 'expo-video', 'expo-web-browser', '@microsoft/power-apps-native-host', '@microsoft/power-apps-native-offline', '@react-native-community/datetimepicker',
+    // Configured explicitly rather than left to Expo's default so prebuild
+    // emits named, resource-table-registered splash assets the wrap pipeline
+    // can overwrite: res/drawable-*/splashscreen_logo.png on Android and the
+    // SplashScreenLogo imageset on iOS.
+    ['expo-splash-screen', {
+      image: resolvedSplashPath,
+      imageWidth: 200,
+      resizeMode: 'contain',
+      backgroundColor: '#ffffff'
+    }]],
+    android: {
+      package: settings.androidPackage,
+      versionCode: settings.versionCode,
+      ...adaptiveIcon
+    },
+    ios: {
+      supportsTablet: true,
+      bundleIdentifier: settings.iosBundleIdentifier,
+      infoPlist: {
+        LSApplicationQueriesSchemes: ['intunemam', 'ms-acompli', 'msauthv2', 'msauthv3']
+      }
+    }
+  });
+}

package/lib/commonjs/config/metroConfig.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPowerAppsMetroConfig = createPowerAppsMetroConfig;
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _nodeModule = require("node:module");
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _metroConfig = require("expo/metro-config.js");
+var _metroLogger = require("./metroLogger.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function nativeRuntimeVersions(projectRoot) {
+  const appConfig = JSON.parse(_nodeFs.default.readFileSync(_nodePath.default.join(projectRoot, 'app.json'), 'utf8'));
+  const versions = appConfig.expo?.extra?.powerappsNative?.nativeRuntimeVersions;
+  if (!Number.isInteger(versions?.android) || versions.android < 1 || !Number.isInteger(versions?.ios) || versions.ios < 1) {
+    throw new Error('app.json is missing valid expo.extra.powerappsNative.nativeRuntimeVersions');
+  }
+  return versions;
+}
+function templateVersion(projectRoot) {
+  const appConfig = JSON.parse(_nodeFs.default.readFileSync(_nodePath.default.join(projectRoot, 'app.json'), 'utf8'));
+  const version = appConfig.expo?.extra?.powerappsNative?.templateVersion;
+  if (!Number.isInteger(version) || version < 1) {
+    throw new Error('app.json is missing a valid expo.extra.powerappsNative.templateVersion');
+  }
+  return version;
+}
+function createPowerAppsMetroConfig(projectRoot, customize = config => config) {
+  const projectRequire = (0, _nodeModule.createRequire)(_nodePath.default.join(projectRoot, 'package.json'));
+  const config = (0, _metroConfig.getDefaultConfig)(projectRoot);
+  config.resolver.sourceExts = [...config.resolver.sourceExts, 'mjs'];
+  config.server = {
+    ...config.server,
+    enhanceMiddleware: middleware => (0, _metroLogger.withPowerNativeMetroLogging)((request, response, next) => {
+      if (request.url === '/__pawrap_verify') {
+        response.setHeader('Content-Type', 'application/json');
+        response.setHeader('Access-Control-Allow-Origin', '*');
+        response.end(JSON.stringify({
+          type: 'pawrap-app',
+          version: '1',
+          templateVersion: templateVersion(projectRoot),
+          nativeRuntimeVersions: nativeRuntimeVersions(projectRoot)
+        }));
+        return;
+      }
+      middleware(request, response, next);
+    }, {
+      projectRoot
+    })
+  };
+  const defaultResolver = config.resolver.resolveRequest;
+  const resolveRequest = (context, moduleName, platform) => {
+    const isNodeRenderer = context.customResolverOptions?.environment === 'node';
+    if (!isNodeRenderer && (moduleName === 'react' || moduleName.startsWith('react/')) || moduleName === 'react-native' && platform !== 'web' || moduleName.startsWith('@babel/runtime')) {
+      return {
+        filePath: projectRequire.resolve(moduleName, {
+          paths: [_nodePath.default.resolve(projectRoot, 'node_modules')]
+        }),
+        type: 'sourceFile'
+      };
+    }
+    return defaultResolver ? defaultResolver(context, moduleName, platform) : context.resolveRequest(context, moduleName, platform);
+  };
+  config.resolver = {
+    ...config.resolver,
+    resolveRequest
+  };
+  return customize(config);
+}