@sentry/wizard 3.42.1 → 4.0.1

package/src/nuxt/nuxt-wizard.ts

@@ -1,188 +0,0 @@
-// @ts-ignore - clack is ESM and TS complains about that. It works though
-import * as clack from '@clack/prompts';
-import * as Sentry from '@sentry/node';
-import chalk from 'chalk';
-import { lt, minVersion } from 'semver';
-import type { WizardOptions } from '../utils/types';
-import { traceStep, withTelemetry } from '../telemetry';
-import {
-  abort,
-  abortIfCancelled,
-  addDotEnvSentryBuildPluginFile,
-  askShouldCreateExampleComponent,
-  askShouldCreateExamplePage,
-  confirmContinueIfNoOrDirtyGitRepo,
-  ensurePackageIsInstalled,
-  getOrAskForProjectData,
-  getPackageDotJson,
-  getPackageManager,
-  installPackage,
-  printWelcome,
-  runPrettierIfInstalled,
-} from '../utils/clack-utils';
-import { getPackageVersion, hasPackageInstalled } from '../utils/package-json';
-import {
-  addSDKModule,
-  getNuxtConfig,
-  createConfigFiles,
-  addNuxtOverrides,
-  askDeploymentPlatform,
-  confirmReadImportDocs,
-} from './sdk-setup';
-import {
-  createExampleComponent,
-  createExamplePage,
-  supportsExamplePage,
-} from './sdk-example';
-import { isNuxtV4 } from './utils';
-
-export function runNuxtWizard(options: WizardOptions) {
-  return withTelemetry(
-    {
-      enabled: options.telemetryEnabled,
-      integration: 'nuxt',
-      wizardOptions: options,
-    },
-    () => runNuxtWizardWithTelemetry(options),
-  );
-}
-
-export async function runNuxtWizardWithTelemetry(
-  options: WizardOptions,
-): Promise<void> {
-  const { promoCode, telemetryEnabled, forceInstall } = options;
-
-  printWelcome({
-    wizardName: 'Sentry Nuxt Wizard',
-    promoCode,
-    telemetryEnabled,
-  });
-
-  await confirmContinueIfNoOrDirtyGitRepo();
-
-  const packageJson = await getPackageDotJson();
-
-  await ensurePackageIsInstalled(packageJson, 'nuxt', 'Nuxt');
-
-  const nuxtVersion = getPackageVersion('nuxt', packageJson);
-  Sentry.setTag('nuxt-version', nuxtVersion);
-
-  const minVer = minVersion(nuxtVersion || '0.0.0');
-
-  if (!nuxtVersion || !minVer || lt(minVer, '3.7.0')) {
-    clack.log.warn(
-      "It seems you're using a Nuxt version <3.7.0 which is not supported by Sentry.\nWe recommend upgrading to the latest version before you continue.",
-    );
-    const shouldContinue = await abortIfCancelled(
-      clack.select({
-        message: 'Do you want to continue anyway?',
-        options: [
-          {
-            label: 'Yes, continue',
-            hint: 'The SDK might not work correctly',
-            value: true,
-          },
-          { label: "No, I'll upgrade first", value: false },
-        ],
-      }),
-    );
-    if (!shouldContinue) {
-      await abort('Exiting Wizard', 0);
-      return;
-    }
-  }
-
-  const { authToken, selectedProject, selfHosted, sentryUrl } =
-    await getOrAskForProjectData(options, 'javascript-nuxt');
-
-  const packageManager = await getPackageManager();
-
-  await addNuxtOverrides(packageJson, packageManager, minVer, forceInstall);
-
-  const sdkAlreadyInstalled = hasPackageInstalled('@sentry/nuxt', packageJson);
-  Sentry.setTag('sdk-already-installed', sdkAlreadyInstalled);
-
-  await installPackage({
-    packageName: '@sentry/nuxt@^9',
-    alreadyInstalled: sdkAlreadyInstalled,
-    packageManager,
-    forceInstall,
-  });
-
-  await addDotEnvSentryBuildPluginFile(authToken);
-
-  const nuxtConfig = await traceStep('load-nuxt-config', getNuxtConfig);
-
-  const projectData = {
-    org: selectedProject.organization.slug,
-    project: selectedProject.slug,
-    projectId: selectedProject.id,
-    url: sentryUrl,
-    selfHosted,
-  };
-
-  const deploymentPlatform = await askDeploymentPlatform();
-  Sentry.setTag('deployment-platform', deploymentPlatform);
-
-  await traceStep('configure-sdk', async () => {
-    await addSDKModule(nuxtConfig, projectData, deploymentPlatform);
-    await createConfigFiles(selectedProject.keys[0].dsn.public);
-  });
-
-  let shouldCreateExamplePage = false;
-  let shouldCreateExampleButton = false;
-
-  const isV4 = await isNuxtV4(nuxtConfig, nuxtVersion);
-  const canCreateExamplePage = await supportsExamplePage(isV4);
-  Sentry.setTag('supports-example-page-creation', canCreateExamplePage);
-
-  if (canCreateExamplePage) {
-    shouldCreateExamplePage = await askShouldCreateExamplePage();
-
-    if (shouldCreateExamplePage) {
-      await traceStep('create-example-page', async () =>
-        createExamplePage(isV4, projectData),
-      );
-    }
-  } else {
-    shouldCreateExampleButton = await askShouldCreateExampleComponent();
-
-    if (shouldCreateExampleButton) {
-      await traceStep('create-example-component', async () =>
-        createExampleComponent(isV4),
-      );
-    }
-  }
-
-  await runPrettierIfInstalled();
-
-  await confirmReadImportDocs(deploymentPlatform);
-
-  clack.outro(
-    buildOutroMessage(shouldCreateExamplePage, shouldCreateExampleButton),
-  );
-}
-
-function buildOutroMessage(
-  shouldCreateExamplePage: boolean,
-  shouldCreateExampleButton: boolean,
-): string {
-  let msg = chalk.green('\nSuccessfully installed the Sentry Nuxt SDK!');
-
-  if (shouldCreateExamplePage) {
-    msg += `\n\nYou can validate your setup by visiting ${chalk.cyan(
-      '"/sentry-example-page"',
-    )}.`;
-  }
-  if (shouldCreateExampleButton) {
-    msg += `\n\nYou can validate your setup by adding the ${chalk.cyan(
-      '`SentryExampleButton`',
-    )} component to a page and triggering it.`;
-  }
-
-  msg += `\n\nCheck out the SDK documentation for further configuration: ${chalk.underline(
-    'https://docs.sentry.io/platforms/javascript/guides/nuxt/',
-  )}`;
-
-  return msg;
-}

