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

package/lib/module/telemetry/OfflineSdkTelemetry.js

@@ -0,0 +1,91 @@
+"use strict";
+
+import { getAppLogger } from '@microsoft/power-apps-native-common';
+import * as OfflineSdk from '@microsoft/power-apps-native-offline';
+
+/**
+ * Operation names for this adapter's own diagnostics, following the
+ * `PowerAppsHost.<Subsystem>.<Action>` convention used by `HostOperationNames`.
+ *
+ * Declared locally rather than imported from `./index`: this module must stay
+ * fail-open and side-effect free, and the barrel constructs HTTP clients at
+ * import time. Two string constants are not worth that dependency.
+ */
+const OfflineTelemetryBindFailed = 'PowerAppsHost.Offline.TelemetryBind.Failed';
+const OfflineTelemetryUnbindFailed = 'PowerAppsHost.Offline.TelemetryUnbind.Failed';
+
+/**
+ * Non-sensitive error discriminator. Records the error's constructor name only,
+ * never its message, so diagnostics cannot leak user or tenant data.
+ */
+function getSafeErrorName(error) {
+  return error instanceof Error ? error.constructor.name : typeof error;
+}
+
+/**
+ * True when the resolved SDK exposes the v1 host-telemetry transport.
+ *
+ * Reading a missing export yields `undefined` rather than throwing, so this
+ * probe is safe on SDK builds that predate the transport. Keeping it separate
+ * from the `try`/`catch` below is what lets an out-of-range SDK stay a silent,
+ * expected no-op while genuine wiring failures still get reported.
+ *
+ * The version equality matters as much as the `typeof`: a future transport
+ * revision with a different sink shape would accept a v1 sink and silently
+ * malform every event rather than throw.
+ */
+function isTransportSupported() {
+  return typeof OfflineSdk.configureOfflineHostTelemetry === 'function' && OfflineSdk.OFFLINE_HOST_TELEMETRY_TRANSPORT_VERSION === 1;
+}
+
+/**
+ * Forwards the privacy-safe Offline SDK transport through the host's existing
+ * app logger so offline events carry the same session, device, and user data.
+ *
+ * The host owns exactly one thing here: binding the SDK transport to this
+ * host's logger. Buffering and teardown semantics live in the SDK.
+ *
+ * Setup and teardown are fail-open but not silent. This runs from an effect in
+ * the provider that roots the app, so an unguarded throw would take down the
+ * whole tree — telemetry is never worth an app that will not start. An
+ * unexpected failure is therefore downgraded to a logged diagnostic rather than
+ * swallowed, so broken wiring stays observable.
+ */
+export function configureOfflineSdkTelemetry(forwardEvents) {
+  if (!isTransportSupported()) {
+    return () => undefined;
+  }
+  const stopForwarding = () => {
+    try {
+      OfflineSdk.configureOfflineHostTelemetry(undefined);
+    } catch (e) {
+      getAppLogger().trackErrorEvent(OfflineTelemetryUnbindFailed, {
+        errorName: getSafeErrorName(e)
+      });
+    }
+  };
+  if (!forwardEvents) {
+    stopForwarding();
+    return stopForwarding;
+  }
+  try {
+    OfflineSdk.configureOfflineHostTelemetry({
+      // Resolved per event, not captured: the Dev Player swaps the logger when
+      // it switches apps, and a captured instance would strand events.
+      //
+      // `name` is the operation name only. Deliberately not passed as the
+      // optional third `eventName` argument: that overrides the canonical
+      // `PowerAppsClient.Activity`/`.Error` 1DS event names, which would hide
+      // every offline event from the queries and dashboards that filter on
+      // them. The name already reaches 1DS as `operation_Name`.
+      trackActivityEvent: (name, properties) => getAppLogger().trackActivityEvent(name, properties),
+      trackErrorEvent: (name, properties) => getAppLogger().trackErrorEvent(name, properties)
+    });
+  } catch (e) {
+    getAppLogger().trackErrorEvent(OfflineTelemetryBindFailed, {
+      errorName: getSafeErrorName(e)
+    });
+    return () => undefined;
+  }
+  return stopForwarding;
+}

