define and handle unsupported state

Author: kpamaran

packages/compass-collection/src/components/collection-header-actions/collection-header-actions.spec.tsx

@@ -61,6 +61,7 @@ describe('CollectionHeaderActions [Component]', function () {
               hasSchemaAnalysisData={true}
               analyzedSchemaDepth={2}
               schemaAnalysisStatus="complete"
+              schemaAnalysisError={null}
               {...props}
             />
           </PreferencesProvider>
@@ -294,5 +295,37 @@ describe('CollectionHeaderActions [Component]', function () {
       expect(button).to.exist;
       expect(button).to.have.attribute('aria-disabled', 'true');
     });
+
+    it('should show an error banner when the schema is in an unsupported state', async function () {
+      mockUseAssignment.returns({
+        assignment: {
+          assignmentData: {
+            variant: 'mockDataGeneratorVariant',
+          },
+        },
+      });
+
+      await renderCollectionHeaderActions(
+        {
+          namespace: 'test.collection',
+          isReadonly: false,
+          hasSchemaAnalysisData: false,
+          schemaAnalysisStatus: 'error',
+          schemaAnalysisError: {
+            errorType: 'unsupportedState',
+            errorMessage: 'Unsupported state',
+          },
+          onOpenMockDataModal: sinon.stub(),
+        },
+        {},
+        atlasConnectionInfo
+      );
+
+      const button = screen.getByTestId(
+        'collection-header-generate-mock-data-button'
+      );
+      expect(button).to.exist;
+      expect(button).to.have.attribute('aria-disabled', 'true');
+    });
   });
 });

packages/compass-collection/src/components/collection-header-actions/collection-header-actions.tsx

