@dudousxd/nestjs-durable-store-typeorm 0.18.0 → 0.19.1

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")})`
@@ -794,6 +886,7 @@ __name(existingColumns, "existingColumns");
 // src/typeorm-state-store.ts
 var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
 var import_typeorm2 = require("typeorm");
+var sqliteSingletonClaims = /* @__PURE__ */ new WeakMap();
 var TypeOrmStateStore = class {
   static {
     __name(this, "TypeOrmStateStore");
@@ -823,6 +916,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) {
@@ -833,11 +929,63 @@ var TypeOrmStateStore = class {
     const rows = (0, import_nestjs_durable_core.normalizeAttributeRows)(runId, attributes);
     if (rows.length) await repo.insert(rows);
   }
+  async tryAdmitSingleton(runId, tag, workflow, limit, retryWakeAt) {
+    const previous = sqliteSingletonClaims.get(this.dataSource) ?? Promise.resolve();
+    const sqlite = [
+      "sqlite",
+      "better-sqlite3",
+      "sqljs"
+    ].includes(this.dataSource.options.type);
+    let release;
+    if (sqlite) {
+      const next = new Promise((resolve) => {
+        release = resolve;
+      });
+      sqliteSingletonClaims.set(this.dataSource, previous.then(() => next));
+      await previous;
+    }
+    try {
+      return await this.dataSource.transaction(async (em) => {
+        const repo = em.getRepository(WorkflowRunEntity);
+        const where = {
+          workflow,
+          status: (0, import_typeorm2.In)(import_nestjs_durable_core.SINGLETON_ACTIVE_STATUSES)
+        };
+        await repo.update(where, {
+          workflow
+        });
+        const runs = (await repo.find({
+          where
+        })).map(fromRunEntity);
+        const tags = (0, import_nestjs_durable_core.singletonAdmissionTags)(runs, runId, tag, workflow, limit);
+        if (!tags) {
+          const patch = (0, import_nestjs_durable_core.singletonAdmissionDenialPatch)(runs, runId, tag, workflow, retryWakeAt);
+          if (patch) await repo.update({
+            id: runId
+          }, {
+            status: "suspended",
+            wakeAt: new Date(patch.wakeAt),
+            updatedAt: patch.updatedAt
+          });
+          return false;
+        }
+        await repo.update({
+          id: runId
+        }, {
+          tags
+        });
+        return true;
+      });
+    } finally {
+      release?.();
+    }
+  }
   async createRun(run) {
     await this.runs().save(toRunEntity(run));
     await this.reindexAttributes(run.id, run.searchAttributes);
   }
-  async updateRun(runId, patch) {
+  async updateRun(runId, inputPatch) {
+    const patch = inputPatch.status && import_nestjs_durable_core.TERMINAL_RUN_STATUSES.includes(inputPatch.status) ? await (0, import_nestjs_durable_core.clearTerminalSingletonAdmission)(runId, inputPatch, (id) => this.getRun(id)) : inputPatch;
     const update = {};
     if ("workflow" in patch) update.workflow = patch.workflow;
     if ("workflowVersion" in patch) update.workflowVersion = patch.workflowVersion;
@@ -883,6 +1031,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,
@@ -1038,6 +1232,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. */
@@ -1100,6 +1297,69 @@ var TypeOrmStateStore = class {
     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: {
@@ -1343,6 +1603,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,
@@ -1350,6 +1643,7 @@ __name(fromCheckpointEntity, "fromCheckpointEntity");
   ENTITIES,
   JSON_BLOB_COLUMNS,
   RunAttributeEntity,
+  ScheduleEntity,
   SignalWaiterEntity,
   StepCheckpointEntity,
   TypeOrmStateStore,