Merge branch 'main' of https://github.com/mongodb-js/compass into atlas-sign-in-flake

Author: mabaasit

.evergreen/create-sbom.sh

@@ -18,8 +18,8 @@ trap_handler() {
 }
 trap trap_handler ERR EXIT
 
-scp -i "$SIGNING_SERVER_PRIVATE_KEY_CYGPATH" -P "$SIGNING_SERVER_PORT" .sbom/dependencies.json /tmp/silkbomb.env /tmp/artifactory_password "$SIGNING_SERVER_USERNAME"@"$SIGNING_SERVER_HOSTNAME":/tmp/
-ssh -i "$SIGNING_SERVER_PRIVATE_KEY_CYGPATH" -p "$SIGNING_SERVER_PORT" "$SIGNING_SERVER_USERNAME"@"$SIGNING_SERVER_HOSTNAME" \
+scp -v -i "$SIGNING_SERVER_PRIVATE_KEY_CYGPATH" -P "$SIGNING_SERVER_PORT" .sbom/dependencies.json /tmp/silkbomb.env /tmp/artifactory_password "$SIGNING_SERVER_USERNAME"@"$SIGNING_SERVER_HOSTNAME":/tmp/
+ssh -v -i "$SIGNING_SERVER_PRIVATE_KEY_CYGPATH" -p "$SIGNING_SERVER_PORT" "$SIGNING_SERVER_USERNAME"@"$SIGNING_SERVER_HOSTNAME" \
   "(cat /tmp/dependencies.json | jq -r '.[] | "'"pkg:npm/" + .name + "@" + .version'"' > /tmp/purls.txt) && \
   echo "pkg:generic/mongo_crypt_shared@${CRYPT_SHARED_VERSION}" >> /tmp/purls.txt && \
   (cat /tmp/artifactory_password | docker login artifactory.corp.mongodb.com --username '${ARTIFACTORY_USERNAME}' --password-stdin ; rm -f /tmp/artifactor_password ) && \
@@ -30,4 +30,4 @@ ssh -i "$SIGNING_SERVER_PRIVATE_KEY_CYGPATH" -p "$SIGNING_SERVER_PORT" "$SIGNING
     --silk-asset-group "${SILK_ASSET_GROUP}" --sbom-in /tmp/sbom-lite.json && \
   docker run --env-file /tmp/silkbomb.env --rm -v /tmp:/tmp artifactory.corp.mongodb.com/release-tools-container-registry-public-local/silkbomb:1.0 download \
     --silk-asset-group "${SILK_ASSET_GROUP}" --sbom-out /tmp/sbom.json"
-scp -i "$SIGNING_SERVER_PRIVATE_KEY_CYGPATH" -P "$SIGNING_SERVER_PORT" "$SIGNING_SERVER_USERNAME"@"$SIGNING_SERVER_HOSTNAME":/tmp/{sbom-lite.json,sbom.json,purls.txt} .sbom/
+scp -v -i "$SIGNING_SERVER_PRIVATE_KEY_CYGPATH" -P "$SIGNING_SERVER_PORT" "$SIGNING_SERVER_USERNAME"@"$SIGNING_SERVER_HOSTNAME":/tmp/{sbom-lite.json,sbom.json,purls.txt} .sbom/

THIRD-PARTY-NOTICES.md

@@ -1,5 +1,5 @@
 The following third-party software is used by and included in **Mongodb Compass**.
-This document was automatically generated on Wed Jan 15 2025.
+This document was automatically generated on Thu Jan 16 2025.
 
 ## List of dependencies
 

docs/tracking-plan.md

@@ -1,7 +1,7 @@
 
 # Compass Tracking Plan
 
-Generated on Wed, Jan 15, 2025
+Generated on Thu, Jan 16, 2025
 
 ## Table of Contents
 
@@ -936,8 +936,6 @@ This event is fired when a collection is created.
 
 **Properties**:
 
