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

package/dist/index.cjs

@@ -25,6 +25,8 @@ __export(index_exports, {
   BufferedEventRepository: () => BufferedEventRepository,
   BufferedSignalEntity: () => BufferedSignalEntity,
   BufferedSignalRepository: () => BufferedSignalRepository,
+  DATETIME_PRECISION: () => DATETIME_PRECISION,
+  DEFAULT_BLOCKING_ALTER_ROW_LIMIT: () => DEFAULT_BLOCKING_ALTER_ROW_LIMIT,
   ENTITIES: () => ENTITIES,
   MikroOrmStateStore: () => MikroOrmStateStore,
   RunAttributeEntity: () => RunAttributeEntity,
@@ -40,6 +42,7 @@ __export(index_exports, {
   durableEntities: () => durableEntities,
   durableManagedTables: () => durableManagedTables,
   ensureMikroOrmDurableSchema: () => ensureMikroOrmDurableSchema,
+  mikroOrmDeferredAlterWarning: () => mikroOrmDeferredAlterWarning,
   mikroOrmSchemaRepairWarning: () => mikroOrmSchemaRepairWarning
 });
 module.exports = __toCommonJS(index_exports);
@@ -90,6 +93,7 @@ function snakeCase(property) {
   return property.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
 }
 __name(snakeCase, "snakeCase");
+var DATETIME_PRECISION = 6;
 function columnNamer(naming) {
   if (naming === "snake_case") return snakeCase;
   if (naming === "preserve") return (property) => property;
@@ -296,6 +300,7 @@ function durableEntities(options = {}) {
       },
       wakeAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         nullable: true,
         fieldName: col("wakeAt")
       },
@@ -306,6 +311,7 @@ function durableEntities(options = {}) {
       },
       lockedUntil: {
         type: "Date",
+        length: DATETIME_PRECISION,
         nullable: true,
         fieldName: col("lockedUntil")
       },
@@ -368,10 +374,12 @@ function durableEntities(options = {}) {
       },
       createdAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         fieldName: col("createdAt")
       },
       updatedAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         fieldName: col("updatedAt")
       }
     }
@@ -460,20 +468,24 @@ function durableEntities(options = {}) {
       },
       wakeAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         nullable: true,
         fieldName: col("wakeAt")
       },
       enqueuedAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         nullable: true,
         fieldName: col("enqueuedAt")
       },
       startedAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         fieldName: col("startedAt")
       },
       finishedAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         fieldName: col("finishedAt")
       }
     }
@@ -618,6 +630,7 @@ function durableEntities(options = {}) {
       },
       publishedAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         fieldName: col("publishedAt")
       }
     }
@@ -676,10 +689,12 @@ function durableEntities(options = {}) {
       },
       createdAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         fieldName: col("createdAt")
       },
       updatedAt: {
         type: "Date",
+        length: DATETIME_PRECISION,
         fieldName: col("updatedAt")
       }
     }
@@ -722,6 +737,21 @@ var MARKER_TABLE = "durable_schema_meta";
 var MARKER_ROW_ID = "durable";
 var SCHEMA_LOCK_NAME = "durable_schema";
 var SCHEMA_REVISION = 1;
