@dudousxd/nestjs-durable-store-typeorm 0.23.1 → 0.25.0

package/dist/index.cjs

@@ -38,7 +38,8 @@ __export(index_exports, {
   durableManagedTables: () => durableManagedTables,
   ensureTypeOrmDurableSchema: () => ensureTypeOrmDurableSchema,
   jsonBlobColumnType: () => jsonBlobColumnType,
-  parseJsonColumn: () => parseJsonColumn
+  parseJsonColumn: () => parseJsonColumn,
+  typeOrmSchemaRepairWarning: () => typeOrmSchemaRepairWarning
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -642,7 +643,19 @@ function buildWidenStatements(isMysql, quote, col) {
   return out;
 }
 __name(buildWidenStatements, "buildWidenStatements");
-async function ensureTypeOrmDurableSchema(dataSource) {
+function typeOrmSchemaRepairWarning(repairs) {
+  return [
+    `[nestjs-durable] store-typeorm repaired the durable schema at boot: ${repairs.join("; ")}.`,
+    "The database had drifted from the schema this library version expects (it was created by an",
+    "older version, or a migration left these out), so they were applied at runtime and nothing",
+    "recorded them in your migration history. To make them permanent, add a migration that calls",
+    "`ensureTypeOrmDurableSchema(queryRunner.connection)`. This warning appears only when a repair",
+    "was applied; a schema that is already current logs nothing."
+  ].join(" ");
+}
+__name(typeOrmSchemaRepairWarning, "typeOrmSchemaRepairWarning");
+async function ensureTypeOrmDurableSchema(dataSource, options = {}) {
+  const logger = options.logger ?? console;
   const q = /* @__PURE__ */ __name((id) => dataSource.driver.escape(id), "q");
   const resolve = durableColumnResolver(dataSource);
   const type = String(dataSource.options.type);
@@ -671,7 +684,9 @@ async function ensureTypeOrmDurableSchema(dataSource) {
   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 = [
-    `CREATE TABLE IF NOT EXISTS ${runs} (
+    [
+      "durable_workflow_runs",
+      `CREATE TABLE IF NOT EXISTS ${runs} (
       ${runsCol("id")} ${str} PRIMARY KEY,
       ${runsCol("workflow")} ${str} NOT NULL,
       ${runsCol("workflowVersion")} ${str} NOT NULL,
@@ -682,8 +697,11 @@ async function ensureTypeOrmDurableSchema(dataSource) {
       ${runsCol("recoveryAttempts")} ${int}, ${runsCol("tags")} ${txt}, ${runsCol("searchAttributes")} ${txt},
       ${runsCol("priority")} ${int}, ${runsCol("namespace")} ${nsCol}, ${runsCol("origin")} ${str},
       ${runsCol("createdAt")} ${ts} NOT NULL, ${runsCol("updatedAt")} ${ts} NOT NULL
-    )`,
-    `CREATE TABLE IF NOT EXISTS ${checkpoints} (
+    )`
+    ],
+    [
+      "durable_step_checkpoints",
+      `CREATE TABLE IF NOT EXISTS ${checkpoints} (
       ${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},
@@ -691,30 +709,45 @@ async function ensureTypeOrmDurableSchema(dataSource) {
       ${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} (
+    [
+      "durable_run_attributes",
+      `CREATE TABLE IF NOT EXISTS ${runAttributes} (
       ${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} (
+    )`
+    ],
+    [
+      "durable_signal_waiters",
+      `CREATE TABLE IF NOT EXISTS ${waiters} (
       ${waiterCol("token")} ${str} PRIMARY KEY, ${waiterCol("runId")} ${str} NOT NULL, ${waiterCol("seq")} ${int} NOT NULL,
       ${waiterCol("parallelGroup")} ${str}
-    )`,
-    `CREATE TABLE IF NOT EXISTS ${buffered} (
+    )`
+    ],
+    [
+      "durable_buffered_signals",
+      `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} (
+    [
+      "durable_buffered_events",
+      `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} (
+    [
+      "durable_schedules",
+      `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"},
@@ -722,6 +755,7 @@ async function ensureTypeOrmDurableSchema(dataSource) {
       ${schCol("spec")} ${txt} NOT NULL, ${schCol("state")} ${txt} NOT NULL,
       ${schCol("createdAt")} ${ts} NOT NULL, ${schCol("updatedAt")} ${ts} NOT NULL
     )`
+    ]
   ];
   const additive = {
     durable_workflow_runs: [
@@ -813,9 +847,21 @@ async function ensureTypeOrmDurableSchema(dataSource) {
       ]
     ]
   };
+  const repairs = [];
+  const created = /* @__PURE__ */ new Set();
   const runner = dataSource.createQueryRunner();
   try {
-    for (const sql of tables) await runner.query(sql);
+    const before = await existingTables(runner, {
+      isSqlite,
+      isMysql
+    });
+    for (const [table, sql] of tables) {
+      await runner.query(sql);
+      if (!before.has(table)) {
+        created.add(table);
+        repairs.push(`created table ${table}`);
+      }
+    }
     for (const [table, props] of Object.entries(additive)) {
       const have = await existingColumns(runner, table, {
         isSqlite,
@@ -825,23 +871,35 @@ async function ensureTypeOrmDurableSchema(dataSource) {
         const column = resolve(table, property);
         if (!have.has(column)) {
           await runner.query(`ALTER TABLE ${q(table)} ADD COLUMN ${q(column)} ${colType}`);
+          repairs.push(`added column ${table}.${column}`);
         }
       }
     }
-    for (const sql of buildWidenStatements(isMysql, q, resolve)) {
-      try {
-        await runner.query(sql);
-      } catch {
+    if (isMysql) {
+      for (const [table, props] of Object.entries(JSON_BLOB_COLUMNS)) {
+        const types = await mysqlColumnTypes(runner, table);
+        for (const prop of props) {
+          const column = resolve(table, prop);
+          const current = types.get(column);
+          if (current === void 0 || current === "longtext") continue;
+          try {
+            await runner.query(`ALTER TABLE ${q(table)} MODIFY COLUMN ${q(column)} ${jsonBlobColumnType(true)}`);
+            repairs.push(`widened ${table}.${column} from ${current} to longtext`);
+          } catch {
+          }
+        }
       }
     }
     const indexes = [
       [
         "durable_runs_status_idx",
-        `${runs} (${runsCol("status")}, ${runsCol("wakeAt")})`
+        `${runs} (${runsCol("status")}, ${runsCol("wakeAt")})`,
+        "durable_workflow_runs"
       ],
       [
         "durable_runs_workflow_status_idx",
-        `${runs} (${runsCol("workflow")}, ${runsCol("status")})`
+        `${runs} (${runsCol("workflow")}, ${runsCol("status")})`,
+        "durable_workflow_runs"
       ],
       // namespace/status/createdAt: every poll tick of a namespaced worker filters on `namespace`
       // ANDed with `status` (and `listPendingRuns` orders by `createdAt`), so without this the two
@@ -850,57 +908,89 @@ async function ensureTypeOrmDurableSchema(dataSource) {
       // already exists picks it up as soon as it runs this version.
       [
         "durable_runs_namespace_status_idx",
-        `${runs} (${runsCol("namespace")}, ${runsCol("status")}, ${runsCol("createdAt")})`
+        `${runs} (${runsCol("namespace")}, ${runsCol("status")}, ${runsCol("createdAt")})`,
+        "durable_workflow_runs"
       ],
       // A run's checkpoints by fan, in seq order: the run detail's per-group aggregates and fan
       // pages. `parallel_group` is `varchar(191)` in this DDL (also when added by ALTER above), so
       // MySQL can key it without a prefix length.
       [
         "durable_step_checkpoints_group_idx",
-        `${checkpoints} (${cpCol("runId")}, ${cpCol("parallelGroup")}, ${cpCol("seq")})`
+        `${checkpoints} (${cpCol("runId")}, ${cpCol("parallelGroup")}, ${cpCol("seq")})`,
+        "durable_step_checkpoints"
       ],
       // A run's waiters: the `ctx.all` join barrier probes them once per settled child.
       [
         "durable_signal_waiters_run_id_idx",
-        `${waiters} (${waiterCol("runId")})`
+        `${waiters} (${waiterCol("runId")})`,
+        "durable_signal_waiters"
       ],
       // buffered signals are taken FIFO per token (smallest id) — index the token for the scan.
       [
         "durable_buffered_signals_token_idx",
-        `${buffered} (${bufCol("token")})`
+        `${buffered} (${bufCol("token")})`,
+        "durable_buffered_signals"
       ],
       // 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")})`
+        `${bufferedEvents} (${bevCol("name")}, ${bevCol("publishedAt")})`,
+        "durable_buffered_events"
       ],
       // 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")})`
+        `${schedules} (${schCol("paused")}, ${schCol("nextFireAt")})`,
+        "durable_schedules"
       ],
       [
         "durable_run_attributes_num_idx",
-        `${runAttributes} (${attrCol("key")}, ${attrCol("numValue")})`
+        `${runAttributes} (${attrCol("key")}, ${attrCol("numValue")})`,
+        "durable_run_attributes"
       ],
       [
         "durable_run_attributes_str_idx",
-        `${runAttributes} (${attrCol("key")}, ${attrCol("strValue")})`
+        `${runAttributes} (${attrCol("key")}, ${attrCol("strValue")})`,
+        "durable_run_attributes"
       ]
     ];
-    for (const [name, target] of indexes) {
+    for (const [name, target, table] of indexes) {
       try {
         await runner.query(`CREATE INDEX ${q(name)} ON ${target}`);
+        if (!created.has(table)) repairs.push(`created index ${name} on ${table}`);
       } catch {
       }
     }
   } finally {
     await runner.release();
   }
+  const freshInstall = created.size === tables.length;
+  if (repairs.length > 0 && !freshInstall) logger.warn(typeOrmSchemaRepairWarning(repairs));
 }
 __name(ensureTypeOrmDurableSchema, "ensureTypeOrmDurableSchema");
+async function existingTables(runner, d) {
+  const names = durableManagedTables();
+  if (d.isSqlite) {
+    const rows2 = await runner.query("SELECT name FROM sqlite_master WHERE type = 'table'");
+    return new Set(rows2.map((r) => r.name).filter((name) => names.includes(name)));
+  }
+  const scope = d.isMysql ? "TABLE_SCHEMA = DATABASE()" : "table_schema = current_schema()";
+  const rows = await runner.query(`SELECT table_name AS name FROM information_schema.tables WHERE ${scope}`);
+  return new Set(rows.map((r) => r.name ?? r.TABLE_NAME).filter((name) => names.includes(name)));
+}
+__name(existingTables, "existingTables");
+async function mysqlColumnTypes(runner, table) {
+  const rows = await runner.query("SELECT column_name AS name, data_type AS type FROM information_schema.columns WHERE table_name = ? AND TABLE_SCHEMA = DATABASE()", [
+    table
+  ]);
+  return new Map(rows.map((r) => [
+    r.name ?? r.COLUMN_NAME,
+    String(r.type ?? r.DATA_TYPE).toLowerCase()
+  ]));
+}
+__name(mysqlColumnTypes, "mysqlColumnTypes");
 async function existingColumns(runner, table, d) {
   if (d.isSqlite) {
     const rows2 = await runner.query(`PRAGMA table_info("${table}")`);
@@ -925,11 +1015,15 @@ var TypeOrmStateStore = class {
     __name(this, "TypeOrmStateStore");
   }
   dataSource;
-  constructor(dataSource) {
+  options;
+  constructor(dataSource, options = {}) {
     this.dataSource = dataSource;
+    this.options = options;
   }
   async ensureSchema() {
-    await ensureTypeOrmDurableSchema(this.dataSource);
+    await ensureTypeOrmDurableSchema(this.dataSource, {
+      logger: this.options.schemaLogger
+    });
   }
   runs() {
     return this.dataSource.getRepository(WorkflowRunEntity);
@@ -998,6 +1092,7 @@ var TypeOrmStateStore = class {
           }, {
             status: "suspended",
             wakeAt: new Date(patch.wakeAt),
+            tags: patch.tags,
             updatedAt: patch.updatedAt
           });
           return false;
@@ -1158,7 +1253,7 @@ var TypeOrmStateStore = class {
     });
     return rows.map(fromRunEntity);
   }
-  async listOrphanedRuns(nowMs, limit, namespace) {
+  async listOrphanedRuns(nowMs, limit, namespace, ownedBy) {
     if (limit <= 0) return [];
     const now = new Date(nowMs);
     const rows = await this.runs().find({
@@ -1182,7 +1277,21 @@ var TypeOrmStateStore = class {
           ...namespace !== void 0 ? {
             namespace
           } : {}
-        }
+        },
+        // A live lease left by a previous process with the caller's own instance id.
+        ...ownedBy ? [
+          {
+            status: (0, import_typeorm2.In)([
+              "running",
+              "cancelling"
+            ]),
+            lockedBy: ownedBy.owner,
+            lockedUntil: (0, import_typeorm2.LessThan)(new Date(ownedBy.lockedBefore)),
+            ...namespace !== void 0 ? {
+              namespace
+            } : {}
+          }
+        ] : []
       ],
       order: {
         createdAt: "ASC"
@@ -1237,9 +1346,12 @@ var TypeOrmStateStore = class {
     }))).execute();
     return result.affected === 1;
   }
-  async releaseRunLock(runId) {
-    await this.runs().update({
+  async releaseRunLock(runId, owner) {
+    await this.runs().update(owner === void 0 ? {
       id: runId
+    } : {
+      id: runId,
+      lockedBy: owner
     }, {
       lockedBy: null,
       lockedUntil: /* @__PURE__ */ __name(() => "NULL", "lockedUntil")
@@ -1739,7 +1851,7 @@ function toRunEntity(run) {
     // An absent namespace is persisted as `'default'` (what the core `WorkflowRun.namespace` docblock
     // promises), so the column is always a value a worker can match on — the opposite of `origin`
     // below, where NULL is the only honest answer.
-    namespace: run.namespace ?? "default",
+    namespace: run.namespace || "default",
     // Absent origin stays SQL NULL — "unknown", never coerced into a real-looking library name.
     origin: run.origin ?? null,
     createdAt: run.createdAt,
@@ -1871,7 +1983,7 @@ function runUpdateSet(patch) {
   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 ("namespace" in patch) update.namespace = patch.namespace ?? "default";
+  if ("namespace" in patch) update.namespace = patch.namespace || "default";
   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;
@@ -1914,6 +2026,7 @@ __name(updateIfPending, "updateIfPending");
   durableManagedTables,
   ensureTypeOrmDurableSchema,
   jsonBlobColumnType,
-  parseJsonColumn
+  parseJsonColumn,
+  typeOrmSchemaRepairWarning
 });
 //# sourceMappingURL=index.cjs.map