@dudousxd/nestjs-durable-store-drizzle 0.23.0 → 0.24.0

package/dist/pg/index.cjs

@@ -25,6 +25,7 @@ __export(pg_exports, {
   DURABLE_PG_DDL: () => DURABLE_PG_DDL,
   DrizzlePgStateStore: () => DrizzlePgStateStore,
   drizzlePgExecutor: () => drizzlePgExecutor,
+  drizzlePgSchemaRepairWarning: () => drizzlePgSchemaRepairWarning,
   durableBufferedEvents: () => durableBufferedEvents,
   durableBufferedSignals: () => durableBufferedSignals,
   durablePgManagedTables: () => durablePgManagedTables,
@@ -41,7 +42,41 @@ __export(pg_exports, {
 module.exports = __toCommonJS(pg_exports);
 
 // src/pg/ddl.ts
+var import_drizzle_orm2 = require("drizzle-orm");
+
+// src/pg/executor.ts
 var import_drizzle_orm = require("drizzle-orm");
+function toDrizzleSql(text2, params = []) {
+  const chunks = [];
+  let last = 0;
+  for (const match of text2.matchAll(/\$(\d+)/g)) {
+    const index2 = Number(match[1]) - 1;
+    if (index2 < 0 || index2 >= params.length) throw new Error(`placeholder ${match[0]} has no bound parameter`);
+    chunks.push(import_drizzle_orm.sql.raw(text2.slice(last, match.index)), import_drizzle_orm.sql`${params[index2]}`);
+    last = (match.index ?? 0) + match[0].length;
+  }
+  chunks.push(import_drizzle_orm.sql.raw(text2.slice(last)));
+  return import_drizzle_orm.sql.join(chunks);
+}
+__name(toDrizzleSql, "toDrizzleSql");
+function rowsOf(result) {
+  if (Array.isArray(result)) return result;
+  return result?.rows ?? [];
+}
+__name(rowsOf, "rowsOf");
+function drizzlePgExecutor(db) {
+  return {
+    dialect: "postgres",
+    escapeId: /* @__PURE__ */ __name((id) => `"${id.replace(/"/g, '""')}"`, "escapeId"),
+    query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await db.execute(toDrizzleSql(text2, params))), "query"),
+    transaction: /* @__PURE__ */ __name((fn) => db.transaction((tx) => fn({
+      query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await tx.execute(toDrizzleSql(text2, params))), "query")
+    })), "transaction")
+  };
+}
+__name(drizzlePgExecutor, "drizzlePgExecutor");
+
+// src/pg/ddl.ts
 var DURABLE_PG_DDL = [
   `CREATE TABLE IF NOT EXISTS "durable_workflow_runs" (
   "id" text PRIMARY KEY NOT NULL,
@@ -134,11 +169,71 @@ var DURABLE_PG_DDL = [
   `CREATE INDEX IF NOT EXISTS "durable_schedules_due_idx" ON "durable_schedules" USING btree ("paused","next_fire_at")`
 ];
 var SCHEMA_LOCK_KEY = "durable_schema";
-async function ensureDrizzlePgDurableSchema(db) {
-  await db.transaction(async (tx) => {
-    await tx.execute(import_drizzle_orm.sql`SELECT pg_advisory_xact_lock(hashtext(${SCHEMA_LOCK_KEY}))`);
-    for (const statement of DURABLE_PG_DDL) await tx.execute(import_drizzle_orm.sql.raw(statement));
+function drizzlePgSchemaRepairWarning(repairs) {
+  return [
+    `[nestjs-durable] store-drizzle 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, generate a drizzle-kit",
+    "migration from `durablePgSchema` (or apply `DURABLE_PG_DDL` in a migration). This warning",
+    "appears only when a repair was applied; a schema that is already current logs nothing."
+  ].join(" ");
+}
+__name(drizzlePgSchemaRepairWarning, "drizzlePgSchemaRepairWarning");
+function ddlTarget(statement) {
+  const table = statement.match(/^CREATE TABLE IF NOT EXISTS "([^"]+)"/i);
+  if (table?.[1]) return {
+    kind: "table",
+    table: table[1]
+  };
+  const index2 = statement.match(/^CREATE (?:UNIQUE )?INDEX (?:CONCURRENTLY )?IF NOT EXISTS "([^"]+)" ON "([^"]+)"/i);
+  if (index2?.[1] && index2[2]) return {
+    kind: "index",
+    index: index2[1],
+    table: index2[2]
+  };
+  const column = statement.match(/^ALTER TABLE "([^"]+)" ADD COLUMN IF NOT EXISTS "([^"]+)"/i);
+  if (column?.[1] && column[2]) return {
+    kind: "column",
+    table: column[1],
+    column: column[2]
+  };
+  return void 0;
+}
+__name(ddlTarget, "ddlTarget");
+async function ensureDrizzlePgDurableSchema(db, options = {}) {
+  const logger = options.logger ?? console;
+  const { repairs, freshInstall } = await db.transaction(async (tx) => {
+    await tx.execute(import_drizzle_orm2.sql`SELECT pg_advisory_xact_lock(hashtext(${SCHEMA_LOCK_KEY}))`);
+    const tables = new Set(rowsOf(await tx.execute(import_drizzle_orm2.sql.raw("SELECT tablename AS name FROM pg_tables WHERE schemaname = current_schema() AND left(tablename, 8) = 'durable_'"))).map((row) => row.name));
+    const indexes = new Set(rowsOf(await tx.execute(import_drizzle_orm2.sql.raw("SELECT indexname AS name FROM pg_indexes WHERE schemaname = current_schema() AND left(tablename, 8) = 'durable_'"))).map((row) => row.name));
+    const columns = new Set(rowsOf(await tx.execute(import_drizzle_orm2.sql.raw("SELECT table_name || '.' || column_name AS name FROM information_schema.columns WHERE table_schema = current_schema() AND left(table_name, 8) = 'durable_'"))).map((row) => row.name));
+    const created = /* @__PURE__ */ new Set();
+    const ddlTables = /* @__PURE__ */ new Set();
+    const applied = [];
+    for (const statement of DURABLE_PG_DDL) {
+      const target = ddlTarget(statement);
+      await tx.execute(import_drizzle_orm2.sql.raw(statement));
+      if (!target) continue;
+      if (target.kind === "table") {
+        ddlTables.add(target.table);
+        if (!tables.has(target.table)) {
+          created.add(target.table);
+          applied.push(`created table ${target.table}`);
+        }
+      } else if (created.has(target.table)) {
+      } else if (target.kind === "index" && !indexes.has(target.index)) {
+        applied.push(`created index ${target.index} on ${target.table}`);
+      } else if (target.kind === "column" && !columns.has(`${target.table}.${target.column}`)) {
+        applied.push(`added column ${target.table}.${target.column}`);
+      }
+    }
+    return {
+      repairs: applied,
+      freshInstall: created.size === ddlTables.size
+    };
   });
+  if (repairs.length > 0 && !freshInstall) logger.warn(drizzlePgSchemaRepairWarning(repairs));
 }
 __name(ensureDrizzlePgDurableSchema, "ensureDrizzlePgDurableSchema");
 
