@sentry/wizard 3.4.0 → 3.5.0

package/src/sourcemaps/utils/sdk-version.ts

@@ -0,0 +1,264 @@
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import clack from '@clack/prompts';
+import chalk from 'chalk';
+import { minVersion, satisfies } from 'semver';
+import {
+  abortIfCancelled,
+  getPackageDotJson,
+  getPackageVersion,
+  installPackage,
+} from '../../utils/clack-utils';
+
+import * as Sentry from '@sentry/node';
+
+const MINIMUM_DEBUG_ID_SDK_VERSION = '7.47.0';
+
+// This array is orderd by the SDKs we want to check for first.
+// The reason is that some SDKs depend on others and some users might
+// have added the dependencies to their package.json. We want to make sure
+// that we actually detect the "top-level" SDK first.
+const SENTRY_SDK_PACKAGE_NAMES = [
+  // SDKs using other framework SDKs need to be checked first
+  '@sentry/gatsby',
+  '@sentry/nextjs',
+  '@sentry/remix',
+  '@sentry/sveltekit',
+
+  // Framework SDKs
+  '@sentry/angular',
+  '@sentry/angular-ivy',
+  '@sentry/ember',
+  '@sentry/react',
+  '@sentry/svelte',
+  '@sentry/vue',
+  '@sentry/serverless',
+
+  // Base SDKs
+  '@sentry/browser',
+  '@sentry/node',
+] as const;
+
+type SdkPackage = {
+  name: (typeof SENTRY_SDK_PACKAGE_NAMES)[number];
+  version: string;
+};
+
+/**
+ * Check for a minimum SDK version and prompt the user to upgrade if necessary.
+ * We distinguish between 4 cases here:
+ *
+ * 1. Users didn't install any SDK yet
+ *    -> We tell them to install an SDK and then continue with the wizard
+ * 2. Users installed an SDK in the range >=7.47.0
+ *    -> All good, no need to do anything!
+ * 3. Users installed an SDK in the range >=7.0.0 <= 7.46.0
+ *    -> We ask if they want to auto-update to the latest version
+ * 4. Users installed an SDK in the range <7.x
+ *    -> We tell users to manually upgrade (migrate between majors)
+ */
+export async function ensureMinimumSdkVersionIsInstalled(): Promise<void> {
+  const packageJson = await getPackageDotJson();
+
+  const installedSdkPackages = SENTRY_SDK_PACKAGE_NAMES.map((packageName) => ({
+    name: packageName,
+    version: getPackageVersion(packageName, packageJson),
+  })).filter((sdkPackage): sdkPackage is SdkPackage => !!sdkPackage.version);
+
+  const installedSdkPackage =
+    installedSdkPackages.length > 0 && installedSdkPackages[0];
+
+  // Case 1:
+  if (!installedSdkPackage) {
+    return await handleNoSdkInstalled();
+  }
+
+  const { name: installedSdkName, version: installedSdkVersionOrRange } =
+    installedSdkPackage;
+
+  const minInstalledVersion = getMinInstalledVersion(
+    installedSdkVersionOrRange,
+    installedSdkName,
+  );
+
+  if (!minInstalledVersion) {
+    // This is handled in the getMinInstalledVersion function
+    return;
+  }
+
+  const hasDebugIdCompatibleSdkVersion = satisfies(
+    minInstalledVersion,
+    `>=${MINIMUM_DEBUG_ID_SDK_VERSION}`,
+  );
+
+  // Case 2:
+  if (hasDebugIdCompatibleSdkVersion) {
+    Sentry.setTag('initial-sdk-version', '>=7.47.0');
+    return;
+  }
+
+  const hasV7SdkVersion = satisfies(minInstalledVersion, '>=7.0.0');
+
+  clack.log.warn(
+    `${chalk.yellowBright(
+      `It seems like you're using an outdated version (${installedSdkVersionOrRange}) of the ${chalk.bold(
+        installedSdkName,
+      )} SDK.`,
+    )}
+Uploading source maps is easiest with an SDK from version ${chalk.bold(
+      MINIMUM_DEBUG_ID_SDK_VERSION,
+    )} or newer.    
+`,
+  );
+
+  // Case 3:
+  if (hasV7SdkVersion) {
+    await handleAutoUpdateSdk(installedSdkName);
+    return;
+  }
+
+  // Case 4:
+  await handleManuallyUpdateSdk(minInstalledVersion);
+}
+
+async function handleManuallyUpdateSdk(minInstalledVersion: string) {
+  Sentry.setTag(
+    'initial-sdk-version',
+    `${satisfies(minInstalledVersion, '>=6.0.0') ? '6.x' : '<6.0.0'}`,
+  );
+
+  clack.log
+    .info(`When upgrading from a version older than 7.0.0, make sure to follow the migration guide:
+https://github.com/getsentry/sentry-javascript/blob/develop/MIGRATION.md#upgrading-from-6x-to-7x
+`);
+
+  const didUpdate = await abortIfCancelled(
+    clack.select({
+      message: 'Did you update your SDK to the latest version?',
+      options: [
+        {
+          label: 'Yes!',
+          value: true,
+        },
+        {
+          label: "No, I'll do it later...",
+          value: false,
+          hint: chalk.yellow(
+            `Remember to update your SDK to at least ${MINIMUM_DEBUG_ID_SDK_VERSION}.`,
+          ),
+        },
+      ],
+      initialValue: true,
+    }),
+  );
+
+  Sentry.setTag(
+    'resolved-sdk-status',
+    didUpdate ? 'updated-manually' : 'update-later',
+  );
+}
+
+async function handleAutoUpdateSdk(packageName: string) {
+  Sentry.setTag('initial-sdk-version', '>=7.0.0 <7.47.0');
+
+  const shouldUpdate = await abortIfCancelled(
+    clack.select({
+      message:
+        'Do you want to automatically update your SDK to the latest version?',
+      options: [
+        {
+          label: 'Yes!',
+          value: true,
+          hint: chalk.green('Recommended'),
+        },
+        {
+          label: "No, I'll do it later...",
+          value: false,
+          hint: chalk.yellow(
+            `Remember to update your SDK to at least ${MINIMUM_DEBUG_ID_SDK_VERSION}.`,
+          ),
+        },
+      ],
+      initialValue: true,
+    }),
+  );
+
+  if (shouldUpdate) {
+    await installPackage({
+      packageName,
+      alreadyInstalled: true,
+      askBeforeUpdating: false, // we already did this above
+    });
+  }
+
+  Sentry.setTag(
+    'resolved-sdk-status',
+    shouldUpdate ? 'updated-automatically' : 'update-later',
+  );
+}
+
+async function handleNoSdkInstalled(): Promise<void> {
+  Sentry.setTag('initial-sdk-version', 'none');
+
+  clack.log.warn(
+    `${chalk.yellowBright(
+      `It seems like you didn't yet install a Sentry SDK in your project.`,
+    )}
+We recommend setting up the SDK before continuing with the source maps wizard.
+
+${chalk.dim(`Take a look at our docs to get started:
+https://docs.sentry.io/`)}`,
+  );
+
+  const installedSDK = await abortIfCancelled(
+    clack.select({
+      message: 'Did you set up your Sentry SDK?',
+      options: [
+        { label: 'Yes, continue!', value: true },
+        {
+          label: "I'll do it later...",
+          value: false,
+          hint: chalk.yellow(
+            'You need to set up an SDK before you can use Sentry',
+          ),
+        },
+      ],
+      initialValue: true,
+    }),
+  );
+
+  Sentry.setTag(
+    'resolved-sdk-status',
+    installedSDK ? 'installed-manually' : 'install-later',
+  );
+}
+
+function getMinInstalledVersion(
+  installedSdkVersionOrRange: string,
+  installedSdkName: string,
+): string | undefined {
+  try {
+    // If `minVersion` is unable to parse the version it will throw an error
+    // However, it will also return `null` if the parameter is undefined, which
+    // we explicitly checked before but the typing doesn't know that.
+    const minInstalledVersion = minVersion(installedSdkVersionOrRange)?.version;
+    if (minInstalledVersion) {
+      return minInstalledVersion;
+    }
+  } catch {
+    // handling this, along with the `null` case below
+  }
+
+  Sentry.setTag('initial-sdk-version', 'unknown');
+  clack.log.warn(
+    `${chalk.yellow(
+      `Could not parse the version of your installed SDK ("${installedSdkName}": "${installedSdkVersionOrRange}")`,
+    )}
+
+Please make sure that your Sentry SDK is updated to version ${chalk.bold(
+      MINIMUM_DEBUG_ID_SDK_VERSION,
+    )} or newer.
+    `,
+  );
+
+  return undefined;
+}

package/src/sveltekit/sveltekit-wizard.ts

@@ -13,17 +13,14 @@ import {
   installPackage,
   printWelcome,
 } from '../utils/clack-utils';
+import { WizardOptions } from '../utils/types';
 import { createExamplePage } from './sdk-example';
 import { createOrMergeSvelteKitFiles, loadSvelteConfig } from './sdk-setup';
 
 import { setupCLIConfig } from './sentry-cli-setup';
 
-interface SvelteKitWizardOptions {
-  promoCode?: string;
-}
-
 export async function runSvelteKitWizard(
-  options: SvelteKitWizardOptions,
+  options: WizardOptions,
 ): Promise<void> {
   printWelcome({
     wizardName: 'Sentry SvelteKit Wizard',
@@ -35,7 +32,7 @@ export async function runSvelteKitWizard(
   const packageJson = await getPackageDotJson();
   await ensurePackageIsInstalled(packageJson, '@sveltejs/kit', 'Sveltekit');
 
-  const { url: sentryUrl, selfHosted } = await askForSelfHosted();
+  const { url: sentryUrl, selfHosted } = await askForSelfHosted(options.url);
 
   const { projects, apiKeys } = await askForWizardLogin({
     promoCode: options.promoCode,

package/src/utils/clack-utils.ts

@@ -11,6 +11,10 @@ import { promisify } from 'util';
 import * as Sentry from '@sentry/node';
 import { windowedSelect } from './vendor/clack-custom-select';
 
+const opn = require('opn') as (
+  url: string,
+) => Promise<childProcess.ChildProcess>;
+
 const SAAS_URL = 'https://sentry.io/';
 
 interface WizardProjectData {
@@ -179,14 +183,19 @@ export async function askForWizardLogin(options: {
     loginUrl.searchParams.set('code', options.promoCode);
   }
 
+  const urlToOpen = loginUrl.toString();
   clack.log.info(
     `${chalk.bold(
-      `Please open the following link in your browser to ${
+      `If the browser window didn't open automatically, please open the following link to ${
         hasSentryAccount ? 'log' : 'sign'
       } into Sentry:`,
-    )}\n\n${chalk.cyan(loginUrl.toString())}`,
+    )}\n\n${chalk.cyan(urlToOpen)}`,
   );
 
+  opn(urlToOpen).catch(() => {
+    // opn throws in environments that don't have a browser (e.g. remote shells) so we just noop here
+  });
+
   const loginSpinner = clack.spinner();
 
   loginSpinner.start(
@@ -250,11 +259,13 @@ export async function askForProjectSelection(
 export async function installPackage({
   packageName,
   alreadyInstalled,
+  askBeforeUpdating = true,
 }: {
   packageName: string;
   alreadyInstalled: boolean;
+  askBeforeUpdating?: boolean;
 }): Promise<void> {
-  if (alreadyInstalled) {
+  if (alreadyInstalled && askBeforeUpdating) {
     const shouldUpdatePackage = await abortIfCancelled(
       clack.confirm({
         message: `The ${chalk.bold.cyan(
@@ -306,34 +317,55 @@ export async function installPackage({
   );
 }
 
-export async function askForSelfHosted(): Promise<{
+/**
+ * Asks users if they are using SaaS or self-hosted Sentry and returns the validated URL.
+ *
+ * If users started the wizard with a --url arg, that URL is used as the default and we skip
+ * the self-hosted question. However, the passed url is still validated and in case it's
+ * invalid, users are asked to enter a new one until it is valid.
+ *
+ * @param urlFromArgs the url passed via the --url arg
+ */
+export async function askForSelfHosted(urlFromArgs?: string): Promise<{
   url: string;
   selfHosted: boolean;
 }> {
-  const choice: 'saas' | 'self-hosted' | symbol = await abortIfCancelled(
-    clack.select({
-      message: 'Are you using Sentry SaaS or self-hosted Sentry?',
-      options: [
-        { value: 'saas', label: 'Sentry SaaS (sentry.io)' },
-        { value: 'self-hosted', label: 'Self-hosted/on-premise/single-tenant' },
-      ],
-    }),
-  );
+  if (!urlFromArgs) {
+    const choice: 'saas' | 'self-hosted' | symbol = await abortIfCancelled(
+      clack.select({
+        message: 'Are you using Sentry SaaS or self-hosted Sentry?',
+        options: [
+          { value: 'saas', label: 'Sentry SaaS (sentry.io)' },
+          {
+            value: 'self-hosted',
+            label: 'Self-hosted/on-premise/single-tenant',
+          },
+        ],
+      }),
+    );
 
-  if (choice === 'saas') {
-    Sentry.setTag('url', SAAS_URL);
-    Sentry.setTag('self-hosted', false);
-    return { url: SAAS_URL, selfHosted: false };
+    if (choice === 'saas') {
+      Sentry.setTag('url', SAAS_URL);
+      Sentry.setTag('self-hosted', false);
+      return { url: SAAS_URL, selfHosted: false };
+    }
   }
 
   let validUrl: string | undefined;
+  let tmpUrlFromArgs = urlFromArgs;
+
   while (validUrl === undefined) {
-    const url = await abortIfCancelled(
-      clack.text({
-        message: 'Please enter the URL of your self-hosted Sentry instance.',
-        placeholder: 'https://sentry.io/',
-      }),
-    );
+    const url =
+      tmpUrlFromArgs ||
+      (await abortIfCancelled(
+        clack.text({
+          message: `Please enter the URL of your ${
+            urlFromArgs ? '' : 'self-hosted '
+          }Sentry instance.`,
+          placeholder: 'https://sentry.io/',
+        }),
+      ));
+    tmpUrlFromArgs = undefined;
 
     try {
       validUrl = new URL(url).toString();
@@ -344,13 +376,16 @@ export async function askForSelfHosted(): Promise<{
       }
     } catch {
       clack.log.error(
-        'Please enter a valid URL. (It should look something like "http://sentry.mydomain.com/")',
+        'Please enter a valid URL. (It should look something like "https://sentry.mydomain.com/")',
       );
     }
   }
 
+  const isSelfHostedUrl = new URL(validUrl).host !== new URL(SAAS_URL).host;
+
   Sentry.setTag('url', validUrl);
-  Sentry.setTag('self-hosted', true);
+  Sentry.setTag('self-hosted', isSelfHostedUrl);
+
   return { url: validUrl, selfHosted: true };
 }
 
@@ -553,9 +588,16 @@ export function hasPackageInstalled(
   packageName: string,
   packageJson: PackageDotJson,
 ): boolean {
+  return getPackageVersion(packageName, packageJson) !== undefined;
+}
+
+export function getPackageVersion(
+  packageName: string,
+  packageJson: PackageDotJson,
+): string | undefined {
   return (
-    !!packageJson?.dependencies?.[packageName] ||
-    !!packageJson?.devDependencies?.[packageName]
+    packageJson?.dependencies?.[packageName] ||
+    packageJson?.devDependencies?.[packageName]
   );
 }
 

package/src/utils/types.ts

@@ -0,0 +1,13 @@
+export type WizardOptions = {
+  /**
+   * The promo code to use while signing up for Sentry.
+   * This can be passed via the --promo-code arg.
+   */
+  promoCode?: string;
+
+  /**
+   * The url of the Sentry instance to use.
+   * This can be passed via the `-u` or `--url` arg.
+   */
+  url?: string;
+};

package/dist/lib/Steps/Integrations/NextJs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NextJs.js","sourceRoot":"","sources":["../../../../lib/Steps/Integrations/NextJs.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,mEAAoE;AAGpE,qDAAoD;AAEpD;;;GAGG;AACH;IAA4B,0BAAe;IACzC,gBAA6B,KAAW;QAAxC,YACE,kBAAM,KAAK,CAAC,SACb;QAF4B,WAAK,GAAL,KAAK,CAAM;;IAExC,CAAC;IAEY,qBAAI,GAAjB,UAAkB,QAAiB;;;;4BACjC,qBAAM,IAAA,+BAAe,EAAC,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,EAAA;;wBAA1D,SAA0D,CAAC;wBAC3D,sBAAO,EAAE,EAAC;;;;KACX;IAEY,gCAAe,GAA5B,UAA6B,QAAiB;;;gBAC5C,kEAAkE;gBAClE,IAAI,IAAI,CAAC,gBAAgB,EAAE;oBACzB,sBAAO,IAAI,CAAC,gBAAgB,EAAC;iBAC9B;gBACD,6DAA6D;gBAC7D,sBAAO,IAAI,CAAC,eAAe,EAAC;;;KAC7B;IACH,aAAC;AAAD,CAAC,AAlBD,CAA4B,iCAAe,GAkB1C;AAlBY,wBAAM","sourcesContent":["import type { Answers } from 'inquirer';\nimport { runNextjsWizard } from '../../../src/nextjs/nextjs-wizard';\n\nimport type { Args } from '../../Constants';\nimport { BaseIntegration } from './BaseIntegration';\n\n/**\n * This class just redirects to the new `nextjs-wizard.ts` flow\n * for anyone calling the wizard without the '-i nextjs' flag.\n */\nexport class NextJs extends BaseIntegration {\n  public constructor(protected _argv: Args) {\n    super(_argv);\n  }\n\n  public async emit(_answers: Answers): Promise<Answers> {\n    await runNextjsWizard({ promoCode: this._argv.promoCode });\n    return {};\n  }\n\n  public async shouldConfigure(_answers: Answers): Promise<Answers> {\n    // eslint-disable-next-line @typescript-eslint/no-misused-promises\n    if (this._shouldConfigure) {\n      return this._shouldConfigure;\n    }\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    return this.shouldConfigure;\n  }\n}\n"]}

package/dist/lib/Steps/Integrations/SvelteKit.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SvelteKit.js","sourceRoot":"","sources":["../../../../lib/Steps/Integrations/SvelteKit.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,4EAA6E;AAG7E,qDAAoD;AAEpD;;;GAGG;AACH;IAA+B,6BAAe;IAC5C,mBAA6B,KAAW;QAAxC,YACE,kBAAM,KAAK,CAAC,SACb;QAF4B,WAAK,GAAL,KAAK,CAAM;;IAExC,CAAC;IAEY,wBAAI,GAAjB,UAAkB,QAAiB;;;;4BACjC,qBAAM,IAAA,qCAAkB,EAAC,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,EAAA;;wBAA7D,SAA6D,CAAC;wBAC9D,sBAAO,EAAE,EAAC;;;;KACX;IAEY,mCAAe,GAA5B,UAA6B,QAAiB;;;gBAC5C,kEAAkE;gBAClE,IAAI,IAAI,CAAC,gBAAgB,EAAE;oBACzB,sBAAO,IAAI,CAAC,gBAAgB,EAAC;iBAC9B;gBACD,6DAA6D;gBAC7D,sBAAO,IAAI,CAAC,eAAe,EAAC;;;KAC7B;IACH,gBAAC;AAAD,CAAC,AAlBD,CAA+B,iCAAe,GAkB7C;AAlBY,8BAAS","sourcesContent":["import type { Answers } from 'inquirer';\nimport { runSvelteKitWizard } from '../../../src/sveltekit/sveltekit-wizard';\n\nimport type { Args } from '../../Constants';\nimport { BaseIntegration } from './BaseIntegration';\n\n/**\n * This class just redirects to the new `sveltekit-wizard.ts` flow\n * for anyone calling the wizard without the '-i sveltekit' flag.\n */\nexport class SvelteKit extends BaseIntegration {\n  public constructor(protected _argv: Args) {\n    super(_argv);\n  }\n\n  public async emit(_answers: Answers): Promise<Answers> {\n    await runSvelteKitWizard({ promoCode: this._argv.promoCode });\n    return {};\n  }\n\n  public async shouldConfigure(_answers: Answers): Promise<Answers> {\n    // eslint-disable-next-line @typescript-eslint/no-misused-promises\n    if (this._shouldConfigure) {\n      return this._shouldConfigure;\n    }\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    return this.shouldConfigure;\n  }\n}\n"]}