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

package/dist/index.cjs

@@ -22,13 +22,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   BufferedEventEntity: () => BufferedEventEntity,
+  BufferedEventRepository: () => BufferedEventRepository,
   BufferedSignalEntity: () => BufferedSignalEntity,
+  BufferedSignalRepository: () => BufferedSignalRepository,
   ENTITIES: () => ENTITIES,
   MikroOrmStateStore: () => MikroOrmStateStore,
   RunAttributeEntity: () => RunAttributeEntity,
+  RunAttributeRepository: () => RunAttributeRepository,
   SignalWaiterEntity: () => SignalWaiterEntity,
+  SignalWaiterRepository: () => SignalWaiterRepository,
   StepCheckpointEntity: () => StepCheckpointEntity,
+  StepCheckpointRepository: () => StepCheckpointRepository,
   WorkflowRunEntity: () => WorkflowRunEntity,
+  WorkflowRunRepository: () => WorkflowRunRepository,
   durableEntities: () => durableEntities,
   durableManagedTables: () => durableManagedTables,
   ensureMikroOrmDurableSchema: () => ensureMikroOrmDurableSchema
@@ -36,7 +42,42 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/entities.ts
+var import_core2 = require("@mikro-orm/core");
+
+// src/repositories.ts
 var import_core = require("@mikro-orm/core");
+var WorkflowRunRepository = class extends import_core.EntityRepository {
+  static {
+    __name(this, "WorkflowRunRepository");
+  }
+};
+var StepCheckpointRepository = class extends import_core.EntityRepository {
+  static {
+    __name(this, "StepCheckpointRepository");
+  }
+};
+var RunAttributeRepository = class extends import_core.EntityRepository {
+  static {
+    __name(this, "RunAttributeRepository");
+  }
+};
+var SignalWaiterRepository = class extends import_core.EntityRepository {
+  static {
+    __name(this, "SignalWaiterRepository");
+  }
+};
+var BufferedSignalRepository = class extends import_core.EntityRepository {
+  static {
+    __name(this, "BufferedSignalRepository");
+  }
+};
+var BufferedEventRepository = class extends import_core.EntityRepository {
+  static {
+    __name(this, "BufferedEventRepository");
+  }
+};
+
+// src/entities.ts
 function snakeCase(property) {
   return property.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
 }
