forge-sql-orm 2.1.4 → 2.1.6

package/dist/ForgeSQLORM.js

@@ -410,7 +410,7 @@ async function clearCursorCache(tables, cursor, options) {
     entityQueryBuilder = entityQueryBuilder.cursor(cursor);
   }
   const listResult = await entityQueryBuilder.limit(100).getMany();
-  if (options.logRawSqlQuery) {
+  if (options.logCache) {
     console.warn(`clear cache Records: ${JSON.stringify(listResult.results.map((r) => r.key))}`);
   }
   await deleteCacheEntriesInBatches(listResult.results, cacheEntityName);
@@ -431,7 +431,7 @@ async function clearExpirationCursorCache(cursor, options) {
     entityQueryBuilder = entityQueryBuilder.cursor(cursor);
   }
   const listResult = await entityQueryBuilder.limit(100).getMany();
-  if (options.logRawSqlQuery) {
+  if (options.logCache) {
     console.warn(`clear expired Records: ${JSON.stringify(listResult.results.map((r) => r.key))}`);
   }
   await deleteCacheEntriesInBatches(listResult.results, cacheEntityName);
@@ -480,7 +480,7 @@ async function clearTablesCache(tables, options) {
       "clearing cache"
     );
   } finally {
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       const duration = luxon.DateTime.now().toSeconds() - startTime.toSeconds();
       console.info(`Cleared ${totalRecords} cache records in ${duration} seconds`);
     }
@@ -499,7 +499,7 @@ async function clearExpiredCache(options) {
     );
   } finally {
     const duration = luxon.DateTime.now().toSeconds() - startTime.toSeconds();
-    if (options?.logRawSqlQuery) {
+    if (options?.logCache) {
       console.debug(`Cleared ${totalRecords} expired cache records in ${duration} seconds`);
     }
   }
@@ -514,7 +514,7 @@ async function getFromCache(query, options) {
   const sqlQuery = query.toSQL();
   const key = hashKey(sqlQuery);
   if (await isTableContainsTableInCacheContext(sqlQuery.sql, options)) {
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       console.warn(`Context contains value to clear. Skip getting from cache`);
     }
     return void 0;
@@ -522,7 +522,7 @@ async function getFromCache(query, options) {
   try {
     const cacheResult = await kvs.kvs.entity(options.cacheEntityName).get(key);
     if (cacheResult && cacheResult[expirationName] >= getCurrentTime() && sqlQuery.sql.toLowerCase() === cacheResult[entityQueryName]) {
-      if (options.logRawSqlQuery) {
+      if (options.logCache) {
         console.warn(`Get value from cache, cacheKey: ${key}`);
       }
       const results = cacheResult[dataName];
@@ -543,7 +543,7 @@ async function setCacheResult(query, options, results, cacheTtl) {
     const dataName = options.cacheEntityDataName ?? CACHE_CONSTANTS.DEFAULT_DATA_NAME;
     const sqlQuery = query.toSQL();
     if (await isTableContainsTableInCacheContext(sqlQuery.sql, options)) {
-      if (options.logRawSqlQuery) {
+      if (options.logCache) {
         console.warn(`Context contains value to clear. Skip setting from cache`);
       }
       return;
@@ -558,7 +558,7 @@ async function setCacheResult(query, options, results, cacheTtl) {
       },
       { entityName: options.cacheEntityName }
     ).execute();
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       console.warn(`Store value to cache, cacheKey: ${key}`);
     }
   } catch (error) {
@@ -586,7 +586,7 @@ async function saveQueryLocalCacheQuery(query, rows, options) {
       sql: sql2.toSQL().sql.toLowerCase(),
       data: rows
     };
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       const q = sql2.toSQL();
       console.debug(
         `[forge-sql-orm][local-cache][SAVE] Stored result in cache. sql="${q.sql}", params=${JSON.stringify(q.params)}`
@@ -603,7 +603,7 @@ async function getQueryLocalCacheQuery(query, options) {
     const sql2 = query;
     const key = hashKey(sql2.toSQL());
     if (context.cache[key] && context.cache[key].sql === sql2.toSQL().sql.toLowerCase()) {
-      if (options.logRawSqlQuery) {
+      if (options.logCache) {
         const q = sql2.toSQL();
         console.debug(
           `[forge-sql-orm][local-cache][HIT] Returned cached result. sql="${q.sql}", params=${JSON.stringify(q.params)}`
@@ -1034,25 +1034,113 @@ class ForgeSQLSelectOperations {
     return updateQueryResponseResults.rows;
   }
 }
-const forgeDriver = async (query, params, method) => {
-  if (method == "execute") {
-    const sqlStatement = sql$1.sql.prepare(query);
-    if (params) {
-      sqlStatement.bindParams(...params);
+const metadataQueryContext = new node_async_hooks.AsyncLocalStorage();
+async function saveMetaDataToContext(metadata) {
+  const context = metadataQueryContext.getStore();
+  if (context && metadata) {
+    context.totalResponseSize += metadata.responseSize;
+    context.totalDbExecutionTime += metadata.dbExecutionTime;
+    context.lastMetadata = metadata;
+  }
+}
+async function getLastestMetadata() {
+  return metadataQueryContext.getStore();
+}
+const operationTypeQueryContext = new node_async_hooks.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.sql.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();
-    let rows;
-    rows = result.rows.map((r) => Object.values(r));
-    return { rows };
   }
+  return { rows: [] };
+}
+async function processExecuteMethod(query, params) {
+  const sqlStatement = sql$1.sql.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.sql.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.sql.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) {
@@ -1294,10 +1382,8 @@ function createRawQueryExecutor(db, options, useGlobalCache = false) {
   return async function(query, cacheTtl) {
     let sql$12;
     if (sql.isSQLWrapper(query)) {
-      const sqlWrapper = query;
-      sql$12 = sqlWrapper.getSQL().toQuery(
-        db.dialect
-      );
+      const dialect = db.dialect;
+      sql$12 = dialect.sqlToQuery(query);
     } else {
       sql$12 = {
         sql: query,
@@ -1798,6 +1884,7 @@ class ForgeSQLORMImpl {
     try {
       const newOptions = options ?? {
         logRawSqlQuery: false,
+        logCache: false,
         disableOptimisticLocking: false,
         cacheWrapTable: true,
         cacheTTL: 120,
@@ -1823,6 +1910,49 @@ class ForgeSQLORMImpl {
       throw error;
     }
   }
+  /**
+   * Executes a query and provides access to execution metadata.
+   * This method allows you to capture detailed information about query execution
+   * including database execution time, response size, and Forge SQL metadata.
+   *
+   * @template T - The return type of the query
+   * @param query - A function that returns a Promise with the query result
+   * @param onMetadata - Callback function that receives execution metadata
+   * @returns Promise with the query result
+   * @example
+   * ```typescript
+   * const result = await forgeSQL.executeWithMetadata(
+   *   async () => await forgeSQL.select().from(users).where(eq(users.id, 1)),
+   *   (dbTime, responseSize, metadata) => {
+   *     console.log(`DB execution time: ${dbTime}ms`);
+   *     console.log(`Response size: ${responseSize} bytes`);
+   *     console.log('Forge metadata:', metadata);
+   *   }
+   * );
+   * ```
+   */
+  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
+            );
+          }
+        }
+      }
+    );
+  }
   /**
    * Executes operations within a cache context that collects cache eviction events.
    * All clearCache calls within the context are collected and executed in batch at the end.
@@ -2204,6 +2334,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:
@@ -2270,6 +2491,30 @@ class ForgeSQLORM {
   constructor(options) {
     this.ormInstance = ForgeSQLORMImpl.getInstance(options);
   }
+  /**
+   * Executes a query and provides access to execution metadata.
+   * This method allows you to capture detailed information about query execution
+   * including database execution time, response size, and Forge SQL metadata.
+   *
+   * @template T - The return type of the query
+   * @param query - A function that returns a Promise with the query result
+   * @param onMetadata - Callback function that receives execution metadata
+   * @returns Promise with the query result
+   * @example
+   * ```typescript
+   * const result = await forgeSQL.executeWithMetadata(
+   *   async () => await forgeSQL.select().from(users).where(eq(users.id, 1)),
+   *   (dbTime, responseSize, metadata) => {
+   *     console.log(`DB execution time: ${dbTime}ms`);
+   *     console.log(`Response size: ${responseSize} bytes`);
+   *     console.log('Forge metadata:', metadata);
+   *   }
+   * );
+   * ```
+   */
+  async executeWithMetadata(query, onMetadata) {
+    return this.ormInstance.executeWithMetadata(query, onMetadata);
+  }
   selectCacheable(fields, cacheTTL) {
     return this.ormInstance.selectCacheable(fields, cacheTTL);
   }
@@ -2527,7 +2772,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.
@@ -2548,7 +2884,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.
@@ -2558,7 +2894,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)
    * );
@@ -2576,7 +2912,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)
    * );
@@ -3067,6 +3403,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()
@@ -3099,12 +3443,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.sql._provision();
-    console.info("Running schema migrations");
+    console.debug("Running schema migrations");
     const migrations2 = await migration(sql$1.migrationRunner);
     const successfulMigrations = await migrations2.run();
-    console.info("Migrations applied:", successfulMigrations);
+    console.debug("Migrations applied:", successfulMigrations);
     const migrationList = await sql$1.migrationRunner.list();
     let migrationHistory = "No migrations found";
     if (Array.isArray(migrationList) && migrationList.length > 0) {
@@ -3113,7 +3457,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,
@@ -3218,167 +3562,260 @@ const clearCacheSchedulerTrigger = async (options) => {
     };
   }
 };
-const topSlowestStatementLastHourTrigger = async (orm, warnThresholdMs = 300, memoryThresholdBytes = 8 * 1024 * 1024) => {
-  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);
-  const TOP_N = 1;
+const DEFAULT_MEMORY_THRESHOLD = 8 * 1024 * 1024;
+const DEFAULT_TIMEOUT = 300;
+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 {
-    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 = drizzleOrm.gte(
-      summaryHistory.summaryEndTime,
-      drizzleOrm.sql`DATE_SUB(NOW(), INTERVAL 1 HOUR)`
-    );
-    const lastHourFilterSummary = drizzleOrm.gte(
-      summary.summaryEndTime,
-      drizzleOrm.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 = mysqlCore.unionAll(qHistory, qSummary).as("combined");
-    const thresholdNs = Math.floor(warnThresholdMs * 1e6);
-    const grouped = orm.getDrizzleQueryBuilder().select({
-      digest: combined.digest,
-      stmtType: combined.stmtType,
-      schemaName: combined.schemaName,
-      execCount: drizzleOrm.sql`SUM(${combined.execCount})`.as("execCount"),
-      avgLatencyNs: drizzleOrm.sql`MAX(${combined.avgLatencyNs})`.as("avgLatencyNs"),
-      maxLatencyNs: drizzleOrm.sql`MAX(${combined.maxLatencyNs})`.as("maxLatencyNs"),
-      minLatencyNs: drizzleOrm.sql`MIN(${combined.minLatencyNs})`.as("minLatencyNs"),
-      avgProcessTimeNs: drizzleOrm.sql`MAX(${combined.avgProcessTimeNs})`.as("avgProcessTimeNs"),
-      avgWaitTimeNs: drizzleOrm.sql`MAX(${combined.avgWaitTimeNs})`.as("avgWaitTimeNs"),
-      avgBackoffTimeNs: drizzleOrm.sql`MAX(${combined.avgBackoffTimeNs})`.as("avgBackoffTimeNs"),
-      avgMemBytes: drizzleOrm.sql`MAX(${combined.avgMemBytes})`.as("avgMemBytes"),
-      maxMemBytes: drizzleOrm.sql`MAX(${combined.maxMemBytes})`.as("maxMemBytes"),
-      avgTotalKeys: drizzleOrm.sql`MAX(${combined.avgTotalKeys})`.as("avgTotalKeys"),
-      firstSeen: drizzleOrm.sql`MIN(${combined.firstSeen})`.as("firstSeen"),
-      lastSeen: drizzleOrm.sql`MAX(${combined.lastSeen})`.as("lastSeen"),
-      planInCache: drizzleOrm.sql`MAX(${combined.planInCache})`.as("planInCache"),
-      planCacheHits: drizzleOrm.sql`SUM(${combined.planCacheHits})`.as("planCacheHits"),
-      // Prefer a non-empty sample text/plan via MAX; acceptable for de-dup
-      digestText: drizzleOrm.sql`MAX(${combined.digestText})`.as("digestText"),
-      plan: drizzleOrm.sql`MAX(${combined.plan})`.as("plan")
-    }).from(combined).where(
-      drizzleOrm.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(
-      drizzleOrm.sql`${grouped.avgLatencyNs} > ${thresholdNs} OR ${grouped.avgMemBytes} > ${memoryThresholdBytes}`
-    ).orderBy(drizzleOrm.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: r.digestText,
-      plan: r.plan
-    }));
-    for (const f of formatted) {
+    return await Promise.race([
+      promise,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`TIMEOUT:${ms}`)), ms);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+};
+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 (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,
-        memoryThresholdBytes,
-        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 = (table2) => ({
+  digest: table2.digest,
+  stmtType: table2.stmtType,
+  schemaName: table2.schemaName,
+  execCount: table2.execCount,
+  avgLatencyNs: table2.avgLatency,
+  maxLatencyNs: table2.maxLatency,
+  minLatencyNs: table2.minLatency,
+  avgProcessTimeNs: table2.avgProcessTime,
+  avgWaitTimeNs: table2.avgWaitTime,
+  avgBackoffTimeNs: table2.avgBackoffTime,
+  avgTotalKeys: table2.avgTotalKeys,
+  firstSeen: table2.firstSeen,
+  lastSeen: table2.lastSeen,
+  planInCache: table2.planInCache,
+  planCacheHits: table2.planCacheHits,
+  digestText: table2.digestText,
+  plan: table2.plan,
+  avgMemBytes: table2.avgMem,
+  maxMemBytes: table2.maxMem
+});
+const buildCombinedQuery = (orm, options) => {
+  const summaryHistory = statementsSummary;
+  const summary = statementsSummary;
+  const summaryHistoryCluster = clusterStatementsSummaryHistory;
+  const summaryCluster = clusterStatementsSummary;
+  const lastHoursFilter = (table2) => drizzleOrm.gte(table2.summaryEndTime, drizzleOrm.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 mysqlCore.unionAll(qHistory, qSummary).as("combined");
+    case "CLUSTER_SUMMARY_AND_HISTORY":
+      return mysqlCore.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: drizzleOrm.sql`SUM(${combined.execCount})`.as("execCount"),
+    avgLatencyNs: drizzleOrm.sql`MAX(${combined.avgLatencyNs})`.as("avgLatencyNs"),
+    maxLatencyNs: drizzleOrm.sql`MAX(${combined.maxLatencyNs})`.as("maxLatencyNs"),
+    minLatencyNs: drizzleOrm.sql`MIN(${combined.minLatencyNs})`.as("minLatencyNs"),
+    avgProcessTimeNs: drizzleOrm.sql`MAX(${combined.avgProcessTimeNs})`.as("avgProcessTimeNs"),
+    avgWaitTimeNs: drizzleOrm.sql`MAX(${combined.avgWaitTimeNs})`.as("avgWaitTimeNs"),
+    avgBackoffTimeNs: drizzleOrm.sql`MAX(${combined.avgBackoffTimeNs})`.as("avgBackoffTimeNs"),
+    avgMemBytes: drizzleOrm.sql`MAX(${combined.avgMemBytes})`.as("avgMemBytes"),
+    maxMemBytes: drizzleOrm.sql`MAX(${combined.maxMemBytes})`.as("maxMemBytes"),
+    avgTotalKeys: drizzleOrm.sql`MAX(${combined.avgTotalKeys})`.as("avgTotalKeys"),
+    firstSeen: drizzleOrm.sql`MIN(${combined.firstSeen})`.as("firstSeen"),
+    lastSeen: drizzleOrm.sql`MAX(${combined.lastSeen})`.as("lastSeen"),
+    planInCache: drizzleOrm.sql`MAX(${combined.planInCache})`.as("planInCache"),
+    planCacheHits: drizzleOrm.sql`SUM(${combined.planCacheHits})`.as("planCacheHits"),
+    digestText: drizzleOrm.sql`MAX(${combined.digestText})`.as("digestText"),
+    plan: drizzleOrm.sql`MAX(${combined.plan})`.as("plan")
+  }).from(combined).where(
+    drizzleOrm.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(
+    drizzleOrm.sql`${grouped.avgLatencyNs} > ${thresholdNs} OR ${grouped.avgMemBytes} > ${memoryThresholdBytes}`
+  ).orderBy(drizzleOrm.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) => {
@@ -3419,6 +3856,7 @@ exports.getHttpResponse = getHttpResponse;
 exports.getPrimaryKeys = getPrimaryKeys;
 exports.getTableMetadata = getTableMetadata;
 exports.getTables = getTables;
+exports.isUpdateQueryResponse = isUpdateQueryResponse;
 exports.mapSelectAllFieldsToAlias = mapSelectAllFieldsToAlias;
 exports.mapSelectFieldsWithAlias = mapSelectFieldsWithAlias;
 exports.migrations = migrations;
@@ -3426,5 +3864,7 @@ exports.nextVal = nextVal;
 exports.parseDateTime = parseDateTime;
 exports.patchDbWithSelectAliased = patchDbWithSelectAliased;
 exports.slowQuery = slowQuery;
+exports.statementsSummary = statementsSummary;
+exports.statementsSummaryHistory = statementsSummaryHistory;
 exports.topSlowestStatementLastHourTrigger = topSlowestStatementLastHourTrigger;
 //# sourceMappingURL=ForgeSQLORM.js.map