track not as an action

Author: paula-stacho

packages/compass-schema/src/components/export-schema-modal.tsx

@@ -26,7 +26,6 @@ import {
   trackSchemaExported,
   type SchemaFormat,
   type ExportStatus,
-  trackSchemaExportFailed,
   downloadSchema,
 } from '../stores/schema-export-reducer';
 
@@ -210,7 +209,6 @@ export default connect(
   {
     onExportedSchemaCopied: trackSchemaExported,
     onExportedSchema: trackSchemaExported,
-    onSchemaExportFailed: trackSchemaExportFailed,
     onCancelSchemaExport: cancelExportSchema,
     onChangeSchemaExportFormat: changeExportSchemaFormat,
     onClose: closeExportSchema,

packages/compass-schema/src/stores/schema-export-reducer.ts

@@ -12,6 +12,8 @@ import { openToast } from '@mongodb-js/compass-components';
 import type { SchemaThunkAction } from './store';
 import { isAction } from '../utils';
 import { calculateSchemaMetadata } from '../modules/schema-analysis';
+import type { TrackFunction } from '@mongodb-js/compass-telemetry';
+import type { ConnectionInfoRef } from '@mongodb-js/compass-connections/provider';
 
 export type SchemaFormat =
   | 'standardJSON'
@@ -154,95 +156,114 @@ async function getSchemaByFormat({
 }
 
 export const downloadSchema = (): SchemaThunkAction<void> => {
-  return (dispatch, getState) => {
+  return (dispatch, getState, { track, connectionInfoRef }) => {
+    const {
+      schemaExport: { exportedSchema, exportFormat, filename },
+    } = getState();
+    if (!exportedSchema) return;
     try {
-      const {
-        schemaExport: { exportedSchema, filename },
-      } = getState();
-      if (!exportedSchema) return;
       const blob = new Blob([exportedSchema], {
         type: 'application/json',
       });
       const url = window.URL.createObjectURL(blob);
+
       const link = document.createElement('a');
       link.href = url;
       link.download = filename || 'export.json';
       link.click();
-      window.URL.revokeObjectURL(url);
+      setTimeout(() => {
+        window.URL.revokeObjectURL(url);
+        link.remove();
+      }, 0);
       dispatch(trackSchemaExported);
     } catch (error) {
-      dispatch(trackSchemaExportFailed('download button clicked'));
+      _trackSchemaExportFailed({
+        stage: 'download button clicked',
+        track,
+        connectionInfoRef,
+        exportedSchema,
+        exportFormat,
+      });
       throw error;
     }
   };
 };
 
-export const trackSchemaExportFailed = (
-  stage: string
-): SchemaThunkAction<void> => {
-  return (dispatch, getState, { track, connectionInfoRef }) => {
-    const { exportedSchema, exportFormat } = getState().schemaExport;
-    track(
-      'Schema Export Failed',
-      {
-        has_schema: !!exportedSchema,
-        schema_length: exportedSchema?.length || 0,
-        format: exportFormat,
-        stage,
-      },
-      connectionInfoRef.current
-    );
-  };
+const _trackSchemaExportFailed = ({
+  stage,
+  track,
+  connectionInfoRef,
+  exportedSchema,
+  exportFormat,
+}: {
+  stage: string;
+  track: TrackFunction;
+  connectionInfoRef: ConnectionInfoRef;
+  exportedSchema: SchemaExportState['exportedSchema'];
+  exportFormat: SchemaExportState['exportFormat'];
+}) => {
+  track(
+    'Schema Export Failed',
+    {
+      has_schema: !!exportedSchema,
+      schema_length: exportedSchema?.length || 0,
+      format: exportFormat,
+      stage,
+    },
+    connectionInfoRef.current
+  );
 };
 
 const _trackSchemaExported = ({
   schema,
   source,
   format,
+  track,
+  connectionInfoRef,
 }: {
   schema: InternalSchema | null;
   source: 'app_menu' | 'schema_tab';
   format: SchemaFormat;
-}): SchemaThunkAction<void> => {
-  return (dispatch, getState, { track, connectionInfoRef }) => {
-    // Use a function here to a) ensure that the calculations here
-    // are only made when telemetry is enabled and b) that errors from
-    // those calculations are caught and logged rather than displayed to
-    // users as errors from the core schema sharing logic.
-    const trackEvent = async () => {
-      const { geo_data, schema_depth } = schema
-        ? await calculateSchemaMetadata(schema)
-        : {
-            geo_data: false,
-            schema_depth: 0,
-          };
-
-      return {
-        has_schema: schema !== null,
-        format,
-        source,
-        schema_width: schema?.fields?.length ?? 0,
-        schema_depth,
-        geo_data,
-      };
+  track: TrackFunction;
+  connectionInfoRef: ConnectionInfoRef;
+}) => {
+  // Use a function here to a) ensure that the calculations here
+  // are only made when telemetry is enabled and b) that errors from
+  // those calculations are caught and logged rather than displayed to
+  // users as errors from the core schema sharing logic.
+  const trackEvent = async () => {
+    const { geo_data, schema_depth } = schema
+      ? await calculateSchemaMetadata(schema)
+      : {
+          geo_data: false,
+          schema_depth: 0,
+        };
+
+    return {
+      has_schema: schema !== null,
+      format,
+      source,
+      schema_width: schema?.fields?.length ?? 0,
+      schema_depth,
+      geo_data,
     };
-    track('Schema Exported', trackEvent, connectionInfoRef.current);
   };
+  track('Schema Exported', trackEvent, connectionInfoRef.current);
 };
 
 export const trackSchemaExported = (): SchemaThunkAction<void> => {
-  return (dispatch, getState) => {
+  return (dispatch, getState, { track, connectionInfoRef }) => {
     const {
       schemaAnalysis: { schema },
       schemaExport: { exportFormat },
     } = getState();
-    dispatch(
-      _trackSchemaExported({
-        schema,
-        format: exportFormat,
-        source: 'schema_tab',
-      })
-    );
+    _trackSchemaExported({
+      schema,
+      format: exportFormat,
+      source: 'schema_tab',
+      track,
+      connectionInfoRef,
+    });
   };
 };
 
@@ -257,7 +278,14 @@ export const changeExportSchemaFormat = (
   return async (
     dispatch,
     getState,
-    { logger: { log }, exportAbortControllerRef, schemaAccessorRef, namespace }
+    {
+      logger: { log },
+      exportAbortControllerRef,
+      schemaAccessorRef,
+      namespace,
+      track,
+      connectionInfoRef,
+    }
   ) => {
     // If we're already in progress we abort their current operation.
     exportAbortControllerRef.current?.abort();
@@ -308,7 +336,13 @@ export const changeExportSchemaFormat = (
         type: SchemaExportActions.changeExportSchemaFormatError,
         errorMessage: (err as Error).message,
       });
-      dispatch(trackSchemaExportFailed('switching format'));
+      _trackSchemaExportFailed({
+        stage: 'switching format',
+        track,
+        connectionInfoRef,
+        exportedSchema: undefined,
+        exportFormat,
+      });
       return;
     }
 
@@ -509,21 +543,21 @@ export const switchToSchemaExport = (): SchemaThunkAction<void> => {
 
 export const confirmedExportLegacySchemaToClipboard =
   (): SchemaThunkAction<void> => {
-    return (dispatch, getState, { namespace }) => {
+    return (dispatch, getState, { namespace, track, connectionInfoRef }) => {
       const {
         schemaAnalysis: { schema },
       } = getState();
       const hasSchema = schema !== null;
       if (hasSchema) {
         void navigator.clipboard.writeText(JSON.stringify(schema, null, '  '));
       }
-      dispatch(
-        _trackSchemaExported({
-          schema,
-          source: 'app_menu',
-          format: 'legacyJSON',
-        })
-      );
+      _trackSchemaExported({
+        schema,
+        source: 'app_menu',
+        format: 'legacyJSON',
+        track,
+        connectionInfoRef,
+      });
       dispatch({ type: SchemaExportActions.closeLegacyBanner });
       openToast(
         'share-schema',