package/lib/module/telemetry/OfflineSdkTelemetry.web.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export function configureOfflineSdkTelemetry(_forwardEvents) {
+  return () => undefined;
+}

package/lib/module/telemetry/index.js

@@ -10,8 +10,9 @@
  * alongside the canonical host operation-name constants.
  */
 
-export { getAppLogger, configureAppLogger } from '@microsoft/power-apps-native-common';
-
+import { HttpClient } from '@microsoft/power-apps-native-common/http';
+import { isDebugLoggingEnabled } from "../logger.js";
+export { getAppLogger, configureAppLogger, getCustomerTelemetryLogger } from '@microsoft/power-apps-native-common';
 /**
  * Canonical operation names for host package telemetry.
  * Follow the `PowerAppsHost.<Subsystem>.<Action>` convention so events are
@@ -42,14 +43,24 @@ export const HostOperationNames = {
   /** Top-level React error boundary caught an unhandled JS error. */
   RuntimeUnhandledJsError: 'PowerAppsHost.Runtime.UnhandledJsError',
   // ── Platform APIs ─────────────────────────────────────────────────────────
+  /** Power Platform RP HTTP request, including backend correlation IDs. */
+  PlatformHttpRequest: 'PowerAppsHost.Platform.HttpRequest',
   /** Resolve Dataverse instanceUrl from Power Platform environment API. */
   PlatformFetchInstanceUrl: 'PowerAppsHost.Platform.FetchInstanceUrl',
   /** useConnectionRefs failed to resolve connections (recoverable). Recorded only on failure. */
   PlatformLoadConnectionsFailed: 'PowerAppsHost.Platform.LoadConnections.Failed',
   /** Create a new Power Platform connection. */
   PlatformCreateConnection: 'PowerAppsHost.Platform.CreateConnection',
+  /** Repair an existing Power Platform connection. */
+  PlatformRepairConnection: 'PowerAppsHost.Platform.RepairConnection',
+  /** Poll a connection until it becomes active. */
+  PlatformPollConnectionStatus: 'PowerAppsHost.Platform.PollConnectionStatus',
   /** Resolve app connection references for the current launch. */
   PlatformResolveConnectionRefs: 'PowerAppsHost.Platform.ResolveConnectionRefs',
   /** Grant this app access to a Power Platform connection ACL. */
-  PlatformConnectionAclGrant: 'PowerAppsHost.Platform.ConnectionAclGrant'
-};
+  PlatformConnectionAclGrant: 'PowerAppsHost.Platform.ConnectionAclGrant',
+  /** Installed Offline SDK predates the SDK-owned routing contract. */
+  OfflineRoutingContractUnsupported: 'PowerAppsHost.Offline.RoutingContract.Unsupported'
+};
+export const bridgeHttpClient = new HttpClient(HostOperationNames.BridgeHttpRequest, isDebugLoggingEnabled);
+export const platformHttpClient = new HttpClient(HostOperationNames.PlatformHttpRequest, isDebugLoggingEnabled);

package/lib/typescript/commonjs/auth/AuthContext.d.ts

@@ -46,9 +46,11 @@ export interface AuthProviderProps {
      * Pass explicitly only to override the default (e.g. in tests).
      */
     intuneConfig?: IntuneConfig;
+    /** Token audiences that must be available before the account is considered signed in. */
+    requiredScopes?: string[];
     children: React.ReactNode;
 }