-- **is_capped** (required): `boolean`
-  - Indicates whether the collection is capped.
 - **has_collation** (required): `boolean`
   - Indicates whether the collection has a custom collation.
 - **is_timeseries** (required): `boolean`
@@ -960,8 +958,6 @@ This event is fired when a database is created.
 
 **Properties**:
 
-- **is_capped** (required): `boolean`
-  - Indicates whether the first collection in the database is capped.
 - **has_collation** (required): `boolean`
   - Indicates whether the first collection in the database has a custom collation.
 - **is_timeseries** (required): `boolean`

package-lock.json

@@ -7,6 +7,9 @@ const PROPERTIES_FLE2 = 'fle2';
 const PROPERTIES_VIEW = 'view';
 const PROPERTIES_READ_ONLY = 'read-only';
 
+/**
+ * @param {import('../').CollectionProps} coll 
+ */
 function getProperties(coll) {
   const properties = [];
 
@@ -29,7 +32,7 @@ function getProperties(coll) {
     });
   }
 
-  if (coll.capped) {
+  if (coll.is_capped) {
     properties.push({
       id: PROPERTIES_CAPPED,
     });

packages/collection-model/lib/collection-properties.js

@@ -222,7 +222,7 @@ const CollectionModel = AmpersandModel.extend(debounceActions(['fetch']), {
       },
     },
     properties: {
-      deps: ['collation', 'type', 'capped', 'clustered', 'readonly', 'fle2'],
+      deps: ['collation', 'type', 'is_capped', 'clustered', 'readonly', 'fle2'],
       fn() {
         return getProperties(this);
       },

packages/collection-model/lib/model.js

@@ -62,6 +62,7 @@
     "compass-preferences-model": "^2.32.1",
     "hadron-app-registry": "^9.3.1",
     "lodash": "^4.17.21",
+    "mongodb": "^6.12.0",
     "mongodb-build-info": "^1.7.2",
     "mongodb-connection-string-url": "^3.0.1",
     "mongodb-data-service": "^22.24.1",

packages/compass-connections/package.json

@@ -10,6 +10,8 @@ import {
 } from '@mongodb-js/testing-library-compass';
 import React from 'react';
 import { InMemoryConnectionStorage } from '@mongodb-js/connection-storage/provider';
+import { getDataServiceForConnection } from './connections-store-redux';
+import { type ConnectionInfo } from '@mongodb-js/connection-info';
 
 const mockConnections = [
   {
@@ -34,6 +36,13 @@ const mockConnections = [
   },
 ];
 
+const connectionInfoWithAtlasMetadata = {
+  ...createDefaultConnectionInfo(),
+  atlasMetadata: {
+    clusterName: 'pineapple',
+  } as ConnectionInfo['atlasMetadata'],
+};
+
 function renderCompassConnections(opts?: RenderConnectionsOptions) {
   return render(
     <div>
@@ -274,6 +283,101 @@ describe('CompassConnections store', function () {
         await connectionStorage.load({ id: mockConnections[0].id })
       ).to.have.nested.property('favorite.name', 'turtles');
     });
+
+    it('should ignore server heartbeat failed events that are not non-retryable error codes', async function () {
+      const { connectionsStore } = renderCompassConnections({
+        connectFn: async () => {
+          await wait(1);
+          return {};
+        },
+      });
+
+      // Wait till we're connected.
+      await connectionsStore.actions.connect(connectionInfoWithAtlasMetadata);
+
+      const connections = connectionsStore.getState().connections;
+      expect(connections.ids).to.have.lengthOf(1);
+
+      const dataService = getDataServiceForConnection(
+        connectionInfoWithAtlasMetadata.id
+      );
+
+      let didDisconnect = false;
+      let didCheckForConnected = false;
+      sinon.stub(dataService, 'disconnect').callsFake(async () => {
+        didDisconnect = true;
+        return Promise.resolve();
+      });
+      dataService.isConnected = () => {
+        // If this is called we know the error wasn't handled properly.
+        didCheckForConnected = true;
+        return true;
+      };
+
+      let didReceiveCallToHeartbeatFailedListener = false;
+      dataService.on('serverHeartbeatFailed', () => {
+        didReceiveCallToHeartbeatFailedListener = true;
+      });
+
+      // Send a heartbeat fail with an error that's not a non-retryable error code.
+      dataService['emit']('serverHeartbeatFailed', {
+        failure: new Error('code: 1234, Not the error we are looking for'),
+      });
+
+      // Wait for the listener to handle the message.
+      await waitFor(() => {
+        expect(didReceiveCallToHeartbeatFailedListener).to.be.true;
+      });
+      await wait(1);
+
+      expect(didDisconnect).to.be.false;
+      expect(didCheckForConnected).to.be.false;
+    });
+
+    it('should listen for non-retryable errors on server heartbeat failed events and disconnect the data service when encountered', async function () {
+      const { connectionsStore } = renderCompassConnections({
+        connectFn: async () => {
+          await wait(1);
+          return {};
+        },
+      });
+
+      // Wait till we're connected.
+      await connectionsStore.actions.connect(connectionInfoWithAtlasMetadata);
+
+      const connections = connectionsStore.getState().connections;
+      expect(connections.ids).to.have.lengthOf(1);
+
+      const dataService = getDataServiceForConnection(
+        connectionInfoWithAtlasMetadata.id
+      );
+
+      let didDisconnect = false;
+      sinon.stub(dataService, 'disconnect').callsFake(async () => {
+        didDisconnect = true;
+        return Promise.resolve();
+      });
+      dataService.isConnected = () => true;
+
+      // Send a heartbeat fail with an error that's a non-retryable error code.
+      dataService['emit']('serverHeartbeatFailed', {
+        failure: new Error('code: 3003, reason: Insufficient permissions'),
+      });
+
+      await waitFor(() => {
+        expect(didDisconnect).to.be.true;
+      });
+
+      await waitFor(function () {
+        const titleNode = screen.getByText('Unable to connect to pineapple');
+        expect(titleNode).to.be.visible;
+
+        const descriptionNode = screen.getByText(
+          'Reason: Insufficient permissions. To use continue to use this connection either disconnect and reconnect, or refresh your page.'
+        );
+        expect(descriptionNode).to.be.visible;
+      });
+    });
   });
 
   describe('#saveAndConnect', function () {

packages/compass-connections/src/stores/connections-store-redux.spec.tsx

@@ -3,6 +3,7 @@ import type { Reducer, AnyAction, Action } from 'redux';
 import { createStore, applyMiddleware } from 'redux';
 import type { ThunkAction } from 'redux-thunk';
 import thunk from 'redux-thunk';
+import type { ServerHeartbeatFailedEvent } from 'mongodb';
 import {
   getConnectionTitle,
   type ConnectionInfo,
@@ -1465,6 +1466,57 @@ function isAtlasStreamsInstance(
   }
 }
 
+// We listen for non-retry-able errors on failed server heartbeats.
+// These can happen on compass web when:
+// - A user's session has ended.
+// - The user's roles have changed.
+// - The cluster / group they are trying to connect to has since been deleted.
+// When we encounter one we disconnect. This is to avoid polluting logs/metrics
+// and to avoid constantly retrying to connect when we know it'll fail.
+// These error codes can be found at
+// https://github.com/10gen/mms/blob/de2a9c463cfe530efb8e2a0941033e8207b6cb11/server/src/main/com/xgen/cloud/services/clusterconnection/runtime/res/CustomCloseCodes.java
+const NonRetryableErrorCodes = [3000, 3003, 4004, 1008] as const;
+const NonRetryableErrorDescriptionFallbacks: {
+  [code in typeof NonRetryableErrorCodes[number]]: string;
+} = {
+  3000: 'Unauthorized',
+  3003: 'Forbidden',
+  4004: 'Not Found',
+  1008: 'Violated policy',
+};
+
+function isNonRetryableHeartbeatFailure(evt: ServerHeartbeatFailedEvent) {
+  return NonRetryableErrorCodes.some((code) =>
+    evt.failure.message.includes(`code: ${code},`)
+  );
+}
+
+function getDescriptionForNonRetryableError(error: Error): string {
+  // Give a description from the error message when provided, otherwise fallback
+  // to the generic error description.
+  const reason = error.message.match(/code: \d+, reason: (.*)$/)?.[1];
+  return reason && reason.length > 0
+    ? reason
+    : NonRetryableErrorDescriptionFallbacks[
+        Number(
+          error.message.match(/code: (\d+),/)?.[1]
+        ) as typeof NonRetryableErrorCodes[number]
+      ] ?? 'Unknown';
+}
+
+const openConnectionClosedWithNonRetryableErrorToast = (
+  connectionInfo: ConnectionInfo,
+  error: Error
+) => {
+  openToast(`non-retryable-error-encountered--${connectionInfo.id}`, {
+    title: `Unable to connect to ${getConnectionTitle(connectionInfo)}`,
+    description: `Reason: ${getDescriptionForNonRetryableError(
+      error
+    )}. To use continue to use this connection either disconnect and reconnect, or refresh your page.`,
+    variant: 'warning',
+  });
+};
+
 export const connect = (
   connectionInfo: ConnectionInfo
 ): ConnectionsThunkAction<
@@ -1659,6 +1711,34 @@ const connectWithOptions = (
           return;
         }
 
+        let showedNonRetryableErrorToast = false;
+        // Listen for non-retry-able errors on failed server heartbeats.
+        // These can happen on compass web when:
+        // - A user's session has ended.
+        // - The user's roles have changed.
+        // - The cluster / group they are trying to connect to has since been deleted.
+        // When we encounter one we disconnect. This is to avoid polluting logs/metrics
+        // and to avoid constantly retrying to connect when we know it'll fail.
+        dataService.on(
+          'serverHeartbeatFailed',
+          (evt: ServerHeartbeatFailedEvent) => {
+            if (!isNonRetryableHeartbeatFailure(evt)) {
+              return;
+            }
+
+            if (!dataService.isConnected() || showedNonRetryableErrorToast) {
+              return;
+            }
+
+            openConnectionClosedWithNonRetryableErrorToast(
+              connectionInfo,
+              evt.failure
+            );
+            showedNonRetryableErrorToast = true;
+            void dataService.disconnect();
+          }
+        );
+
         dataService.on('oidcAuthFailed', (error) => {
           openToast('oidc-auth-failed', {
             title: `Failed to authenticate for ${getConnectionTitle(

packages/compass-connections/src/stores/connections-store-redux.ts

@@ -240,14 +240,22 @@ const CrudToolbar: React.FunctionComponent<CrudToolbarProps> = ({
           {!readonly && (
             <UpdateMenu
               isWritable={isWritable && !shouldDisableBulkOp}
-              disabledTooltip="Remove limit and skip in your query to perform an update"
+              disabledTooltip={
+                isWritable
+                  ? 'Remove limit and skip in your query to perform an update'
+                  : instanceDescription
+              }
               onClick={onUpdateButtonClicked}
             ></UpdateMenu>
           )}
           {!readonly && (
             <DeleteMenu
               isWritable={isWritable && !shouldDisableBulkOp}
-              disabledTooltip="Remove limit and skip in your query to perform a delete"
+              disabledTooltip={
+                isWritable
+                  ? 'Remove limit and skip in your query to perform a delete'
+                  : instanceDescription
+              }
               onClick={onDeleteButtonClicked}
             ></DeleteMenu>
           )}