forge-sql-orm 2.1.4 → 2.1.5

package/src/core/ForgeSQLORM.ts

@@ -38,6 +38,8 @@ import { cacheApplicationContext, localCacheApplicationContext } from "../utils/
 import { clearTablesCache } from "../utils/cacheUtils";
 import { SQLWrapper } from "drizzle-orm/sql/sql";
 import { WithSubquery } from "drizzle-orm/subquery";
+import { ForgeSQLMetadata } from "../utils/forgeDriver";
+import {getLastestMetadata, metadataQueryContext} from "../utils/metadataContextUtils";
 
 /**
  * Implementation of ForgeSQLORM that uses Drizzle ORM for query building.
@@ -45,59 +47,100 @@ import { WithSubquery } from "drizzle-orm/subquery";
  * to use Drizzle's query builder while executing queries through Forge SQL.
  */
 class ForgeSQLORMImpl implements ForgeSqlOperation {
-  private static instance: ForgeSQLORMImpl | null = null;
-  private readonly drizzle: MySqlRemoteDatabase<any> & {
-    selectAliased: SelectAliasedType;
-    selectAliasedDistinct: SelectAliasedDistinctType;
-    selectAliasedCacheable: SelectAliasedCacheableType;
-    selectAliasedDistinctCacheable: SelectAliasedDistinctCacheableType;
-    insertWithCacheContext: InsertAndEvictCacheType;
-    insertAndEvictCache: InsertAndEvictCacheType;
-    updateAndEvictCache: UpdateAndEvictCacheType;
-    updateWithCacheContext: UpdateAndEvictCacheType;
-    deleteAndEvictCache: DeleteAndEvictCacheType;
-    deleteWithCacheContext: DeleteAndEvictCacheType;
-  };
-  private readonly crudOperations: VerioningModificationForgeSQL;
-  private readonly fetchOperations: SchemaSqlForgeSql;
-  private readonly analyzeOperations: SchemaAnalyzeForgeSql;
-  private readonly cacheOperations: ForgeSQLCacheOperations;
-  private readonly options: ForgeSqlOrmOptions;
+    private static instance: ForgeSQLORMImpl | null = null;
+    private readonly drizzle: MySqlRemoteDatabase<any> & {
+        selectAliased: SelectAliasedType;
+        selectAliasedDistinct: SelectAliasedDistinctType;
+        selectAliasedCacheable: SelectAliasedCacheableType;
+        selectAliasedDistinctCacheable: SelectAliasedDistinctCacheableType;
+        insertWithCacheContext: InsertAndEvictCacheType;
+        insertAndEvictCache: InsertAndEvictCacheType;
+        updateAndEvictCache: UpdateAndEvictCacheType;
+        updateWithCacheContext: UpdateAndEvictCacheType;
+        deleteAndEvictCache: DeleteAndEvictCacheType;
+        deleteWithCacheContext: DeleteAndEvictCacheType;
+    };
+    private readonly crudOperations: VerioningModificationForgeSQL;
+    private readonly fetchOperations: SchemaSqlForgeSql;
+    private readonly analyzeOperations: SchemaAnalyzeForgeSql;
+    private readonly cacheOperations: ForgeSQLCacheOperations;
+    private readonly options: ForgeSqlOrmOptions;
 
-  /**
-   * Private constructor to enforce singleton behavior.
-   * @param options - Options for configuring ForgeSQL ORM behavior.
-   */
-  private constructor(options?: ForgeSqlOrmOptions) {
-    try {
-      const newOptions: ForgeSqlOrmOptions = options ?? {
-        logRawSqlQuery: false,
-        disableOptimisticLocking: false,
-        cacheWrapTable: true,
-        cacheTTL: 120,
-        cacheEntityQueryName: "sql",
-        cacheEntityExpirationName: "expiration",
-        cacheEntityDataName: "data",
-      };
-      this.options = newOptions;
-      if (newOptions.logRawSqlQuery) {
-        console.debug("Initializing ForgeSQLORM...");
-      }
-      // Initialize Drizzle instance with our custom driver
-      const proxiedDriver = createForgeDriverProxy(newOptions.hints, newOptions.logRawSqlQuery);
-      this.drizzle = patchDbWithSelectAliased(
-        drizzle(proxiedDriver, { logger: newOptions.logRawSqlQuery }),
-        newOptions,
-      );
-      this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
-      this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
-      this.analyzeOperations = new ForgeSQLAnalyseOperation(this);
-      this.cacheOperations = new ForgeSQLCacheOperations(newOptions, this);
-    } catch (error) {
-      console.error("ForgeSQLORM initialization failed:", error);
-      throw error;
+    /**
+     * Private constructor to enforce singleton behavior.
+     * @param options - Options for configuring ForgeSQL ORM behavior.
+     */
+    private constructor(options?: ForgeSqlOrmOptions) {
+        try {
+            const newOptions: ForgeSqlOrmOptions = options ?? {
+                logRawSqlQuery: false,
+                logCache: false,
+                disableOptimisticLocking: false,
+                cacheWrapTable: true,
+                cacheTTL: 120,
+                cacheEntityQueryName: "sql",
+                cacheEntityExpirationName: "expiration",
+                cacheEntityDataName: "data",
+            };
+            this.options = newOptions;
+            if (newOptions.logRawSqlQuery) {
+                // eslint-disable-next-line no-console
+                console.debug("Initializing ForgeSQLORM...");
+            }
+            // Initialize Drizzle instance with our custom driver
+            const proxiedDriver = createForgeDriverProxy(newOptions.hints, newOptions.logRawSqlQuery);
+            this.drizzle = patchDbWithSelectAliased(
+                drizzle(proxiedDriver, {logger: newOptions.logRawSqlQuery}),
+                newOptions,
+            );
+            this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
+            this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
+            this.analyzeOperations = new ForgeSQLAnalyseOperation(this);
+            this.cacheOperations = new ForgeSQLCacheOperations(newOptions, this);
+        } catch (error) {
+            // eslint-disable-next-line no-console
+            console.error("ForgeSQLORM initialization failed:", error);
+            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<T>(query: () => Promise<T>, onMetadata: (totalDbExecutionTime: number, totalResponseSize: number, forgeMetadata: ForgeSQLMetadata) => Promise<void> | void): Promise<T> {
+       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.
@@ -610,6 +653,31 @@ class ForgeSQLORM implements ForgeSqlOperation {
     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<T>(query: () => Promise<T>, onMetadata: (totalDbExecutionTime: number, totalResponseSize: number, forgeMetadata: ForgeSQLMetadata) => Promise<void> | void): Promise<T> {
+        return this.ormInstance.executeWithMetadata(query, onMetadata);
+    }
+
   selectCacheable<TSelection extends SelectedFields>(
     fields: TSelection,
     cacheTTL?: number,

package/src/core/ForgeSQLQueryBuilder.ts

@@ -26,19 +26,19 @@ import {
 } from "./SystemTables";
 import { ForgeSQLCacheOperations } from "./ForgeSQLCacheOperations";
 import {
-  DeleteAndEvictCacheType,
-  ExecuteQuery,
-  ExecuteQueryCacheable,
-  InsertAndEvictCacheType,
-  SelectAliasedCacheableType,
-  SelectAliasedDistinctCacheableType,
-  SelectAliasedDistinctType,
-  SelectAliasedType,
-  SelectAllDistinctFromAliasedType,
-  SelectAllDistinctFromCacheableAliasedType,
-  SelectAllFromAliasedType,
-  SelectAllFromCacheableAliasedType,
-  UpdateAndEvictCacheType,
+    DeleteAndEvictCacheType,
+    ExecuteQuery,
+    ExecuteQueryCacheable, ForgeSQLMetadata,
+    InsertAndEvictCacheType,
+    SelectAliasedCacheableType,
+    SelectAliasedDistinctCacheableType,
+    SelectAliasedDistinctType,
+    SelectAliasedType,
+    SelectAllDistinctFromAliasedType,
+    SelectAllDistinctFromCacheableAliasedType,
+    SelectAllFromAliasedType,
+    SelectAllFromCacheableAliasedType,
+    UpdateAndEvictCacheType,
 } from "..";
 import {
   MySqlDeleteBase,
@@ -497,6 +497,31 @@ export interface QueryBuilderForgeSql {
    */
   executeWithLocalCacheContextAndReturnValue<T>(cacheContext: () => Promise<T>): Promise<T>;
 
+  /**
+   * 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);
+   *   }
+   * );
+   * ```
+   */
+  executeWithMetadata<T>(
+    query: () => Promise<T>, 
+    onMetadata: (totalDbExecutionTime: number, totalResponseSize: number, forgeMetadata: ForgeSQLMetadata) => Promise<void> | void
+  ): Promise<T>;
   /**
    * Executes a raw SQL query with local cache support.
    * This method provides local caching for raw SQL queries within the current invocation context.
@@ -816,22 +841,31 @@ export type AdditionalMetadata = Record<string, TableMetadata>;
  * @interface ForgeSqlOrmOptions
  */
 export interface ForgeSqlOrmOptions {
-  /** Whether to log raw SQL queries */
+  /** Whether to log raw SQL queries to the console */
   logRawSqlQuery?: boolean;
-  /** Whether to disable optimistic locking */
+  /** Whether to log cache operations (hits, misses, evictions) */
+  logCache?: boolean;
+  /** Whether to disable optimistic locking for update operations */
   disableOptimisticLocking?: boolean;
-  /** SQL hints to be applied to queries */
+  /** SQL hints to be applied to queries for optimization */
   hints?: SqlHints;
+  /** Default Cache TTL (Time To Live) in seconds */
   cacheTTL?: number;
+  /** Name of the KVS entity used for cache storage */
   cacheEntityName?: string;
+  /** Name of the field in cache entity that stores SQL query */
   cacheEntityQueryName?: string;
+  /** Whether to wrap table names with backticks in cache keys */
   cacheWrapTable?: boolean;
+  /** Name of the field in cache entity that stores expiration timestamp */
   cacheEntityExpirationName?: string;
+  /** Name of the field in cache entity that stores cached data */
   cacheEntityDataName?: string;
 
   /**
    * Additional metadata for table configuration.
-   * Allows specifying table-specific settings and behaviors.
+   * Allows specifying table-specific settings and behaviors such as version fields for optimistic locking.
+   * 
    * @example
    * ```typescript
    * {

package/src/core/ForgeSQLSelectOperations.ts

@@ -58,6 +58,7 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
   async executeRawSQL<T extends object | unknown>(query: string, params?: unknown[]): Promise<T[]> {
     if (this.options.logRawSqlQuery) {
       const paramsStr = params ? `, with params: ${JSON.stringify(params)}` : "";
+        // eslint-disable-next-line no-console
       console.debug(`Executing with SQL ${query}${paramsStr}`);
     }
     const sqlStatement = sql.prepare<T>(query);
@@ -80,6 +81,7 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
       sqlStatement.bindParams(...params);
     }
     if (this.options.logRawSqlQuery) {
+        // eslint-disable-next-line no-console
       console.debug(
         `Executing Update with SQL ${query}` +
           (params ? `, with params: ${JSON.stringify(params)}` : ""),

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

@@ -268,6 +268,7 @@ async function handleSuccessfulExecution(
       await evictLocalCacheQuery(table, options);
       if (isCached) {
         await clearCache(table, options).catch((e) => {
+            // eslint-disable-next-line no-console
           console.warn("Ignore cache clear errors", e);
         });
       } else {
@@ -457,6 +458,7 @@ async function handleCachedQuery(
     await saveQueryLocalCacheQuery(target, transformed, options);
     await setCacheResult(target, options, transformed, cacheTtl).catch((cacheError) => {
       // Log cache error but don't fail the query
+        // eslint-disable-next-line no-console
       console.warn("Cache set error:", cacheError);
     });
 

package/src/utils/cacheContextUtils.ts

@@ -102,8 +102,9 @@ export async function saveQueryLocalCacheQuery<
       sql: sql.toSQL().sql.toLowerCase(),
       data: rows,
     };
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       const q = sql.toSQL();
+        // eslint-disable-next-line no-console
       console.debug(
         `[forge-sql-orm][local-cache][SAVE] Stored result in cache. sql="${q.sql}", params=${JSON.stringify(q.params)}`,
       );
@@ -140,8 +141,9 @@ export async function getQueryLocalCacheQuery<
     const sql = query as { toSQL: () => Query };
     const key = hashKey(sql.toSQL());
     if (context.cache[key] && context.cache[key].sql === sql.toSQL().sql.toLowerCase()) {
-      if (options.logRawSqlQuery) {
+      if (options.logCache) {
         const q = sql.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)}`,
         );

package/src/utils/cacheUtils.ts

@@ -123,7 +123,8 @@ async function clearCursorCache(
 
   const listResult = await entityQueryBuilder.limit(100).getMany();
 
-  if (options.logRawSqlQuery) {
+  if (options.logCache) {
+      // eslint-disable-next-line no-console
     console.warn(`clear cache Records: ${JSON.stringify(listResult.results.map((r) => r.key))}`);
   }
 
@@ -170,7 +171,8 @@ async function clearExpirationCursorCache(
 
   const listResult = await entityQueryBuilder.limit(100).getMany();
 
-  if (options.logRawSqlQuery) {
+  if (options.logCache) {
+      // eslint-disable-next-line no-console
     console.warn(`clear expired Records: ${JSON.stringify(listResult.results.map((r) => r.key))}`);
   }
 
@@ -201,10 +203,12 @@ async function executeWithRetry<T>(operation: () => Promise<T>, operationName: s
     try {
       return await operation();
     } catch (err: any) {
+        // eslint-disable-next-line no-console
       console.warn(`Error during ${operationName}: ${err.message}, retry ${attempt}`, err);
       attempt++;
 
       if (attempt >= CACHE_CONSTANTS.MAX_RETRY_ATTEMPTS) {
+          // eslint-disable-next-line no-console
         console.error(`Error during ${operationName}: ${err.message}`, err);
         throw err;
       }
@@ -260,8 +264,9 @@ export async function clearTablesCache(
       "clearing cache",
     );
   } finally {
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       const duration = DateTime.now().toSeconds() - startTime.toSeconds();
+        // eslint-disable-next-line no-console
       console.info(`Cleared ${totalRecords} cache records in ${duration} seconds`);
     }
   }
@@ -287,7 +292,8 @@ export async function clearExpiredCache(options: ForgeSqlOrmOptions): Promise<vo
     );
   } finally {
     const duration = DateTime.now().toSeconds() - startTime.toSeconds();
-    if (options?.logRawSqlQuery) {
+    if (options?.logCache) {
+        // eslint-disable-next-line no-console
       console.debug(`Cleared ${totalRecords} expired cache records in ${duration} seconds`);
     }
   }
@@ -318,7 +324,8 @@ export async function getFromCache<T>(
 
   // Skip cache if table is in cache context (will be cleared)
   if (await isTableContainsTableInCacheContext(sqlQuery.sql, options)) {
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
+        // eslint-disable-next-line no-console
       console.warn(`Context contains value to clear. Skip getting from cache`);
     }
     return undefined;
@@ -332,13 +339,15 @@ export async function getFromCache<T>(
       (cacheResult[expirationName] as number) >= getCurrentTime() &&
       sqlQuery.sql.toLowerCase() === cacheResult[entityQueryName]
     ) {
-      if (options.logRawSqlQuery) {
+      if (options.logCache) {
+          // eslint-disable-next-line no-console
         console.warn(`Get value from cache, cacheKey: ${key}`);
       }
       const results = cacheResult[dataName];
       return JSON.parse(results as string);
     }
   } catch (error: any) {
+      // eslint-disable-next-line no-console
     console.error(`Error getting from cache: ${error.message}`, error);
   }
 
@@ -375,7 +384,8 @@ export async function setCacheResult(
 
     // Skip cache if table is in cache context (will be cleared)
     if (await isTableContainsTableInCacheContext(sqlQuery.sql, options)) {
-      if (options.logRawSqlQuery) {
+      if (options.logCache) {
+          // eslint-disable-next-line no-console
         console.warn(`Context contains value to clear. Skip setting from cache`);
       }
       return;
@@ -396,10 +406,12 @@ export async function setCacheResult(
       )
       .execute();
 
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
+        // eslint-disable-next-line no-console
       console.warn(`Store value to cache, cacheKey: ${key}`);
     }
   } catch (error: any) {
+      // eslint-disable-next-line no-console
     console.error(`Error setting cache: ${error.message}`, error);
   }
 }

package/src/utils/forgeDriver.ts

@@ -1,7 +1,27 @@
 import { sql, UpdateQueryResponse } from "@forge/sql";
+import {saveMetaDataInContextContext} from "./metadataContextUtils";
 
-interface ForgeSQLResult {
+export type ForgeSQLMetadata = {
+    dbExecutionTime: number,
+    responseSize: number,
+    fields: {
+        "catalog": string,
+        "name": string,
+        "schema": string,
+        "characterSet": number,
+        "decimals": number,
+        "table": string,
+        "orgTable": string,
+        "orgName": string,
+        "flags": number,
+        "columnType": number,
+        "columnLength": number
+    }[]
+};
+
+export interface ForgeSQLResult {
   rows: Record<string, unknown>[] | Record<string, unknown>;
+  metadata: ForgeSQLMetadata
 }
 
 export const forgeDriver = async (
@@ -27,6 +47,7 @@ export const forgeDriver = async (
       await sqlStatement.bindParams(...params);
     }
     const result = (await sqlStatement.execute()) as ForgeSQLResult;
+    await saveMetaDataInContextContext(result.metadata)
     let rows;
     rows = (result.rows as any[]).map((r) => Object.values(r as Record<string, unknown>));
     return { rows: rows };

package/src/utils/forgeDriverProxy.ts

@@ -19,6 +19,7 @@ export function createForgeDriverProxy(options?: SqlHints, logRawSqlQuery?: bool
     const modifiedQuery = injectSqlHints(query, options);
 
     if (options && logRawSqlQuery && modifiedQuery !== query) {
+        // eslint-disable-next-line no-console
       console.debug("injected Hints: " + modifiedQuery);
     }
     try {
@@ -26,6 +27,7 @@ export function createForgeDriverProxy(options?: SqlHints, logRawSqlQuery?: bool
       return await forgeDriver(modifiedQuery, params, method);
     } catch (error) {
       if (logRawSqlQuery) {
+          // eslint-disable-next-line no-console
         console.debug("SQL Error:", JSON.stringify(error));
       }
       throw error;

package/src/utils/metadataContextUtils.ts

@@ -0,0 +1,24 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import {ForgeSQLMetadata} from "./forgeDriver";
+
+export type MetadataQueryContext = {
+    totalDbExecutionTime: number,
+    totalResponseSize: number,
+    lastMetadata?: ForgeSQLMetadata;
+}
+export const metadataQueryContext = new AsyncLocalStorage<MetadataQueryContext>();
+
+export async function saveMetaDataInContextContext(
+  metadata: ForgeSQLMetadata,
+): Promise<void> {
+  const context = metadataQueryContext.getStore();
+  if (context && metadata) {
+      context.totalResponseSize += metadata.responseSize
+      context.totalDbExecutionTime += metadata.dbExecutionTime
+      context.lastMetadata = metadata;
+  }
+}
+
+export async function getLastestMetadata():Promise<MetadataQueryContext|undefined> {
+    return metadataQueryContext.getStore();
+}

package/src/utils/sqlUtils.ts

@@ -329,6 +329,7 @@ export function generateDropTableStatements(
   const dropStatements: string[] = [];
   const validOptions = options ?? { sequence: true, table: true };
   if (!validOptions.sequence && !validOptions.table) {
+      // eslint-disable-next-line no-console
     console.warn('No drop operations requested: both "table" and "sequence" options are false');
     return [];
   }

package/src/webtriggers/applyMigrationsWebTrigger.ts

@@ -31,12 +31,14 @@ export const applySchemaMigrations = async (
     if (typeof migration !== "function") {
       throw new Error("migration is not a function");
     }
-
+      // eslint-disable-next-line no-console
     console.log("Provisioning the database");
     await sql._provision();
+      // eslint-disable-next-line no-console
     console.info("Running schema migrations");
     const migrations = await migration(migrationRunner);
     const successfulMigrations = await migrations.run();
+      // eslint-disable-next-line no-console
     console.info("Migrations applied:", successfulMigrations);
 
     const migrationList = await migrationRunner.list();
@@ -51,7 +53,7 @@ export const applySchemaMigrations = async (
         .map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`)
         .join("\n");
     }
-
+      // eslint-disable-next-line no-console
     console.info("Migrations history:\nid, name, migrated_at\n", migrationHistory);
 
     return {
@@ -68,6 +70,7 @@ export const applySchemaMigrations = async (
       error?.debug?.context?.message ??
       error.message ??
       "Unknown error occurred";
+      // eslint-disable-next-line no-console
     console.error("Error during migration:", errorMessage);
     return {
       headers: { "Content-Type": ["application/json"] },

package/src/webtriggers/clearCacheSchedulerTrigger.ts

@@ -64,6 +64,7 @@ export const clearCacheSchedulerTrigger = async (options?: ForgeSqlOrmOptions) =
       }),
     };
   } catch (error) {
+      // eslint-disable-next-line no-console
     console.error("Error during cache cleanup: ", JSON.stringify(error));
     return {
       headers: { "Content-Type": ["application/json"] },

package/src/webtriggers/dropMigrationWebTrigger.ts

@@ -34,6 +34,7 @@ export async function dropSchemaMigrations(): Promise<TriggerResponse<string>> {
 
     // Execute each statement
     for (const statement of dropStatements) {
+        // eslint-disable-next-line no-console
       console.debug(`execute DDL: ${statement}`);
       await sql.executeDDL(statement);
     }
@@ -48,6 +49,7 @@ export async function dropSchemaMigrations(): Promise<TriggerResponse<string>> {
       error?.debug?.message ??
       error.message ??
       "Unknown error occurred";
+      // eslint-disable-next-line no-console
     console.error(errorMessage);
     return getHttpResponse<string>(500, errorMessage);
   }

package/src/webtriggers/dropTablesMigrationWebTrigger.ts

@@ -34,6 +34,7 @@ export async function dropTableSchemaMigrations(): Promise<TriggerResponse<strin
 
     // Execute each statement
     for (const statement of dropStatements) {
+        // eslint-disable-next-line no-console
       console.debug(`execute DDL: ${statement}`);
       await sql.executeDDL(statement);
     }
@@ -48,6 +49,7 @@ export async function dropTableSchemaMigrations(): Promise<TriggerResponse<strin
       error?.debug?.message ??
       error.message ??
       "Unknown error occurred";
+      // eslint-disable-next-line no-console
     console.error(errorMessage);
     return getHttpResponse<string>(500, errorMessage);
   }

package/src/webtriggers/fetchSchemaWebTrigger.ts

@@ -46,6 +46,7 @@ export async function fetchSchemaWebTrigger(): Promise<TriggerResponse<string>>
       error?.debug?.message ??
       error.message ??
       "Unknown error occurred";
+      // eslint-disable-next-line no-console
     console.error(errorMessage);
     return getHttpResponse<string>(500, errorMessage);
   }