feat: Grab Provider Information (#12)

Grab the current provider information, and a bit of cleanup work.

Author: nsdeschenes

.github/workflows/ci.yml

@@ -189,6 +189,11 @@ jobs:
       - name: Run unit tests
         run: pnpm run test:unit:ci --maxWorkers=2
 
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
 #   fossa:
 #     name: Run Fossa
 #     runs-on: ubuntu-latest

package.json

@@ -12,6 +12,7 @@
     "lint:fix": "pnpm -r --filter='./packages/*' lint:fix",
     "format": "pnpm -r --filter='./packages/*' format && prettier --write '*.{cjs,json}' --ignore-unknown --no-error-on-unmatched-pattern",
     "format:check": "pnpm -r --filter='./packages/*' format:check && prettier --check '*.{cjs,json}' --ignore-unknown --no-error-on-unmatched-pattern",
+    "test:unit": "pnpm -r --filter='./packages/*' run test:unit",
     "test:unit:ci": "pnpm -r --filter='./packages/*' run test:unit:ci"
   },
   "keywords": [],

packages/bundler-plugin-core/src/bundle-analysis/bundleAnalysisPluginFactory.ts

@@ -0,0 +1,53 @@
+import { detectProvider } from "../utils/provider.ts";
+import {
+  type BundleAnalysisUploadPlugin,
+  type Options,
+  type Output,
+  type ProviderUtilInputs,
+  type UploadOverrides,
+} from "../types.ts";
+import { type UnpluginOptions } from "unplugin";
+import { debug } from "../utils/logging.ts";
+
+interface BundleAnalysisUploadPluginArgs {
+  userOptions: Options;
+  bundleAnalysisUploadPlugin: BundleAnalysisUploadPlugin;
+}
+
+export const bundleAnalysisPluginFactory = ({
+  userOptions,
+  bundleAnalysisUploadPlugin,
+}: BundleAnalysisUploadPluginArgs): UnpluginOptions => {
+  // const dryRun = userOptions?.dryRun ?? false;
+  const output: Output = {
+    version: "1",
+  };
+
+  const { pluginVersion, version, ...pluginOpts } = bundleAnalysisUploadPlugin({
+    output,
+    uploaderOverrides: userOptions?.uploaderOverrides,
+  });
+
+  output.version = version;
+  output.plugin = {
+    name: pluginOpts.name,
+    version: pluginVersion,
+  };
+
+  return {
+    ...pluginOpts,
+    buildStart() {
+      output.builtAt = Date.now();
+    },
+    buildEnd(this) {
+      output.duration = Date.now() - (output.builtAt ?? 0);
+    },
+    writeBundle: async () => {
+      const args: UploadOverrides = userOptions.uploaderOverrides ?? {};
+      const envs = process.env;
+      const inputs: ProviderUtilInputs = { envs, args };
+      const provider = await detectProvider(inputs);
+      debug(`\nprovider: ${JSON.stringify(provider, null, 2)}`);
+    },
+  };
+};

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

@@ -7,11 +7,13 @@ import {
   type Chunk,
   type Module,
   type Options,
-  type Output,
+  type ProviderUtilInputs,
+  type UploadOverrides,
 } from "./types.ts";
 
 import { jsonSchema } from "./schemas.ts";
 import { red } from "./utils/logging.ts";
+import { bundleAnalysisPluginFactory } from "./bundle-analysis/bundleAnalysisPluginFactory.ts";
 
 const NODE_VERSION_RANGE = ">=18.18.0";
 
@@ -33,38 +35,25 @@ export function codecovUnpluginFactory({
     }
 
     if (userOptions?.enableBundleAnalysis) {
-      const output: Output = {
-        version: "1",
-      };
-
-      let startTime = NaN;
-      const { pluginVersion, version, ...pluginOpts } =
-        bundleAnalysisUploadPlugin({
-          output,
-          uploaderOverrides: userOptions?.uploaderOverrides,
-        });
-
-      plugins.push({
-        ...pluginOpts,
-        buildStart() {
-          startTime = Date.now();
-          output.version = version;
-          output.plugin = {
-            name: pluginOpts.name,
-            version: pluginVersion,
-          };
-          output.builtAt = startTime;
-        },
-        buildEnd(this) {
-          const duration = Date.now() - startTime;
-          output.duration = duration;
-        },
-      });
+      plugins.push(
+        bundleAnalysisPluginFactory({
+          userOptions,
+          bundleAnalysisUploadPlugin,
+        }),
+      );
     }
 
     return plugins;
   });
 }
 
-export type { BundleAnalysisUploadPlugin, Asset, Chunk, Module, Options };
+export type {
+  BundleAnalysisUploadPlugin,
+  Asset,
+  Chunk,
+  Module,
+  Options,
+  ProviderUtilInputs,
+  UploadOverrides,
+};
 export { jsonSchema };

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