package/src/nuxt/sdk-example.ts

@@ -1,135 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-// @ts-expect-error - clack is ESM and TS complains about that. It works though
-import clack from '@clack/prompts';
-import {
-  getIndexRouteTemplate,
-  getSentryExampleApiTemplate,
-  getSentryExamplePageTemplate,
-  getSentryErrorButtonTemplate,
-} from './templates';
-import { abort, isUsingTypeScript } from '../utils/clack-utils';
-import chalk from 'chalk';
-import * as Sentry from '@sentry/node';
-
-function getSrcDirectory(isNuxtV4: boolean) {
-  // In nuxt v4, the src directory is `app/` unless
-  // users already had a `pages` directory
-  return isNuxtV4 && !fs.existsSync(path.resolve('pages')) ? 'app' : '.';
-}
-
-export async function supportsExamplePage(isNuxtV4: boolean) {
-  // We currently only support creating an example page
-  // if users can reliably access it without having to
-  // add code changes themselves.
-  //
-  // If users have an `app.vue` layout without the
-  // needed component to render routes (<NuxtPage/>),
-  // we bail out of creating an example page altogether.
-  const src = getSrcDirectory(isNuxtV4);
-  const app = path.join(src, 'app.vue');
-
-  // If there's no `app.vue` layout, nuxt automatically renders
-  // the routes.
-  if (!fs.existsSync(path.resolve(app))) {
-    return true;
-  }
-
-  const content = await fs.promises.readFile(path.resolve(app), 'utf8');
-  return !!content.match(/<NuxtPage/g);
-}
-
-export async function createExamplePage(
-  isNuxtV4: boolean,
-  options: {
-    org: string;
-    project: string;
-    projectId: string;
-    url: string;
-  },
-) {
-  try {
-    const src = getSrcDirectory(isNuxtV4);
-    const pages = path.join(src, 'pages');
-
-    if (!fs.existsSync(path.resolve(pages))) {
-      fs.mkdirSync(path.resolve(pages), { recursive: true });
-
-      const indexPage = path.join(pages, 'index.vue');
-
-      await fs.promises.writeFile(
-        path.resolve(indexPage),
-        getIndexRouteTemplate(),
-      );
-
-      clack.log.success(`Created ${chalk.cyan(indexPage)}.`);
-    }
-
-    const examplePage = path.join(pages, 'sentry-example-page.vue');
-
-    if (fs.existsSync(path.resolve(examplePage))) {
-      clack.log.warn(
-        `It seems like a sentry example page already exists. Skipping creation of example page.`,
-      );
-      return;
-    }
-
-    await fs.promises.writeFile(
-      path.resolve(examplePage),
-      getSentryExamplePageTemplate(options),
-    );
-
-    clack.log.success(`Created ${chalk.cyan(examplePage)}.`);
-
-    const api = path.join('server', 'api');
-
-    if (!fs.existsSync(path.resolve(api))) {
-      fs.mkdirSync(path.resolve(api), { recursive: true });
-    }
-
-    const exampleApi = path.join(
-      api,
-      isUsingTypeScript() ? 'sentry-example-api.ts' : 'sentry-example-api.js',
-    );
-
-    await fs.promises.writeFile(
-      path.resolve(exampleApi),
-      getSentryExampleApiTemplate(),
-    );
-
-    clack.log.success(`Created ${chalk.cyan(exampleApi)}.`);
-  } catch (e: unknown) {
-    clack.log.error('Error while creating an example page to test Sentry:');
-    clack.log.info(
-      chalk.dim(
-        typeof e === 'object' && e != null && 'toString' in e
-          ? e.toString()
-          : typeof e === 'string'
-          ? e
-          : 'Unknown error',
-      ),
-    );
-    Sentry.captureException(
-      'Error while creating an example Nuxt page to test Sentry',
-    );
-    await abort('Exiting Wizard');
-  }
-}
-
-export async function createExampleComponent(isNuxtV4: boolean) {
-  const src = getSrcDirectory(isNuxtV4);
-  const components = path.join(src, 'components');
-
-  if (!fs.existsSync(path.resolve(components))) {
-    fs.mkdirSync(path.resolve(components), { recursive: true });
-  }
-
-  const exampleComponent = path.join(components, 'SentryErrorButton.vue');
-
-  await fs.promises.writeFile(
-    path.resolve(exampleComponent),
-    getSentryErrorButtonTemplate(),
-  );
-
-  clack.log.success(`Created ${chalk.cyan(exampleComponent)}.`);
-}

