ref(core): Add Sentry CLI

packages/bundler-plugin-core/package.json

@@ -31,9 +31,11 @@
     "clean:build": "rimraf ./dist *.tgz",
     "clean:deps": "rimraf node_modules",
     "test": "jest",
-    "lint": "eslint ./src ./test"
+    "lint": "eslint ./src ./test",
+    "fix": "eslint ./src ./test --format stylish --fix"
   },
   "dependencies": {
+    "@sentry/cli": "^1.74.6",
     "@sentry/node": "^7.11.1",
     "@sentry/tracing": "^7.11.1",
     "axios": "^0.27.2",

packages/bundler-plugin-core/src/options-mapping.ts

@@ -21,7 +21,7 @@ type RequiredInternalOptions = Required<
 >;
 
 type OptionalInternalOptions = Partial<
-  Pick<UserOptions, "dist" | "errorHandler" | "setCommits" | "deploy">
+  Pick<UserOptions, "dist" | "errorHandler" | "setCommits" | "deploy" | "configFile">
 >;
 
 type NormalizedInternalOptions = {
@@ -97,6 +97,7 @@ export function normalizeUserOptions(userOptions: UserOptions): InternalOptions
     deploy: userOptions.deploy,
     entries,
     include,
+    configFile: userOptions.configFile,
   };
 }
 

packages/bundler-plugin-core/src/sentry/cli.ts

@@ -0,0 +1,61 @@
+import SentryCli, { SentryCliReleases } from "@sentry/cli";
+import { InternalOptions } from "../options-mapping";
+import { Logger } from "./logger";
+
+type SentryDryRunCLI = { releases: Omit<SentryCliReleases, "listDeploys" | "execute"> };
+type SentryCLILike = SentryCli | SentryDryRunCLI;
+
+/**
+ * Creates a new Sentry CLI instance.
+ *
+ * In case, users selected the `dryRun` options, this returns a stub
+ * that makes no-ops out of most CLI operations
+ */
+export function getSentryCli(internalOptions: InternalOptions, logger: Logger): SentryCLILike {
+  const cli = new SentryCli(internalOptions.configFile, {
+    silent: internalOptions.silent,
+    org: internalOptions.org,
+    project: internalOptions.project,
+    authToken: internalOptions.authToken,
+    url: internalOptions.url,
+    vcsRemote: internalOptions.vcsRemote,
+  });
+
+  if (internalOptions.dryRun) {
+    return getDryRunCLI(cli, logger);
+  }
+
+  return cli;
+}
+
+function getDryRunCLI(cli: SentryCli, logger: Logger): SentryDryRunCLI {
+  return {
+    releases: {
+      proposeVersion: () =>
+        cli.releases.proposeVersion().then((version) => {
+          logger.info("Proposed version:\n", version);
+          return version;
+        }),
+      new: (release: string) => {
+        logger.info("Creating new release:\n", release);
+        return Promise.resolve(release);
+      },
+      uploadSourceMaps: (release: string, config: unknown) => {
+        logger.info("Calling upload-sourcemaps with:\n", config);
+        return Promise.resolve(release);
+      },
+      finalize: (release: string) => {
+        logger.info("Finalizing release:\n", release);
+        return Promise.resolve(release);
+      },
+      setCommits: (release: string, config: unknown) => {
+        logger.info("Calling set-commits with:\n", config);
+        return Promise.resolve(release);
+      },
+      newDeploy: (release: string, config: unknown) => {
+        logger.info("Calling deploy with:\n", config);
+        return Promise.resolve(release);
+      },
+    },
+  };
+}

packages/bundler-plugin-core/src/sentry/logger.ts

@@ -6,7 +6,14 @@ interface LoggerOptions {
   prefix: string;
 }
 
