@dudousxd/nestjs-durable-store-typeorm 0.9.1 → 0.11.0

package/dist/index.cjs

@@ -30,6 +30,9 @@ __export(index_exports, {
   TypeOrmStateStore: () => TypeOrmStateStore,
   WorkflowRunEntity: () => WorkflowRunEntity,
   buildWidenStatements: () => buildWidenStatements,
+  columnNamer: () => columnNamer,
+  durableColumnResolver: () => durableColumnResolver,
+  durableEntities: () => durableEntities,
   ensureTypeOrmDurableSchema: () => ensureTypeOrmDurableSchema,
   jsonBlobColumnType: () => jsonBlobColumnType,
   parseJsonColumn: () => parseJsonColumn
@@ -38,17 +41,6 @@ module.exports = __toCommonJS(index_exports);
 
 // src/entities.ts
 var import_typeorm = require("typeorm");
-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");
 function parseJsonColumn(raw, field) {
   if (raw == null) return void 0;
   if (typeof raw !== "string") return raw;
@@ -67,6 +59,16 @@ function jsonColumnTransformer(field) {
   };
 }
 __name(jsonColumnTransformer, "jsonColumnTransformer");
+function snakeCase(property) {
+  return property.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+__name(snakeCase, "snakeCase");
+function columnNamer(naming) {
+  if (naming === "snake_case") return snakeCase;
+  if (naming === "preserve") return (property) => property;
+  return naming;
+}
+__name(columnNamer, "columnNamer");
 var WorkflowRunEntity = class {
   static {
     __name(this, "WorkflowRunEntity");
@@ -87,94 +89,6 @@ var WorkflowRunEntity = class {
   createdAt;
   updatedAt;
 };
-_ts_decorate([
-  (0, import_typeorm.PrimaryColumn)("text"),
-  _ts_metadata("design:type", String)
-], WorkflowRunEntity.prototype, "id", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text"),
-  _ts_metadata("design:type", String)
-], WorkflowRunEntity.prototype, "workflow", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text"),
-  _ts_metadata("design:type", String)
-], WorkflowRunEntity.prototype, "workflowVersion", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text"),
-  _ts_metadata("design:type", typeof RunStatus === "undefined" ? Object : RunStatus)
-], WorkflowRunEntity.prototype, "status", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("runs.input")
-  }),
-  _ts_metadata("design:type", Object)
-], WorkflowRunEntity.prototype, "input", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("runs.output")
-  }),
-  _ts_metadata("design:type", Object)
-], WorkflowRunEntity.prototype, "output", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("runs.error")
-  }),
-  _ts_metadata("design:type", Object)
-], WorkflowRunEntity.prototype, "error", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)({
-    nullable: true
-  }),
-  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
-], WorkflowRunEntity.prototype, "wakeAt", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true
-  }),
-  _ts_metadata("design:type", Object)
-], WorkflowRunEntity.prototype, "lockedBy", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)({
-    nullable: true
-  }),
-  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
-], WorkflowRunEntity.prototype, "lockedUntil", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("integer", {
-    nullable: true
-  }),
-  _ts_metadata("design:type", Number)
-], WorkflowRunEntity.prototype, "recoveryAttempts", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("runs.tags")
-  }),
-  _ts_metadata("design:type", Object)
-], WorkflowRunEntity.prototype, "tags", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("runs.searchAttributes")
-  }),
-  _ts_metadata("design:type", Object)
-], WorkflowRunEntity.prototype, "searchAttributes", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)(),
-  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
-], WorkflowRunEntity.prototype, "createdAt", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)(),
-  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
-], WorkflowRunEntity.prototype, "updatedAt", void 0);
-WorkflowRunEntity = _ts_decorate([
-  (0, import_typeorm.Entity)({
-    name: "durable_workflow_runs"
-  })
-], WorkflowRunEntity);
 var StepCheckpointEntity = class {
   static {
     __name(this, "StepCheckpointEntity");
@@ -196,93 +110,6 @@ var StepCheckpointEntity = class {
   startedAt;
   finishedAt;
 };
-_ts_decorate([
-  (0, import_typeorm.PrimaryColumn)("text"),
-  _ts_metadata("design:type", String)
-], StepCheckpointEntity.prototype, "runId", void 0);
-_ts_decorate([
-  (0, import_typeorm.PrimaryColumn)("integer"),
-  _ts_metadata("design:type", Number)
-], StepCheckpointEntity.prototype, "seq", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text"),
-  _ts_metadata("design:type", String)
-], StepCheckpointEntity.prototype, "name", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text"),
-  _ts_metadata("design:type", typeof StepKind === "undefined" ? Object : StepKind)
-], StepCheckpointEntity.prototype, "kind", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text"),
-  _ts_metadata("design:type", String)
-], StepCheckpointEntity.prototype, "stepId", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text"),
-  _ts_metadata("design:type", String)
-], StepCheckpointEntity.prototype, "status", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("checkpoints.input")
-  }),
-  _ts_metadata("design:type", Object)
-], StepCheckpointEntity.prototype, "input", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("checkpoints.output")
-  }),
-  _ts_metadata("design:type", Object)
-], StepCheckpointEntity.prototype, "output", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("checkpoints.error")
-  }),
-  _ts_metadata("design:type", Object)
-], StepCheckpointEntity.prototype, "error", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("checkpoints.events")
-  }),
-  _ts_metadata("design:type", Object)
-], StepCheckpointEntity.prototype, "events", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("integer"),
-  _ts_metadata("design:type", Number)
-], StepCheckpointEntity.prototype, "attempts", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true
-  }),
-  _ts_metadata("design:type", Object)
-], StepCheckpointEntity.prototype, "workerGroup", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)({
-    nullable: true
-  }),
-  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
-], StepCheckpointEntity.prototype, "wakeAt", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)({
-    nullable: true
-  }),
-  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
-], StepCheckpointEntity.prototype, "enqueuedAt", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)(),
-  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
-], StepCheckpointEntity.prototype, "startedAt", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)(),
-  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
-], StepCheckpointEntity.prototype, "finishedAt", void 0);
-StepCheckpointEntity = _ts_decorate([
-  (0, import_typeorm.Entity)({
-    name: "durable_step_checkpoints"
-  })
-], StepCheckpointEntity);
 var RunAttributeEntity = class {
   static {
     __name(this, "RunAttributeEntity");
@@ -290,34 +117,8 @@ var RunAttributeEntity = class {
   runId;
   key;
   strValue;
-  // `float`/`double` portable across SQLite/MySQL/Postgres for numeric range scans.
   numValue;
 };
-_ts_decorate([
-  (0, import_typeorm.PrimaryColumn)("text"),
-  _ts_metadata("design:type", String)
-], RunAttributeEntity.prototype, "runId", void 0);
-_ts_decorate([
-  (0, import_typeorm.PrimaryColumn)("text"),
-  _ts_metadata("design:type", String)
-], RunAttributeEntity.prototype, "key", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true
-  }),
-  _ts_metadata("design:type", Object)
-], RunAttributeEntity.prototype, "strValue", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("float", {
-    nullable: true
-  }),
-  _ts_metadata("design:type", Object)
-], RunAttributeEntity.prototype, "numValue", void 0);
-RunAttributeEntity = _ts_decorate([
-  (0, import_typeorm.Entity)({
-    name: "durable_run_attributes"
-  })
-], RunAttributeEntity);
 var SignalWaiterEntity = class {
   static {
     __name(this, "SignalWaiterEntity");
@@ -326,60 +127,265 @@ var SignalWaiterEntity = class {
   runId;
   seq;
 };
-_ts_decorate([
-  (0, import_typeorm.PrimaryColumn)("text"),
-  _ts_metadata("design:type", String)
-], SignalWaiterEntity.prototype, "token", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text"),
-  _ts_metadata("design:type", String)
-], SignalWaiterEntity.prototype, "runId", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("integer"),
-  _ts_metadata("design:type", Number)
-], SignalWaiterEntity.prototype, "seq", void 0);
-SignalWaiterEntity = _ts_decorate([
-  (0, import_typeorm.Entity)({
-    name: "durable_signal_waiters"
-  })
-], SignalWaiterEntity);
 var BufferedSignalEntity = class {
   static {
     __name(this, "BufferedSignalEntity");
   }
-  // Auto-increment PK for FIFO ordering. Left as TypeORM's default increment type so it maps to the
-  // driver-native auto-increment column (INTEGER on SQLite, BIGINT/SERIAL on MySQL/Postgres).
   id;
   token;
   payload;
 };
