forge-sql-orm 2.1.11 → 2.1.13

package/src/core/ForgeSQLORM.ts

@@ -204,31 +204,31 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
         },
       },
       async () => {
-           const result = await query();
-          const metadata = await getLastestMetadata();
-          try {
-               if (metadata) {
-                   await onMetadata(
-                       metadata.totalDbExecutionTime,
-                       metadata.totalResponseSize,
-                       metadata.printQueriesWithPlan,
-                   );
-               }
-           } catch (e: any) {
-              // eslint-disable-next-line no-console
-               console.error(
-                 "[ForgeSQLORM][executeWithMetadata] Failed to run onMetadata callback",
-                 {
-                   errorMessage: e?.message,
-                   errorStack: e?.stack,
-                   totalDbExecutionTime: metadata?.totalDbExecutionTime,
-                   totalResponseSize: metadata?.totalResponseSize,
-                   beginTime: metadata?.beginTime,
-                 },
-                 e,
-               );
-           }
-           return result;
+        const result = await query();
+        const metadata = await getLastestMetadata();
+        try {
+          if (metadata) {
+            await onMetadata(
+              metadata.totalDbExecutionTime,
+              metadata.totalResponseSize,
+              metadata.printQueriesWithPlan,
+            );
+          }
+        } catch (e: any) {
+          // eslint-disable-next-line no-console
+          console.error(
+            "[ForgeSQLORM][executeWithMetadata] Failed to run onMetadata callback",
+            {
+              errorMessage: e?.message,
+              errorStack: e?.stack,
+              totalDbExecutionTime: metadata?.totalDbExecutionTime,
+              totalResponseSize: metadata?.totalResponseSize,
+              beginTime: metadata?.beginTime,
+            },
+            e,
+          );
+        }
+        return result;
       },
     );
   }
@@ -780,7 +780,10 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
    * const result = await forgeSQL.executeCacheable("SELECT * FROM users WHERE status = 'active'");
    * ```
    */
-  executeCacheable<T>(query: SQLWrapper | string, cacheTtl?: number) {
+  executeCacheable<T>(
+    query: SQLWrapper | string,
+    cacheTtl?: number,
+  ): Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, T>> {
     return this.drizzle.executeQueryCacheable<T>(query, cacheTtl);
   }
 
@@ -1340,7 +1343,10 @@ class ForgeSQLORM implements ForgeSqlOperation {
    * const result = await forgeSQL.executeCacheable("SELECT * FROM users WHERE status = 'active'");
    * ```
    */
-  executeCacheable(query: SQLWrapper | string, cacheTtl?: number) {
+  executeCacheable<T>(
+    query: SQLWrapper | string,
+    cacheTtl?: number,
+  ): Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, T>> {
     return this.ormInstance.executeCacheable(query, cacheTtl);
   }
 

package/src/lib/drizzle/extensions/additionalActions.ts

@@ -593,6 +593,17 @@ function createAliasedSelectBuilder<TSelection extends SelectedFields>(
             }
           };
         }
+        if (prop === "catch") {
+          return (onrejected: any) => (receiver as any).then(undefined, onrejected);
+        }
+
+        if (prop === "finally") {
+          return (onfinally: any) =>
+            (receiver as any).then(
+              (value: any) => Promise.resolve(value).finally(onfinally),
+              (reason: any) => Promise.reject(reason).finally(onfinally),
+            );
+        }
 
         const value = Reflect.get(target, prop, receiver);
 

package/src/utils/cacheContextUtils.ts

@@ -159,10 +159,11 @@ export async function getQueryLocalCacheQuery<
     } else {
       sql = query as { toSQL: () => Query };
     }