@@ -21,6 +21,7 @@ import {
 import {
   SCHEMA_ANALYSIS_STATE_ANALYZING,
   type SchemaAnalysisStatus,
+  type SchemaAnalysisError,
 } from '../../schema-analysis-types';
 
 /**
@@ -57,6 +58,7 @@ type CollectionHeaderActionsProps = {
   sourcePipeline?: unknown[];
   onOpenMockDataModal: () => void;
   hasSchemaAnalysisData: boolean;
+  schemaAnalysisError: SchemaAnalysisError | null;
   analyzedSchemaDepth: number;
   schemaAnalysisStatus: SchemaAnalysisStatus | null;
 };
@@ -73,6 +75,7 @@ const CollectionHeaderActions: React.FunctionComponent<
   hasSchemaAnalysisData,
   analyzedSchemaDepth,
   schemaAnalysisStatus,
+  schemaAnalysisError,
 }: CollectionHeaderActionsProps) => {
   const connectionInfo = useConnectionInfo();
   const { id: connectionId, atlasMetadata } = connectionInfo;
@@ -151,6 +154,9 @@ const CollectionHeaderActions: React.FunctionComponent<
             'At this time we are unable to generate mock data for collections that have deeply nested documents'}
           {isCollectionEmpty &&
             'Please add data to your collection to generate similar mock documents'}
+          {schemaAnalysisError &&
+            schemaAnalysisError.errorType === 'unsupportedState' &&
+            'This collection has a field with a name that contains a ".", which mock data generation does not support at this time.'}
         </Tooltip>
       )}
       {atlasMetadata && (

packages/compass-collection/src/components/collection-header/collection-header.tsx

@@ -24,7 +24,9 @@ import { openMockDataGeneratorModal } from '../../modules/collection-tab';
 import type { CollectionState } from '../../modules/collection-tab';
 import {
   SCHEMA_ANALYSIS_STATE_COMPLETE,
+  SCHEMA_ANALYSIS_STATE_ERROR,
   type SchemaAnalysisStatus,
+  type SchemaAnalysisError,
 } from '../../schema-analysis-types';
 
 const collectionHeaderStyles = css({
@@ -70,6 +72,7 @@ type CollectionHeaderProps = {
   hasSchemaAnalysisData: boolean;
   analyzedSchemaDepth: number;
   schemaAnalysisStatus: SchemaAnalysisStatus | null;
+  schemaAnalysisError: SchemaAnalysisError | null;
 };
 
 const getInsightsForPipeline = (pipeline: any[], isAtlas: boolean) => {
@@ -108,6 +111,7 @@ const CollectionHeader: React.FunctionComponent<CollectionHeaderProps> = ({
   hasSchemaAnalysisData,
   analyzedSchemaDepth,
   schemaAnalysisStatus,
+  schemaAnalysisError,
 }) => {
   const darkMode = useDarkMode();
   const showInsights = usePreference('showInsights');
@@ -188,6 +192,7 @@ const CollectionHeader: React.FunctionComponent<CollectionHeaderProps> = ({
           hasSchemaAnalysisData={hasSchemaAnalysisData}
           analyzedSchemaDepth={analyzedSchemaDepth}
           schemaAnalysisStatus={schemaAnalysisStatus}
+          schemaAnalysisError={schemaAnalysisError}
         />
       </div>
       <MockDataGeneratorModal />
@@ -199,6 +204,10 @@ const mapStateToProps = (state: CollectionState) => {
   const { schemaAnalysis } = state;
 
   return {
+    schemaAnalysisError:
+      schemaAnalysis && schemaAnalysis.status === SCHEMA_ANALYSIS_STATE_ERROR
+        ? schemaAnalysis.error
+        : null,
     hasSchemaAnalysisData:
       schemaAnalysis &&
       schemaAnalysis.status === SCHEMA_ANALYSIS_STATE_COMPLETE &&

packages/compass-collection/src/components/mock-data-generator-modal/to-simplified-field-info.ts

@@ -1,3 +1,4 @@
+import { FIELD_NAME_SEPARATOR } from '../../transform-schema-to-field-info';
 import type { processSchema } from '../../transform-schema-to-field-info';
 import type { FieldInfo } from '../../schema-analysis-types';
 
@@ -22,7 +23,7 @@ export default function toSimplifiedFieldInfo(
 
   const result: SimplifiedFieldInfoTree = {};
   for (const path of sortedFieldPaths) {
-    const fieldParts = path.split('.');
+    const fieldParts = path.split(FIELD_NAME_SEPARATOR);
 
     let node = result;
     for (let i = 0; i < fieldParts.length; i++) {

packages/compass-collection/src/modules/collection-tab.ts

@@ -32,7 +32,10 @@ import {
   type FieldInfo,
 } from '../schema-analysis-types';
 import { calculateSchemaDepth } from '../calculate-schema-depth';
-import { processSchema } from '../transform-schema-to-field-info';
+import {
+  processSchema,
+  ProcessSchemaUnsupportedStateError,
+} from '../transform-schema-to-field-info';
 import type { Document, MongoError } from 'mongodb';
 import { MockDataGeneratorStep } from '../components/mock-data-generator-modal/types';
 import type { MockDataGeneratorState } from '../components/mock-data-generator-modal/types';
@@ -51,6 +54,13 @@ function isAction<A extends AnyAction>(
 const ERROR_CODE_MAX_TIME_MS_EXPIRED = 50;
 
 function getErrorDetails(error: Error): SchemaAnalysisError {
+  if (error instanceof ProcessSchemaUnsupportedStateError) {
+    return {
+      errorType: 'unsupportedState',
+      errorMessage: error.message,
+    };
+  }
+
   const errorCode = (error as MongoError).code;
   const errorMessage = error.message || 'Unknown error';
   let errorType: SchemaAnalysisError['errorType'] = 'general';
@@ -648,6 +658,23 @@ export const analyzeCollectionSchema = (): CollectionThunkAction<
         return;
       }
 
+      if (err instanceof ProcessSchemaUnsupportedStateError) {
+        logger.log.error(
+          mongoLogId(1_001_000_365),
+          'Collection',
+          'Schema analysis failed due to unsupported state',
+          {
+            namespace,
+            error: err.message,
+          }
+        );
+        dispatch({
+          type: CollectionActions.SchemaAnalysisFailed,
+          error: err,
+        });
+        return;
+      }
+
       logger.log.error(
         mongoLogId(1_001_000_363),
         'Collection',

packages/compass-collection/src/schema-analysis-types.ts

@@ -22,7 +22,7 @@ export type SchemaAnalysisStartedState = {
 
 export type SchemaAnalysisError = {
   errorMessage: string;
-  errorType: 'timeout' | 'highComplexity' | 'general';
+  errorType: 'timeout' | 'highComplexity' | 'general' | 'unsupportedState';
 };
 
 export type SchemaAnalysisErrorState = {

packages/compass-collection/src/transform-schema-to-field-info.ts

@@ -43,6 +43,21 @@ import {
  * Maximum number of sample values to include for each field
  */
 const MAX_SAMPLE_VALUES = 10;
+export const FIELD_NAME_SEPARATOR = '.';
+
+export class ProcessSchemaUnsupportedStateError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ProcessSchemaUnsupportedStateError';
+  }
+}
+
+export class ProcessSchemaValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ProcessSchemaValidationError';
+  }
+}
 
 /**
  * Converts a BSON value to its primitive JavaScript equivalent
@@ -163,6 +178,12 @@ function processNamedField(
     return;
   }
 
+  if (field.name.includes(FIELD_NAME_SEPARATOR)) {
+    throw new ProcessSchemaUnsupportedStateError(
+      `no support for field names that contain a '.' ; field name: '${field.name}'`
+    );
+  }
+
   const currentPath = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
 
   // Process based on the type
@@ -238,13 +259,13 @@ function validateFieldPath(fieldPath: string) {
 
   for (const part of parts) {
     if (part === '') {
-      throw new Error(
+      throw new ProcessSchemaValidationError(
         `invalid fieldPath '${fieldPath}': field parts cannot be empty`
       );
     }
 
     if (part.replaceAll('[]', '') === '') {
-      throw new Error(
+      throw new ProcessSchemaValidationError(
         `invalid fieldPath '${fieldPath}': field parts must have characters other than '[]'`
       );
     }
@@ -257,7 +278,7 @@ function validateFieldPath(fieldPath: string) {
     //   $      - at the end of the string
     const remaining = part.replace(/(\[\])+$/, '');
     if (remaining.includes('[') || remaining.includes(']')) {
-      throw new Error(
+      throw new ProcessSchemaValidationError(
         `invalid fieldPath '${fieldPath}': '[]' can only appear at the end of field parts`
       );
     }