@dudousxd/nestjs-durable-dashboard 0.40.0 → 0.42.0

package/dist/server/index.d.cts

@@ -1,5 +1,5 @@
 import * as _dudousxd_nestjs_durable_core from '@dudousxd/nestjs-durable-core';
-import { RunGateway, StateStore, WorkflowEngine, RunQuery, RunListItem, DurableTopology, GroupHealth, RunDetail, RunResult, UpdateResult, EngineEvent, RunStatus } from '@dudousxd/nestjs-durable-core';
+import { RunGateway, StateStore, WorkflowEngine, RunQuery, RunListItem, RunFacetQuery, RunFacetRow, DurableTopology, GroupHealth, RunDetail, RunResult, UpdateResult, EngineEvent, RunStatus } from '@dudousxd/nestjs-durable-core';
 export { RunDetail } from '@dudousxd/nestjs-durable-core';
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
@@ -134,6 +134,9 @@ declare class DashboardService {
      */
     metrics(): Promise<string>;
     listRuns(query: RunQuery): Promise<RunListItem[]>;
+    /** `(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: RunFacetQuery): Promise<RunFacetRow[]>;
     /** 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). */
@@ -154,11 +157,15 @@ declare class DashboardService {
         compensate?: boolean;
     }): Promise<RunResult | null>;
     /**
-     * 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.
      */
