@sentry/wizard 3.9.2 → 3.11.0

package/src/apple/xcode-manager.ts

@@ -2,17 +2,30 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unused-vars */
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import clack from '@clack/prompts';
 import * as fs from 'fs';
 import { SentryProjectData } from '../utils/types';
 import * as templates from './templates';
+import * as path from 'path';
 const xcode = require('xcode');
 
-/* eslint-enable @typescript-eslint/no-unused-vars */
+interface ProjetFile {
+  key: string;
+  path: string;
+}
 
-function setDebugInformationFormat(proj: any): void {
+function setDebugInformationFormat(proj: any, targetName: string): void {
   const xcObjects = proj.hash.project.objects;
-  const target = proj.getFirstTarget().firstTarget;
+  const targetKey: string = Object.keys(xcObjects.PBXNativeTarget || {}).filter(
+    (key) => {
+      return (
+        !key.endsWith('_comment') &&
+        xcObjects.PBXNativeTarget[key].name === targetName
+      );
+    },
+  )[0];
+  const target = xcObjects.PBXNativeTarget[targetKey];
 
   xcObjects.XCConfigurationList[
     target.buildConfigurationList
@@ -23,7 +36,7 @@ function setDebugInformationFormat(proj: any): void {
   });
 }
 
-function addSentrySPM(proj: any): void {
+function addSentrySPM(proj: any, targetName: string): void {
   const xcObjects = proj.hash.project.objects;
 
   const sentryFrameworkUUID = proj.generateUuid() as string;
@@ -61,7 +74,16 @@ function addSentrySPM(proj: any): void {
     }
   }
 
-  const target = proj.getFirstTarget().firstTarget;
+  const targetKey: string = Object.keys(xcObjects.PBXNativeTarget || {}).filter(
+    (key) => {
+      return (
+        !key.endsWith('_comment') &&
+        xcObjects.PBXNativeTarget[key].name === targetName
+      );
+    },
+  )[0];
+  const target = xcObjects.PBXNativeTarget[targetKey];
+
   if (!target.packageProductDependencies) {
     target.packageProductDependencies = [];
   }
@@ -106,15 +128,25 @@ function addSentrySPM(proj: any): void {
   };
   xcObjects.XCSwiftPackageProductDependency[sentrySPMUUID + '_comment'] =
     'Sentry';
+
+  clack.log.step('Added Sentry SPM dependency to your project');
 }
 
 function addUploadSymbolsScript(
   xcodeProject: any,
   sentryProject: SentryProjectData,
-  apiKeys: { token: string },
+  targetName: string,
   uploadSource = true,
 ): void {
   const xcObjects = xcodeProject.hash.project.objects;
+  const targetKey: string = Object.keys(xcObjects.PBXNativeTarget || {}).filter(
+    (key) => {
+      return (
+        !key.endsWith('_comment') &&
+        xcObjects.PBXNativeTarget[key].name === targetName
+      );
+    },
+  )[0];
 
   for (const scriptKey in xcObjects.PBXShellScriptBuildPhase || {}) {
     if (!scriptKey.endsWith('_comment')) {
@@ -132,7 +164,7 @@ function addUploadSymbolsScript(
     [],
     'PBXShellScriptBuildPhase',
     'Upload Debug Symbols to Sentry',
-    null,
+    targetKey,
     {
       inputFileListPaths: [],
       outputFileListPaths: [],
@@ -141,29 +173,139 @@ function addUploadSymbolsScript(
       shellScript: templates.getRunScriptTemplate(
         sentryProject.organization.slug,
         sentryProject.slug,
-        apiKeys.token,
         uploadSource,
       ),
     },
   );
+  clack.log.step(`Added Sentry upload script to "${targetName}" build phase`);
 }
 
-export function updateXcodeProject(
-  projectPath: string,
-  sentryProject: SentryProjectData,
-  apiKeys: { token: string },
-  addSPMReference: boolean,
-  uploadSource = true,
-): void {
-  const proj = xcode.project(projectPath);
-  proj.parseSync();
-  addUploadSymbolsScript(proj, sentryProject, apiKeys, uploadSource);
-  if (uploadSource) {
-    setDebugInformationFormat(proj);
+export class XcodeProject {
+  projectPath: string;
+  project: any;
+  objects: any;
+  files: ProjetFile[] | undefined;
+
+  public constructor(projectPath: string) {
+    this.projectPath = projectPath;
+    this.project = xcode.project(projectPath);
+    this.project.parseSync();
+    this.objects = this.project.hash.project.objects;
+  }
+
+  public getAllTargets(): string[] {
+    return Object.keys(this.objects.PBXNativeTarget || {})
+      .filter((key) => {
+        return (
+          !key.endsWith('_comment') &&
+          this.objects.PBXNativeTarget[key].productType.startsWith(
+            '"com.apple.product-type.application',
+          )
+        );
+      })
+      .map((key) => {
+        return this.objects.PBXNativeTarget[key].name as string;
+      });
+  }
+
+  public updateXcodeProject(
+    sentryProject: SentryProjectData,
+    target: string,
+    apiKeys: { token: string },
+    addSPMReference: boolean,
+    uploadSource = true,
+  ): void {
+    addUploadSymbolsScript(this.project, sentryProject, target, uploadSource);
+    if (uploadSource) {
+      setDebugInformationFormat(this.project, target);
+    }
+    if (addSPMReference) {
+      addSentrySPM(this.project, target);
+    }
+    const newContent = this.project.writeSync();
+    fs.writeFileSync(this.projectPath, newContent);
+  }
+
+  public filesForTarget(target: string): string[] | undefined {
+    const files = this.projectFiles();
+    const fileDictionary: any = {};
+    files.forEach((file) => {
+      fileDictionary[file.key] = file.path;
+    });
+
+    const nativeTarget = Object.keys(this.objects.PBXNativeTarget || {}).filter(
+      (key) => {
+        return (
+          !key.endsWith('_comment') &&
+          this.objects.PBXNativeTarget[key].name === target
+        );
+      },
+    )[0];
+
+    if (nativeTarget === undefined) {
+      return undefined;
+    }
+
+    const buildPhaseKey = this.objects.PBXNativeTarget[
+      nativeTarget
+    ].buildPhases.filter((phase: any) => {
+      return this.objects.PBXSourcesBuildPhase[phase.value] !== undefined;
+    })[0];
+
+    if (buildPhaseKey === undefined) {
+      return undefined;
+    }
+
+    const buildPhases = this.objects.PBXSourcesBuildPhase[buildPhaseKey.value];
+    if (buildPhases === undefined) {
+      return undefined;
+    }
+
+    const baseDir = path.dirname(path.dirname(this.projectPath));
+
+    return buildPhases.files
+      .map((file: any) => {
+        const buildFile = fileDictionary[
+          this.objects.PBXBuildFile[file.value].fileRef
+        ] as string;
+        if (!buildFile) {
+          return '';
+        }
+        return path.join(baseDir, buildFile);
+      })
+      .filter((f: string) => f.length > 0) as string[];
   }
-  if (addSPMReference) {
-    addSentrySPM(proj);
+
+  projectFiles(): ProjetFile[] {
+    if (this.files === undefined) {
+      const proj = this.project.getFirstProject();
+      const mainGroupKey = proj.firstProject.mainGroup;
+      const mainGroup = this.objects.PBXGroup[mainGroupKey];
+      this.files = this.buildGroup(mainGroup);
+    }
+    return this.files;
+  }
+
+  buildGroup(group: any, path = ''): ProjetFile[] {
+    const result: ProjetFile[] = [];
+    for (const child of group.children) {
+      if (this.objects.PBXFileReference[child.value]) {
+        const fileReference = this.objects.PBXFileReference[child.value];
+        result.push({
+          key: child.value,
+          path: `${path}${fileReference.path.replace(/"/g, '')}`,
+        });
+      } else if (this.objects.PBXGroup[child.value]) {
+        const groupReference = this.objects.PBXGroup[child.value];
+        const groupChildren = this.buildGroup(
+          groupReference,
+          groupReference.path
+            ? `${path}${groupReference.path.replace(/"/g, '')}/`
+            : path,
+        );
+        result.push(...groupChildren);
+      }
+    }
+    return result;
   }
-  const newContent = proj.writeSync();
-  fs.writeFileSync(projectPath, newContent);
 }

package/src/nextjs/nextjs-wizard.ts

@@ -10,7 +10,7 @@ import * as path from 'path';
 import {
   abort,
   abortIfCancelled,
-  addSentryCliRc,
+  addSentryCliConfig,
   confirmContinueEvenThoughNoGitRepo,
   ensurePackageIsInstalled,
   getOrAskForProjectData,
@@ -28,6 +28,7 @@ import {
   getNextjsWebpackPluginOptionsTemplate,
   getSentryConfigContents,
   getSentryExampleApiRoute,
+  getSentryExampleAppDirApiRoute,
   getSentryExamplePageContents,
 } from './templates';
 
@@ -44,7 +45,7 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
   await ensurePackageIsInstalled(packageJson, 'next', 'Next.js');
 
   const { selectedProject, authToken, selfHosted, sentryUrl } =
-    await getOrAskForProjectData(options);
+    await getOrAskForProjectData(options, 'javascript-nextjs');
 
   await installPackage({
     packageName: '@sentry/nextjs',
@@ -279,8 +280,11 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
     }
   }
 
+  const srcDir = path.join(process.cwd(), 'src');
   const maybePagesDirPath = path.join(process.cwd(), 'pages');
-  const maybeSrcPagesDirPath = path.join(process.cwd(), 'src', 'pages');
+  const maybeSrcPagesDirPath = path.join(srcDir, 'pages');
+  const maybeAppDirPath = path.join(process.cwd(), 'app');
+  const maybeSrcAppDirPath = path.join(srcDir, 'app');
 
   let pagesLocation =
     fs.existsSync(maybePagesDirPath) &&
@@ -291,23 +295,83 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
       ? ['src', 'pages']
       : undefined;
 
-  if (!pagesLocation) {
-    pagesLocation = ['pages'];
+  const appLocation =
+    fs.existsSync(maybeAppDirPath) &&
+    fs.lstatSync(maybeAppDirPath).isDirectory()
+      ? ['app']
+      : fs.existsSync(maybeSrcAppDirPath) &&
+        fs.lstatSync(maybeSrcAppDirPath).isDirectory()
+      ? ['src', 'app']
+      : undefined;
+
+  if (!pagesLocation && !appLocation) {
+    pagesLocation =
+      fs.existsSync(srcDir) && fs.lstatSync(srcDir).isDirectory()
+        ? ['src', 'pages']
+        : ['pages'];
     fs.mkdirSync(path.join(process.cwd(), ...pagesLocation), {
       recursive: true,
     });
   }
 
-  if (pagesLocation) {
+  if (appLocation) {
+    const examplePageContents = getSentryExamplePageContents({
+      selfHosted,
+      orgSlug: selectedProject.organization.slug,
+      projectId: selectedProject.id,
+      url: sentryUrl,
+      useClient: true,
+    });
+
+    await fs.promises.writeFile(
+      path.join(
+        process.cwd(),
+        ...appLocation,
+        'sentry-example-page',
+        'page.jsx',
+      ),
+      examplePageContents,
+      { encoding: 'utf8', flag: 'w' },
+    );
+
+    clack.log.success(
+      `Created ${chalk.bold(
+        path.join(...appLocation, 'sentry-example-page', 'page.jsx'),
+      )}.`,
+    );
+
+    fs.mkdirSync(path.join(process.cwd(), ...appLocation, 'api'), {
+      recursive: true,
+    });
+
+    await fs.promises.writeFile(
+      path.join(
+        process.cwd(),
+        ...appLocation,
+        'api',
+        'sentry-example-api',
+        'route.js',
+      ),
+      getSentryExampleAppDirApiRoute(),
+      { encoding: 'utf8', flag: 'w' },
+    );
+
+    clack.log.success(
+      `Created ${chalk.bold(
+        path.join(...appLocation, 'api', 'sentry-example-api', 'route.js'),
+      )}.`,
+    );
+  } else if (pagesLocation) {
     const examplePageContents = getSentryExamplePageContents({
       selfHosted,
       orgSlug: selectedProject.organization.slug,
       projectId: selectedProject.id,
       url: sentryUrl,
+      useClient: false,
     });
 
     await fs.promises.writeFile(
-      path.join(process.cwd(), ...pagesLocation, 'sentry-example-page.js'),
+      path.join(process.cwd(), ...pagesLocation, 'sentry-example-page.jsx'),
       examplePageContents,
       { encoding: 'utf8', flag: 'w' },
     );
@@ -340,7 +404,7 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
     );
   }
 
-  await addSentryCliRc(authToken);
+  await addSentryCliConfig(authToken);
 
   const mightBeUsingVercel = fs.existsSync(
     path.join(process.cwd(), 'vercel.json'),

package/src/nextjs/templates.ts

@@ -150,15 +150,18 @@ export function getSentryExamplePageContents(options: {
   url: string;
   orgSlug: string;
   projectId: string;
+  useClient: boolean;
 }): string {
   const issuesPageLink = options.selfHosted
     ? `${options.url}organizations/${options.orgSlug}/issues/?project=${options.projectId}`
     : `https://${options.orgSlug}.sentry.io/issues/?project=${options.projectId}`;
 
-  return `import Head from "next/head";
+  return `${
+    options.useClient ? '"use client";\n\n' : ''
+  }import Head from "next/head";
 import * as Sentry from "@sentry/nextjs";
 
-export default function Home() {
+export default function Page() {
   return (
     <div>
       <Head>
@@ -250,3 +253,14 @@ export default function handler(_req, res) {
 }
 `;
 }
+
+export function getSentryExampleAppDirApiRoute() {
+  return `import { NextResponse } from "next/server";
+
+// A faulty API route to test Sentry's error monitoring
+export function GET() {
+  throw new Error("Sentry Example API Route Error");
+  return NextResponse.json({ data: "Testing Sentry Error..." });
+}
+`;
+}

package/src/remix/codemods/handle-error.ts

@@ -0,0 +1,67 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+// @ts-expect-error - magicast is ESM and TS complains about that. It works though
+import type { ProxifiedModule } from 'magicast';
+import type { Program } from '@babel/types';
+
+import * as recast from 'recast';
+
+import { HANDLE_ERROR_TEMPLATE_V2 } from '../templates';
+import { getInitCallInsertionIndex, hasSentryContent } from '../utils';
+
+// @ts-expect-error - clack is ESM and TS complains about that. It works though
+import clack from '@clack/prompts';
+import chalk from 'chalk';
+
+// @ts-expect-error - magicast is ESM and TS complains about that. It works though
+import { generateCode } from 'magicast';
+
+export function instrumentHandleError(
+  originalEntryServerMod: ProxifiedModule<any>,
+  serverEntryFilename: string,
+): boolean {
+  const originalEntryServerModAST = originalEntryServerMod.$ast as Program;
+
+  const handleErrorFunction = originalEntryServerModAST.body.find(
+    (node) =>
+      node.type === 'ExportNamedDeclaration' &&
+      node.declaration?.type === 'FunctionDeclaration' &&
+      node.declaration.id?.name === 'handleError',
+  );
+
+  if (!handleErrorFunction) {
+    clack.log.warn(
+      `Could not find function ${chalk.cyan('handleError')} in ${chalk.cyan(
+        serverEntryFilename,
+      )}. Creating one for you.`,
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const implementation = recast.parse(HANDLE_ERROR_TEMPLATE_V2).program
+      .body[0];
+
+    originalEntryServerModAST.body.splice(
+      getInitCallInsertionIndex(originalEntryServerModAST),
+      0,
+      // @ts-expect-error - string works here because the AST is proxified by magicast
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      recast.types.builders.exportNamedDeclaration(implementation),
+    );
+  } else if (
+    hasSentryContent(
+      generateCode(handleErrorFunction).code,
+      originalEntryServerMod.$code,
+    )
+  ) {
+    return false;
+  } else {
+    // @ts-expect-error - string works here because the AST is proxified by magicast
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+    handleErrorFunction.declaration.body.body.unshift(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      recast.parse(HANDLE_ERROR_TEMPLATE_V2).program.body[0].body.body[0],
+    );
+  }
+
+  return true;
+}

package/src/remix/codemods/root-v1.ts

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+import * as recast from 'recast';
+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 chalk from 'chalk';
+
+// @ts-expect-error - magicast is ESM and TS complains about that. It works though
+import { builders, generateCode, loadFile, writeFile } from 'magicast';
+
+export async function instrumentRootRouteV1(
+  rootFileName: string,
+): Promise<void> {
+  try {
+    const rootRouteAst = await loadFile(
+      path.join(process.cwd(), 'app', rootFileName),
+    );
+
+    rootRouteAst.imports.$add({
+      from: '@sentry/remix',
+      imported: 'withSentry',
+      local: 'withSentry',
+    });
+
+    recast.visit(rootRouteAst.$ast, {
+      visitExportDefaultDeclaration(path) {
+        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+        if (path.value.declaration.type === 'FunctionDeclaration') {
+          // Move the function declaration just before the default export
+          path.insertBefore(path.value.declaration);
+
+          // Get the name of the function to be wrapped
+          const functionName: string = path.value.declaration.id.name as string;
+
+          // Create the wrapped function call
+          const functionCall = recast.types.builders.callExpression(
+            recast.types.builders.identifier('withSentry'),
+            [recast.types.builders.identifier(functionName)],
+          );
+
+          // Replace the default export with the wrapped function call
+          path.value.declaration = functionCall;
+        } else if (path.value.declaration.type === 'Identifier') {
+          const rootRouteExport = rootRouteAst.exports.default;
+
+          const expressionToWrap = generateCode(
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            rootRouteExport.$ast,
+          ).code;
+
+          rootRouteAst.exports.default = builders.raw(
+            `withSentry(${expressionToWrap})`,
+          );
+        } else {
+          clack.log.warn(
+            chalk.yellow(
+              `Couldn't instrument ${chalk.bold(
+                rootFileName,
+              )} automatically. Wrap your default export with: ${chalk.dim(
+                'withSentry()',
+              )}\n`,
+            ),
+          );
+        }
+
+        this.traverse(path);
+        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+      },
+    });
+
+    await writeFile(
+      rootRouteAst.$ast,
+      path.join(process.cwd(), 'app', rootFileName),
+    );
+  } catch (e: unknown) {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    clack.log.warn(
+      chalk.yellow(
+        `Something went wrong writing to ${chalk.bold(rootFileName)}`,
+      ),
+    );
+    clack.log.info(
+      `Please put the following code snippet into ${chalk.bold(
+        rootFileName,
+      )}: ${chalk.dim('You probably have to clean it up a bit.')}\n`,
+    );
+  }
+}

package/src/remix/codemods/root-v2.ts

@@ -0,0 +1,84 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+import * as recast from 'recast';
+import * as path from 'path';
+
+import type { ExportNamedDeclaration, Program } from '@babel/types';
+
+// @ts-expect-error - magicast is ESM and TS complains about that. It works though
+import { loadFile, writeFile } from 'magicast';
+
+import { ERROR_BOUNDARY_TEMPLATE_V2 } from '../templates';
+
+export async function instrumentRootRouteV2(
+  rootFileName: string,
+): Promise<void> {
+  const rootRouteAst = await loadFile(
+    path.join(process.cwd(), 'app', rootFileName),
+  );
+
+  const exportsAst = rootRouteAst.exports.$ast as Program;
+
+  const namedExports = exportsAst.body.filter(
+    (node) => node.type === 'ExportNamedDeclaration',
+  ) as ExportNamedDeclaration[];
+
+  let foundErrorBoundary = false;
+
+  namedExports.forEach((namedExport) => {
+    const declaration = namedExport.declaration;
+
+    if (!declaration) {
+      return;
+    }
+
+    if (declaration.type === 'FunctionDeclaration') {
+      if (declaration.id?.name === 'ErrorBoundary') {
+        foundErrorBoundary = true;
+      }
+    } else if (declaration.type === 'VariableDeclaration') {
+      const declarations = declaration.declarations;
+
+      declarations.forEach((declaration) => {
+        // @ts-expect-error - id should always have a name in this case
+        if (declaration.id?.name === 'ErrorBoundary') {
+          foundErrorBoundary = true;
+        }
+      });
+    }
+  });
+
+  if (!foundErrorBoundary) {
+    rootRouteAst.imports.$add({
+      from: '@sentry/remix',
+      imported: 'captureRemixErrorBoundaryError',
+      local: 'captureRemixErrorBoundaryError',
+    });
+
+    rootRouteAst.imports.$add({
+      from: '@remix-run/react',
+      imported: 'useRouteError',
+      local: 'useRouteError',
+    });
+
+    recast.visit(rootRouteAst.$ast, {
+      visitExportDefaultDeclaration(path) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        const implementation = recast.parse(ERROR_BOUNDARY_TEMPLATE_V2).program
+          .body[0];
+
+        path.insertBefore(
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          recast.types.builders.exportDeclaration(false, implementation),
+        );
+
+        this.traverse(path);
+      },
+    });
+  }
+
+  await writeFile(
+    rootRouteAst.$ast,
+    path.join(process.cwd(), 'app', rootFileName),
+  );
+}