@sentry/wizard 3.10.0 → 3.12.0

package/src/utils/package-manager.ts

@@ -0,0 +1,61 @@
+/* eslint-disable @typescript-eslint/typedef */
+import { exec } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { promisify } from 'util';
+
+export interface PackageManager {
+  name: string;
+  label: string;
+  lockFile: string;
+  installCommand: string;
+  buildCommand: string;
+}
+
+const bun: PackageManager = {
+  name: 'bun',
+  label: 'Bun',
+  lockFile: 'bun.lockb',
+  installCommand: 'bun add',
+  buildCommand: 'bun build',
+};
+const yarn: PackageManager = {
+  name: 'yarn',
+  label: 'Yarn',
+  lockFile: 'yarn.lock',
+  installCommand: 'yarn add',
+  buildCommand: 'yarn build',
+};
+const pnpm: PackageManager = {
+  name: 'pnpm',
+  label: 'PNPM',
+  lockFile: 'pnpm-lock.yaml',
+  installCommand: 'pnpm add',
+  buildCommand: 'pnpm build',
+};
+const npm: PackageManager = {
+  name: 'npm',
+  label: 'NPM',
+  lockFile: 'package-lock.json',
+  installCommand: 'npm add',
+  buildCommand: 'npm run build',
+};
+
+export const packageManagers = [bun, yarn, pnpm, npm];
+
+export function detectPackageManger(): PackageManager | null {
+  for (const packageManager of packageManagers) {
+    if (fs.existsSync(path.join(process.cwd(), packageManager.lockFile))) {
+      return packageManager;
+    }
+  }
+  // We make the default NPM - it's weird if we don't find any lock file
+  return null;
+}
+
+export async function installPackageWithPackageManager(
+  packageManager: PackageManager,
+  packageName: string,
+): Promise<void> {
+  await promisify(exec)(`${packageManager.installCommand} ${packageName}`);
+}

package/src/utils/release-registry.ts

@@ -0,0 +1,19 @@
+import axios from 'axios';
+import { debug } from './debug';
+const registryUrl = 'https://release-registry.services.sentry.io/';
+
+export async function fetchSdkVersion(
+  sdk: string,
+): Promise<string | undefined> {
+  try {
+    const data = (
+      await axios.get<Record<string, { version: string }>>(
+        `${registryUrl}/sdks`,
+      )
+    ).data;
+    return data[sdk]?.version;
+  } catch {
+    debug('Failed to fetch latest version from release registry.');
+  }
+  return undefined;
+}

package/src/utils/sentrycli-utils.ts

@@ -0,0 +1,22 @@
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface SentryCLIConfiguration {
+  auth_token: string;
+}
+
+export function createSentryCLIRC(
+  directory: string,
+  params: SentryCLIConfiguration,
+) {
+  const rcPath = path.join(directory, '.sentryclirc');
+  fs.writeFileSync(rcPath, '[auth]\ntoken=' + params.auth_token);
+
+  if (fs.existsSync('.gitignore')) {
+    const gitIgnore = fs.readFileSync('.gitignore').toString();
+    if (!gitIgnore.includes('.sentryclirc')) {
+      fs.appendFileSync('.gitignore', '\n.sentryclirc');
+    }
+  }
+}

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/vite.test.ts