@@ -146,38 +241,6 @@ __name(ensureDrizzlePgDurableSchema, "ensureDrizzlePgDurableSchema");
 var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
 var import_drizzle_orm4 = require("drizzle-orm");
 
-// src/pg/executor.ts
-var import_drizzle_orm2 = require("drizzle-orm");
-function toDrizzleSql(text2, params = []) {
-  const chunks = [];
-  let last = 0;
-  for (const match of text2.matchAll(/\$(\d+)/g)) {
-    const index2 = Number(match[1]) - 1;
-    if (index2 < 0 || index2 >= params.length) throw new Error(`placeholder ${match[0]} has no bound parameter`);
-    chunks.push(import_drizzle_orm2.sql.raw(text2.slice(last, match.index)), import_drizzle_orm2.sql`${params[index2]}`);
-    last = (match.index ?? 0) + match[0].length;
-  }
-  chunks.push(import_drizzle_orm2.sql.raw(text2.slice(last)));
-  return import_drizzle_orm2.sql.join(chunks);
-}
-__name(toDrizzleSql, "toDrizzleSql");
-function rowsOf(result) {
-  if (Array.isArray(result)) return result;
-  return result?.rows ?? [];
-}
-__name(rowsOf, "rowsOf");
-function drizzlePgExecutor(db) {
-  return {
-    dialect: "postgres",
-    escapeId: /* @__PURE__ */ __name((id) => `"${id.replace(/"/g, '""')}"`, "escapeId"),
-    query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await db.execute(toDrizzleSql(text2, params))), "query"),
-    transaction: /* @__PURE__ */ __name((fn) => db.transaction((tx) => fn({
-      query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await tx.execute(toDrizzleSql(text2, params))), "query")
-    })), "transaction")
-  };
-}
-__name(drizzlePgExecutor, "drizzlePgExecutor");
-
 // src/pg/schema.ts
 var import_drizzle_orm3 = require("drizzle-orm");
 var import_pg_core = require("drizzle-orm/pg-core");
@@ -390,7 +453,9 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   /** Idempotent CREATE TABLE / INDEX IF NOT EXISTS under an advisory lock — called on boot when the
   *  module's `autoSchema` is on. Turn `autoSchema` off if drizzle-kit owns these tables. */
   async ensureSchema() {
-    await ensureDrizzlePgDurableSchema(this.db);
+    await ensureDrizzlePgDurableSchema(this.db, {
+      logger: this.options.schemaLogger
+    });
   }
   /** The read-scope predicate on the runs table (undefined when the store is unscoped). */
   scope() {
@@ -588,11 +653,11 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     });
     return rows.length === 1;
   }
-  async releaseRunLock(runId) {
+  async releaseRunLock(runId, owner) {
     await this.db.update(durableWorkflowRuns).set({
       lockedBy: null,
       lockedUntil: null
-    }).where((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId));
+    }).where(owner === void 0 ? (0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId) : (0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId), (0, import_drizzle_orm4.eq)(durableWorkflowRuns.lockedBy, owner)));
   }
   async renewRunLock(runId, owner, leaseUntilMs) {
     const rows = await this.db.update(durableWorkflowRuns).set({
@@ -1140,6 +1205,7 @@ __name(excludedSet, "excludedSet");
   DURABLE_PG_DDL,
   DrizzlePgStateStore,
   drizzlePgExecutor,
+  drizzlePgSchemaRepairWarning,
   durableBufferedEvents,
   durableBufferedSignals,
   durablePgManagedTables,