@@ -51,6 +92,7 @@ var WorkflowRunEntity = class {
   static {
     __name(this, "WorkflowRunEntity");
   }
+  [import_core2.EntityRepositoryType];
   id;
   workflow;
   workflowVersion;
@@ -75,6 +117,7 @@ var StepCheckpointEntity = class {
   static {
     __name(this, "StepCheckpointEntity");
   }
+  [import_core2.EntityRepositoryType];
   runId;
   seq;
   name;
@@ -97,6 +140,7 @@ var RunAttributeEntity = class {
   static {
     __name(this, "RunAttributeEntity");
   }
+  [import_core2.EntityRepositoryType];
   runId;
   key;
   strValue;
@@ -106,6 +150,7 @@ var SignalWaiterEntity = class {
   static {
     __name(this, "SignalWaiterEntity");
   }
+  [import_core2.EntityRepositoryType];
   token;
   runId;
   seq;
@@ -115,6 +160,7 @@ var BufferedSignalEntity = class {
   static {
     __name(this, "BufferedSignalEntity");
   }
+  [import_core2.EntityRepositoryType];
   id;
   token;
   payload;
@@ -123,6 +169,7 @@ var BufferedEventEntity = class {
   static {
     __name(this, "BufferedEventEntity");
   }
+  [import_core2.EntityRepositoryType];
   id;
   name;
   payload;
@@ -137,9 +184,12 @@ function namespaceFilterCond(args) {
 __name(namespaceFilterCond, "namespaceFilterCond");
 function durableEntities(options = {}) {
   const col = columnNamer(options.naming ?? "snake_case");
-  const workflowRuns = new import_core.EntitySchema({
+  const workflowRuns = new import_core2.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.
@@ -300,9 +350,10 @@ function durableEntities(options = {}) {
       }
     }
   });
-  const stepCheckpoints = new import_core.EntitySchema({
+  const stepCheckpoints = new import_core2.EntitySchema({
     class: StepCheckpointEntity,
     tableName: "durable_step_checkpoints",
+    repository: /* @__PURE__ */ __name(() => StepCheckpointRepository, "repository"),
     properties: {
       runId: {
         type: "string",
@@ -388,9 +439,10 @@ function durableEntities(options = {}) {
       }
     }
   });
-  const runAttributes = new import_core.EntitySchema({
+  const runAttributes = new import_core2.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: [
@@ -433,9 +485,10 @@ function durableEntities(options = {}) {
       }
     }
   });
-  const signalWaiters = new import_core.EntitySchema({
+  const signalWaiters = new import_core2.EntitySchema({
     class: SignalWaiterEntity,
     tableName: "durable_signal_waiters",
+    repository: /* @__PURE__ */ __name(() => SignalWaiterRepository, "repository"),
     properties: {
       token: {
         type: "string",
@@ -460,9 +513,10 @@ function durableEntities(options = {}) {
       }
     }
   });
-  const bufferedSignals = new import_core.EntitySchema({
+  const bufferedSignals = new import_core2.EntitySchema({
     class: BufferedSignalEntity,
     tableName: "durable_buffered_signals",
+    repository: /* @__PURE__ */ __name(() => BufferedSignalRepository, "repository"),
     properties: {
       id: {
         type: "integer",
@@ -482,9 +536,10 @@ function durableEntities(options = {}) {
       }
     }
   });
-  const bufferedEvents = new import_core.EntitySchema({
+  const bufferedEvents = new import_core2.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: [
@@ -533,7 +588,7 @@ var ENTITIES = durableEntities();
 
 // src/mikro-orm-state-store.ts
 var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
-var import_core2 = require("@mikro-orm/core");
+var import_core3 = require("@mikro-orm/core");
 
 // src/schema.ts
 var import_node_crypto = require("crypto");
@@ -1016,20 +1071,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) {
@@ -1037,6 +1119,7 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
         $in: query.statuses
       };
     }
+    if (and.length) where.$and = and;
     return where;
   }
   async listRuns(query) {
@@ -1045,7 +1128,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);
@@ -1071,17 +1154,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. */
@@ -1093,7 +1182,7 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     const rows = await this.runQueryBuilder(em, query, this.runWhere(query)).select([
       `r.${statusCol}`,
       `r.${originCol}`
-    ]).addSelect((0, import_core2.raw)("count(*) as count")).groupBy([
+    ]).addSelect((0, import_core3.raw)("count(*) as count")).groupBy([
       `r.${statusCol}`,
       `r.${originCol}`
     ]).execute();
@@ -1102,20 +1191,50 @@ 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 (!(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);
+    }
+    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((0, import_core3.raw)("count(*) as count")).groupBy([
+      `r.${col}`
+    ]).execute();
+    return (0, import_nestjs_durable_core.mergeRunValueFacetRows)(rows.map((row) => ({
+      value: row[axis.field] ?? null,
+      count: Number(row.count)
+    })), 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 = (0, import_nestjs_durable_core.attributeColumnFor)(f) === "numValue" ? cols.numValue : cols.strValue;
-    const cmp = (0, import_nestjs_durable_core.sqlComparator)(f.op);
-    const operand = (0, import_nestjs_durable_core.attributeOperand)(f);
-    const literal = typeof operand === "number" ? String(operand) : `'${String(operand).replace(/'/g, "''")}'`;
+    const comparisons = (0, import_nestjs_durable_core.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
@@ -1396,13 +1515,19 @@ __name(fromCheckpointEntity, "fromCheckpointEntity");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BufferedEventEntity,
+  BufferedEventRepository,
   BufferedSignalEntity,
+  BufferedSignalRepository,
   ENTITIES,
   MikroOrmStateStore,
   RunAttributeEntity,
+  RunAttributeRepository,
   SignalWaiterEntity,
+  SignalWaiterRepository,
   StepCheckpointEntity,
+  StepCheckpointRepository,
   WorkflowRunEntity,
+  WorkflowRunRepository,
   durableEntities,
   durableManagedTables,
   ensureMikroOrmDurableSchema