-_ts_decorate([
-  (0, import_typeorm.PrimaryGeneratedColumn)(),
-  _ts_metadata("design:type", Number)
-], BufferedSignalEntity.prototype, "id", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text"),
-  _ts_metadata("design:type", String)
-], BufferedSignalEntity.prototype, "token", void 0);
-_ts_decorate([
-  (0, import_typeorm.Column)("text", {
-    nullable: true,
-    transformer: jsonColumnTransformer("buffered.payload")
-  }),
-  _ts_metadata("design:type", Object)
-], BufferedSignalEntity.prototype, "payload", void 0);
-BufferedSignalEntity = _ts_decorate([
-  (0, import_typeorm.Entity)({
-    name: "durable_buffered_signals"
-  })
-], BufferedSignalEntity);
-var ENTITIES = [
-  WorkflowRunEntity,
-  StepCheckpointEntity,
-  RunAttributeEntity,
-  SignalWaiterEntity,
-  BufferedSignalEntity
-];
+function durableEntities(options = {}) {
+  const col = columnNamer(options.naming ?? "snake_case");
+  const workflowRuns = new import_typeorm.EntitySchema({
+    name: "WorkflowRunEntity",
+    target: WorkflowRunEntity,
+    tableName: "durable_workflow_runs",
+    columns: {
+      id: {
+        type: "text",
+        primary: true,
+        name: col("id")
+      },
+      workflow: {
+        type: "text",
+        name: col("workflow")
+      },
+      workflowVersion: {
+        type: "text",
+        name: col("workflowVersion")
+      },
+      status: {
+        type: "text",
+        name: col("status")
+      },
+      input: {
+        type: "text",
+        nullable: true,
+        name: col("input"),
+        transformer: jsonColumnTransformer("runs.input")
+      },
+      output: {
+        type: "text",
+        nullable: true,
+        name: col("output"),
+        transformer: jsonColumnTransformer("runs.output")
+      },
+      error: {
+        type: "text",
+        nullable: true,
+        name: col("error"),
+        transformer: jsonColumnTransformer("runs.error")
+      },
+      wakeAt: {
+        type: Date,
+        nullable: true,
+        name: col("wakeAt")
+      },
+      lockedBy: {
+        type: "text",
+        nullable: true,
+        name: col("lockedBy")
+      },
+      lockedUntil: {
+        type: Date,
+        nullable: true,
+        name: col("lockedUntil")
+      },
+      recoveryAttempts: {
+        type: "integer",
+        nullable: true,
+        name: col("recoveryAttempts")
+      },
+      tags: {
+        type: "text",
+        nullable: true,
+        name: col("tags"),
+        transformer: jsonColumnTransformer("runs.tags")
+      },
+      searchAttributes: {
+        type: "text",
+        nullable: true,
+        name: col("searchAttributes"),
+        transformer: jsonColumnTransformer("runs.searchAttributes")
+      },
+      createdAt: {
+        type: Date,
+        name: col("createdAt")
+      },
+      updatedAt: {
+        type: Date,
+        name: col("updatedAt")
+      }
+    }
+  });
+  const stepCheckpoints = new import_typeorm.EntitySchema({
+    name: "StepCheckpointEntity",
+    target: StepCheckpointEntity,
+    tableName: "durable_step_checkpoints",
+    columns: {
+      runId: {
+        type: "text",
+        primary: true,
+        name: col("runId")
+      },
+      seq: {
+        type: "integer",
+        primary: true,
+        name: col("seq")
+      },
+      name: {
+        type: "text",
+        name: col("name")
+      },
+      kind: {
+        type: "text",
+        name: col("kind")
+      },
+      stepId: {
+        type: "text",
+        name: col("stepId")
+      },
+      status: {
+        type: "text",
+        name: col("status")
+      },
+      input: {
+        type: "text",
+        nullable: true,
+        name: col("input"),
+        transformer: jsonColumnTransformer("checkpoints.input")
+      },
+      output: {
+        type: "text",
+        nullable: true,
+        name: col("output"),
+        transformer: jsonColumnTransformer("checkpoints.output")
+      },
+      error: {
+        type: "text",
+        nullable: true,
+        name: col("error"),
+        transformer: jsonColumnTransformer("checkpoints.error")
+      },
+      events: {
+        type: "text",
+        nullable: true,
+        name: col("events"),
+        transformer: jsonColumnTransformer("checkpoints.events")
+      },
+      attempts: {
+        type: "integer",
+        name: col("attempts")
+      },
+      workerGroup: {
+        type: "text",
+        nullable: true,
+        name: col("workerGroup")
+      },
+      wakeAt: {
+        type: Date,
+        nullable: true,
+        name: col("wakeAt")
+      },
+      enqueuedAt: {
+        type: Date,
+        nullable: true,
+        name: col("enqueuedAt")
+      },
+      startedAt: {
+        type: Date,
+        name: col("startedAt")
+      },
+      finishedAt: {
+        type: Date,
+        name: col("finishedAt")
+      }
+    }
+  });
+  const runAttributes = new import_typeorm.EntitySchema({
+    name: "RunAttributeEntity",
+    target: RunAttributeEntity,
+    tableName: "durable_run_attributes",
+    columns: {
+      runId: {
+        type: "text",
+        primary: true,
+        name: col("runId")
+      },
+      key: {
+        type: "text",
+        primary: true,
+        name: col("key")
+      },
+      strValue: {
+        type: "text",
+        nullable: true,
+        name: col("strValue")
+      },
+      // `float`/`double` portable across SQLite/MySQL/Postgres for numeric range scans.
+      numValue: {
+        type: "float",
+        nullable: true,
+        name: col("numValue")
+      }
+    }
+  });
+  const signalWaiters = new import_typeorm.EntitySchema({
+    name: "SignalWaiterEntity",
+    target: SignalWaiterEntity,
+    tableName: "durable_signal_waiters",
+    columns: {
+      token: {
+        type: "text",
+        primary: true,
+        name: col("token")
+      },
+      runId: {
+        type: "text",
+        name: col("runId")
+      },
+      seq: {
+        type: "integer",
+        name: col("seq")
+      }
+    }
+  });
+  const bufferedSignals = new import_typeorm.EntitySchema({
+    name: "BufferedSignalEntity",
+    target: BufferedSignalEntity,
+    tableName: "durable_buffered_signals",
+    columns: {
+      // Auto-increment PK for FIFO ordering. Left as TypeORM's default increment generation so it
+      // maps to the driver-native auto-increment column (INTEGER on SQLite, BIGINT/SERIAL elsewhere).
+      id: {
+        type: Number,
+        primary: true,
+        generated: "increment",
+        name: col("id")
+      },
+      token: {
+        type: "text",
+        name: col("token")
+      },
+      payload: {
+        type: "text",
+        nullable: true,
+        name: col("payload"),
+        transformer: jsonColumnTransformer("buffered.payload")
+      }
+    }
+  });
+  return [
+    workflowRuns,
+    stepCheckpoints,
+    runAttributes,
+    signalWaiters,
+    bufferedSignals
+  ];
+}
+__name(durableEntities, "durableEntities");
+var ENTITIES = durableEntities();
 
 // src/schema.ts
 var JSON_BLOB_COLUMNS = {
@@ -397,16 +403,36 @@ var JSON_BLOB_COLUMNS = {
     "events"
   ]
 };
