forge-sql-orm 2.1.23 → 2.1.24

package/src/utils/cacheTableUtils.ts

@@ -1,6 +1,17 @@
+// qlty-ignore: +qlty:file-complexity
 import { Parser } from "node-sql-parser";
 import { ForgeSqlOrmOptions } from "../core/ForgeSQLQueryBuilder";
 
+/**
+ * Extracts table name from backticks_quote_string type.
+ */
+function extractTableNameFromBackticks(value: any): string | null {
+  if (value.type === "backticks_quote_string" && typeof value.value === "string") {
+    return value.value === "dual" ? null : value.value.toLowerCase();
+  }
+  return null;
+}
+
 /**
  * Extracts table name from object value.
  */
@@ -9,22 +20,25 @@ function extractTableNameFromObject(value: any, context?: string): string | null
   if (Array.isArray(value)) {
     return null;
   }
+
   // Handle backticks_quote_string type only for node.table context
-  if (
-    context?.includes("node.table") &&
-    value.type === "backticks_quote_string" &&
-    typeof value.value === "string"
-  ) {
-    return value.value === "dual" ? null : value.value.toLowerCase();
+  if (context?.includes("node.table")) {
+    const fromBackticks = extractTableNameFromBackticks(value);
+    if (fromBackticks !== null) {
+      return fromBackticks;
+    }
   }
+
   // Try value.name first (most common)
   if (typeof value.name === "string") {
     return value.name === "dual" ? null : value.name.toLowerCase();
   }
+
   // Try value.table if it's a nested structure
   if (value.table) {
     return normalizeTableName(value.table, context);
   }
+
   // Log when we encounter an object that we can't extract table name from
   // eslint-disable-next-line no-console
   console.warn(
@@ -93,6 +107,22 @@ function isLikelyAlias(node: any): boolean {
   return isColumnRefAlias(node) || isExplicitAlias(node) || isShortNameAlias(node);
 }
 
+/**
+ * Extracts table name from table/dual node.
+ */
+function extractTableNameFromTableNode(node: any): string | null {
+  const fromTable = node.table
+    ? normalizeTableName(node.table, `node.type=${node.type}, node.table`)
+    : null;
+  if (fromTable) {
+    return fromTable;
+  }
+  const fromName = node.name
+    ? normalizeTableName(node.name, `node.type=${node.type}, node.name`)
+    : null;
+  return fromName;
+}
+
 /**
  * Extracts table name from table node.
  *
@@ -100,38 +130,18 @@ function isLikelyAlias(node: any): boolean {
  * @returns Table name in lowercase or null if not applicable
  */
 function extractTableName(node: any): string | null {
-  if (!node) {
-    return null;
-  }
-
-  // Early return for likely aliases
-  if (isLikelyAlias(node)) {
+  if (!node || isLikelyAlias(node)) {
     return null;
   }
 
   // Handle table node directly
   if (node.type === "table" || node.type === "dual") {
-    const fromTable = node.table
-      ? normalizeTableName(node.table, `node.type=${node.type}, node.table`)
-      : null;
-    if (fromTable) {
-      return fromTable;
-    }
-    const fromName = node.name
-      ? normalizeTableName(node.name, `node.type=${node.type}, node.name`)
-      : null;
-    if (fromName) {
-      return fromName;
-    }
-    return null;
+    return extractTableNameFromTableNode(node);
   }
 
   // Handle table reference in different formats
   if (node.table) {
-    const tableName = normalizeTableName(node.table, `node.table (type: ${node.type})`);
-    if (tableName) {
-      return tableName;
-    }
+    return normalizeTableName(node.table, `node.table (type: ${node.type})`);
   }
 
   return null;
@@ -205,6 +215,30 @@ function processFromAndJoin(node: any, tables: Set<string>): void {
   }
 }
 
+/**
+ * Processes a single column for table extraction.
+ */
+function processSingleColumn(col: any, tables: Set<string>): void {
+  if (!col) {
+    return;
+  }
+
+  // If the column itself is a subquery
+  if (col.type === "subquery" || col.type === "select") {
+    extractTablesFromNode(col, tables);
+  }
+
+  // Process expression (may contain subqueries)
+  if (col.expr) {
+    extractTablesFromNode(col.expr, tables);
+  }
+
+  // Process AST (alternative structure for subqueries)
+  if (col.ast) {
+    extractTablesFromNode(col.ast, tables);
+  }
+}
+
 /**
  * Processes SELECT columns that may contain subqueries.
  */
@@ -215,24 +249,7 @@ function processSelectColumns(node: any, tables: Set<string>): void {
   }
 
   if (Array.isArray(columns)) {
-    columns.forEach((col: any) => {
-      if (!col) return;
-
-      // If the column itself is a subquery
-      if (col.type === "subquery" || col.type === "select") {
-        extractTablesFromNode(col, tables);
-      }
-
-      // Process expression (may contain subqueries)
-      if (col.expr) {
-        extractTablesFromNode(col.expr, tables);
-      }
-
-      // Process AST (alternative structure for subqueries)
-      if (col.ast) {
-        extractTablesFromNode(col.ast, tables);
-      }
-    });
+    columns.forEach((col: any) => processSingleColumn(col, tables));
   } else if (typeof columns === "object") {
     extractTablesFromNode(columns, tables);
   }
@@ -265,14 +282,16 @@ function processUnionNode(unionNode: any, tables: Set<string>): void {
     return;
   }
 
-  const isUnionType =
-    unionNode.type === "select" ||
-    unionNode.type === "union" ||
-    unionNode.type === "union_all" ||
-    unionNode.type === "union_distinct" ||
-    unionNode.type === "intersect" ||
-    unionNode.type === "except" ||
-    unionNode.type === "minus";
+  const unionTypes = [
+    "select",
+    "union",
+    "union_all",
+    "union_distinct",
+    "intersect",
+    "except",
+    "minus",
+  ];
+  const isUnionType = unionTypes.includes(unionNode.type);
 
   if (isUnionType) {
     extractTablesFromNode(unionNode, tables);
@@ -304,13 +323,15 @@ function processUnion(node: any, tables: Set<string>): void {
  * Processes UNION/INTERSECT/EXCEPT operation nodes.
  */
 function processUnionOperation(node: any, tables: Set<string>): void {
-  const isUnionOperation =
-    node.type === "union" ||
-    node.type === "union_all" ||
-    node.type === "union_distinct" ||
-    node.type === "intersect" ||
-    node.type === "except" ||
-    node.type === "minus";
+  const unionOperationTypes = [
+    "union",
+    "union_all",
+    "union_distinct",
+    "intersect",
+    "except",
+    "minus",
+  ];
+  const isUnionOperation = unionOperationTypes.includes(node.type);
 
   if (!isUnionOperation) {
     return;
@@ -342,27 +363,25 @@ function processNext(node: any, tables: Set<string>): void {
 /**
  * Recursively processes all object properties for any remaining nested structures.
  */
-function processRecursively(node: any, tables: Set<string>): void {
-  const isLikelyAlias =
-    (node.type === "column_ref" && !node.table) ||
-    (node.name &&
-      !node.table &&
-      node.type !== "table" &&
-      node.type !== "dual" &&
-      node.name.length <= 2);
-
-  if (isLikelyAlias || Array.isArray(node)) {
-    return;
-  }
+/**
+ * Processes array values recursively.
+ */
+function processArrayValues(values: any[], tables: Set<string>): void {
+  values.forEach((item: any) => {
+    if (item && typeof item === "object") {
+      extractTablesFromNode(item, tables);
+    }
+  });
+}
 
+/**
+ * Processes object values recursively.
+ */
+function processObjectValues(node: any, tables: Set<string>): void {
   Object.values(node).forEach((value) => {
     if (value && typeof value === "object") {
       if (Array.isArray(value)) {
-        value.forEach((item: any) => {
-          if (item && typeof item === "object") {
-            extractTablesFromNode(item, tables);
-          }
-        });
+        processArrayValues(value, tables);
       } else {
         extractTablesFromNode(value, tables);
       }
@@ -370,6 +389,72 @@ function processRecursively(node: any, tables: Set<string>): void {
   });
 }
 
+function processRecursively(node: any, tables: Set<string>): void {
+  const isColumnRefAlias = node.type === "column_ref" && !node.table;
+  const hasName = Boolean(node.name);
+  const hasNoTable = !node.table;
+  const isNotTableType = node.type !== "table" && node.type !== "dual";
+  const isShortName = hasName && node.name.length <= 2;
+  const isShortNameAlias = hasName && hasNoTable && isNotTableType && isShortName;
+  const isLikelyAlias = isColumnRefAlias || isShortNameAlias;
+
+  if (isLikelyAlias || Array.isArray(node)) {
+    return;
+  }
+
+  processObjectValues(node, tables);
+}
+
+/**
+ * Processes DML statement types (UPDATE, INSERT, DELETE).
+ */
+function processDmlStatements(node: any, tables: Set<string>): void {
+  if (node.type === "update" && node.table) {
+    extractTablesFromNode(node.table, tables);
+  } else if (node.type === "insert" && node.table) {
+    extractTablesFromNode(node.table, tables);
+  } else if (node.type === "delete" && node.from) {
+    extractTablesFromNode(node.from, tables);
+  }
+}
+
+/**
+ * Processes SELECT-specific clauses (WHERE, HAVING, ORDER BY, GROUP BY).
+ */
+function processSelectClauses(node: any, tables: Set<string>): void {
+  if (node.where) {
+    extractTablesFromNode(node.where, tables);
+  }
+  if (node.having) {
+    extractTablesFromNode(node.having, tables);
+  }
+  processOrderByOrGroupBy(node.orderby || node.order_by, tables);
+  processOrderByOrGroupBy(node.groupby || node.group_by, tables);
+}
+
+/**
+ * Processes subquery and SELECT statement types.
+ */
+function processSubqueryAndSelect(node: any, tables: Set<string>): void {
+  if (node.type === "subquery" || node.type === "select") {
+    if (node.ast) {
+      extractTablesFromNode(node.ast, tables);
+    }
+    if (node.from) {
+      extractTablesFromNode(node.from, tables);
+    }
+  }
+}
+
+/**
+ * Processes set operations (UNION, INTERSECT, EXCEPT).
+ */
+function processSetOperations(node: any, tables: Set<string>): void {
+  processUnion(node, tables);
+  processUnionOperation(node, tables);
+  processNext(node, tables);
+}
+
 /**
  * Recursively extracts table names from SQL AST node.
  * Handles regular tables, CTEs, subqueries, and complex query structures.
@@ -391,58 +476,20 @@ function extractTablesFromNode(node: any, tables: Set<string>): void {
   // Extract tables from FROM and JOIN clauses
   processFromAndJoin(node, tables);
 
-  // Handle subqueries explicitly
-  if (node.type === "subquery" || node.type === "select") {
-    if (node.ast) {
-      extractTablesFromNode(node.ast, tables);
-    }
-    if (node.from) {
-      extractTablesFromNode(node.from, tables);
-    }
-  }
+  // Handle subqueries and SELECT statements
+  processSubqueryAndSelect(node, tables);
 
-  // Extract tables from WHERE clause (may contain subqueries)
-  if (node.where) {
-    extractTablesFromNode(node.where, tables);
-  }
+  // Process SELECT-specific clauses
+  processSelectClauses(node, tables);
 
   // Extract tables from SELECT columns (may contain subqueries)
   processSelectColumns(node, tables);
 
-  // Extract tables from HAVING clause (may contain subqueries)
-  if (node.having) {
-    extractTablesFromNode(node.having, tables);
-  }
-
-  // Extract tables from ORDER BY clause (may contain subqueries)
-  processOrderByOrGroupBy(node.orderby || node.order_by, tables);
-
-  // Extract tables from GROUP BY clause (may contain subqueries)
-  processOrderByOrGroupBy(node.groupby || node.group_by, tables);
+  // Process DML statements (UPDATE, INSERT, DELETE)
+  processDmlStatements(node, tables);
 
-  // Extract tables from UPDATE statement
-  if (node.type === "update" && node.table) {
-    extractTablesFromNode(node.table, tables);
-  }
-
-  // Extract tables from INSERT statement
-  if (node.type === "insert" && node.table) {
-    extractTablesFromNode(node.table, tables);
-  }
-
-  // Extract tables from DELETE statement
-  if (node.type === "delete" && node.from) {
-    extractTablesFromNode(node.from, tables);
-  }
-
-  // Extract tables from UNION operations
-  processUnion(node, tables);
-
-  // Handle node types for UNION/INTERSECT/EXCEPT operations
-  processUnionOperation(node, tables);
-
-  // Handle _next property (alternative UNION structure)
-  processNext(node, tables);
+  // Process set operations (UNION, INTERSECT, EXCEPT)
+  processSetOperations(node, tables);
 
   // Recursively process all object properties
   processRecursively(node, tables);
@@ -456,6 +503,33 @@ function extractTablesFromNode(node: any, tables: Set<string>): void {
  * @param options - ForgeSQL ORM options for logging
  * @returns Comma-separated string of unique table names in backticks
  */
+/**
+ * Formats table names as backticked comma-separated string.
+ */
+function formatBacktickedValues(tables: Set<string>): string {
+  return Array.from(tables)
+    .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base", numeric: true }))
+    .map((table) => `\`${table}\``)
+    .join(",");
+}
+
+/**
+ * Extracts table names using regex fallback.
+ */
+function extractTablesWithRegex(sql: string): Set<string> {
+  const regex = /`([^`]+)`/g;
+  const matches = new Set<string>();
+  let match;
+
+  while ((match = regex.exec(sql.toLowerCase())) !== null) {
+    if (!match[1].startsWith("a_")) {
+      matches.add(match[1]);
+    }
+  }
+
+  return matches;
+}
+
 export function extractBacktickedValues(sql: string, options: ForgeSqlOrmOptions): string {
   // Try to use node-sql-parser first
   try {
@@ -471,11 +545,7 @@ export function extractBacktickedValues(sql: string, options: ForgeSqlOrmOptions
     });
 
     if (tables.size > 0) {
-      // Sort to ensure consistent order for the same input
-      const backtickedValues = Array.from(tables)
-        .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base", numeric: true }))
-        .map((table) => `\`${table}\``)
-        .join(",");
+      const backtickedValues = formatBacktickedValues(tables);
       if (options.logCache) {
         // eslint-disable-next-line no-console
         console.warn(`Extracted backticked values: ${backtickedValues}`);
@@ -494,18 +564,6 @@ export function extractBacktickedValues(sql: string, options: ForgeSqlOrmOptions
   }
 
   // Fallback to regex-based extraction (original logic)
-  const regex = /`([^`]+)`/g;
-  const matches = new Set<string>();
-  let match;
-
-  while ((match = regex.exec(sql.toLowerCase())) !== null) {
-    if (!match[1].startsWith("a_")) {
-      matches.add(`\`${match[1]}\``);
-    }
-  }
-
-  // Sort to ensure consistent order for the same input
-  return Array.from(matches)
-    .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base", numeric: true }))
-    .join(",");
+  const matches = extractTablesWithRegex(sql);
+  return formatBacktickedValues(matches);
 }

package/src/utils/forgeDriverProxy.ts

@@ -16,6 +16,42 @@ const QUERY_ERROR_CODES = {
  */
 const STATEMENTS_SUMMARY_DELAY_MS = 200;
 
+/**
+ * Checks if error is a timeout or out-of-memory error.
+ */
+function isQueryError(error: any): { isTimeout: boolean; isOutOfMemory: boolean } {
+  const isTimeout = error?.code === QUERY_ERROR_CODES.TIMEOUT;
+  const isOutOfMemory = error?.context?.debug?.errno === QUERY_ERROR_CODES.OUT_OF_MEMORY_ERRNO;
+  return { isTimeout, isOutOfMemory };
+}
+
+/**
+ * Handles timeout or out-of-memory errors by analyzing the query.
+ */
+async function handleQueryError(
+  queryStartTime: number,
+  forgeSqlOperation: ForgeSqlOperation,
+  isTimeout: boolean,
+): Promise<void> {
+  // Wait for CLUSTER_STATEMENTS_SUMMARY to be populated with our failed query data
+  await new Promise((resolve) => setTimeout(resolve, STATEMENTS_SUMMARY_DELAY_MS));
+
+  const queryEndTime = Date.now();
+  const queryDuration = queryEndTime - queryStartTime;
+  const errorType: "OOM" | "TIMEOUT" = isTimeout ? "TIMEOUT" : "OOM";
+
+  if (isTimeout) {
+    // eslint-disable-next-line no-console
+    console.error(` TIMEOUT detected - Query exceeded time limit`);
+  } else {
+    // eslint-disable-next-line no-console
+    console.error(`OUT OF MEMORY detected - Query exceeded memory limit`);
+  }
+
+  // Analyze the failed query using CLUSTER_STATEMENTS_SUMMARY
+  await handleErrorsWithPlan(forgeSqlOperation, queryDuration, errorType);
+}
+
 /**
  * Creates a proxy for the forgeDriver that injects SQL hints and handles query analysis
  * @param forgeSqlOperation - The ForgeSQL operation instance
@@ -51,28 +87,10 @@ export function createForgeDriverProxy(
       // Execute the query with injected hints
       return await forgeDriver(modifiedQuery, params, method);
     } catch (error: any) {
-      // Check if this is a timeout or out-of-memory error that we want to analyze
-      const isTimeoutError = error.code === QUERY_ERROR_CODES.TIMEOUT;
-      const isOutOfMemoryError =
-        error?.context?.debug?.errno === QUERY_ERROR_CODES.OUT_OF_MEMORY_ERRNO;
-
-      if (isTimeoutError || isOutOfMemoryError) {
-        // Wait for CLUSTER_STATEMENTS_SUMMARY to be populated with our failed query data
-        await new Promise((resolve) => setTimeout(resolve, STATEMENTS_SUMMARY_DELAY_MS));
+      const { isTimeout, isOutOfMemory } = isQueryError(error);
 
-        const queryEndTime = Date.now();
-        const queryDuration = queryEndTime - queryStartTime;
-        let errorType: "OOM" | "TIMEOUT" = "TIMEOUT";
-        if (isTimeoutError) {
-          // eslint-disable-next-line no-console
-          console.error(` TIMEOUT detected - Query exceeded time limit`);
-        } else {
-          // eslint-disable-next-line no-console
-          console.error(`OUT OF MEMORY detected - Query exceeded memory limit`);
-          errorType = "OOM";
-        }
-        // Analyze the failed query using CLUSTER_STATEMENTS_SUMMARY
-        await handleErrorsWithPlan(forgeSqlOperation, queryDuration, errorType);
+      if (isTimeout || isOutOfMemory) {
+        await handleQueryError(queryStartTime, forgeSqlOperation, isTimeout);
       }
 
       // Log SQL error details if requested

package/src/utils/sqlHints.ts

@@ -26,38 +26,33 @@ export function injectSqlHints(query: string, hints?: SqlHints): string {
   // Normalize the query for easier matching
   const normalizedQuery = query.trim().toUpperCase();
 
-  // Get the appropriate hints based on query type
+  // Map query types to their hints
+  const queryTypeMap: Record<string, string[] | undefined> = {
+    SELECT: hints.select,
+    INSERT: hints.insert,
+    UPDATE: hints.update,
+    DELETE: hints.delete,
+  };
+
+  // Find matching query type and get hints
   let queryHints: string[] | undefined;
-
-  if (normalizedQuery.startsWith("SELECT")) {
-    queryHints = hints.select;
-  } else if (normalizedQuery.startsWith("INSERT")) {
-    queryHints = hints.insert;
-  } else if (normalizedQuery.startsWith("UPDATE")) {
-    queryHints = hints.update;
-  } else if (normalizedQuery.startsWith("DELETE")) {
-    queryHints = hints.delete;
+  let queryPrefix: string | null = null;
+
+  for (const [type, typeHints] of Object.entries(queryTypeMap)) {
+    if (normalizedQuery.startsWith(type)) {
+      queryPrefix = type;
+      queryHints = typeHints;
+      break;
+    }
   }
 
   // If no hints for this query type, return original query
-  if (!queryHints || queryHints.length === 0) {
+  if (!queryHints || queryHints.length === 0 || !queryPrefix) {
     return query;
   }
 
-  // Join all hints with spaces
+  // Join all hints with spaces and inject into query
   const hintsString = queryHints.join(" ");
-
-  // Inject hints into the query
-  if (normalizedQuery.startsWith("SELECT")) {
-    return `SELECT /*+ ${hintsString} */ ${query.substring(6)}`;
-  } else if (normalizedQuery.startsWith("INSERT")) {
-    return `INSERT /*+ ${hintsString} */ ${query.substring(6)}`;
-  } else if (normalizedQuery.startsWith("UPDATE")) {
-    return `UPDATE /*+ ${hintsString} */ ${query.substring(6)}`;
-  } else if (normalizedQuery.startsWith("DELETE")) {
-    return `DELETE /*+ ${hintsString} */ ${query.substring(6)}`;
-  }
-
-  // If no match found, return original query
-  return query;
+  const prefixLength = queryPrefix.length;
+  return `${queryPrefix} /*+ ${hintsString} */ ${query.substring(prefixLength)}`;
 }