wip

nbbeeken · nbbeeken · commit 5e1a11c2a0ef · 2025-12-17T13:10:25.000-05:00
diff --git a/packages/compass-connections/src/components/connection-status-notifications.tsx b/packages/compass-connections/src/components/connection-status-notifications.tsx
@@ -100,7 +100,7 @@ function ConnectionErrorToastBody({
         >
           {info ? getConnectionTitle(info) : 'Connection failed'}
         </span>
-        <span data-testid="connection-error-text">{error.message}</span>
+        <textarea data-testid="connection-error-text" value={error.stack + (error as any).cause?.stack + (error as any).cause?.cause?.stack}></textarea>
       </span>
       <span className={connectionErrorActionsStyles}>
         {info && onReview && (
diff --git a/packages/compass-connections/src/index.tsx b/packages/compass-connections/src/index.tsx
@@ -73,6 +73,11 @@ const ConnectionsComponent: React.FunctionComponent<{
    * When connections fail to load, this callback will be called
    */
   onFailToLoadConnections: (error: Error) => void;
+  /**
+   * Can be used to override the default useSystemCA behavior.
+   * Set to false in browser environments where system CA certificates are not available.
+   */
+  useSystemCA?: boolean;
 }> = ({ children }) => {
   const activeConnections = useConnectionsList((connection) => {
     return connection.status === 'connected';
@@ -119,6 +124,7 @@ const CompassConnectionsPlugin = registerCompassPlugin(
         globalAppRegistry,
         onFailToLoadConnections: initialProps.onFailToLoadConnections,
         compassAssistant,
+        useSystemCA: initialProps.useSystemCA,
       });
 
       setTimeout(() => {
diff --git a/packages/compass-connections/src/stores/connections-store-redux.ts b/packages/compass-connections/src/stores/connections-store-redux.ts
@@ -214,6 +214,7 @@ type ThunkExtraArg = {
   globalAppRegistry: Pick<AppRegistry, 'on' | 'emit' | 'removeListener'>;
   onFailToLoadConnections: (error: Error) => void;
   compassAssistant: CompassAssistantService;
+  useSystemCA?: boolean;
 };
 
 export type ConnectionsThunkAction<
@@ -1532,6 +1533,7 @@ const connectWithOptions = (
       appName,
       getExtraConnectionData,
       connectFn,
+      useSystemCA,
     }
   ) => {
     let inflightConnection = InFlightConnections.get(connectionInfo.id);
@@ -1643,6 +1645,7 @@ const connectWithOptions = (
                   deviceAuthAbortController.signal
                 );
               },
+              useSystemCA,
             }),
           }
         );
diff --git a/packages/compass-e2e-tests/helpers/compass.ts b/packages/compass-e2e-tests/helpers/compass.ts
@@ -24,12 +24,14 @@ import { CHROME_STARTUP_FLAGS } from './chrome-startup-flags';
 import {
   DEFAULT_CONNECTION_STRINGS,
   DEFAULT_CONNECTION_NAMES,
+  DEFAULT_CONNECTIONS,
   DEFAULT_CONNECTIONS_SERVER_INFO,
   isTestingWeb,
   isTestingDesktop,
   context,
   assertTestingWeb,
   isTestingAtlasCloudExternal,
+  isTestingAtlasCloudSandbox,
 } from './test-runner-context';
 import {
   MONOREPO_ELECTRON_CHROMIUM_VERSION,
@@ -897,6 +899,22 @@ export async function startBrowser(
     );
   } else {
     await browser.navigateTo(context.sandboxUrl);
+
+    // For Atlas Cloud Sandbox tests, inject the default connections into localStorage
+    // and reload the page so that SandboxConnectionStorage picks them up
+    if (isTestingAtlasCloudSandbox(context)) {
+      await browser.execute((connections) => {
+        const historyKey = 'CONNECTIONS_HISTORY_V$';
+        const bytes = new TextEncoder().encode(JSON.stringify(connections));
+        const binStr = String.fromCodePoint(...bytes);
+        const b64Str = window.btoa(binStr);
+        localStorage.setItem(historyKey, b64Str);
+      }, DEFAULT_CONNECTIONS);
+
+      // Reload the page so that SandboxConnectionStorage is re-instantiated
+      // with the connections from localStorage
+      await browser.navigateTo(context.sandboxUrl);
+    }
   }
 
   const compass = new Compass(name, browser, {
diff --git a/packages/compass-web/sandbox/sandbox-connection-storage.tsx b/packages/compass-web/sandbox/sandbox-connection-storage.tsx
@@ -63,7 +63,9 @@ class SandboxConnectionStorage implements ConnectionStorage {
     );
   }
   save({ connectionInfo }: { connectionInfo: ConnectionInfo }): Promise<void> {
-    this._connections.set(connectionInfo.id, connectionInfo);
+    // Normalize the connection to ensure useSystemCA is false before saving
+    const normalizedInfo = this.normalizeConnectionInfo(connectionInfo);
+    this._connections.set(normalizedInfo.id, normalizedInfo);
     setTimeout(() => {
       saveHistory(Array.from(this._connections.values()));
     }, 0);
diff --git a/packages/compass-web/src/connection-storage.tsx b/packages/compass-web/src/connection-storage.tsx
@@ -163,6 +163,22 @@ export class AtlasCloudConnectionStorage
       });
     return this.loadAllPromise;
   }
+
+  async save({
+    connectionInfo,
+  }: {
+    connectionInfo: ConnectionInfo;
+  }): Promise<void> {
+    // Ensure useSystemCA is false for all connections in the browser environment
+    const normalizedInfo: ConnectionInfo = {
+      ...connectionInfo,
+      connectionOptions: {
+        ...connectionInfo.connectionOptions,
+        useSystemCA: false,
+      },
+    };
+    return super.save({ connectionInfo: normalizedInfo });
+  }
 }
 
 const SandboxConnectionStorageContext =
diff --git a/packages/compass-web/src/entrypoint.tsx b/packages/compass-web/src/entrypoint.tsx
@@ -126,6 +126,55 @@ const WithAtlasProviders: React.FC<{ children: React.ReactNode }> = ({
   );
 };
 
+const WithConnectionsProvider: React.FC<{
+  appName: string;
+  autoconnectId?: string;
+  onFailToLoadConnections: (err: Error) => void;
+  children: React.ReactNode;
+}> = ({ appName, autoconnectId, onFailToLoadConnections, children }) => {
+  const logger = useCompassWebLogger({});
+
+  return (
+    <CompassConnections
+      appName={appName}
+      onFailToLoadConnections={onFailToLoadConnections}
+      // Compass Web runs in browser environments where system CA certificates
+      // are not available, so we disable useSystemCA
+      useSystemCA={false}
+      onExtraConnectionDataRequest={() => {
+        return Promise.resolve([{}, null] as [
+          Record<string, unknown>,
+          null
+        ]);
+      }}
+      onAutoconnectInfoRequest={(connectionStore) => {
+        if (autoconnectId) {
+          return connectionStore.loadAll().then(
+            (connections) => {
+              return connections.find(
+                (connectionInfo) => connectionInfo.id === autoconnectId
+              );
+            },
+            (err) => {
+              const { log, mongoLogId } = logger;
+              log.warn(
+                mongoLogId(1_001_000_329),
+                'Compass Web',
+                'Could not load connections when trying to autoconnect',
+                { err: err.message }
+              );
+              return undefined;
+            }
+          );
+        }
+        return Promise.resolve(undefined);
+      }}
+    >
+      {children}
+    </CompassConnections>
+  );
+};
+
 const WithStorageProviders = createServiceProvider(
   function WithStorageProviders({
     orgId,
@@ -556,38 +605,10 @@ const CompassWeb = ({
                           originForPrompt="atlas-data-explorer"
                           appNameForPrompt={APP_NAMES_FOR_PROMPT.DataExplorer}
                         >
-                          <CompassConnections
+                          <WithConnectionsProvider
                             appName={appName ?? 'Compass Web'}
+                            autoconnectId={autoconnectId}
                             onFailToLoadConnections={onFailToLoadConnections}
-                            onExtraConnectionDataRequest={() => {
-                              return Promise.resolve([{}, null] as [
-                                Record<string, unknown>,
-                                null
-                              ]);
-                            }}
-                            onAutoconnectInfoRequest={(connectionStore) => {
-                              if (autoconnectId) {
-                                return connectionStore.loadAll().then(
-                                  (connections) => {
-                                    return connections.find(
-                                      (connectionInfo) =>
-                                        connectionInfo.id === autoconnectId
-                                    );
-                                  },
-                                  (err) => {
-                                    const { log, mongoLogId } = logger;
-                                    log.warn(
-                                      mongoLogId(1_001_000_329),
-                                      'Compass Web',
-                                      'Could not load connections when trying to autoconnect',
-                                      { err: err.message }
-                                    );
-                                    return undefined;
-                                  }
-                                );
-                              }
-                              return Promise.resolve(undefined);
-                            }}
                           >
                             <CompassInstanceStorePlugin>
                               <FieldStorePlugin>
@@ -611,7 +632,7 @@ const CompassWeb = ({
                                 isCloudOptIn={true}
                               />
                             </CompassInstanceStorePlugin>
-                          </CompassConnections>
+                          </WithConnectionsProvider>
                         </CompassAssistantProvider>
                       </AtlasCloudConnectionStorageProvider>
                     </DataModelStorageServiceProviderWeb>
diff --git a/packages/connection-form/src/hooks/use-connect-form.ts b/packages/connection-form/src/hooks/use-connect-form.ts
@@ -848,6 +848,7 @@ export function adjustConnectionOptionsBeforeConnect({
   defaultAppName,
   notifyDeviceFlow,
   preferences,
+  useSystemCA,
 }: {
   connectionOptions: Readonly<ConnectionOptions>;
   connectionId: string;
@@ -861,6 +862,7 @@ export function adjustConnectionOptionsBeforeConnect({
     telemetryAnonymousId?: string;
     forceConnectionOptions: [string, string][];
   };
+  useSystemCA?: boolean;
 }): ConnectionOptions {
   const transformers: ((
     connectionOptions: Readonly<ConnectionOptions>
@@ -882,5 +884,14 @@ export function adjustConnectionOptionsBeforeConnect({
   for (const transformer of transformers) {
     connectionOptions = transformer(connectionOptions);
   }
+
+  // Apply useSystemCA if explicitly provided
+  if (useSystemCA !== undefined) {
+    connectionOptions = {
+      ...connectionOptions,
+      useSystemCA,
+    };
+  }
+
   return connectionOptions;
 }
diff --git a/packages/data-service/src/connect-mongo-client.ts b/packages/data-service/src/connect-mongo-client.ts
@@ -285,7 +285,13 @@ export async function connectMongoClientDataService({
         const { client: metadataClient, state } = await connectSingleClient({
           autoEncryption: undefined,
         });
-        const parentHandlePromise = state.getStateShareServer();
+        
+        // StateShareServer is only needed for OIDC authentication.
+        // Check if OIDC is being used before creating the server.
+        const connectionStringUrl = new ConnectionString(url);
+        const isOIDC = connectionStringUrl.searchParams.get('authMechanism') === 'MONGODB-OIDC';
+        const parentHandlePromise = isOIDC ? state.getStateShareServer() : Promise.resolve('');
+        
         parentHandlePromise.catch(() => {
           /* handled below */
         });
@@ -324,7 +330,10 @@ export async function connectMongoClientDataService({
       waitForTunnelError(tunnel),
     ]); // waitForTunnel always throws, never resolves
 
-    options.parentHandle = await state.getStateShareServer();
+    // Only get StateShareServer handle for OIDC connections
+    const connectionStringUrl = new ConnectionString(url);
+    const isOIDC = connectionStringUrl.searchParams.get('authMechanism') === 'MONGODB-OIDC';
+    options.parentHandle = isOIDC ? await state.getStateShareServer() : '';
 
     return [
       metadataClient,

Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ function ConnectionErrorToastBody({`
`100`	`100`	`>`
`101`	`101`	`{info ? getConnectionTitle(info) : 'Connection failed'}`
`102`	`102`	`</span>`
`103`		`- <span data-testid="connection-error-text">{error.message}</span>`
	`103`	`+ <textarea data-testid="connection-error-text" value={error.stack + (error as any).cause?.stack + (error as any).cause?.cause?.stack}></textarea>`
`104`	`104`	`</span>`
`105`	`105`	`<span className={connectionErrorActionsStyles}>`
`106`	`106`	`{info && onReview && (`