Merge branch 'main' of https://github.com/mongodb-js/compass into COMPASS-9449-export-to-png

Author: mabaasit

package-lock.json

@@ -114,7 +114,7 @@ const ConnectionsNavigationTree: React.FunctionComponent<
 
   const getCollapseAfterForConnectedItem = useCallback(
     (actions: NavigationItemActions) => {
-      const [firstAction, secondAction] = actions;
+      const [, secondAction, thirdAction] = actions;
 
       const actionCanBeShownInline = (
         action: NavigationItemActions[number]
@@ -123,31 +123,32 @@ const ConnectionsNavigationTree: React.FunctionComponent<
           return false;
         }
 
-        return ['create-database', 'open-shell'].includes(
+        return ['refresh-databases', 'create-database', 'open-shell'].includes(
           (action as ItemAction<Actions>).action
         );
       };
 
       // this is the normal case for a connection that is writable and when we
       // also have shell enabled
       if (
-        actionCanBeShownInline(firstAction) &&
-        actionCanBeShownInline(secondAction)
+        actionCanBeShownInline(secondAction) &&
+        actionCanBeShownInline(thirdAction)
       ) {
-        return 2;
+        return 3;
       }
 
       // this will happen when the either the connection is not writable or the
       // preference is readonly, or shell is not enabled in which case we either
       // do not show create-database action or open-shell action
       if (
-        actionCanBeShownInline(firstAction) ||
-        actionCanBeShownInline(secondAction)
+        actionCanBeShownInline(secondAction) ||
+        actionCanBeShownInline(thirdAction)
       ) {
-        return 1;
+        return 2;
       }
 
-      return 0;
+      // Always display the refresh action (firstAction).
+      return 1;
     },
     []
   );

packages/compass-connections-navigation/src/connections-navigation-tree.tsx

