@dudousxd/nestjs-durable-store-mikro-orm 0.32.0 → 0.33.1

package/dist/index.d.cts

@@ -145,6 +145,79 @@ declare function durableEntities(options?: {
 /** Durable entity schemas with the canonical `'snake_case'` column names. */
 declare const ENTITIES: EntitySchema<any, never, _mikro_orm_core.EntityCtor<any>>[];
 
+/**
+ * Tables this store creates and manages at boot (autoSchema). Feed to your ORM's migration differ
+ * exclude/skipTables so it never tries to drop them.
+ *
+ * ```ts
+ * await MikroORM.init({
+ *   // ...your entities/driver config
+ *   schemaGenerator: { skipTables: durableManagedTables() },
+ * });
+ * ```
+ *
+ * Derived from the same {@link DURABLE_TABLE_NAMES} set `ensureMikroOrmDurableSchema` scopes its own
+ * heal to — one list, so a consumer's denylist can never drift from what this store actually owns.
+ */
+declare function durableManagedTables(): string[];
+/**
+ * Where {@link ensureMikroOrmDurableSchema} reports a schema repair it actually applied. `console`
+ * (the default) satisfies it, and so does NestJS's `Logger`, so an app can route the warning into
+ * its own log stream.
+ */
+interface DurableSchemaLogger {
+    warn(message: string): void;
+}
+interface EnsureMikroOrmDurableSchemaOptions {
+    /** Sink for the schema-repair warning. Defaults to `console`. */
+    logger?: DurableSchemaLogger | undefined;
+}
+/**
+ * The warning logged when the boot-time heal changed an EXISTING durable schema: created a table
+ * that was missing next to ones that exist, added a column or index, changed a column type, or
+ * converted a table's collation. Never logged when the schema was already current, and never on a
+ * fresh install (no durable table existed, so creating them all is the expected first boot).
+ *
+ * The discriminator matters more than the wording: a warning on every boot would be filtered as
+ * noise, and a silent repair hides a migration-managed schema that has drifted from the library.
+ */
+declare function mikroOrmSchemaRepairWarning(repairs: readonly string[]): string;
+/**
+ * Idempotently create/extend ONLY the durable tables (additive — never drops). Safe to run on every
+ * boot (auto-schema) and from a MikroORM migration when you disable auto-schema:
+ *
+ * ```ts
+ * export class AddDurableTables extends Migration {
+ *   async up() { await ensureMikroOrmDurableSchema(this.getEntityManager().getOrm()); }
+ * }
+ * ```
+ *
+ * It does NOT run a whole-ORM `schema.update()`. When the store shares the host app's ORM (the
+ * recommended setup — a single ORM avoids MikroORM's global-metadata clobber between instances),
+ * a full `schema.update()` would try to reconcile EVERY app table to the entity metadata: on a
+ * migration-managed schema that means recreating the migrations table and dropping app foreign keys.
+ * Instead we compute the safe additive diff and execute only the statements that target our own
+ * `durable_*` tables. `getUpdateSchemaSQL` already emits a `create table` only for a missing table
+ * and `alter table ... add` only for missing columns, so existing tables — and the entire rest of
+ * the host schema — are left untouched.
+ *
+ * This runs on every boot of every pod, and `getUpdateSchemaSQL({ safe: true })` introspects the
+ * WHOLE database's `information_schema` (the store shares the app ORM) before string-filtering down
+ * to our tables — wasted round-trips when nothing changed. So a fingerprint GATE fronts it: a marker
+ * table records the fingerprint of the metadata last applied; if the in-memory expected fingerprint
+ * matches the stored one we return after two cheap round-trips (a `CREATE TABLE IF NOT EXISTS` for
+ * the marker + one PK read), skipping BOTH the introspection AND the collation probes. Only a fresh
+ * DB (no marker), an entity change, or a {@link SCHEMA_REVISION} bump runs the full heal — under a
+ * best-effort advisory lock, with a re-check in case a sibling pod healed while we waited.
+ *
+ * When the heal changes an existing durable schema (a missing table, column or index, a column type,
+ * a MySQL collation), it logs ONE warning listing each change to `options.logger` (default
+ * `console`); see {@link mikroOrmSchemaRepairWarning}. A current schema and a fresh install log
+ * nothing. Because of the fingerprint gate, a column dropped by hand AFTER the marker was written is
+ * not noticed until the fingerprint changes (an upgrade) or the marker row is deleted.
+ */
+declare function ensureMikroOrmDurableSchema(orm: MikroORM, options?: EnsureMikroOrmDurableSchemaOptions): Promise<void>;
+
 /** Options for scoping a `MikroOrmStateStore` to a single tenant namespace. */
 interface MikroOrmStateStoreOptions {
     /**
@@ -155,6 +228,12 @@ interface MikroOrmStateStoreOptions {
     scope?: {
         namespace?: string;
     };
+    /**
+     * Where `ensureSchema()` (the boot-time auto-schema) reports a schema repair it actually applied
+     * — a missing table, column or index it had to add. Defaults to `console`. NestJS's `Logger`
+     * satisfies it.
+     */
+    schemaLogger?: DurableSchemaLogger | undefined;
 }
 /**
  * MikroORM-backed `StateStore`. Works on any MikroORM driver — Postgres, MySQL, SQLite (tested);
@@ -166,6 +245,7 @@ interface MikroOrmStateStoreOptions {
  */
 declare class MikroOrmStateStore implements StateStore {
     private readonly orm;
+    private readonly opts;
     private readonly scopeNamespace;
     constructor(orm: MikroORM, opts?: MikroOrmStateStoreOptions);
     /**
@@ -193,6 +273,7 @@ declare class MikroOrmStateStore implements StateStore {
      *  the in-memory store's reindex so the side-table always reflects the run's live searchAttributes. */
     private reindexAttributes;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    getRuns(runIds: string[]): Promise<WorkflowRun[]>;
     deleteRun(runId: string): Promise<void>;
     deleteRuns(runIds: string[]): Promise<void>;
     pruneTerminalRuns(policy: RetentionPolicy, nowMs: number, limit: number): Promise<number>;
@@ -209,7 +290,7 @@ declare class MikroOrmStateStore implements StateStore {
     listPendingRuns(limit: number, namespace?: string): Promise<WorkflowRun[]>;
     listDueTimers(nowMs: number, namespace?: string, limit?: number): Promise<WorkflowRun[]>;
     tryLockRun(runId: string, owner: string, leaseUntilMs: number, nowMs: number): Promise<boolean>;
-    releaseRunLock(runId: string): Promise<void>;
+    releaseRunLock(runId: string, owner?: string): Promise<void>;
     renewRunLock(runId: string, owner: string, leaseUntilMs: number): Promise<boolean>;
     /** The `where` every run query shares — {@link listRuns} pages it, {@link runFacets} groups it.
      *  Only the predicates MikroORM can express declaratively; `tag`/`attributes` need raw SQL and are
@@ -332,49 +413,4 @@ declare class MikroOrmStateStore implements StateStore {
     removeBufferedEvent(id: string): Promise<boolean>;
 }
 
-/**
- * Tables this store creates and manages at boot (autoSchema). Feed to your ORM's migration differ
- * exclude/skipTables so it never tries to drop them.
- *
- * ```ts
- * await MikroORM.init({
- *   // ...your entities/driver config
- *   schemaGenerator: { skipTables: durableManagedTables() },
- * });
- * ```
- *
- * Derived from the same {@link DURABLE_TABLE_NAMES} set `ensureMikroOrmDurableSchema` scopes its own
- * heal to — one list, so a consumer's denylist can never drift from what this store actually owns.
- */
-declare function durableManagedTables(): string[];
-/**
- * Idempotently create/extend ONLY the durable tables (additive — never drops). Safe to run on every
- * boot (auto-schema) and from a MikroORM migration when you disable auto-schema:
- *
- * ```ts
- * export class AddDurableTables extends Migration {
- *   async up() { await ensureMikroOrmDurableSchema(this.getEntityManager().getOrm()); }
- * }
- * ```
- *
- * It does NOT run a whole-ORM `schema.update()`. When the store shares the host app's ORM (the
- * recommended setup — a single ORM avoids MikroORM's global-metadata clobber between instances),
- * a full `schema.update()` would try to reconcile EVERY app table to the entity metadata: on a
- * migration-managed schema that means recreating the migrations table and dropping app foreign keys.
- * Instead we compute the safe additive diff and execute only the statements that target our own
- * `durable_*` tables. `getUpdateSchemaSQL` already emits a `create table` only for a missing table
- * and `alter table ... add` only for missing columns, so existing tables — and the entire rest of
- * the host schema — are left untouched.
- *
- * This runs on every boot of every pod, and `getUpdateSchemaSQL({ safe: true })` introspects the
- * WHOLE database's `information_schema` (the store shares the app ORM) before string-filtering down
- * to our tables — wasted round-trips when nothing changed. So a fingerprint GATE fronts it: a marker
- * table records the fingerprint of the metadata last applied; if the in-memory expected fingerprint
- * matches the stored one we return after two cheap round-trips (a `CREATE TABLE IF NOT EXISTS` for
- * the marker + one PK read), skipping BOTH the introspection AND the collation probes. Only a fresh
- * DB (no marker), an entity change, or a {@link SCHEMA_REVISION} bump runs the full heal — under a
- * best-effort advisory lock, with a re-check in case a sibling pod healed while we waited.
- */
-declare function ensureMikroOrmDurableSchema(orm: MikroORM): Promise<void>;
-
-export { BufferedEventEntity, BufferedEventRepository, BufferedSignalEntity, BufferedSignalRepository, type DurableColumnNaming, ENTITIES, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, RunAttributeRepository, ScheduleEntity, ScheduleRepository, SignalWaiterEntity, SignalWaiterRepository, StepCheckpointEntity, StepCheckpointRepository, WorkflowRunEntity, WorkflowRunRepository, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema };
+export { BufferedEventEntity, BufferedEventRepository, BufferedSignalEntity, BufferedSignalRepository, type DurableColumnNaming, type DurableSchemaLogger, ENTITIES, type EnsureMikroOrmDurableSchemaOptions, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, RunAttributeRepository, ScheduleEntity, ScheduleRepository, SignalWaiterEntity, SignalWaiterRepository, StepCheckpointEntity, StepCheckpointRepository, WorkflowRunEntity, WorkflowRunRepository, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema, mikroOrmSchemaRepairWarning };

package/dist/index.d.ts

@@ -145,6 +145,79 @@ declare function durableEntities(options?: {
 /** Durable entity schemas with the canonical `'snake_case'` column names. */
 declare const ENTITIES: EntitySchema<any, never, _mikro_orm_core.EntityCtor<any>>[];
 
+/**
+ * Tables this store creates and manages at boot (autoSchema). Feed to your ORM's migration differ
+ * exclude/skipTables so it never tries to drop them.
+ *
+ * ```ts
+ * await MikroORM.init({
+ *   // ...your entities/driver config
+ *   schemaGenerator: { skipTables: durableManagedTables() },
+ * });
+ * ```
+ *
+ * Derived from the same {@link DURABLE_TABLE_NAMES} set `ensureMikroOrmDurableSchema` scopes its own
+ * heal to — one list, so a consumer's denylist can never drift from what this store actually owns.
+ */
+declare function durableManagedTables(): string[];
+/**
+ * Where {@link ensureMikroOrmDurableSchema} reports a schema repair it actually applied. `console`
+ * (the default) satisfies it, and so does NestJS's `Logger`, so an app can route the warning into
+ * its own log stream.
+ */
+interface DurableSchemaLogger {
+    warn(message: string): void;
+}
+interface EnsureMikroOrmDurableSchemaOptions {
+    /** Sink for the schema-repair warning. Defaults to `console`. */
+    logger?: DurableSchemaLogger | undefined;
+}
+/**
+ * The warning logged when the boot-time heal changed an EXISTING durable schema: created a table
+ * that was missing next to ones that exist, added a column or index, changed a column type, or
+ * converted a table's collation. Never logged when the schema was already current, and never on a
+ * fresh install (no durable table existed, so creating them all is the expected first boot).
+ *
+ * The discriminator matters more than the wording: a warning on every boot would be filtered as
+ * noise, and a silent repair hides a migration-managed schema that has drifted from the library.
+ */
+declare function mikroOrmSchemaRepairWarning(repairs: readonly string[]): string;
+/**
+ * Idempotently create/extend ONLY the durable tables (additive — never drops). Safe to run on every
+ * boot (auto-schema) and from a MikroORM migration when you disable auto-schema:
+ *
+ * ```ts
+ * export class AddDurableTables extends Migration {
+ *   async up() { await ensureMikroOrmDurableSchema(this.getEntityManager().getOrm()); }
+ * }
+ * ```
+ *
+ * It does NOT run a whole-ORM `schema.update()`. When the store shares the host app's ORM (the
+ * recommended setup — a single ORM avoids MikroORM's global-metadata clobber between instances),
+ * a full `schema.update()` would try to reconcile EVERY app table to the entity metadata: on a
+ * migration-managed schema that means recreating the migrations table and dropping app foreign keys.
+ * Instead we compute the safe additive diff and execute only the statements that target our own
+ * `durable_*` tables. `getUpdateSchemaSQL` already emits a `create table` only for a missing table
+ * and `alter table ... add` only for missing columns, so existing tables — and the entire rest of
+ * the host schema — are left untouched.
+ *
+ * This runs on every boot of every pod, and `getUpdateSchemaSQL({ safe: true })` introspects the
+ * WHOLE database's `information_schema` (the store shares the app ORM) before string-filtering down
+ * to our tables — wasted round-trips when nothing changed. So a fingerprint GATE fronts it: a marker
+ * table records the fingerprint of the metadata last applied; if the in-memory expected fingerprint
+ * matches the stored one we return after two cheap round-trips (a `CREATE TABLE IF NOT EXISTS` for
+ * the marker + one PK read), skipping BOTH the introspection AND the collation probes. Only a fresh
+ * DB (no marker), an entity change, or a {@link SCHEMA_REVISION} bump runs the full heal — under a
+ * best-effort advisory lock, with a re-check in case a sibling pod healed while we waited.
+ *
+ * When the heal changes an existing durable schema (a missing table, column or index, a column type,
+ * a MySQL collation), it logs ONE warning listing each change to `options.logger` (default
+ * `console`); see {@link mikroOrmSchemaRepairWarning}. A current schema and a fresh install log
+ * nothing. Because of the fingerprint gate, a column dropped by hand AFTER the marker was written is
+ * not noticed until the fingerprint changes (an upgrade) or the marker row is deleted.
+ */
+declare function ensureMikroOrmDurableSchema(orm: MikroORM, options?: EnsureMikroOrmDurableSchemaOptions): Promise<void>;
+
 /** Options for scoping a `MikroOrmStateStore` to a single tenant namespace. */
 interface MikroOrmStateStoreOptions {
     /**
@@ -155,6 +228,12 @@ interface MikroOrmStateStoreOptions {
     scope?: {
         namespace?: string;
     };
+    /**
+     * Where `ensureSchema()` (the boot-time auto-schema) reports a schema repair it actually applied
+     * — a missing table, column or index it had to add. Defaults to `console`. NestJS's `Logger`
+     * satisfies it.
+     */
+    schemaLogger?: DurableSchemaLogger | undefined;
 }
 /**
  * MikroORM-backed `StateStore`. Works on any MikroORM driver — Postgres, MySQL, SQLite (tested);
@@ -166,6 +245,7 @@ interface MikroOrmStateStoreOptions {
  */
 declare class MikroOrmStateStore implements StateStore {
     private readonly orm;
+    private readonly opts;
     private readonly scopeNamespace;
     constructor(orm: MikroORM, opts?: MikroOrmStateStoreOptions);
     /**
@@ -193,6 +273,7 @@ declare class MikroOrmStateStore implements StateStore {
      *  the in-memory store's reindex so the side-table always reflects the run's live searchAttributes. */
     private reindexAttributes;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    getRuns(runIds: string[]): Promise<WorkflowRun[]>;
     deleteRun(runId: string): Promise<void>;
     deleteRuns(runIds: string[]): Promise<void>;
     pruneTerminalRuns(policy: RetentionPolicy, nowMs: number, limit: number): Promise<number>;
@@ -209,7 +290,7 @@ declare class MikroOrmStateStore implements StateStore {
     listPendingRuns(limit: number, namespace?: string): Promise<WorkflowRun[]>;
     listDueTimers(nowMs: number, namespace?: string, limit?: number): Promise<WorkflowRun[]>;
     tryLockRun(runId: string, owner: string, leaseUntilMs: number, nowMs: number): Promise<boolean>;
-    releaseRunLock(runId: string): Promise<void>;
+    releaseRunLock(runId: string, owner?: string): Promise<void>;
     renewRunLock(runId: string, owner: string, leaseUntilMs: number): Promise<boolean>;
     /** The `where` every run query shares — {@link listRuns} pages it, {@link runFacets} groups it.
      *  Only the predicates MikroORM can express declaratively; `tag`/`attributes` need raw SQL and are
@@ -332,49 +413,4 @@ declare class MikroOrmStateStore implements StateStore {
     removeBufferedEvent(id: string): Promise<boolean>;
 }
 
-/**
- * Tables this store creates and manages at boot (autoSchema). Feed to your ORM's migration differ
- * exclude/skipTables so it never tries to drop them.
- *
- * ```ts
- * await MikroORM.init({
- *   // ...your entities/driver config
- *   schemaGenerator: { skipTables: durableManagedTables() },
- * });
- * ```
- *
- * Derived from the same {@link DURABLE_TABLE_NAMES} set `ensureMikroOrmDurableSchema` scopes its own
- * heal to — one list, so a consumer's denylist can never drift from what this store actually owns.
- */
-declare function durableManagedTables(): string[];
-/**
- * Idempotently create/extend ONLY the durable tables (additive — never drops). Safe to run on every
- * boot (auto-schema) and from a MikroORM migration when you disable auto-schema:
- *
- * ```ts
- * export class AddDurableTables extends Migration {
- *   async up() { await ensureMikroOrmDurableSchema(this.getEntityManager().getOrm()); }
- * }
- * ```
- *
- * It does NOT run a whole-ORM `schema.update()`. When the store shares the host app's ORM (the
- * recommended setup — a single ORM avoids MikroORM's global-metadata clobber between instances),
- * a full `schema.update()` would try to reconcile EVERY app table to the entity metadata: on a
- * migration-managed schema that means recreating the migrations table and dropping app foreign keys.
- * Instead we compute the safe additive diff and execute only the statements that target our own
- * `durable_*` tables. `getUpdateSchemaSQL` already emits a `create table` only for a missing table
- * and `alter table ... add` only for missing columns, so existing tables — and the entire rest of
- * the host schema — are left untouched.
- *
- * This runs on every boot of every pod, and `getUpdateSchemaSQL({ safe: true })` introspects the
- * WHOLE database's `information_schema` (the store shares the app ORM) before string-filtering down
- * to our tables — wasted round-trips when nothing changed. So a fingerprint GATE fronts it: a marker
- * table records the fingerprint of the metadata last applied; if the in-memory expected fingerprint
- * matches the stored one we return after two cheap round-trips (a `CREATE TABLE IF NOT EXISTS` for
- * the marker + one PK read), skipping BOTH the introspection AND the collation probes. Only a fresh
- * DB (no marker), an entity change, or a {@link SCHEMA_REVISION} bump runs the full heal — under a
- * best-effort advisory lock, with a re-check in case a sibling pod healed while we waited.
- */
-declare function ensureMikroOrmDurableSchema(orm: MikroORM): Promise<void>;
-
-export { BufferedEventEntity, BufferedEventRepository, BufferedSignalEntity, BufferedSignalRepository, type DurableColumnNaming, ENTITIES, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, RunAttributeRepository, ScheduleEntity, ScheduleRepository, SignalWaiterEntity, SignalWaiterRepository, StepCheckpointEntity, StepCheckpointRepository, WorkflowRunEntity, WorkflowRunRepository, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema };
+export { BufferedEventEntity, BufferedEventRepository, BufferedSignalEntity, BufferedSignalRepository, type DurableColumnNaming, type DurableSchemaLogger, ENTITIES, type EnsureMikroOrmDurableSchemaOptions, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, RunAttributeRepository, ScheduleEntity, ScheduleRepository, SignalWaiterEntity, SignalWaiterRepository, StepCheckpointEntity, StepCheckpointRepository, WorkflowRunEntity, WorkflowRunRepository, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema, mikroOrmSchemaRepairWarning };

package/dist/index.js

@@ -679,6 +679,78 @@ var MARKER_TABLE = "durable_schema_meta";
 var MARKER_ROW_ID = "durable";
 var SCHEMA_LOCK_NAME = "durable_schema";
 var SCHEMA_REVISION = 1;
+function mikroOrmSchemaRepairWarning(repairs) {
+  return [
+    `[nestjs-durable] store-mikro-orm 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",
+    "`ensureMikroOrmDurableSchema(orm)`. This warning appears only when a repair was applied; a",
+    "schema that is already current logs nothing."
+  ].join(" ");
+}
+__name(mikroOrmSchemaRepairWarning, "mikroOrmSchemaRepairWarning");
+function unquote(identifier) {
+  return identifier.replace(/^[`"']|[`"']$/g, "");
+}
+__name(unquote, "unquote");
+function describeDurableStatement(statement) {
+  const table = targetTable(statement) ?? "?";
+  if (/^create\s+table\b/i.test(statement)) return [
+    `created table ${table}`
+  ];
+  const createIndex = statement.match(/^create\s+(?:unique\s+)?index\s+(?:if\s+not\s+exists\s+)?([`"']?[\w$]+[`"']?)/i);
+  if (createIndex?.[1]) return [
+    `created index ${unquote(createIndex[1])} on ${table}`
+  ];
+  if (/^alter\s+table\b/i.test(statement)) {
+    const out = [];
+    let other = false;
+    for (const action of splitTopLevel(statement.replace(/^alter\s+table\s+[`"']?[\w$]+[`"']?\s*/i, ""))) {
+      const index = action.match(/^add\s+(?:unique\s+|fulltext\s+)?(?:index|key)\s+([`"']?[\w$]+[`"']?)/i);
+      const constraint = action.match(/^add\s+constraint\s+([`"']?[\w$]+[`"']?)/i);
+      const column = action.match(/^add\s+(?:column\s+)?([`"']?[\w$]+[`"']?)/i);
+      if (index?.[1]) out.push(`created index ${unquote(index[1])} on ${table}`);
+      else if (constraint?.[1]) out.push(`added constraint ${unquote(constraint[1])} on ${table}`);
+      else if (column?.[1] && !/^add\s+(?:primary|unique|fulltext|foreign)\b/i.test(action)) out.push(`added column ${table}.${unquote(column[1])}`);
+      else other = true;
+    }
+    if (other || out.length === 0) {
+      const flat = statement.replace(/\s+/g, " ");
+      out.push(`altered ${table} (${flat.length > 160 ? `${flat.slice(0, 157)}...` : flat})`);
+    }
+    return out;
+  }
+  return [
+    `ran ${statement.replace(/\s+/g, " ").slice(0, 160)}`
+  ];
+}
+__name(describeDurableStatement, "describeDurableStatement");
+function splitTopLevel(text) {
+  const parts = [];
+  let depth = 0;
+  let quote;
+  let current = "";
+  for (const ch of text) {
+    if (quote) {
+      if (ch === quote) quote = void 0;
+    } else if (ch === "'" || ch === '"' || ch === "`") {
+      quote = ch;
+    } else if (ch === "(") {
+      depth++;
+    } else if (ch === ")") {
+      depth--;
+    } else if (ch === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+__name(splitTopLevel, "splitTopLevel");
 function compareStrings(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
@@ -797,7 +869,8 @@ async function releaseSchemaLock(orm, dialect) {
   }
 }
 __name(releaseSchemaLock, "releaseSchemaLock");
-async function ensureMikroOrmDurableSchema(orm) {
+async function ensureMikroOrmDurableSchema(orm, options = {}) {
+  const logger = options.logger ?? console;
   const dialect = detectSqlDialect(orm);
   await orm.em.getConnection().execute(createMarkerTableSql());
   const expected = computeExpectedFingerprint(orm, DURABLE_TABLE_NAMES);
@@ -810,8 +883,9 @@ async function ensureMikroOrmDurableSchema(orm) {
     if (await readStoredFingerprint(orm) === expected) {
       return;
     }
-    await healDurableSchema(orm);
+    const { repairs, freshInstall } = await healDurableSchema(orm);
     await writeFingerprint(orm, dialect, expected);
+    if (repairs.length > 0 && !freshInstall) logger.warn(mikroOrmSchemaRepairWarning(repairs));
   } finally {
     await releaseSchemaLock(orm, dialect);
   }
@@ -826,9 +900,14 @@ async function healDurableSchema(orm) {
     return table !== void 0 && DURABLE_TABLE_NAMES.has(table);
   });
   const connection = orm.em.getConnection();
+  const created = new Set(ours.filter((statement) => /^create\s+table\b/i.test(statement)).map((statement) => targetTable(statement)));
+  const repairs = [];
   for (const statement of ours) {
     try {
       await connection.execute(statement);
+      const table = targetTable(statement);
+      const isCreateTable = /^create\s+table\b/i.test(statement);
+      if (isCreateTable || !created.has(table)) repairs.push(...describeDurableStatement(statement));
     } catch (err) {
       if (isRequiredStructure(statement)) {
         throw err;
@@ -837,7 +916,17 @@ async function healDurableSchema(orm) {
       console.warn(`[nestjs-durable-store-mikro-orm] skipped a non-structural durable-schema statement that failed; the column is left as-is (functional) \u2014 repair the data out of band to converge its type. Statement: ${statement} \u2014 ${message}`);
     }
   }
-  await alignDurableCollation(orm);
+  const converted = await alignDurableCollation(orm);
+  for (const { table, from, to } of converted) {
+    if (!created.has(table)) repairs.push(`converted ${table} collation from ${from} to ${to}`);
+  }
+  const freshInstall = [
+    ...DURABLE_TABLE_NAMES
+  ].every((table) => created.has(table));
+  return {
+    repairs,
+    freshInstall
+  };
 }
 __name(healDurableSchema, "healDurableSchema");
 function isSafeSqlIdentifier(value) {
@@ -845,17 +934,18 @@ function isSafeSqlIdentifier(value) {
 }
 __name(isSafeSqlIdentifier, "isSafeSqlIdentifier");
 async function alignDurableCollation(orm) {
+  const converted = [];
   const platform = String(orm.em.getPlatform().constructor.name).toLowerCase();
   if (!platform.includes("mysql") && !platform.includes("maria")) {
-    return;
+    return converted;
   }
   const collate = orm.config.get("collate");
   if (typeof collate !== "string" || !isSafeSqlIdentifier(collate)) {
-    return;
+    return converted;
   }
   const charset = collate.split("_")[0];
   if (!charset || !isSafeSqlIdentifier(charset)) {
-    return;
+    return converted;
   }
   const connection = orm.em.getConnection();
   for (const table of DURABLE_TABLE_NAMES) {
@@ -868,11 +958,17 @@ async function alignDurableCollation(orm) {
         continue;
       }
       await connection.execute(`alter table \`${table}\` convert to character set ${charset} collate ${collate}`);
+      converted.push({
+        table,
+        from: current,
+        to: collate
+      });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       console.warn(`[nestjs-durable-store-mikro-orm] could not align collation for \`${table}\` to ${collate} (left as-is): ${message}`);
     }
   }
+  return converted;
 }
 __name(alignDurableCollation, "alignDurableCollation");
 
@@ -882,10 +978,12 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     __name(this, "MikroOrmStateStore");
   }
   orm;
+  opts;
   scopeNamespace;
-  constructor(orm, opts) {
+  constructor(orm, opts = {}) {
     this.orm = orm;
-    this.scopeNamespace = opts?.scope?.namespace;
+    this.opts = opts;
+    this.scopeNamespace = opts.scope?.namespace;
   }
   /**
   * Derive a store confined to a single tenant `scope.namespace`, sharing this store's ORM (no new
@@ -895,6 +993,7 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
   */
   withScope(scope) {
     return new _MikroOrmStateStore(this.orm, {
+      ...this.opts,
       scope
     });
   }
@@ -912,7 +1011,9 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     return em;
   }
   async ensureSchema() {
-    await ensureMikroOrmDurableSchema(this.orm);
+    await ensureMikroOrmDurableSchema(this.orm, {
+      logger: this.opts.schemaLogger
+    });
   }
   async tryAdmitSingleton(runId, tag, workflow, limit, retryWakeAt) {
     return this.fork().transactional(async (em) => {
@@ -1011,6 +1112,17 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     });
     return entity ? fromRunEntity(entity) : null;
   }
+  async getRuns(runIds) {
+    if (runIds.length === 0) return [];
+    const rows = await this.fork().find(WorkflowRunEntity, {
+      id: {
+        $in: [
+          ...new Set(runIds)
+        ]
+      }
+    });
+    return rows.map(fromRunEntity);
+  }
   async deleteRun(runId) {
     const em = this.fork();
     await em.nativeDelete(StepCheckpointEntity, {
@@ -1254,10 +1366,13 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     });
     return affected === 1;
   }
-  async releaseRunLock(runId) {
+  async releaseRunLock(runId, owner) {
     const em = this.fork();
-    await em.nativeUpdate(WorkflowRunEntity, {
+    await em.nativeUpdate(WorkflowRunEntity, owner === void 0 ? {
       id: runId
+    } : {
+      id: runId,
+      lockedBy: owner
     }, {
       lockedBy: null,
       lockedUntil: null
@@ -2141,6 +2256,7 @@ export {
   WorkflowRunRepository,
   durableEntities,
   durableManagedTables,
-  ensureMikroOrmDurableSchema
+  ensureMikroOrmDurableSchema,
+  mikroOrmSchemaRepairWarning
 };
 //# sourceMappingURL=index.js.map