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

package/dist/index.d.ts

@@ -203,11 +203,40 @@ declare class MikroOrmStateStore implements StateStore {
      *  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}. */
+    /**
+     * Distinct values of one filter axis over the same predicates {@link listRuns} pages, with counts —
+     * what a console's value pickers list.
+     *
+     * All three axis families are answered by ONE grouped query against the filtered run set, so the
+     * counts are exact over that whole set (not a sample), the ordering is stable, and a picker can
+     * page and search server-side. That last part is what makes a picker usable on the axis that needs
+     * it most: tag cardinality grows with the data, so the values an operator is looking for are
+     * routinely outside any top slice, and a search that only filtered the fetched page could never
+     * find them.
+     *
+     * The predicates come from {@link runQueryBuilder} as a subquery rather than being rewritten here,
+     * so a picker and the list it filters can never disagree about which runs they are talking about.
+     */
     runValueFacets(axis: RunValueAxis, query: RunFacetQuery, opts?: RunValueFacetOptions): Promise<RunValueFacetRow[]>;
+    /** The filtered run set as a derived table, carrying only the columns the axis needs. One source
+     *  of truth with `listRuns`: the same builder, the same predicates. */
+    private runSubquery;
+    /** Where the values of an axis come from, and how to name one — a column of the filtered runs, an
+     *  element of their tags array, or a row of the attribute side table. */
+    private valueSource;
+    /**
+     * The dialect's way of turning a JSON array column into one row per element — the only portable
+     * thing about it being that all three have one. Without it a tag picker cannot be grouped in the
+     * database at all, and falls back to deduping a bounded page of runs in memory: counts that
+     * describe a sample, and an order that cannot be paged.
+     */
+    private jsonArrayJoin;
+    /** `lower(value) like '%needle%'` — the picker's search box, applied BEFORE the page is cut so a
+     *  match outside the top slice is still reachable. */
+    private searchCondition;
+    /** A grouped value as the string a picker shows. Drivers return a JSON element or a numeric
+     *  attribute as something other than a string; `null` stays null (the absent bucket). */
+    private text;
     /** 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

package/dist/index.js

@@ -547,7 +547,7 @@ __name(durableEntities, "durableEntities");
 var ENTITIES = durableEntities();
 
 // src/mikro-orm-state-store.ts
-import { RUN_VALUE_FACET_SCAN, attributePredicateOperands, axisIsRunColumn, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, parseDuration, runValueFacetsFromRuns } from "@dudousxd/nestjs-durable-core";
+import { ENGINE_MINTED_TAG_PREFIXES, RUN_VALUE_FACET_LIMIT, attributePredicateOperands, axisIsRunColumn, facetOrigin, mergeRunFacetRows, normalizeAttributeRows, parseDuration } from "@dudousxd/nestjs-durable-core";
 import { raw } from "@mikro-orm/core";
 
 // src/schema.ts
@@ -1151,30 +1151,118 @@ 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}. */
+  /**
+  * Distinct values of one filter axis over the same predicates {@link listRuns} pages, with counts —
+  * what a console's value pickers list.
+  *
+  * All three axis families are answered by ONE grouped query against the filtered run set, so the
+  * counts are exact over that whole set (not a sample), the ordering is stable, and a picker can
+  * page and search server-side. That last part is what makes a picker usable on the axis that needs
+  * it most: tag cardinality grows with the data, so the values an operator is looking for are
+  * routinely outside any top slice, and a search that only filtered the fetched page could never
+  * find them.
+  *
+  * The predicates come from {@link runQueryBuilder} as a subquery rather than being rewritten here,
+  * so a picker and the list it filters can never disagree about which runs they are talking about.
+  */
   async runValueFacets(axis, query, opts) {
-    if (!axisIsRunColumn(axis)) {
-      const runs = await this.listRuns({
-        ...query,
-        limit: opts?.scan ?? RUN_VALUE_FACET_SCAN
-      });
-      return runValueFacetsFromRuns(runs, axis, 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,
+    const quote = this.idQuote(em);
+    const limit = Math.max(0, opts?.limit ?? RUN_VALUE_FACET_LIMIT);
+    const offset = Math.max(0, opts?.offset ?? 0);
+    if (limit === 0) return [];
+    const runs = this.runSubquery(em, query, axis);
+    const { source, valueExpr } = this.valueSource(em, axis, runs, quote);
+    const conditions = [
+      this.searchCondition(valueExpr, opts?.search)
+    ].filter((part) => part !== void 0);
+    const where = conditions.length ? ` where ${conditions.join(" and ")}` : "";
+    const engineLast = axis.field === "tag" ? `case when ${valueExpr} like '${ENGINE_MINTED_TAG_PREFIXES[0]}%' then 1 else 0 end, ` : "";
+    const sql = `select ${valueExpr} as value, count(*) as count from ${source}${where} group by ${valueExpr} order by ${engineLast}count(*) desc, ${valueExpr} asc limit ${limit} offset ${offset}`;
+    const rows = await em.getConnection().execute(sql);
+    return rows.map((row) => ({
+      // Blank and absent are the same thing to an operator on the origin axis — see facetOrigin.
+      value: axis.field === "origin" ? facetOrigin(row.value) : this.text(row.value),
       count: Number(row.count)
-    })), opts);
+    }));
+  }
+  /** The filtered run set as a derived table, carrying only the columns the axis needs. One source
+  *  of truth with `listRuns`: the same builder, the same predicates. */
+  runSubquery(em, query, axis) {
+    const meta = em.getMetadata().get(WorkflowRunEntity);
+    const idCol = meta.properties.id?.fieldNames?.[0] ?? "id";
+    const columns = axis.field === "tag" ? [
+      `r.${idCol}`,
+      `r.${this.tagsColumn(em)}`
+    ] : axisIsRunColumn(axis) ? [
+      `r.${meta.properties[axis.field]?.fieldNames?.[0] ?? axis.field}`
+    ] : [
+      `r.${idCol}`
+    ];
+    return this.runQueryBuilder(em, query, this.runWhere(query)).select(columns).getFormattedQuery();
+  }
+  /** Where the values of an axis come from, and how to name one — a column of the filtered runs, an
+  *  element of their tags array, or a row of the attribute side table. */
+  valueSource(em, axis, runs, quote) {
+    const meta = em.getMetadata().get(WorkflowRunEntity);
+    if (axisIsRunColumn(axis)) {
+      const col = meta.properties[axis.field]?.fieldNames?.[0] ?? axis.field;
+      return {
+        source: `(${runs}) as ${quote("r")}`,
+        valueExpr: `${quote("r")}.${quote(col)}`
+      };
+    }
+    if (axis.field === "tag") {
+      return {
+        source: `(${runs}) as ${quote("r")} ${this.jsonArrayJoin(em, `${quote("r")}.${quote(this.tagsColumn(em))}`, quote)}`,
+        valueExpr: `${quote("t")}.${quote("value")}`
+      };
+    }
+    const cols = this.attributeColumns(em);
+    const idCol = meta.properties.id?.fieldNames?.[0] ?? "id";
+    const a = quote("a");
+    const join = `${quote(cols.table)} as ${a} join (${runs}) as ${quote("r")} on ${a}.${quote(cols.runId)} = ${quote("r")}.${quote(idCol)}`;
+    if (axis.field === "attributeKey") {
+      return {
+        source: join,
+        valueExpr: `${a}.${quote(cols.key)}`
+      };
+    }
+    const key = axis.key.replace(/'/g, "''");
+    return {
+      source: `${join} and ${a}.${quote(cols.key)} = '${key}'`,
+      valueExpr: `coalesce(${a}.${quote(cols.strValue)}, cast(${a}.${quote(cols.numValue)} as char))`
+    };
+  }
+  /**
+  * The dialect's way of turning a JSON array column into one row per element — the only portable
+  * thing about it being that all three have one. Without it a tag picker cannot be grouped in the
+  * database at all, and falls back to deduping a bounded page of runs in memory: counts that
+  * describe a sample, and an order that cannot be paged.
+  */
+  jsonArrayJoin(em, colRef, quote) {
+    const platform = String(em.getPlatform().constructor.name).toLowerCase();
+    const t = quote("t");
+    if (platform.includes("postgre")) {
+      return `cross join lateral jsonb_array_elements_text(${colRef}::jsonb) as ${t}(${quote("value")})`;
+    }
+    if (platform.includes("mysql") || platform.includes("mariadb")) {
+      return `join json_table(cast(${colRef} as json), '$[*]' columns (${quote("value")} varchar(512) path '$')) as ${t}`;
+    }
+    return `join json_each(${colRef}) as ${t}`;
+  }
+  /** `lower(value) like '%needle%'` — the picker's search box, applied BEFORE the page is cut so a
+  *  match outside the top slice is still reachable. */
+  searchCondition(valueExpr, search) {
+    const needle = search?.trim().toLowerCase();
+    if (!needle) return void 0;
+    const escaped = needle.replace(/'/g, "''").replace(/[%_]/g, (c) => `\\${c}`);
+    return `lower(${valueExpr}) like '%${escaped}%'`;
+  }
+  /** A grouped value as the string a picker shows. Drivers return a JSON element or a numeric
+  *  attribute as something other than a string; `null` stays null (the absent bucket). */
+  text(value) {
+    return value === null || value === void 0 ? null : String(value);
   }
   /** 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):