forge-sql-orm 2.1.4 → 2.1.6

package/src/core/ForgeSQLORM.ts

@@ -38,6 +38,10 @@ 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";
+import { operationTypeQueryContext } from "../utils/requestTypeContextUtils";
+import type { MySqlQueryResultKind } from "drizzle-orm/mysql-core/session";
 
 /**
  * Implementation of ForgeSQLORM that uses Drizzle ORM for query building.
@@ -72,6 +76,7 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
     try {
       const newOptions: ForgeSqlOrmOptions = options ?? {
         logRawSqlQuery: false,
+        logCache: false,
         disableOptimisticLocking: false,
         cacheWrapTable: true,
         cacheTTL: 120,
@@ -81,6 +86,7 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
       };
       this.options = newOptions;
       if (newOptions.logRawSqlQuery) {
+        // eslint-disable-next-line no-console
         console.debug("Initializing ForgeSQLORM...");
       }
       // Initialize Drizzle instance with our custom driver
@@ -94,11 +100,63 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
       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.
    * All clearCache calls within the context are collected and executed in batch at the end.
@@ -531,8 +589,101 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
    * const result = await forgeSQL.execute("SELECT * FROM users WHERE status = 'active'");
    * ```
    */
-  execute(query: SQLWrapper | string) {
-    return this.drizzle.executeQuery(query);
+  execute<T>(query: SQLWrapper | string) {
+    return this.drizzle.executeQuery<T>(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<T>(query: SQLWrapper | string) {
+    return this.executeDDLActions(async () => this.drizzle.executeQuery<T>(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<T>(actions: () => Promise<T>): Promise<T> {
+    return operationTypeQueryContext.run({ operationType: "DDL" }, async () => actions());
   }
 
   /**
@@ -553,8 +704,8 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
    * const result = await forgeSQL.executeCacheable("SELECT * FROM users WHERE status = 'active'");
    * ```
    */
-  executeCacheable(query: SQLWrapper | string, cacheTtl?: number) {
-    return this.drizzle.executeQueryCacheable(query, cacheTtl);
+  executeCacheable<T>(query: SQLWrapper | string, cacheTtl?: number) {
+    return this.drizzle.executeQueryCacheable<T>(query, cacheTtl);
   }
 
   /**
@@ -610,6 +761,38 @@ 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,
@@ -909,8 +1092,103 @@ class ForgeSQLORM implements ForgeSqlOperation {
    * const result = await forgeSQL.execute("SELECT * FROM users WHERE status = 'active'");
    * ```
    */
-  execute(query: SQLWrapper | string) {
-    return this.ormInstance.getDrizzleQueryBuilder().executeQuery(query);
+  execute<T>(
+    query: SQLWrapper | string,
+  ): Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, T>> {
+    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: SQLWrapper | string) {
+    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<T>(actions: () => Promise<T>): Promise<T> {
+    return this.ormInstance.executeDDLActions(actions);
   }
 
   /**
@@ -932,7 +1210,7 @@ class ForgeSQLORM implements ForgeSqlOperation {
    * ```
    */
   executeCacheable(query: SQLWrapper | string, cacheTtl?: number) {
-    return this.ormInstance.getDrizzleQueryBuilder().executeQueryCacheable(query, cacheTtl);
+    return this.ormInstance.executeCacheable(query, cacheTtl);
   }
 
   /**
@@ -943,7 +1221,7 @@ class ForgeSQLORM implements ForgeSqlOperation {
    * @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)
    * );
@@ -962,7 +1240,7 @@ class ForgeSQLORM implements ForgeSqlOperation {
    * @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)
    * );

package/src/core/ForgeSQLQueryBuilder.ts

@@ -29,6 +29,7 @@ import {
   DeleteAndEvictCacheType,
   ExecuteQuery,
   ExecuteQueryCacheable,
+  ForgeSQLMetadata,
   InsertAndEvictCacheType,
   SelectAliasedCacheableType,
   SelectAliasedDistinctCacheableType,
@@ -497,6 +498,35 @@ 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.
@@ -513,9 +543,100 @@ export interface QueryBuilderForgeSql {
    * const result = await forgeSQL.execute("SELECT * FROM users WHERE status = 'active'");
    * ```
    */
-  execute(
+  execute<T>(
+    query: SQLWrapper | string,
+  ): Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, T>>;
+
+  /**
+   * 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<T>(
     query: SQLWrapper | string,
-  ): Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, unknown>>;
+  ): Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, T>>;
+
+  /**
+   * 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<T>(actions: () => Promise<T>): Promise<T>;
 
   /**
    * Executes a raw SQL query with both local and global cache support.
@@ -535,10 +656,10 @@ export interface QueryBuilderForgeSql {
    * const result = await forgeSQL.executeCacheable("SELECT * FROM users WHERE status = 'active'");
    * ```
    */
-  executeCacheable(
+  executeCacheable<T>(
     query: SQLWrapper | string,
     cacheTtl?: number,
-  ): Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, unknown>>;
+  ): Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, T>>;
   /**
    * Creates a Common Table Expression (CTE) builder for complex queries.
    * CTEs allow you to define temporary named result sets that exist within the scope of a single query.
@@ -816,22 +937,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/core/SystemTables.ts

@@ -312,6 +312,22 @@ export const clusterStatementsSummaryHistory = informationSchema.table(
 // Types
 export type ClusterStatementsSummaryHistory = typeof clusterStatementsSummaryHistory.$inferSelect;
 
+export const statementsSummaryHistory = informationSchema.table(
+  "STATEMENTS_SUMMARY_HISTORY",
+  createClusterStatementsSummarySchema(),
+);
+
+// Types
+export type StatementsSummaryHistory = typeof statementsSummaryHistory.$inferSelect;
+
+export const statementsSummary = informationSchema.table(
+  "STATEMENTS_SUMMARY",
+  createClusterStatementsSummarySchema(),
+);
+
+// Types
+export type StatementsSummary = typeof statementsSummary.$inferSelect;
+
 export const clusterStatementsSummary = informationSchema.table(
   "CLUSTER_STATEMENTS_SUMMARY",
   createClusterStatementsSummarySchema(),

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

@@ -22,9 +22,9 @@ import {
   saveQueryLocalCacheQuery,
   saveTableIfInsideCacheContext,
 } from "../../../utils/cacheContextUtils";
-import { BuildQueryConfig, isSQLWrapper, SQLWrapper } from "drizzle-orm/sql/sql";
+import { isSQLWrapper, SQLWrapper } from "drizzle-orm/sql/sql";
 import type { MySqlQueryResultKind } from "drizzle-orm/mysql-core/session";
-import { getTableColumns, Query } from "drizzle-orm";
+import { getTableColumns, Query, SQL } from "drizzle-orm";
 import { MySqlDialect } from "drizzle-orm/mysql-core/dialect";
 import type {
   GetSelectTableName,
@@ -204,17 +204,17 @@ export type SelectAllDistinctFromCacheableAliasedType = <T extends MySqlTable>(
 /**
  * Type for executing raw SQL queries with local cache
  */
-export type ExecuteQuery = (
+export type ExecuteQuery = <T>(
   query: SQLWrapper | string,
-) => Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, unknown>>;
+) => Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, T>>;
 
 /**
  * Type for executing raw SQL queries with local and global cache
  */
-export type ExecuteQueryCacheable = (
+export type ExecuteQueryCacheable = <T>(
   query: SQLWrapper | string,
   cacheTtl?: number,
-) => Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, unknown>>;
+) => Promise<MySqlQueryResultKind<MySqlRemoteQueryResultHKT, T>>;
 
 /**
  * Type for insert operations with cache eviction
@@ -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);
     });
 
@@ -615,12 +617,8 @@ function createRawQueryExecutor(
     let sql: Query;
 
     if (isSQLWrapper(query)) {
-      const sqlWrapper = query as SQLWrapper;
-      sql = sqlWrapper
-        .getSQL()
-        .toQuery(
-          (db as unknown as { dialect: MySqlDialect }).dialect as unknown as BuildQueryConfig,
-        );
+      const dialect = (db as unknown as { dialect: MySqlDialect }).dialect;
+      sql = dialect.sqlToQuery(query as SQL);
     } else {
       sql = {
         sql: query,