@@ -0,0 +1,149 @@
+import * as fs from 'fs';
+import { addVitePluginToConfig } from '../../../src/sourcemaps/tools/vite';
+
+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('addVitePluginToConfig', () => {
+  afterEach(() => {
+    fileContent = '';
+    jest.clearAllMocks();
+  });
+
+  it.each([
+    [
+      'no build options',
+      `
+export default defineConfig({
+  plugins: [
+    vue(),
+  ],
+})
+`,
+      `import { sentryVitePlugin } from "@sentry/vite-plugin";
+export default defineConfig({
+  plugins: [vue(), sentryVitePlugin({
+    org: "my-org",
+    project: "my-project"
+  })],
+
+  build: {
+    sourcemap: true
+  }
+})`,
+    ],
+    [
+      'no build.sourcemap options',
+      `
+export default defineConfig({
+  plugins: [
+    vue(),
+  ],
+  build: {
+    test: 1,  
+  }
+})
+  `,
+      `import { sentryVitePlugin } from "@sentry/vite-plugin";
+export default defineConfig({
+  plugins: [vue(), sentryVitePlugin({
+    org: "my-org",
+    project: "my-project"
+  })],
+  build: {
+    test: 1,
+    sourcemap: true
+  }
+})`,
+    ],
+    [
+      'keep sourcemap: "hidden"',
+      `
+export default {
+  plugins: [
+    vue(),
+  ],
+  build: {
+    sourcemap: "hidden",
+  }
+}
+    `,
+      `import { sentryVitePlugin } from "@sentry/vite-plugin";
+export default {
+  plugins: [vue(), sentryVitePlugin({
+    org: "my-org",
+    project: "my-project"
+  })],
+  build: {
+    sourcemap: "hidden",
+  }
+}`,
+    ],
+    [
+      'rewrite sourcemap: false to true',
+      `
+const cfg = {
+  plugins: [
+    vue(),
+  ],
+  build: {
+    sourcemap: false,
+  }
+}
+
+export default cfg;
+      `,
+      `import { sentryVitePlugin } from "@sentry/vite-plugin";
+const cfg = {
+  plugins: [vue(), sentryVitePlugin({
+    org: "my-org",
+    project: "my-project"
+  })],
+
+  build: {
+    sourcemap: true,
+  }
+}
+
+export default cfg;`,
+    ],
+  ])(
+    'adds the plugin and enables source maps generation (%s)',
+    async (_, originalCode, expectedCode) => {
+      updateFileContent(originalCode);
+
+      const addedCode = await addVitePluginToConfig('', {
+        authToken: '',
+        orgSlug: 'my-org',
+        projectSlug: 'my-project',
+        selfHosted: false,
+        url: 'https://sentry.io/',
+      });
+
+      expect(writeFileSpy).toHaveBeenCalledTimes(1);
+      const [[, fileContent]] = writeFileSpy.mock.calls;
+      expect(fileContent).toBe(expectedCode);
+      expect(addedCode).toBe(true);
+    },
+  );
+});

package/test/sourcemaps/tools/webpack.test.ts

