@dudousxd/nestjs-durable-store-mikro-orm 0.8.0 → 0.9.0

package/dist/index.cjs

@@ -0,0 +1,785 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BufferedSignalEntity: () => BufferedSignalEntity,
+  ENTITIES: () => ENTITIES,
+  MikroOrmStateStore: () => MikroOrmStateStore,
+  RunAttributeEntity: () => RunAttributeEntity,
+  SignalWaiterEntity: () => SignalWaiterEntity,
+  StepCheckpointEntity: () => StepCheckpointEntity,
+  WorkflowRunEntity: () => WorkflowRunEntity,
+  ensureMikroOrmDurableSchema: () => ensureMikroOrmDurableSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/entities.ts
+var import_core = require("@mikro-orm/core");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var WorkflowRunEntity = class {
+  static {
+    __name(this, "WorkflowRunEntity");
+  }
+  id;
+  workflow;
+  workflowVersion;
+  status;
+  input;
+  output;
+  error;
+  wakeAt;
+  lockedBy;
+  lockedUntil;
+  recoveryAttempts;
+  tags;
+  searchAttributes;
+  createdAt;
+  updatedAt;
+};
+_ts_decorate([
+  (0, import_core.PrimaryKey)(),
+  _ts_metadata("design:type", String)
+], WorkflowRunEntity.prototype, "id", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", String)
+], WorkflowRunEntity.prototype, "workflow", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", String)
+], WorkflowRunEntity.prototype, "workflowVersion", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", typeof RunStatus === "undefined" ? Object : RunStatus)
+], WorkflowRunEntity.prototype, "status", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], WorkflowRunEntity.prototype, "input", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], WorkflowRunEntity.prototype, "output", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], WorkflowRunEntity.prototype, "error", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], WorkflowRunEntity.prototype, "wakeAt", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WorkflowRunEntity.prototype, "lockedBy", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], WorkflowRunEntity.prototype, "lockedUntil", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "integer",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WorkflowRunEntity.prototype, "recoveryAttempts", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], WorkflowRunEntity.prototype, "tags", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], WorkflowRunEntity.prototype, "searchAttributes", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], WorkflowRunEntity.prototype, "createdAt", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], WorkflowRunEntity.prototype, "updatedAt", void 0);
+WorkflowRunEntity = _ts_decorate([
+  (0, import_core.Entity)({
+    tableName: "durable_workflow_runs"
+  })
+], WorkflowRunEntity);
+var StepCheckpointEntity = class {
+  static {
+    __name(this, "StepCheckpointEntity");
+  }
+  runId;
+  seq;
+  name;
+  kind;
+  stepId;
+  status;
+  input;
+  output;
+  error;
+  events;
+  attempts;
+  workerGroup;
+  wakeAt;
+  enqueuedAt;
+  startedAt;
+  finishedAt;
+};
+_ts_decorate([
+  (0, import_core.PrimaryKey)(),
+  _ts_metadata("design:type", String)
+], StepCheckpointEntity.prototype, "runId", void 0);
+_ts_decorate([
+  (0, import_core.PrimaryKey)(),
+  _ts_metadata("design:type", Number)
+], StepCheckpointEntity.prototype, "seq", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", String)
+], StepCheckpointEntity.prototype, "name", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", typeof StepKind === "undefined" ? Object : StepKind)
+], StepCheckpointEntity.prototype, "kind", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", String)
+], StepCheckpointEntity.prototype, "stepId", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", String)
+], StepCheckpointEntity.prototype, "status", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], StepCheckpointEntity.prototype, "input", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], StepCheckpointEntity.prototype, "output", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], StepCheckpointEntity.prototype, "error", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], StepCheckpointEntity.prototype, "events", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", Number)
+], StepCheckpointEntity.prototype, "attempts", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], StepCheckpointEntity.prototype, "workerGroup", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], StepCheckpointEntity.prototype, "wakeAt", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], StepCheckpointEntity.prototype, "enqueuedAt", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], StepCheckpointEntity.prototype, "startedAt", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], StepCheckpointEntity.prototype, "finishedAt", void 0);
+StepCheckpointEntity = _ts_decorate([
+  (0, import_core.Entity)({
+    tableName: "durable_step_checkpoints"
+  })
+], StepCheckpointEntity);
+var RunAttributeEntity = class {
+  static {
+    __name(this, "RunAttributeEntity");
+  }
+  runId;
+  key;
+  strValue;
+  // `float`/`double` is portable across SQLite/MySQL/Postgres for numeric range scans.
+  numValue;
+};
+_ts_decorate([
+  (0, import_core.PrimaryKey)(),
+  _ts_metadata("design:type", String)
+], RunAttributeEntity.prototype, "runId", void 0);
+_ts_decorate([
+  (0, import_core.PrimaryKey)(),
+  _ts_metadata("design:type", String)
+], RunAttributeEntity.prototype, "key", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "string",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], RunAttributeEntity.prototype, "strValue", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "float",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], RunAttributeEntity.prototype, "numValue", void 0);
+RunAttributeEntity = _ts_decorate([
+  (0, import_core.Entity)({
+    tableName: "durable_run_attributes"
+  })
+], RunAttributeEntity);
+var SignalWaiterEntity = class {
+  static {
+    __name(this, "SignalWaiterEntity");
+  }
+  token;
+  runId;
+  seq;
+};
+_ts_decorate([
+  (0, import_core.PrimaryKey)(),
+  _ts_metadata("design:type", String)
+], SignalWaiterEntity.prototype, "token", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", String)
+], SignalWaiterEntity.prototype, "runId", void 0);
+_ts_decorate([
+  (0, import_core.Property)(),
+  _ts_metadata("design:type", Number)
+], SignalWaiterEntity.prototype, "seq", void 0);
+SignalWaiterEntity = _ts_decorate([
+  (0, import_core.Entity)({
+    tableName: "durable_signal_waiters"
+  })
+], SignalWaiterEntity);
+var BufferedSignalEntity = class {
+  static {
+    __name(this, "BufferedSignalEntity");
+  }
+  id;
+  token;
+  payload;
+};
+_ts_decorate([
+  (0, import_core.PrimaryKey)({
+    autoincrement: true
+  }),
+  _ts_metadata("design:type", Number)
+], BufferedSignalEntity.prototype, "id", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    index: true
+  }),
+  _ts_metadata("design:type", String)
+], BufferedSignalEntity.prototype, "token", void 0);
+_ts_decorate([
+  (0, import_core.Property)({
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], BufferedSignalEntity.prototype, "payload", void 0);
+BufferedSignalEntity = _ts_decorate([
+  (0, import_core.Entity)({
+    tableName: "durable_buffered_signals"
+  })
+], BufferedSignalEntity);
+var ENTITIES = [
+  WorkflowRunEntity,
+  StepCheckpointEntity,
+  RunAttributeEntity,
+  SignalWaiterEntity,
+  BufferedSignalEntity
+];
+
+// src/mikro-orm-state-store.ts
+var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
+
+// src/schema.ts
+async function ensureMikroOrmDurableSchema(orm) {
+  await orm.schema.updateSchema({
+    safe: true
+  });
+}
+__name(ensureMikroOrmDurableSchema, "ensureMikroOrmDurableSchema");
+
+// src/mikro-orm-state-store.ts
+var MikroOrmStateStore = class {
+  static {
+    __name(this, "MikroOrmStateStore");
+  }
+  orm;
+  constructor(orm) {
+    this.orm = orm;
+  }
+  async ensureSchema() {
+    await ensureMikroOrmDurableSchema(this.orm);
+  }
+  async createRun(run) {
+    const em = this.orm.em.fork();
+    em.create(WorkflowRunEntity, toRunEntity(run));
+    await em.flush();
+    await this.reindexAttributes(run.id, run.searchAttributes);
+  }
+  async updateRun(runId, patch) {
+    const em = this.orm.em.fork();
+    const entity = await em.findOneOrFail(WorkflowRunEntity, {
+      id: runId
+    });
+    Object.assign(entity, toRunEntity({
+      ...fromRunEntity(entity),
+      ...patch
+    }));
+    await em.flush();
+    if ("searchAttributes" in patch) await this.reindexAttributes(runId, patch.searchAttributes);
+  }
+  /** 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, forked) {
+    const em = forked ?? this.orm.em.fork();
+    await em.nativeDelete(RunAttributeEntity, {
+      runId
+    });
+    const rows = (0, import_nestjs_durable_core.normalizeAttributeRows)(runId, attributes);
+    if (rows.length) await em.insertMany(RunAttributeEntity, rows);
+  }
+  async getRun(runId) {
+    const em = this.orm.em.fork();
+    const entity = await em.findOne(WorkflowRunEntity, {
+      id: runId
+    });
+    return entity ? fromRunEntity(entity) : null;
+  }
+  async getCheckpoint(runId, seq) {
+    const em = this.orm.em.fork();
+    const entity = await em.findOne(StepCheckpointEntity, {
+      runId,
+      seq
+    });
+    return entity ? fromCheckpointEntity(entity) : null;
+  }
+  async saveCheckpoint(checkpoint) {
+    const em = this.orm.em.fork();
+    await em.upsert(StepCheckpointEntity, toCheckpointEntity(checkpoint));
+    await em.flush();
+  }
+  async transaction(work) {
+    return this.orm.em.fork().transactional(async (em) => work({
+      raw: em,
+      saveCheckpoint: /* @__PURE__ */ __name(async (cp) => {
+        await em.upsert(StepCheckpointEntity, toCheckpointEntity(cp));
+      }, "saveCheckpoint")
+    }));
+  }
+  async listIncompleteRuns() {
+    const em = this.orm.em.fork();
+    const rows = await em.find(WorkflowRunEntity, {
+      status: "running"
+    });
+    return rows.map(fromRunEntity);
+  }
+  async listPendingRuns(limit) {
+    const em = this.orm.em.fork();
+    const rows = await em.find(WorkflowRunEntity, {
+      status: "pending"
+    }, {
+      orderBy: {
+        createdAt: "asc"
+      },
+      limit
+    });
+    return rows.map(fromRunEntity);
+  }
+  async listDueTimers(nowMs) {
+    const em = this.orm.em.fork();
+    const rows = await em.find(WorkflowRunEntity, {
+      status: "suspended",
+      wakeAt: {
+        $ne: null,
+        $lte: new Date(nowMs)
+      }
+    });
+    return rows.map(fromRunEntity);
+  }
+  async tryLockRun(runId, owner, leaseUntilMs, nowMs) {
+    const em = this.orm.em.fork();
+    const affected = await em.nativeUpdate(WorkflowRunEntity, {
+      id: runId,
+      $or: [
+        {
+          lockedUntil: null
+        },
+        {
+          lockedUntil: {
+            $lte: new Date(nowMs)
+          }
+        }
+      ]
+    }, {
+      lockedBy: owner,
+      lockedUntil: new Date(leaseUntilMs)
+    });
+    return affected === 1;
+  }
+  async releaseRunLock(runId) {
+    const em = this.orm.em.fork();
+    await em.nativeUpdate(WorkflowRunEntity, {
+      id: runId
+    }, {
+      lockedBy: null,
+      lockedUntil: null
+    });
+  }
+  async renewRunLock(runId, owner, leaseUntilMs) {
+    const em = this.orm.em.fork();
+    const affected = await em.nativeUpdate(WorkflowRunEntity, {
+      id: runId,
+      lockedBy: owner
+    }, {
+      lockedUntil: new Date(leaseUntilMs)
+    });
+    return affected === 1;
+  }
+  async listRuns(query) {
+    const em = this.orm.em.fork();
+    const where = {};
+    if (query.workflow) where.workflow = query.workflow;
+    if (query.status && query.statuses) {
+      where.$and = [
+        {
+          status: query.status
+        },
+        {
+          status: {
+            $in: query.statuses
+          }
+        }
+      ];
+    } else if (query.status) {
+      where.status = query.status;
+    } else if (query.statuses) {
+      where.status = {
+        $in: query.statuses
+      };
+    }
+    const orderBy = {
+      createdAt: "desc"
+    };
+    if (query.tag || query.attributes?.length) {
+      const quote = this.idQuote(em);
+      const cols = this.attributeColumns(em);
+      const qb = em.createQueryBuilder(WorkflowRunEntity, "r").where(where).orderBy(orderBy);
+      if (query.tag) {
+        const tagsCol = this.tagsColumn(em);
+        const pattern = `%"${query.tag.replace(/'/g, "''")}"%`;
+        const colExpr = this.jsonAsText(em, `${quote("r")}.${quote(tagsCol)}`);
+        qb.andWhere(`${colExpr} LIKE '${pattern}'`);
+      }
+      for (const f of query.attributes ?? []) {
+        qb.andWhere(this.attributeExistsSql(f, quote, "r", cols));
+      }
+      if (query.limit != null) qb.limit(query.limit);
+      if (query.offset != null) qb.offset(query.offset);
+      const rows2 = await qb.getResultList();
+      return rows2.map(fromRunEntity);
+    }
+    const rows = await em.find(WorkflowRunEntity, where, {
+      ...query.limit != null ? {
+        limit: query.limit
+      } : {},
+      ...query.offset != null ? {
+        offset: query.offset
+      } : {},
+      orderBy
+    });
+    return rows.map(fromRunEntity);
+  }
+  /** 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):
+  *  EXISTS already requires a present row, so EXISTS(... <> ...) is exactly ne-with-present. Numeric
+  *  operands compare the num column, everything else the str column. Identifiers are quoted per
+  *  driver and operands are inlined as literals (string operands are escaped by doubling quotes). */
+  attributeExistsSql(f, quote, alias, cols) {
+    const col = (0, import_nestjs_durable_core.attributeColumnFor)(f) === "numValue" ? cols.numValue : cols.strValue;
+    const cmp = (0, import_nestjs_durable_core.sqlComparator)(f.op);
+    const operand = (0, import_nestjs_durable_core.attributeOperand)(f);
+    const literal = typeof operand === "number" ? String(operand) : `'${String(operand).replace(/'/g, "''")}'`;
+    const a = quote(cols.table);
+    const sub = quote("a");
+    const outerId = `${quote(alias)}.${quote(cols.runPk)}`;
+    return `EXISTS (SELECT 1 FROM ${a} ${sub} WHERE ${sub}.${quote(cols.runId)} = ${outerId} AND ${sub}.${quote(cols.key)} = '${f.key.replace(/'/g, "''")}' AND ${sub}.${quote(col)} ${cmp} ${literal})`;
+  }
+  /** Resolve the side-table's actual column names from MikroORM metadata, so the raw EXISTS matches
+  *  the active naming strategy (underscore vs camelCase) rather than guessing. The run PK column is
+  *  reused for BOTH the outer correlation and the side-table FK (they share the same fieldName). */
+  attributeColumns(em) {
+    const meta = em.getMetadata().get(RunAttributeEntity.name);
+    const field = /* @__PURE__ */ __name((prop) => meta.properties[prop]?.fieldNames?.[0] ?? prop, "field");
+    const runMeta = em.getMetadata().get(WorkflowRunEntity.name);
+    const runPk = runMeta.properties.id?.fieldNames?.[0] ?? "id";
+    return {
+      table: meta.tableName,
+      runId: field("runId"),
+      runPk,
+      key: field("key"),
+      strValue: field("strValue"),
+      numValue: field("numValue")
+    };
+  }
+  /** Resolve the `tags` column name from metadata (per the active naming strategy), for the raw LIKE. */
+  tagsColumn(em) {
+    const runMeta = em.getMetadata().get(WorkflowRunEntity.name);
+    return runMeta.properties.tags?.fieldNames?.[0] ?? "tags";
+  }
+  /** Wrap a JSON column reference so it can be `LIKE`d as text. Postgres `jsonb`/`json` rejects `LIKE`
+  *  directly (`operator does not exist: jsonb ~~ unknown`) — cast to `text`; MySQL JSON needs an
+  *  explicit `CHAR` cast; SQLite stores JSON as text already, so no cast. */
+  jsonAsText(em, colRef) {
+    const platform = String(em.getPlatform().constructor.name).toLowerCase();
+    if (platform.includes("postgre")) return `${colRef}::text`;
+    if (platform.includes("mysql") || platform.includes("mariadb")) return `CAST(${colRef} AS CHAR)`;
+    return colRef;
+  }
+  /** Quote an identifier per the active SQL driver (MySQL/MariaDB backtick, others double-quote). */
+  idQuote(em) {
+    const platform = String(em.getPlatform().constructor.name).toLowerCase();
+    const isMysql = platform.includes("mysql") || platform.includes("mariadb");
+    const ch = isMysql ? "`" : '"';
+    return (id) => `${ch}${id}${ch}`;
+  }
+  async listCheckpoints(runId) {
+    const em = this.orm.em.fork();
+    const rows = await em.find(StepCheckpointEntity, {
+      runId
+    }, {
+      orderBy: {
+        seq: "asc"
+      }
+    });
+    return rows.map(fromCheckpointEntity);
+  }
+  async putSignalWaiter(waiter) {
+    const em = this.orm.em.fork();
+    await em.upsert(SignalWaiterEntity, {
+      ...waiter
+    });
+    await em.flush();
+  }
+  async takeSignalWaiter(token) {
+    const em = this.orm.em.fork();
+    const entity = await em.findOne(SignalWaiterEntity, {
+      token
+    });
+    if (!entity) return null;
+    const waiter = {
+      token: entity.token,
+      runId: entity.runId,
+      seq: entity.seq
+    };
+    await em.removeAndFlush(entity);
+    return waiter;
+  }
+  async listSignalWaiters(prefix) {
+    const em = this.orm.em.fork();
+    const rows = await em.find(SignalWaiterEntity, {
+      token: {
+        $like: `${prefix}%`
+      }
+    });
+    return rows.map((e) => ({
+      token: e.token,
+      runId: e.runId,
+      seq: e.seq
+    }));
+  }
+  async bufferSignal(token, payload) {
+    const em = this.orm.em.fork();
+    const e = new BufferedSignalEntity();
+    e.token = token;
+    e.payload = payload ?? null;
+    em.persist(e);
+    await em.flush();
+  }
+  async takeBufferedSignal(token) {
+    const em = this.orm.em.fork();
+    const entity = await em.findOne(BufferedSignalEntity, {
+      token
+    }, {
+      orderBy: {
+        id: "asc"
+      }
+    });
+    if (!entity) return null;
+    const payload = entity.payload ?? void 0;
+    await em.removeAndFlush(entity);
+    return {
+      payload
+    };
+  }
+};
+function toRunEntity(run) {
+  const e = new WorkflowRunEntity();
+  e.id = run.id;
+  e.workflow = run.workflow;
+  e.workflowVersion = run.workflowVersion;
+  e.status = run.status;
+  e.input = run.input ?? null;
+  e.output = run.output ?? null;
+  e.error = run.error ?? null;
+  if (run.wakeAt != null) e.wakeAt = new Date(run.wakeAt);
+  if (run.lockedBy !== void 0) e.lockedBy = run.lockedBy;
+  if (run.lockedUntil != null) e.lockedUntil = new Date(run.lockedUntil);
+  if (run.recoveryAttempts !== void 0) e.recoveryAttempts = run.recoveryAttempts;
+  e.tags = run.tags ?? null;
+  e.searchAttributes = run.searchAttributes ?? null;
+  e.createdAt = run.createdAt;
+  e.updatedAt = run.updatedAt;
+  return e;
+}
+__name(toRunEntity, "toRunEntity");
+function fromRunEntity(e) {
+  return {
+    id: e.id,
+    workflow: e.workflow,
+    workflowVersion: e.workflowVersion,
+    status: e.status,
+    input: e.input ?? void 0,
+    output: e.output ?? void 0,
+    error: e.error ?? void 0,
+    wakeAt: e.wakeAt?.getTime(),
+    lockedBy: e.lockedBy ?? void 0,
+    lockedUntil: e.lockedUntil?.getTime(),
+    recoveryAttempts: e.recoveryAttempts ?? void 0,
+    tags: e.tags ?? void 0,
+    searchAttributes: e.searchAttributes ?? void 0,
+    createdAt: e.createdAt,
+    updatedAt: e.updatedAt
+  };
+}
+__name(fromRunEntity, "fromRunEntity");
+function toCheckpointEntity(cp) {
+  const e = new StepCheckpointEntity();
+  e.runId = cp.runId;
+  e.seq = cp.seq;
+  e.name = cp.name;
+  e.kind = cp.kind;
+  e.stepId = cp.stepId;
+  e.status = cp.status;
+  e.input = cp.input ?? null;
+  e.output = cp.output ?? null;
+  e.error = cp.error ?? null;
+  e.events = cp.events ?? null;
+  e.attempts = cp.attempts;
+  if (cp.workerGroup !== void 0) e.workerGroup = cp.workerGroup;
+  if (cp.wakeAt != null) e.wakeAt = new Date(cp.wakeAt);
+  e.enqueuedAt = cp.enqueuedAt;
+  e.startedAt = cp.startedAt;
+  e.finishedAt = cp.finishedAt;
+  return e;
+}
+__name(toCheckpointEntity, "toCheckpointEntity");
+function fromCheckpointEntity(e) {
+  return {
+    runId: e.runId,
+    seq: e.seq,
+    name: e.name,
+    kind: e.kind,
+    stepId: e.stepId,
+    status: e.status,
+    input: e.input ?? void 0,
+    output: e.output ?? void 0,
+    error: e.error ?? void 0,
+    events: e.events ?? void 0,
+    attempts: e.attempts,
+    workerGroup: e.workerGroup ?? void 0,
+    wakeAt: e.wakeAt?.getTime(),
+    enqueuedAt: e.enqueuedAt ?? e.startedAt,
+    startedAt: e.startedAt,
+    finishedAt: e.finishedAt
+  };
+}
+__name(fromCheckpointEntity, "fromCheckpointEntity");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BufferedSignalEntity,
+  ENTITIES,
+  MikroOrmStateStore,
+  RunAttributeEntity,
+  SignalWaiterEntity,
+  StepCheckpointEntity,
+  WorkflowRunEntity,
+  ensureMikroOrmDurableSchema
+});
+//# sourceMappingURL=index.cjs.map