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

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as _mikro_orm_core from '@mikro-orm/core';
 import { EntityRepository, EntityRepositoryType, EntitySchema, MikroORM } from '@mikro-orm/core';
-import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
 
 /**
  * Custom repositories for the durable entities, so a host app can `@InjectRepository`/inject a
@@ -196,15 +196,36 @@ declare class MikroOrmStateStore implements StateStore {
      *  predicates only raw SQL can express — the `tag` JSON LIKE and one EXISTS per attribute filter.
      *  Shared so a facet count and the page it labels are taken over the SAME set. */
     private runQueryBuilder;
+    /** `tags LIKE '%"etl"%'` — the quoted token, so `etl` doesn't match `etl-foo`. See the note in
+     *  {@link listRuns} for why this is raw SQL rather than a MikroORM condition. */
+    private tagLikeSql;
     /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
      *  console can show whole-set counts next to a bounded page instead of downloading every run to
      *  count them in the browser. */
     runFacets(query: RunFacetQuery): Promise<RunFacetRow[]>;
+    /** Distinct values of one filter axis over the same predicates {@link listRuns} pages. A run-table
+     *  column is a `GROUP BY` like {@link runFacets}, exact over the whole matching set; the tag and
+     *  attribute axes live outside the row (json array / side table) and are counted from a bounded
+     *  page of runs instead — see {@link RunValueFacetOptions.scan}. */
+    runValueFacets(axis: RunValueAxis, query: RunFacetQuery, opts?: RunValueFacetOptions): Promise<RunValueFacetRow[]>;
+    /**
+     * 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.
+     */
+    private scannedValueFacets;
     /** 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
-     *  operands compare the num column, everything else the str column. Identifiers are quoted per
-     *  driver and operands are inlined as literals (string operands are escaped by doubling quotes). */
+     *  operands compare the num column, everything else the str column. `in` contributes one comparison
+     *  per member, ORed inside the single EXISTS — one subquery either way, and an `in` over no values
+     *  yields no comparison and so matches nothing. Identifiers are quoted per driver and operands are
+     *  inlined as literals (string operands are escaped by doubling quotes). */
     private attributeExistsSql;
     /** Resolve the side-table's actual column names from MikroORM metadata, so the raw EXISTS matches
      *  the active naming strategy (underscore vs camelCase) rather than guessing. The run PK column is

package/dist/index.js

@@ -547,7 +547,7 @@ __name(durableEntities, "durableEntities");
 var ENTITIES = durableEntities();
 
 // src/mikro-orm-state-store.ts
-import { attributeColumnFor, attributeOperand, mergeRunFacetRows, normalizeAttributeRows, parseDuration, sqlComparator } from "@dudousxd/nestjs-durable-core";
+import { RUN_VALUE_FACET_SCAN, attributePredicateOperands, axisIsRunColumn, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, parseDuration } from "@dudousxd/nestjs-durable-core";
 import { raw } from "@mikro-orm/core";
 
 // src/schema.ts
@@ -1031,20 +1031,47 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
   *  applied by the QueryBuilder path in both callers. */
   runWhere(query) {
     const where = {};
+    const and = [];
     if (query.workflow) where.workflow = query.workflow;
+    if (query.workflows) and.push({
+      workflow: {
+        $in: query.workflows
+      }
+    });
     if (query.namespace !== void 0) where.namespace = query.namespace;
+    if (query.namespaces) and.push({
+      namespace: {
+        $in: query.namespaces
+      }
+    });
     if (query.origin !== void 0) where.origin = query.origin;
+    if (query.origins) {
+      const named = query.origins.filter((o) => o !== null);
+      const branches = [];
+      if (named.length) branches.push({
+        origin: {
+          $in: named
+        }
+      });
+      if (query.origins.some((o) => o === null)) branches.push({
+        origin: null
+      });
+      and.push(branches.length ? {
+        $or: branches
+      } : {
+        origin: {
+          $in: []
+        }
+      });
+    }
     if (query.status && query.statuses) {
-      where.$and = [
-        {
-          status: query.status
-        },
-        {
-          status: {
-            $in: query.statuses
-          }
+      and.push({
+        status: query.status
+      }, {
+        status: {
+          $in: query.statuses
         }
-      ];
+      });
     } else if (query.status) {
       where.status = query.status;
     } else if (query.statuses) {
@@ -1052,6 +1079,7 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
         $in: query.statuses
       };
     }
+    if (and.length) where.$and = and;
     return where;
   }
   async listRuns(query) {
@@ -1060,7 +1088,7 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     const orderBy = {
       createdAt: "desc"
     };
-    if (query.tag || query.attributes?.length) {
+    if (query.tag || query.tags || query.attributes?.length) {
       const qb = this.runQueryBuilder(em, query, where).orderBy(orderBy);
       if (query.limit != null) qb.limit(query.limit);
       if (query.offset != null) qb.offset(query.offset);
@@ -1086,17 +1114,23 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     const quote = this.idQuote(em);
     const cols = this.attributeColumns(em);
     const qb = em.createQueryBuilder(WorkflowRunEntity, "r").where(where);
-    if (query.tag) {
-      const tagsCol = this.tagsColumn(em);
-      const pattern = `%"${query.tag.replace(/'/g, "''")}"%`;
-      const colExpr = this.jsonAsText(em, `${quote("r")}.${quote(tagsCol)}`);
-      qb.andWhere(`${colExpr} LIKE '${pattern}'`);
+    if (query.tag) qb.andWhere(this.tagLikeSql(em, query.tag, quote));
+    if (query.tags) {
+      const branches = query.tags.map((t) => this.tagLikeSql(em, t, quote));
+      qb.andWhere(branches.length ? `(${branches.join(" OR ")})` : "1 = 0");
     }
     for (const f of query.attributes ?? []) {
       qb.andWhere(this.attributeExistsSql(f, quote, "r", cols));
     }
     return qb;
   }
+  /** `tags LIKE '%"etl"%'` — the quoted token, so `etl` doesn't match `etl-foo`. See the note in
+  *  {@link listRuns} for why this is raw SQL rather than a MikroORM condition. */
+  tagLikeSql(em, tag, quote) {
+    const pattern = `%"${tag.replace(/'/g, "''")}"%`;
+    const colExpr = this.jsonAsText(em, `${quote("r")}.${quote(this.tagsColumn(em))}`);
+    return `${colExpr} LIKE '${pattern}'`;
+  }
   /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
   *  console can show whole-set counts next to a bounded page instead of downloading every run to
   *  count them in the browser. */
@@ -1117,20 +1151,103 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
       count: Number(r.count)
     })));
   }