@@ -93,6 +93,11 @@ export const connectedConnectionItemActions = ({
     connectionInfo,
   });
   return stripNullActions([
+    {
+      action: 'refresh-databases',
+      label: 'Refresh databases',
+      icon: 'Refresh',
+    },
     hasWriteActionsDisabled
       ? null
       : {
@@ -123,11 +128,6 @@ export const connectedConnectionItemActions = ({
           icon: 'InfoWithCircle',
           label: 'Show connection info',
         },
-    {
-      action: 'refresh-databases',
-      label: 'Refresh databases',
-      icon: 'Refresh',
-    },
     {
       action: 'connection-disconnect',
       icon: 'Disconnect',

packages/compass-connections-navigation/src/item-actions.ts

@@ -58,7 +58,6 @@
     "@mongodb-js/compass-app-stores": "^7.48.1",
     "@mongodb-js/compass-components": "^1.40.0",
     "@mongodb-js/compass-connections": "^1.62.1",
-    "@mongodb-js/compass-editor": "^0.42.0",
     "@mongodb-js/compass-logging": "^1.7.4",
     "@mongodb-js/compass-telemetry": "^1.10.2",
     "@mongodb-js/compass-user-data": "^0.7.4",

packages/compass-data-modeling/package.json

@@ -4,8 +4,10 @@ import {
   createPluginTestHelpers,
   screen,
   waitFor,
+  render,
+  userEvent,
 } from '@mongodb-js/testing-library-compass';
-import DiagramEditor from './diagram-editor';
+import DiagramEditor, { getFieldsFromSchema } from './diagram-editor';
 import type { DataModelingStore } from '../../test/setup-store';
 import type {
   Edit,
@@ -229,3 +231,182 @@ describe('DiagramEditor', function () {
     });
   });
 });
+
+describe('getFieldsFromSchema', function () {
+  const validateMixedType = async (
+    type: React.ReactNode,
+    expectedTooltip: RegExp
+  ) => {
+    render(<>{type}</>);
+    const mixed = screen.getByText('(mixed)');
+    expect(mixed).to.be.visible;
+    expect(screen.queryByText(expectedTooltip)).to.not.exist;
+    userEvent.hover(mixed);
+    await waitFor(() => {
+      expect(screen.getByText(expectedTooltip)).to.be.visible;
+    });
+  };
+
+  describe('flat schema', function () {
+    it('return empty array for empty schema', function () {
+      const result = getFieldsFromSchema({});
+      expect(result).to.deep.equal([]);
+    });
+
+    it('returns fields for a simple schema', function () {
+      const result = getFieldsFromSchema({
+        bsonType: 'object',
+        properties: {
+          name: { bsonType: 'string' },
+          age: { bsonType: 'int' },
+        },
+      });
+      expect(result).to.deep.equal([
+        { name: 'name', type: 'string', depth: 0, glyphs: [] },
+        { name: 'age', type: 'int', depth: 0, glyphs: [] },
+      ]);
+    });
+
+    it('returns mixed fields with tooltip on hover', async function () {
+      const result = getFieldsFromSchema({
+        bsonType: 'object',
+        properties: {
+          age: { bsonType: ['int', 'string'] },
+        },
+      });
+      expect(result[0]).to.deep.include({ name: 'age', depth: 0, glyphs: [] });
+      await validateMixedType(result[0].type, /int, string/);
+    });
+  });
+
+  describe('nested schema', function () {
+    it('returns fields for a nested schema', function () {
+      const result = getFieldsFromSchema({
+        bsonType: 'object',
+        properties: {
+          person: {
+            bsonType: 'object',
+            properties: {
+              name: { bsonType: 'string' },
+              address: {
+                bsonType: 'object',
+                properties: {
+                  street: { bsonType: 'string' },
+                  city: { bsonType: 'string' },
+                },
+              },
+            },
+          },
+        },
+      });
+      expect(result).to.deep.equal([
+        { name: 'person', type: 'object', depth: 0, glyphs: [] },
+        { name: 'name', type: 'string', depth: 1, glyphs: [] },
+        { name: 'address', type: 'object', depth: 1, glyphs: [] },
+        { name: 'street', type: 'string', depth: 2, glyphs: [] },
+        { name: 'city', type: 'string', depth: 2, glyphs: [] },
+      ]);
+    });
+
+    it('returns [] for array', function () {
+      const result = getFieldsFromSchema({
+        bsonType: 'object',
+        properties: {
+          tags: {
+            bsonType: 'array',
+            items: { bsonType: 'string' },
+          },
+        },
+      });
+      expect(result).to.deep.equal([
+        { name: 'tags', type: '[]', depth: 0, glyphs: [] },
+      ]);
+    });
+
+    it('returns fields for an array of objects', function () {
+      const result = getFieldsFromSchema({
+        bsonType: 'object',
+        properties: {
+          todos: {
+            bsonType: 'array',
+            items: {
+              bsonType: 'object',
+              properties: {
+                title: { bsonType: 'string' },
+                completed: { bsonType: 'boolean' },
+              },
+            },
+          },
+        },
+      });
+      expect(result).to.deep.equal([
+        { name: 'todos', type: '[]', depth: 0, glyphs: [] },
+        { name: 'title', type: 'string', depth: 1, glyphs: [] },
+        { name: 'completed', type: 'boolean', depth: 1, glyphs: [] },
+      ]);
+    });
+
+    it('returns fields for a mixed schema with objects', async function () {
+      const result = getFieldsFromSchema({
+        bsonType: 'object',
+        properties: {
+          name: {
+            anyOf: [
+              { bsonType: 'string' },
+              {
+                bsonType: 'object',
+                properties: {
+                  first: { bsonType: 'string' },
+                  last: { bsonType: 'string' },
+                },
+              },
+            ],
+          },
+        },
+      });
+      expect(result).to.have.lengthOf(3);
+      expect(result[0]).to.deep.include({ name: 'name', depth: 0, glyphs: [] });
+      await validateMixedType(result[0].type, /string, object/);
+      expect(result[1]).to.deep.equal({
+        name: 'first',
+        type: 'string',
+        depth: 1,
+        glyphs: [],
+      });
+      expect(result[2]).to.deep.equal({
+        name: 'last',
+        type: 'string',
+        depth: 1,
+        glyphs: [],
+      });
+    });
+
+    it('returns fields for an array of mixed (including objects)', function () {
+      const result = getFieldsFromSchema({
+        bsonType: 'object',
+        properties: {
+          todos: {
+            bsonType: 'array',
+            items: {
+              anyOf: [
+                {
+                  bsonType: 'object',
+                  properties: {
+                    title: { bsonType: 'string' },
+                    completed: { bsonType: 'boolean' },
+                  },
+                },
+                { bsonType: 'string' },
+              ],
+            },
+          },
+        },
+      });
+      expect(result).to.deep.equal([
+        { name: 'todos', type: '[]', depth: 0, glyphs: [] },
+        { name: 'title', type: 'string', depth: 1, glyphs: [] },
+        { name: 'completed', type: 'boolean', depth: 1, glyphs: [] },
+      ]);
+    });
+  });
+});