@dudousxd/nestjs-durable-store-typeorm 0.17.0 → 0.19.0

package/dist/index.cjs

@@ -26,6 +26,7 @@ __export(index_exports, {
   ENTITIES: () => ENTITIES,
   JSON_BLOB_COLUMNS: () => JSON_BLOB_COLUMNS,
   RunAttributeEntity: () => RunAttributeEntity,
+  ScheduleEntity: () => ScheduleEntity,
   SignalWaiterEntity: () => SignalWaiterEntity,
   StepCheckpointEntity: () => StepCheckpointEntity,
   TypeOrmStateStore: () => TypeOrmStateStore,
@@ -152,6 +153,23 @@ var BufferedEventEntity = class {
   payload;
   publishedAt;
 };
+var ScheduleEntity = class {
+  static {
+    __name(this, "ScheduleEntity");
+  }
+  id;
+  namespace;
+  workflow;
+  paused;
+  /** Epoch ms as a `bigint` (drivers hand it back as a string) — an exact integer, so the
+  *  compare-and-set in `updateSchedule` can't be defeated by a DATETIME's truncated milliseconds. */
+  nextFireAt;
+  tags;
+  spec;
+  state;
+  createdAt;
+  updatedAt;
+};
 function durableEntities(options = {}) {
   const col = columnNamer(options.naming ?? "snake_case");
   const workflowRuns = new import_typeorm.EntitySchema({
@@ -479,13 +497,69 @@ function durableEntities(options = {}) {
       }
     }
   });
+  const schedules = new import_typeorm.EntitySchema({
+    name: "ScheduleEntity",
+    target: ScheduleEntity,
+    tableName: "durable_schedules",
+    columns: {
+      id: {
+        type: "text",
+        primary: true,
+        name: col("id")
+      },
+      namespace: {
+        type: "text",
+        name: col("namespace"),
+        default: "default"
+      },
+      workflow: {
+        type: "text",
+        name: col("workflow")
+      },
+      paused: {
+        type: Boolean,
+        name: col("paused"),
+        default: false
+      },
+      nextFireAt: {
+        type: "bigint",
+        nullable: true,
+        name: col("nextFireAt")
+      },
+      tags: {
+        type: "text",
+        nullable: true,
+        name: col("tags"),
+        transformer: jsonColumnTransformer("schedules.tags")
+      },
+      spec: {
+        type: "text",
+        name: col("spec"),
+        transformer: jsonColumnTransformer("schedules.spec")
+      },
+      state: {
+        type: "text",
+        name: col("state"),
+        transformer: jsonColumnTransformer("schedules.state")
+      },
+      createdAt: {
+        type: Date,
+        name: col("createdAt")
+      },
+      updatedAt: {
+        type: Date,
+        name: col("updatedAt")
+      }
+    }
+  });
   return [
     workflowRuns,
     stepCheckpoints,
     runAttributes,
     signalWaiters,
     bufferedSignals,
-    bufferedEvents
+    bufferedEvents,
+    schedules
   ];
 }
 __name(durableEntities, "durableEntities");
@@ -513,7 +587,8 @@ var TABLE_TO_ENTITY = {
   durable_run_attributes: RunAttributeEntity,
   durable_signal_waiters: SignalWaiterEntity,
   durable_buffered_signals: BufferedSignalEntity,
-  durable_buffered_events: BufferedEventEntity
+  durable_buffered_events: BufferedEventEntity,
+  durable_schedules: ScheduleEntity
 };
 function durableManagedTables() {
   return Object.keys(TABLE_TO_ENTITY);
@@ -571,6 +646,8 @@ async function ensureTypeOrmDurableSchema(dataSource) {
   const waiterCol = /* @__PURE__ */ __name((property) => q(resolve("durable_signal_waiters", property)), "waiterCol");
   const bufCol = /* @__PURE__ */ __name((property) => q(resolve("durable_buffered_signals", property)), "bufCol");
   const bevCol = /* @__PURE__ */ __name((property) => q(resolve("durable_buffered_events", property)), "bevCol");
+  const schedules = q("durable_schedules");
+  const schCol = /* @__PURE__ */ __name((property) => q(resolve("durable_schedules", property)), "schCol");
   const num = isPg ? "double precision" : isMysql ? "double" : "real";
   const bufferedId = isSqlite ? `${bufCol("id")} integer PRIMARY KEY AUTOINCREMENT` : isMysql ? `${bufCol("id")} bigint NOT NULL AUTO_INCREMENT PRIMARY KEY` : isPg ? `${bufCol("id")} bigserial PRIMARY KEY` : `${bufCol("id")} bigint NOT NULL AUTO_INCREMENT PRIMARY KEY`;
   const tables = [
@@ -614,6 +691,16 @@ async function ensureTypeOrmDurableSchema(dataSource) {
     `CREATE TABLE IF NOT EXISTS ${bufferedEvents} (
       ${bevCol("id")} ${str} PRIMARY KEY, ${bevCol("name")} ${str} NOT NULL,
       ${bevCol("payload")} ${txt}, ${bevCol("publishedAt")} ${ts} NOT NULL
+    )`,
+    // Persisted schedules. `next_fire_at` is epoch ms as a bigint (exact, so the compare-and-set on
+    // it survives MySQL's DATETIME millisecond truncation); `spec`/`state` are engine-owned JSON.
+    `CREATE TABLE IF NOT EXISTS ${schedules} (
+      ${schCol("id")} ${str} PRIMARY KEY, ${schCol("namespace")} ${nsCol},
+      ${schCol("workflow")} ${str} NOT NULL,
+      ${schCol("paused")} boolean NOT NULL DEFAULT ${isPg ? "false" : "0"},
+      ${schCol("nextFireAt")} bigint, ${schCol("tags")} ${txt},
+      ${schCol("spec")} ${txt} NOT NULL, ${schCol("state")} ${txt} NOT NULL,
+      ${schCol("createdAt")} ${ts} NOT NULL, ${schCol("updatedAt")} ${ts} NOT NULL
     )`
   ];
   const additive = {
@@ -757,6 +844,11 @@ async function ensureTypeOrmDurableSchema(dataSource) {
       ],
       // Search-attribute pushdown: equality + range predicates probe by (key, value). Two composite
       // indexes — one per typed column — so a numeric range or a string equality is an index scan.
+      // Persisted schedules: the poll's "due by T" scan (`paused = false AND next_fire_at <= T`).
+      [
+        "durable_schedules_due_idx",
+        `${schedules} (${schCol("paused")}, ${schCol("nextFireAt")})`
+      ],
       [
         "durable_run_attributes_num_idx",
         `${runAttributes} (${attrCol("key")}, ${attrCol("numValue")})`
@@ -823,6 +915,9 @@ var TypeOrmStateStore = class {
   attributes() {
     return this.dataSource.getRepository(RunAttributeEntity);
   }
+  schedules() {
+    return this.dataSource.getRepository(ScheduleEntity);
+  }
   /** Rewrite a run's normalized attribute rows: delete the old set, insert the current one. Mirrors
   *  the in-memory store's reindex so the side-table always reflects the run's live searchAttributes. */
   async reindexAttributes(runId, attributes, em) {
@@ -883,6 +978,52 @@ var TypeOrmStateStore = class {
       id: runId
     });
   }
+  async deleteRuns(runIds) {
+    if (runIds.length === 0) return;
+    await this.dataSource.transaction(async (em) => {
+      await em.getRepository(StepCheckpointEntity).delete({
+        runId: (0, import_typeorm2.In)(runIds)
+      });
+      await em.getRepository(SignalWaiterEntity).delete({
+        runId: (0, import_typeorm2.In)(runIds)
+      });
+      await em.getRepository(RunAttributeEntity).delete({
+        runId: (0, import_typeorm2.In)(runIds)
+      });
+      await em.getRepository(WorkflowRunEntity).delete({
+        id: (0, import_typeorm2.In)(runIds)
+      });
+    });
+  }
+  async pruneTerminalRuns(policy, nowMs, limit) {
+    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 scoped = /* @__PURE__ */ __name(() => this.runQueryBuilder({
+      ...policy.scope ?? {},
+      statuses
+    }).select("r.id", "id"), "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 scoped().andWhere("r.updatedAt < :cutoff", {
+        cutoff
+      }).orderBy("r.updatedAt", "ASC").limit(limit).getRawMany();
+      for (const r of rows) ids.add(r.id);
+    }
+    if (policy.maxCount != null && ids.size < limit) {
+      const rows = await scoped().orderBy("r.updatedAt", "DESC").addOrderBy("r.id", "DESC").limit(limit).offset(policy.maxCount).getRawMany();
+      for (const r of rows) {
+        if (ids.size >= limit) break;
+        ids.add(r.id);
+      }
+    }
+    const doomed = [
+      ...ids
+    ].slice(0, limit);
+    await this.deleteRuns(doomed);
+    return doomed.length;
+  }
   async getCheckpoint(runId, seq) {
     const e = await this.checkpoints().findOneBy({
       runId,
@@ -987,13 +1128,28 @@ var TypeOrmStateStore = class {
     if (query.workflow) qb.andWhere("r.workflow = :workflow", {
       workflow: query.workflow
     });
+    if (query.workflows) qb.andWhere(query.workflows.length ? "r.workflow IN (:...workflows)" : "1 = 0", query.workflows.length ? {
+      workflows: query.workflows
+    } : {});
     if (query.namespace !== void 0) qb.andWhere("r.namespace = :namespace", {
       namespace: query.namespace
     });
+    if (query.namespaces) qb.andWhere(query.namespaces.length ? "r.namespace IN (:...namespaces)" : "1 = 0", query.namespaces.length ? {
+      namespaces: query.namespaces
+    } : {});
     if (query.origin === null) qb.andWhere("r.origin IS NULL");
     else if (query.origin !== void 0) qb.andWhere("r.origin = :origin", {
       origin: query.origin
     });
+    if (query.origins) {
+      const named = query.origins.filter((o) => o !== null);
+      const branches = [];
+      if (named.length) branches.push("r.origin IN (:...origins)");
+      if (query.origins.some((o) => o === null)) branches.push("r.origin IS NULL");
+      qb.andWhere(branches.length ? `(${branches.join(" OR ")})` : "1 = 0", named.length ? {
+        origins: named
+      } : {});
+    }
     if (query.status) qb.andWhere("r.status = :status", {
       status: query.status
     });
@@ -1003,6 +1159,13 @@ var TypeOrmStateStore = class {
     if (query.tag) qb.andWhere("r.tags LIKE :tagPattern", {
       tagPattern: `%"${query.tag}"%`
     });
+    if (query.tags) {
+      const branches = query.tags.map((_, i) => `r.tags LIKE :tagPattern${i}`);
+      qb.andWhere(branches.length ? `(${branches.join(" OR ")})` : "1 = 0", Object.fromEntries(query.tags.map((t, i) => [
+        `tagPattern${i}`,
+        `%"${t}"%`
+      ])));
+    }
     if (query.attributes?.length) {
       query.attributes.forEach((f, i) => this.applyAttributeExists(qb, f, i));
     }
@@ -1016,6 +1179,9 @@ var TypeOrmStateStore = class {
     const rows = await qb.getMany();
     return rows.map(fromRunEntity);
   }
+  async countRuns(query) {
+    return this.runQueryBuilder(query).getCount();
+  }
   /** `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. */
@@ -1026,33 +1192,121 @@ var TypeOrmStateStore = class {
       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 text / side table) and are counted from a bounded page
+  *  of runs instead — see `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 rows = await this.runQueryBuilder(query).select(`r.${axis.field}`, "value").addSelect("COUNT(*)", "count").groupBy(`r.${axis.field}`).getRawMany();
+    return (0, import_nestjs_durable_core.mergeRunValueFacetRows)(rows.map((r) => ({
+      value: r.value ?? null,
+      count: Number(r.count)
+    })), opts);
+  }
   /** Add one attribute predicate to `qb` as an EXISTS subquery on the side-table. `i` namespaces the
   *  bind params so multiple ANDed filters don't collide. */
   applyAttributeExists(qb, f, i) {
-    const valueProperty = (0, import_nestjs_durable_core.attributeColumnFor)(f);
-    const cmp = (0, import_nestjs_durable_core.sqlComparator)(f.op);
+    const comparisons = (0, import_nestjs_durable_core.attributePredicateOperands)(f);
     const keyParam = `attrKey${i}`;
-    const valParam = `attrVal${i}`;
     const resolve = durableColumnResolver(this.dataSource);
     const q = this.idQuote();
     const wrap = /* @__PURE__ */ __name((name) => `${q}${name}${q}`, "wrap");
     const runIdCol = wrap(resolve("durable_run_attributes", "runId"));
     const keyCol = wrap(resolve("durable_run_attributes", "key"));
-    const valueCol = wrap(resolve("durable_run_attributes", valueProperty));
     const runPkCol = wrap(resolve("durable_workflow_runs", "id"));
     const table = wrap("durable_run_attributes");
     const a = `a${i}`;
-    const sql = `EXISTS (SELECT 1 FROM ${table} ${a} WHERE ${a}.${runIdCol} = r.${runPkCol} AND ${a}.${keyCol} = :${keyParam} AND ${a}.${valueCol} ${cmp} :${valParam})`;
-    qb.andWhere(sql, {
-      [keyParam]: f.key,
-      [valParam]: (0, import_nestjs_durable_core.attributeOperand)(f)
+    const params = {
+      [keyParam]: f.key
+    };
+    const branches = comparisons.map(({ column, comparator, operand }, j) => {
+      const valParam = `attrVal${i}_${j}`;
+      params[valParam] = operand;
+      return `${a}.${wrap(resolve("durable_run_attributes", column))} ${comparator} :${valParam}`;
     });
+    if (branches.length === 0) {
+      qb.andWhere("1 = 0");
+      return;
+    }
+    const match = branches.length === 1 ? branches[0] : `(${branches.join(" OR ")})`;
+    const sql = `EXISTS (SELECT 1 FROM ${table} ${a} WHERE ${a}.${runIdCol} = r.${runPkCol} AND ${a}.${keyCol} = :${keyParam} AND ${match})`;
+    qb.andWhere(sql, params);
   }
   /** The identifier quote char for the active driver (MySQL backtick, others double-quote). */
   idQuote() {
     const type = String(this.dataSource.options.type);
     return type === "mysql" || type === "mariadb" || type === "aurora-mysql" ? "`" : '"';
   }
+  // ---- persisted schedules ----------------------------------------------------------------------
+  async saveSchedule(record) {
+    await this.schedules().save(toScheduleEntity(record));
+  }
+  async getSchedule(id) {
+    const e = await this.schedules().findOneBy({
+      id
+    });
+    return e ? fromScheduleEntity(e) : null;
+  }
+  /** One conditional UPDATE: the compare-and-set on `next_fire_at` (an exact bigint) is atomic. */
+  async updateSchedule(id, patch, expectedNextFireAt) {
+    const set = {};
+    if (patch.namespace !== void 0) set.namespace = patch.namespace;
+    if (patch.workflow !== void 0) set.workflow = patch.workflow;
+    if (patch.paused !== void 0) set.paused = patch.paused;
+    if ("nextFireAt" in patch) set.nextFireAt = patch.nextFireAt ?? null;
+    if ("tags" in patch) set.tags = patch.tags ?? null;
+    if (patch.spec !== void 0) set.spec = patch.spec;
+    if (patch.state !== void 0) set.state = patch.state;
+    if (patch.updatedAt !== void 0) set.updatedAt = patch.updatedAt;
+    if (!Object.keys(set).length) return await this.getSchedule(id) !== null;
+    const qb = this.schedules().createQueryBuilder().update().set(set).where({
+      id
+    });
+    if (expectedNextFireAt === null) qb.andWhere({
+      nextFireAt: (0, import_typeorm2.IsNull)()
+    });
+    else if (expectedNextFireAt !== void 0) qb.andWhere({
+      nextFireAt: expectedNextFireAt
+    });
+    const result = await qb.execute();
+    return (result.affected ?? 0) > 0;
+  }
+  async deleteSchedule(id) {
+    const result = await this.schedules().delete({
+      id
+    });
+    return (result.affected ?? 0) > 0;
+  }
+  async listSchedules(query) {
+    const qb = this.schedules().createQueryBuilder("s");
+    if (query.namespace !== void 0) qb.andWhere("s.namespace = :namespace", {
+      namespace: query.namespace
+    });
+    if (query.workflow !== void 0) qb.andWhere("s.workflow = :workflow", {
+      workflow: query.workflow
+    });
+    if (query.paused !== void 0) qb.andWhere("s.paused = :paused", {
+      paused: query.paused
+    });
+    if (query.tag !== void 0) qb.andWhere("s.tags LIKE :tag", {
+      tag: `%"${query.tag}"%`
+    });
+    if (query.dueBy !== void 0) qb.andWhere("s.paused = :notPaused AND s.nextFireAt <= :dueBy", {
+      notPaused: false,
+      dueBy: query.dueBy
+    });
+    qb.orderBy("CASE WHEN s.nextFireAt IS NULL THEN 1 ELSE 0 END", "ASC").addOrderBy("s.nextFireAt", "ASC").addOrderBy("s.id", "ASC");
+    if (query.limit != null) qb.take(query.limit);
+    if (query.offset != null) qb.skip(query.offset);
+    return (await qb.getMany()).map(fromScheduleEntity);
+  }
   async listCheckpoints(runId) {
     const rows = await this.checkpoints().find({
       where: {
@@ -1296,6 +1550,39 @@ 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,
+    // SQLite/MySQL hand a boolean column back as 0/1.
+    paused: Boolean(e.paused),
+    nextFireAt: e.nextFireAt == null ? null : Number(e.nextFireAt),
+    ...e.tags ? {
+      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,
@@ -1303,6 +1590,7 @@ __name(fromCheckpointEntity, "fromCheckpointEntity");
   ENTITIES,
   JSON_BLOB_COLUMNS,
   RunAttributeEntity,
+  ScheduleEntity,
   SignalWaiterEntity,
   StepCheckpointEntity,
   TypeOrmStateStore,