@dudousxd/nestjs-durable-core 0.67.0 → 0.68.0

package/dist/index.cjs

@@ -45,6 +45,8 @@ __export(index_exports, {
   LEGACY_V1_PROTOCOL: () => LEGACY_V1_PROTOCOL,
   NonDeterminismError: () => NonDeterminismError,
   QueueController: () => QueueController,
+  RUN_VALUE_FACET_LIMIT: () => RUN_VALUE_FACET_LIMIT,
+  RUN_VALUE_FACET_SCAN: () => RUN_VALUE_FACET_SCAN,
   RemoteStepError: () => RemoteStepError,
   RemoteStepTimeout: () => RemoteStepTimeout,
   RemoteWorkflowExecutor: () => RemoteWorkflowExecutor,
@@ -67,6 +69,8 @@ __export(index_exports, {
   applyAttributeQuery: () => applyAttributeQuery,
   attributeColumnFor: () => attributeColumnFor,
   attributeOperand: () => attributeOperand,
+  attributePredicateOperands: () => attributePredicateOperands,
+  axisIsRunColumn: () => axisIsRunColumn,
   bindWorkflowClass: () => bindWorkflowClass,
   breakpointToken: () => breakpointToken,
   buildWorkflowDirectory: () => buildWorkflowDirectory,
@@ -100,6 +104,7 @@ __export(index_exports, {
   log: () => log,
   matchesAttributes: () => matchesAttributes,
   mergeRunFacetRows: () => mergeRunFacetRows,
+  mergeRunValueFacetRows: () => mergeRunValueFacetRows,
   missingCapabilities: () => missingCapabilities,
   negotiate: () => negotiate,
   normalizeAttributeRows: () => normalizeAttributeRows,
@@ -118,6 +123,7 @@ __export(index_exports, {
   runInWorkflowCtx: () => runInWorkflowCtx,
   runSchedules: () => runSchedules,
   runStepHandler: () => runStepHandler,
+  runValueFacetsFromRuns: () => runValueFacetsFromRuns,
   sanitizeQueueToken: () => sanitizeQueueToken,
   scheduledRunId: () => scheduledRunId,
   sqlComparator: () => sqlComparator,
@@ -1885,12 +1891,10 @@ var SingletonGate = class {
       ]
     })).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id));
     for (const next of gated.slice(0, cfg.limit ?? 1)) {
-      if (next.wakeAt != null) {
-        await this.deps.store.updateRun(next.id, {
-          wakeAt: void 0,
-          updatedAt: /* @__PURE__ */ new Date()
-        }).catch(() => void 0);
-      }
+      await this.deps.store.updateRun(next.id, {
+        wakeAt: this.deps.clock(),
+        updatedAt: /* @__PURE__ */ new Date()
+      }).catch(() => void 0);
       this.deps.dispatch(next.id);
     }
   }
@@ -6135,6 +6139,76 @@ function mergeRunFacetRows(rows) {
 }
 __name(mergeRunFacetRows, "mergeRunFacetRows");
 
+// src/run-value-facets.ts
+var RUN_VALUE_FACET_LIMIT = 100;
+var RUN_VALUE_FACET_SCAN = 5e3;
+function axisIsRunColumn(axis) {
+  return axis.field === "workflow" || axis.field === "status" || axis.field === "origin" || axis.field === "namespace";
+}
+__name(axisIsRunColumn, "axisIsRunColumn");
+function valuesOf(run, axis) {
+  switch (axis.field) {
+    case "workflow":
+      return [
+        run.workflow
+      ];
+    case "status":
+      return [
+        run.status
+      ];
+    case "origin":
+      return [
+        facetOrigin(run.origin)
+      ];
+    case "namespace":
+      return run.namespace === void 0 ? [] : [
+        run.namespace
+      ];
+    case "tag":
+      return run.tags ?? [];
+    case "attributeKey":
+      return Object.keys(run.searchAttributes ?? {});
+    case "attributeValue": {
+      const value = run.searchAttributes?.[axis.key];
+      return value === void 0 ? [] : [
+        String(value)
+      ];
+    }
+  }
+}
+__name(valuesOf, "valuesOf");
+function mergeRunValueFacetRows(rows, opts) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const value = row.value ?? null;
+    counts.set(value, (counts.get(value) ?? 0) + Number(row.count));
+  }
+  const merged = [
+    ...counts
+  ].map(([value, count]) => ({
+    value,
+    count
+  })).filter((row) => row.count > 0).sort((a, b) => {
+    if (b.count !== a.count) return b.count - a.count;
+    if (a.value === null) return 1;
+    if (b.value === null) return -1;
+    return a.value.localeCompare(b.value);
+  });
+  return merged.slice(0, opts?.limit ?? RUN_VALUE_FACET_LIMIT);
+}
+__name(mergeRunValueFacetRows, "mergeRunValueFacetRows");
+function runValueFacetsFromRuns(runs, axis, opts) {
+  const rows = [];
+  for (const run of runs) {
+    for (const value of valuesOf(run, axis)) rows.push({
+      value,
+      count: 1
+    });
+  }
+  return mergeRunValueFacetRows(rows, opts);
+}
+__name(runValueFacetsFromRuns, "runValueFacetsFromRuns");
+
 // src/run-gateway.ts
 var RunGateway = class {
   static {
@@ -6156,11 +6230,21 @@ var CodecStateStore = class {
   * of resolving to a silently wrong empty result.
   */
   runFacets;
+  /**
+  * Forwarded verbatim, and safe to: the axes a value facet enumerates are searchable metadata
+  * (workflow, status, origin, namespace, tags, search attributes), none of which the codec encodes.
+  * Bound the same conditional way as {@link runFacets} so absence is reported, not faked.
+  */
+  runValueFacets;
   constructor(inner, codec) {
     this.inner = inner;
     this.codec = codec;
     const facets = inner.runFacets;
     if (facets) this.runFacets = (query) => facets.call(inner, query);
+    const valueFacets = inner.runValueFacets;
+    if (valueFacets) {
+      this.runValueFacets = (axis, query, opts) => valueFacets.call(inner, axis, query, opts);
+    }
   }
   enc(v) {
     return v === void 0 ? void 0 : this.codec.encode(v);
@@ -6515,8 +6599,10 @@ async function runSchedules(engine, schedules, nowMs, opts) {
 __name(runSchedules, "runSchedules");
 
 // src/search-attributes.ts
-function compare(actual, op, expected) {
-  switch (op) {
+function compare(actual, filter) {
+  if (filter.op === "in") return filter.values.some((v) => actual === v);
+  const expected = filter.value;
+  switch (filter.op) {
     case "eq":
       return actual === expected;
     case "ne":
@@ -6535,7 +6621,7 @@ __name(compare, "compare");
 function matchesAttributes(attributes, filters) {
   if (!filters?.length) return true;
   if (!attributes) return false;
-  return filters.every((f) => f.key in attributes && compare(attributes[f.key], f.op, f.value));
+  return filters.every((f) => f.key in attributes && compare(attributes[f.key], f));
 }
 __name(matchesAttributes, "matchesAttributes");
 function applyAttributeQuery(rows, query) {
@@ -6601,6 +6687,30 @@ function attributeOperand(filter) {
   return filter.value;
 }
 __name(attributeOperand, "attributeOperand");
+function attributePredicateOperands(filter) {
+  if (filter.op === "in") {
+    return filter.values.map((value) => {
+      const scalar = {
+        key: filter.key,
+        op: "eq",
+        value
+      };
+      return {
+        column: attributeColumnFor(scalar),
+        comparator: "=",
+        operand: attributeOperand(scalar)
+      };
+    });
+  }
+  return [
+    {
+      column: attributeColumnFor(filter),
+      comparator: sqlComparator(filter.op),
+      operand: attributeOperand(filter)
+    }
+  ];
+}
+__name(attributePredicateOperands, "attributePredicateOperands");
 
 // src/search-attributes-schema.ts
 function readSearchAttributes(schema, run) {
@@ -6828,33 +6938,27 @@ var InMemoryStateStore = class {
     const byRun = this.attributeIndex.get(f.key);
     const out = /* @__PURE__ */ new Set();
     if (!byRun) return out;
-    const numeric = typeof f.value === "number";
-    const operand = typeof f.value === "boolean" ? f.value ? "true" : "false" : f.value;
+    const comparisons = attributePredicateOperands(f);
     for (const row of byRun.values()) {
-      const actual = numeric ? row.numValue : row.strValue;
-      if (actual == null) continue;
-      let ok = false;
-      switch (f.op) {
-        case "eq":
-          ok = actual === operand;
-          break;
-        case "ne":
-          ok = actual !== operand;
-          break;
-        case "gt":
-          ok = actual > operand;
-          break;
-        case "gte":
-          ok = actual >= operand;
-          break;
-        case "lt":
-          ok = actual < operand;
-          break;
-        case "lte":
-          ok = actual <= operand;
-          break;
-      }
-      if (ok) out.add(row.runId);
+      const matched = comparisons.some(({ column, comparator, operand }) => {
+        const actual = column === "numValue" ? row.numValue : row.strValue;
+        if (actual == null) return false;
+        switch (comparator) {
+          case "=":
+            return actual === operand;
+          case "<>":
+            return actual !== operand;
+          case ">":
+            return actual > operand;
+          case ">=":
+            return actual >= operand;
+          case "<":
+            return actual < operand;
+          default:
+            return actual <= operand;
+        }
+      });
+      if (matched) out.add(row.runId);
     }
     return out;
   }
@@ -6865,12 +6969,20 @@ var InMemoryStateStore = class {
       ...this.runs.values()
     ];
     if (query.workflow) runs = runs.filter((r) => r.workflow === query.workflow);
+    if (query.workflows) runs = runs.filter((r) => query.workflows?.includes(r.workflow));
     if (query.status) runs = runs.filter((r) => r.status === query.status);
     if (query.statuses) runs = runs.filter((r) => query.statuses?.includes(r.status));
     if (query.tag) runs = runs.filter((r) => r.tags?.includes(query.tag));
+    if (query.tags) runs = runs.filter((r) => r.tags?.some((t) => query.tags?.includes(t)));
     if (query.namespace !== void 0) runs = runs.filter((r) => r.namespace === query.namespace);
+    if (query.namespaces) {
+      runs = runs.filter((r) => r.namespace !== void 0 && query.namespaces?.includes(r.namespace));
+    }
     if (query.origin === null) runs = runs.filter((r) => r.origin == null);
     else if (query.origin !== void 0) runs = runs.filter((r) => r.origin === query.origin);
+    if (query.origins) {
+      runs = runs.filter((r) => query.origins?.includes(r.origin ?? null));
+    }
     if (query.attributes?.length) {
       let candidates = null;
       for (const f of query.attributes) {
@@ -6907,6 +7019,16 @@ var InMemoryStateStore = class {
       count: 1
     })));
   }
+  /** Counted over the newest `scan` matching runs for EVERY axis, not just `tag`: this store holds
+  *  its runs in a Map with no index to group by, so the bound that the SQL stores need only for tags
+  *  is the honest one to apply here throughout. */
+  async runValueFacets(axis, query, opts) {
+    const runs = await this.listRuns({
+      ...query,
+      limit: opts?.scan ?? RUN_VALUE_FACET_SCAN
+    });
+    return runValueFacetsFromRuns(runs, axis, opts);
+  }
   async listCheckpoints(runId) {
     const rows = [
       ...this.checkpoints.values()
@@ -7008,6 +7130,8 @@ var InMemoryTransport = class {
   LEGACY_V1_PROTOCOL,
   NonDeterminismError,
   QueueController,
+  RUN_VALUE_FACET_LIMIT,
+  RUN_VALUE_FACET_SCAN,
   RemoteStepError,
   RemoteStepTimeout,
   RemoteWorkflowExecutor,
@@ -7030,6 +7154,8 @@ var InMemoryTransport = class {
   applyAttributeQuery,
   attributeColumnFor,
   attributeOperand,
+  attributePredicateOperands,
+  axisIsRunColumn,
   bindWorkflowClass,
   breakpointToken,
   buildWorkflowDirectory,
@@ -7063,6 +7189,7 @@ var InMemoryTransport = class {
   log,
   matchesAttributes,
   mergeRunFacetRows,
+  mergeRunValueFacetRows,
   missingCapabilities,
   negotiate,
   normalizeAttributeRows,
@@ -7081,6 +7208,7 @@ var InMemoryTransport = class {
   runInWorkflowCtx,
   runSchedules,
   runStepHandler,
+  runValueFacetsFromRuns,
   sanitizeQueueToken,
   scheduledRunId,
   sqlComparator,