@dudousxd/nestjs-durable-store-mikro-orm 0.25.0 → 0.27.0

package/dist/index.cjs

@@ -29,6 +29,8 @@ __export(index_exports, {
   MikroOrmStateStore: () => MikroOrmStateStore,
   RunAttributeEntity: () => RunAttributeEntity,
   RunAttributeRepository: () => RunAttributeRepository,
+  ScheduleEntity: () => ScheduleEntity,
+  ScheduleRepository: () => ScheduleRepository,
   SignalWaiterEntity: () => SignalWaiterEntity,
   SignalWaiterRepository: () => SignalWaiterRepository,
   StepCheckpointEntity: () => StepCheckpointEntity,
@@ -76,6 +78,11 @@ var BufferedEventRepository = class extends import_core.EntityRepository {
     __name(this, "BufferedEventRepository");
   }
 };
+var ScheduleRepository = class extends import_core.EntityRepository {
+  static {
+    __name(this, "ScheduleRepository");
+  }
+};
 
 // src/entities.ts
 function snakeCase(property) {
@@ -175,6 +182,24 @@ var BufferedEventEntity = class {
   payload;
   publishedAt;
 };
+var ScheduleEntity = class {
+  static {
+    __name(this, "ScheduleEntity");
+  }
+  [import_core2.EntityRepositoryType];
+  id;
+  namespace;
+  workflow;
+  paused;
+  /** Epoch ms as a `bigint` column — exact, so `updateSchedule`'s compare-and-set can't be defeated
+  *  by a DATETIME's truncated milliseconds. Drivers may hand it back as a string. */
+  nextFireAt;
+  tags;
+  spec;
+  state;
+  createdAt;
+  updatedAt;
+};
 function namespaceFilterCond(args) {
   if (args?.namespace === void 0) return {};
   return {
@@ -574,13 +599,76 @@ function durableEntities(options = {}) {
       }
     }
   });
+  const schedules = new import_core2.EntitySchema({
+    class: ScheduleEntity,
+    tableName: "durable_schedules",
+    repository: /* @__PURE__ */ __name(() => ScheduleRepository, "repository"),
+    // The poll's "due by T" scan: `paused = false AND next_fire_at <= T ORDER BY next_fire_at`.
+    indexes: [
+      {
+        name: "durable_schedules_due_idx",
+        properties: [
+          "paused",
+          "nextFireAt"
+        ]
+      }
+    ],
+    properties: {
+      id: {
+        type: "string",
+        primary: true,
+        fieldName: col("id")
+      },
+      namespace: {
+        type: "string",
+        default: "default",
+        fieldName: col("namespace")
+      },
+      workflow: {
+        type: "string",
+        fieldName: col("workflow")
+      },
+      paused: {
+        type: "boolean",
+        default: false,
+        fieldName: col("paused")
+      },
+      nextFireAt: {
+        type: "bigint",
+        nullable: true,
+        fieldName: col("nextFireAt")
+      },
+      tags: {
+        type: "json",
+        nullable: true,
+        fieldName: col("tags")
+      },
+      spec: {
+        type: "json",
+        fieldName: col("spec")
+      },
+      state: {
+        type: "json",
+        fieldName: col("state")
+      },
+      createdAt: {
+        type: "Date",
+        fieldName: col("createdAt")
+      },
+      updatedAt: {
+        type: "Date",
+        fieldName: col("updatedAt")
+      }
+    }
+  });
   return [
     workflowRuns,
     stepCheckpoints,
     runAttributes,
     signalWaiters,
     bufferedSignals,
-    bufferedEvents
+    bufferedEvents,
+    schedules
   ];
 }
 __name(durableEntities, "durableEntities");
@@ -598,7 +686,8 @@ var DURABLE_TABLE_NAMES = /* @__PURE__ */ new Set([
   "durable_run_attributes",
   "durable_signal_waiters",
   "durable_buffered_signals",
-  "durable_buffered_events"
+  "durable_buffered_events",
+  "durable_schedules"
 ]);
 function durableManagedTables() {
   return [
@@ -895,71 +984,69 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
       id: runId
     });
   }