+var DEFAULT_BLOCKING_ALTER_ROW_LIMIT = 1e5;
+function deferredAlterWarning(store, deferred, limit) {
+  return [
+    `[nestjs-durable] ${store} did NOT apply ${deferred.length} durable-schema column type change(s) at boot.`,
+    `MySQL rebuilds a table to change a column type and blocks writes to it until the copy ends, and these tables hold more than blockingAlterRowLimit (${limit}) rows:`,
+    ...deferred.map((d) => `  -- ${d.table}, ~${d.rows} rows
+  ${d.statement};`),
+    "Run them in a maintenance window or with an online schema change tool (gh-ost, pt-online-schema-change), or raise blockingAlterRowLimit to let a boot run them. Until then the store keeps working on the old column types, and this warning repeats on every boot."
+  ].join("\n");
+}
+__name(deferredAlterWarning, "deferredAlterWarning");
+function mikroOrmDeferredAlterWarning(deferred, limit) {
+  return deferredAlterWarning("store-mikro-orm", deferred, limit);
+}
+__name(mikroOrmDeferredAlterWarning, "mikroOrmDeferredAlterWarning");
 function mikroOrmSchemaRepairWarning(repairs) {
   return [
     `[nestjs-durable] store-mikro-orm repaired the durable schema at boot: ${repairs.join("; ")}.`,
@@ -926,29 +956,43 @@ async function ensureMikroOrmDurableSchema(orm, options = {}) {
     if (await readStoredFingerprint(orm) === expected) {
       return;
     }
-    const { repairs, freshInstall } = await healDurableSchema(orm);
-    await writeFingerprint(orm, dialect, expected);
+    const limit = options.blockingAlterRowLimit ?? DEFAULT_BLOCKING_ALTER_ROW_LIMIT;
+    const { repairs, freshInstall, deferred } = await healDurableSchema(orm, dialect, limit);
+    if (deferred.length === 0) await writeFingerprint(orm, dialect, expected);
     if (repairs.length > 0 && !freshInstall) logger.warn(mikroOrmSchemaRepairWarning(repairs));
+    if (deferred.length > 0) logger.warn(mikroOrmDeferredAlterWarning(deferred, limit));
   } finally {
     await releaseSchemaLock(orm, dialect);
   }
 }
 __name(ensureMikroOrmDurableSchema, "ensureMikroOrmDurableSchema");
-async function healDurableSchema(orm) {
+async function healDurableSchema(orm, dialect, blockingAlterRowLimit) {
   const sql = await orm.schema.getUpdateSchemaSQL({
     safe: true
   });
-  const ours = sql.split(";").map((statement) => statement.trim()).filter((statement) => {
+  const ours = mergeColumnTypeChanges(sql.split(";").map((statement) => statement.trim()).filter((statement) => {
     const table = targetTable(statement);
     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 = [];
+  const deferred = [];
   for (const statement of ours) {
+    const table = targetTable(statement);
+    if (dialect === "mysql" && !created.has(table) && isColumnTypeChange(statement)) {
+      const rows = await estimatedRowCount(orm, table);
+      if (rows > blockingAlterRowLimit) {
+        deferred.push({
+          table,
+          rows,
+          statement
+        });
+        continue;
+      }
+    }
     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) {
@@ -968,10 +1012,45 @@ async function healDurableSchema(orm) {
   ].every((table) => created.has(table));
   return {
     repairs,
-    freshInstall
+    freshInstall,
+    deferred
   };
 }
 __name(healDurableSchema, "healDurableSchema");
+function mergeColumnTypeChanges(statements) {
+  const merged = [];
+  const at = /* @__PURE__ */ new Map();
+  for (const statement of statements) {
+    const table = targetTable(statement);
+    if (!table || !isColumnTypeChange(statement)) {
+      merged.push(statement);
+      continue;
+    }
+    const actions = statement.replace(/^alter\s+table\s+[`"']?[\w$]+[`"']?\s*/i, "");
+    const index = at.get(table);
+    if (index === void 0) {
+      at.set(table, merged.length);
+      merged.push(statement);
+    } else {
+      merged[index] = `${merged[index]}, ${actions}`;
+    }
+  }
+  return merged;
+}
+__name(mergeColumnTypeChanges, "mergeColumnTypeChanges");
+function isColumnTypeChange(statement) {
+  if (!/^alter\s+table\b/i.test(statement)) return false;
+  const actions = splitTopLevel(statement.replace(/^alter\s+table\s+[`"']?[\w$]+[`"']?\s*/i, ""));
+  return actions.length > 0 && actions.every((action) => /^modify\b/i.test(action));
+}
+__name(isColumnTypeChange, "isColumnTypeChange");
+async function estimatedRowCount(orm, table) {
+  const rows = await orm.em.getConnection().execute("select table_rows as table_rows from information_schema.tables where table_schema = database() and table_name = ? limit 1", [
+    table
+  ]);
+  return Number(rows[0]?.table_rows ?? 0);
+}
+__name(estimatedRowCount, "estimatedRowCount");
 function isSafeSqlIdentifier(value) {
   return /^[A-Za-z0-9_]+$/.test(value);
 }
@@ -1055,7 +1134,8 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
   }
   async ensureSchema() {
     await ensureMikroOrmDurableSchema(this.orm, {
-      logger: this.opts.schemaLogger
+      logger: this.opts.schemaLogger,
+      blockingAlterRowLimit: this.opts.schemaBlockingAlterRowLimit
     });
   }
   async tryAdmitSingleton(runId, tag, workflow, limit, retryWakeAt) {
@@ -2286,6 +2366,8 @@ __name(fromScheduleEntity, "fromScheduleEntity");
   BufferedEventRepository,
   BufferedSignalEntity,
   BufferedSignalRepository,
+  DATETIME_PRECISION,
+  DEFAULT_BLOCKING_ALTER_ROW_LIMIT,
   ENTITIES,
   MikroOrmStateStore,
   RunAttributeEntity,
@@ -2301,6 +2383,7 @@ __name(fromScheduleEntity, "fromScheduleEntity");
   durableEntities,
   durableManagedTables,
   ensureMikroOrmDurableSchema,
+  mikroOrmDeferredAlterWarning,
   mikroOrmSchemaRepairWarning
 });
 //# sourceMappingURL=index.cjs.map