@sentry/wizard 3.10.0 → 3.12.0

package/src/sourcemaps/tools/vite.ts

@@ -1,18 +1,25 @@
 // @ts-ignore - clack is ESM and TS complains about that. It works though
-import clack, { select } from '@clack/prompts';
+import * as clack from '@clack/prompts';
 // @ts-ignore - magicast is ESM and TS complains about that. It works though
 import { generateCode, parseModule } from 'magicast';
 // @ts-ignore - magicast is ESM and TS complains about that. It works though
 import { addVitePlugin } from 'magicast/helpers';
 
+import type { namedTypes as t } from 'ast-types';
+
+import * as recast from 'recast';
+
 import * as Sentry from '@sentry/node';
 
 import chalk from 'chalk';
 import {
   abortIfCancelled,
   addDotEnvSentryBuildPluginFile,
+  askForToolConfigPath,
+  createNewConfigFile,
   getPackageDotJson,
   installPackage,
+  showCopyPasteInstructions,
 } from '../../utils/clack-utils';
 import { hasPackageInstalled } from '../../utils/package-json';
 
@@ -20,7 +27,7 @@ import {
   SourceMapUploadToolConfigurationFunction,
   SourceMapUploadToolConfigurationOptions,
 } from './types';
-import { findScriptFile, hasSentryContent } from '../../utils/ast-utils';
+import { findFile, hasSentryContent } from '../../utils/ast-utils';
 
 import * as path from 'path';
 import * as fs from 'fs';
@@ -87,59 +94,44 @@ export const configureVitePlugin: SourceMapUploadToolConfigurationFunction =
     });
 
     const viteConfigPath =
-      findScriptFile(path.resolve(process.cwd(), 'vite.config')) ||
-      (await askForViteConfigPath());
+      findFile(path.resolve(process.cwd(), 'vite.config')) ??
+      (await askForToolConfigPath('Vite', 'vite.config.js'));
 
     let successfullyAdded = false;
     if (viteConfigPath) {
       successfullyAdded = await addVitePluginToConfig(viteConfigPath, options);
     } else {
-      successfullyAdded = await createNewViteConfig(options);
+      successfullyAdded = await createNewConfigFile(
+        path.join(process.cwd(), 'vite.config.js'),
+        getViteConfigSnippet(options, false),
+        'More information about vite configs: https://vitejs.dev/config/',
+      );
+      Sentry.setTag(
+        'created-new-config',
+        successfullyAdded ? 'success' : 'fail',
+      );
     }
 
     if (successfullyAdded) {
+      clack.log.info(
+        `We recommend checking the ${
+          viteConfigPath ? 'modified' : 'added'
+        } file after the wizard finished to ensure it works with your build setup.`,
+      );
+
       Sentry.setTag('ast-mod', 'success');
     } else {
       Sentry.setTag('ast-mod', 'fail');
       await showCopyPasteInstructions(
         path.basename(viteConfigPath || 'vite.config.js'),
-        options,
+        getViteConfigSnippet(options, true),
       );
     }
 
     await addDotEnvSentryBuildPluginFile(options.authToken);
   };
 