package/src/nuxt/sdk-setup.ts

@@ -1,349 +0,0 @@
-// @ts-expect-error - clack is ESM and TS complains about that. It works though
-import * as clack from '@clack/prompts';
-import * as Sentry from '@sentry/node';
-import chalk from 'chalk';
-import fs from 'fs';
-// @ts-expect-error - magicast is ESM and TS complains about that. It works though
-import { loadFile, generateCode } from 'magicast';
-// @ts-expect-error - magicast is ESM and TS complains about that. It works though
-import { addNuxtModule } from 'magicast/helpers';
-import path from 'path';
-import {
-  getConfigBody,
-  getDefaultNuxtConfig,
-  getNuxtModuleFallbackTemplate,
-  getSentryConfigContents,
-} from './templates';
-import {
-  abortIfCancelled,
-  askShouldAddPackageOverride,
-  askShouldInstallPackage,
-  featureSelectionPrompt,
-  installPackage,
-  isUsingTypeScript,
-  opn,
-} from '../utils/clack-utils';
-import { traceStep } from '../telemetry';
-import { lt, SemVer } from 'semver';
-import { PackageManager, PNPM } from '../utils/package-manager';
-import { hasPackageInstalled, PackageDotJson } from '../utils/package-json';
-import { deploymentPlatforms, DeploymentPlatform } from './types';
-
-const possibleNuxtConfig = [
-  'nuxt.config.js',
-  'nuxt.config.mjs',
-  'nuxt.config.cjs',
-  'nuxt.config.ts',
-  'nuxt.config.mts',
-  'nuxt.config.cts',
-];
-
-export async function getNuxtConfig(): Promise<string> {
-  let configFile = possibleNuxtConfig.find((fileName) =>
-    fs.existsSync(path.join(process.cwd(), fileName)),
-  );
-
-  if (!configFile) {
-    clack.log.info('No Nuxt config file found, creating a new one.');
-    Sentry.setTag('nuxt-config-strategy', 'create');
-    // nuxt recommends its config to be .ts by default
-    configFile = 'nuxt.config.ts';
-
-    await fs.promises.writeFile(
-      path.join(process.cwd(), configFile),
-      getDefaultNuxtConfig(),
-      { encoding: 'utf-8', flag: 'w' },
-    );
-
-    clack.log.success(`Created ${chalk.cyan('nuxt.config.ts')}.`);
-  }
-
-  return path.join(process.cwd(), configFile);
-}
-
-export async function askDeploymentPlatform(): Promise<
-  DeploymentPlatform | symbol
-> {
-  return await abortIfCancelled(
-    clack.select({
-      message: 'Please select your deployment platform.',
-      options: deploymentPlatforms.map((platform) => ({
-        value: platform,
-        label: `${platform.charAt(0).toUpperCase()}${platform.slice(1)}`,
-      })),
-    }),
-  );
-}
-
-export async function addSDKModule(
-  config: string,
-  options: { org: string; project: string; url: string; selfHosted: boolean },
-  deploymentPlatform: DeploymentPlatform | symbol,
-): Promise<void> {
-  const shouldTopLevelImport =
-    deploymentPlatform === 'vercel' || deploymentPlatform === 'netlify';
-
-  if (shouldTopLevelImport) {
-    clack.log.warn(
-      `Sentry needs to be initialized before the application starts. ${chalk.cyan(
-        `${deploymentPlatform
-          .charAt(0)
-          .toUpperCase()}${deploymentPlatform.slice(1)}`,
-      )} does not support this yet.\n\nWe will inject the Sentry server-side config at the top of your Nuxt server entry file instead.\n\nThis comes with some restrictions, for more info see:\n\n${chalk.underline(
-        'https://docs.sentry.io/platforms/javascript/guides/nuxt/install/top-level-import/',
-      )} `,
-    );
-  }
-
-  try {
-    const mod = await loadFile(config);
-
-    addNuxtModule(mod, '@sentry/nuxt/module', 'sentry', {
-      sourceMapsUploadOptions: {
-        org: options.org,
-        project: options.project,
-        ...(options.selfHosted && { url: options.url }),
-      },
-      ...(shouldTopLevelImport && {
-        autoInjectServerSentry: 'top-level-import',
-      }),
-    });
-    addNuxtModule(mod, '@sentry/nuxt/module', 'sourcemap', {
-      client: 'hidden',
-    });
-
-    const { code } = generateCode(mod);
-
-    await fs.promises.writeFile(config, code, { encoding: 'utf-8', flag: 'w' });
-
-    clack.log.success(
-      `Added Sentry Nuxt Module to ${chalk.cyan(path.basename(config))}.`,
-    );
-  } catch (e: unknown) {
-    clack.log.error(
-      'Error while adding the Sentry Nuxt Module to the Nuxt config.',
-    );
-    clack.log.info(
-      chalk.dim(
-        typeof e === 'object' && e != null && 'toString' in e
-          ? e.toString()
-          : typeof e === 'string'
-          ? e
-          : 'Unknown error',
-      ),
-    );
-    Sentry.captureException(
-      'Error while setting up the Nuxt Module in nuxt config',
-    );
-
-    clack.log.warn(
-      `Please add the following settings to ${chalk.cyan(
-        path.basename(config),
-      )}:`,
-    );
-    // eslint-disable-next-line no-console
-    console.log(
-      `\n\n${getNuxtModuleFallbackTemplate(options, shouldTopLevelImport)}\n\n`,
-    );
-  }
-}
-
-export async function createConfigFiles(dsn: string) {
-  const selectedFeatures = await featureSelectionPrompt([
-    {
-      id: 'performance',
-      prompt: `Do you want to enable ${chalk.bold(
-        'Tracing',
-      )} to track the performance of your application?`,
-      enabledHint: 'recommended',
-    },
-    {
-      id: 'replay',
-      prompt: `Do you want to enable ${chalk.bold(
-        'Sentry Session Replay',
-      )} to get a video-like reproduction of errors during a user session?`,
-      enabledHint: 'recommended, but increases bundle size',
-    },
-  ] as const);
-
-  const typeScriptDetected = isUsingTypeScript();
-
-  const configVariants = ['server', 'client'] as const;
-
-  for (const configVariant of configVariants) {
-    await traceStep(`create-sentry-${configVariant}-config`, async () => {
-      const jsConfig = `sentry.${configVariant}.config.js`;
-      const tsConfig = `sentry.${configVariant}.config.ts`;
-
-      const jsConfigExists = fs.existsSync(path.join(process.cwd(), jsConfig));
-      const tsConfigExists = fs.existsSync(path.join(process.cwd(), tsConfig));
-
-      let shouldWriteFile = true;
-
-      if (jsConfigExists || tsConfigExists) {
-        const existingConfigs = [];
-
-        if (jsConfigExists) {
-          existingConfigs.push(jsConfig);
-        }
-
-        if (tsConfigExists) {
-          existingConfigs.push(tsConfig);
-        }
-
-        const overwriteExistingConfigs = await abortIfCancelled(
-          clack.confirm({
-            message: `Found existing Sentry ${configVariant} config (${existingConfigs.join(
-              ', ',
-            )}). Overwrite ${existingConfigs.length > 1 ? 'them' : 'it'}?`,
-          }),
-        );
-        Sentry.setTag(
-          `overwrite-${configVariant}-config`,
-          overwriteExistingConfigs,
-        );
-
-        shouldWriteFile = overwriteExistingConfigs;
-
-        if (overwriteExistingConfigs) {
-          if (jsConfigExists) {
-            fs.unlinkSync(path.join(process.cwd(), jsConfig));
-            clack.log.warn(`Removed existing ${chalk.cyan(jsConfig)}.`);
-          }
-          if (tsConfigExists) {
-            fs.unlinkSync(path.join(process.cwd(), tsConfig));
-            clack.log.warn(`Removed existing ${chalk.cyan(tsConfig)}.`);
-          }
-        }
-      }
-
-      if (shouldWriteFile) {
-        await fs.promises.writeFile(
-          path.join(process.cwd(), typeScriptDetected ? tsConfig : jsConfig),
-          getSentryConfigContents(dsn, configVariant, selectedFeatures),
-          { encoding: 'utf8', flag: 'w' },
-        );
-        clack.log.success(
-          `Created new ${chalk.cyan(
-            typeScriptDetected ? tsConfig : jsConfig,
-          )}.`,
-        );
-        Sentry.setTag(`created-${configVariant}-config`, true);
-      } else {
-        clack.log.info(
-          `Okay, here are the changes your ${chalk.cyan(
-            typeScriptDetected ? tsConfig : jsConfig,
-          )} should contain:`,
-        );
-        // eslint-disable-next-line no-console
-        console.log(
-          '\n\n  ' +
-            getConfigBody(dsn, configVariant, selectedFeatures) +
-            '\n\n',
-        );
-      }
-    });
-  }
-}
-
-export async function addNuxtOverrides(
-  packageJson: PackageDotJson,
-  packageManager: PackageManager,
-  nuxtMinVer: SemVer | null,
-  forceInstall?: boolean,
-) {
-  const isPNPM = PNPM.detect();
-
-  const overrides = [
-    {
-      pkgName: '@vercel/nft',
-      pkgVersion: '^0.27.4',
-    },
-    ...(nuxtMinVer && lt(nuxtMinVer, '3.14.0')
-      ? [{ pkgName: 'ofetch', pkgVersion: '^1.4.0' }]
-      : []),
-  ];
-
-  clack.log.warn(
-    `To ensure Sentry can properly instrument your code it needs to add version overrides for some Nuxt dependencies${
-      isPNPM ? ` and install ${chalk.cyan('import-in-the-middle')}.` : '.'
-    }\n\nFor more info see: ${chalk.underline(
-      'https://github.com/getsentry/sentry-javascript/issues/14514',
-    )}${
-      isPNPM
-        ? `\n\nand ${chalk.underline(
-            'https://docs.sentry.io/platforms/javascript/guides/nuxt/troubleshooting/#pnpm-dev-cannot-find-package-import-in-the-middle',
-          )}`
-        : ''
-    }`,
-  );
-
-  for (const { pkgName, pkgVersion } of overrides) {
-    const shouldAddOverride = await askShouldAddPackageOverride(
-      pkgName,
-      pkgVersion,
-    );
-
-    if (shouldAddOverride) {
-      await packageManager.addOverride(pkgName, pkgVersion);
-    }
-  }
-
-  if (PNPM.detect()) {
-    // For pnpm, we want to install iitm
-    // See: https://docs.sentry.io/platforms/javascript/guides/nuxt/troubleshooting/#pnpm-dev-cannot-find-package-import-in-the-middle
-    const iitmAlreadyInstalled = hasPackageInstalled(
-      'import-in-the-middle',
-      packageJson,
-    );
-    Sentry.setTag('iitm-already-installed', iitmAlreadyInstalled);
-
-    const shouldInstallIitm = await askShouldInstallPackage(
-      'import-in-the-middle',
-    );
-
-    if (shouldInstallIitm) {
-      await installPackage({
-        packageName: 'import-in-the-middle',
-        alreadyInstalled: iitmAlreadyInstalled,
-        packageManager,
-        forceInstall,
-      });
-    }
-  }
-}
-
-export async function confirmReadImportDocs(
-  deploymentPlatform: DeploymentPlatform | symbol,
-) {
-  const canImportSentryServerConfigFile =
-    deploymentPlatform !== 'vercel' && deploymentPlatform !== 'netlify';
-
-  if (!canImportSentryServerConfigFile) {
-    // Nothing to do, users have been set up with automatic top-level-import instead
-    return;
-  }
-
-  const docsUrl =
-    'https://docs.sentry.io/platforms/javascript/guides/nuxt/install/cli-import/#initializing-sentry-with---import';
-
-  clack.log.info(
-    `After building your Nuxt app, you need to ${chalk.bold(
-      '--import',
-    )} the Sentry server config file when running your app.\n\nFor more info, see:\n\n${chalk.underline(
-      docsUrl,
-    )}`,
-  );
-
-  const shouldOpenDocs = await abortIfCancelled(
-    clack.confirm({ message: 'Do you want to open the docs?' }),
-  );
-
-  Sentry.setTag('init-with-import-docs-opened', shouldOpenDocs);
-
-  if (shouldOpenDocs) {
-    opn(docsUrl, { wait: false }).catch(() => {
-      // opn throws in environments that don't have a browser (e.g. remote shells) so we just noop here
-    });
-  }
-}