@dudousxd/nestjs-durable-store-typeorm 0.13.0 → 0.15.0

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BufferedEventEntity: () => BufferedEventEntity,
   BufferedSignalEntity: () => BufferedSignalEntity,
   ENTITIES: () => ENTITIES,
   JSON_BLOB_COLUMNS: () => JSON_BLOB_COLUMNS,
@@ -89,6 +90,7 @@ var WorkflowRunEntity = class {
   tags;
   searchAttributes;
   priority;
+  origin;
   createdAt;
   updatedAt;
 };
@@ -140,6 +142,15 @@ var BufferedSignalEntity = class {
   token;
   payload;
 };
+var BufferedEventEntity = class {
+  static {
+    __name(this, "BufferedEventEntity");
+  }
+  id;
+  name;
+  payload;
+  publishedAt;
+};
 function durableEntities(options = {}) {
   const col = columnNamer(options.naming ?? "snake_case");
   const workflowRuns = new import_typeorm.EntitySchema({
@@ -226,6 +237,18 @@ function durableEntities(options = {}) {
         nullable: true,
         name: col("priority")
       },
+      // Which library/module registered the workflow this run belongs to (e.g.
+      // `@dudousxd/nestjs-catalog-pipeline`), derived at registration time — never caller input.
+      // Nullable with NO default: an origin cannot be reconstructed for a row written before this
+      // column existed, so it stays NULL and reads back as `undefined` = "unknown". Defaulting it to
+      // a real-looking string would be indistinguishable from a genuine registration in the
+      // dashboard's facet. `ensureTypeOrmDurableSchema` back-fills the COLUMN onto pre-existing
+      // tables (see the `additive` map in ./schema), never its value.
+      origin: {
+        type: "text",
+        nullable: true,
+        name: col("origin")
+      },
       createdAt: {
         type: Date,
         name: col("createdAt")
@@ -408,12 +431,44 @@ function durableEntities(options = {}) {
       }
     }
   });
+  const bufferedEvents = new import_typeorm.EntitySchema({
+    name: "BufferedEventEntity",
+    target: BufferedEventEntity,
+    tableName: "durable_buffered_events",
+    // No `indices` here (unlike MikroORM's EntitySchema, which does declare one): this store manages
+    // its DDL — including the `(name, publishedAt)` index — via raw SQL in `schema.ts`'s
+    // `ensureTypeOrmDurableSchema`, the same as every other durable_* table's indexes.
+    columns: {
+      // Caller-minted uuid (engine.publishEvent), not autoincrement — removeBufferedEvent targets it
+      // directly and needs to be handed the SAME id it was buffered with.
+      id: {
+        type: "text",
+        primary: true,
+        name: col("id")
+      },
+      name: {
+        type: "text",
+        name: col("name")
+      },
+      payload: {
+        type: "text",
+        nullable: true,
+        name: col("payload"),
+        transformer: jsonColumnTransformer("buffered.eventPayload")
+      },
+      publishedAt: {
+        type: Date,
+        name: col("publishedAt")
+      }
+    }
+  });
   return [
     workflowRuns,
     stepCheckpoints,
     runAttributes,
     signalWaiters,
-    bufferedSignals
+    bufferedSignals,
+    bufferedEvents
   ];
 }
 __name(durableEntities, "durableEntities");