@@ -0,0 +1,303 @@
+import * as fs from 'fs';
+
+import { modifyWebpackConfig } from '../../../src/sourcemaps/tools/webpack';
+
+function updateFileContent(content: string): void {
+  fileContent = content;
+}
+
+let fileContent = '';
+
+jest.mock('@clack/prompts', () => {
+  return {
+    log: {
+      info: jest.fn(),
+      success: jest.fn(),
+    },
+    select: jest.fn().mockImplementation(() => Promise.resolve(true)),
+    isCancel: jest.fn().mockReturnValue(false),
+  };
+});
+
+jest
+  .spyOn(fs.promises, 'readFile')
+  .mockImplementation(() => Promise.resolve(fileContent));
+
+const writeFileSpy = jest
+  .spyOn(fs.promises, 'writeFile')
+  .mockImplementation(() => Promise.resolve(void 0));
+
+const noSourcemapNoPluginsPojo = `module.exports = {
+  entry: "./src/index.js",
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+};`;
+
+const noSourcemapNoPluginsPojoResult = `const {
+  sentryWebpackPlugin
+} = require("@sentry/webpack-plugin");
+
+module.exports = {
+  entry: "./src/index.js",
+
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+
+  devtool: "source-map",
+
+  plugins: [sentryWebpackPlugin({
+    authToken: process.env.SENTRY_AUTH_TOKEN,
+    org: "my-org",
+    project: "my-project"
+  })]
+};`;
+
+const noSourcemapsNoPluginsId = `const config = {
+  entry: "./src/index.js",
+
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+};
+
+module.exports = config;`;
+
+const noSourcemapsNoPluginsIdResult = `const {
+  sentryWebpackPlugin
+} = require("@sentry/webpack-plugin");
+
+const config = {
+  entry: "./src/index.js",
+
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+
+  devtool: "source-map",
+
+  plugins: [sentryWebpackPlugin({
+    authToken: process.env.SENTRY_AUTH_TOKEN,
+    org: "my-org",
+    project: "my-project"
+  })]
+};
+
+module.exports = config;`;
+
+const hiddenSourcemapNoPluginsId = `const config = {
+  entry: "./src/index.js",
+
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+
+  devtool: "hidden-cheap-source-map",
+};
+
+module.exports = config;
+    `;
+const hiddenSourcemapNoPluginsIdResult = `const {
+  sentryWebpackPlugin
+} = require("@sentry/webpack-plugin");
+
+const config = {
+  entry: "./src/index.js",
+
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+
+  devtool: "hidden-source-map",
+
+  plugins: [sentryWebpackPlugin({
+    authToken: process.env.SENTRY_AUTH_TOKEN,
+    org: "my-org",
+    project: "my-project"
+  })]
+};
+
+module.exports = config;`;
+
+const arbitrarySourcemapNoPluginsId = `
+const config = {
+  entry: "./src/index.js",
+
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+
+  devtool: getSourcemapSetting(),
+};
+
+module.exports = config;
+    `;
+const arbitrarySourcemapNoPluginsIdResult = `const {
+  sentryWebpackPlugin
+} = require("@sentry/webpack-plugin");
+
+const config = {
+  entry: "./src/index.js",
+
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+
+  devtool: "source-map",
+
+  plugins: [sentryWebpackPlugin({
+    authToken: process.env.SENTRY_AUTH_TOKEN,
+    org: "my-org",
+    project: "my-project"
+  })]
+};
+
+module.exports = config;`;
+
+const noSourcemapUndefinedPluginsPojo = `module.exports = {
+  entry: "./src/index.js",
+  plugins: undefined,
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+};`;
+
+const noSourcemapUndefinedPluginsPojoResult = `const {
+  sentryWebpackPlugin
+} = require("@sentry/webpack-plugin");
+
+module.exports = {
+  entry: "./src/index.js",
+
+  plugins: [sentryWebpackPlugin({
+    authToken: process.env.SENTRY_AUTH_TOKEN,
+    org: "my-org",
+    project: "my-project"
+  })],
+
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+
+  devtool: "source-map"
+};`;
+
+const noSourcemapPluginsPojo = `module.exports = {
+  entry: "./src/index.js",
+  plugins: [
+    new HtmlWebpackPlugin(),
+    new MiniCssExtractPlugin(),
+  ],
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+};`;
+
+const noSourcemapPluginsPojoResult = `const {
+  sentryWebpackPlugin
+} = require("@sentry/webpack-plugin");
+
+module.exports = {
+  entry: "./src/index.js",
+
+  plugins: [new HtmlWebpackPlugin(), new MiniCssExtractPlugin(), sentryWebpackPlugin({
+    authToken: process.env.SENTRY_AUTH_TOKEN,
+    org: "my-org",
+    project: "my-project"
+  })],
+
+  output: {
+    filename: "main.js",
+    path: path.resolve(__dirname, "build"),
+  },
+
+  devtool: "source-map"
+};`;
+
+describe('modifyWebpackConfig', () => {
+  afterEach(() => {
+    fileContent = '';
+    jest.clearAllMocks();
+  });
+
+  it.each([
+    [
+      'no sourcemap option, no plugins, object',
+      noSourcemapNoPluginsPojo,
+      noSourcemapNoPluginsPojoResult,
+    ],
+    [
+      'no sourcemap option, no plugins, identifier',
+      noSourcemapsNoPluginsId,
+      noSourcemapsNoPluginsIdResult,
+    ],
+    [
+      'hidden sourcemap option, no plugins, identifier',
+      hiddenSourcemapNoPluginsId,
+      hiddenSourcemapNoPluginsIdResult,
+    ],
+    [
+      'arbitrary sourcemap option, no plugins, identifier',
+      arbitrarySourcemapNoPluginsId,
+      arbitrarySourcemapNoPluginsIdResult,
+    ],
+    [
+      'no sourcemap option, plugins, object',
+      noSourcemapUndefinedPluginsPojo,
+      noSourcemapUndefinedPluginsPojoResult,
+    ],
+    [
+      'no sourcemap option, plugins, object',
+      noSourcemapPluginsPojo,
+      noSourcemapPluginsPojoResult,
+    ],
+  ])(
+    'adds plugin and source maps emission to the webpack config (%s)',
+    async (_, originalCode, expectedCode) => {
+      updateFileContent(originalCode);
+
+      //   updateFileContent(originalCode);
+      const addedCode = await modifyWebpackConfig('', {
+        authToken: '',
+        orgSlug: 'my-org',
+        projectSlug: 'my-project',
+        selfHosted: false,
+        url: 'https://sentry.io/',
+      });
+
+      expect(writeFileSpy).toHaveBeenCalledTimes(1);
+      const [[, fileContent]] = writeFileSpy.mock.calls;
+      expect(fileContent).toBe(expectedCode);
+      expect(addedCode).toBe(true);
+    },
+  );
+
+  it('adds the url parameter to the webpack plugin options if self-hosted', async () => {
+    updateFileContent(noSourcemapNoPluginsPojo);
+
+    const addedCode = await modifyWebpackConfig('', {
+      authToken: '',
+      orgSlug: 'my-org',
+      projectSlug: 'my-project',
+      selfHosted: true,
+      url: 'https://santry.io/',
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledTimes(1);
+    const [[, fileContent]] = writeFileSpy.mock.calls;
+    expect(fileContent).toContain('url: "https://santry.io/"');
+    expect(addedCode).toBe(true);
+  });
+});

package/test/utils/ast-utils.test.ts

@@ -1,22 +1,37 @@
-//@ts-ignore
-import { parseModule } from 'magicast';
 import { hasSentryContent } from '../../src/utils/ast-utils';
 
+import * as recast from 'recast';
+
 describe('AST utils', () => {
   describe('hasSentryContent', () => {
-    it("returns true if a '@sentry/' import was found in the parsed module", () => {
-      const code = `
+    it.each([
+      `
+      const { sentryVitePlugin } = require("@sentry/vite-plugin");
+      const somethingelse = require('gs');
+    `,
+      `
         import { sentryVitePlugin } from "@sentry/vite-plugin";
         import * as somethingelse from 'gs';
 
         export default {
             plugins: [sentryVitePlugin()]
         }
-      `;
+      `,
+    ])(
+      "returns true if a require('@sentry/') call was found in the parsed module",
+      (code) => {
+        // recast.parse returns a Program node (or fails) but it's badly typed as any
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        const program = recast.parse(code)
+          .program as recast.types.namedTypes.Program;
+        expect(hasSentryContent(program)).toBe(true);
+      },
+    );
 
-      expect(hasSentryContent(parseModule(code))).toBe(true);
-    });
     it.each([
+      `const whatever = require('something')`,
+      `// const {sentryWebpackPlugin} = require('@sentry/webpack-plugin')`,
+      `const {sAntryWebpackPlugin} = require('webpack-plugin-@sentry')`,
       `
       import * as somethingelse from 'gs';
       export default {
@@ -35,9 +50,13 @@ describe('AST utils', () => {
       }
       `,
     ])(
-      "reutrns false for modules without a valid '@sentry/' import",
+      "returns false if the file doesn't contain any require('@sentry/') calls",
       (code) => {
-        expect(hasSentryContent(parseModule(code))).toBe(false);
+        // recast.parse returns a Program node (or fails) but it's badly typed as any
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        const program = recast.parse(code)
+          .program as recast.types.namedTypes.Program;
+        expect(hasSentryContent(program)).toBe(false);
       },
     );
   });