-export function createLogger(options: LoggerOptions) {
+export type Logger = {
+  info(message: string, ...params: unknown[]): void;
+  warn(message: string, ...params: unknown[]): void;
+  error(message: string, ...params: unknown[]): void;
+  debug(message: string, ...params: unknown[]): void;
+};
+
+export function createLogger(options: LoggerOptions): Logger {
   function addBreadcrumb(level: SeverityLevel, message: string) {
     options.hub.addBreadcrumb({
       category: "logger",
@@ -16,29 +23,38 @@ export function createLogger(options: LoggerOptions) {
   }
 
   return {
-    info(message: string) {
+    info(message: string, ...params: unknown[]) {
       if (!options?.silent) {
         // eslint-disable-next-line no-console
-        console.log(`${options.prefix} ${message}`);
+        console.log(`${options.prefix} Info: ${message}`, ...params);
       }
 
       addBreadcrumb("info", message);
     },
-    warn(message: string) {
+    warn(message: string, ...params: unknown[]) {
       if (!options?.silent) {
         // eslint-disable-next-line no-console
-        console.log(`${options.prefix} Warning! ${message}`);
+        console.log(`${options.prefix} Warning: ${message}`, ...params);
       }
 
       addBreadcrumb("warning", message);
     },
-    error(message: string) {
+    error(message: string, ...params: unknown[]) {
       if (!options?.silent) {
         // eslint-disable-next-line no-console
-        console.log(`${options.prefix} Error: ${message}`);
+        console.log(`${options.prefix} Error: ${message}`, ...params);
       }
 
       addBreadcrumb("error", message);
     },
+
+    debug(message: string, ...params: unknown[]) {
+      if (!options?.silent) {
+        // eslint-disable-next-line no-console
+        console.log(`${options.prefix} Debug: ${message}`, ...params);
+      }
+
+      addBreadcrumb("debug", message);
+    },
   };
 }

packages/bundler-plugin-core/src/types.ts

@@ -177,6 +177,15 @@ export type Options = Omit<IncludeEntry, "paths"> & {
    * Defaults to true
    */
   telemetry?: boolean;
+
+  /**
+   * Path to Sentry CLI config properties, as described in
+   * https://docs.sentry.io/product/cli/configuration/#configuration-file.
+   *
+   * By default, the config file is looked for upwards from the current path, and
+   * defaults from ~/.sentryclirc are always loaded
+   */
+  configFile?: string;
 };
 
 export type IncludeEntry = {

packages/bundler-plugin-core/test/cli.test.ts

@@ -0,0 +1,16 @@
+import SentryCli from "@sentry/cli";
+import { getSentryCli } from "../src/sentry/cli";
+
+describe("getSentryCLI", () => {
+  it("returns a valid CLI instance if dryRun is not specified", () => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+    const cli = getSentryCli({} as any, {} as any);
+    expect(cli).toBeInstanceOf(SentryCli);
+  });
+
+  it("returns a valid CLI instance if dryRun is set to true", () => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+    const cli = getSentryCli({ dryRun: true } as any, {} as any);
+    expect(cli).not.toBeInstanceOf(SentryCli);
+  });
+});

packages/bundler-plugin-core/test/logger.test.ts

@@ -19,41 +19,47 @@ describe("Logger", () => {
     mockedAddBreadcrumb.mockReset();
   });
 
-  it(".info() should log correctly", () => {
+  it.each([
+    ["info", "Info"],
+    ["warn", "Warning"],
+    ["error", "Error"],
+    ["debug", "Debug"],
+  ] as const)(".%s() should log correctly", (loggerMethod, logLevel) => {
     const prefix = "[some-prefix]";
     const logger = createLogger({ hub, prefix });
-    logger.info("Hey!");
 
-    expect(consoleLogSpy).toHaveBeenCalledWith("[some-prefix] Hey!");
-    expect(mockedAddBreadcrumb).toHaveBeenCalledWith({
-      category: "logger",
-      level: "info",
-      message: "Hey!",
-    });
-  });
+    logger[loggerMethod]("Hey!");
 
-  it(".warn() should log correctly", () => {
-    const prefix = "[some-prefix]";
-    const logger = createLogger({ hub, prefix });
-    logger.warn("Hey!");
-
-    expect(consoleLogSpy).toHaveBeenCalledWith("[some-prefix] Warning! Hey!");
+    expect(consoleLogSpy).toHaveBeenCalledWith(`[some-prefix] ${logLevel}: Hey!`);
     expect(mockedAddBreadcrumb).toHaveBeenCalledWith({
       category: "logger",
-      level: "warning",
+      level: logLevel.toLowerCase(),
       message: "Hey!",
     });
   });
 
-  it(".error() should log correctly", () => {
+  it.each([
+    ["info", "Info"],
+    ["warn", "Warning"],
+    ["error", "Error"],
+    ["debug", "Debug"],
+  ] as const)(".%s() should log multiple params correctly", (loggerMethod, logLevel) => {
     const prefix = "[some-prefix]";
     const logger = createLogger({ hub, prefix });
-    logger.error("Hey!");
 
-    expect(consoleLogSpy).toHaveBeenCalledWith("[some-prefix] Error: Hey!");
+    logger[loggerMethod]("Hey!", "this", "is", "a test with", 5, "params");
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      `[some-prefix] ${logLevel}: Hey!`,
+      "this",
+      "is",
+      "a test with",
+      5,
+      "params"
+    );
     expect(mockedAddBreadcrumb).toHaveBeenCalledWith({
       category: "logger",
-      level: "error",
+      level: logLevel.toLowerCase(),
       message: "Hey!",
     });
   });