-async function createNewViteConfig(
-  options: SourceMapUploadToolConfigurationOptions,
-): Promise<boolean> {
-  try {
-    await fs.promises.writeFile(
-      'vite.config.js',
-      getViteConfigSnippet(options, false),
-    );
-    Sentry.setTag('created-new-config', 'success');
-    return true;
-  } catch (e) {
-    debug(e);
-    Sentry.setTag('created-new-config', 'fail');
-    clack.log.warn(
-      `Could not create a new ${chalk.cyan(
-        'vite.config.js',
-      )} file. Please create one manually and follow the instructions below.`,
-    );
-
-    clack.log.info(
-      chalk.gray(
-        'More information about vite configs: https://vitejs.dev/config/',
-      ),
-    );
-
-    return false;
-  }
-}
-
-async function addVitePluginToConfig(
+export async function addVitePluginToConfig(
   viteConfigPath: string,
   options: SourceMapUploadToolConfigurationOptions,
 ): Promise<boolean> {
@@ -152,7 +144,7 @@ async function addVitePluginToConfig(
 
     const mod = parseModule(viteConfigContent);
 
-    if (hasSentryContent(mod)) {
+    if (hasSentryContent(mod.$ast as t.Program)) {
       const shouldContinue = await abortIfCancelled(
         clack.select({
           message: `${prettyViteConfigFilename} already contains Sentry-related code. Should the wizard modify it anyway?`,
@@ -176,6 +168,12 @@ async function addVitePluginToConfig(
       }
     }
 
+    const enabledSourcemaps = enableSourcemapGeneration(mod.$ast as t.Program);
+    if (!enabledSourcemaps) {
+      Sentry.setTag('ast-mod-fail-reason', 'insertion-fail');
+      return false;
+    }
+
     const { orgSlug: org, projectSlug: project, selfHosted, url } = options;
 
     addVitePlugin(mod, {
@@ -194,7 +192,7 @@ async function addVitePluginToConfig(
     await fs.promises.writeFile(viteConfigPath, code);
 
     clack.log.success(
-      `Added the Sentry Vite plugin to ${prettyViteConfigFilename}`,
+      `Added the Sentry Vite plugin to ${prettyViteConfigFilename} and enabled source maps`,
     );
 
     return true;
@@ -205,56 +203,122 @@ async function addVitePluginToConfig(
   }
 }
 
-async function showCopyPasteInstructions(
-  viteConfigFilename: string,
-  options: SourceMapUploadToolConfigurationOptions,
-) {
-  clack.log.step(
-    `Add the following code to your ${chalk.cyan(viteConfigFilename)} file:`,
-  );
+function enableSourcemapGeneration(program: t.Program): boolean {
+  const configObj = getViteConfigObject(program);
+
+  if (!configObj) {
+    return false;
+  }
 
-  // Intentionally logging directly to console here so that the code can be copied/pasted directly
-  // eslint-disable-next-line no-console
-  console.log(`\n${getViteConfigSnippet(options, true)}`);
+  const b = recast.types.builders;
 
-  await abortIfCancelled(
-    select({
-      message: 'Did you copy the snippet above?',
-      options: [{ label: 'Yes, continue!', value: true }],
-      initialValue: true,
-    }),
+  const buildProp = configObj.properties.find(
+    (p: t.ObjectProperty) =>
+      p.key.type === 'Identifier' && p.key.name === 'build',
   );
+
+  // case 1: build property doesn't exist yet, so we can just add it
+  if (!buildProp) {
+    configObj.properties.push(
+      b.objectProperty(
+        b.identifier('build'),
+        b.objectExpression([
+          b.objectProperty(b.identifier('sourcemap'), b.booleanLiteral(true)),
+        ]),
+      ),
+    );
+    return true;
+  }
+
+  const isValidBuildProp =
+    buildProp.type === 'ObjectProperty' &&
+    buildProp.value.type === 'ObjectExpression';
+
+  if (!isValidBuildProp) {
+    return false;
+  }
+
+  const sourceMapsProp =
+    buildProp.value.type === 'ObjectExpression' &&
+    buildProp.value.properties.find(
+      (p: t.ObjectProperty) =>
+        p.key.type === 'Identifier' && p.key.name === 'sourcemap',
+    );
+
+  // case 2: build.sourcemap property doesn't exist yet, so we just add it
+  if (!sourceMapsProp && buildProp.value.type === 'ObjectExpression') {
+    buildProp.value.properties.push(
+      b.objectProperty(b.identifier('sourcemap'), b.booleanLiteral(true)),
+    );
+    return true;
+  }
+
+  if (!sourceMapsProp || sourceMapsProp.type !== 'ObjectProperty') {
+    return false;
+  }
+
+  // case 3: build.sourcemap property exists, and it's set to 'hidden'
+  if (
+    sourceMapsProp.value.type === 'StringLiteral' &&
+    sourceMapsProp.value.value === 'hidden'
+  ) {
+    // nothing to do for us
+    return true;
+  }
+
+  // case 4: build.sourcemap property exists, but it's not enabled, so we set it to true
+  //         or it is already true in which case this is a noop
+  sourceMapsProp.value = b.booleanLiteral(true);
+  return true;
 }
 
-async function askForViteConfigPath(): Promise<string | undefined> {
-  const hasViteConfig = await abortIfCancelled(
-    clack.confirm({
-      message: `Do you have a vite config file (e.g. ${chalk.cyan(
-        'vite.config.js',
-      )}?`,
-      initialValue: true,
-    }),
-  );
+function getViteConfigObject(
+  program: t.Program,
+): t.ObjectExpression | undefined {
+  const defaultExport = program.body.find(
+    (s) => s.type === 'ExportDefaultDeclaration',
+  ) as t.ExportDefaultDeclaration;
 
-  if (!hasViteConfig) {
+  if (!defaultExport) {
     return undefined;
   }
 
-  return await abortIfCancelled(
-    clack.text({
-      message: 'Please enter the path to your vite config file:',
-      placeholder: `.${path.sep}vite.config.js`,
-      validate: (value) => {
-        if (!value) {
-          return 'Please enter a path.';
-        }
+  if (defaultExport.declaration.type === 'ObjectExpression') {
+    return defaultExport.declaration;
+  }
+
+  if (
+    defaultExport.declaration.type === 'CallExpression' &&
+    defaultExport.declaration.arguments[0].type === 'ObjectExpression'
+  ) {
+    return defaultExport.declaration.arguments[0];
+  }
+
+  if (defaultExport.declaration.type === 'Identifier') {
+    const configId = defaultExport.declaration.name;
+    return findConfigNode(configId, program);
+  }
+
+  return undefined;
+}
 
-        try {
-          fs.accessSync(value);
-        } catch {
-          return 'Could not access the file at this path.';
+function findConfigNode(
+  configId: string,
+  program: t.Program,
+): t.ObjectExpression | undefined {
+  for (const node of program.body) {
+    if (node.type === 'VariableDeclaration') {
+      for (const declaration of node.declarations) {
+        if (
+          declaration.type === 'VariableDeclarator' &&
+          declaration.id.type === 'Identifier' &&
+          declaration.id.name === configId &&
+          declaration.init?.type === 'ObjectExpression'
+        ) {
+          return declaration.init;
         }
-      },
-    }),
-  );
+      }
+    }
+  }
+  return undefined;
 }