fix: paginate repository list to load all workspace repositories (#25)

* fix: paginate repository list to load all workspace repositories

- Add shared paginated fetcher in workspaceRepositoryFetcher.js
- Fetch repos in page_size=500 chunks until all pages are consumed
- Show withProgress loading indicator during multi-page fetches
- Sort merged repository list alphabetically by name
- Return error cleanly if the first page fails
- Log warning and return partial results if a later page fails
- Wire fetcher into workspaceNode.js and cloudsmithProvider.js
- Support both normal workspace expansion and defaultWorkspace mode
- Add regression tests for multi-page, first-page failure, partial failure, and default-workspace integration

* fix: use API-reported page size for pagination stop check

- Detect short final page from pagination.pageSize instead of requested size
- Treat non-array response data as error instead of silent empty result

---------

Co-authored-by: Colin Moynes <77994705+colinmoynes@users.noreply.github.com>

Author: DevonL

models/workspaceNode.js

@@ -3,8 +3,10 @@
 const vscode = require("vscode");
 const path = require("path");
 const { CloudsmithAPI } = require("../util/cloudsmithAPI");
+const InfoNode = require("./infoNode");
 const repositoryNode = require("./repositoryNode");
 const { WorkspaceInfoNode } = require("./workspaceInfoNode");
+const workspaceRepositoryFetcher = require("../util/workspaceRepositoryFetcher");
 
 class WorkspaceNode {
   constructor(item, context) {
@@ -32,22 +34,22 @@ class WorkspaceNode {
   async getRepositories() {
     const context = this.context;
     const workspace = this.workspace;
-    const cloudsmithAPI = new CloudsmithAPI(context);
-    const repositories = await cloudsmithAPI.get(
-      "repos/" + workspace + "/?sort=name"
+    const result = await workspaceRepositoryFetcher.fetchWorkspaceRepositories(
+      context,
+      workspace
     );
 
-    const RepositoryNodes = [];
-    if (typeof repositories === "string") {
-      vscode.window.showErrorMessage(
-        `Could not load repositories for ${workspace}. ${repositories}`
-      );
-      return RepositoryNodes;
+    if (result.error) {
+      return [new InfoNode(
+        "Failed to load repositories",
+        "Check your connection and try refreshing",
+        `Failed to load repositories for ${workspace}: ${result.error}`,
+        "warning"
+      )];
     }
 
-    if (!Array.isArray(repositories)) {
-      return RepositoryNodes;
-    }
+    const repositories = result.repositories;
+    const RepositoryNodes = [];
 
     for (const repo of repositories) {
       const repositoryNodeInst = new repositoryNode(

test/cloudsmithProvider.test.js

@@ -0,0 +1,78 @@
+const assert = require("assert");
+const { CloudsmithAPI } = require("../util/cloudsmithAPI");
+const { ConnectionManager } = require("../util/connectionManager");
+const workspaceRepositoryFetcher = require("../util/workspaceRepositoryFetcher");
+const { CloudsmithProvider } = require("../views/cloudsmithProvider");
+
+suite("CloudsmithProvider Test Suite", () => {
+  let originalConnect;
+  let originalGet;
+  let originalFetchWorkspaceRepositories;
+  let provider;
+  let cacheUpdates;
+
+  const context = {
+    globalState: {
+      update(key, value) {
+        cacheUpdates.push({ key, value });
+      },
+    },
+  };
+
+  setup(() => {
+    cacheUpdates = [];
+    provider = new CloudsmithProvider(context);
+
+    originalConnect = ConnectionManager.prototype.connect;
+    originalGet = CloudsmithAPI.prototype.get;
+    originalFetchWorkspaceRepositories =
+      workspaceRepositoryFetcher.fetchWorkspaceRepositories;
+
+    ConnectionManager.prototype.connect = async () => "true";
+    CloudsmithAPI.prototype.get = async endpoint => {
+      if (endpoint.startsWith("quota/")) {
+        return {
+          usage: {
+            display: {
+              storage: { used: "0 GB", plan_limit: "10 GB", percentage_used: "0" },
+              bandwidth: { used: "0 GB", plan_limit: "10 GB", percentage_used: "0" },
+            },
+          },
+        };
+      }
+
+      return [];
+    };
+  });
+
+  teardown(() => {
+    ConnectionManager.prototype.connect = originalConnect;
+    CloudsmithAPI.prototype.get = originalGet;
+    workspaceRepositoryFetcher.fetchWorkspaceRepositories =
+      originalFetchWorkspaceRepositories;
+  });
+
+  test("loads repositories for the default workspace through the shared fetcher", async () => {
+    workspaceRepositoryFetcher.fetchWorkspaceRepositories = async () => ({
+      repositories: [
+        { name: "repo-a", slug: "repo-a" },
+        { name: "repo-b", slug: "repo-b" },
+      ],
+      error: null,
+      warning: null,
+      partial: false,
+    });
+
+    const nodes = await provider.getRepositories("workspace-a");
+
+    assert.strictEqual(nodes.length, 3);
+    assert.strictEqual(nodes[0].workspaceName, "workspace-a");
+    assert.strictEqual(nodes[1].name, "repo-a");
+    assert.strictEqual(nodes[2].name, "repo-b");
+    assert.strictEqual(cacheUpdates.length, 1);
+    assert.strictEqual(cacheUpdates[0].key, "CloudsmithCache");
+    assert.deepStrictEqual(cacheUpdates[0].value.workspaces, [
+      { name: "workspace-a", slug: "workspace-a" },
+    ]);
+  });
+});

test/workspaceNode.test.js

@@ -0,0 +1,81 @@
+const assert = require("assert");
+const { CloudsmithAPI } = require("../util/cloudsmithAPI");
+const workspaceRepositoryFetcher = require("../util/workspaceRepositoryFetcher");
+const WorkspaceNode = require("../models/workspaceNode");
+
+suite("WorkspaceNode Test Suite", () => {
+  let originalGet;
+  let originalFetchWorkspaceRepositories;
+  let cacheUpdates;
+  let context;
+
+  setup(() => {
+    originalGet = CloudsmithAPI.prototype.get;
+    originalFetchWorkspaceRepositories =
+      workspaceRepositoryFetcher.fetchWorkspaceRepositories;
+    cacheUpdates = [];
+    context = {
+      globalState: {
+        update(key, value) {
+          cacheUpdates.push({ key, value });
+        },
+      },
+    };
+
+    CloudsmithAPI.prototype.get = async () => "quota unavailable";
+  });
+
+  teardown(() => {
+    CloudsmithAPI.prototype.get = originalGet;
+    workspaceRepositoryFetcher.fetchWorkspaceRepositories =
+      originalFetchWorkspaceRepositories;
+  });
+
+  test("shows an error child when the first repository page fails", async () => {
+    workspaceRepositoryFetcher.fetchWorkspaceRepositories = async () => ({
+      repositories: [],
+      error: "Response status: 500",
+      warning: null,
+      partial: false,
+    });
+
+    const node = new WorkspaceNode(
+      { name: "Workspace A", slug: "workspace-a" },
+      context
+    );
+
+    const children = await node.getChildren();
+
+    assert.strictEqual(children.length, 2);
+    assert.strictEqual(children[1]._label, "Failed to load repositories");
+    assert.strictEqual(cacheUpdates.length, 0);
+  });
+
+  test("updates the repository cache with fetched repositories", async () => {
+    workspaceRepositoryFetcher.fetchWorkspaceRepositories = async () => ({
+      repositories: [
+        { name: "repo-a", slug: "repo-a" },
+        { name: "repo-b", slug: "repo-b" },
+      ],
+      error: null,
+      warning: null,
+      partial: false,
+    });
+
+    const node = new WorkspaceNode(
+      { name: "Workspace A", slug: "workspace-a" },
+      context
+    );
+
+    const repos = await node.getRepositories();
+
+    assert.strictEqual(repos.length, 2);
+    assert.strictEqual(repos[0].name, "repo-a");
+    assert.strictEqual(cacheUpdates.length, 1);
+    assert.strictEqual(cacheUpdates[0].key, "CloudsmithCache");
+    assert.deepStrictEqual(
+      cacheUpdates[0].value.workspaces.map(repo => repo.slug),
+      ["repo-a", "repo-b"]
+    );
+  });
+});