@dudousxd/nestjs-durable-dashboard 0.40.0 → 0.42.0

package/dist/server/index.cjs

@@ -135,6 +135,11 @@ var DashboardService = class {
   listRuns(query) {
     return this.gateway.listRuns(query);
   }
+  /** `(status, origin)` counts over the same predicates {@link listRuns} pages — what keeps the
+  *  console's chips exact while its list is bounded to a page. */
+  runFacets(query) {
+    return this.gateway.runFacets(query);
+  }
   /** This deployment's durable role (control plane vs tenant) + tenant name — for the dashboard header
   *  badge. Routes through the gateway, which knows its own topology (store-backed = operator, proxy =
   *  tenant). Works on both topologies (no store/engine needed). */
@@ -163,8 +168,12 @@ var DashboardService = class {
     return this.gateway.cancel(runId, opts);
   }
   /**
-  * Apply `retry` or `cancel` to every run matching a filter (status / tag / workflow) — e.g. "retry
-  * every `dead` run tagged `type:mel`". Capped at 500 runs per call; runs that can't be acted on
+  * Apply `retry` or `cancel` to every run matching a filter (status / tag / workflow / namespace /
+  * origin) — e.g. "retry every `dead` run tagged `type:mel`". The filter is the same one the run
+  * list uses, so a bulk action can never reach wider than the list it was launched from — but note
+  * an ABSENT predicate still means "every value on that axis" (an omitted `namespace` is every
+  * tenant), which is what makes passing the operator's full filter through mandatory, not optional.
+  * Capped at 500 runs per call; runs that can't be acted on
   * (already terminal) are skipped. Returns how many matched and how many the action applied to.
   */
   async bulk(action, filter, opts) {
@@ -276,6 +285,13 @@ function parseAttrFilters(attr) {
 }
 __name(parseAttrFilters, "parseAttrFilters");
 
+// src/server/run-list-row.ts
+function toRunListRow(run) {
+  const { input: _input, output: _output, error: _error, ...row } = run;
+  return row;
+}
+__name(toRunListRow, "toRunListRow");
+
 // src/server/durable-api.controller.ts
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -294,6 +310,41 @@ function _ts_param2(paramIndex, decorator) {
   };
 }
 __name(_ts_param2, "_ts_param");
+function pageBounds(limit, offset) {
+  const bound = /* @__PURE__ */ __name((raw) => {
+    const n = Number(raw);
+    return raw !== void 0 && raw !== "" && Number.isInteger(n) && n >= 0 ? n : void 0;
+  }, "bound");
+  const l = bound(limit);
+  const o = bound(offset);
+  return {
+    ...l !== void 0 ? {
+      limit: l
+    } : {},
+    ...o !== void 0 ? {
+      offset: o
+    } : {}
+  };
+}
+__name(pageBounds, "pageBounds");
+function statusPredicate(status) {
+  if (Array.isArray(status)) return status.length ? {
+    statuses: status
+  } : {};
+  return status ? {
+    status
+  } : {};
+}
+__name(statusPredicate, "statusPredicate");
+function originPredicate(origin, unattributed) {
+  if (unattributed === "true" || unattributed === "1") return {
+    origin: null
+  };
+  return origin ? {
+    origin
+  } : {};
+}
+__name(originPredicate, "originPredicate");
 var DurableApiController = class {
   static {
     __name(this, "DurableApiController");
@@ -302,12 +353,40 @@ var DurableApiController = class {
   constructor(dashboard) {
     this.dashboard = dashboard;
   }
-  runs(status, workflow, tag, attr) {
-    return this.dashboard.listRuns({
-      status,
+  /**
+  * The run list, filtered by whatever the operator asked for. Every predicate is OPTIONAL and an
+  * omitted one means "don't narrow on this axis" — in particular `namespace`, whose absence keeps
+  * the historical, deliberate behaviour that read paths are NOT namespace-scoped (core,
+  * `WorkflowRun.namespace`): the console shows every tenant's runs until an operator chooses one.
+  * A blank param (`?namespace=`, from a cleared filter box) is the same as an absent one; passing
+  * `''` through would be an exact match on a tenant nobody has, i.e. a silently empty console.
+  */
+  async runs(status, workflow, tag, attr, namespace, origin, unattributed, limit, offset) {
+    const runs = await this.dashboard.listRuns({
+      ...statusPredicate(status),
       workflow,
       tag,
-      attributes: parseAttrFilters(attr)
+      attributes: parseAttrFilters(attr),
+      namespace: namespace || void 0,
+      ...originPredicate(origin, unattributed),
+      ...pageBounds(limit, offset)
+    });
+    return runs.map(toRunListRow);
+  }
+  /**
+  * `(status, origin)` counts for the runs matching the same tag/tenant/attribute predicates as
+  * `GET runs`. This is what lets that listing be PAGED at all: the page bounds what the console
+  * renders, this bounds nothing and keeps its status and origin chips exact.
+  *
+  * `status`, `origin` and the page bounds are deliberately NOT accepted — they are the axes being
+  * counted, so narrowing by them would report the answer back to itself.
+  */
+  facets(workflow, tag, attr, namespace) {
+    return this.dashboard.runFacets({
+      workflow,
+      tag,
+      attributes: parseAttrFilters(attr),
+      namespace: namespace || void 0
     });
   }
   /** Prometheus-text metrics (runs/steps by outcome, per-workflow counts) for a scrape. */
@@ -339,13 +418,22 @@ var DurableApiController = class {
   retryWithInput(id, body) {
     return this.dashboard.retryWithInput(id, body?.input);
   }
-  /** Bulk retry/cancel every run matching a filter (status / tag / workflow). */
-  bulk(action, status, tag, workflow, attr, compensate) {
+  /**
+  * Bulk retry/cancel every run matching a filter (status / tag / workflow / namespace / origin).
+  * The filter takes the SAME params as `GET runs` and is parsed identically, so "retry all" acts on
+  * exactly the set the operator was looking at rather than a wider one.
+  */
+  bulk(action, status, tag, workflow, attr, compensate, namespace, origin, unattributed) {
     return this.dashboard.bulk(action === "cancel" ? "cancel" : "retry", {
       status,
       tag,
       workflow,
-      attributes: parseAttrFilters(attr)
+      attributes: parseAttrFilters(attr),
+      namespace: namespace || void 0,
+      // The unattributed bucket is a scope a console can actually SELECT, so a bulk action launched
+      // under it must be narrowed to it. Dropping the param would widen a retry/cancel to every
+      // origin — acting on runs the operator was not looking at.
+      ...originPredicate(origin, unattributed)
     }, {
       compensate: compensate === "true"
     });
@@ -394,15 +482,40 @@ _ts_decorate2([
   _ts_param2(1, (0, import_common2.Query)("workflow")),
   _ts_param2(2, (0, import_common2.Query)("tag")),
   _ts_param2(3, (0, import_common2.Query)("attr")),
+  _ts_param2(4, (0, import_common2.Query)("namespace")),
+  _ts_param2(5, (0, import_common2.Query)("origin")),
+  _ts_param2(6, (0, import_common2.Query)("unattributed")),
+  _ts_param2(7, (0, import_common2.Query)("limit")),
+  _ts_param2(8, (0, import_common2.Query)("offset")),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    typeof RunStatus === "undefined" ? Object : RunStatus,
+    Object,
     String,
     String,
-    Object
+    Object,
+    String,
+    String,
+    String,
+    String,
+    String
   ]),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata2("design:returntype", Promise)
 ], DurableApiController.prototype, "runs", null);
+_ts_decorate2([
+  (0, import_common2.Get)("runs/facets"),
+  _ts_param2(0, (0, import_common2.Query)("workflow")),
+  _ts_param2(1, (0, import_common2.Query)("tag")),
+  _ts_param2(2, (0, import_common2.Query)("attr")),
+  _ts_param2(3, (0, import_common2.Query)("namespace")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    String,
+    Object,
+    String
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "facets", null);
 _ts_decorate2([
   (0, import_common2.Get)("metrics"),
   (0, import_common2.Header)("Content-Type", "text/plain; version=0.0.4"),
@@ -468,6 +581,9 @@ _ts_decorate2([
   _ts_param2(3, (0, import_common2.Query)("workflow")),
   _ts_param2(4, (0, import_common2.Query)("attr")),
   _ts_param2(5, (0, import_common2.Query)("compensate")),
+  _ts_param2(6, (0, import_common2.Query)("namespace")),
+  _ts_param2(7, (0, import_common2.Query)("origin")),
+  _ts_param2(8, (0, import_common2.Query)("unattributed")),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     String,
@@ -475,6 +591,9 @@ _ts_decorate2([
     String,
     String,
     Object,
+    String,
+    String,
+    String,
     String
   ]),
   _ts_metadata2("design:returntype", void 0)