-export declare function AuthProvider({ msalConfig, intuneConfig, children }: AuthProviderProps): React.JSX.Element;
+export declare function AuthProvider({ msalConfig, intuneConfig, requiredScopes, children, }: AuthProviderProps): React.JSX.Element;
 /**
  * Returns the current auth state from the nearest <AuthProvider>.
  * Must be called within the AuthProvider tree.

package/lib/typescript/commonjs/auth/AuthContext.web.d.ts

@@ -13,6 +13,7 @@ export interface AuthState {
 export interface AuthProviderProps {
     msalConfig: MsalAuthConfig;
     intuneConfig?: IntuneConfig;
+    requiredScopes?: string[];
     children: React.ReactNode;
 }
 export declare function AuthProvider({ children }: AuthProviderProps): React.JSX.Element;

package/lib/typescript/commonjs/bridge/bridgeState.d.ts

@@ -0,0 +1,5 @@
+import type { NativeBridgeOptions } from './NativePowerAppsBridge';
+export declare function getRequestBodyForMethod(method: string, body: BodyInit | null): BodyInit | null;
+export declare function assertSuccessfulHttpStatus(status: number, method: string): void;
+export declare function updateBridgeOptionsInPlace(current: NativeBridgeOptions, next: NativeBridgeOptions): NativeBridgeOptions;
+//# sourceMappingURL=bridgeState.d.ts.map

package/lib/typescript/commonjs/config/babelConfig.d.ts

@@ -0,0 +1,12 @@
+export interface BabelConfigApi {
+    cache(value: boolean): void;
+}
+export interface PowerAppsBabelConfigOptions {
+    presets?: unknown[];
+    plugins?: unknown[];
+}
+export declare function createPowerAppsBabelConfig(api: BabelConfigApi, options?: PowerAppsBabelConfigOptions): {
+    presets: unknown[];
+    plugins: unknown[];
+};
+//# sourceMappingURL=babelConfig.d.ts.map

package/lib/typescript/commonjs/config/expoConfig.d.ts

@@ -0,0 +1,21 @@
+import type { ConfigContext, ExpoConfig } from 'expo/config';
+export interface PowerAppsExpoConfigSettings {
+    name: string;
+    slug: string;
+    scheme: string;
+    androidPackage: string;
+    iosBundleIdentifier: string;
+    version: string;
+    versionCode: number;
+    iconPath?: string | null;
+    /**
+     * Optional splash image. When omitted, falls back to the `APP_SPLASH_PATH`
+     * environment variable and then to the branding placeholder, so the template
+     * needs no wiring of its own and prebuild always emits replaceable slots.
+     */
+    splashPath?: string | null;
+    isDevClient?: boolean;
+}
+export type CustomizePowerAppsExpoConfig = (config: ExpoConfig) => ExpoConfig;
+export declare function createPowerAppsExpoConfig(baseConfig: ConfigContext['config'], settings: PowerAppsExpoConfigSettings, customize?: CustomizePowerAppsExpoConfig): ExpoConfig;
+//# sourceMappingURL=expoConfig.d.ts.map

package/lib/typescript/commonjs/config/metroConfig.d.ts

@@ -0,0 +1,6 @@
+import { getDefaultConfig } from 'expo/metro-config.js';
+type PowerAppsMetroConfig = ReturnType<typeof getDefaultConfig>;
+type CustomizeMetroConfig = (config: PowerAppsMetroConfig) => PowerAppsMetroConfig;
+export declare function createPowerAppsMetroConfig(projectRoot: string, customize?: CustomizeMetroConfig): PowerAppsMetroConfig;
+export {};
+//# sourceMappingURL=metroConfig.d.ts.map

package/lib/typescript/commonjs/config/metroLogger.d.ts

@@ -0,0 +1,21 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+type InstrumentationContext = {
+    phase: string;
+    logPath: string;
+};
+type InstrumentationErrorHandler = (error: Error, context: InstrumentationContext) => void;
+type MetroNext = (error?: Error) => void;
+export type MetroMiddleware = (request: IncomingMessage, response: ServerResponse, next: MetroNext) => unknown;
+export type MetroLoggingOptions = {
+    projectRoot?: string;
+    maxBodyBytes?: number;
+    onError?: InstrumentationErrorHandler;
+};
+export declare function redactMetroLog(value: unknown): string;
+export declare function enablePowerNativeMetroLogging(options?: MetroLoggingOptions): {
+    logDir: string;
+    logPath: string;
+};
+export declare function withPowerNativeMetroLogging(middleware: MetroMiddleware, options?: MetroLoggingOptions): MetroMiddleware;
+export {};
+//# sourceMappingURL=metroLogger.d.ts.map