forge-sql-orm 2.1.11 → 2.1.13

package/src/utils/sqlUtils.ts

@@ -3,11 +3,11 @@ import {
   AnyColumn,
   Column,
   gte,
-    ilike,
+  ilike,
   isNotNull,
   isTable,
-    ne,
-    not,
+  ne,
+  not,
   notInArray,
   SQL,
   sql,
@@ -20,16 +20,14 @@ import { AnyIndexBuilder } from "drizzle-orm/mysql-core/indexes";
 import { CheckBuilder } from "drizzle-orm/mysql-core/checks";
 import { ForeignKeyBuilder } from "drizzle-orm/mysql-core/foreign-keys";
 import { UniqueConstraintBuilder } from "drizzle-orm/mysql-core/unique-constraint";
-import {
-    SelectedFields
-} from "drizzle-orm/mysql-core/query-builders/select.types";
+import { SelectedFields } from "drizzle-orm/mysql-core/query-builders/select.types";
 import { MySqlTable } from "drizzle-orm/mysql-core";
 import { isSQLWrapper } from "drizzle-orm/sql/sql";
-import {clusterStatementsSummary, slowQuery} from "../core/SystemTables";
+import { clusterStatementsSummary, slowQuery } from "../core/SystemTables";
 import { ForgeSqlOperation } from "../core/ForgeSQLQueryBuilder";
-import { ColumnDataType} from "drizzle-orm/column-builder";
-import {AnyMySqlColumn} from "drizzle-orm/mysql-core/columns/common";
-import type {ColumnBaseConfig} from "drizzle-orm/column";
+import { ColumnDataType } from "drizzle-orm/column-builder";
+import { AnyMySqlColumn } from "drizzle-orm/mysql-core/columns/common";
+import type { ColumnBaseConfig } from "drizzle-orm/column";
 
 /**
  * Interface representing table metadata information
@@ -95,7 +93,7 @@ export const parseDateTime = (value: string | Date, format: string): Date => {
     }
   }
   // 4. Ensure the result is a valid Date object
-  if (isNaN(result.getTime())) {
+  if (Number.isNaN(result.getTime())) {
     result = new Date(value);
   }
   return result;
@@ -129,7 +127,7 @@ export function formatDateTime(
     }
     if (!dt?.isValid) {
       const parsed = Number(value);
-      if (!isNaN(parsed)) {
+      if (!Number.isNaN(parsed)) {
         dt = DateTime.fromMillis(parsed);
       }
     }
@@ -185,17 +183,15 @@ export function getPrimaryKeys<T extends AnyMySqlTable>(table: T): [string, AnyC
     // Collect all primary key columns from all primary key builders
     const primaryKeyColumns = new Set<[string, AnyColumn]>();
 
-    primaryKeys.forEach((primaryKeyBuilder) => {
+    for (const primaryKeyBuilder of primaryKeys) {
       // Get primary key columns from each builder
-      Object.entries(columns)
-        .filter(([, column]) => {
-          // @ts-ignore - PrimaryKeyBuilder has internal columns property
-          return primaryKeyBuilder.columns.includes(column);
-        })
-        .forEach(([name, column]) => {
-          primaryKeyColumns.add([name, column]);
-        });
-    });
+      for (const [name, column1] of Object.entries(columns).filter(([, column]) => {
+        // @ts-ignore - PrimaryKeyBuilder has internal columns property
+        return primaryKeyBuilder.columns.includes(column);
+      })) {
+        primaryKeyColumns.add([name, column1]);
+      }
+    }
 
     return Array.from(primaryKeyColumns);
   }
@@ -222,12 +218,12 @@ function processForeignKeys(
     // @ts-ignore
     const fkArray: any[] = table[foreignKeysSymbol];
     if (fkArray) {
-      fkArray.forEach((fk) => {
+      for (const fk of fkArray) {
         if (fk.reference) {
           const item = fk.reference(fk);
           foreignKeys.push(item);
         }
-      });
+      }
     }
   }
 
@@ -244,14 +240,14 @@ function processForeignKeys(
               (item) => (item as ConfigBuilderData).value ?? item,
             );
 
-        configBuilders.forEach((builder) => {
-          if (!builder?.constructor) return;
+        for (const builder of configBuilders) {
+          if (!builder?.constructor) continue;
 
           const builderName = builder.constructor.name.toLowerCase();
           if (builderName.includes("foreignkeybuilder")) {
             foreignKeys.push(builder);
           }
-        });
+        }
       }
     }
   }
@@ -299,8 +295,8 @@ export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
             );
 
         // Process each builder
-        configBuilders.forEach((builder) => {
-          if (!builder?.constructor) return;
+        for (const builder of configBuilders) {
+          if (!builder?.constructor) continue;
 
           const builderName = builder.constructor.name.toLowerCase();
 
@@ -322,7 +318,7 @@ export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
 
           // Always add to extras array
           builders.extras.push(builder);
-        });
+        }
       }
     }
   }
@@ -354,14 +350,14 @@ export function generateDropTableStatements(
     console.warn('No drop operations requested: both "table" and "sequence" options are false');
     return [];
   }
-  tables.forEach((tableName) => {
+  for (const tableName of tables) {
     if (validOptions.table) {
       dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);
     }
     if (validOptions.sequence) {
       dropStatements.push(`DROP SEQUENCE IF EXISTS \`${tableName}\`;`);
     }
-  });
+  }
 
   return dropStatements;
 }
@@ -375,13 +371,13 @@ function mapSelectTableToAlias(
 ): any {
   const { columns, tableName } = getTableMetadata(table);
   const selectionsTableFields: Record<string, unknown> = {};
-  Object.keys(columns).forEach((name) => {
+  for (const name of Object.keys(columns)) {
     const column = columns[name] as AnyColumn;
     const uniqName = `a_${uniqPrefix}_${tableName}_${column.name}`.toLowerCase();
     const fieldAlias = sql.raw(uniqName);
     selectionsTableFields[name] = sql`${column} as \`${fieldAlias}\``;
     aliasMap[uniqName] = column;
-  });
+  }
   return selectionsTableFields;
 }
 
@@ -408,9 +404,9 @@ export function mapSelectAllFieldsToAlias(
     selections[name] = fields;
   } else {
     const innerSelections: any = {};
-    Object.entries(fields).forEach(([iname, ifields]) => {
+    for (const [iname, ifields] of Object.entries(fields)) {
       mapSelectAllFieldsToAlias(innerSelections, iname, `${uniqName}_${iname}`, ifields, aliasMap);
-    });
+    }
     selections[name] = innerSelections;
   }
   return selections;
@@ -423,9 +419,10 @@ export function mapSelectFieldsWithAlias<TSelection extends SelectedFields>(
   }
   const aliasMap: AliasColumnMap = {};
   const selections: any = {};
-  Object.entries(fields).forEach(([name, fields]) => {
-    mapSelectAllFieldsToAlias(selections, name, name, fields, aliasMap);
-  });
+  for (let i = 0; i < Object.entries(fields).length; i++) {
+    const [name, fields1] = Object.entries(fields)[i];
+    mapSelectAllFieldsToAlias(selections, name, name, fields1, aliasMap);
+  }
   return { selections, aliasMap };
 }
 
@@ -548,7 +545,7 @@ function processNullBranches(obj: Record<string, unknown>): Record<string, unkno
 }
 
 export function formatLimitOffset(limitOrOffset: number): number {
-  if (typeof limitOrOffset !== "number" || isNaN(limitOrOffset)) {
+  if (typeof limitOrOffset !== "number" || Number.isNaN(limitOrOffset)) {
     throw new Error("limitOrOffset must be a valid number");
   }
   return sql.raw(`${limitOrOffset}`) as unknown as number;
@@ -591,8 +588,8 @@ export async function printQueriesWithPlan(
 ) {
   try {
     const statementsTable = clusterStatementsSummary;
-      const timeoutMs = timeout ?? 3000;
-      const results = await withTimeout(
+    const timeoutMs = timeout ?? 3000;
+    const results = await withTimeout(
       forgeSQLORM
         .getDrizzleQueryBuilder()
         .select({
@@ -601,14 +598,21 @@ export async function printQueriesWithPlan(
           avgMem: statementsTable.avgMem,
           execCount: statementsTable.execCount,
           plan: statementsTable.plan,
-            stmtType: statementsTable.stmtType,
+          stmtType: statementsTable.stmtType,
         })
         .from(statementsTable)
         .where(
           and(
             isNotNull(statementsTable.digest),
-              not(ilike(statementsTable.digestText, "%information_schema%")),
-            notInArray(statementsTable.stmtType, ["Use", "Set", "Show","Commit","Rollback", "Begin"]),
+            not(ilike(statementsTable.digestText, "%information_schema%")),
+            notInArray(statementsTable.stmtType, [
+              "Use",
+              "Set",
+              "Show",
+              "Commit",
+              "Rollback",
+              "Begin",
+            ]),
             gte(
               statementsTable.lastSeen,
               sql`DATE_SUB
@@ -619,12 +623,11 @@ export async function printQueriesWithPlan(
             ),
           ),
         ),
-          `Timeout ${timeoutMs}ms in printQueriesWithPlan - transient timeouts are usually fine; repeated timeouts mean this diagnostic query is consistently slow and should be investigated`
-        ,
-      timeoutMs+200,
+      `Timeout ${timeoutMs}ms in printQueriesWithPlan - transient timeouts are usually fine; repeated timeouts mean this diagnostic query is consistently slow and should be investigated`,
+      timeoutMs + 200,
     );
 
-    results.forEach((result) => {
+    for (const result of results) {
       // Average execution time (convert from nanoseconds to milliseconds)
       const avgTimeMs = Number(result.avgLatency) / 1_000_000;
       const avgMemMB = Number(result.avgMem) / 1_000_000;
@@ -634,7 +637,7 @@ export async function printQueriesWithPlan(
       console.warn(
         `SQL: ${result.digestText} | Memory: ${avgMemMB.toFixed(2)} MB | Time: ${avgTimeMs.toFixed(2)} ms | stmtType: ${result.stmtType} | Executions: ${result.execCount}\n Plan:${result.plan}`,
       );
-    });
+    }
   } catch (error) {
     // eslint-disable-next-line no-console
     console.debug(
@@ -644,11 +647,11 @@ export async function printQueriesWithPlan(
   }
 }
 
-const SESSION_ALIAS_NAME_ORM = 'orm';
+const SESSION_ALIAS_NAME_ORM = "orm";
 
 /**
  * Analyzes and logs slow queries from the last specified number of hours.
- * 
+ *
  * This function queries the slow query system table to find queries that were executed
  * within the specified time window and logs detailed performance information including:
  * - SQL query text
@@ -656,77 +659,81 @@ const SESSION_ALIAS_NAME_ORM = 'orm';
  * - Query execution time (in ms)
  * - Execution count
  * - Execution plan
- * 
+ *
  * @param forgeSQLORM - The ForgeSQL operation instance for database access
  * @param hours - Number of hours to look back for slow queries (e.g., 1 for last hour, 24 for last day)
  * @param timeout - Optional timeout in milliseconds for the query execution (defaults to 1500ms)
- * 
+ *
  * @example
  * ```typescript
  * // Analyze slow queries from the last hour
  * await slowQueryPerHours(forgeSQLORM, 1);
- * 
+ *
  * // Analyze slow queries from the last 24 hours with custom timeout
  * await slowQueryPerHours(forgeSQLORM, 24, 3000);
- * 
+ *
  * // Analyze slow queries from the last 6 hours
  * await slowQueryPerHours(forgeSQLORM, 6);
  * ```
- * 
+ *
  * @throws Does not throw - errors are logged to console.debug instead
  */
-export async function slowQueryPerHours(forgeSQLORM: ForgeSqlOperation, hours:number, timeout?: number) {
-    try {
-        const timeoutMs = timeout ?? 1500;
-        const results = await withTimeout(
-            forgeSQLORM
-                .getDrizzleQueryBuilder()
-                .select({
-                    query: withTidbHint(slowQuery.query),
-                    queryTime: slowQuery.queryTime,
-                    memMax: slowQuery.memMax,
-                    plan: slowQuery.plan,
-                })
-                .from(slowQuery)
-                .where(
-                    and(
-                        isNotNull(slowQuery.digest),
-                        ne(slowQuery.sessionAlias, SESSION_ALIAS_NAME_ORM),
-                        gte(
-                            slowQuery.time,
-                            sql`DATE_SUB
+export async function slowQueryPerHours(
+  forgeSQLORM: ForgeSqlOperation,
+  hours: number,
+  timeout?: number,
+) {
+  try {
+    const timeoutMs = timeout ?? 1500;
+    const results = await withTimeout(
+      forgeSQLORM
+        .getDrizzleQueryBuilder()
+        .select({
+          query: withTidbHint(slowQuery.query),
+          queryTime: slowQuery.queryTime,
+          memMax: slowQuery.memMax,
+          plan: slowQuery.plan,
+        })
+        .from(slowQuery)
+        .where(
+          and(
+            isNotNull(slowQuery.digest),
+            ne(slowQuery.sessionAlias, SESSION_ALIAS_NAME_ORM),
+            gte(
+              slowQuery.time,
+              sql`DATE_SUB
                             (NOW(), INTERVAL
                             ${hours}
                             HOUR
                             )`,
-                        ),
-                    ),
-                ),
-            `Timeout ${timeoutMs}ms in slowQueryPerHours - transient timeouts are usually fine; repeated timeouts mean this diagnostic query is consistently slow and should be investigated`,
-            timeoutMs,
-        );
-       const response:string[] =[]
-        results.forEach((result) => {
-            // Convert memory from bytes to MB and handle null values
-            const memMaxMB = result.memMax ? Number(result.memMax) / 1_000_000 : 0;
-
-            const message = `Found SlowQuery SQL: ${result.query} | Memory: ${memMaxMB.toFixed(2)} MB | Time: ${result.queryTime} ms\n Plan:${result.plan}`;
-            response.push(message);
-            // 1. Query info: SQL, memory, time, executions
-            // eslint-disable-next-line no-console
-            console.warn(
-                message,
-            );
-        });
-        return response;
-    } catch (error) {
-        // eslint-disable-next-line no-console
-        console.debug(
-            `Error occurred while retrieving query execution plan: ${error instanceof Error ? error.message : "Unknown error"}. Try again after some time`,
-            error,
-        );
-        return [`Error occurred while retrieving query execution plan: ${error instanceof Error ? error.message : "Unknown error"}`]
+            ),
+          ),
+        ),
+      `Timeout ${timeoutMs}ms in slowQueryPerHours - transient timeouts are usually fine; repeated timeouts mean this diagnostic query is consistently slow and should be investigated`,
+      timeoutMs,
+    );
+    const response: string[] = [];
+    for (const result of results) {
+      // Convert memory from bytes to MB and handle null values
+      const memMaxMB = result.memMax ? Number(result.memMax) / 1_000_000 : 0;
+
+      const message = `Found SlowQuery SQL: ${result.query} | Memory: ${memMaxMB.toFixed(2)} MB | Time: ${result.queryTime} ms\n Plan:${result.plan}`;
+      response.push(message);
+      // 1. Query info: SQL, memory, time, executions
+      // eslint-disable-next-line no-console
+      console.warn(message);
     }
+    return response;
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.debug(
+      `Error occurred while retrieving query execution plan: ${error instanceof Error ? error.message : "Unknown error"}. Try again after some time`,
+      error,
+    );
+    return [
+      `Error occurred while retrieving query execution plan: ${error instanceof Error ? error.message : "Unknown error"}`,
+    ];
+  }
 }
 
 /**
@@ -737,29 +744,33 @@ export async function slowQueryPerHours(forgeSQLORM: ForgeSqlOperation, hours:nu
  * @returns Promise that resolves with the result or rejects on timeout
  * @throws {Error} When the operation times out
  */
-export async function withTimeout<T>(promise: Promise<T>, message: string, timeoutMs: number): Promise<T> {
-    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  message: string,
+  timeoutMs: number,
+): Promise<T> {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(message));
+    }, timeoutMs);
+  });
 
-    const timeoutPromise = new Promise<never>((_, reject) => {
-        timeoutId = setTimeout(() => {
-            reject(
-                new Error(message),
-            );
-        }, timeoutMs);
-    });
-
-    try {
-        return await Promise.race([promise, timeoutPromise]);
-    } finally {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-        }
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
     }
+  }
 }
 
-export function withTidbHint<TDataType extends ColumnDataType, TPartial extends Partial<ColumnBaseConfig<TDataType, string>>>(column: AnyMySqlColumn<TPartial>): AnyMySqlColumn<TPartial> {
-    // We lie a bit to TypeScript here: at runtime this is a new SQL fragment,
-    // but returning TExpr keeps the column type info in downstream inference.
-    return sql`/*+ SET_VAR(tidb_session_alias=${sql.raw(`${SESSION_ALIAS_NAME_ORM}`)}) */ ${column}` as unknown as AnyMySqlColumn<TPartial>;
+export function withTidbHint<
+  TDataType extends ColumnDataType,
+  TPartial extends Partial<ColumnBaseConfig<TDataType, string>>,
+>(column: AnyMySqlColumn<TPartial>): AnyMySqlColumn<TPartial> {
+  // We lie a bit to TypeScript here: at runtime this is a new SQL fragment,
+  // but returning TExpr keeps the column type info in downstream inference.
+  return sql`/*+ SET_VAR(tidb_session_alias=${sql.raw(`${SESSION_ALIAS_NAME_ORM}`)}) */ ${column}` as unknown as AnyMySqlColumn<TPartial>;
 }
-

package/src/webtriggers/slowQuerySchedulerTrigger.ts

@@ -1,45 +1,45 @@
-import {getHttpResponse, TriggerResponse} from "./index";
-import {slowQueryPerHours} from "../utils/sqlUtils";
-import {ForgeSqlOperation} from "../core/ForgeSQLQueryBuilder";
+import { getHttpResponse, TriggerResponse } from "./index";
+import { slowQueryPerHours } from "../utils/sqlUtils";
+import { ForgeSqlOperation } from "../core/ForgeSQLQueryBuilder";
 
 /**
  * Scheduler trigger for analyzing slow queries from the last specified number of hours.
- * 
+ *
  * This trigger analyzes slow queries from TiDB's slow query log system table and provides
  * detailed performance information including SQL query text, memory usage, execution time,
  * and execution plans. It's designed to be used as a scheduled trigger in Atlassian Forge
  * to monitor query performance over time.
- * 
+ *
  * The function queries the slow query system table to find queries executed within the
  * specified time window and logs detailed performance information to the console. Results
  * are limited to the top 50 slow queries to prevent excessive output.
- * 
+ *
  * @param forgeSQLORM - The ForgeSQL operation instance for database access
  * @param options - Configuration options for the slow query analysis
  * @param options.hours - Number of hours to look back for slow queries (default: 1)
  * @param options.timeout - Timeout in milliseconds for the query execution (default: 2000ms)
- * 
+ *
  * @returns Promise<TriggerResponse<string>> - HTTP response with JSON stringified query results or error message
- * 
+ *
  * @example
  * ```typescript
  * import ForgeSQL, { slowQuerySchedulerTrigger } from "forge-sql-orm";
- * 
+ *
  * const forgeSQL = new ForgeSQL();
- * 
+ *
  * // Basic usage with default options (1 hour, 2000ms timeout)
  * export const slowQueryTrigger = () =>
  *   slowQuerySchedulerTrigger(forgeSQL, { hours: 1, timeout: 2000 });
- * 
+ *
  * // Analyze slow queries from the last 6 hours with extended timeout
  * export const sixHourSlowQueryTrigger = () =>
  *   slowQuerySchedulerTrigger(forgeSQL, { hours: 6, timeout: 5000 });
- * 
+ *
  * // Analyze slow queries from the last 24 hours
  * export const dailySlowQueryTrigger = () =>
  *   slowQuerySchedulerTrigger(forgeSQL, { hours: 24, timeout: 3000 });
  * ```
- * 
+ *
  * @example
  * ```yaml
  * # manifest.yml configuration
@@ -47,36 +47,43 @@ import {ForgeSqlOperation} from "../core/ForgeSQLQueryBuilder";
  *   - key: slow-query-trigger
  *     function: slowQueryTrigger
  *     interval: hour
- * 
+ *
  * function:
  *   - key: slowQueryTrigger
  *     handler: index.slowQueryTrigger
  * ```
- * 
+ *
  * @remarks
  * - Results are automatically logged to the Forge Developer Console via `console.warn()`
  * - The function returns up to 50 slow queries to prevent excessive logging
  * - Transient timeouts are usually fine; repeated timeouts indicate the diagnostic query itself is slow
  * - This trigger is best used with hourly intervals to catch slow queries in a timely manner
  * - Error responses return HTTP 500 with error details
- * 
+ *
  * @see {@link slowQueryPerHours} - The underlying function that performs the actual query analysis
  */
-export async function slowQuerySchedulerTrigger(forgeSQLORM: ForgeSqlOperation, options: {
-    hours: number,
-    timeout: number
-}): Promise<TriggerResponse<string>> {
-    try {
-        return getHttpResponse<string>(200, JSON.stringify(await slowQueryPerHours(forgeSQLORM, options?.hours ?? 1, options?.timeout ?? 3000)));
-    } catch (error: any) {
-        const errorMessage =
-            error?.debug?.sqlMessage ??
-            error?.debug?.message ??
-            error.message ??
-            "Unknown error occurred";
-        // eslint-disable-next-line no-console
-        console.error(errorMessage);
-        return getHttpResponse<string>(500, errorMessage);
-    }
+export async function slowQuerySchedulerTrigger(
+  forgeSQLORM: ForgeSqlOperation,
+  options: {
+    hours: number;
+    timeout: number;
+  },
+): Promise<TriggerResponse<string>> {
+  try {
+    return getHttpResponse<string>(
+      200,
+      JSON.stringify(
+        await slowQueryPerHours(forgeSQLORM, options?.hours ?? 1, options?.timeout ?? 3000),
+      ),
+    );
+  } catch (error: any) {
+    const errorMessage =
+      error?.debug?.sqlMessage ??
+      error?.debug?.message ??
+      error.message ??
+      "Unknown error occurred";
+    // eslint-disable-next-line no-console
+    console.error(errorMessage);
+    return getHttpResponse<string>(500, errorMessage);
+  }
 }
-