feat: Upload Stats Information (#14)

Initial implementation of uploading stats information.

Author: nsdeschenes

codecov.yml

@@ -15,12 +15,12 @@ component_management:
     - component_id: package_rollup
       name: Rollup plugin
       paths:
-        - packages/plugin-rollup/**
+        - packages/rollup-plugin/**
     - component_id: package_vite
       name: Vite plugin
       paths:
-        - packages/plugin-vite/**
+        - packages/vite-plugin/**
     - component_id: package_webpack
       name: Webpack plugin
       paths:
-        - packages/plugin-webpack/**
+        - packages/webpack-plugin/**

packages/bundler-plugin-core/jest.config.ts

@@ -12,7 +12,6 @@ const config: Config = {
     "!test/helpers.ts",
   ],
   moduleNameMapper: {
-    "^@/(.*)$": "<rootDir>/src/$1",
     "^@test-utils/(.*)$": "<rootDir>/test-utils/$1",
   },
   transform: {

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

@@ -7,7 +7,8 @@ import {
   type UploadOverrides,
 } from "../types.ts";
 import { type UnpluginOptions } from "unplugin";
-import { debug } from "../utils/logging.ts";
+import { getPreSignedURL } from "../utils/getPreSignedURL.ts";
+import { uploadStats } from "../utils/uploadStats.ts";
 
 interface BundleAnalysisUploadPluginArgs {
   userOptions: Options;
@@ -25,7 +26,7 @@ export const bundleAnalysisPluginFactory = ({
 
   const { pluginVersion, version, ...pluginOpts } = bundleAnalysisUploadPlugin({
     output,
-    uploaderOverrides: userOptions?.uploaderOverrides,
+    userOptions,
   });
 
   output.version = version;
@@ -43,11 +44,34 @@ export const bundleAnalysisPluginFactory = ({
       output.duration = Date.now() - (output.builtAt ?? 0);
     },
     writeBundle: async () => {
+      // don't need to do anything here if dryRun is true
+      if (userOptions?.dryRun) return;
+
       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)}`);
+
+      let sendStats = true;
+      let url = "";
+      try {
+        url = await getPreSignedURL({
+          apiURL: "http://localhost:3000",
+          globalUploadToken: "123",
+          serviceParams: provider,
+        });
+      } catch (error) {
+        sendStats = false;
+      }
+
+      try {
+        if (sendStats) {
+          await uploadStats({
+            preSignedUrl: url,
+            message: JSON.stringify(output),
+          });
+        }
+      } catch {}
     },
   };
 };

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

@@ -11,7 +11,6 @@ import {
   type UploadOverrides,
 } from "./types.ts";
 
-import { jsonSchema } from "./schemas.ts";
 import { red } from "./utils/logging.ts";
 import { bundleAnalysisPluginFactory } from "./bundle-analysis/bundleAnalysisPluginFactory.ts";
 
@@ -31,7 +30,8 @@ export function codecovUnpluginFactory({
       red(
         `Codecov ${unpluginMetaContext.framework} bundler plugin requires Node.js ${NODE_VERSION_RANGE}. You are using Node.js ${process.version}. Please upgrade your Node.js version.`,
       );
-      process.exit(1);
+
+      return plugins;
     }
 
     if (userOptions?.enableBundleAnalysis) {
@@ -56,4 +56,3 @@ export type {
   ProviderUtilInputs,
   UploadOverrides,
 };
-export { jsonSchema };

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

@@ -46,7 +46,7 @@ export interface Output {
 
 export interface BundleAnalysisUploadPluginArgs {
   output: Output;
-  uploaderOverrides?: UploadOverrides;
+  userOptions: Options;
 }
 
 export interface Options {

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

@@ -3,7 +3,7 @@ import { setupServer } from "msw/node";
 
 import { fetchWithRetry } from "../fetchWithRetry";
 
-jest.mock("@/utils/delay");
+jest.mock("../delay.ts");
 
 const server = setupServer();
 

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

@@ -3,6 +3,8 @@ import { setupServer } from "msw/node";
 
 import { uploadStats } from "../uploadStats";
 import { FailedUploadError } from "../../errors/FailedUploadError";
+import { FailedFetchError } from "../../errors/FailedFetchError";
+import { UploadLimitReachedError } from "../../errors/UploadLimitReachedError";
 
 const server = setupServer();
 
@@ -20,10 +22,11 @@ afterAll(() => {
 
 interface SetupArgs {
   sendError?: boolean;
+  status?: number;
 }
 
 describe("uploadStats", () => {
-  function setup({ sendError = false }: SetupArgs) {
+  function setup({ sendError = false, status = 200 }: SetupArgs) {
     const consoleSpy = jest
       .spyOn(console, "log")
       .mockImplementation(() => null);
@@ -40,7 +43,7 @@ describe("uploadStats", () => {
         }
 
         if (!sendError) {
-          return HttpResponse.json({}, { status: 200 });
+          return HttpResponse.json({}, { status });
         }
 
         return HttpResponse.error();
@@ -52,33 +55,69 @@ describe("uploadStats", () => {
     };
   }
 
-  describe("on a successful upload", () => {
-    it("returns a 200", async () => {
-      setup({});
-      const preSignedUrl = "http://localhost/upload/stats/";
-      const message = JSON.stringify({ some: "cool", stats: true });
+  describe("on a successful request", () => {
+    it("returns true", async () => {
+      setup({ sendError: false });
 
-      const response = await uploadStats({ message, preSignedUrl });
+      const data = await uploadStats({
+        message: "cool-message",
+        preSignedUrl: "http://localhost/upload/stats/",
+      });
 
-      expect(response.status).toEqual(200);
+      expect(data).toBeTruthy();
     });
   });
 
-  describe("on a failed upload", () => {
-    it("throws a FailedUploadError", async () => {
-      const { consoleSpy } = setup({ sendError: true });
-      const preSignedUrl = "http://localhost/upload/stats/";
-      const message = JSON.stringify({ some: "cool", stats: true });
-
-      let error;
-      try {
-        await uploadStats({ message, preSignedUrl });
-      } catch (e) {
-        error = e;
-      }
-
-      expect(consoleSpy).toHaveBeenCalled();
-      expect(error).toBeInstanceOf(FailedUploadError);
+  describe("on an unsuccessful request", () => {
+    describe("fetch fails", () => {
+      it("throws a FailedFetchError", async () => {
+        setup({ sendError: true });
+
+        let error;
+        try {
+          await uploadStats({ message: "cool-message", preSignedUrl: "" });
+        } catch (e) {
+          error = e;
+        }
+
+        expect(error).toBeInstanceOf(FailedFetchError);
+      });
+    });
+
+    describe("upload limit is reached", () => {
+      it("throws an UploadLimitReachedError", async () => {
+        setup({ status: 429, sendError: false });
+
+        let error;
+        try {
+          await uploadStats({
+            message: "cool-message",
+            preSignedUrl: "http://localhost/upload/stats/",
+          });
+        } catch (e) {
+          error = e;
+        }
+
+        expect(error).toBeInstanceOf(UploadLimitReachedError);
+      });
+    });
+
+    describe("response is not ok", () => {
+      it("throws a FailedUploadError", async () => {
+        setup({ sendError: false, status: 400 });
+
+        let error;
+        try {
+          await uploadStats({
+            message: "cool-message",
+            preSignedUrl: "http://localhost/upload/stats/",
+          });
+        } catch (e) {
+          error = e;
+        }
+
+        expect(error).toBeInstanceOf(FailedUploadError);
+      });
     });
   });
 });

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

@@ -6,26 +6,28 @@ interface FetchWithRetryArgs {
   url: string;
   retryCount: number;
   requestData: RequestInit;
+  name?: string;
 }
 
 export const fetchWithRetry = async ({
   url,
   retryCount,
   requestData,
+  name,
 }: FetchWithRetryArgs) => {
   let response = new Response(null, { status: 400 });
 
   for (let i = 0; i < retryCount + 1; i++) {
     try {
-      debug(`Attempting to fetch number: ${i}`);
+      debug(`Attempting to fetch ${name}, attempt: ${i}`);
       await delay(DEFAULT_RETRY_DELAY * i);
       response = await fetch(url, requestData);
       break;
     } catch (err) {
-      debug(`Fetch attempt number ${i} failed`);
+      debug(`${name} fetch attempt ${i} failed`);
       const isLastAttempt = i + 1 === retryCount;
       if (isLastAttempt) {
-        red(`Fetch failed after ${i} attempts`);
+        red(`${name} failed after ${i} attempts`);
         throw err;
       }
     }

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

@@ -6,7 +6,7 @@ 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";
+import { green, red, yellow } from "./logging.ts";
 import { preProcessBody } from "./preProcessBody.ts";
 
 interface GetPreSignedURLArgs {
@@ -44,6 +44,7 @@ export const getPreSignedURL = async ({
     response = await fetchWithRetry({
       url,
       retryCount,
+      name: "`get-pre-signed-url`",
       requestData: {
         method: "POST",
         headers: {
@@ -54,43 +55,44 @@ export const getPreSignedURL = async ({
       },
     });
   } catch (e) {
-    red(`Failed to get pre-signed URL: ${e}`);
-    throw new FailedFetchError("Failed to get pre-signed URL");
+    red("Failed to fetch pre-signed URL");
+    throw new FailedFetchError("Failed to fetch pre-signed URL");
   }
 
   if (response.status === 429) {
-    red(`Upload limit reached`);
+    red("Upload limit reached");
     throw new UploadLimitReachedError("Upload limit reached");
   }
 
   if (!response.ok) {
-    red(`Failed to get pre-signed URL`);
+    red("Failed to get pre-signed URL, bad response");
     throw new FailedFetchError("Failed to get pre-signed URL");
   }
 
   let data;
   try {
     data = await response.json();
   } catch (e) {
-    red(`Failed to get pre-signed URL`);
-    throw new FailedFetchError("Failed to get pre-signed URL");
+    red("Failed to parse pre-signed URL body");
+    throw new FailedFetchError("Failed to parse pre-signed URL body");
   }
 
   const parsedData = PreSignedURLSchema.safeParse(data);
 
   if (!parsedData.success) {
-    red(`Failed to get pre-signed URL`);
-    throw new FailedFetchError("Failed to get pre-signed URL");
+    red("Failed to validate pre-signed URL");
+    throw new FailedFetchError("Failed to validate pre-signed URL");
   }
 
+  green(`Successfully pre-signed URL fetched`);
   return parsedData.data.url;
 };
 
 const getToken = (
   globalUploadToken: string | undefined,
   repoToken: string | undefined,
 ) => {
-  if (globalUploadToken && !repoToken) {
+  if (globalUploadToken && repoToken) {
     yellow(
       "Both globalUploadToken and repoToken found, Using globalUploadToken",
     );

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

@@ -55,6 +55,7 @@ describe("CI Providers", () => {
         args: {
           ...createEmptyArgs(),
           ...{
+            branch: "main",
             sha: "123",
             slug: "testOrg/testRepo",
           },