@dudousxd/nestjs-durable-store-mikro-orm 0.20.0 → 0.22.0

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import * as _mikro_orm_core from '@mikro-orm/core';
 import { EntitySchema, MikroORM } from '@mikro-orm/core';
-import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
 
 /**
  * How property names map to physical column names. The durable tables are adapter-agnostic: a run
@@ -32,6 +32,7 @@ declare class WorkflowRunEntity {
     searchAttributes?: Record<string, string | number | boolean> | null;
     priority?: number | null;
     namespace: string;
+    origin?: string | null;
     createdAt: Date;
     updatedAt: Date;
 }
@@ -152,7 +153,19 @@ declare class MikroOrmStateStore implements StateStore {
     tryLockRun(runId: string, owner: string, leaseUntilMs: number, nowMs: number): Promise<boolean>;
     releaseRunLock(runId: string): Promise<void>;
     renewRunLock(runId: string, owner: string, leaseUntilMs: number): Promise<boolean>;
+    /** The `where` every run query shares — {@link listRuns} pages it, {@link runFacets} groups it.
+     *  Only the predicates MikroORM can express declaratively; `tag`/`attributes` need raw SQL and are
+     *  applied by the QueryBuilder path in both callers. */
+    private runWhere;
     listRuns(query: RunQuery): Promise<WorkflowRun[]>;
+    /** A QueryBuilder over `durable_workflow_runs` (root alias `r`) carrying `where` plus the two
+     *  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;
+    /** `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[]>;
     /** 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.d.ts

@@ -1,6 +1,6 @@
 import * as _mikro_orm_core from '@mikro-orm/core';
 import { EntitySchema, MikroORM } from '@mikro-orm/core';
-import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
 
 /**
  * How property names map to physical column names. The durable tables are adapter-agnostic: a run
@@ -32,6 +32,7 @@ declare class WorkflowRunEntity {
     searchAttributes?: Record<string, string | number | boolean> | null;
     priority?: number | null;
     namespace: string;
+    origin?: string | null;
     createdAt: Date;
     updatedAt: Date;
 }
@@ -152,7 +153,19 @@ declare class MikroOrmStateStore implements StateStore {
     tryLockRun(runId: string, owner: string, leaseUntilMs: number, nowMs: number): Promise<boolean>;
     releaseRunLock(runId: string): Promise<void>;
     renewRunLock(runId: string, owner: string, leaseUntilMs: number): Promise<boolean>;
+    /** The `where` every run query shares — {@link listRuns} pages it, {@link runFacets} groups it.
+     *  Only the predicates MikroORM can express declaratively; `tag`/`attributes` need raw SQL and are
+     *  applied by the QueryBuilder path in both callers. */
+    private runWhere;
     listRuns(query: RunQuery): Promise<WorkflowRun[]>;