-    const key = hashKey(sql.toSQL());
-    if (context.cache[key] && context.cache[key].sql === sql.toSQL().sql.toLowerCase()) {
+    const toSQL = sql.toSQL();
+    const key = hashKey(toSQL);
+    if (context.cache[key] && context.cache[key].sql === toSQL.sql.toLowerCase()) {
       if (options.logCache) {
-        const q = sql.toSQL();
+        const q = toSQL;
         // eslint-disable-next-line no-console
         console.debug(
           `[forge-sql-orm][local-cache][HIT] Returned cached result. sql="${q.sql}", params=${JSON.stringify(q.params)}`,
@@ -201,12 +202,14 @@ export async function evictLocalCacheQuery<T extends AnyMySqlTable>(
     const tableName = getTableName(table);
     const searchString = options.cacheWrapTable ? `\`${tableName}\`` : tableName;
     const keyToEvicts: string[] = [];
-    Object.keys(context.cache).forEach((key) => {
+    for (const key of Object.keys(context.cache)) {
       if (context.cache[key].sql.includes(searchString)) {
         keyToEvicts.push(key);
       }
-    });
-    keyToEvicts.forEach((key) => delete context.cache[key]);
+    }
+    for (const key of keyToEvicts) {
+      delete context.cache[key];
+    }
   }
 }
 

package/src/utils/cacheUtils.ts

@@ -1,5 +1,5 @@
 import { DateTime } from "luxon";
-import * as crypto from "crypto";
+import * as crypto from "node:crypto";
 import { Query } from "drizzle-orm";
 import { AnyMySqlTable } from "drizzle-orm/mysql-core";
 import { getTableName } from "drizzle-orm/table";
@@ -47,6 +47,29 @@ function nowPlusSeconds(secondsToAdd: number): number {
   return Math.floor(dt.toSeconds());
 }
 
+/**
+ * Extracts all table/column names between backticks from SQL query and returns them as comma-separated string.
+ *
+ * @param sql - SQL query string
+ * @returns Comma-separated string of unique backticked values
+ */
+function extractBacktickedValues(sql: string): 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]}\``);
+    }
+  }
+
+  // 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(",");
+}
+
 /**
  * Generates a hash key for a query based on its SQL and parameters.
  *
@@ -74,9 +97,9 @@ async function deleteCacheEntriesInBatches(
   for (let i = 0; i < results.length; i += CACHE_CONSTANTS.BATCH_SIZE) {
     const batch = results.slice(i, i + CACHE_CONSTANTS.BATCH_SIZE);
     let transactionBuilder = kvs.transact();
-    batch.forEach((result) => {
+    for (const result of batch) {
       transactionBuilder = transactionBuilder.delete(result.key, { entityName: cacheEntityName });
-    });
+    }
     await transactionBuilder.execute();
   }
 }
@@ -339,7 +362,7 @@ export async function getFromCache<T>(
     if (
       cacheResult &&
       (cacheResult[expirationName] as number) >= getCurrentTime() &&
-      sqlQuery.sql.toLowerCase() === cacheResult[entityQueryName]
+      extractBacktickedValues(sqlQuery.sql) === cacheResult[entityQueryName]
     ) {
       if (options.logCache) {
         // eslint-disable-next-line no-console
@@ -400,7 +423,7 @@ export async function setCacheResult(
       .set(
         key,
         {
-          [entityQueryName]: sqlQuery.sql.toLowerCase(),
+          [entityQueryName]: extractBacktickedValues(sqlQuery.sql),
           [expirationName]: nowPlusSeconds(cacheTtl),
           [dataName]: JSON.stringify(results),
         },

package/src/utils/forgeDriver.ts

@@ -1,9 +1,9 @@
 import { sql, UpdateQueryResponse } from "@forge/sql";
 import { saveMetaDataToContext } from "./metadataContextUtils";
 import { getOperationType } from "./requestTypeContextUtils";
-import {withTimeout} from "./sqlUtils";
+import { withTimeout } from "./sqlUtils";
 
-const timeoutMs =10000;
+const timeoutMs = 10000;
 const timeoutMessage = `Atlassian @forge/sql did not return a response within ${timeoutMs}ms (${timeoutMs / 1000} seconds), so the request is blocked. Possible causes: slow query, network issues, or exceeding Forge SQL limits.`;
 
 /**
@@ -92,7 +92,7 @@ async function processDDLResult(method: QueryMethod, result: any): Promise<Forge
   }
 
   if (isUpdateQueryResponse(result.rows)) {
-    const oneRow = result.rows as any;
+    const oneRow = result.rows;
     return { ...oneRow, rows: [oneRow] };
   }
 
@@ -145,8 +145,8 @@ async function processAllMethod(query: string, params: unknown[]): Promise<Forge
     await sqlStatement.bindParams(...params);
   }
 
-  const result = (await withTimeout(sqlStatement.execute(), timeoutMessage, timeoutMs)) as ForgeSQLResult;
-  await saveMetaDataToContext(result.metadata);
+  const result = await withTimeout(sqlStatement.execute(), timeoutMessage, timeoutMs);
+  await saveMetaDataToContext(result.metadata as ForgeSQLMetadata);
 
   if (!result.rows) {
     return { rows: [] };
@@ -188,7 +188,11 @@ export const forgeDriver = async (
   const operationType = await getOperationType();
   // Handle DDL operations
   if (operationType === "DDL") {
-    const result = await withTimeout(sql.executeDDL(inlineParams(query, params)), timeoutMessage, timeoutMs);
+    const result = await withTimeout(
+      sql.executeDDL(inlineParams(query, params)),
+      timeoutMessage,
+      timeoutMs,
+    );
     return await processDDLResult(method, result);
   }
 

package/src/utils/metadataContextUtils.ts

@@ -19,10 +19,7 @@ export async function saveMetaDataToContext(metadata?: ForgeSQLMetadata): Promis
       if (process.env.NODE_ENV !== "test") {
         await new Promise((r) => setTimeout(r, 200));
       }
-       await printQueriesWithPlan(
-        context.forgeSQLORM,
-        Date.now() - context.beginTime.getTime(),
-      );
+      await printQueriesWithPlan(context.forgeSQLORM, Date.now() - context.beginTime.getTime());
     };
     if (metadata) {
       context.totalResponseSize += metadata.responseSize;