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

package/dist/index.cjs

@@ -39,7 +39,8 @@ __export(index_exports, {
   WorkflowRunRepository: () => WorkflowRunRepository,
   durableEntities: () => durableEntities,
   durableManagedTables: () => durableManagedTables,
-  ensureMikroOrmDurableSchema: () => ensureMikroOrmDurableSchema
+  ensureMikroOrmDurableSchema: () => ensureMikroOrmDurableSchema,
+  mikroOrmSchemaRepairWarning: () => mikroOrmSchemaRepairWarning
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -721,6 +722,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;
 }
@@ -839,7 +912,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);
@@ -852,8 +926,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);
   }
@@ -868,9 +943,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;
@@ -879,7 +959,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) {
@@ -887,17 +977,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) {
@@ -910,11 +1001,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");
 
@@ -924,10 +1021,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
@@ -937,6 +1036,7 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
   */
   withScope(scope) {
     return new _MikroOrmStateStore(this.orm, {
+      ...this.opts,
       scope
     });
   }
@@ -954,7 +1054,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) => {
@@ -1053,6 +1155,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, {
@@ -1296,10 +1409,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
@@ -2184,6 +2300,7 @@ __name(fromScheduleEntity, "fromScheduleEntity");
   WorkflowRunRepository,
   durableEntities,
   durableManagedTables,
-  ensureMikroOrmDurableSchema
+  ensureMikroOrmDurableSchema,
+  mikroOrmSchemaRepairWarning
 });
 //# sourceMappingURL=index.cjs.map