@dudousxd/nestjs-durable-store-mikro-orm 0.24.0 → 0.25.0

package/dist/index.cjs

@@ -1197,11 +1197,7 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
   *  page of runs instead — see {@link RunValueFacetOptions.scan}. */
   async runValueFacets(axis, query, opts) {
     if (!(0, import_nestjs_durable_core.axisIsRunColumn)(axis)) {
-      const runs = await this.listRuns({
-        ...query,
-        limit: opts?.scan ?? import_nestjs_durable_core.RUN_VALUE_FACET_SCAN
-      });
-      return (0, import_nestjs_durable_core.runValueFacetsFromRuns)(runs, axis, opts);
+      return this.scannedValueFacets(axis, query, opts);
     }
     const em = this.fork();
     const meta = em.getMetadata().get(WorkflowRunEntity);
@@ -1216,6 +1212,63 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
       count: Number(row.count)
     })), opts);
   }
+  /**
+  * The axes whose values do not live in a column of the run row: `tag` (inside a JSON array) and the
+  * two search-attribute axes (a side table). Both read the newest `scan` matching runs.
+  *
+  * Neither reads a run's PAYLOAD. The obvious implementation — page `listRuns` and count in
+  * memory — pulls `input`, `output` and `error` for every run in the window, which on a control
+  * plane with real payloads is tens of megabytes fetched to produce a list of a hundred short
+  * strings, every time a picker opens. These project the one column each question needs instead:
+  * the tags column, or the run ids that then drive one grouped read of the side table.
+  */
+  async scannedValueFacets(axis, query, opts) {
+    const em = this.fork();
+    const scan = opts?.scan ?? import_nestjs_durable_core.RUN_VALUE_FACET_SCAN;
+    const where = this.runWhere(query);
+    const runMeta = em.getMetadata().get(WorkflowRunEntity);
+    const idCol = runMeta.properties.id?.fieldNames?.[0] ?? "id";
+    if (axis.field === "tag") {
+      const tagsCol = this.tagsColumn(em);
+      const rows = await this.runQueryBuilder(em, query, where).select([
+        `r.${tagsCol}`
+      ]).orderBy({
+        createdAt: "desc"
+      }).limit(scan).execute();
+      const values = [];
+      for (const row of rows) {
+        const raw2 = row.tags ?? row[tagsCol];
+        const tags = typeof raw2 === "string" ? JSON.parse(raw2) : raw2;
+        if (!Array.isArray(tags)) continue;
+        for (const tag of tags) values.push({
+          value: String(tag),
+          count: 1
+        });
+      }
+      return (0, import_nestjs_durable_core.mergeRunValueFacetRows)(values, opts);
+    }
+    const idRows = await this.runQueryBuilder(em, query, where).select([
+      `r.${idCol}`
+    ]).orderBy({
+      createdAt: "desc"
+    }).limit(scan).execute();
+    const runIds = idRows.map((row) => String(row.id ?? row[idCol]));
+    if (runIds.length === 0) return [];
+    const attributes = await em.find(RunAttributeEntity, axis.field === "attributeValue" ? {
+      runId: {
+        $in: runIds
+      },
+      key: axis.key
+    } : {
+      runId: {
+        $in: runIds
+      }
+    });
+    return (0, import_nestjs_durable_core.mergeRunValueFacetRows)(attributes.map((row) => ({
+      value: axis.field === "attributeKey" ? row.key : row.strValue ?? (row.numValue == null ? null : String(row.numValue)),
+      count: 1
+    })), opts);
+  }
   /** One attribute predicate as a raw EXISTS subquery on the side-table, correlated to the outer run
   *  alias. `<>` (ne) also excludes runs where the attribute is absent (missing-key-never-matches):
   *  EXISTS already requires a present row, so EXISTS(... <> ...) is exactly ne-with-present. Numeric