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

package/dist/index.d.ts

@@ -1,6 +1,34 @@
 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 { EntityRepository, EntityRepositoryType, EntitySchema, MikroORM } from '@mikro-orm/core';
+import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+
+/**
+ * Custom repositories for the durable entities, so a host app can `@InjectRepository`/inject a
+ * `WorkflowRunRepository` by type instead of repeating `em.find(WorkflowRunEntity, …)` with the
+ * entity class as the first argument everywhere.
+ *
+ * They are wired per-schema inside `durableEntities()` (not with a decorator), because that factory
+ * can be called more than once with different column naming and each call must produce schemas that
+ * still point at these classes. Each entity also declares `[EntityRepositoryType]`, which is what
+ * makes `em.getRepository(WorkflowRunEntity)` resolve to the specific type rather than the base
+ * `EntityRepository`.
+ *
+ * The bodies are intentionally empty: the durable engine's own queries go through
+ * `MikroOrmStateStore`, and a durable-owned query added here would be a second, unversioned read
+ * path over the same tables. They exist as an injectable, correctly-typed handle for host code.
+ */
+declare class WorkflowRunRepository extends EntityRepository<WorkflowRunEntity> {
+}
+declare class StepCheckpointRepository extends EntityRepository<StepCheckpointEntity> {
+}
+declare class RunAttributeRepository extends EntityRepository<RunAttributeEntity> {
+}
+declare class SignalWaiterRepository extends EntityRepository<SignalWaiterEntity> {
+}
+declare class BufferedSignalRepository extends EntityRepository<BufferedSignalEntity> {
+}
+declare class BufferedEventRepository extends EntityRepository<BufferedEventEntity> {
+}
 
 /**
  * How property names map to physical column names. The durable tables are adapter-agnostic: a run
@@ -16,6 +44,7 @@ import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepChec
  */
 type DurableColumnNaming = 'snake_case' | 'preserve' | ((property: string) => string);
 declare class WorkflowRunEntity {
+    [EntityRepositoryType]?: WorkflowRunRepository;
     id: string;
     workflow: string;
     workflowVersion: string;
@@ -37,6 +66,7 @@ declare class WorkflowRunEntity {
     updatedAt: Date;
 }
 declare class StepCheckpointEntity {
+    [EntityRepositoryType]?: StepCheckpointRepository;
     runId: string;
     seq: number;
     name: string;
@@ -62,18 +92,21 @@ declare class StepCheckpointEntity {
  * `numValue`, strings/booleans in `strValue` (booleans as "true"/"false"); see normalizeAttributeRows.
  */
 declare class RunAttributeEntity {
+    [EntityRepositoryType]?: RunAttributeRepository;
     runId: string;
     key: string;
     strValue?: string | null;
     numValue?: number | null;
 }
 declare class SignalWaiterEntity {
+    [EntityRepositoryType]?: SignalWaiterRepository;
     token: string;
     runId: string;
     seq: number;
     parallelGroup?: string | null;
 }
 declare class BufferedSignalEntity {
+    [EntityRepositoryType]?: BufferedSignalRepository;
     id: number;
     token: string;
     payload?: unknown;
@@ -82,6 +115,7 @@ declare class BufferedSignalEntity {
  *  caller-minted `id` (a uuid, not autoincrement — `removeBufferedEvent` targets it directly), not by
  *  `runId`: events are name-based pub/sub, not tied to any one run. */
 declare class BufferedEventEntity {
+    [EntityRepositoryType]?: BufferedEventRepository;
     id: string;
     name: string;
     payload?: unknown;
@@ -153,7 +187,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
@@ -242,4 +288,4 @@ declare function durableManagedTables(): string[];
  */
 declare function ensureMikroOrmDurableSchema(orm: MikroORM): Promise<void>;
 
-export { BufferedEventEntity, BufferedSignalEntity, type DurableColumnNaming, ENTITIES, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, SignalWaiterEntity, StepCheckpointEntity, WorkflowRunEntity, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema };
+export { BufferedEventEntity, BufferedEventRepository, BufferedSignalEntity, BufferedSignalRepository, type DurableColumnNaming, ENTITIES, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, RunAttributeRepository, SignalWaiterEntity, SignalWaiterRepository, StepCheckpointEntity, StepCheckpointRepository, WorkflowRunEntity, WorkflowRunRepository, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema };

package/dist/index.js

@@ -2,7 +2,42 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/entities.ts
-import { EntitySchema } from "@mikro-orm/core";
+import { EntityRepositoryType, EntitySchema } from "@mikro-orm/core";
+
+// src/repositories.ts
+import { EntityRepository } from "@mikro-orm/core";
+var WorkflowRunRepository = class extends EntityRepository {
+  static {
+    __name(this, "WorkflowRunRepository");
+  }
+};
+var StepCheckpointRepository = class extends EntityRepository {
+  static {
+    __name(this, "StepCheckpointRepository");
+  }
+};
+var RunAttributeRepository = class extends EntityRepository {
+  static {
+    __name(this, "RunAttributeRepository");
+  }
+};
+var SignalWaiterRepository = class extends EntityRepository {
+  static {
+    __name(this, "SignalWaiterRepository");
+  }
+};
+var BufferedSignalRepository = class extends EntityRepository {
+  static {
+    __name(this, "BufferedSignalRepository");
+  }
+};
+var BufferedEventRepository = class extends EntityRepository {
+  static {
+    __name(this, "BufferedEventRepository");
+  }
+};
+
+// src/entities.ts
 function snakeCase(property) {
   return property.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
 }
@@ -17,6 +52,7 @@ var WorkflowRunEntity = class {
   static {
     __name(this, "WorkflowRunEntity");
   }
+  [EntityRepositoryType];
   id;
   workflow;
   workflowVersion;
@@ -41,6 +77,7 @@ var StepCheckpointEntity = class {
   static {
     __name(this, "StepCheckpointEntity");
   }
+  [EntityRepositoryType];
   runId;
   seq;
   name;
@@ -63,6 +100,7 @@ var RunAttributeEntity = class {
   static {
     __name(this, "RunAttributeEntity");
   }
+  [EntityRepositoryType];
   runId;
   key;
   strValue;
@@ -72,6 +110,7 @@ var SignalWaiterEntity = class {
   static {
     __name(this, "SignalWaiterEntity");
   }
+  [EntityRepositoryType];
   token;
   runId;
   seq;
@@ -81,6 +120,7 @@ var BufferedSignalEntity = class {
   static {
     __name(this, "BufferedSignalEntity");
   }
+  [EntityRepositoryType];
   id;
   token;
   payload;
@@ -89,6 +129,7 @@ var BufferedEventEntity = class {
   static {
     __name(this, "BufferedEventEntity");
   }
+  [EntityRepositoryType];
   id;
   name;
   payload;
@@ -106,6 +147,9 @@ function durableEntities(options = {}) {
   const workflowRuns = new EntitySchema({
     class: WorkflowRunEntity,
     tableName: "durable_workflow_runs",
+    // Wired per schema rather than once on the class: `durableEntities` can be called again with a
+    // different `naming`, and each call builds a distinct EntitySchema over the same class.
+    repository: /* @__PURE__ */ __name(() => WorkflowRunRepository, "repository"),
     // Global filter: confines every read to the tenant's namespace when the store is scoped.
     // The `cond` returns `{}` (no-op) when the `namespace` arg is `undefined`, so an unscoped
     // (operator / control-plane) store sees all rows unchanged — existing behaviour is preserved.
@@ -269,6 +313,7 @@ function durableEntities(options = {}) {
   const stepCheckpoints = new EntitySchema({
     class: StepCheckpointEntity,
     tableName: "durable_step_checkpoints",
+    repository: /* @__PURE__ */ __name(() => StepCheckpointRepository, "repository"),
     properties: {
       runId: {
         type: "string",
@@ -357,6 +402,7 @@ function durableEntities(options = {}) {
   const runAttributes = new EntitySchema({
     class: RunAttributeEntity,
     tableName: "durable_run_attributes",
+    repository: /* @__PURE__ */ __name(() => RunAttributeRepository, "repository"),
     // The search-attribute EXISTS join (see the class docstring) pushes equality/range predicates down
     // onto `(key, numValue)` / `(key, strValue)`; mirror the Prisma adapter so those scans stay indexed.
     indexes: [
@@ -402,6 +448,7 @@ function durableEntities(options = {}) {
   const signalWaiters = new EntitySchema({
     class: SignalWaiterEntity,
     tableName: "durable_signal_waiters",
+    repository: /* @__PURE__ */ __name(() => SignalWaiterRepository, "repository"),
     properties: {
       token: {
         type: "string",
@@ -429,6 +476,7 @@ function durableEntities(options = {}) {
   const bufferedSignals = new EntitySchema({
     class: BufferedSignalEntity,
     tableName: "durable_buffered_signals",
+    repository: /* @__PURE__ */ __name(() => BufferedSignalRepository, "repository"),
     properties: {
       id: {
         type: "integer",
@@ -451,6 +499,7 @@ function durableEntities(options = {}) {
   const bufferedEvents = new EntitySchema({
     class: BufferedEventEntity,
     tableName: "durable_buffered_events",
+    repository: /* @__PURE__ */ __name(() => BufferedEventRepository, "repository"),
     // `(name, publishedAt)` serves both `listBufferedEvents`'s name-scoped scan and its oldest-first
     // ordering in one index.
     indexes: [
@@ -498,7 +547,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";
@@ -976,8 +1026,10 @@ 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;
@@ -1000,23 +1052,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();
@@ -1033,6 +1078,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
@@ -1326,13 +1410,19 @@ function fromCheckpointEntity(e) {
 __name(fromCheckpointEntity, "fromCheckpointEntity");
 export {
   BufferedEventEntity,
+  BufferedEventRepository,
   BufferedSignalEntity,
+  BufferedSignalRepository,
   ENTITIES,
   MikroOrmStateStore,
   RunAttributeEntity,
+  RunAttributeRepository,
   SignalWaiterEntity,
+  SignalWaiterRepository,
   StepCheckpointEntity,
+  StepCheckpointRepository,
   WorkflowRunEntity,
+  WorkflowRunRepository,
   durableEntities,
   durableManagedTables,
   ensureMikroOrmDurableSchema