+var TABLE_TO_ENTITY = {
+  durable_workflow_runs: WorkflowRunEntity,
+  durable_step_checkpoints: StepCheckpointEntity,
+  durable_run_attributes: RunAttributeEntity,
+  durable_signal_waiters: SignalWaiterEntity,
+  durable_buffered_signals: BufferedSignalEntity
+};
+function durableColumnResolver(dataSource) {
+  return (table, property) => {
+    const entity = TABLE_TO_ENTITY[table];
+    if (!entity) throw new Error(`durable store: unknown table "${table}"`);
+    const meta = dataSource.getMetadata(entity);
+    const column = meta.findColumnWithPropertyName(property);
+    if (!column) {
+      throw new Error(`durable store: no column for ${table}.${property} in entity metadata`);
+    }
+    return column.databaseName;
+  };
+}
+__name(durableColumnResolver, "durableColumnResolver");
 function jsonBlobColumnType(isMysql) {
   return isMysql ? "longtext" : "text";
 }
 __name(jsonBlobColumnType, "jsonBlobColumnType");
-function buildWidenStatements(isMysql, quote) {
+function buildWidenStatements(isMysql, quote, col) {
   if (!isMysql) return [];
   const out = [];
-  for (const [table, cols] of Object.entries(JSON_BLOB_COLUMNS)) {
-    for (const col of cols) {
-      out.push(`ALTER TABLE ${quote(table)} MODIFY COLUMN ${quote(col)} longtext`);
+  for (const [table, props] of Object.entries(JSON_BLOB_COLUMNS)) {
+    for (const prop of props) {
+      out.push(`ALTER TABLE ${quote(table)} MODIFY COLUMN ${quote(col(table, prop))} longtext`);
     }
   }
   return out;
@@ -414,6 +440,7 @@ function buildWidenStatements(isMysql, quote) {
 __name(buildWidenStatements, "buildWidenStatements");
 async function ensureTypeOrmDurableSchema(dataSource) {
   const q = /* @__PURE__ */ __name((id) => dataSource.driver.escape(id), "q");
+  const resolve = durableColumnResolver(dataSource);
   const type = String(dataSource.options.type);
   const isPg = type === "postgres" || type === "aurora-postgres";
   const isMysql = type === "mysql" || type === "mariadb" || type === "aurora-mysql";
@@ -427,40 +454,45 @@ async function ensureTypeOrmDurableSchema(dataSource) {
   const runAttributes = q("durable_run_attributes");
   const waiters = q("durable_signal_waiters");
   const buffered = q("durable_buffered_signals");
+  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 num = isPg ? "double precision" : isMysql ? "double" : "real";
-  const bufferedId = isSqlite ? `${q("id")} integer PRIMARY KEY AUTOINCREMENT` : isMysql ? `${q("id")} bigint NOT NULL AUTO_INCREMENT PRIMARY KEY` : isPg ? `${q("id")} bigserial PRIMARY KEY` : `${q("id")} bigint NOT NULL AUTO_INCREMENT PRIMARY KEY`;
+  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 = [
     `CREATE TABLE IF NOT EXISTS ${runs} (
-      ${q("id")} ${str} PRIMARY KEY,
-      ${q("workflow")} ${str} NOT NULL,
-      ${q("workflowVersion")} ${str} NOT NULL,
-      ${q("status")} ${str} NOT NULL,
-      ${q("input")} ${txt}, ${q("output")} ${txt}, ${q("error")} ${txt},
-      ${q("wakeAt")} ${ts}, ${q("lockedBy")} ${str}, ${q("lockedUntil")} ${ts},
-      ${q("recoveryAttempts")} ${int}, ${q("tags")} ${txt}, ${q("searchAttributes")} ${txt},
-      ${q("createdAt")} ${ts} NOT NULL, ${q("updatedAt")} ${ts} NOT NULL
+      ${runsCol("id")} ${str} PRIMARY KEY,
+      ${runsCol("workflow")} ${str} NOT NULL,
+      ${runsCol("workflowVersion")} ${str} NOT NULL,
+      ${runsCol("status")} ${str} NOT NULL,
+      ${runsCol("input")} ${txt}, ${runsCol("output")} ${txt}, ${runsCol("error")} ${txt},
+      ${runsCol("wakeAt")} ${ts}, ${runsCol("lockedBy")} ${str}, ${runsCol("lockedUntil")} ${ts},
+      ${runsCol("recoveryAttempts")} ${int}, ${runsCol("tags")} ${txt}, ${runsCol("searchAttributes")} ${txt},
+      ${runsCol("createdAt")} ${ts} NOT NULL, ${runsCol("updatedAt")} ${ts} NOT NULL
     )`,
     `CREATE TABLE IF NOT EXISTS ${checkpoints} (
-      ${q("runId")} ${str} NOT NULL, ${q("seq")} ${int} NOT NULL,
-      ${q("name")} ${str} NOT NULL, ${q("kind")} ${str} NOT NULL, ${q("stepId")} ${str} NOT NULL,
-      ${q("status")} ${str} NOT NULL, ${q("input")} ${txt}, ${q("output")} ${txt}, ${q("error")} ${txt}, ${q("events")} ${txt},
-      ${q("attempts")} ${int} NOT NULL, ${q("workerGroup")} ${str},
-      ${q("wakeAt")} ${ts}, ${q("enqueuedAt")} ${ts},
-      ${q("startedAt")} ${ts} NOT NULL, ${q("finishedAt")} ${ts} NOT NULL,
-      PRIMARY KEY (${q("runId")}, ${q("seq")})
+      ${cpCol("runId")} ${str} NOT NULL, ${cpCol("seq")} ${int} NOT NULL,
+      ${cpCol("name")} ${str} NOT NULL, ${cpCol("kind")} ${str} NOT NULL, ${cpCol("stepId")} ${str} NOT NULL,
+      ${cpCol("status")} ${str} NOT NULL, ${cpCol("input")} ${txt}, ${cpCol("output")} ${txt}, ${cpCol("error")} ${txt}, ${cpCol("events")} ${txt},
+      ${cpCol("attempts")} ${int} NOT NULL, ${cpCol("workerGroup")} ${str},
+      ${cpCol("wakeAt")} ${ts}, ${cpCol("enqueuedAt")} ${ts},
+      ${cpCol("startedAt")} ${ts} NOT NULL, ${cpCol("finishedAt")} ${ts} NOT NULL,
+      PRIMARY KEY (${cpCol("runId")}, ${cpCol("seq")})
     )`,
     // Normalized search-attribute side-table: one row per (run, key) so attribute predicates push
     // DOWN into SQL via an EXISTS join (indexed below). `key` is keyed → must be varchar on MySQL.
     `CREATE TABLE IF NOT EXISTS ${runAttributes} (
-      ${q("runId")} ${str} NOT NULL, ${q("key")} ${str} NOT NULL,
-      ${q("strValue")} ${str}, ${q("numValue")} ${num},
-      PRIMARY KEY (${q("runId")}, ${q("key")})
+      ${attrCol("runId")} ${str} NOT NULL, ${attrCol("key")} ${str} NOT NULL,
+      ${attrCol("strValue")} ${str}, ${attrCol("numValue")} ${num},
+      PRIMARY KEY (${attrCol("runId")}, ${attrCol("key")})
     )`,
     `CREATE TABLE IF NOT EXISTS ${waiters} (
-      ${q("token")} ${str} PRIMARY KEY, ${q("runId")} ${str} NOT NULL, ${q("seq")} ${int} NOT NULL
+      ${waiterCol("token")} ${str} PRIMARY KEY, ${waiterCol("runId")} ${str} NOT NULL, ${waiterCol("seq")} ${int} NOT NULL
     )`,
     `CREATE TABLE IF NOT EXISTS ${buffered} (
-      ${bufferedId}, ${q("token")} ${str} NOT NULL, ${q("payload")} ${txt}
+      ${bufferedId}, ${bufCol("token")} ${str} NOT NULL, ${bufCol("payload")} ${txt}
     )`
   ];
   const additive = {
@@ -520,18 +552,19 @@ async function ensureTypeOrmDurableSchema(dataSource) {
   const runner = dataSource.createQueryRunner();
   try {
     for (const sql of tables) await runner.query(sql);
-    for (const [table, cols] of Object.entries(additive)) {
+    for (const [table, props] of Object.entries(additive)) {
       const have = await existingColumns(runner, table, {
         isSqlite,
         isMysql
       });
-      for (const [col, colType] of cols) {
-        if (!have.has(col)) {
-          await runner.query(`ALTER TABLE ${q(table)} ADD COLUMN ${q(col)} ${colType}`);
+      for (const [property, colType] of props) {
+        const column = resolve(table, property);
+        if (!have.has(column)) {
+          await runner.query(`ALTER TABLE ${q(table)} ADD COLUMN ${q(column)} ${colType}`);
         }
       }
     }
-    for (const sql of buildWidenStatements(isMysql, q)) {
+    for (const sql of buildWidenStatements(isMysql, q, resolve)) {
       try {
         await runner.query(sql);
       } catch {
@@ -540,26 +573,26 @@ async function ensureTypeOrmDurableSchema(dataSource) {
     const indexes = [
       [
         "durable_runs_status_idx",
-        `${runs} (${q("status")}, ${q("wakeAt")})`
+        `${runs} (${runsCol("status")}, ${runsCol("wakeAt")})`
       ],
       [
         "durable_runs_workflow_status_idx",
-        `${runs} (${q("workflow")}, ${q("status")})`
+        `${runs} (${runsCol("workflow")}, ${runsCol("status")})`
       ],
       // buffered signals are taken FIFO per token (smallest id) — index the token for the scan.
       [
         "durable_buffered_signals_token_idx",
-        `${buffered} (${q("token")})`
+        `${buffered} (${bufCol("token")})`
       ],
       // 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.
       [
         "durable_run_attributes_num_idx",
-        `${runAttributes} (${q("key")}, ${q("numValue")})`
+        `${runAttributes} (${attrCol("key")}, ${attrCol("numValue")})`
       ],
       [
         "durable_run_attributes_str_idx",
-        `${runAttributes} (${q("key")}, ${q("strValue")})`
+        `${runAttributes} (${attrCol("key")}, ${attrCol("strValue")})`
       ]
     ];
     for (const [name, target] of indexes) {
@@ -658,6 +691,20 @@ var TypeOrmStateStore = class {
     });
     return e ? fromRunEntity(e) : null;
   }
+  async deleteRun(runId) {
+    await this.checkpoints().delete({
+      runId
+    });
+    await this.waiters().delete({
+      runId
+    });
+    await this.attributes().delete({
+      runId
+    });
+    await this.runs().delete({
+      id: runId
+    });
+  }
   async getCheckpoint(runId, seq) {
     const e = await this.checkpoints().findOneBy({
       runId,
@@ -761,13 +808,21 @@ var TypeOrmStateStore = class {
   /** 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 col = (0, import_nestjs_durable_core.attributeColumnFor)(f);
+    const valueProperty = (0, import_nestjs_durable_core.attributeColumnFor)(f);
     const cmp = (0, import_nestjs_durable_core.sqlComparator)(f.op);
     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 durable_run_attributes ${a} WHERE ${a}."runId" = r.id AND ${a}."key" = :${keyParam} AND ${a}."${col}" ${cmp} :${valParam})`;
-    qb.andWhere(sql.replace(/"/g, this.idQuote()), {
+    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)
     });
@@ -971,6 +1026,9 @@ __name(fromCheckpointEntity, "fromCheckpointEntity");
   TypeOrmStateStore,
   WorkflowRunEntity,
   buildWidenStatements,
+  columnNamer,
+  durableColumnResolver,
+  durableEntities,
   ensureTypeOrmDurableSchema,
   jsonBlobColumnType,
   parseJsonColumn