-    bulk(action: 'retry' | 'cancel', filter: Pick<RunQuery, 'status' | 'tag' | 'workflow' | 'attributes'>, opts?: {
+    bulk(action: 'retry' | 'cancel', filter: Pick<RunQuery, 'status' | 'tag' | 'workflow' | 'attributes' | 'namespace' | 'origin'>, opts?: {
         compensate?: boolean;
     }): Promise<{
         matched: number;
@@ -191,11 +198,40 @@ declare class DashboardService {
     }>;
 }
 
+/**
+ * A run as the CONSOLE'S LIST needs it: every field a row or its derived state reads, and none of the
+ * payloads only the detail view opens.
+ *
+ * `input`, `output` and `error` are dropped. On a real control plane they dominate the response —
+ * measured against a 9.5k-run deployment, `error` alone (stack traces on every failed run) was 63% of
+ * a 12 MB listing — while no list row, and no `deriveRunState` input, ever reads them. The detail
+ * endpoint (`GET runs/:id`) still returns the whole run, which is where those three are actually
+ * rendered.
+ */
+type RunListRow = Omit<RunListItem, 'input' | 'output' | 'error'>;
+
 /** JSON API consumed by the control-plane SPA. Mounted at `apiBasePath` (set by RouterModule). */
 declare class DurableApiController {
     private readonly dashboard;
     constructor(dashboard: DashboardService);
-    runs(status?: RunStatus, workflow?: string, tag?: string, attr?: string | string[]): Promise<_dudousxd_nestjs_durable_core.RunListItem[]>;
+    /**
+     * 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.
+     */
+    runs(status?: RunStatus | RunStatus[], workflow?: string, tag?: string, attr?: string | string[], namespace?: string, origin?: string, unattributed?: string, limit?: string, offset?: string): Promise<RunListRow[]>;
+    /**
+     * `(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?: string, tag?: string, attr?: string | string[], namespace?: string): Promise<_dudousxd_nestjs_durable_core.RunFacetRow[]>;
     /** Prometheus-text metrics (runs/steps by outcome, per-workflow counts) for a scrape. */
     metrics(): Promise<string>;
     /** Per-group worker health (queue backlog + live worker heartbeats) for the Workers panel. */
@@ -215,8 +251,12 @@ declare class DurableApiController {
     }): Promise<{
         runId: string;
     } | null>;
-    /** Bulk retry/cancel every run matching a filter (status / tag / workflow). */
-    bulk(action: 'retry' | 'cancel', status?: RunStatus, tag?: string, workflow?: string, attr?: string | string[], compensate?: string): Promise<{
+    /**
+     * 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: 'retry' | 'cancel', status?: RunStatus, tag?: string, workflow?: string, attr?: string | string[], compensate?: string, namespace?: string, origin?: string, unattributed?: string): Promise<{
         matched: number;
         applied: number;
     }>;

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
 import * as _dudousxd_nestjs_durable_core from '@dudousxd/nestjs-durable-core';
-import { RunGateway, StateStore, WorkflowEngine, RunQuery, RunListItem, DurableTopology, GroupHealth, RunDetail, RunResult, UpdateResult, EngineEvent, RunStatus } from '@dudousxd/nestjs-durable-core';
+import { RunGateway, StateStore, WorkflowEngine, RunQuery, RunListItem, RunFacetQuery, RunFacetRow, DurableTopology, GroupHealth, RunDetail, RunResult, UpdateResult, EngineEvent, RunStatus } from '@dudousxd/nestjs-durable-core';
 export { RunDetail } from '@dudousxd/nestjs-durable-core';
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
@@ -134,6 +134,9 @@ declare class DashboardService {
      */
     metrics(): Promise<string>;
     listRuns(query: RunQuery): Promise<RunListItem[]>;
+    /** `(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: RunFacetQuery): Promise<RunFacetRow[]>;
     /** 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). */
@@ -154,11 +157,15 @@ declare class DashboardService {
         compensate?: boolean;
     }): Promise<RunResult | null>;
     /**
-     * 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.
      */
-    bulk(action: 'retry' | 'cancel', filter: Pick<RunQuery, 'status' | 'tag' | 'workflow' | 'attributes'>, opts?: {
+    bulk(action: 'retry' | 'cancel', filter: Pick<RunQuery, 'status' | 'tag' | 'workflow' | 'attributes' | 'namespace' | 'origin'>, opts?: {
         compensate?: boolean;
     }): Promise<{
         matched: number;
@@ -191,11 +198,40 @@ declare class DashboardService {
     }>;
 }
 
+/**
+ * A run as the CONSOLE'S LIST needs it: every field a row or its derived state reads, and none of the
+ * payloads only the detail view opens.
+ *
+ * `input`, `output` and `error` are dropped. On a real control plane they dominate the response —
+ * measured against a 9.5k-run deployment, `error` alone (stack traces on every failed run) was 63% of
+ * a 12 MB listing — while no list row, and no `deriveRunState` input, ever reads them. The detail
+ * endpoint (`GET runs/:id`) still returns the whole run, which is where those three are actually
+ * rendered.
+ */
+type RunListRow = Omit<RunListItem, 'input' | 'output' | 'error'>;
+
 /** JSON API consumed by the control-plane SPA. Mounted at `apiBasePath` (set by RouterModule). */
 declare class DurableApiController {
     private readonly dashboard;
     constructor(dashboard: DashboardService);
-    runs(status?: RunStatus, workflow?: string, tag?: string, attr?: string | string[]): Promise<_dudousxd_nestjs_durable_core.RunListItem[]>;
+    /**
+     * 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.
+     */
+    runs(status?: RunStatus | RunStatus[], workflow?: string, tag?: string, attr?: string | string[], namespace?: string, origin?: string, unattributed?: string, limit?: string, offset?: string): Promise<RunListRow[]>;
+    /**
+     * `(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?: string, tag?: string, attr?: string | string[], namespace?: string): Promise<_dudousxd_nestjs_durable_core.RunFacetRow[]>;
     /** Prometheus-text metrics (runs/steps by outcome, per-workflow counts) for a scrape. */
     metrics(): Promise<string>;
     /** Per-group worker health (queue backlog + live worker heartbeats) for the Workers panel. */
@@ -215,8 +251,12 @@ declare class DurableApiController {
     }): Promise<{
         runId: string;
     } | null>;
-    /** Bulk retry/cancel every run matching a filter (status / tag / workflow). */
-    bulk(action: 'retry' | 'cancel', status?: RunStatus, tag?: string, workflow?: string, attr?: string | string[], compensate?: string): Promise<{
+    /**
+     * 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: 'retry' | 'cancel', status?: RunStatus, tag?: string, workflow?: string, attr?: string | string[], compensate?: string, namespace?: string, origin?: string, unattributed?: string): Promise<{
         matched: number;
         applied: number;
     }>;

package/dist/server/index.js

@@ -101,6 +101,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). */
@@ -129,8 +134,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) {
@@ -242,6 +251,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;
@@ -260,6 +276,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");
@@ -268,12 +319,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. */
@@ -305,13 +384,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"
     });
@@ -360,15 +448,40 @@ _ts_decorate2([
   _ts_param2(1, Query("workflow")),
   _ts_param2(2, Query("tag")),
   _ts_param2(3, Query("attr")),
+  _ts_param2(4, Query("namespace")),
+  _ts_param2(5, Query("origin")),
+  _ts_param2(6, Query("unattributed")),
+  _ts_param2(7, Query("limit")),
+  _ts_param2(8, 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([
+  Get("runs/facets"),
+  _ts_param2(0, Query("workflow")),
+  _ts_param2(1, Query("tag")),
+  _ts_param2(2, Query("attr")),
+  _ts_param2(3, 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([
   Get("metrics"),
   Header("Content-Type", "text/plain; version=0.0.4"),
@@ -434,6 +547,9 @@ _ts_decorate2([
   _ts_param2(3, Query("workflow")),
   _ts_param2(4, Query("attr")),
   _ts_param2(5, Query("compensate")),
+  _ts_param2(6, Query("namespace")),
+  _ts_param2(7, Query("origin")),
+  _ts_param2(8, Query("unattributed")),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     String,
@@ -441,6 +557,9 @@ _ts_decorate2([
     String,
     String,
     Object,
+    String,
+    String,
+    String,
     String
   ]),
   _ts_metadata2("design:returntype", void 0)