@microsoft/power-apps-native-host 0.2.22 → 0.3.0

package/lib/module/bridge/PowerPagesBridge.js

@@ -0,0 +1,151 @@
+"use strict";
+
+import { bridgeHttpClient, getAppLogger, HostOperationNames } from "../telemetry/index.js";
+import { getHttpCorrelationProperties } from '@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/')) {
+    return `${parsedUrl.pathname}${parsedUrl.search}`;
+  }
+  const lowerPath = parsedUrl.pathname.toLowerCase();
+  if (lowerPath.includes('/$metadata') || lowerPath.includes('/entitydefinitions') || lowerPath.includes('/$batch') || lowerPath.includes('/microsoft.dynamics.crm.')) {
+    throw new Error(`PowerPagesBridge does not support this Dataverse operation: ${parsedUrl.pathname}`);
+  }
+  const dataverseApiPattern = /\/api\/data\/v\d+(?:\.\d+)+\//gi;
+  let finalMatch = null;
+  let match;
+  while ((match = dataverseApiPattern.exec(parsedUrl.pathname)) !== null) {
+    finalMatch = match;
+  }
+  if (finalMatch?.index === undefined) {
+    throw new Error(`PowerPagesBridge only supports Dataverse Web API requests: ${parsedUrl.pathname}`);
+  }
+  const resourcePath = parsedUrl.pathname.slice(finalMatch.index + finalMatch[0].length);
+  return `/_api/${resourcePath}${parsedUrl.search}`;
+}
+let requestVerificationTokenPromise;
+function getRequestVerificationToken() {
+  requestVerificationTokenPromise ??= (async () => {
+    const response = await bridgeHttpClient.request('/_layout/tokenhtml', {
+      credentials: 'same-origin'
+    });
+    if (!response.ok) {
+      throw new Error(`PowerPagesBridge could not get a CSRF token (${response.status})`);
+    }
+    const tokenDocument = new DOMParser().parseFromString(await response.text(), 'text/html');
+    const token = tokenDocument.querySelector('input[name="__RequestVerificationToken"]')?.getAttribute('value');
+    if (!token) {
+      throw new Error('PowerPagesBridge could not find a CSRF token in /_layout/tokenhtml');
+    }
+    return token;
+  })().catch(error => {
+    requestVerificationTokenPromise = undefined;
+    throw error;
+  });
+  return requestVerificationTokenPromise;
+}
+function createHeaders(headers, token) {
+  const result = new Headers();
+  for (const [name, value] of Object.entries(headers ?? {})) {
+    if (name.toLowerCase() !== 'authorization') {
+      result.set(name, value);
+    }
+  }
+  result.set('__RequestVerificationToken', token);
+  return result;
+}
+export class PowerPagesBridge {
+  constructor(options) {
+    this.options = options;
+  }
+  updateOptions(options) {
+    this.options = options;
+  }
+  async initialize() {}
+  createRequestBody(config) {
+    return config.body ?? '';
+  }
+  async executePluginAsync(pluginName, pluginAction, params) {
+    const pluginKey = `${pluginName}.${pluginAction}`;
+    switch (pluginKey) {
+      case 'AppIdentityServicePlugin.getAppAccessTokenAsync':
+      case 'AppIdentityServicePlugin.getAppDynamicResourceAccessTokenAsync':
+        return '';
+      case 'AppPowerAppsClientPlugin.getAppCdsDataSourceConfigsAsync':
+        return this.options.dataSources;
+      case 'AppPowerAppsClientPlugin.loadAppConnectionsAsync_v2':
+      case 'AppPowerAppsClientPlugin.loadNonCompositeConnectionsAsync':
+        return this.options.connections;
+      case 'AppPowerAppsClientPlugin.resolveCompositeConnectionsAsync':
+        return null;
+      case 'AppHttpClientPlugin.sendHttpAsync':
+        return this.sendHttpAsync(params);
+      case 'PublishedAppTelemetry.trackEvent':
+      case 'PublishedAppTelemetry.trackException':
+      case 'PublishedAppTelemetry.trackMetric':
+      case 'PublishedAppTelemetry.startScenario':
+      case 'PublishedAppTelemetry.endScenario':
+      case 'PublishedAppTelemetry.setDefaultProperties':
+        return undefined;
+      default:
+        throw new Error(`PowerPagesBridge does not support ${pluginKey}`);
+    }
+  }
+  async sendHttpAsync(params) {
+    const request = params[0];
+    const body = params[1];
+    const powerPagesUrl = toPowerPagesUrl(request.url);
+    const token = await getRequestVerificationToken();
+    let response;
+    try {
+      response = await bridgeHttpClient.request(powerPagesUrl, {
+        method: request.method,
+        headers: createHeaders(request.headers, token),
+        body: body || undefined,
+        credentials: 'same-origin'
+      });
+    } catch (error) {
+      throw error;
+    }
+    const correlationProperties = getHttpCorrelationProperties(response.headers);
+    const responseHeaders = {};
+    response.headers.forEach((value, name) => {
+      responseHeaders[name === 'content-type' ? 'Content-Type' : name] = value;
+    });
+    let responseBody;
+    try {
+      responseBody = await response.arrayBuffer();
+    } catch (error) {
+      getAppLogger().trackErrorEvent(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}` : '';
+      // RuntimeDataClient treats JSON tuples as successful before inspecting status.
+      // Reject with its HTTP-plugin error shape so 4xx/5xx responses remain failures.
+      throw [[`Power Pages Web API request failed (${response.status})${detail}`, undefined, {
+        status: response.status,
+        headers: responseHeaders
+      }], responseBody];
+    }
+    return [{
+      status: response.status,
+      headers: responseHeaders
+    }, responseBody];
+  }
+}
+let bridge;
+export function setupPowerPagesHost(options) {
+  if (bridge) {
+    bridge.updateOptions(options);
+    return;
+  }
+  bridge = new PowerPagesBridge(options);
+  globalThis.powerAppsBridge = bridge;
+}

package/lib/module/bridge/bridgeState.js

@@ -0,0 +1,34 @@
+"use strict";
+
+export function getRequestBodyForMethod(method, body) {
+  const normalizedMethod = method.toUpperCase();
+  return normalizedMethod === 'GET' || normalizedMethod === 'HEAD' ? null : body;
+}
+export function assertSuccessfulHttpStatus(status, method) {
+  if (status >= 200 && status < 300) return;
+  throw new Error(`HTTP ${status} for ${method.toUpperCase()} request`);
+}
+export 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
+  };
+}