+  async deleteRuns(runIds) {
+    if (runIds.length === 0) return;
+    const runId = {
+      $in: runIds
+    };
+    await this.fork().transactional(async (tem) => {
+      await tem.nativeDelete(StepCheckpointEntity, {
+        runId
+      });
+      await tem.nativeDelete(SignalWaiterEntity, {
+        runId
+      });
+      await tem.nativeDelete(RunAttributeEntity, {
+        runId
+      });
+      await tem.nativeDelete(WorkflowRunEntity, {
+        id: runId
+      });
+    });
+  }
   async pruneTerminalRuns(policy, nowMs, limit) {
-    if (policy.statuses.length === 0 || limit <= 0) return 0;
+    const statuses = policy.statuses.filter((s) => import_nestjs_durable_core.TERMINAL_RUN_STATUSES.includes(s));
+    if (statuses.length === 0 || limit <= 0) return 0;
+    if (policy.maxAge == null && policy.maxCount == null) return 0;
     const em = this.fork();
-    const status = {
-      $in: policy.statuses
+    const meta = em.getMetadata().get(WorkflowRunEntity);
+    const idCol = meta.properties.id?.fieldNames?.[0] ?? "id";
+    const query = {
+      ...policy.scope ?? {},
+      statuses
     };
+    const scoped = /* @__PURE__ */ __name((extra) => this.runQueryBuilder(em, query, {
+      ...this.runWhere(query),
+      ...extra ?? {}
+    }).select([
+      `r.${idCol}`
+    ]), "scoped");
     const ids = /* @__PURE__ */ new Set();
     if (policy.maxAge != null) {
       const cutoff = new Date(nowMs - (0, import_nestjs_durable_core.parseDuration)(policy.maxAge));
-      const rows = await em.find(WorkflowRunEntity, {
-        status,
+      const rows = await scoped({
         updatedAt: {
           $lt: cutoff
         }
-      }, {
-        fields: [
-          "id"
-        ],
-        orderBy: {
-          updatedAt: "asc"
-        },
-        limit
-      });
-      for (const r of rows) ids.add(r.id);
+      }).orderBy({
+        "r.updatedAt": "asc"
+      }).limit(limit).execute();
+      for (const r of rows) ids.add(String(r[idCol] ?? r.id));
     }
     if (policy.maxCount != null && ids.size < limit) {
-      const rows = await em.find(WorkflowRunEntity, {
-        status
-      }, {
-        fields: [
-          "id"
-        ],
-        orderBy: {
-          updatedAt: "desc",
-          id: "desc"
-        },
-        limit,
-        offset: policy.maxCount
-      });
+      const rows = await scoped().orderBy({
+        "r.updatedAt": "desc",
+        "r.id": "desc"
+      }).limit(limit).offset(policy.maxCount).execute();
       for (const r of rows) {
-        ids.add(r.id);
         if (ids.size >= limit) break;
+        ids.add(String(r[idCol] ?? r.id));
       }
     }
-    if (ids.size === 0) return 0;
     const idList = [
       ...ids
     ].slice(0, limit);
-    const runId = {
-      $in: idList
-    };
-    await em.transactional(async (tem) => {
-      await tem.nativeDelete(StepCheckpointEntity, {
-        runId
-      });
-      await tem.nativeDelete(SignalWaiterEntity, {
-        runId
-      });
-      await tem.nativeDelete(RunAttributeEntity, {
-        runId
-      });
-      await tem.nativeDelete(WorkflowRunEntity, {
-        id: runId
-      });
-    });
+    await this.deleteRuns(idList);
     return idList.length;
   }
   async getCheckpoint(runId, seq) {
@@ -1171,6 +1258,11 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     const colExpr = this.jsonAsText(em, `${quote("r")}.${quote(this.tagsColumn(em))}`);
     return `${colExpr} LIKE '${pattern}'`;
   }
+  async countRuns(query) {
+    const em = this.fork();
+    const rows = await this.runQueryBuilder(em, query, this.runWhere(query)).select([]).addSelect((0, import_core3.raw)("count(*) as count")).execute();
+    return Number(rows[0]?.count ?? 0);
+  }
   /** `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. */
@@ -1191,83 +1283,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 (!(0, import_nestjs_durable_core.axisIsRunColumn)(axis)) {
-      return this.scannedValueFacets(axis, query, 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,
+    const quote = this.idQuote(em);
+    const limit = Math.max(0, opts?.limit ?? import_nestjs_durable_core.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 '${import_nestjs_durable_core.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" ? (0, import_nestjs_durable_core.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)}`
+    ] : (0, import_nestjs_durable_core.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 ((0, import_nestjs_durable_core.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 axes whose values do not live in a column of the run row: `tag` (inside a JSON array) and the
-  * two search-attribute axes (a side table). Both read the newest `scan` matching runs.
-  *
-  * Neither reads a run's PAYLOAD. The obvious implementation — page `listRuns` and count in
-  * memory — pulls `input`, `output` and `error` for every run in the window, which on a control
-  * plane with real payloads is tens of megabytes fetched to produce a list of a hundred short
-  * strings, every time a picker opens. These project the one column each question needs instead:
-  * the tags column, or the run ids that then drive one grouped read of the side table.
+  * 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.
   */
-  async scannedValueFacets(axis, query, opts) {
-    const em = this.fork();
-    const scan = opts?.scan ?? import_nestjs_durable_core.RUN_VALUE_FACET_SCAN;
-    const where = this.runWhere(query);
-    const runMeta = em.getMetadata().get(WorkflowRunEntity);
-    const idCol = runMeta.properties.id?.fieldNames?.[0] ?? "id";
-    if (axis.field === "tag") {
-      const tagsCol = this.tagsColumn(em);
-      const rows = await this.runQueryBuilder(em, query, where).select([
-        `r.${tagsCol}`
-      ]).orderBy({
-        createdAt: "desc"
-      }).limit(scan).execute();
-      const values = [];
-      for (const row of rows) {
-        const raw2 = row.tags ?? row[tagsCol];
-        const tags = typeof raw2 === "string" ? JSON.parse(raw2) : raw2;
-        if (!Array.isArray(tags)) continue;
-        for (const tag of tags) values.push({
-          value: String(tag),
-          count: 1
-        });
-      }
-      return (0, import_nestjs_durable_core.mergeRunValueFacetRows)(values, opts);
+  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")})`;
     }
-    const idRows = await this.runQueryBuilder(em, query, where).select([
-      `r.${idCol}`
-    ]).orderBy({
-      createdAt: "desc"
-    }).limit(scan).execute();
-    const runIds = idRows.map((row) => String(row.id ?? row[idCol]));
-    if (runIds.length === 0) return [];
-    const attributes = await em.find(RunAttributeEntity, axis.field === "attributeValue" ? {
-      runId: {
-        $in: runIds
-      },
-      key: axis.key
-    } : {
-      runId: {
-        $in: runIds
-      }
-    });
-    return (0, import_nestjs_durable_core.mergeRunValueFacetRows)(attributes.map((row) => ({
-      value: axis.field === "attributeKey" ? row.key : row.strValue ?? (row.numValue == null ? null : String(row.numValue)),
-      count: 1
-    })), opts);
+    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):
@@ -1327,6 +1454,76 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     const ch = isMysql ? "`" : '"';
     return (id) => `${ch}${id}${ch}`;
   }
+  // ---- persisted schedules ----------------------------------------------------------------------
+  async saveSchedule(record) {
+    const em = this.fork();
+    await em.upsert(ScheduleEntity, toScheduleEntity(record));
+  }
+  async getSchedule(id) {
+    const entity = await this.fork().findOne(ScheduleEntity, {
+      id
+    });
+    return entity ? fromScheduleEntity(entity) : null;
+  }
+  /** One conditional `nativeUpdate`: the compare-and-set on `next_fire_at` (an exact bigint) is a
+  *  single statement. */
+  async updateSchedule(id, patch, expectedNextFireAt) {
+    const data = {};
+    if (patch.namespace !== void 0) data.namespace = patch.namespace;
+    if (patch.workflow !== void 0) data.workflow = patch.workflow;
+    if (patch.paused !== void 0) data.paused = patch.paused;
+    if ("nextFireAt" in patch) data.nextFireAt = patch.nextFireAt ?? null;
+    if ("tags" in patch) data.tags = patch.tags ?? null;
+    if (patch.spec !== void 0) data.spec = patch.spec;
+    if (patch.state !== void 0) data.state = patch.state;
+    if (patch.updatedAt !== void 0) data.updatedAt = patch.updatedAt;
+    if (!Object.keys(data).length) return await this.getSchedule(id) !== null;
+    const where = {
+      id
+    };
+    if (expectedNextFireAt !== void 0) where.nextFireAt = expectedNextFireAt;
+    const affected = await this.fork().nativeUpdate(ScheduleEntity, where, data);
+    return affected > 0;
+  }
+  async deleteSchedule(id) {
+    return await this.fork().nativeDelete(ScheduleEntity, {
+      id
+    }) > 0;
+  }
+  async listSchedules(query) {
+    const em = this.fork();
+    const where = {};
+    if (query.namespace !== void 0) where.namespace = query.namespace;
+    if (query.workflow !== void 0) where.workflow = query.workflow;
+    if (query.paused !== void 0) where.paused = query.paused;
+    if (query.dueBy !== void 0) {
+      where.$and = [
+        {
+          paused: false
+        },
+        {
+          nextFireAt: {
+            $lte: query.dueBy
+          }
+        }
+      ];
+    }
+    const quote = this.idQuote(em);
+    const meta = em.getMetadata().get(ScheduleEntity);
+    const tagsCol = meta.properties.tags?.fieldNames?.[0] ?? "tags";
+    const qb = em.createQueryBuilder(ScheduleEntity, "r").where(where);
+    if (query.tag !== void 0) {
+      const pattern = `%"${query.tag.replace(/'/g, "''")}"%`;
+      qb.andWhere(`${this.jsonAsText(em, `${quote("r")}.${quote(tagsCol)}`)} LIKE '${pattern}'`);
+    }
+    qb.orderBy({
+      "r.nextFireAt": "asc nulls last",
+      "r.id": "asc"
+    });
+    if (query.limit != null) qb.limit(query.limit);
+    if (query.offset != null) qb.offset(query.offset);
+    return (await qb.getResultList()).map(fromScheduleEntity);
+  }
   async listCheckpoints(runId) {
     const em = this.fork();
     const rows = await em.find(StepCheckpointEntity, {
@@ -1565,6 +1762,38 @@ function fromCheckpointEntity(e) {
   };
 }
 __name(fromCheckpointEntity, "fromCheckpointEntity");
+function toScheduleEntity(r) {
+  const e = new ScheduleEntity();
+  e.id = r.id;
+  e.namespace = r.namespace;
+  e.workflow = r.workflow;
+  e.paused = r.paused;
+  e.nextFireAt = r.nextFireAt;
+  e.tags = r.tags ?? null;
+  e.spec = r.spec;
+  e.state = r.state;
+  e.createdAt = r.createdAt;
+  e.updatedAt = r.updatedAt;
+  return e;
+}
+__name(toScheduleEntity, "toScheduleEntity");
+function fromScheduleEntity(e) {
+  return {
+    id: e.id,
+    namespace: e.namespace,
+    workflow: e.workflow,
+    paused: Boolean(e.paused),
+    nextFireAt: e.nextFireAt == null ? null : Number(e.nextFireAt),
+    ...e.tags?.length ? {
+      tags: e.tags
+    } : {},
+    spec: e.spec ?? {},
+    state: e.state ?? {},
+    createdAt: e.createdAt,
+    updatedAt: e.updatedAt
+  };
+}
+__name(fromScheduleEntity, "fromScheduleEntity");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BufferedEventEntity,
@@ -1575,6 +1804,8 @@ __name(fromCheckpointEntity, "fromCheckpointEntity");
   MikroOrmStateStore,
   RunAttributeEntity,
   RunAttributeRepository,
+  ScheduleEntity,
+  ScheduleRepository,
   SignalWaiterEntity,
   SignalWaiterRepository,
   StepCheckpointEntity,