@gravity-rail/cli 0.32.0 → 0.33.0

package/dist/lib.js

@@ -10355,12 +10355,81 @@ var ActivityRefResolver = class {
       forWorkspace.set(`${ref.kind}|${ref.uuid}`, ref);
       byWorkspace.set(ref.workspaceUuid, forWorkspace);
     }
+    const groups = [...byWorkspace].map(
+      ([workspaceUuid, wanted]) => [workspaceUuid, [...wanted.values()]]
+    );
+    if (this.options.orgUuid) {
+      await this.primeOrg(this.options.orgUuid, groups);
+      return;
+    }
     await Promise.all(
-      [...byWorkspace].map(
-        ([workspaceUuid, wanted]) => this.primeWorkspace(workspaceUuid, [...wanted.values()])
-      )
+      groups.map(([workspaceUuid, wanted]) => this.primeWorkspace(workspaceUuid, wanted))
     );
   }
+  /**
+   * One org call per chunk, each carrying whole workspace groups.
+   *
+   * The server's cap is over the whole request rather than per workspace, and
+   * it accepts each workspace at most once per request — so a group larger
+   * than the cap is split across requests, and smaller groups ride together
+   * until the next one would not fit.
+   */
+  async primeOrg(orgUuid, groups) {
+    const chunks = [];
+    let current = [];
+    let size = 0;
+    for (const [workspaceUuid, refs] of groups) {
+      for (let start = 0; start < refs.length; start += MAX_REFS_PER_BATCH) {
+        const slice = refs.slice(start, start + MAX_REFS_PER_BATCH);
+        if (size + slice.length > MAX_REFS_PER_BATCH && current.length > 0) {
+          chunks.push(current);
+          current = [];
+          size = 0;
+        }
+        current.push([workspaceUuid, slice]);
+        size += slice.length;
+      }
+    }
+    if (current.length > 0) chunks.push(current);
+    for (const chunk of chunks) {
+      const key = `org:${orgUuid}|${chunk.map(
+        ([workspaceUuid, refs]) => `${workspaceUuid}:${refs.map((ref) => `${ref.kind}|${ref.uuid}`).sort().join(",")}`
+      ).sort().join(";")}`;
+      const pending = this.inFlight.get(key) ?? this.fetchOrgChunk(orgUuid, chunk, key);
+      this.inFlight.set(key, pending);
+      await pending;
+    }
+  }
+  /** One org batch call, seeded into the same per-ref cache. */
+  async fetchOrgChunk(orgUuid, chunk, key) {
+    try {
+      this.fetches += 1;
+      const response = await this.client.resolveOrgEntityRefs(orgUuid, {
+        workspaces: chunk.map(([workspaceUuid, refs]) => ({
+          workspaceUuid,
+          refs: refs.map((ref) => ({ kind: ref.kind, uuid: ref.uuid }))
+        }))
+      });
+      const answered = new Map(
+        response.workspaces.map((group) => [
+          group.workspaceUuid,
+          new Map(group.refs.map((entry) => [`${entry.kind}|${entry.uuid}`, entry]))
+        ])
+      );
+      for (const [workspaceUuid, refs] of chunk) {
+        const byKey = answered.get(workspaceUuid);
+        if (!byKey) continue;
+        for (const ref of refs) {
+          const entry = byKey.get(`${ref.kind}|${ref.uuid}`);
+          if (!entry) continue;
+          const resolution = batchResolution(ref, entry);
+          if (resolution) this.cache.set(this.cacheKey(ref), Promise.resolve(resolution));
+        }
+      }
+    } catch {
+      this.inFlight.delete(key);
+    }
+  }
   async primeWorkspace(workspaceUuid, refs) {
     for (let start = 0; start < refs.length; start += MAX_REFS_PER_BATCH) {
       const chunk = refs.slice(start, start + MAX_REFS_PER_BATCH);
@@ -10612,8 +10681,10 @@ function globalFlags(ctx) {
   return flags;
 }
 function resolverFor(hctx) {
+  const mount = resolveActivityMount(hctx.args);
   return new ActivityRefResolver(requireAuth(hctx.ctx).apiClient, {
-    bare: hctx.args.ids === true
+    bare: hctx.args.ids === true,
+    orgUuid: mount.kind === "org" ? mount.uuid : void 0
   });
 }
 function isAggregate(response) {