forge-sql-orm 2.1.5 → 2.1.7

package/dist/ForgeSQLORM.mjs

@@ -1016,7 +1016,7 @@ class ForgeSQLSelectOperations {
   }
 }
 const metadataQueryContext = new AsyncLocalStorage();
-async function saveMetaDataInContextContext(metadata) {
+async function saveMetaDataToContext(metadata) {
   const context = metadataQueryContext.getStore();
   if (context && metadata) {
     context.totalResponseSize += metadata.responseSize;
@@ -1027,26 +1027,101 @@ async function saveMetaDataInContextContext(metadata) {
 async function getLastestMetadata() {
   return metadataQueryContext.getStore();
 }
-const forgeDriver = async (query, params, method) => {
-  if (method == "execute") {
-    const sqlStatement = sql$1.prepare(query);
-    if (params) {
-      sqlStatement.bindParams(...params);
+const operationTypeQueryContext = new AsyncLocalStorage();
+async function getOperationType() {
+  return operationTypeQueryContext.getStore()?.operationType ?? "DML";
+}
+function isUpdateQueryResponse(obj) {
+  return obj !== null && typeof obj === "object" && typeof obj.affectedRows === "number" && typeof obj.insertId === "number";
+}
+async function withTimeout$1(promise, timeoutMs = 1e4) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(
+        new Error(
+          `Atlassian @forge/sql did not return a response within ${timeoutMs}ms (${timeoutMs / 1e3} seconds), so the request is blocked. Possible causes: slow query, network issues, or exceeding Forge SQL limits.`
+        )
+      );
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
     }
-    const updateQueryResponseResults = await sqlStatement.execute();
-    let result = updateQueryResponseResults.rows;
-    return { ...result, rows: [result] };
-  } else {
-    const sqlStatement = await sql$1.prepare(query);
-    if (params) {
-      await sqlStatement.bindParams(...params);
+  }
+}
+function inlineParams(sql2, params) {
+  let i = 0;
+  return sql2.replace(/\?/g, () => {
+    const val = params[i++];
+    if (val === null) return "NULL";
+    if (typeof val === "number") return val.toString();
+    return `'${String(val).replace(/'/g, "''")}'`;
+  });
+}
+async function processDDLResult(method, result) {
+  if (result.metadata) {
+    await saveMetaDataToContext(result.metadata);
+  }
+  if (!result?.rows) {
+    return { rows: [] };
+  }
+  if (isUpdateQueryResponse(result.rows)) {
+    const oneRow = result.rows;
+    return { ...oneRow, rows: [oneRow] };
+  }
+  if (Array.isArray(result.rows)) {
+    if (method === "execute") {
+      return { rows: result.rows };
+    } else {
+      const rows = result.rows.map((r) => Object.values(r));
+      return { rows };
     }
-    const result = await sqlStatement.execute();
-    await saveMetaDataInContextContext(result.metadata);
-    let rows;
-    rows = result.rows.map((r) => Object.values(r));
-    return { rows };
   }
+  return { rows: [] };
+}
+async function processExecuteMethod(query, params) {
+  const sqlStatement = sql$1.prepare(query);
+  if (params) {
+    sqlStatement.bindParams(...params);
+  }
+  const result = await withTimeout$1(sqlStatement.execute());
+  await saveMetaDataToContext(result.metadata);
+  if (!result?.rows) {
+    return { rows: [] };
+  }
+  if (isUpdateQueryResponse(result.rows)) {
+    const oneRow = result.rows;
+    return { ...oneRow, rows: [oneRow] };
+  }
+  return { rows: result.rows };
+}
+async function processAllMethod(query, params) {
+  const sqlStatement = await sql$1.prepare(query);
+  if (params) {
+    await sqlStatement.bindParams(...params);
+  }
+  const result = await withTimeout$1(sqlStatement.execute());
+  await saveMetaDataToContext(result.metadata);
+  if (!result?.rows) {
+    return { rows: [] };
+  }
+  const rows = result.rows.map((r) => Object.values(r));
+  return { rows };
+}
+const forgeDriver = async (query, params, method) => {
+  const operationType = await getOperationType();
+  if (operationType === "DDL") {
+    const result = await withTimeout$1(sql$1.executeDDL(inlineParams(query, params)));
+    return await processDDLResult(method, result);
+  }
+  if (method === "execute") {
+    return await processExecuteMethod(query, params ?? []);
+  }
+  return await processAllMethod(query, params ?? []);
 };
 function injectSqlHints(query, hints) {
   if (!hints) {
@@ -1120,7 +1195,7 @@ async function handleSuccessfulExecution(rows, onfulfilled, table, options, isCa
     if (isCached && !cacheApplicationContext.getStore()) {
       await clearCache(table, options);
     }
-    const result = onfulfilled?.(rows);
+    const result = onfulfilled ? onfulfilled(rows) : rows;
     return result;
   } catch (error) {
     if (shouldClearCacheOnError(error)) {
@@ -1191,11 +1266,11 @@ async function handleCachedQuery(target, options, cacheTtl, selections, aliasMap
   try {
     const localCached = await getQueryLocalCacheQuery(target, options);
     if (localCached) {
-      return onfulfilled?.(localCached);
+      return onfulfilled ? onfulfilled(localCached) : localCached;
     }
     const cacheResult = await getFromCache(target, options);
     if (cacheResult) {
-      return onfulfilled?.(cacheResult);
+      return onfulfilled ? onfulfilled(cacheResult) : cacheResult;
     }
     const rows = await target.execute();
     const transformed = applyFromDriverTransform(rows, selections, aliasMap);
@@ -1203,23 +1278,29 @@ async function handleCachedQuery(target, options, cacheTtl, selections, aliasMap
     await setCacheResult(target, options, transformed, cacheTtl).catch((cacheError) => {
       console.warn("Cache set error:", cacheError);
     });
-    return onfulfilled?.(transformed);
+    return onfulfilled ? onfulfilled(transformed) : transformed;
   } catch (error) {
-    return onrejected?.(error);
+    if (onrejected) {
+      return onrejected(error);
+    }
+    throw error;
   }
 }
 async function handleNonCachedQuery(target, options, selections, aliasMap, onfulfilled, onrejected) {
   try {
     const localCached = await getQueryLocalCacheQuery(target, options);
     if (localCached) {
-      return onfulfilled?.(localCached);
+      return onfulfilled ? onfulfilled(localCached) : localCached;
     }
     const rows = await target.execute();
     const transformed = applyFromDriverTransform(rows, selections, aliasMap);
     await saveQueryLocalCacheQuery(target, transformed, options);
-    return onfulfilled?.(transformed);
+    return onfulfilled ? onfulfilled(transformed) : transformed;
   } catch (error) {
-    return onrejected?.(error);
+    if (onrejected) {
+      return onrejected(error);
+    }
+    throw error;
   }
 }
 function createAliasedSelectBuilder(db, fields, selectFn, useCache, options, cacheTtl) {
@@ -1288,10 +1369,8 @@ function createRawQueryExecutor(db, options, useGlobalCache = false) {
   return async function(query, cacheTtl) {
     let sql2;
     if (isSQLWrapper(query)) {
-      const sqlWrapper = query;
-      sql2 = sqlWrapper.getSQL().toQuery(
-        db.dialect
-      );
+      const dialect = db.dialect;
+      sql2 = dialect.sqlToQuery(query);
     } else {
       sql2 = {
         sql: query,
@@ -1840,19 +1919,26 @@ class ForgeSQLORMImpl {
    * ```
    */
   async executeWithMetadata(query, onMetadata) {
-    return metadataQueryContext.run({
-      totalDbExecutionTime: 0,
-      totalResponseSize: 0
-    }, async () => {
-      try {
-        return await query();
-      } finally {
-        const metadata = await getLastestMetadata();
-        if (metadata && metadata.lastMetadata) {
-          await onMetadata(metadata.totalDbExecutionTime, metadata.totalResponseSize, metadata.lastMetadata);
+    return metadataQueryContext.run(
+      {
+        totalDbExecutionTime: 0,
+        totalResponseSize: 0
+      },
+      async () => {
+        try {
+          return await query();
+        } finally {
+          const metadata = await getLastestMetadata();
+          if (metadata && metadata.lastMetadata) {
+            await onMetadata(
+              metadata.totalDbExecutionTime,
+              metadata.totalResponseSize,
+              metadata.lastMetadata
+            );
+          }
         }
       }
-    });
+    );
   }
   /**
    * Executes operations within a cache context that collects cache eviction events.
@@ -2235,6 +2321,97 @@ class ForgeSQLORMImpl {
   execute(query) {
     return this.drizzle.executeQuery(query);
   }
+  /**
+   * Executes a Data Definition Language (DDL) SQL query.
+   * DDL operations include CREATE, ALTER, DROP, TRUNCATE, and other schema modification statements.
+   *
+   * This method is specifically designed for DDL operations and provides:
+   * - Proper operation type context for DDL queries
+   * - No caching (DDL operations should not be cached)
+   * - Direct execution without query optimization
+   *
+   * @template T - The expected return type of the query result
+   * @param query - The DDL SQL query to execute (SQLWrapper or string)
+   * @returns Promise with query results
+   * @throws {Error} If the DDL operation fails
+   *
+   * @example
+   * ```typescript
+   * // Create a new table
+   * await forgeSQL.executeDDL(`
+   *   CREATE TABLE users (
+   *     id INT PRIMARY KEY AUTO_INCREMENT,
+   *     name VARCHAR(255) NOT NULL,
+   *     email VARCHAR(255) UNIQUE
+   *   )
+   * `);
+   *
+   * // Alter table structure
+   * await forgeSQL.executeDDL(sql`
+   *   ALTER TABLE users
+   *   ADD COLUMN created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+   * `);
+   *
+   * // Drop a table
+   * await forgeSQL.executeDDL("DROP TABLE IF EXISTS old_users");
+   * ```
+   */
+  async executeDDL(query) {
+    return this.executeDDLActions(async () => this.drizzle.executeQuery(query));
+  }
+  /**
+   * Executes a series of actions within a DDL operation context.
+   * This method provides a way to execute regular SQL queries that should be treated
+   * as DDL operations, ensuring proper operation type context for performance monitoring.
+   *
+   * This method is useful for:
+   * - Executing regular SQL queries in DDL context for monitoring purposes
+   * - Wrapping non-DDL operations that should be treated as DDL for analysis
+   * - Ensuring proper operation type context for complex workflows
+   * - Maintaining DDL operation context across multiple function calls
+   *
+   * @template T - The return type of the actions function
+   * @param actions - Function containing SQL operations to execute in DDL context
+   * @returns Promise that resolves to the return value of the actions function
+   *
+   * @example
+   * ```typescript
+   * // Execute regular SQL queries in DDL context for monitoring
+   * await forgeSQL.executeDDLActions(async () => {
+   *   const slowQueries = await forgeSQL.execute(`
+   *     SELECT * FROM INFORMATION_SCHEMA.STATEMENTS_SUMMARY
+   *     WHERE AVG_LATENCY > 1000000
+   *   `);
+   *   return slowQueries;
+   * });
+   *
+   * // Execute complex analysis queries in DDL context
+   * const result = await forgeSQL.executeDDLActions(async () => {
+   *   const tableInfo = await forgeSQL.execute("SHOW TABLES");
+   *   const performanceData = await forgeSQL.execute(`
+   *     SELECT * FROM INFORMATION_SCHEMA.CLUSTER_STATEMENTS_SUMMARY_HISTORY
+   *     WHERE SUMMARY_END_TIME > DATE_SUB(NOW(), INTERVAL 1 HOUR)
+   *   `);
+   *   return { tableInfo, performanceData };
+   * });
+   *
+   * // Execute monitoring queries with error handling
+   * try {
+   *   await forgeSQL.executeDDLActions(async () => {
+   *     const metrics = await forgeSQL.execute(`
+   *       SELECT COUNT(*) as query_count
+   *       FROM INFORMATION_SCHEMA.STATEMENTS_SUMMARY
+   *     `);
+   *     console.log(`Total queries: ${metrics[0].query_count}`);
+   *   });
+   * } catch (error) {
+   *   console.error("Monitoring query failed:", error);
+   * }
+   * ```
+   */
+  async executeDDLActions(actions) {
+    return operationTypeQueryContext.run({ operationType: "DDL" }, async () => actions());
+  }
   /**
    * Executes a raw SQL query with both local and global cache support.
    * This method provides comprehensive caching for raw SQL queries:
@@ -2582,7 +2759,98 @@ class ForgeSQLORM {
    * ```
    */
   execute(query) {
-    return this.ormInstance.getDrizzleQueryBuilder().executeQuery(query);
+    return this.ormInstance.execute(query);
+  }
+  /**
+   * Executes a Data Definition Language (DDL) SQL query.
+   * DDL operations include CREATE, ALTER, DROP, TRUNCATE, and other schema modification statements.
+   *
+   * This method is specifically designed for DDL operations and provides:
+   * - Proper operation type context for DDL queries
+   * - No caching (DDL operations should not be cached)
+   * - Direct execution without query optimization
+   *
+   * @template T - The expected return type of the query result
+   * @param query - The DDL SQL query to execute (SQLWrapper or string)
+   * @returns Promise with query results
+   * @throws {Error} If the DDL operation fails
+   *
+   * @example
+   * ```typescript
+   * // Create a new table
+   * await forgeSQL.executeDDL(`
+   *   CREATE TABLE users (
+   *     id INT PRIMARY KEY AUTO_INCREMENT,
+   *     name VARCHAR(255) NOT NULL,
+   *     email VARCHAR(255) UNIQUE
+   *   )
+   * `);
+   *
+   * // Alter table structure
+   * await forgeSQL.executeDDL(sql`
+   *   ALTER TABLE users
+   *   ADD COLUMN created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+   * `);
+   *
+   * // Drop a table
+   * await forgeSQL.executeDDL("DROP TABLE IF EXISTS old_users");
+   * ```
+   */
+  executeDDL(query) {
+    return this.ormInstance.executeDDL(query);
+  }
+  /**
+   * Executes a series of actions within a DDL operation context.
+   * This method provides a way to execute regular SQL queries that should be treated
+   * as DDL operations, ensuring proper operation type context for performance monitoring.
+   *
+   * This method is useful for:
+   * - Executing regular SQL queries in DDL context for monitoring purposes
+   * - Wrapping non-DDL operations that should be treated as DDL for analysis
+   * - Ensuring proper operation type context for complex workflows
+   * - Maintaining DDL operation context across multiple function calls
+   *
+   * @template T - The return type of the actions function
+   * @param actions - Function containing SQL operations to execute in DDL context
+   * @returns Promise that resolves to the return value of the actions function
+   *
+   * @example
+   * ```typescript
+   * // Execute regular SQL queries in DDL context for monitoring
+   * await forgeSQL.executeDDLActions(async () => {
+   *   const slowQueries = await forgeSQL.execute(`
+   *     SELECT * FROM INFORMATION_SCHEMA.STATEMENTS_SUMMARY
+   *     WHERE AVG_LATENCY > 1000000
+   *   `);
+   *   return slowQueries;
+   * });
+   *
+   * // Execute complex analysis queries in DDL context
+   * const result = await forgeSQL.executeDDLActions(async () => {
+   *   const tableInfo = await forgeSQL.execute("SHOW TABLES");
+   *   const performanceData = await forgeSQL.execute(`
+   *     SELECT * FROM INFORMATION_SCHEMA.CLUSTER_STATEMENTS_SUMMARY_HISTORY
+   *     WHERE SUMMARY_END_TIME > DATE_SUB(NOW(), INTERVAL 1 HOUR)
+   *   `);
+   *   return { tableInfo, performanceData };
+   * });
+   *
+   * // Execute monitoring queries with error handling
+   * try {
+   *   await forgeSQL.executeDDLActions(async () => {
+   *     const metrics = await forgeSQL.execute(`
+   *       SELECT COUNT(*) as query_count
+   *       FROM INFORMATION_SCHEMA.STATEMENTS_SUMMARY
+   *     `);
+   *     console.log(`Total queries: ${metrics[0].query_count}`);
+   *   });
+   * } catch (error) {
+   *   console.error("Monitoring query failed:", error);
+   * }
+   * ```
+   */
+  executeDDLActions(actions) {
+    return this.ormInstance.executeDDLActions(actions);
   }
   /**
    * Executes a raw SQL query with both local and global cache support.
@@ -2603,7 +2871,7 @@ class ForgeSQLORM {
    * ```
    */
   executeCacheable(query, cacheTtl) {
-    return this.ormInstance.getDrizzleQueryBuilder().executeQueryCacheable(query, cacheTtl);
+    return this.ormInstance.executeCacheable(query, cacheTtl);
   }
   /**
    * Creates a Common Table Expression (CTE) builder for complex queries.
@@ -2613,7 +2881,7 @@ class ForgeSQLORM {
    * @example
    * ```typescript
    * const withQuery = forgeSQL.$with('userStats').as(
-   *   forgeSQL.select({ userId: users.id, count: sql<number>`count(*)` })
+   *   forgeSQL.getDrizzleQueryBuilder().select({ userId: users.id, count: sql<number>`count(*)` })
    *     .from(users)
    *     .groupBy(users.id)
    * );
@@ -2631,7 +2899,7 @@ class ForgeSQLORM {
    * @example
    * ```typescript
    * const withQuery = forgeSQL.$with('userStats').as(
-   *   forgeSQL.select({ userId: users.id, count: sql<number>`count(*)` })
+   *   forgeSQL.getDrizzleQueryBuilder().select({ userId: users.id, count: sql<number>`count(*)` })
    *     .from(users)
    *     .groupBy(users.id)
    * );
@@ -3122,6 +3390,14 @@ const clusterStatementsSummaryHistory = informationSchema.table(
   "CLUSTER_STATEMENTS_SUMMARY_HISTORY",
   createClusterStatementsSummarySchema()
 );
+const statementsSummaryHistory = informationSchema.table(
+  "STATEMENTS_SUMMARY_HISTORY",
+  createClusterStatementsSummarySchema()
+);
+const statementsSummary = informationSchema.table(
+  "STATEMENTS_SUMMARY",
+  createClusterStatementsSummarySchema()
+);
 const clusterStatementsSummary = informationSchema.table(
   "CLUSTER_STATEMENTS_SUMMARY",
   createClusterStatementsSummarySchema()
@@ -3154,12 +3430,12 @@ const applySchemaMigrations = async (migration) => {
     if (typeof migration !== "function") {
       throw new Error("migration is not a function");
     }
-    console.log("Provisioning the database");
+    console.debug("Provisioning the database");
     await sql$1._provision();
-    console.info("Running schema migrations");
+    console.debug("Running schema migrations");
     const migrations2 = await migration(migrationRunner);
     const successfulMigrations = await migrations2.run();
-    console.info("Migrations applied:", successfulMigrations);
+    console.debug("Migrations applied:", successfulMigrations);
     const migrationList = await migrationRunner.list();
     let migrationHistory = "No migrations found";
     if (Array.isArray(migrationList) && migrationList.length > 0) {
@@ -3168,7 +3444,7 @@ const applySchemaMigrations = async (migration) => {
       );
       migrationHistory = sortedMigrations.map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`).join("\n");
     }
-    console.info("Migrations history:\nid, name, migrated_at\n", migrationHistory);
+    console.debug("Migrations history:\nid, name, migrated_at\n", migrationHistory);
     return {
       headers: { "Content-Type": ["application/json"] },
       statusCode: 200,
@@ -3275,196 +3551,258 @@ const clearCacheSchedulerTrigger = async (options) => {
 };
 const DEFAULT_MEMORY_THRESHOLD = 8 * 1024 * 1024;
 const DEFAULT_TIMEOUT = 300;
-const topSlowestStatementLastHourTrigger = async (orm, options) => {
-  if (!orm) {
-    return {
-      statusCode: 500,
-      headers: { "Content-Type": ["application/json"] },
-      body: JSON.stringify({
-        success: false,
-        message: "ORM instance is required",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+const DEFAULT_TOP_N = 1;
+const DEFAULT_HOURS = 1;
+const DEFAULT_TABLES = "CLUSTER_SUMMARY_AND_HISTORY";
+const MAX_QUERY_TIMEOUT_MS = 3e3;
+const MAX_SQL_LENGTH = 1e3;
+const RETRY_ATTEMPTS = 2;
+const RETRY_BASE_DELAY_MS = 1e3;
+const nsToMs = (value) => {
+  const n = Number(value);
+  return Number.isFinite(n) ? n / 1e6 : NaN;
+};
+const bytesToMB = (value) => {
+  const n = Number(value);
+  return Number.isFinite(n) ? n / (1024 * 1024) : NaN;
+};
+const jsonSafeStringify = (value) => JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v);
+const sanitizeSQL = (sql2, maxLen = MAX_SQL_LENGTH) => {
+  let s = sql2;
+  s = s.replace(/--[^\n\r]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  s = s.replace(/'(?:\\'|[^'])*'/g, "?");
+  s = s.replace(/\b-?\d+(?:\.\d+)?\b/g, "?");
+  s = s.replace(/\s+/g, " ").trim();
+  if (s.length > maxLen) {
+    s = s.slice(0, maxLen) + " …[truncated]";
+  }
+  return s;
+};
+const withTimeout = async (promise, ms) => {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`TIMEOUT:${ms}`)), ms);
       })
-    };
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
   }
-  let newOptions = options ?? {
-    warnThresholdMs: DEFAULT_TIMEOUT,
-    memoryThresholdBytes: DEFAULT_MEMORY_THRESHOLD,
-    showPlan: false
-  };
-  const nsToMs = (v) => {
-    const n = Number(v);
-    return Number.isFinite(n) ? n / 1e6 : NaN;
-  };
-  const bytesToMB = (v) => {
-    const n = Number(v);
-    return Number.isFinite(n) ? n / (1024 * 1024) : NaN;
-  };
-  const jsonSafeStringify = (value) => JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v);
-  function sanitizeSQL(sql2, maxLen = 1e3) {
-    let s = sql2;
-    s = s.replace(/--[^\n\r]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
-    s = s.replace(/'(?:\\'|[^'])*'/g, "?");
-    s = s.replace(/\b-?\d+(?:\.\d+)?\b/g, "?");
-    s = s.replace(/\s+/g, " ").trim();
-    if (s.length > maxLen) {
-      s = s.slice(0, maxLen) + " …[truncated]";
-    }
-    return s;
-  }
-  const TOP_N = 1;
-  try {
-    const summaryHistory = clusterStatementsSummaryHistory;
-    const summary = clusterStatementsSummary;
-    const selectShape = (t) => ({
-      digest: t.digest,
-      stmtType: t.stmtType,
-      schemaName: t.schemaName,
-      execCount: t.execCount,
-      avgLatencyNs: t.avgLatency,
-      maxLatencyNs: t.maxLatency,
-      minLatencyNs: t.minLatency,
-      avgProcessTimeNs: t.avgProcessTime,
-      avgWaitTimeNs: t.avgWaitTime,
-      avgBackoffTimeNs: t.avgBackoffTime,
-      avgTotalKeys: t.avgTotalKeys,
-      firstSeen: t.firstSeen,
-      lastSeen: t.lastSeen,
-      planInCache: t.planInCache,
-      planCacheHits: t.planCacheHits,
-      digestText: t.digestText,
-      plan: t.plan,
-      avgMemBytes: t.avgMem,
-      maxMemBytes: t.maxMem
-    });
-    const lastHourFilterHistory = gte(
-      summaryHistory.summaryEndTime,
-      sql`DATE_SUB(NOW(), INTERVAL 1 HOUR)`
-    );
-    const lastHourFilterSummary = gte(
-      summary.summaryEndTime,
-      sql`DATE_SUB(NOW(), INTERVAL 1 HOUR)`
-    );
-    const qHistory = orm.getDrizzleQueryBuilder().select(selectShape(summaryHistory)).from(summaryHistory).where(lastHourFilterHistory);
-    const qSummary = orm.getDrizzleQueryBuilder().select(selectShape(summary)).from(summary).where(lastHourFilterSummary);
-    const combined = unionAll(qHistory, qSummary).as("combined");
-    const thresholdNs = Math.floor((newOptions.warnThresholdMs ?? DEFAULT_TIMEOUT) * 1e6);
-    const memoryThresholdBytes = newOptions.memoryThresholdBytes ?? DEFAULT_MEMORY_THRESHOLD;
-    const grouped = orm.getDrizzleQueryBuilder().select({
-      digest: combined.digest,
-      stmtType: combined.stmtType,
-      schemaName: combined.schemaName,
-      execCount: sql`SUM(${combined.execCount})`.as("execCount"),
-      avgLatencyNs: sql`MAX(${combined.avgLatencyNs})`.as("avgLatencyNs"),
-      maxLatencyNs: sql`MAX(${combined.maxLatencyNs})`.as("maxLatencyNs"),
-      minLatencyNs: sql`MIN(${combined.minLatencyNs})`.as("minLatencyNs"),
-      avgProcessTimeNs: sql`MAX(${combined.avgProcessTimeNs})`.as("avgProcessTimeNs"),
-      avgWaitTimeNs: sql`MAX(${combined.avgWaitTimeNs})`.as("avgWaitTimeNs"),
-      avgBackoffTimeNs: sql`MAX(${combined.avgBackoffTimeNs})`.as("avgBackoffTimeNs"),
-      avgMemBytes: sql`MAX(${combined.avgMemBytes})`.as("avgMemBytes"),
-      maxMemBytes: sql`MAX(${combined.maxMemBytes})`.as("maxMemBytes"),
-      avgTotalKeys: sql`MAX(${combined.avgTotalKeys})`.as("avgTotalKeys"),
-      firstSeen: sql`MIN(${combined.firstSeen})`.as("firstSeen"),
-      lastSeen: sql`MAX(${combined.lastSeen})`.as("lastSeen"),
-      planInCache: sql`MAX(${combined.planInCache})`.as("planInCache"),
-      planCacheHits: sql`SUM(${combined.planCacheHits})`.as("planCacheHits"),
-      // Prefer a non-empty sample text/plan via MAX; acceptable for de-dup
-      digestText: sql`MAX(${combined.digestText})`.as("digestText"),
-      plan: sql`MAX(${combined.plan})`.as("plan")
-    }).from(combined).where(
-      sql`COALESCE(${combined.digest}, '') <> '' AND COALESCE(${combined.digestText}, '') <> '' AND COALESCE(${combined.stmtType}, '') NOT IN ('Use','Set','Show')`
-    ).groupBy(combined.digest, combined.stmtType, combined.schemaName).as("grouped");
-    const rows = await orm.getDrizzleQueryBuilder().select({
-      digest: grouped.digest,
-      stmtType: grouped.stmtType,
-      schemaName: grouped.schemaName,
-      execCount: grouped.execCount,
-      avgLatencyNs: grouped.avgLatencyNs,
-      maxLatencyNs: grouped.maxLatencyNs,
-      minLatencyNs: grouped.minLatencyNs,
-      avgProcessTimeNs: grouped.avgProcessTimeNs,
-      avgWaitTimeNs: grouped.avgWaitTimeNs,
-      avgBackoffTimeNs: grouped.avgBackoffTimeNs,
-      avgMemBytes: grouped.avgMemBytes,
-      maxMemBytes: grouped.maxMemBytes,
-      avgTotalKeys: grouped.avgTotalKeys,
-      firstSeen: grouped.firstSeen,
-      lastSeen: grouped.lastSeen,
-      planInCache: grouped.planInCache,
-      planCacheHits: grouped.planCacheHits,
-      digestText: grouped.digestText,
-      plan: grouped.plan
-    }).from(grouped).where(
-      sql`${grouped.avgLatencyNs} > ${thresholdNs} OR ${grouped.avgMemBytes} > ${memoryThresholdBytes}`
-    ).orderBy(desc(grouped.avgLatencyNs)).limit(formatLimitOffset(TOP_N));
-    const formatted = rows.map((r, i) => ({
-      rank: i + 1,
-      // 1-based rank in the top N
-      digest: r.digest,
-      stmtType: r.stmtType,
-      schemaName: r.schemaName,
-      execCount: r.execCount,
-      avgLatencyMs: nsToMs(r.avgLatencyNs),
-      // Convert ns to ms for readability
-      maxLatencyMs: nsToMs(r.maxLatencyNs),
-      minLatencyMs: nsToMs(r.minLatencyNs),
-      avgProcessTimeMs: nsToMs(r.avgProcessTimeNs),
-      avgWaitTimeMs: nsToMs(r.avgWaitTimeNs),
-      avgBackoffTimeMs: nsToMs(r.avgBackoffTimeNs),
-      avgMemMB: bytesToMB(r.avgMemBytes),
-      maxMemMB: bytesToMB(r.maxMemBytes),
-      avgMemBytes: r.avgMemBytes,
-      maxMemBytes: r.maxMemBytes,
-      avgTotalKeys: r.avgTotalKeys,
-      firstSeen: r.firstSeen,
-      lastSeen: r.lastSeen,
-      planInCache: r.planInCache,
-      planCacheHits: r.planCacheHits,
-      digestText: sanitizeSQL(r.digestText),
-      plan: newOptions.showPlan ? r.plan : void 0
-    }));
-    for (const f of formatted) {
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const executeWithRetries = async (task, label) => {
+  let attempt = 0;
+  let delay = RETRY_BASE_DELAY_MS;
+  while (true) {
+    try {
+      attempt++;
+      return await task();
+    } catch (error) {
+      const msg = String(error?.message ?? error);
+      const isTimeout = msg.startsWith("TIMEOUT:");
+      if (attempt > RETRY_ATTEMPTS) throw error;
       console.warn(
-        `${f.rank}. ${f.stmtType}  avg=${f.avgLatencyMs?.toFixed?.(2)}ms  max=${f.maxLatencyMs?.toFixed?.(2)}ms  mem≈${f.avgMemMB?.toFixed?.(2)}MB(max ${f.maxMemMB?.toFixed?.(2)}MB)  exec=${f.execCount} 
-   digest=${f.digest}
-   sql=${(f.digestText || "").slice(0, 300)}${f.digestText && f.digestText.length > 300 ? "…" : ""}`
+        `${label}: attempt ${attempt} failed${isTimeout ? " (timeout)" : ""}; retrying in ${delay}ms...`,
+        error
       );
-      if (newOptions.showPlan && f.plan) {
-        console.warn(`   full plan:
-${f.plan}`);
-      }
+      await sleep(delay);
+      delay *= 2;
     }
-    return {
-      headers: { "Content-Type": ["application/json"] },
-      statusCode: 200,
-      statusText: "OK",
-      body: jsonSafeStringify({
-        success: true,
-        window: "last_1h",
-        top: TOP_N,
-        warnThresholdMs: newOptions.warnThresholdMs,
-        memoryThresholdBytes: newOptions.memoryThresholdBytes,
-        showPlan: newOptions.showPlan,
-        rows: formatted,
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      })
-    };
+  }
+};
+const createErrorResponse = (message, error) => ({
+  headers: { "Content-Type": ["application/json"] },
+  statusCode: 500,
+  statusText: "Internal Server Error",
+  body: jsonSafeStringify({
+    success: false,
+    message,
+    error: error?.cause?.context?.debug?.sqlMessage ?? error?.cause?.message ?? error?.message,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  })
+});
+const createSuccessResponse = (formatted, options) => ({
+  headers: { "Content-Type": ["application/json"] },
+  statusCode: 200,
+  statusText: "OK",
+  body: jsonSafeStringify({
+    success: true,
+    window: `last_${options.hours}h`,
+    top: options.topN,
+    warnThresholdMs: options.warnThresholdMs,
+    memoryThresholdBytes: options.memoryThresholdBytes,
+    showPlan: options.showPlan,
+    rows: formatted,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  })
+});
+const createSelectShape = (table) => ({
+  digest: table.digest,
+  stmtType: table.stmtType,
+  schemaName: table.schemaName,
+  execCount: table.execCount,
+  avgLatencyNs: table.avgLatency,
+  maxLatencyNs: table.maxLatency,
+  minLatencyNs: table.minLatency,
+  avgProcessTimeNs: table.avgProcessTime,
+  avgWaitTimeNs: table.avgWaitTime,
+  avgBackoffTimeNs: table.avgBackoffTime,
+  avgTotalKeys: table.avgTotalKeys,
+  firstSeen: table.firstSeen,
+  lastSeen: table.lastSeen,
+  planInCache: table.planInCache,
+  planCacheHits: table.planCacheHits,
+  digestText: table.digestText,
+  plan: table.plan,
+  avgMemBytes: table.avgMem,
+  maxMemBytes: table.maxMem
+});
+const buildCombinedQuery = (orm, options) => {
+  const summaryHistory = statementsSummary;
+  const summary = statementsSummary;
+  const summaryHistoryCluster = clusterStatementsSummaryHistory;
+  const summaryCluster = clusterStatementsSummary;
+  const lastHoursFilter = (table) => gte(table.summaryEndTime, sql`DATE_SUB(NOW(), INTERVAL ${options.hours} HOUR)`);
+  const qHistory = orm.getDrizzleQueryBuilder().select(createSelectShape(summaryHistory)).from(summaryHistory).where(lastHoursFilter(summaryHistory));
+  const qSummary = orm.getDrizzleQueryBuilder().select(createSelectShape(summary)).from(summary).where(lastHoursFilter(summary));
+  const qHistoryCluster = orm.getDrizzleQueryBuilder().select(createSelectShape(summaryHistoryCluster)).from(summaryHistoryCluster).where(lastHoursFilter(summaryHistoryCluster));
+  const qSummaryCluster = orm.getDrizzleQueryBuilder().select(createSelectShape(summaryCluster)).from(summaryCluster).where(lastHoursFilter(summaryCluster));
+  switch (options.tables) {
+    case "SUMMARY_AND_HISTORY":
+      return unionAll(qHistory, qSummary).as("combined");
+    case "CLUSTER_SUMMARY_AND_HISTORY":
+      return unionAll(qHistoryCluster, qSummaryCluster).as("combined");
+    default:
+      throw new Error(`Unsupported table configuration: ${options.tables}`);
+  }
+};
+const buildGroupedQuery = (orm, combined) => {
+  return orm.getDrizzleQueryBuilder().select({
+    digest: combined.digest,
+    stmtType: combined.stmtType,
+    schemaName: combined.schemaName,
+    execCount: sql`SUM(${combined.execCount})`.as("execCount"),
+    avgLatencyNs: sql`MAX(${combined.avgLatencyNs})`.as("avgLatencyNs"),
+    maxLatencyNs: sql`MAX(${combined.maxLatencyNs})`.as("maxLatencyNs"),
+    minLatencyNs: sql`MIN(${combined.minLatencyNs})`.as("minLatencyNs"),
+    avgProcessTimeNs: sql`MAX(${combined.avgProcessTimeNs})`.as("avgProcessTimeNs"),
+    avgWaitTimeNs: sql`MAX(${combined.avgWaitTimeNs})`.as("avgWaitTimeNs"),
+    avgBackoffTimeNs: sql`MAX(${combined.avgBackoffTimeNs})`.as("avgBackoffTimeNs"),
+    avgMemBytes: sql`MAX(${combined.avgMemBytes})`.as("avgMemBytes"),
+    maxMemBytes: sql`MAX(${combined.maxMemBytes})`.as("maxMemBytes"),
+    avgTotalKeys: sql`MAX(${combined.avgTotalKeys})`.as("avgTotalKeys"),
+    firstSeen: sql`MIN(${combined.firstSeen})`.as("firstSeen"),
+    lastSeen: sql`MAX(${combined.lastSeen})`.as("lastSeen"),
+    planInCache: sql`MAX(${combined.planInCache})`.as("planInCache"),
+    planCacheHits: sql`SUM(${combined.planCacheHits})`.as("planCacheHits"),
+    digestText: sql`MAX(${combined.digestText})`.as("digestText"),
+    plan: sql`MAX(${combined.plan})`.as("plan")
+  }).from(combined).where(
+    sql`COALESCE(${combined.digest}, '') <> '' AND COALESCE(${combined.digestText}, '') <> '' AND COALESCE(${combined.stmtType}, '') NOT IN ('Use','Set','Show')`
+  ).groupBy(combined.digest, combined.stmtType, combined.schemaName).as("grouped");
+};
+const buildFinalQuery = (orm, grouped, options) => {
+  const thresholdNs = Math.floor(options.warnThresholdMs * 1e6);
+  const memoryThresholdBytes = options.memoryThresholdBytes;
+  const query = orm.getDrizzleQueryBuilder().select({
+    digest: grouped.digest,
+    stmtType: grouped.stmtType,
+    schemaName: grouped.schemaName,
+    execCount: grouped.execCount,
+    avgLatencyNs: grouped.avgLatencyNs,
+    maxLatencyNs: grouped.maxLatencyNs,
+    minLatencyNs: grouped.minLatencyNs,
+    avgProcessTimeNs: grouped.avgProcessTimeNs,
+    avgWaitTimeNs: grouped.avgWaitTimeNs,
+    avgBackoffTimeNs: grouped.avgBackoffTimeNs,
+    avgMemBytes: grouped.avgMemBytes,
+    maxMemBytes: grouped.maxMemBytes,
+    avgTotalKeys: grouped.avgTotalKeys,
+    firstSeen: grouped.firstSeen,
+    lastSeen: grouped.lastSeen,
+    planInCache: grouped.planInCache,
+    planCacheHits: grouped.planCacheHits,
+    digestText: grouped.digestText,
+    plan: grouped.plan
+  }).from(grouped).where(
+    sql`${grouped.avgLatencyNs} > ${thresholdNs} OR ${grouped.avgMemBytes} > ${memoryThresholdBytes}`
+  ).orderBy(desc(grouped.avgLatencyNs)).limit(formatLimitOffset(options.topN));
+  if (options.operationType === "DDL") {
+    return orm.executeDDLActions(async () => await query);
+  }
+  return query;
+};
+const formatQueryResults = (rows, options) => {
+  return rows.map((row, index) => ({
+    rank: index + 1,
+    digest: row.digest,
+    stmtType: row.stmtType,
+    schemaName: row.schemaName,
+    execCount: row.execCount,
+    avgLatencyMs: nsToMs(row.avgLatencyNs),
+    maxLatencyMs: nsToMs(row.maxLatencyNs),
+    minLatencyMs: nsToMs(row.minLatencyNs),
+    avgProcessTimeMs: nsToMs(row.avgProcessTimeNs),
+    avgWaitTimeMs: nsToMs(row.avgWaitTimeNs),
+    avgBackoffTimeMs: nsToMs(row.avgBackoffTimeNs),
+    avgMemMB: bytesToMB(row.avgMemBytes),
+    maxMemMB: bytesToMB(row.maxMemBytes),
+    avgMemBytes: row.avgMemBytes,
+    maxMemBytes: row.maxMemBytes,
+    avgTotalKeys: row.avgTotalKeys,
+    firstSeen: row.firstSeen,
+    lastSeen: row.lastSeen,
+    planInCache: row.planInCache,
+    planCacheHits: row.planCacheHits,
+    digestText: options.operationType === "DDL" ? row.digestText : sanitizeSQL(row.digestText),
+    plan: options.showPlan ? row.plan : void 0
+  }));
+};
+const logQueryResults = (formatted, options) => {
+  for (const result of formatted) {
+    console.warn(
+      `${result.rank}. ${result.stmtType}  avg=${result.avgLatencyMs?.toFixed?.(2)}ms  max=${result.maxLatencyMs?.toFixed?.(2)}ms  mem≈${result.avgMemMB?.toFixed?.(2)}MB(max ${result.maxMemMB?.toFixed?.(2)}MB)  exec=${result.execCount} 
+   digest=${result.digest}
+   sql=${(result.digestText || "").slice(0, 300)}${result.digestText && result.digestText.length > 300 ? "…" : ""}`
+    );
+    if (options.showPlan && result.plan) {
+      console.warn(`   full plan:
+${result.plan}`);
+    }
+  }
+};
+const topSlowestStatementLastHourTrigger = async (orm, options) => {
+  if (!orm) {
+    return createErrorResponse("ORM instance is required");
+  }
+  const mergedOptions = {
+    warnThresholdMs: options?.warnThresholdMs ?? DEFAULT_TIMEOUT,
+    memoryThresholdBytes: options?.memoryThresholdBytes ?? DEFAULT_MEMORY_THRESHOLD,
+    showPlan: options?.showPlan ?? false,
+    operationType: options?.operationType ?? "DML",
+    topN: options?.topN ?? DEFAULT_TOP_N,
+    hours: options?.hours ?? DEFAULT_HOURS,
+    tables: options?.tables ?? DEFAULT_TABLES
+  };
+  try {
+    const combined = buildCombinedQuery(orm, mergedOptions);
+    const grouped = buildGroupedQuery(orm, combined);
+    const finalQuery = buildFinalQuery(orm, grouped, mergedOptions);
+    const rows = await executeWithRetries(
+      () => withTimeout(finalQuery, MAX_QUERY_TIMEOUT_MS),
+      "topSlowestStatementLastHourTrigger"
+    );
+    const formatted = formatQueryResults(rows, mergedOptions);
+    logQueryResults(formatted, mergedOptions);
+    return createSuccessResponse(formatted, mergedOptions);
   } catch (error) {
-    console.error(
-      "Error in topSlowestStatementLastHourTrigger:",
+    console.warn(
+      "Error in topSlowestStatementLastHourTrigger (one-off errors can be ignored; if it recurs, investigate):",
       error?.cause?.context?.debug?.sqlMessage ?? error?.cause ?? error
     );
-    return {
-      headers: { "Content-Type": ["application/json"] },
-      statusCode: 500,
-      statusText: "Internal Server Error",
-      body: jsonSafeStringify({
-        success: false,
-        message: "Failed to fetch or log slow queries",
-        error: error?.cause?.context?.debug?.sqlMessage ?? error?.cause?.message,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })
-    };
+    return createErrorResponse("Failed to fetch or log slow queries", error);
   }
 };
 const getHttpResponse = (statusCode, body) => {
@@ -3506,6 +3844,7 @@ export {
   getPrimaryKeys,
   getTableMetadata,
   getTables,
+  isUpdateQueryResponse,
   mapSelectAllFieldsToAlias,
   mapSelectFieldsWithAlias,
   migrations,
@@ -3513,6 +3852,8 @@ export {
   parseDateTime,
   patchDbWithSelectAliased,
   slowQuery,
+  statementsSummary,
+  statementsSummaryHistory,
   topSlowestStatementLastHourTrigger
 };
 //# sourceMappingURL=ForgeSQLORM.mjs.map