+    /** A QueryBuilder over `durable_workflow_runs` (root alias `r`) carrying `where` plus the two
+     *  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;
+    /** `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[]>;
     /** 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

@@ -33,6 +33,7 @@ var WorkflowRunEntity = class {
   searchAttributes;
   priority;
   namespace;
+  origin;
   createdAt;
   updatedAt;
 };
@@ -230,6 +231,31 @@ function durableEntities(options = {}) {
         default: "default",
         fieldName: col("namespace")
       },
+      // Which library/module registered the workflow this run belongs to (e.g.
+      // `@dudousxd/nestjs-catalog-pipeline`), derived at registration time — never caller input.
+      //
+      // NULLABLE WITH NO DEFAULT, deliberately unlike `namespace` above. `namespace` can honestly
+      // default a pre-existing row to `'default'` (that IS the namespace an unscoped engine ran it
+      // in); an origin cannot be reconstructed after the fact, so a row written before this column
+      // existed must read back as `undefined` = "unknown". Stamping it `'app'`/`'unknown'` would be
+      // indistinguishable from a real registration in the dashboard's facet — a wrong origin is worse
+      // than an absent one. Two MikroORM specifics reinforce it: a `default` here would NOT be
+      // back-filled onto existing rows anyway (the DDL default only applies to new inserts, and a
+      // TypeScript field initialiser never runs for rows the ORM did not create), so a default would
+      // buy nothing but a lie for future rows.
+      //
+      // No index, unlike `namespace`. That one is on the HOT path — every poll tick filters
+      // `listPendingRuns`/`listDueTimers`/`listIncompleteRuns` by it, hence
+      // `durable_workflow_runs_namespace_status_idx`. Nothing filters by `origin` except the
+      // dashboard's `listRuns`, where it is ANDed with the `status`/`workflow` predicates that
+      // `durable_workflow_runs_status_wake_at_idx` / `..._workflow_status_idx` already bound. If a
+      // deployment ever makes origin-filtered listings hot, add the composite index in your own
+      // migration rather than here.
+      origin: {
+        type: "string",
+        nullable: true,
+        fieldName: col("origin")
+      },
       createdAt: {
         type: "Date",
         fieldName: col("createdAt")
@@ -472,7 +498,8 @@ __name(durableEntities, "durableEntities");
 var ENTITIES = durableEntities();
 
 // src/mikro-orm-state-store.ts
-import { attributeColumnFor, attributeOperand, normalizeAttributeRows, parseDuration, sqlComparator } from "@dudousxd/nestjs-durable-core";
+import { attributeColumnFor, attributeOperand, mergeRunFacetRows, normalizeAttributeRows, parseDuration, sqlComparator } from "@dudousxd/nestjs-durable-core";
+import { raw } from "@mikro-orm/core";
 
 // src/schema.ts
 import { createHash } from "node:crypto";
@@ -950,11 +977,14 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     });
     return affected === 1;
   }
-  async listRuns(query) {
-    const em = this.fork();
+  /** The `where` every run query shares — {@link listRuns} pages it, {@link runFacets} groups it.
+  *  Only the predicates MikroORM can express declaratively; `tag`/`attributes` need raw SQL and are
+  *  applied by the QueryBuilder path in both callers. */
+  runWhere(query) {
     const where = {};
     if (query.workflow) where.workflow = query.workflow;
     if (query.namespace !== void 0) where.namespace = query.namespace;
+    if (query.origin !== void 0) where.origin = query.origin;
     if (query.status && query.statuses) {
       where.$and = [
         {
@@ -973,23 +1003,16 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
         $in: query.statuses
       };
     }
+    return where;
+  }
+  async listRuns(query) {
+    const em = this.fork();
+    const where = this.runWhere(query);
     const orderBy = {
       createdAt: "desc"
     };
     if (query.tag || query.attributes?.length) {
-      if (this.scopeNamespace !== void 0) where.namespace = this.scopeNamespace;
-      const quote = this.idQuote(em);
-      const cols = this.attributeColumns(em);
-      const qb = em.createQueryBuilder(WorkflowRunEntity, "r").where(where).orderBy(orderBy);
-      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}'`);
-      }
-      for (const f of query.attributes ?? []) {
-        qb.andWhere(this.attributeExistsSql(f, quote, "r", cols));
-      }
+      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);
       const rows2 = await qb.getResultList();
@@ -1006,6 +1029,45 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     });
     return rows.map(fromRunEntity);
   }
+  /** A QueryBuilder over `durable_workflow_runs` (root alias `r`) carrying `where` plus the two
+  *  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. */
+  runQueryBuilder(em, query, where) {
+    if (this.scopeNamespace !== void 0) where.namespace = this.scopeNamespace;
+    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}'`);
+    }
+    for (const f of query.attributes ?? []) {
+      qb.andWhere(this.attributeExistsSql(f, quote, "r", cols));
+    }
+    return qb;
+  }
+  /** `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. */
+  async runFacets(query) {
+    const em = this.fork();
+    const meta = em.getMetadata().get(WorkflowRunEntity);
+    const statusCol = meta.properties.status?.fieldNames?.[0] ?? "status";
+    const originCol = meta.properties.origin?.fieldNames?.[0] ?? "origin";
+    const rows = await this.runQueryBuilder(em, query, this.runWhere(query)).select([
+      `r.${statusCol}`,
+      `r.${originCol}`
+    ]).addSelect(raw("count(*) as count")).groupBy([
+      `r.${statusCol}`,
+      `r.${originCol}`
+    ]).execute();
+    return mergeRunFacetRows(rows.map((r) => ({
+      ...r,
+      count: Number(r.count)
+    })));
+  }
   /** 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
@@ -1222,6 +1284,7 @@ function toRunEntity(run) {
   e.searchAttributes = run.searchAttributes ?? null;
   e.priority = run.priority ?? null;
   e.namespace = run.namespace ?? "default";
+  e.origin = run.origin ?? null;
   e.createdAt = run.createdAt;
   e.updatedAt = run.updatedAt;
   return e;
@@ -1245,6 +1308,8 @@ function fromRunEntity(e) {
     searchAttributes: e.searchAttributes ?? void 0,
     priority: e.priority ?? void 0,
     namespace: e.namespace,
+    // NULL (a row written before the column existed) surfaces as `undefined` = unknown origin.
+    origin: e.origin ?? void 0,
     createdAt: e.createdAt,
     updatedAt: e.updatedAt
   };