@@ -440,7 +495,8 @@ var TABLE_TO_ENTITY = {
   durable_step_checkpoints: StepCheckpointEntity,
   durable_run_attributes: RunAttributeEntity,
   durable_signal_waiters: SignalWaiterEntity,
-  durable_buffered_signals: BufferedSignalEntity
+  durable_buffered_signals: BufferedSignalEntity,
+  durable_buffered_events: BufferedEventEntity
 };
 function durableManagedTables() {
   return Object.keys(TABLE_TO_ENTITY);
@@ -490,11 +546,13 @@ async function ensureTypeOrmDurableSchema(dataSource) {
   const runAttributes = q("durable_run_attributes");
   const waiters = q("durable_signal_waiters");
   const buffered = q("durable_buffered_signals");
+  const bufferedEvents = q("durable_buffered_events");
   const runsCol = /* @__PURE__ */ __name((property) => q(resolve("durable_workflow_runs", property)), "runsCol");
   const cpCol = /* @__PURE__ */ __name((property) => q(resolve("durable_step_checkpoints", property)), "cpCol");
   const attrCol = /* @__PURE__ */ __name((property) => q(resolve("durable_run_attributes", property)), "attrCol");
   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 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 = [
@@ -507,7 +565,7 @@ async function ensureTypeOrmDurableSchema(dataSource) {
       ${runsCol("wakeAt")} ${ts}, ${runsCol("lockedBy")} ${str}, ${runsCol("lockedUntil")} ${ts},
       ${runsCol("awaitingDecisionTaskId")} ${str},
       ${runsCol("recoveryAttempts")} ${int}, ${runsCol("tags")} ${txt}, ${runsCol("searchAttributes")} ${txt},
-      ${runsCol("priority")} ${int},
+      ${runsCol("priority")} ${int}, ${runsCol("origin")} ${str},
       ${runsCol("createdAt")} ${ts} NOT NULL, ${runsCol("updatedAt")} ${ts} NOT NULL
     )`,
     `CREATE TABLE IF NOT EXISTS ${checkpoints} (
@@ -532,6 +590,12 @@ async function ensureTypeOrmDurableSchema(dataSource) {
     )`,
     `CREATE TABLE IF NOT EXISTS ${buffered} (
       ${bufferedId}, ${bufCol("token")} ${str} NOT NULL, ${bufCol("payload")} ${txt}
+    )`,
+    // Caller-minted uuid PK (engine.publishEvent), not auto-increment — unlike durable_buffered_signals
+    // above, removeBufferedEvent needs to target the EXACT id it was buffered with.
+    `CREATE TABLE IF NOT EXISTS ${bufferedEvents} (
+      ${bevCol("id")} ${str} PRIMARY KEY, ${bevCol("name")} ${str} NOT NULL,
+      ${bevCol("payload")} ${txt}, ${bevCol("publishedAt")} ${ts} NOT NULL
     )`
   ];
   const additive = {
@@ -567,6 +631,14 @@ async function ensureTypeOrmDurableSchema(dataSource) {
       [
         "priority",
         int
+      ],
+      // Nullable and NOT back-filled with a value: every row that predates the column keeps a NULL
+      // origin, which the store reads as `undefined` = "unknown origin". There is no honest value to
+      // back-fill — the origin is derived from the registration that created the run, which is long
+      // gone by the time this ALTER runs.
+      [
+        "origin",
+        str
       ]
     ],
     durable_step_checkpoints: [
@@ -643,6 +715,11 @@ async function ensureTypeOrmDurableSchema(dataSource) {
         "durable_buffered_signals_token_idx",
         `${buffered} (${bufCol("token")})`
       ],
+      // buffered events are scanned oldest-first per name — one composite index serves both.
+      [
+        "durable_buffered_events_name_published_at_idx",
+        `${bufferedEvents} (${bevCol("name")}, ${bevCol("publishedAt")})`
+      ],
       // 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.
       [
@@ -705,6 +782,9 @@ var TypeOrmStateStore = class {
   buffered() {
     return this.dataSource.getRepository(BufferedSignalEntity);
   }
+  bufferedEvents() {
+    return this.dataSource.getRepository(BufferedEventEntity);
+  }
   attributes() {
     return this.dataSource.getRepository(RunAttributeEntity);
   }
@@ -738,6 +818,7 @@ var TypeOrmStateStore = class {
     if ("tags" in patch) update.tags = patch.tags ?? null;
     if ("searchAttributes" in patch) update.searchAttributes = patch.searchAttributes ?? null;
     if ("priority" in patch) update.priority = patch.priority ?? null;
+    if ("origin" in patch) update.origin = patch.origin ?? null;
     if ("createdAt" in patch) update.createdAt = patch.createdAt;
     if ("updatedAt" in patch) update.updatedAt = patch.updatedAt;
     const result = await this.runs().createQueryBuilder().update().set(update).where({
@@ -851,6 +932,9 @@ var TypeOrmStateStore = class {
     if (query.workflow) qb.andWhere("r.workflow = :workflow", {
       workflow: query.workflow
     });
+    if (query.origin !== void 0) qb.andWhere("r.origin = :origin", {
+      origin: query.origin
+    });
     if (query.status) qb.andWhere("r.status = :status", {
       status: query.status
     });
@@ -999,6 +1083,36 @@ var TypeOrmStateStore = class {
       payload: e.payload ?? void 0
     };
   }
+  async bufferEvent(input) {
+    await this.bufferedEvents().save({
+      id: input.id,
+      name: input.name,
+      payload: input.payload ?? null,
+      publishedAt: new Date(input.publishedAt)
+    });
+  }
+  async listBufferedEvents(name, limit) {
+    const rows = await this.bufferedEvents().find({
+      where: {
+        name
+      },
+      order: {
+        publishedAt: "ASC"
+      },
+      take: limit
+    });
+    return rows.map((e) => ({
+      id: e.id,
+      payload: e.payload ?? void 0,
+      publishedAt: e.publishedAt.getTime()
+    }));
+  }
+  async removeBufferedEvent(id) {
+    const result = await this.bufferedEvents().delete({
+      id
+    });
+    return result.affected === 1;
+  }
 };
 function toRunEntity(run) {
   return {
@@ -1023,6 +1137,8 @@ function toRunEntity(run) {
     tags: run.tags ?? null,
     searchAttributes: run.searchAttributes ?? null,
     priority: run.priority ?? null,
+    // Absent origin stays SQL NULL — "unknown", never coerced into a real-looking library name.
+    origin: run.origin ?? null,
     createdAt: run.createdAt,
     updatedAt: run.updatedAt
   };
@@ -1045,6 +1161,8 @@ function fromRunEntity(e) {
     tags: e.tags ?? void 0,
     searchAttributes: e.searchAttributes ?? void 0,
     priority: e.priority ?? void 0,
+    // NULL (a row written before the column existed) surfaces as `undefined` = unknown origin.
+    origin: e.origin ?? void 0,
     createdAt: e.createdAt,
     updatedAt: e.updatedAt
   };
@@ -1099,6 +1217,7 @@ function fromCheckpointEntity(e) {
 __name(fromCheckpointEntity, "fromCheckpointEntity");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BufferedEventEntity,
   BufferedSignalEntity,
   ENTITIES,
   JSON_BLOB_COLUMNS,