@sentry/wizard 3.11.0 → 3.13.0

package/src/utils/clack-utils.ts

@@ -17,6 +17,7 @@ import {
   installPackageWithPackageManager,
   packageManagers,
 } from './package-manager';
+import { debug } from './debug';
 
 const opn = require('opn') as (
   url: string,
@@ -124,18 +125,23 @@ export function printWelcome(options: {
 
   let welcomeText =
     options.message ||
-    'This Wizard will help you set up Sentry for your application.\nThank you for using Sentry :)';
+    `The ${options.wizardName} will help you set up Sentry for your application.\nThank you for using Sentry :)`;
 
   if (options.promoCode) {
-    welcomeText += `\n\nUsing promo-code: ${options.promoCode}`;
+    welcomeText = `${welcomeText}\n\nUsing promo-code: ${options.promoCode}`;
   }
 
   if (wizardPackage.version) {
-    welcomeText += `\n\nVersion: ${wizardPackage.version}`;
+    welcomeText = `${welcomeText}\n\nVersion: ${wizardPackage.version}`;
   }
 
   if (options.telemetryEnabled) {
-    welcomeText += `\n\nYou are using the Sentry Wizard with telemetry enabled. This helps us improve the Wizard.\nYou can disable it at any time by running \`sentry-wizard --disable-telemetry\`.`;
+    welcomeText = `${welcomeText}
+
+This wizard sends telemetry data and crash reports to Sentry. This helps us improve the Wizard.
+You can turn this off at any time by running ${chalk.cyanBright(
+      'sentry-wizard --disable-telemetry',
+    )}.`;
   }
 
   clack.note(welcomeText);
@@ -247,43 +253,9 @@ export async function installPackage({
   );
 }
 
-async function addOrgAndProjectToSentryCliRc(
-  org: string,
-  project: string,
-  setupConfig: CliSetupConfig,
-): Promise<void> {
-  const configContents = fs.readFileSync(
-    path.join(process.cwd(), setupConfig.filename),
-    'utf8',
-  );
-
-  if (setupConfig.likelyAlreadyHasOrgAndProject(configContents)) {
-    clack.log.warn(
-      `${chalk.bold(
-        setupConfig.filename,
-      )} already has org and project. Will not add them.`,
-    );
-  } else {
-    try {
-      await fs.promises.appendFile(
-        path.join(process.cwd(), setupConfig.filename),
-        `\n${setupConfig.orgAndProjContent(org, project)}\n`,
-      );
-    } catch (e) {
-      clack.log.warn(
-        `${chalk.bold(
-          setupConfig.filename,
-        )} could not be updated with org and project.`,
-      );
-    }
-  }
-}
-
 export async function addSentryCliConfig(
   authToken: string,
   setupConfig: CliSetupConfig = sourceMapsCliSetupConfig,
-  orgSlug?: string,
-  projectSlug?: string,
 ): Promise<void> {
   const configExists = fs.existsSync(
     path.join(process.cwd(), setupConfig.filename),
@@ -351,10 +323,6 @@ export async function addSentryCliConfig(
     }
   }
 
-  if (orgSlug && projectSlug) {
-    await addOrgAndProjectToSentryCliRc(orgSlug, projectSlug, setupConfig);
-  }
-
   await addAuthTokenFileToGitIgnore(setupConfig.filename);
 }
 
@@ -456,6 +424,7 @@ export async function ensurePackageIsInstalled(
   packageName: string,
 ) {
   if (!hasPackageInstalled(packageId, packageJson)) {
+    Sentry.setTag('package-installed', false);
     const continueWithoutPackage = await abortIfCancelled(
       clack.confirm({
         message: `${packageName} does not seem to be installed. Do you still want to continue?`,
@@ -466,6 +435,8 @@ export async function ensurePackageIsInstalled(
     if (!continueWithoutPackage) {
       await abort(undefined, 0);
     }
+  } else {
+    Sentry.setTag('package-installed', true);
   }
 }
 
@@ -778,14 +749,21 @@ async function askForWizardLogin(options: {
 async function askForProjectSelection(
   projects: SentryProjectData[],
 ): Promise<SentryProjectData> {
+  const label = (project: SentryProjectData): string => {
+    return `${project.organization.slug}/${project.slug}`;
+  };
+  const sortedProjects = [...projects];
+  sortedProjects.sort((a: SentryProjectData, b: SentryProjectData) => {
+    return label(a).localeCompare(label(b));
+  });
   const selection: SentryProjectData | symbol = await abortIfCancelled(
     clack.select({
       maxItems: 12,
       message: 'Select your Sentry project.',
-      options: projects.map((project) => {
+      options: sortedProjects.map((project) => {
         return {
           value: project,
-          label: `${project.organization.slug}/${project.slug}`,
+          label: label(project),
         };
       }),
     }),
@@ -797,3 +775,192 @@ async function askForProjectSelection(
 
   return selection;
 }
+
+/**
+ * Asks users if they have a config file for @param tool (e.g. Vite).
+ * If yes, asks users to specify the path to their config file.
+ *
+ * Use this helper function as a fallback mechanism if the lookup for
+ * a config file with its most usual location/name fails.
+ *
+ * @param toolName Name of the tool for which we're looking for the config file
+ * @param configFileName Name of the most common config file name (e.g. vite.config.js)
+ *
+ * @returns a user path to the config file or undefined if the user doesn't have a config file
+ */
+export async function askForToolConfigPath(
+  toolName: string,
+  configFileName: string,
+): Promise<string | undefined> {
+  const hasConfig = await abortIfCancelled(
+    clack.confirm({
+      message: `Do you have a ${toolName} config file (e.g. ${chalk.cyan(
+        configFileName,
+      )})?`,
+      initialValue: true,
+    }),
+  );
+
+  if (!hasConfig) {
+    return undefined;
+  }
+
+  return await abortIfCancelled(
+    clack.text({
+      message: `Please enter the path to your ${toolName} config file:`,
+      placeholder: path.join('.', configFileName),
+      validate: (value) => {
+        if (!value) {
+          return 'Please enter a path.';
+        }
+
+        try {
+          fs.accessSync(value);
+        } catch {
+          return 'Could not access the file at this path.';
+        }
+      },
+    }),
+  );
+}
+
+/**
+ * Prints copy/paste-able instructions to the console.
+ * Afterwards asks the user if they added the code snippet to their file.
+ *
+ * While there's no point in providing a "no" answer here, it gives users time to fulfill the
+ * task before the wizard continues with additional steps.
+ *
+ * Use this function if you want to show users instructions on how to add/modify
+ * code in their file. This is helpful if automatic insertion failed or is not possible/feasible.
+ *
+ * @param filename the name of the file to which the code snippet should be applied.
+ * If a path is provided, only the filename will be used.
+ *
+ * @param codeSnippet the snippet to be printed. Use {@link makeCodeSnippet}  to create the
+ * diff-like format for visually highlighting unchanged or modified lines of code.
+ *
+ * @param hint (optional) a hint to be printed after the main instruction to add
+ * the code from @param codeSnippet to their @param filename.
+ *
+ * More guidelines on copy/paste instructions:
+ * @see {@link https://develop.sentry.dev/sdk/setup-wizards/#copy--paste-snippets}
+ *
+ * TODO: refactor copy paste instructions across different wizards to use this function.
+ *       this might require adding a custom message parameter to the function
+ */
+export async function showCopyPasteInstructions(
+  filename: string,
+  codeSnippet: string,
+  hint?: string,
+): Promise<void> {
+  clack.log.step(
+    `Add the following code to your ${chalk.cyan(
+      path.basename(filename),
+    )} file:${hint ? chalk.dim(` (${chalk.dim(hint)})`) : ''}`,
+  );
+
+  // Padding the code snippet to be printed with a \n at the beginning and end
+  // This makes it easier to distinguish the snippet from the rest of the output
+  // Intentionally logging directly to console here so that the code can be copied/pasted directly
+  // eslint-disable-next-line no-console
+  console.log(`\n${codeSnippet}\n`);
+
+  await abortIfCancelled(
+    clack.select({
+      message: 'Did you apply the snippet above?',
+      options: [{ label: 'Yes, continue!', value: true }],
+      initialValue: true,
+    }),
+  );
+}
+
+/**
+ * Callback that exposes formatting helpers for a code snippet.
+ * @param unchanged - Formats text as old code.
+ * @param plus - Formats text as new code.
+ * @param minus - Formats text as removed code.
+ */
+type CodeSnippetFormatter = (
+  unchanged: (txt: string) => string,
+  plus: (txt: string) => string,
+  minus: (txt: string) => string,
+) => string;
+
+/**
+ * Crafts a code snippet that can be used to e.g.
+ * - print copy/paste instructions to the console
+ * - create a new config file.
+ *
+ * @param colors set this to true if you want the final snippet to be colored.
+ * This is useful for printing the snippet to the console as part of copy/paste instructions.
+ *
+ * @param callback the callback that returns the formatted code snippet.
+ * It exposes takes the helper functions for marking code as unchaned, new or removed.
+ * These functions no-op if no special formatting should be applied
+ * and otherwise apply the appropriate formatting/coloring.
+ * (@see {@link CodeSnippetFormatter})
+ *
+ * @see {@link showCopyPasteInstructions} for the helper with which to display the snippet in the console.
+ *
+ * @returns a string containing the final, formatted code snippet.
+ */
+export function makeCodeSnippet(
+  colors: boolean,
+  callback: CodeSnippetFormatter,
+): string {
+  const unchanged = (txt: string) => (colors ? chalk.grey(txt) : txt);
+  const plus = (txt: string) => (colors ? chalk.greenBright(txt) : txt);
+  const minus = (txt: string) => (colors ? chalk.redBright(txt) : txt);
+
+  return callback(unchanged, plus, minus);
+}
+
+/**
+ * Creates a new config file with the given @param filepath and @param codeSnippet.
+ *
+ * Use this function to create a new config file for users. This is useful
+ * when users answered that they don't yet have a config file for a tool.
+ *
+ * (This doesn't mean that they don't yet have some other way of configuring
+ * their tool but we can leave it up to them to figure out how to merge configs
+ * here.)
+ *
+ * @param filepath absolute path to the new config file
+ * @param codeSnippet the snippet to be inserted into the file
+ * @param moreInformation (optional) the message to be printed after the file was created
+ * For example, this can be a link to more information about configuring the tool.
+ *
+ * @returns true on sucess, false otherwise
+ */
+export async function createNewConfigFile(
+  filepath: string,
+  codeSnippet: string,
+  moreInformation?: string,
+): Promise<boolean> {
+  if (!path.isAbsolute(filepath)) {
+    debug(`createNewConfigFile: filepath is not absolute: ${filepath}`);
+    return false;
+  }
+
+  const prettyFilename = chalk.cyan(path.relative(process.cwd(), filepath));
+
+  try {
+    await fs.promises.writeFile(filepath, codeSnippet);
+
+    clack.log.success(`Added new ${prettyFilename} file.`);
+
+    if (moreInformation) {
+      clack.log.info(chalk.gray(moreInformation));
+    }
+
+    return true;
+  } catch (e) {
+    debug(e);
+    clack.log.warn(
+      `Could not create a new ${prettyFilename} file. Please create one manually and follow the instructions below.`,
+    );
+  }
+
+  return false;
+}

package/src/utils/package-manager.ts

@@ -10,38 +10,44 @@ export interface PackageManager {
   lockFile: string;
   installCommand: string;
   buildCommand: string;
+  /* The command that the package manager uses to run a script from package.json */
+  runScriptCommand: string;
 }
 
-const bun: PackageManager = {
+export const BUN: PackageManager = {
   name: 'bun',
   label: 'Bun',
   lockFile: 'bun.lockb',
   installCommand: 'bun add',
-  buildCommand: 'bun build',
+  buildCommand: 'bun run build',
+  runScriptCommand: 'bun run',
 };
-const yarn: PackageManager = {
+export const YARN: PackageManager = {
   name: 'yarn',
   label: 'Yarn',
   lockFile: 'yarn.lock',
   installCommand: 'yarn add',
   buildCommand: 'yarn build',
+  runScriptCommand: 'yarn',
 };
-const pnpm: PackageManager = {
+export const PNPM: PackageManager = {
   name: 'pnpm',
   label: 'PNPM',
   lockFile: 'pnpm-lock.yaml',
   installCommand: 'pnpm add',
   buildCommand: 'pnpm build',
+  runScriptCommand: 'pnpm',
 };
-const npm: PackageManager = {
+export const NPM: PackageManager = {
   name: 'npm',
   label: 'NPM',
   lockFile: 'package-lock.json',
   installCommand: 'npm add',
   buildCommand: 'npm run build',
+  runScriptCommand: 'npm run',
 };
 
-export const packageManagers = [bun, yarn, pnpm, npm];
+export const packageManagers = [BUN, YARN, PNPM, NPM];
 
 export function detectPackageManger(): PackageManager | null {
   for (const packageManager of packageManagers) {

package/test/android/code-tools.test.ts

@@ -0,0 +1,49 @@
+//@ts-ignore
+import { getLastImportLineLocation } from '../../src/android/code-tools';
+
+describe('code-tools', () => {
+  describe('getLastImportLineLocation', () => {
+    it('returns proper line index', () => {
+      const code = `import a.b.c;\n` + `//<insert-location>\n` + `class X {}`;
+      expect(getLastImportLineLocation(code)).toBe(
+        code.indexOf('//<insert-location>'),
+      );
+    });
+
+    it('returns proper line index when static import is used', () => {
+      const code =
+        `import static a.b.c;\n` + `//<insert-location>\n` + `class X {}`;
+      expect(getLastImportLineLocation(code)).toBe(
+        code.indexOf('//<insert-location>'),
+      );
+    });
+
+    it('returns proper line index when wildcard import is used', () => {
+      const code = `import a.b.*\n` + `//<insert-location>\n` + `class X {}`;
+      expect(getLastImportLineLocation(code)).toBe(
+        code.indexOf('//<insert-location>'),
+      );
+    });
+
+    it('returns proper line index when alias import is used', () => {
+      const code =
+        `import static a.b.c as d\n` + `//<insert-location>\n` + `class X {}`;
+      expect(getLastImportLineLocation(code)).toBe(
+        code.indexOf('//<insert-location>'),
+      );
+    });
+
+    it('returns proper line index when multiple imports are present', () => {
+      const code =
+        `import static a.b.c as d\n` +
+        `import a.b.*\n` +
+        `import static a.b.c;\n` +
+        `import a.b.c;\n` +
+        `//<insert-location>\n` +
+        `class X {}`;
+      expect(getLastImportLineLocation(code)).toBe(
+        code.indexOf('//<insert-location>'),
+      );
+    });
+  });
+});

package/test/sourcemaps/tools/sentry-cli.test.ts

@@ -0,0 +1,51 @@
+import * as fs from 'fs';
+
+import { addSentryCommandToBuildCommand } from '../../../src/sourcemaps/tools/sentry-cli';
+
+import * as packageManagerHelpers from '../../../src/utils/package-manager';
+
+const writeFileSpy = jest
+  .spyOn(fs.promises, 'writeFile')
+  .mockImplementation(() => Promise.resolve());
+
+jest.mock('@clack/prompts', () => {
+  return {
+    log: {
+      info: jest.fn(),
+      success: jest.fn(),
+    },
+    confirm: jest.fn().mockResolvedValue(true),
+    isCancel: jest.fn().mockReturnValue(false),
+  };
+});
+
+describe('addSentryCommandToBuildCommand', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  it.each([
+    [
+      packageManagerHelpers.NPM,
+      packageManagerHelpers.PNPM,
+      packageManagerHelpers.YARN,
+      packageManagerHelpers.BUN,
+    ],
+  ])('adds the cli command to the script command (%s)', async (_, pacMan) => {
+    jest
+      .spyOn(packageManagerHelpers, 'detectPackageManger')
+      .mockReturnValue(pacMan);
+    const packageJson = {
+      scripts: {
+        build: 'tsc',
+      },
+      version: '1.0.0',
+    };
+    await addSentryCommandToBuildCommand(packageJson);
+    expect(writeFileSpy).toHaveBeenCalledWith(
+      expect.stringContaining('package.json'),
+      expect.stringContaining(
+        `tsc && ${pacMan.runScriptCommand} sentry:sourcemaps`,
+      ),
+    );
+  });
+});

package/test/sourcemaps/tools/tsc.test.ts

@@ -0,0 +1,181 @@
+import * as fs from 'fs';
+import { enableSourcemaps } from '../../../src/sourcemaps/tools/tsc';
+
+function updateFileContent(content: string): void {
+  fileContent = content;
+}
+
+let fileContent = '';
+
+jest.mock('@clack/prompts', () => {
+  return {
+    log: {
+      info: jest.fn(),
+      success: jest.fn(),
+    },
+  };
+});
+
+jest
+  .spyOn(fs.promises, 'readFile')
+  .mockImplementation(() => Promise.resolve(fileContent));
+
+const writeFileSpy = jest
+  .spyOn(fs.promises, 'writeFile')
+  .mockImplementation(() => Promise.resolve(void 0));
+
+describe('enableSourcemaps', () => {
+  afterEach(() => {
+    fileContent = '';
+    jest.clearAllMocks();
+  });
+
+  it.each([
+    [
+      'no sourcemaps options',
+      `
+/**
+ * My TS config with comments
+ */
+{
+  "extends": "./tsconfig.build.json",
+
+  "compilerOptions": {
+    // line comment which should stay
+    "moduleResolution": "node16",
+    "outDir": "dist" // another inline comment
+  },
+
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ]
+}
+`,
+      `
+/**
+ * My TS config with comments
+ */
+{
+  "extends": "./tsconfig.build.json",
+
+  "compilerOptions": {
+    // line comment which should stay
+    "moduleResolution": "node16",
+
+    // another inline comment
+    "outDir": "dist",
+
+    "sourceMap": true,
+    "inlineSources": true,
+
+    // Set \`sourceRoot\` to  "/" to strip the build path prefix
+    // from generated source code references.
+    // This improves issue grouping in Sentry.
+    "sourceRoot": "/"
+  },
+
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ]
+}
+`,
+    ],
+    [
+      'a few sourcemaps options',
+      `
+/**
+ * My TS config with comments
+ */
+{
+  "extends": "./tsconfig.build.json",
+
+  "compilerOptions": {
+    // line comment which should stay
+    "moduleResolution": "node16",
+    "outDir": "dist", // another inline comment
+    "sourceMap": false,
+    "sourceRoot": "/src"
+  },
+
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ]
+}
+`,
+      `
+/**
+ * My TS config with comments
+ */
+{
+  "extends": "./tsconfig.build.json",
+
+  "compilerOptions": {
+    // line comment which should stay
+    "moduleResolution": "node16",
+
+    // another inline comment
+    "outDir": "dist",
+
+    "sourceMap": true,
+
+    // Set \`sourceRoot\` to  "/" to strip the build path prefix
+    // from generated source code references.
+    // This improves issue grouping in Sentry.
+    "sourceRoot": "/",
+
+    "inlineSources": true
+  },
+
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ]
+}
+`,
+    ],
+    [
+      'no compiler options',
+      `
+{
+    "include": [
+        "src/**/*",
+        "test/**/*"
+    ]
+}
+`,
+      `
+{
+    "include": [
+        "src/**/*",
+        "test/**/*"
+    ],
+
+    "compilerOptions": {
+        "sourceMap": true,
+        "inlineSources": true,
+
+        // Set \`sourceRoot\` to  "/" to strip the build path prefix
+        // from generated source code references.
+        // This improves issue grouping in Sentry.
+        "sourceRoot": "/"
+    }
+}
+`,
+    ],
+  ])(
+    'adds the plugin and enables source maps generation (%s)',
+    async (_, originalCode, expectedCode) => {
+      updateFileContent(originalCode);
+
+      const addedCode = await enableSourcemaps('');
+
+      expect(writeFileSpy).toHaveBeenCalledTimes(1);
+      const [[, fileContent]] = writeFileSpy.mock.calls;
+      expect(fileContent).toBe(expectedCode);
+      expect(addedCode).toBe(true);
+    },
+  );
+});