@@ -91,7 +91,7 @@ export interface Options {
   /**
    * The amount of times the upload function will retry.
    *
-   * Defaults to 3
+   * Defaults to `3`
    */
   retryCount?: number;
 
@@ -100,6 +100,13 @@ export interface Options {
 
   /** Override values for passing custom information to API. */
   uploaderOverrides?: UploadOverrides;
+
+  /**
+   * When enabled information will not be uploaded to Codecov.
+   *
+   * Defaults to `false`
+   */
+  dryRun?: boolean;
 }
 
 export type BundleAnalysisUploadPlugin = (

packages/bundler-plugin-core/src/utils/__tests__/getPreSignedURL.test.ts

@@ -2,9 +2,9 @@ import { HttpResponse, http } from "msw";
 import { setupServer } from "msw/node";
 
 import { getPreSignedURL } from "../getPreSignedURL.ts";
-import { FailedFetchError } from "@/errors/FailedFetchError.ts";
-import { NoUploadTokenError } from "@/errors/NoUploadTokenError.ts";
-import { UploadLimitReachedError } from "@/errors/UploadLimitReachedError.ts";
+import { FailedFetchError } from "../../errors/FailedFetchError.ts";
+import { NoUploadTokenError } from "../../errors/NoUploadTokenError.ts";
+import { UploadLimitReachedError } from "../../errors/UploadLimitReachedError.ts";
 
 const server = setupServer();
 

packages/bundler-plugin-core/src/utils/__tests__/provider.test.ts

@@ -0,0 +1,89 @@
+import { type ProviderUtilInputs } from "src/types.ts";
+import { detectProvider, setSlug } from "../provider.ts";
+import { isProgramInstalled } from "../isProgramInstalled";
+
+jest.mock("../isProgramInstalled");
+const mockedIsProgramInstalled = isProgramInstalled as jest.Mock;
+
+describe("detectProvider", () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    consoleSpy = jest.spyOn(console, "log").mockImplementation(() => null);
+  });
+
+  afterEach(() => {
+    consoleSpy.mockReset();
+  });
+
+  describe("when provider is detected", () => {
+    beforeEach(() => {
+      mockedIsProgramInstalled.mockReturnValue(false);
+    });
+
+    it("returns the service params", async () => {
+      const inputs: ProviderUtilInputs = {
+        args: {},
+        envs: {
+          CI: "true",
+          APPVEYOR: "true",
+        },
+      };
+
+      const result = await detectProvider(inputs);
+
+      expect(result.service).toEqual("appveyor");
+    });
+  });
+
+  describe("no provider is detected", () => {
+    it("throws an error", async () => {
+      let error;
+
+      try {
+        const inputs: ProviderUtilInputs = {
+          args: {},
+          envs: {},
+        };
+
+        const result = await detectProvider(inputs);
+        console.info(result);
+      } catch (e) {
+        error = e;
+      }
+
+      expect(error).toBeInstanceOf(Error);
+      if (error instanceof Error) {
+        expect(error.message).toEqual("Could not detect provider");
+      }
+    });
+  });
+});
+
+describe("setSlug", () => {
+  describe("when slugArg is defined and not empty", () => {
+    it("returns slugArg", () => {
+      const slugArg = "cool-slug";
+
+      const result = setSlug(slugArg, undefined, undefined);
+      expect(result).toEqual(slugArg);
+    });
+  });
+
+  describe("when slugArg is not defined or empty and orgEnv and repoEnv are defined and not empty", () => {
+    it("returns orgEnv/repoEnv", () => {
+      const orgEnv = "cool-org";
+      const repoEnv = "cool-repo";
+
+      const result = setSlug(undefined, orgEnv, repoEnv);
+      expect(result).toEqual(`${orgEnv}/${repoEnv}`);
+    });
+  });
+
+  describe("all values are undefined", () => {
+    it("returns an empty string", () => {
+      const result = setSlug(undefined, undefined, undefined);
+      expect(result).toEqual("");
+    });
+  });
+});

packages/bundler-plugin-core/src/utils/__tests__/uploadStats.test.ts

@@ -2,7 +2,7 @@ import { HttpResponse, http } from "msw";
 import { setupServer } from "msw/node";
 
 import { uploadStats } from "../uploadStats";
-import { FailedUploadError } from "@/errors/FailedUploadError";
+import { FailedUploadError } from "../../errors/FailedUploadError";
 
 const server = setupServer();
 

packages/bundler-plugin-core/src/utils/getPreSignedURL.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
 
-import { FailedFetchError } from "@/errors/FailedFetchError.ts";
-import { NoUploadTokenError } from "@/errors/NoUploadTokenError.ts";
-import { UploadLimitReachedError } from "@/errors/UploadLimitReachedError.ts";
-import { type ProviderServiceParams } from "@/types.ts";
+import { FailedFetchError } from "../errors/FailedFetchError.ts";
+import { NoUploadTokenError } from "../errors/NoUploadTokenError.ts";
+import { UploadLimitReachedError } from "../errors/UploadLimitReachedError.ts";
+import { type ProviderServiceParams } from "../types.ts";
 import { DEFAULT_RETRY_COUNT } from "./constants.ts";
 import { fetchWithRetry } from "./fetchWithRetry.ts";
 import { red, yellow } from "./logging.ts";

packages/bundler-plugin-core/src/utils/provider.ts

@@ -1,3 +1,24 @@
+import {
+  type ProviderServiceParams,
+  type ProviderUtilInputs,
+} from "../types.ts";
+import { cyan, red } from "./logging.ts";
+import { providerList } from "./providers";
+
+export async function detectProvider(
+  inputs: ProviderUtilInputs,
+): Promise<ProviderServiceParams> {
+  cyan("Detecting CI provider");
+  for (const provider of providerList) {
+    if (provider.detect(inputs.envs)) {
+      cyan(`Detected CI provider: ${provider.getServiceName()}`);
+      return await provider.getServiceParams(inputs);
+    }
+  }
+  red("Could not detect CI provider");
+  throw new Error("Could not detect provider");
+}
+
 export function setSlug(
   slugArg: string | undefined,
   orgEnv: string | undefined,