feat: Work on Upload Functions (#10)

Get initial upload functions cleaned up and sorted.

Author: nsdeschenes

.eslintrc.js

@@ -8,7 +8,12 @@ const config = {
     "plugin:@typescript-eslint/stylistic-type-checked",
     "plugin:prettier/recommended",
   ],
-  ignorePatterns: ["**/bundlers/**"],
+  ignorePatterns: [
+    "**/bundlers/**",
+    "**/coverage/**",
+    "**/dist/**",
+    "**/node_modules/**",
+  ],
   parserOptions: {
     ecmaVersion: "latest",
     sourceType: "module",

.gitignore

@@ -128,3 +128,5 @@ dist
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+
+.DS_Store

bundlers/vite/package.json

@@ -29,5 +29,8 @@
   },
   "volta": {
     "extends": "../../package.json"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
-}
+}

packages/bundler-plugin-core/src/errors/FailedFetchError.ts

@@ -0,0 +1,5 @@
+export class FailedFetchError extends Error {
+  constructor(msg: string) {
+    super(msg);
+  }
+}

packages/bundler-plugin-core/src/errors/FailedUploadError.ts

@@ -0,0 +1,5 @@
+export class FailedUploadError extends Error {
+  constructor(msg: string) {
+    super(msg);
+  }
+}

packages/bundler-plugin-core/src/errors/NoUploadTokenError.ts

@@ -0,0 +1,5 @@
+export class NoUploadTokenError extends Error {
+  constructor(msg: string) {
+    super(msg);
+  }
+}

packages/bundler-plugin-core/src/errors/UploadLimitReachedError.ts

@@ -0,0 +1,5 @@
+export class UploadLimitReachedError extends Error {
+  constructor(msg: string) {
+    super(msg);
+  }
+}

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

@@ -1,6 +1,5 @@
 import { type UnpluginOptions, createUnplugin } from "unplugin";
 import { satisfies } from "semver";
-import { z } from "zod";
 
 import {
   type BundleAnalysisUploadPlugin,
@@ -34,12 +33,6 @@ export function codecovUnpluginFactory({
     }
 
     if (userOptions?.enableBundleAnalysis) {
-      const statsFileName = z
-        .string()
-        .endsWith(".json")
-        .optional()
-        .parse(userOptions?.statsFileName);
-
       const output: Output = {
         version: "1",
       };
@@ -48,7 +41,6 @@ export function codecovUnpluginFactory({
       const { pluginVersion, version, ...pluginOpts } =
         bundleAnalysisUploadPlugin({
           output,
-          statsFileName,
           uploaderOverrides: userOptions?.uploaderOverrides,
         });
 

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

@@ -46,13 +46,59 @@ export interface Output {
 
 export interface BundleAnalysisUploadPluginArgs {
   output: Output;
-  statsFileName?: string;
   uploaderOverrides?: UploadOverrides;
 }
 
 export interface Options {
-  statsFileName?: string;
+  /**
+   * The upload token to use for uploading the bundle analysis information.
+   *
+   * `globalUploadToken` and `repoName` must be set if this is not set.
+   */
+  globalUploadToken?: string;
+
+  /**
+   * The name of the repository to upload the bundle analysis information to.
+   *
+   * `globalUploadToken` and `repoName` must be set if this is not set.
+   */
+  repoName?: string;
+
+  /**
+   * The upload token to use for uploading the bundle analysis information.
+   *
+   * Mutually exclusive to using `globalUploadToken` and `repoName`.
+   */
+  repoToken?: string;
+
+  /**
+   * The commit hash to use for uploading the bundle analysis information.
+   *
+   * Defaults package.json name field.
+   */
+  namespace?: string;
+
+  // TODO: Update the default value here
+  /**
+   * The api url used to fetch the upload url.
+   *
+   * Only required if self-hosting codecov.
+   *
+   * Defaults to `https://api.codecov.io`.
+   */
+  apiUrl?: string;
+
+  /**
+   * The amount of times the upload function will retry.
+   *
+   * Defaults to 3
+   */
+  retryCount?: number;
+
+  /** Whether you would like bundle analysis to be enabled. */
   enableBundleAnalysis?: boolean;
+
+  /** Override values for passing custom information to API. */
   uploaderOverrides?: UploadOverrides;
 }
 

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

@@ -0,0 +1,112 @@
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+
+import { fetchWithRetry } from "../fetchWithRetry";
+
+jest.mock("@/utils/delay");
+
+const server = setupServer();
+
+beforeAll(() => {
+  server.listen();
+});
+
+afterEach(() => {
+  server.resetHandlers();
+});
+
+afterAll(() => {
+  server.close();
+});
+
+interface SetupArgs {
+  status?: number;
+  data?: object;
+  retryCount?: number;
+  sendError?: boolean;
+}
+
+describe("fetchWithRetry", () => {
+  let consoleSpy: jest.SpyInstance;
+
+  afterEach(() => {
+    consoleSpy.mockReset();
+  });
+
+  function setup({
+    status = 200,
+    data = {},
+    sendError = false,
+    retryCount = 0,
+  }: SetupArgs) {
+    consoleSpy = jest.spyOn(console, "log").mockImplementation(() => null);
+
+    server.use(
+      http.all("http://localhost", ({}) => {
+        if (retryCount === 0 && !sendError) {
+          return HttpResponse.json(data, { status });
+        }
+        retryCount -= 1;
+        return HttpResponse.error();
+      }),
+    );
+  }
+
+  describe('when the initial response is "success"', () => {
+    it("returns the pre-signed URL", async () => {
+      setup({
+        data: { url: "http://example.com" },
+        retryCount: 0,
+      });
+
+      const urlPromise = await fetchWithRetry({
+        url: "http://localhost",
+        requestData: {},
+        retryCount: 3,
+      });
+      const data = (await urlPromise.json()) as { url: string };
+
+      expect(data?.url).toBe("http://example.com");
+    });
+  });
+
+  describe('when the initial response is "retryable"', () => {
+    it("returns the pre-signed URL after retrying", async () => {
+      setup({
+        data: { url: "http://example.com" },
+        retryCount: 2,
+      });
+
+      const urlPromise = await fetchWithRetry({
+        url: "http://localhost",
+        requestData: {},
+        retryCount: 3,
+      });
+      const data = (await urlPromise.json()) as { url: string };
+
+      expect(data?.url).toBe("http://example.com");
+    });
+  });
+
+  describe("retry count exceeds limit", () => {
+    it("throws an error", async () => {
+      setup({
+        data: { url: "http://example.com" },
+        retryCount: 2,
+        sendError: true,
+      });
+
+      let error;
+      try {
+        await fetchWithRetry({
+          url: "http://localhost",
+          requestData: {},
+          retryCount: 1,
+        });
+      } catch (e) {
+        error = e;
+      }
+      expect(error).toBeInstanceOf(TypeError);
+    });
+  });
+});