+  /** Distinct values of one filter axis over the same predicates {@link listRuns} pages. A run-table
+  *  column is a `GROUP BY` like {@link runFacets}, exact over the whole matching set; the tag and
+  *  attribute axes live outside the row (json array / side table) and are counted from a bounded
+  *  page of runs instead — see {@link RunValueFacetOptions.scan}. */
+  async runValueFacets(axis, query, opts) {
+    if (!axisIsRunColumn(axis)) {
+      return this.scannedValueFacets(axis, query, opts);
+    }
+    const em = this.fork();
+    const meta = em.getMetadata().get(WorkflowRunEntity);
+    const col = meta.properties[axis.field]?.fieldNames?.[0] ?? axis.field;
+    const rows = await this.runQueryBuilder(em, query, this.runWhere(query)).select([
+      `r.${col}`
+    ]).addSelect(raw("count(*) as count")).groupBy([
+      `r.${col}`
+    ]).execute();
+    return mergeRunValueFacetRows(rows.map((row) => ({
+      value: row[axis.field] ?? null,
+      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 ?? 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 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 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
-  *  operands compare the num column, everything else the str column. Identifiers are quoted per
-  *  driver and operands are inlined as literals (string operands are escaped by doubling quotes). */
+  *  operands compare the num column, everything else the str column. `in` contributes one comparison
+  *  per member, ORed inside the single EXISTS — one subquery either way, and an `in` over no values
+  *  yields no comparison and so matches nothing. Identifiers are quoted per driver and operands are
+  *  inlined as literals (string operands are escaped by doubling quotes). */
   attributeExistsSql(f, quote, alias, cols) {
-    const col = attributeColumnFor(f) === "numValue" ? cols.numValue : cols.strValue;
-    const cmp = sqlComparator(f.op);
-    const operand = attributeOperand(f);
-    const literal = typeof operand === "number" ? String(operand) : `'${String(operand).replace(/'/g, "''")}'`;
+    const comparisons = attributePredicateOperands(f).map(({ column, comparator, operand }) => {
+      const col = column === "numValue" ? cols.numValue : cols.strValue;
+      const literal = typeof operand === "number" ? String(operand) : `'${String(operand).replace(/'/g, "''")}'`;
+      return `${quote("a")}.${quote(col)} ${comparator} ${literal}`;
+    });
+    if (comparisons.length === 0) return "1 = 0";
     const a = quote(cols.table);
     const sub = quote("a");
     const outerId = `${quote(alias)}.${quote(cols.runPk)}`;
-    return `EXISTS (SELECT 1 FROM ${a} ${sub} WHERE ${sub}.${quote(cols.runId)} = ${outerId} AND ${sub}.${quote(cols.key)} = '${f.key.replace(/'/g, "''")}' AND ${sub}.${quote(col)} ${cmp} ${literal})`;
+    const match = comparisons.length === 1 ? comparisons[0] : `(${comparisons.join(" OR ")})`;
+    return `EXISTS (SELECT 1 FROM ${a} ${sub} WHERE ${sub}.${quote(cols.runId)} = ${outerId} AND ${sub}.${quote(cols.key)} = '${f.key.replace(/'/g, "''")}' AND ${match})`;
   }
   /** Resolve the side-table's actual column names from MikroORM metadata, so the raw EXISTS matches
   *  the active naming strategy (underscore vs camelCase) rather than guessing. The run PK column is