forge-sql-orm 2.1.12 → 2.1.14

package/dist/ForgeSQLORM.mjs

@@ -1,3905 +0,0 @@
-import { isTable, sql as sql$1, and, isNotNull, not, ilike, notInArray, gte, ne, eq, getTableColumns } from "drizzle-orm";
-import { DateTime } from "luxon";
-import { isSQLWrapper } from "drizzle-orm/sql/sql";
-import { mysqlTable, timestamp, varchar, bigint, mysqlSchema, longtext, double, boolean, text, int, customType } from "drizzle-orm/mysql-core";
-import { sql, migrationRunner } from "@forge/sql";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { getTableName } from "drizzle-orm/table";
-import * as crypto from "crypto";
-import { kvs, WhereConditions, Filter, FilterConditions } from "@forge/kvs";
-import { drizzle } from "drizzle-orm/mysql-proxy";
-const migrations = mysqlTable("__migrations", {
-  id: bigint("id", { mode: "number" }).primaryKey().autoincrement(),
-  name: varchar("name", { length: 255 }).notNull(),
-  migratedAt: timestamp("migratedAt").defaultNow().notNull()
-});
-const informationSchema = mysqlSchema("information_schema");
-const slowQuery = informationSchema.table("CLUSTER_SLOW_QUERY", {
-  time: timestamp("Time", { fsp: 6, mode: "string" }).notNull(),
-  // Timestamp when the slow query was recorded
-  txnStartTs: bigint("Txn_start_ts", { mode: "bigint", unsigned: true }),
-  // Transaction start timestamp (TSO)
-  user: varchar("User", { length: 64 }),
-  // User executing the query
-  host: varchar("Host", { length: 64 }),
-  // Host from which the query originated
-  connId: bigint("Conn_ID", { mode: "bigint", unsigned: true }),
-  // Connection ID
-  sessionAlias: varchar("Session_alias", { length: 64 }),
-  // Session alias
-  execRetryCount: bigint("Exec_retry_count", { mode: "bigint", unsigned: true }),
-  // Number of retries during execution
-  execRetryTime: double("Exec_retry_time"),
-  // Time spent in retries
-  queryTime: double("Query_time"),
-  // Total execution time
-  parseTime: double("Parse_time"),
-  // Time spent parsing SQL
-  compileTime: double("Compile_time"),
-  // Time spent compiling query plan
-  rewriteTime: double("Rewrite_time"),
-  // Time spent rewriting query
-  preprocSubqueries: bigint("Preproc_subqueries", { mode: "bigint", unsigned: true }),
-  // Number of subqueries preprocessed
-  preprocSubqueriesTime: double("Preproc_subqueries_time"),
-  // Time spent preprocessing subqueries
-  optimizeTime: double("Optimize_time"),
-  // Time spent in optimizer
-  waitTs: double("Wait_TS"),
-  // Wait time for getting TSO
-  prewriteTime: double("Prewrite_time"),
-  // Time spent in prewrite phase
-  waitPrewriteBinlogTime: double("Wait_prewrite_binlog_time"),
-  // Time waiting for binlog prewrite
-  commitTime: double("Commit_time"),
-  // Commit duration
-  getCommitTsTime: double("Get_commit_ts_time"),
-  // Time waiting for commit TSO
-  commitBackoffTime: double("Commit_backoff_time"),
-  // Backoff time during commit
-  backoffTypes: varchar("Backoff_types", { length: 64 }),
-  // Types of backoff occurred
-  resolveLockTime: double("Resolve_lock_time"),
-  // Time resolving locks
-  localLatchWaitTime: double("Local_latch_wait_time"),
-  // Time waiting on local latch
-  writeKeys: bigint("Write_keys", { mode: "bigint" }),
-  // Number of keys written
-  writeSize: bigint("Write_size", { mode: "bigint" }),
-  // Amount of data written
-  prewriteRegion: bigint("Prewrite_region", { mode: "bigint" }),
-  // Regions involved in prewrite
-  txnRetry: bigint("Txn_retry", { mode: "bigint" }),
-  // Transaction retry count
-  copTime: double("Cop_time"),
-  // Time spent in coprocessor
-  processTime: double("Process_time"),
-  // Processing time
-  waitTime: double("Wait_time"),
-  // Wait time in TiKV
-  backoffTime: double("Backoff_time"),
-  // Backoff wait time
-  lockKeysTime: double("LockKeys_time"),
-  // Time spent waiting for locks
-  requestCount: bigint("Request_count", { mode: "bigint", unsigned: true }),
-  // Total number of requests
-  totalKeys: bigint("Total_keys", { mode: "bigint", unsigned: true }),
-  // Total keys scanned
-  processKeys: bigint("Process_keys", { mode: "bigint", unsigned: true }),
-  // Keys processed
-  rocksdbDeleteSkippedCount: bigint("Rocksdb_delete_skipped_count", {
-    mode: "bigint",
-    unsigned: true
-  }),
-  // RocksDB delete skips
-  rocksdbKeySkippedCount: bigint("Rocksdb_key_skipped_count", { mode: "bigint", unsigned: true }),
-  // RocksDB key skips
-  rocksdbBlockCacheHitCount: bigint("Rocksdb_block_cache_hit_count", {
-    mode: "bigint",
-    unsigned: true
-  }),
-  // RocksDB block cache hits
-  rocksdbBlockReadCount: bigint("Rocksdb_block_read_count", { mode: "bigint", unsigned: true }),
-  // RocksDB block reads
-  rocksdbBlockReadByte: bigint("Rocksdb_block_read_byte", { mode: "bigint", unsigned: true }),
-  // RocksDB block read bytes
-  db: varchar("DB", { length: 64 }),
-  // Database name
-  indexNames: varchar("Index_names", { length: 100 }),
-  // Indexes used
-  isInternal: boolean("Is_internal"),
-  // Whether the query is internal
-  digest: varchar("Digest", { length: 64 }),
-  // SQL digest hash
-  stats: varchar("Stats", { length: 512 }),
-  // Stats used during planning
-  copProcAvg: double("Cop_proc_avg"),
-  // Coprocessor average processing time
-  copProcP90: double("Cop_proc_p90"),
-  // Coprocessor 90th percentile processing time
-  copProcMax: double("Cop_proc_max"),
-  // Coprocessor max processing time
-  copProcAddr: varchar("Cop_proc_addr", { length: 64 }),
-  // Coprocessor address for processing
-  copWaitAvg: double("Cop_wait_avg"),
-  // Coprocessor average wait time
-  copWaitP90: double("Cop_wait_p90"),
-  // Coprocessor 90th percentile wait time
-  copWaitMax: double("Cop_wait_max"),
-  // Coprocessor max wait time
-  copWaitAddr: varchar("Cop_wait_addr", { length: 64 }),
-  // Coprocessor address for wait
-  memMax: bigint("Mem_max", { mode: "bigint" }),
-  // Max memory usage
-  diskMax: bigint("Disk_max", { mode: "bigint" }),
-  // Max disk usage
-  kvTotal: double("KV_total"),
-  // Total KV request time
-  pdTotal: double("PD_total"),
-  // Total PD request time
-  backoffTotal: double("Backoff_total"),
-  // Total backoff time
-  writeSqlResponseTotal: double("Write_sql_response_total"),
-  // SQL response write time
-  resultRows: bigint("Result_rows", { mode: "bigint" }),
-  // Rows returned
-  warnings: longtext("Warnings"),
-  // Warnings during execution
-  backoffDetail: varchar("Backoff_Detail", { length: 4096 }),
-  // Detailed backoff info
-  prepared: boolean("Prepared"),
-  // Whether query was prepared
-  succ: boolean("Succ"),
-  // Success flag
-  isExplicitTxn: boolean("IsExplicitTxn"),
-  // Whether explicit transaction
-  isWriteCacheTable: boolean("IsWriteCacheTable"),
-  // Whether wrote to cache table
-  planFromCache: boolean("Plan_from_cache"),
-  // Plan was from cache
-  planFromBinding: boolean("Plan_from_binding"),
-  // Plan was from binding
-  hasMoreResults: boolean("Has_more_results"),
-  // Query returned multiple results
-  resourceGroup: varchar("Resource_group", { length: 64 }),
-  // Resource group name
-  requestUnitRead: double("Request_unit_read"),
-  // RU consumed for read
-  requestUnitWrite: double("Request_unit_write"),
-  // RU consumed for write
-  timeQueuedByRc: double("Time_queued_by_rc"),
-  // Time queued by resource control
-  tidbCpuTime: double("Tidb_cpu_time"),
-  // TiDB CPU time
-  tikvCpuTime: double("Tikv_cpu_time"),
-  // TiKV CPU time
-  plan: longtext("Plan"),
-  // Query execution plan
-  planDigest: varchar("Plan_digest", { length: 128 }),
-  // Plan digest hash
-  binaryPlan: longtext("Binary_plan"),
-  // Binary execution plan
-  prevStmt: longtext("Prev_stmt"),
-  // Previous statement in session
-  query: longtext("Query")
-  // Original SQL query
-});
-const createClusterStatementsSummarySchema = () => ({
-  instance: varchar("INSTANCE", { length: 64 }),
-  // TiDB/TiKV instance address
-  summaryBeginTime: timestamp("SUMMARY_BEGIN_TIME", { mode: "string" }).notNull(),
-  // Begin time of this summary window
-  summaryEndTime: timestamp("SUMMARY_END_TIME", { mode: "string" }).notNull(),
-  // End time of this summary window
-  stmtType: varchar("STMT_TYPE", { length: 64 }).notNull(),
-  // Statement type (e.g., Select/Insert/Update)
-  schemaName: varchar("SCHEMA_NAME", { length: 64 }),
-  // Current schema name
-  digest: varchar("DIGEST", { length: 64 }),
-  // SQL digest (normalized hash)
-  digestText: text("DIGEST_TEXT").notNull(),
-  // Normalized SQL text
-  tableNames: text("TABLE_NAMES"),
-  // Involved table names
-  indexNames: text("INDEX_NAMES"),
-  // Used index names
-  sampleUser: varchar("SAMPLE_USER", { length: 64 }),
-  // Sampled user who executed the statements
-  execCount: bigint("EXEC_COUNT", { mode: "bigint", unsigned: true }).notNull(),
-  // Total executions
-  sumErrors: int("SUM_ERRORS", { unsigned: true }).notNull(),
-  // Sum of errors
-  sumWarnings: int("SUM_WARNINGS", { unsigned: true }).notNull(),
-  // Sum of warnings
-  sumLatency: bigint("SUM_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
-  // Sum of latency (ns)
-  maxLatency: bigint("MAX_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
-  // Max latency (ns)
-  minLatency: bigint("MIN_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
-  // Min latency (ns)
-  avgLatency: bigint("AVG_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg latency (ns)
-  avgParseLatency: bigint("AVG_PARSE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg parse time (ns)
-  maxParseLatency: bigint("MAX_PARSE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
-  // Max parse time (ns)
-  avgCompileLatency: bigint("AVG_COMPILE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg compile time (ns)
-  maxCompileLatency: bigint("MAX_COMPILE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
-  // Max compile time (ns)
-  sumCopTaskNum: bigint("SUM_COP_TASK_NUM", { mode: "bigint", unsigned: true }).notNull(),
-  // Total number of cop tasks
-  maxCopProcessTime: bigint("MAX_COP_PROCESS_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Max TiKV coprocessor processing time (ns)
-  maxCopProcessAddress: varchar("MAX_COP_PROCESS_ADDRESS", { length: 256 }),
-  // Address of cop task with max processing time
-  maxCopWaitTime: bigint("MAX_COP_WAIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Max TiKV coprocessor wait time (ns)
-  maxCopWaitAddress: varchar("MAX_COP_WAIT_ADDRESS", { length: 256 }),
-  // Address of cop task with max wait time
-  avgProcessTime: bigint("AVG_PROCESS_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg TiKV processing time (ns)
-  maxProcessTime: bigint("MAX_PROCESS_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Max TiKV processing time (ns)
-  avgWaitTime: bigint("AVG_WAIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg TiKV wait time (ns)
-  maxWaitTime: bigint("MAX_WAIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Max TiKV wait time (ns)
-  avgBackoffTime: bigint("AVG_BACKOFF_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg backoff time before retry (ns)
-  maxBackoffTime: bigint("MAX_BACKOFF_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Max backoff time before retry (ns)
-  avgTotalKeys: bigint("AVG_TOTAL_KEYS", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg scanned keys
-  maxTotalKeys: bigint("MAX_TOTAL_KEYS", { mode: "bigint", unsigned: true }).notNull(),
-  // Max scanned keys
-  avgProcessedKeys: bigint("AVG_PROCESSED_KEYS", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg processed keys
-  maxProcessedKeys: bigint("MAX_PROCESSED_KEYS", { mode: "bigint", unsigned: true }).notNull(),
-  // Max processed keys
-  avgRocksdbDeleteSkippedCount: double("AVG_ROCKSDB_DELETE_SKIPPED_COUNT").notNull(),
-  // Avg RocksDB deletes skipped
-  maxRocksdbDeleteSkippedCount: int("MAX_ROCKSDB_DELETE_SKIPPED_COUNT", {
-    unsigned: true
-  }).notNull(),
-  // Max RocksDB deletes skipped
-  avgRocksdbKeySkippedCount: double("AVG_ROCKSDB_KEY_SKIPPED_COUNT").notNull(),
-  // Avg RocksDB keys skipped
-  maxRocksdbKeySkippedCount: int("MAX_ROCKSDB_KEY_SKIPPED_COUNT", { unsigned: true }).notNull(),
-  // Max RocksDB keys skipped
-  avgRocksdbBlockCacheHitCount: double("AVG_ROCKSDB_BLOCK_CACHE_HIT_COUNT").notNull(),
-  // Avg RocksDB block cache hits
-  maxRocksdbBlockCacheHitCount: int("MAX_ROCKSDB_BLOCK_CACHE_HIT_COUNT", {
-    unsigned: true
-  }).notNull(),
-  // Max RocksDB block cache hits
-  avgRocksdbBlockReadCount: double("AVG_ROCKSDB_BLOCK_READ_COUNT").notNull(),
-  // Avg RocksDB block reads
-  maxRocksdbBlockReadCount: int("MAX_ROCKSDB_BLOCK_READ_COUNT", { unsigned: true }).notNull(),
-  // Max RocksDB block reads
-  avgRocksdbBlockReadByte: double("AVG_ROCKSDB_BLOCK_READ_BYTE").notNull(),
-  // Avg RocksDB block read bytes
-  maxRocksdbBlockReadByte: int("MAX_ROCKSDB_BLOCK_READ_BYTE", { unsigned: true }).notNull(),
-  // Max RocksDB block read bytes
-  avgPrewriteTime: bigint("AVG_PREWRITE_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg prewrite phase time (ns)
-  maxPrewriteTime: bigint("MAX_PREWRITE_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Max prewrite phase time (ns)
-  avgCommitTime: bigint("AVG_COMMIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg commit phase time (ns)
-  maxCommitTime: bigint("MAX_COMMIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Max commit phase time (ns)
-  avgGetCommitTsTime: bigint("AVG_GET_COMMIT_TS_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Avg get commit_ts time (ns)
-  maxGetCommitTsTime: bigint("MAX_GET_COMMIT_TS_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Max get commit_ts time (ns)
-  avgCommitBackoffTime: bigint("AVG_COMMIT_BACKOFF_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Avg backoff during commit (ns)
-  maxCommitBackoffTime: bigint("MAX_COMMIT_BACKOFF_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Max backoff during commit (ns)
-  avgResolveLockTime: bigint("AVG_RESOLVE_LOCK_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Avg resolve lock time (ns)
-  maxResolveLockTime: bigint("MAX_RESOLVE_LOCK_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Max resolve lock time (ns)
-  avgLocalLatchWaitTime: bigint("AVG_LOCAL_LATCH_WAIT_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Avg local latch wait (ns)
-  maxLocalLatchWaitTime: bigint("MAX_LOCAL_LATCH_WAIT_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Max local latch wait (ns)
-  avgWriteKeys: double("AVG_WRITE_KEYS").notNull(),
-  // Avg number of written keys
-  maxWriteKeys: bigint("MAX_WRITE_KEYS", { mode: "bigint", unsigned: true }).notNull(),
-  // Max written keys
-  avgWriteSize: double("AVG_WRITE_SIZE").notNull(),
-  // Avg written bytes
-  maxWriteSize: bigint("MAX_WRITE_SIZE", { mode: "bigint", unsigned: true }).notNull(),
-  // Max written bytes
-  avgPrewriteRegions: double("AVG_PREWRITE_REGIONS").notNull(),
-  // Avg regions in prewrite
-  maxPrewriteRegions: int("MAX_PREWRITE_REGIONS", { unsigned: true }).notNull(),
-  // Max regions in prewrite
-  avgTxnRetry: double("AVG_TXN_RETRY").notNull(),
-  // Avg transaction retry count
-  maxTxnRetry: int("MAX_TXN_RETRY", { unsigned: true }).notNull(),
-  // Max transaction retry count
-  sumExecRetry: bigint("SUM_EXEC_RETRY", { mode: "bigint", unsigned: true }).notNull(),
-  // Sum of execution retries (pessimistic)
-  sumExecRetryTime: bigint("SUM_EXEC_RETRY_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Sum time of execution retries (ns)
-  sumBackoffTimes: bigint("SUM_BACKOFF_TIMES", { mode: "bigint", unsigned: true }).notNull(),
-  // Sum of backoff retries
-  backoffTypes: varchar("BACKOFF_TYPES", { length: 1024 }),
-  // Backoff types with counts
-  avgMem: bigint("AVG_MEM", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg memory used (bytes)
-  maxMem: bigint("MAX_MEM", { mode: "bigint", unsigned: true }).notNull(),
-  // Max memory used (bytes)
-  avgDisk: bigint("AVG_DISK", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg disk used (bytes)
-  maxDisk: bigint("MAX_DISK", { mode: "bigint", unsigned: true }).notNull(),
-  // Max disk used (bytes)
-  avgKvTime: bigint("AVG_KV_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg time spent in TiKV (ns)
-  avgPdTime: bigint("AVG_PD_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg time spent in PD (ns)
-  avgBackoffTotalTime: bigint("AVG_BACKOFF_TOTAL_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Avg total backoff time (ns)
-  avgWriteSqlRespTime: bigint("AVG_WRITE_SQL_RESP_TIME", {
-    mode: "bigint",
-    unsigned: true
-  }).notNull(),
-  // Avg write SQL response time (ns)
-  avgTidbCpuTime: bigint("AVG_TIDB_CPU_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg TiDB CPU time (ns)
-  avgTikvCpuTime: bigint("AVG_TIKV_CPU_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg TiKV CPU time (ns)
-  maxResultRows: bigint("MAX_RESULT_ROWS", { mode: "bigint" }).notNull(),
-  // Max number of result rows
-  minResultRows: bigint("MIN_RESULT_ROWS", { mode: "bigint" }).notNull(),
-  // Min number of result rows
-  avgResultRows: bigint("AVG_RESULT_ROWS", { mode: "bigint" }).notNull(),
-  // Avg number of result rows
-  prepared: boolean("PREPARED").notNull(),
-  // Whether statements are prepared
-  avgAffectedRows: double("AVG_AFFECTED_ROWS").notNull(),
-  // Avg affected rows
-  firstSeen: timestamp("FIRST_SEEN", { mode: "string" }).notNull(),
-  // First time statements observed
-  lastSeen: timestamp("LAST_SEEN", { mode: "string" }).notNull(),
-  // Last time statements observed
-  planInCache: boolean("PLAN_IN_CACHE").notNull(),
-  // Whether last stmt hit plan cache
-  planCacheHits: bigint("PLAN_CACHE_HITS", { mode: "bigint" }).notNull(),
-  // Number of plan cache hits
-  planInBinding: boolean("PLAN_IN_BINDING").notNull(),
-  // Whether matched bindings
-  querySampleText: text("QUERY_SAMPLE_TEXT"),
-  // Sampled original SQL
-  prevSampleText: text("PREV_SAMPLE_TEXT"),
-  // Sampled previous SQL before commit
-  planDigest: varchar("PLAN_DIGEST", { length: 64 }),
-  // Plan digest hash
-  plan: text("PLAN"),
-  // Sampled textual plan
-  binaryPlan: text("BINARY_PLAN"),
-  // Sampled binary plan
-  charset: varchar("CHARSET", { length: 64 }),
-  // Sampled charset
-  collation: varchar("COLLATION", { length: 64 }),
-  // Sampled collation
-  planHint: varchar("PLAN_HINT", { length: 64 }),
-  // Sampled plan hint
-  maxRequestUnitRead: double("MAX_REQUEST_UNIT_READ").notNull(),
-  // Max RU cost (read)
-  avgRequestUnitRead: double("AVG_REQUEST_UNIT_READ").notNull(),
-  // Avg RU cost (read)
-  maxRequestUnitWrite: double("MAX_REQUEST_UNIT_WRITE").notNull(),
-  // Max RU cost (write)
-  avgRequestUnitWrite: double("AVG_REQUEST_UNIT_WRITE").notNull(),
-  // Avg RU cost (write)
-  maxQueuedRcTime: bigint("MAX_QUEUED_RC_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Max queued time waiting for RU (ns)
-  avgQueuedRcTime: bigint("AVG_QUEUED_RC_TIME", { mode: "bigint", unsigned: true }).notNull(),
-  // Avg queued time waiting for RU (ns)
-  resourceGroup: varchar("RESOURCE_GROUP", { length: 64 }),
-  // Bound resource group name
-  planCacheUnqualified: bigint("PLAN_CACHE_UNQUALIFIED", { mode: "bigint" }).notNull(),
-  // Times not eligible for plan cache
-  planCacheUnqualifiedLastReason: text("PLAN_CACHE_UNQUALIFIED_LAST_REASON")
-  // Last reason of plan cache ineligibility
-});
-const clusterStatementsSummaryHistory = informationSchema.table(
-  "CLUSTER_STATEMENTS_SUMMARY_HISTORY",
-  createClusterStatementsSummarySchema()
-);
-const statementsSummaryHistory = informationSchema.table(
-  "STATEMENTS_SUMMARY_HISTORY",
-  createClusterStatementsSummarySchema()
-);
-const statementsSummary = informationSchema.table(
-  "STATEMENTS_SUMMARY",
-  createClusterStatementsSummarySchema()
-);
-const clusterStatementsSummary = informationSchema.table(
-  "CLUSTER_STATEMENTS_SUMMARY",
-  createClusterStatementsSummarySchema()
-);
-async function getTables() {
-  const tables = await sql.executeDDL("SHOW TABLES");
-  return tables.rows.flatMap((tableInfo) => Object.values(tableInfo));
-}
-const forgeSystemTables = [migrations];
-const parseDateTime = (value, format) => {
-  let result;
-  if (value instanceof Date) {
-    result = value;
-  } else {
-    const dt = DateTime.fromFormat(value, format);
-    if (dt.isValid) {
-      result = dt.toJSDate();
-    } else {
-      const sqlDt = DateTime.fromSQL(value);
-      if (sqlDt.isValid) {
-        result = sqlDt.toJSDate();
-      } else {
-        const isoDt = DateTime.fromRFC2822(value);
-        if (isoDt.isValid) {
-          result = isoDt.toJSDate();
-        } else {
-          result = new Date(value);
-        }
-      }
-    }
-  }
-  if (isNaN(result.getTime())) {
-    result = new Date(value);
-  }
-  return result;
-};
-function formatDateTime(value, format, isTimeStamp) {
-  let dt = null;
-  if (value instanceof Date) {
-    dt = DateTime.fromJSDate(value);
-  } else if (typeof value === "string") {
-    for (const parser of [
-      DateTime.fromISO,
-      DateTime.fromRFC2822,
-      DateTime.fromSQL,
-      DateTime.fromHTTP
-    ]) {
-      dt = parser(value);
-      if (dt.isValid) break;
-    }
-    if (!dt?.isValid) {
-      const parsed = Number(value);
-      if (!isNaN(parsed)) {
-        dt = DateTime.fromMillis(parsed);
-      }
-    }
-  } else if (typeof value === "number") {
-    dt = DateTime.fromMillis(value);
-  } else {
-    throw new Error("Unsupported type");
-  }
-  if (!dt?.isValid) {
-    throw new Error("Invalid Date");
-  }
-  const minDate = DateTime.fromSeconds(1);
-  const maxDate = DateTime.fromMillis(2147483647 * 1e3);
-  if (isTimeStamp) {
-    if (dt < minDate) {
-      throw new Error(
-        "Atlassian Forge does not support zero or negative timestamps. Allowed range: from '1970-01-01 00:00:01.000000' to '2038-01-19 03:14:07.999999'."
-      );
-    }
-    if (dt > maxDate) {
-      throw new Error(
-        "Atlassian Forge does not support timestamps beyond 2038-01-19 03:14:07.999999. Please use a smaller date within the supported range."
-      );
-    }
-  }
-  return dt.toFormat(format);
-}
-function getPrimaryKeys(table) {
-  const { columns, primaryKeys } = getTableMetadata(table);
-  const columnPrimaryKeys = Object.entries(columns).filter(([, column]) => column.primary);
-  if (columnPrimaryKeys.length > 0) {
-    return columnPrimaryKeys;
-  }
-  if (Array.isArray(primaryKeys) && primaryKeys.length > 0) {
-    const primaryKeyColumns = /* @__PURE__ */ new Set();
-    primaryKeys.forEach((primaryKeyBuilder) => {
-      Object.entries(columns).filter(([, column]) => {
-        return primaryKeyBuilder.columns.includes(column);
-      }).forEach(([name, column]) => {
-        primaryKeyColumns.add([name, column]);
-      });
-    });
-    return Array.from(primaryKeyColumns);
-  }
-  return [];
-}
-function processForeignKeys(table, foreignKeysSymbol, extraSymbol) {
-  const foreignKeys = [];
-  if (foreignKeysSymbol) {
-    const fkArray = table[foreignKeysSymbol];
-    if (fkArray) {
-      fkArray.forEach((fk) => {
-        if (fk.reference) {
-          const item = fk.reference(fk);
-          foreignKeys.push(item);
-        }
-      });
-    }
-  }
-  if (extraSymbol) {
-    const extraConfigBuilder = table[extraSymbol];
-    if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
-      const configBuilderData = extraConfigBuilder(table);
-      if (configBuilderData) {
-        const configBuilders = Array.isArray(configBuilderData) ? configBuilderData : Object.values(configBuilderData).map(
-          (item) => item.value ?? item
-        );
-        configBuilders.forEach((builder) => {
-          if (!builder?.constructor) return;
-          const builderName = builder.constructor.name.toLowerCase();
-          if (builderName.includes("foreignkeybuilder")) {
-            foreignKeys.push(builder);
-          }
-        });
-      }
-    }
-  }
-  return foreignKeys;
-}
-function getTableMetadata(table) {
-  const symbols = Object.getOwnPropertySymbols(table);
-  const nameSymbol = symbols.find((s) => s.toString().includes("Name"));
-  const columnsSymbol = symbols.find((s) => s.toString().includes("Columns"));
-  const foreignKeysSymbol = symbols.find((s) => s.toString().includes("ForeignKeys)"));
-  const extraSymbol = symbols.find((s) => s.toString().includes("ExtraConfigBuilder"));
-  const builders = {
-    indexes: [],
-    checks: [],
-    foreignKeys: [],
-    primaryKeys: [],
-    uniqueConstraints: [],
-    extras: []
-  };
-  builders.foreignKeys = processForeignKeys(table, foreignKeysSymbol, extraSymbol);
-  if (extraSymbol) {
-    const extraConfigBuilder = table[extraSymbol];
-    if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
-      const configBuilderData = extraConfigBuilder(table);
-      if (configBuilderData) {
-        const configBuilders = Array.isArray(configBuilderData) ? configBuilderData : Object.values(configBuilderData).map(
-          (item) => item.value ?? item
-        );
-        configBuilders.forEach((builder) => {
-          if (!builder?.constructor) return;
-          const builderName = builder.constructor.name.toLowerCase();
-          const builderMap = {
-            indexbuilder: builders.indexes,
-            checkbuilder: builders.checks,
-            primarykeybuilder: builders.primaryKeys,
-            uniqueconstraintbuilder: builders.uniqueConstraints
-          };
-          for (const [type, array] of Object.entries(builderMap)) {
-            if (builderName.includes(type)) {
-              array.push(builder);
-              break;
-            }
-          }
-          builders.extras.push(builder);
-        });
-      }
-    }
-  }
-  return {
-    tableName: nameSymbol ? table[nameSymbol] : "",
-    columns: columnsSymbol ? table[columnsSymbol] : {},
-    ...builders
-  };
-}
-function generateDropTableStatements(tables, options) {
-  const dropStatements = [];
-  const validOptions = options ?? { sequence: true, table: true };
-  if (!validOptions.sequence && !validOptions.table) {
-    console.warn('No drop operations requested: both "table" and "sequence" options are false');
-    return [];
-  }
-  tables.forEach((tableName) => {
-    if (validOptions.table) {
-      dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);
-    }
-    if (validOptions.sequence) {
-      dropStatements.push(`DROP SEQUENCE IF EXISTS \`${tableName}\`;`);
-    }
-  });
-  return dropStatements;
-}
-function mapSelectTableToAlias(table, uniqPrefix, aliasMap) {
-  const { columns, tableName } = getTableMetadata(table);
-  const selectionsTableFields = {};
-  Object.keys(columns).forEach((name) => {
-    const column = columns[name];
-    const uniqName = `a_${uniqPrefix}_${tableName}_${column.name}`.toLowerCase();
-    const fieldAlias = sql$1.raw(uniqName);
-    selectionsTableFields[name] = sql$1`${column} as \`${fieldAlias}\``;
-    aliasMap[uniqName] = column;
-  });
-  return selectionsTableFields;
-}
-function isDrizzleColumn(column) {
-  return column && typeof column === "object" && "table" in column;
-}
-function mapSelectAllFieldsToAlias(selections, name, uniqName, fields, aliasMap) {
-  if (isTable(fields)) {
-    selections[name] = mapSelectTableToAlias(fields, uniqName, aliasMap);
-  } else if (isDrizzleColumn(fields)) {
-    const column = fields;
-    const uniqAliasName = `a_${uniqName}_${column.name}`.toLowerCase();
-    let aliasName = sql$1.raw(uniqAliasName);
-    selections[name] = sql$1`${column} as \`${aliasName}\``;
-    aliasMap[uniqAliasName] = column;
-  } else if (isSQLWrapper(fields)) {
-    selections[name] = fields;
-  } else {
-    const innerSelections = {};
-    Object.entries(fields).forEach(([iname, ifields]) => {
-      mapSelectAllFieldsToAlias(innerSelections, iname, `${uniqName}_${iname}`, ifields, aliasMap);
-    });
-    selections[name] = innerSelections;
-  }
-  return selections;
-}
-function mapSelectFieldsWithAlias(fields) {
-  if (!fields) {
-    throw new Error("fields is empty");
-  }
-  const aliasMap = {};
-  const selections = {};
-  Object.entries(fields).forEach(([name, fields2]) => {
-    mapSelectAllFieldsToAlias(selections, name, name, fields2, aliasMap);
-  });
-  return { selections, aliasMap };
-}
-function getAliasFromDrizzleAlias(value) {
-  const isSQL = value !== null && typeof value === "object" && isSQLWrapper(value) && "queryChunks" in value;
-  if (isSQL) {
-    const sql2 = value;
-    const queryChunks = sql2.queryChunks;
-    if (queryChunks.length > 3) {
-      const aliasNameChunk = queryChunks[queryChunks.length - 2];
-      if (isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {
-        const aliasNameChunkSql = aliasNameChunk;
-        if (aliasNameChunkSql.queryChunks?.length === 1 && aliasNameChunkSql.queryChunks[0]) {
-          const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];
-          if ("value" in queryChunksStringChunc) {
-            const values = queryChunksStringChunc.value;
-            if (values && values.length === 1) {
-              return values[0];
-            }
-          }
-        }
-      }
-    }
-  }
-  return void 0;
-}
-function transformValue(value, alias, aliasMap) {
-  const column = aliasMap[alias];
-  if (!column) return value;
-  let customColumn = column;
-  const fromDriver = customColumn?.mapFrom;
-  if (fromDriver && value !== null && value !== void 0) {
-    return fromDriver(value);
-  }
-  return value;
-}
-function transformObject(obj, selections, aliasMap) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const selection = selections[key];
-    const alias = getAliasFromDrizzleAlias(selection);
-    if (alias && aliasMap[alias]) {
-      result[key] = transformValue(value, alias, aliasMap);
-    } else if (selection && typeof selection === "object" && !isSQLWrapper(selection)) {
-      result[key] = transformObject(
-        value,
-        selection,
-        aliasMap
-      );
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function applyFromDriverTransform(rows, selections, aliasMap) {
-  return rows.map((row) => {
-    const transformed = transformObject(
-      row,
-      selections,
-      aliasMap
-    );
-    return processNullBranches(transformed);
-  });
-}
-function processNullBranches(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (obj.constructor && obj.constructor.name !== "Object") {
-    return obj;
-  }
-  const result = {};
-  let allNull = true;
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === null || value === void 0) {
-      result[key] = null;
-      continue;
-    }
-    if (typeof value === "object") {
-      const processed = processNullBranches(value);
-      result[key] = processed;
-      if (processed !== null) {
-        allNull = false;
-      }
-    } else {
-      result[key] = value;
-      allNull = false;
-    }
-  }
-  return allNull ? null : result;
-}
-function formatLimitOffset(limitOrOffset) {
-  if (typeof limitOrOffset !== "number" || isNaN(limitOrOffset)) {
-    throw new Error("limitOrOffset must be a valid number");
-  }
-  return sql$1.raw(`${limitOrOffset}`);
-}
-function nextVal(sequenceName) {
-  return sql$1.raw(`NEXTVAL(${sequenceName})`);
-}
-async function printQueriesWithPlan(forgeSQLORM, timeDiffMs, timeout) {
-  try {
-    const statementsTable = clusterStatementsSummary;
-    const timeoutMs2 = timeout ?? 3e3;
-    const results = await withTimeout(
-      forgeSQLORM.getDrizzleQueryBuilder().select({
-        digestText: withTidbHint(statementsTable.digestText),
-        avgLatency: statementsTable.avgLatency,
-        avgMem: statementsTable.avgMem,
-        execCount: statementsTable.execCount,
-        plan: statementsTable.plan,
-        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"
-          ]),
-          gte(
-            statementsTable.lastSeen,
-            sql$1`DATE_SUB
-                            (NOW(), INTERVAL
-                            ${timeDiffMs * 1e3}
-                            MICROSECOND
-                            )`
-          )
-        )
-      ),
-      `Timeout ${timeoutMs2}ms in printQueriesWithPlan - transient timeouts are usually fine; repeated timeouts mean this diagnostic query is consistently slow and should be investigated`,
-      timeoutMs2 + 200
-    );
-    results.forEach((result) => {
-      const avgTimeMs = Number(result.avgLatency) / 1e6;
-      const avgMemMB = Number(result.avgMem) / 1e6;
-      console.warn(
-        `SQL: ${result.digestText} | Memory: ${avgMemMB.toFixed(2)} MB | Time: ${avgTimeMs.toFixed(2)} ms | stmtType: ${result.stmtType} | Executions: ${result.execCount}
- Plan:${result.plan}`
-      );
-    });
-  } catch (error) {
-    console.debug(
-      `Error occurred while retrieving query execution plan: ${error instanceof Error ? error.message : "Unknown error"}. Try again after some time`,
-      error
-    );
-  }
-}
-const SESSION_ALIAS_NAME_ORM = "orm";
-async function slowQueryPerHours(forgeSQLORM, hours, timeout) {
-  try {
-    const timeoutMs2 = 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$1`DATE_SUB
-                            (NOW(), INTERVAL
-                            ${hours}
-                            HOUR
-                            )`
-          )
-        )
-      ),
-      `Timeout ${timeoutMs2}ms in slowQueryPerHours - transient timeouts are usually fine; repeated timeouts mean this diagnostic query is consistently slow and should be investigated`,
-      timeoutMs2
-    );
-    const response = [];
-    results.forEach((result) => {
-      const memMaxMB = result.memMax ? Number(result.memMax) / 1e6 : 0;
-      const message = `Found SlowQuery SQL: ${result.query} | Memory: ${memMaxMB.toFixed(2)} MB | Time: ${result.queryTime} ms
- Plan:${result.plan}`;
-      response.push(message);
-      console.warn(message);
-    });
-    return response;
-  } catch (error) {
-    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"}`
-    ];
-  }
-}
-async function withTimeout(promise, message, timeoutMs2) {
-  let timeoutId;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(new Error(message));
-    }, timeoutMs2);
-  });
-  try {
-    return await Promise.race([promise, timeoutPromise]);
-  } finally {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-  }
-}
-function withTidbHint(column) {
-  return sql$1`/*+ SET_VAR(tidb_session_alias=${sql$1.raw(`${SESSION_ALIAS_NAME_ORM}`)}) */ ${column}`;
-}
-const CACHE_CONSTANTS = {
-  BATCH_SIZE: 25,
-  MAX_RETRY_ATTEMPTS: 3,
-  INITIAL_RETRY_DELAY: 1e3,
-  RETRY_DELAY_MULTIPLIER: 2,
-  DEFAULT_ENTITY_QUERY_NAME: "sql",
-  DEFAULT_EXPIRATION_NAME: "expiration",
-  DEFAULT_DATA_NAME: "data",
-  HASH_LENGTH: 32
-};
-function getCurrentTime() {
-  const dt = DateTime.now();
-  return Math.floor(dt.toSeconds());
-}
-function nowPlusSeconds(secondsToAdd) {
-  const dt = DateTime.now().plus({ seconds: secondsToAdd });
-  return Math.floor(dt.toSeconds());
-}
-function extractBacktickedValues(sql2) {
-  const regex = /`([^`]+)`/g;
-  const matches = /* @__PURE__ */ new Set();
-  let match;
-  while ((match = regex.exec(sql2.toLowerCase())) !== null) {
-    if (!match[1].startsWith("a_")) {
-      matches.add(`\`${match[1]}\``);
-    }
-  }
-  return Array.from(matches).sort().join(",");
-}
-function hashKey(query) {
-  const h = crypto.createHash("sha256");
-  h.update(query.sql.toLowerCase());
-  h.update(JSON.stringify(query.params));
-  return "CachedQuery_" + h.digest("hex").slice(0, CACHE_CONSTANTS.HASH_LENGTH);
-}
-async function deleteCacheEntriesInBatches(results, cacheEntityName) {
-  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) => {
-      transactionBuilder = transactionBuilder.delete(result.key, { entityName: cacheEntityName });
-    });
-    await transactionBuilder.execute();
-  }
-}
-async function clearCursorCache(tables, cursor, options) {
-  const cacheEntityName = options.cacheEntityName;
-  if (!cacheEntityName) {
-    throw new Error("cacheEntityName is not configured");
-  }
-  const entityQueryName = options.cacheEntityQueryName ?? CACHE_CONSTANTS.DEFAULT_ENTITY_QUERY_NAME;
-  let filters = new Filter();
-  for (const table of tables) {
-    const wrapIfNeeded = options.cacheWrapTable ? `\`${table}\`` : table;
-    filters.or(entityQueryName, FilterConditions.contains(wrapIfNeeded?.toLowerCase()));
-  }
-  let entityQueryBuilder = kvs.entity(cacheEntityName).query().index(entityQueryName).filters(filters);
-  if (cursor) {
-    entityQueryBuilder = entityQueryBuilder.cursor(cursor);
-  }
-  const listResult = await entityQueryBuilder.limit(100).getMany();
-  if (options.logCache) {
-    console.warn(`clear cache Records: ${JSON.stringify(listResult.results.map((r) => r.key))}`);
-  }
-  await deleteCacheEntriesInBatches(listResult.results, cacheEntityName);
-  if (listResult.nextCursor) {
-    return listResult.results.length + await clearCursorCache(tables, listResult.nextCursor, options);
-  } else {
-    return listResult.results.length;
-  }
-}
-async function clearExpirationCursorCache(cursor, options) {
-  const cacheEntityName = options.cacheEntityName;
-  if (!cacheEntityName) {
-    throw new Error("cacheEntityName is not configured");
-  }
-  const entityExpirationName = options.cacheEntityExpirationName ?? CACHE_CONSTANTS.DEFAULT_EXPIRATION_NAME;
-  let entityQueryBuilder = kvs.entity(cacheEntityName).query().index(entityExpirationName).where(WhereConditions.lessThan(Math.floor(DateTime.now().toSeconds())));
-  if (cursor) {
-    entityQueryBuilder = entityQueryBuilder.cursor(cursor);
-  }
-  const listResult = await entityQueryBuilder.limit(100).getMany();
-  if (options.logCache) {
-    console.warn(`clear expired Records: ${JSON.stringify(listResult.results.map((r) => r.key))}`);
-  }
-  await deleteCacheEntriesInBatches(listResult.results, cacheEntityName);
-  if (listResult.nextCursor) {
-    return listResult.results.length + await clearExpirationCursorCache(listResult.nextCursor, options);
-  } else {
-    return listResult.results.length;
-  }
-}
-async function executeWithRetry(operation, operationName) {
-  let attempt = 0;
-  let delay = CACHE_CONSTANTS.INITIAL_RETRY_DELAY;
-  while (attempt < CACHE_CONSTANTS.MAX_RETRY_ATTEMPTS) {
-    try {
-      return await operation();
-    } catch (err) {
-      console.warn(`Error during ${operationName}: ${err.message}, retry ${attempt}`, err);
-      attempt++;
-      if (attempt >= CACHE_CONSTANTS.MAX_RETRY_ATTEMPTS) {
-        console.error(`Error during ${operationName}: ${err.message}`, err);
-        throw err;
-      }
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      delay *= CACHE_CONSTANTS.RETRY_DELAY_MULTIPLIER;
-    }
-  }
-  throw new Error(`Maximum retry attempts exceeded for ${operationName}`);
-}
-async function clearCache(schema, options) {
-  const tableName = getTableName(schema);
-  if (cacheApplicationContext.getStore()) {
-    cacheApplicationContext.getStore()?.tables.add(tableName);
-  } else {
-    await clearTablesCache([tableName], options);
-  }
-}
-async function clearTablesCache(tables, options) {
-  if (!options.cacheEntityName) {
-    throw new Error("cacheEntityName is not configured");
-  }
-  const startTime = DateTime.now();
-  let totalRecords = 0;
-  try {
-    totalRecords = await executeWithRetry(
-      () => clearCursorCache(tables, "", options),
-      "clearing cache"
-    );
-  } finally {
-    if (options.logCache) {
-      const duration = DateTime.now().toSeconds() - startTime.toSeconds();
-      console.info(`Cleared ${totalRecords} cache records in ${duration} seconds`);
-    }
-  }
-}
-async function clearExpiredCache(options) {
-  if (!options.cacheEntityName) {
-    throw new Error("cacheEntityName is not configured");
-  }
-  const startTime = DateTime.now();
-  let totalRecords = 0;
-  try {
-    totalRecords = await executeWithRetry(
-      () => clearExpirationCursorCache("", options),
-      "clearing expired cache"
-    );
-  } finally {
-    const duration = DateTime.now().toSeconds() - startTime.toSeconds();
-    if (options?.logCache) {
-      console.debug(`Cleared ${totalRecords} expired cache records in ${duration} seconds`);
-    }
-  }
-}
-async function getFromCache(query, options) {
-  if (!options.cacheEntityName) {
-    throw new Error("cacheEntityName is not configured");
-  }
-  const entityQueryName = options.cacheEntityQueryName ?? CACHE_CONSTANTS.DEFAULT_ENTITY_QUERY_NAME;
-  const expirationName = options.cacheEntityExpirationName ?? CACHE_CONSTANTS.DEFAULT_EXPIRATION_NAME;
-  const dataName = options.cacheEntityDataName ?? CACHE_CONSTANTS.DEFAULT_DATA_NAME;
-  const sqlQuery = query.toSQL();
-  const key = hashKey(sqlQuery);
-  if (await isTableContainsTableInCacheContext(sqlQuery.sql, options)) {
-    if (options.logCache) {
-      console.warn(`Context contains value to clear. Skip getting from cache`);
-    }
-    return void 0;
-  }
-  try {
-    const cacheResult = await kvs.entity(options.cacheEntityName).get(key);
-    if (cacheResult && cacheResult[expirationName] >= getCurrentTime() && extractBacktickedValues(sqlQuery.sql) === cacheResult[entityQueryName]) {
-      if (options.logCache) {
-        console.warn(`Get value from cache, cacheKey: ${key}`);
-      }
-      const results = cacheResult[dataName];
-      return JSON.parse(results);
-    }
-  } catch (error) {
-    console.error(`Error getting from cache: ${error.message}`, error);
-  }
-  return void 0;
-}
-async function setCacheResult(query, options, results, cacheTtl) {
-  if (!options.cacheEntityName) {
-    throw new Error("cacheEntityName is not configured");
-  }
-  try {
-    const entityQueryName = options.cacheEntityQueryName ?? CACHE_CONSTANTS.DEFAULT_ENTITY_QUERY_NAME;
-    const expirationName = options.cacheEntityExpirationName ?? CACHE_CONSTANTS.DEFAULT_EXPIRATION_NAME;
-    const dataName = options.cacheEntityDataName ?? CACHE_CONSTANTS.DEFAULT_DATA_NAME;
-    const sqlQuery = query.toSQL();
-    if (await isTableContainsTableInCacheContext(sqlQuery.sql, options)) {
-      if (options.logCache) {
-        console.warn(`Context contains value to clear. Skip setting from cache`);
-      }
-      return;
-    }
-    const key = hashKey(sqlQuery);
-    await kvs.transact().set(
-      key,
-      {
-        [entityQueryName]: extractBacktickedValues(sqlQuery.sql),
-        [expirationName]: nowPlusSeconds(cacheTtl),
-        [dataName]: JSON.stringify(results)
-      },
-      { entityName: options.cacheEntityName }
-    ).execute();
-    if (options.logCache) {
-      console.warn(`Store value to cache, cacheKey: ${key}`);
-    }
-  } catch (error) {
-    console.error(`Error setting cache: ${error.message}`, error);
-  }
-}
-function isQuery(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.sql === "string" && Array.isArray(obj.params);
-}
-const cacheApplicationContext = new AsyncLocalStorage();
-const localCacheApplicationContext = new AsyncLocalStorage();
-async function saveTableIfInsideCacheContext(table) {
-  const context = cacheApplicationContext.getStore();
-  if (context) {
-    const tableName = getTableName(table).toLowerCase();
-    context.tables.add(tableName);
-  }
-}
-async function saveQueryLocalCacheQuery(query, rows, options) {
-  const context = localCacheApplicationContext.getStore();
-  if (context) {
-    if (!context.cache) {
-      context.cache = {};
-    }
-    let sql2;
-    if (isQuery(query)) {
-      sql2 = { toSQL: () => query };
-    } else {
-      sql2 = query;
-    }
-    const key = hashKey(sql2.toSQL());
-    context.cache[key] = {
-      sql: sql2.toSQL().sql.toLowerCase(),
-      data: rows
-    };
-    if (options.logCache) {
-      const q = sql2.toSQL();
-      console.debug(
-        `[forge-sql-orm][local-cache][SAVE] Stored result in cache. sql="${q.sql}", params=${JSON.stringify(q.params)}`
-      );
-    }
-  }
-}
-async function getQueryLocalCacheQuery(query, options) {
-  const context = localCacheApplicationContext.getStore();
-  if (context) {
-    if (!context.cache) {
-      context.cache = {};
-    }
-    let sql2;
-    if (isQuery(query)) {
-      sql2 = { toSQL: () => query };
-    } else {
-      sql2 = query;
-    }
-    const key = hashKey(sql2.toSQL());
-    if (context.cache[key] && context.cache[key].sql === sql2.toSQL().sql.toLowerCase()) {
-      if (options.logCache) {
-        const q = sql2.toSQL();
-        console.debug(
-          `[forge-sql-orm][local-cache][HIT] Returned cached result. sql="${q.sql}", params=${JSON.stringify(q.params)}`
-        );
-      }
-      return context.cache[key].data;
-    }
-  }
-  return void 0;
-}
-async function evictLocalCacheQuery(table, options) {
-  const context = localCacheApplicationContext.getStore();
-  if (context) {
-    if (!context.cache) {
-      context.cache = {};
-    }
-    const tableName = getTableName(table);
-    const searchString = options.cacheWrapTable ? `\`${tableName}\`` : tableName;
-    const keyToEvicts = [];
-    Object.keys(context.cache).forEach((key) => {
-      if (context.cache[key].sql.includes(searchString)) {
-        keyToEvicts.push(key);
-      }
-    });
-    keyToEvicts.forEach((key) => delete context.cache[key]);
-  }
-}
-async function isTableContainsTableInCacheContext(sql2, options) {
-  const context = cacheApplicationContext.getStore();
-  if (!context) {
-    return false;
-  }
-  const tables = Array.from(context.tables);
-  const lowerSql = sql2.toLowerCase();
-  return tables.some((table) => {
-    const tablePattern = options.cacheWrapTable ? `\`${table}\`` : table;
-    return lowerSql.includes(tablePattern);
-  });
-}
-class ForgeSQLCrudOperations {
-  forgeOperations;
-  options;
-  /**
-   * Creates a new instance of ForgeSQLCrudOperations.
-   * @param forgeSqlOperations - The ForgeSQL operations instance
-   * @param options - Configuration options for the ORM
-   */
-  constructor(forgeSqlOperations, options) {
-    this.forgeOperations = forgeSqlOperations;
-    this.options = options;
-  }
-  /**
-   * Inserts records into the database with optional versioning support.
-   * If a version field exists in the schema, versioning is applied.
-   *
-   * This method automatically handles:
-   * - Version field initialization for optimistic locking
-   * - Batch insertion for multiple records
-   * - Duplicate key handling with optional updates
-   *
-   * @template T - The type of the table schema
-   * @param schema - The entity schema
-   * @param models - Array of entities to insert
-   * @param updateIfExists - Whether to update existing records (default: false)
-   * @returns Promise that resolves to the number of inserted rows
-   * @throws Error if the insert operation fails
-   */
-  async insert(schema, models, updateIfExists = false) {
-    if (!models?.length) return 0;
-    const { tableName, columns } = getTableMetadata(schema);
-    const versionMetadata = this.validateVersionField(tableName, columns);
-    const preparedModels = models.map(
-      (model) => this.prepareModelWithVersion(model, versionMetadata, columns)
-    );
-    const queryBuilder = this.forgeOperations.insert(schema).values(preparedModels);
-    const finalQuery = updateIfExists ? queryBuilder.onDuplicateKeyUpdate({
-      set: Object.fromEntries(
-        Object.keys(preparedModels[0]).map((key) => [key, schema[key]])
-      )
-    }) : queryBuilder;
-    const result = await finalQuery;
-    await saveTableIfInsideCacheContext(schema);
-    return result[0].insertId;
-  }
-  /**
-   * Deletes a record by its primary key with optional version check.
-   * If versioning is enabled, ensures the record hasn't been modified since last read.
-   *
-   * This method automatically handles:
-   * - Single primary key validation
-   * - Optimistic locking checks if versioning is enabled
-   * - Version field validation before deletion
-   *
-   * @template T - The type of the table schema
-   * @param id - The ID of the record to delete
-   * @param schema - The entity schema
-   * @returns Promise that resolves to the number of affected rows
-   * @throws Error if the delete operation fails
-   * @throws Error if multiple primary keys are found
-   * @throws Error if optimistic locking check fails
-   */
-  async deleteById(id, schema) {
-    const { tableName, columns } = getTableMetadata(schema);
-    const primaryKeys = this.getPrimaryKeys(schema);
-    if (primaryKeys.length !== 1) {
-      throw new Error("Only single primary key is supported");
-    }
-    const [primaryKeyName, primaryKeyColumn] = primaryKeys[0];
-    const versionMetadata = this.validateVersionField(tableName, columns);
-    const conditions = [eq(primaryKeyColumn, id)];
-    if (versionMetadata && columns) {
-      const versionField = columns[versionMetadata.fieldName];
-      if (versionField) {
-        const oldModel = await this.getOldModel({ [primaryKeyName]: id }, schema, [
-          versionMetadata.fieldName,
-          versionField
-        ]);
-        conditions.push(eq(versionField, oldModel[versionMetadata.fieldName]));
-      }
-    }
-    const queryBuilder = this.forgeOperations.delete(schema).where(and(...conditions));
-    const result = await queryBuilder;
-    if (versionMetadata && result[0].affectedRows === 0) {
-      throw new Error(`Optimistic locking failed: record with primary key ${id} has been modified`);
-    }
-    await saveTableIfInsideCacheContext(schema);
-    return result[0].affectedRows;
-  }
-  /**
-   * Updates a record by its primary key with optimistic locking support.
-   * If versioning is enabled:
-   * - Retrieves the current version
-   * - Checks for concurrent modifications
-   * - Increments the version on successful update
-   *
-   * This method automatically handles:
-   * - Primary key validation
-   * - Version field retrieval and validation
-   * - Optimistic locking conflict detection
-   * - Version field incrementation
-   *
-   * @template T - The type of the table schema
-   * @param entity - The entity with updated values (must include primary key)
-   * @param schema - The entity schema
-   * @returns Promise that resolves to the number of affected rows
-   * @throws Error if the primary key is not provided
-   * @throws Error if optimistic locking check fails
-   * @throws Error if multiple primary keys are found
-   */
-  async updateById(entity, schema) {
-    const { tableName, columns } = getTableMetadata(schema);
-    const primaryKeys = this.getPrimaryKeys(schema);
-    if (primaryKeys.length !== 1) {
-      throw new Error("Only single primary key is supported");
-    }
-    const [primaryKeyName, primaryKeyColumn] = primaryKeys[0];
-    const versionMetadata = this.validateVersionField(tableName, columns);
-    if (!(primaryKeyName in entity)) {
-      throw new Error(`Primary key ${primaryKeyName} must be provided in the entity`);
-    }
-    const currentVersion = await this.getCurrentVersion(
-      entity,
-      primaryKeyName,
-      versionMetadata,
-      columns,
-      schema
-    );
-    const updateData = this.prepareUpdateData(entity, versionMetadata, columns, currentVersion);
-    const conditions = [
-      eq(primaryKeyColumn, entity[primaryKeyName])
-    ];
-    if (versionMetadata && columns) {
-      const versionField = columns[versionMetadata.fieldName];
-      if (versionField) {
-        conditions.push(eq(versionField, currentVersion));
-      }
-    }
-    const queryBuilder = this.forgeOperations.update(schema).set(updateData).where(and(...conditions));
-    const result = await queryBuilder;
-    if (versionMetadata && result[0].affectedRows === 0) {
-      throw new Error(
-        `Optimistic locking failed: record with primary key ${entity[primaryKeyName]} has been modified`
-      );
-    }
-    await saveTableIfInsideCacheContext(schema);
-    return result[0].affectedRows;
-  }
-  /**
-   * Updates specified fields of records based on provided conditions.
-   * This method does not support versioning and should be used with caution.
-   *
-   * @template T - The type of the table schema
-   * @param {Partial<InferInsertModel<T>>} updateData - The data to update
-   * @param {T} schema - The entity schema
-   * @param {SQL<unknown>} where - The WHERE conditions
-   * @returns {Promise<number>} Number of affected rows
-   * @throws {Error} If WHERE conditions are not provided
-   * @throws {Error} If the update operation fails
-   */
-  async updateFields(updateData, schema, where) {
-    if (!where) {
-      throw new Error("WHERE conditions must be provided");
-    }
-    const queryBuilder = this.forgeOperations.update(schema).set(updateData).where(where);
-    const result = await queryBuilder;
-    await saveTableIfInsideCacheContext(schema);
-    return result[0].affectedRows;
-  }
-  // Helper methods
-  /**
-   * Gets primary keys from the schema.
-   * @template T - The type of the table schema
-   * @param {T} schema - The table schema
-   * @returns {[string, AnyColumn][]} Array of primary key name and column pairs
-   * @throws {Error} If no primary keys are found
-   */
-  getPrimaryKeys(schema) {
-    const primaryKeys = getPrimaryKeys(schema);
-    if (!primaryKeys) {
-      throw new Error(`No primary keys found for schema: ${schema}`);
-    }
-    return primaryKeys;
-  }
-  /**
-   * Validates and retrieves version field metadata.
-   * @param {string} tableName - The name of the table
-   * @param {Record<string, AnyColumn>} columns - The table columns
-   * @returns {Object | undefined} Version field metadata if valid, undefined otherwise
-   */
-  validateVersionField(tableName, columns) {
-    if (this.options.disableOptimisticLocking) {
-      return void 0;
-    }
-    const versionMetadata = this.options.additionalMetadata?.[tableName]?.versionField;
-    if (!versionMetadata) return void 0;
-    let fieldName = versionMetadata.fieldName;
-    let versionField = columns[versionMetadata.fieldName];
-    if (!versionField) {
-      const find = Object.entries(columns).find(([, c]) => c.name === versionMetadata.fieldName);
-      if (find) {
-        fieldName = find[0];
-        versionField = find[1];
-      }
-    }
-    if (!versionField) {
-      console.warn(
-        `Version field "${versionMetadata.fieldName}" not found in table ${tableName}. Versioning will be skipped.`
-      );
-      return void 0;
-    }
-    if (!versionField.notNull) {
-      console.warn(
-        `Version field "${versionMetadata.fieldName}" in table ${tableName} is nullable. Versioning may not work correctly.`
-      );
-      return void 0;
-    }
-    const fieldType = versionField.getSQLType();
-    const isSupportedType = fieldType === "datetime" || fieldType === "timestamp" || fieldType === "int" || fieldType === "number" || fieldType === "decimal";
-    if (!isSupportedType) {
-      console.warn(
-        `Version field "${versionMetadata.fieldName}" in table ${tableName} has unsupported type "${fieldType}". Only datetime, timestamp, int, and decimal types are supported for versioning. Versioning will be skipped.`
-      );
-      return void 0;
-    }
-    return { fieldName, type: fieldType };
-  }
-  /**
-   * Gets the current version of an entity.
-   * @template T - The type of the table schema
-   * @param {Partial<InferInsertModel<T>>} entity - The entity
-   * @param {string} primaryKeyName - The name of the primary key
-   * @param {Object | undefined} versionMetadata - Version field metadata
-   * @param {Record<string, AnyColumn>} columns - The table columns
-   * @param {T} schema - The table schema
-   * @returns {Promise<unknown>} The current version value
-   */
-  async getCurrentVersion(entity, primaryKeyName, versionMetadata, columns, schema) {
-    if (!versionMetadata || !columns) return void 0;
-    const versionField = columns[versionMetadata.fieldName];
-    if (!versionField) return void 0;
-    if (versionMetadata.fieldName in entity) {
-      return entity[versionMetadata.fieldName];
-    }
-    const oldModel = await this.getOldModel(
-      { [primaryKeyName]: entity[primaryKeyName] },
-      schema,
-      [versionMetadata.fieldName, versionField]
-    );
-    return oldModel[versionMetadata.fieldName];
-  }
-  /**
-   * Prepares a model for insertion with version field.
-   * @template T - The type of the table schema
-   * @param {Partial<InferInsertModel<T>>} model - The model to prepare
-   * @param {Object | undefined} versionMetadata - Version field metadata
-   * @param {Record<string, AnyColumn>} columns - The table columns
-   * @returns {InferInsertModel<T>} The prepared model
-   */
-  prepareModelWithVersion(model, versionMetadata, columns) {
-    if (!versionMetadata || !columns) return model;
-    let fieldName = versionMetadata.fieldName;
-    let versionField = columns[versionMetadata.fieldName];
-    if (!versionField) {
-      const find = Object.entries(columns).find(([, c]) => c.name === versionMetadata.fieldName);
-      if (find) {
-        fieldName = find[0];
-        versionField = find[1];
-      }
-    }
-    if (!versionField) return model;
-    const modelWithVersion = { ...model };
-    const fieldType = versionField.getSQLType();
-    const versionValue = fieldType === "datetime" || fieldType === "timestamp" ? /* @__PURE__ */ new Date() : 1;
-    modelWithVersion[fieldName] = versionValue;
-    return modelWithVersion;
-  }
-  /**
-   * Prepares update data with version field.
-   * @template T - The type of the table schema
-   * @param {Partial<InferInsertModel<T>>} entity - The entity to update
-   * @param {Object | undefined} versionMetadata - Version field metadata
-   * @param {Record<string, AnyColumn>} columns - The table columns
-   * @param {unknown} currentVersion - The current version value
-   * @returns {Partial<InferInsertModel<T>>} The prepared update data
-   */
-  prepareUpdateData(entity, versionMetadata, columns, currentVersion) {
-    const updateData = { ...entity };
-    if (versionMetadata && columns) {
-      const versionField = columns[versionMetadata.fieldName];
-      if (versionField) {
-        const fieldType = versionField.getSQLType();
-        updateData[versionMetadata.fieldName] = fieldType === "datetime" || fieldType === "timestamp" ? /* @__PURE__ */ new Date() : currentVersion + 1;
-      }
-    }
-    return updateData;
-  }
-  /**
-   * Retrieves an existing model by primary key.
-   * @template T - The type of the table schema
-   * @param {Record<string, unknown>} primaryKeyValues - The primary key values
-   * @param {T} schema - The table schema
-   * @param {[string, AnyColumn]} versionField - The version field name and column
-   * @returns {Promise<Awaited<T> extends Array<any> ? Awaited<T>[number] | undefined : Awaited<T> | undefined>} The existing model
-   * @throws {Error} If the record is not found
-   */
-  async getOldModel(primaryKeyValues, schema, versionField) {
-    const [versionFieldName, versionFieldColumn] = versionField;
-    const primaryKeys = this.getPrimaryKeys(schema);
-    const [primaryKeyName, primaryKeyColumn] = primaryKeys[0];
-    const resultQuery = this.forgeOperations.select({
-      [primaryKeyName]: primaryKeyColumn,
-      [versionFieldName]: versionFieldColumn
-    }).from(schema).where(eq(primaryKeyColumn, primaryKeyValues[primaryKeyName]));
-    const model = await this.forgeOperations.fetch().executeQueryOnlyOne(resultQuery);
-    if (!model) {
-      throw new Error(`Record not found in table ${schema}`);
-    }
-    return model;
-  }
-}
-class ForgeSQLSelectOperations {
-  options;
-  /**
-   * Creates a new instance of ForgeSQLSelectOperations.
-   * @param {ForgeSqlOrmOptions} options - Configuration options for the ORM
-   */
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * Executes a Drizzle query and returns a single result.
-   * Throws an error if more than one record is returned.
-   *
-   * @template T - The type of the query builder
-   * @param {T} query - The Drizzle query to execute
-   * @returns {Promise<Awaited<T> extends Array<any> ? Awaited<T>[number] | undefined : Awaited<T> | undefined>} A single result object or undefined
-   * @throws {Error} If more than one record is returned
-   */
-  async executeQueryOnlyOne(query) {
-    const results = await query;
-    const datas = results;
-    if (!datas.length) {
-      return void 0;
-    }
-    if (datas.length > 1) {
-      throw new Error(`Expected 1 record but returned ${datas.length}`);
-    }
-    return datas[0];
-  }
-  /**
-   * Executes a raw SQL query and returns the results.
-   * Logs the query if logging is enabled.
-   *
-   * @template T - The type of the result objects
-   * @param {string} query - The raw SQL query to execute
-   * @param {SqlParameters[]} [params] - Optional SQL parameters
-   * @returns {Promise<T[]>} A list of results as objects
-   */
-  async executeRawSQL(query, params) {
-    if (this.options.logRawSqlQuery) {
-      const paramsStr = params ? `, with params: ${JSON.stringify(params)}` : "";
-      console.debug(`Executing with SQL ${query}${paramsStr}`);
-    }
-    const sqlStatement = sql.prepare(query);
-    if (params) {
-      sqlStatement.bindParams(...params);
-    }
-    const result = await sqlStatement.execute();
-    return result.rows;
-  }
-  /**
-   * Executes a raw SQL update query.
-   * @param {string} query - The raw SQL update query
-   * @param {SqlParameters[]} [params] - Optional SQL parameters
-   * @returns {Promise<UpdateQueryResponse>} The update response containing affected rows
-   */
-  async executeRawUpdateSQL(query, params) {
-    const sqlStatement = sql.prepare(query);
-    if (params) {
-      sqlStatement.bindParams(...params);
-    }
-    if (this.options.logRawSqlQuery) {
-      console.debug(
-        `Executing Update with SQL ${query}` + (params ? `, with params: ${JSON.stringify(params)}` : "")
-      );
-    }
-    const updateQueryResponseResults = await sqlStatement.execute();
-    return updateQueryResponseResults.rows;
-  }
-}
-const metadataQueryContext = new AsyncLocalStorage();
-async function saveMetaDataToContext(metadata) {
-  const context = metadataQueryContext.getStore();
-  if (context) {
-    context.printQueriesWithPlan = async () => {
-      if (process.env.NODE_ENV !== "test") {
-        await new Promise((r) => setTimeout(r, 200));
-      }
-      await printQueriesWithPlan(context.forgeSQLORM, Date.now() - context.beginTime.getTime());
-    };
-    if (metadata) {
-      context.totalResponseSize += metadata.responseSize;
-      context.totalDbExecutionTime += metadata.dbExecutionTime;
-    }
-  }
-}
-async function getLastestMetadata() {
-  return metadataQueryContext.getStore();
-}
-const operationTypeQueryContext = new AsyncLocalStorage();
-async function getOperationType() {
-  return operationTypeQueryContext.getStore()?.operationType ?? "DML";
-}
-const timeoutMs = 1e4;
-const timeoutMessage = `Atlassian @forge/sql did not return a response within ${timeoutMs}ms (${timeoutMs / 1e3} seconds), so the request is blocked. Possible causes: slow query, network issues, or exceeding Forge SQL limits.`;
-function isUpdateQueryResponse(obj) {
-  return obj !== null && typeof obj === "object" && typeof obj.affectedRows === "number" && typeof obj.insertId === "number";
-}
-function inlineParams(sql2, params) {
-  let i = 0;
-  return sql2.replace(/\?/g, () => {
-    const val = params[i++];
-    if (val === null) return "NULL";
-    if (typeof val === "number") return val.toString();
-    return `'${String(val).replace(/'/g, "''")}'`;
-  });
-}
-async function processDDLResult(method, result) {
-  if (result.metadata) {
-    await saveMetaDataToContext(result.metadata);
-  }
-  if (!result?.rows) {
-    return { rows: [] };
-  }
-  if (isUpdateQueryResponse(result.rows)) {
-    const oneRow = result.rows;
-    return { ...oneRow, rows: [oneRow] };
-  }
-  if (Array.isArray(result.rows)) {
-    if (method === "execute") {
-      return { rows: [result.rows] };
-    } else {
-      const rows = result.rows.map((r) => Object.values(r));
-      return { rows };
-    }
-  }
-  return { rows: [] };
-}
-async function processExecuteMethod(query, params) {
-  const sqlStatement = sql.prepare(query);
-  if (params) {
-    sqlStatement.bindParams(...params);
-  }
-  const result = await withTimeout(sqlStatement.execute(), timeoutMessage, timeoutMs);
-  await saveMetaDataToContext(result.metadata);
-  if (!result.rows) {
-    return { rows: [[]] };
-  }
-  return { rows: [result.rows] };
-}
-async function processAllMethod(query, params) {
-  const sqlStatement = await sql.prepare(query);
-  if (params) {
-    await sqlStatement.bindParams(...params);
-  }
-  const result = await withTimeout(
-    sqlStatement.execute(),
-    timeoutMessage,
-    timeoutMs
-  );
-  await saveMetaDataToContext(result.metadata);
-  if (!result.rows) {
-    return { rows: [] };
-  }
-  const rows = result.rows.map((r) => Object.values(r));
-  return { rows };
-}
-const forgeDriver = async (query, params, method) => {
-  const operationType = await getOperationType();
-  if (operationType === "DDL") {
-    const result = await withTimeout(
-      sql.executeDDL(inlineParams(query, params)),
-      timeoutMessage,
-      timeoutMs
-    );
-    return await processDDLResult(method, result);
-  }
-  if (method === "execute") {
-    return await processExecuteMethod(query, params ?? []);
-  }
-  return await processAllMethod(query, params ?? []);
-};
-function injectSqlHints(query, hints) {
-  if (!hints) {
-    return query;
-  }
-  const normalizedQuery = query.trim().toUpperCase();
-  let queryHints;
-  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;
-  }
-  if (!queryHints || queryHints.length === 0) {
-    return query;
-  }
-  const hintsString = queryHints.join(" ");
-  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)}`;
-  }
-  return query;
-}
-const QUERY_ERROR_CODES = {
-  TIMEOUT: "SQL_QUERY_TIMEOUT",
-  OUT_OF_MEMORY_ERRNO: 8175
-};
-const STATEMENTS_SUMMARY_DELAY_MS = 200;
-function createForgeDriverProxy(forgeSqlOperation, options, logRawSqlQuery) {
-  return async (query, params, method) => {
-    const modifiedQuery = injectSqlHints(query, options);
-    if (options && logRawSqlQuery && modifiedQuery !== query) {
-      console.debug(`SQL Hints injected: ${modifiedQuery}`);
-    }
-    const queryStartTime = Date.now();
-    try {
-      return await forgeDriver(modifiedQuery, params, method);
-    } catch (error) {
-      const isTimeoutError = error.code === QUERY_ERROR_CODES.TIMEOUT;
-      const isOutOfMemoryError = error?.context?.debug?.errno === QUERY_ERROR_CODES.OUT_OF_MEMORY_ERRNO;
-      if (isTimeoutError || isOutOfMemoryError) {
-        if (isTimeoutError) {
-          console.error(` TIMEOUT detected - Query exceeded time limit`);
-        } else {
-          console.error(`OUT OF MEMORY detected - Query exceeded memory limit`);
-        }
-        await new Promise((resolve) => setTimeout(resolve, STATEMENTS_SUMMARY_DELAY_MS));
-        const queryEndTime = Date.now();
-        const queryDuration = queryEndTime - queryStartTime;
-        await printQueriesWithPlan(forgeSqlOperation, queryDuration);
-      }
-      if (logRawSqlQuery) {
-        console.debug(`SQL Error Details:`, JSON.stringify(error, null, 2));
-      }
-      throw error;
-    }
-  };
-}
-const NON_CACHE_CLEARING_ERROR_CODES = ["VALIDATION_ERROR", "CONSTRAINT_ERROR"];
-const CACHE_CLEARING_ERROR_CODES = ["DEADLOCK", "LOCK_WAIT_TIMEOUT", "CONNECTION_ERROR"];
-const NON_CACHE_CLEARING_PATTERNS = [/validation/i, /constraint/i];
-const CACHE_CLEARING_PATTERNS = [/timeout/i, /connection/i];
-function shouldClearCacheOnError(error) {
-  if (error?.code && NON_CACHE_CLEARING_ERROR_CODES.includes(error.code)) {
-    return false;
-  }
-  if (error?.message && NON_CACHE_CLEARING_PATTERNS.some((pattern) => pattern.test(error.message))) {
-    return false;
-  }
-  if (error?.code && CACHE_CLEARING_ERROR_CODES.includes(error.code)) {
-    return true;
-  }
-  if (error?.message && CACHE_CLEARING_PATTERNS.some((pattern) => pattern.test(error.message))) {
-    return true;
-  }
-  return true;
-}
-async function handleSuccessfulExecution(rows, onfulfilled, table, options, isCached) {
-  try {
-    await evictLocalCacheQuery(table, options);
-    await saveTableIfInsideCacheContext(table);
-    if (isCached && !cacheApplicationContext.getStore()) {
-      await clearCache(table, options);
-    }
-    const result = onfulfilled ? onfulfilled(rows) : rows;
-    return result;
-  } catch (error) {
-    if (shouldClearCacheOnError(error)) {
-      await evictLocalCacheQuery(table, options);
-      if (isCached) {
-        await clearCache(table, options).catch((e) => {
-          console.warn("Ignore cache clear errors", e);
-        });
-      } else {
-        await saveTableIfInsideCacheContext(table);
-      }
-    }
-    throw error;
-  }
-}
-function handleFunctionCall(value, target, args, table, options, isCached) {
-  const result = value.apply(target, args);
-  if (typeof result === "object" && result !== null && "execute" in result) {
-    return wrapCacheEvictBuilder(result, table, options, isCached);
-  }
-  return result;
-}
-const wrapCacheEvictBuilder = (rawBuilder, table, options, isCached) => {
-  return new Proxy(rawBuilder, {
-    get(target, prop, receiver) {
-      if (prop === "then") {
-        return (onfulfilled, onrejected) => target.execute().then(
-          (rows) => handleSuccessfulExecution(rows, onfulfilled, table, options, isCached),
-          onrejected
-        );
-      }
-      const value = Reflect.get(target, prop, receiver);
-      if (typeof value === "function") {
-        return (...args) => handleFunctionCall(value, target, args, table, options, isCached);
-      }
-      return value;
-    }
-  });
-};
-function insertAndEvictCacheBuilder(db, table, options, isCached) {
-  const builder = db.insert(table);
-  return wrapCacheEvictBuilder(
-    builder,
-    table,
-    options,
-    isCached
-  );
-}
-function updateAndEvictCacheBuilder(db, table, options, isCached) {
-  const builder = db.update(table);
-  return wrapCacheEvictBuilder(
-    builder,
-    table,
-    options,
-    isCached
-  );
-}
-function deleteAndEvictCacheBuilder(db, table, options, isCached) {
-  const builder = db.delete(table);
-  return wrapCacheEvictBuilder(
-    builder,
-    table,
-    options,
-    isCached
-  );
-}
-async function handleCachedQuery(target, options, cacheTtl, selections, aliasMap, onfulfilled, onrejected) {
-  try {
-    const localCached = await getQueryLocalCacheQuery(target, options);
-    if (localCached) {
-      return onfulfilled ? onfulfilled(localCached) : localCached;
-    }
-    const cacheResult = await getFromCache(target, options);
-    if (cacheResult) {
-      return onfulfilled ? onfulfilled(cacheResult) : cacheResult;
-    }
-    const rows = await target.execute();
-    const transformed = applyFromDriverTransform(rows, selections, aliasMap);
-    await saveQueryLocalCacheQuery(target, transformed, options);
-    await setCacheResult(target, options, transformed, cacheTtl).catch((cacheError) => {
-      console.warn("Cache set error:", cacheError);
-    });
-    return onfulfilled ? onfulfilled(transformed) : transformed;
-  } catch (error) {
-    if (onrejected) {
-      return onrejected(error);
-    }
-    throw error;
-  }
-}
-async function handleNonCachedQuery(target, options, selections, aliasMap, onfulfilled, onrejected) {
-  try {
-    const localCached = await getQueryLocalCacheQuery(target, options);
-    if (localCached) {
-      return onfulfilled ? onfulfilled(localCached) : localCached;
-    }
-    const rows = await target.execute();
-    const transformed = applyFromDriverTransform(rows, selections, aliasMap);
-    await saveQueryLocalCacheQuery(target, transformed, options);
-    return onfulfilled ? onfulfilled(transformed) : transformed;
-  } catch (error) {
-    if (onrejected) {
-      return onrejected(error);
-    }
-    throw error;
-  }
-}
-function createAliasedSelectBuilder(db, fields, selectFn, useCache, options, cacheTtl) {
-  const { selections, aliasMap } = mapSelectFieldsWithAlias(fields);
-  const builder = selectFn(selections);
-  const wrapBuilder = (rawBuilder) => {
-    return new Proxy(rawBuilder, {
-      get(target, prop, receiver) {
-        if (prop === "execute") {
-          return async (...args) => {
-            const rows = await target.execute(...args);
-            return applyFromDriverTransform(rows, selections, aliasMap);
-          };
-        }
-        if (prop === "then") {
-          return (onfulfilled, onrejected) => {
-            if (useCache) {
-              const ttl = cacheTtl ?? options.cacheTTL ?? 120;
-              return handleCachedQuery(
-                target,
-                options,
-                ttl,
-                selections,
-                aliasMap,
-                onfulfilled,
-                onrejected
-              );
-            } else {
-              return handleNonCachedQuery(
-                target,
-                options,
-                selections,
-                aliasMap,
-                onfulfilled,
-                onrejected
-              );
-            }
-          };
-        }
-        const value = Reflect.get(target, prop, receiver);
-        if (typeof value === "function") {
-          return (...args) => {
-            const result = value.apply(target, args);
-            if (typeof result === "object" && result !== null && "execute" in result) {
-              return wrapBuilder(result);
-            }
-            return result;
-          };
-        }
-        return value;
-      }
-    });
-  };
-  return wrapBuilder(builder);
-}
-const DEFAULT_OPTIONS = {
-  logRawSqlQuery: false,
-  disableOptimisticLocking: false,
-  cacheTTL: 120,
-  cacheWrapTable: true,
-  cacheEntityQueryName: "sql",
-  cacheEntityExpirationName: "expiration",
-  cacheEntityDataName: "data"
-};
-function createRawQueryExecutor(db, options, useGlobalCache = false) {
-  return async function(query, cacheTtl) {
-    let sql2;
-    if (isSQLWrapper(query)) {
-      const dialect = db.dialect;
-      sql2 = dialect.sqlToQuery(query);
-    } else {
-      sql2 = {
-        sql: query,
-        params: []
-      };
-    }
-    const localCacheResult = await getQueryLocalCacheQuery(sql2, options);
-    if (localCacheResult) {
-      return localCacheResult;
-    }
-    if (useGlobalCache) {
-      const cacheResult = await getFromCache({ toSQL: () => sql2 }, options);
-      if (cacheResult) {
-        return cacheResult;
-      }
-    }
-    const results = await db.execute(query);
-    await saveQueryLocalCacheQuery(sql2, results, options);
-    if (useGlobalCache) {
-      await setCacheResult(
-        { toSQL: () => sql2 },
-        options,
-        results,
-        cacheTtl ?? options.cacheTTL ?? 120
-      );
-    }
-    return results;
-  };
-}
-function patchDbWithSelectAliased(db, options) {
-  const newOptions = { ...DEFAULT_OPTIONS, ...options };
-  db.selectAliased = function(fields) {
-    return createAliasedSelectBuilder(
-      db,
-      fields,
-      (selections) => db.select(selections),
-      false,
-      newOptions
-    );
-  };
-  db.selectAliasedCacheable = function(fields, cacheTtl) {
-    return createAliasedSelectBuilder(
-      db,
-      fields,
-      (selections) => db.select(selections),
-      true,
-      newOptions,
-      cacheTtl
-    );
-  };
-  db.selectAliasedDistinct = function(fields) {
-    return createAliasedSelectBuilder(
-      db,
-      fields,
-      (selections) => db.selectDistinct(selections),
-      false,
-      newOptions
-    );
-  };
-  db.selectAliasedDistinctCacheable = function(fields, cacheTtl) {
-    return createAliasedSelectBuilder(
-      db,
-      fields,
-      (selections) => db.selectDistinct(selections),
-      true,
-      newOptions,
-      cacheTtl
-    );
-  };
-  db.selectFrom = function(table) {
-    return db.selectAliased(getTableColumns(table)).from(table);
-  };
-  db.selectFromCacheable = function(table, cacheTtl) {
-    return db.selectAliasedCacheable(getTableColumns(table), cacheTtl).from(table);
-  };
-  db.selectDistinctFrom = function(table) {
-    return db.selectAliasedDistinct(getTableColumns(table)).from(table);
-  };
-  db.selectDistinctFromCacheable = function(table, cacheTtl) {
-    return db.selectAliasedDistinctCacheable(getTableColumns(table), cacheTtl).from(table);
-  };
-  db.insertWithCacheContext = function(table) {
-    return insertAndEvictCacheBuilder(db, table, newOptions, false);
-  };
-  db.insertAndEvictCache = function(table) {
-    return insertAndEvictCacheBuilder(db, table, newOptions, true);
-  };
-  db.updateWithCacheContext = function(table) {
-    return updateAndEvictCacheBuilder(db, table, newOptions, false);
-  };
-  db.updateAndEvictCache = function(table) {
-    return updateAndEvictCacheBuilder(db, table, newOptions, true);
-  };
-  db.deleteWithCacheContext = function(table) {
-    return deleteAndEvictCacheBuilder(db, table, newOptions, false);
-  };
-  db.deleteAndEvictCache = function(table) {
-    return deleteAndEvictCacheBuilder(db, table, newOptions, true);
-  };
-  db.executeQuery = createRawQueryExecutor(db, newOptions, false);
-  db.executeQueryCacheable = createRawQueryExecutor(db, newOptions, true);
-  return db;
-}
-class ForgeSQLAnalyseOperation {
-  forgeOperations;
-  /**
-   * Creates a new instance of ForgeSQLAnalizeOperation.
-   * @param {ForgeSqlOperation} forgeOperations - The ForgeSQL operations instance
-   */
-  constructor(forgeOperations) {
-    this.forgeOperations = forgeOperations;
-    this.mapToCamelCaseClusterStatement = this.mapToCamelCaseClusterStatement.bind(this);
-  }
-  /**
-   * Executes EXPLAIN on a raw SQL query.
-   * @param {string} query - The SQL query to analyze
-   * @param {unknown[]} bindParams - The query parameters
-   * @returns {Promise<ExplainAnalyzeRow[]>} The execution plan analysis results
-   */
-  async explainRaw(query, bindParams) {
-    const results = await this.forgeOperations.fetch().executeRawSQL(`EXPLAIN ${query}`, bindParams);
-    return results.map((row) => ({
-      id: row.id,
-      estRows: row.estRows,
-      actRows: row.actRows,
-      task: row.task,
-      accessObject: row["access object"],
-      executionInfo: row["execution info"],
-      operatorInfo: row["operator info"],
-      memory: row.memory,
-      disk: row.disk
-    }));
-  }
-  /**
-   * Executes EXPLAIN on a Drizzle query.
-   * @param {{ toSQL: () => Query }} query - The Drizzle query to analyze
-   * @returns {Promise<ExplainAnalyzeRow[]>} The execution plan analysis results
-   */
-  async explain(query) {
-    const { sql: sql2, params } = query.toSQL();
-    return this.explainRaw(sql2, params);
-  }
-  /**
-   * Executes EXPLAIN ANALYZE on a raw SQL query.
-   * @param {string} query - The SQL query to analyze
-   * @param {unknown[]} bindParams - The query parameters
-   * @returns {Promise<ExplainAnalyzeRow[]>} The execution plan analysis results
-   */
-  async explainAnalyzeRaw(query, bindParams) {
-    const results = await this.forgeOperations.fetch().executeRawSQL(`EXPLAIN ANALYZE ${query}`, bindParams);
-    return results.map((row) => ({
-      id: row.id,
-      estRows: row.estRows,
-      actRows: row.actRows,
-      task: row.task,
-      accessObject: row["access object"],
-      executionInfo: row["execution info"],
-      operatorInfo: row["operator info"],
-      memory: row.memory,
-      disk: row.disk
-    }));
-  }
-  /**
-   * Executes EXPLAIN ANALYZE on a Drizzle query.
-   * @param {{ toSQL: () => Query }} query - The Drizzle query to analyze
-   * @returns {Promise<ExplainAnalyzeRow[]>} The execution plan analysis results
-   */
-  async explainAnalyze(query) {
-    const { sql: sql2, params } = query.toSQL();
-    return this.explainAnalyzeRaw(sql2, params);
-  }
-  /**
-   * Decodes a query execution plan from its string representation.
-   * @param {string} input - The raw execution plan string
-   * @returns {ExplainAnalyzeRow[]} The decoded execution plan rows
-   */
-  decodedPlan(input) {
-    if (!input) {
-      return [];
-    }
-    const lines = input.trim().split("\n");
-    if (lines.length < 2) return [];
-    const headersRaw = lines[0].split("	").map((h) => h.trim()).filter(Boolean);
-    const headers = headersRaw.map((h) => {
-      return h.replace(/\s+/g, " ").replace(/[-\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (s) => s.toLowerCase());
-    });
-    return lines.slice(1).map((line) => {
-      const values = line.split("	").map((s) => s.trim()).filter(Boolean);
-      const row = {};
-      headers.forEach((key, i) => {
-        row[key] = values[i] ?? "";
-      });
-      return row;
-    });
-  }
-  /**
-   * Normalizes a raw slow query row into a more structured format.
-   * @param {SlowQueryRaw} row - The raw slow query data
-   * @returns {SlowQueryNormalized} The normalized slow query data
-   */
-  normalizeSlowQuery(row) {
-    return {
-      time: row.Time,
-      txnStartTs: row.Txn_start_ts,
-      user: row.User,
-      host: row.Host,
-      connId: row.Conn_ID,
-      db: row.DB,
-      query: row.Query,
-      digest: row.Digest,
-      queryTime: row.Query_time,
-      compileTime: row.Compile_time,
-      optimizeTime: row.Optimize_time,
-      processTime: row.Process_time,
-      waitTime: row.Wait_time,
-      parseTime: row.Parse_time,
-      rewriteTime: row.Rewrite_time,
-      copTime: row.Cop_time,
-      copProcAvg: row.Cop_proc_avg,
-      copProcMax: row.Cop_proc_max,
-      copProcP90: row.Cop_proc_p90,
-      copProcAddr: row.Cop_proc_addr,
-      copWaitAvg: row.Cop_wait_avg,
-      copWaitMax: row.Cop_wait_max,
-      copWaitP90: row.Cop_wait_p90,
-      copWaitAddr: row.Cop_wait_addr,
-      memMax: row.Mem_max,
-      diskMax: row.Disk_max,
-      totalKeys: row.Total_keys,
-      processKeys: row.Process_keys,
-      requestCount: row.Request_count,
-      kvTotal: row.KV_total,
-      pdTotal: row.PD_total,
-      resultRows: row.Result_rows,
-      rocksdbBlockCacheHitCount: row.Rocksdb_block_cache_hit_count,
-      rocksdbBlockReadCount: row.Rocksdb_block_read_count,
-      rocksdbBlockReadByte: row.Rocksdb_block_read_byte,
-      plan: row.Plan,
-      binaryPlan: row.Binary_plan,
-      planDigest: row.Plan_digest,
-      parsedPlan: this.decodedPlan(row.Plan)
-    };
-  }
-  /**
-   * Builds a SQL query for retrieving cluster statement history.
-   * @param {string[]} tables - The tables to analyze
-   * @param {Date} [from] - The start date for the analysis
-   * @param {Date} [to] - The end date for the analysis
-   * @returns {string} The SQL query for cluster statement history
-   */
-  buildClusterStatementQuery(tables, from, to) {
-    const formatDateTime2 = (date) => DateTime.fromJSDate(date).toFormat("yyyy-LL-dd'T'HH:mm:ss.SSS");
-    const tableConditions = tables.map((table) => `TABLE_NAMES LIKE CONCAT(SCHEMA_NAME, '.', '%', '${table}', '%')`).join(" OR ");
-    const timeConditions = [];
-    if (from) {
-      timeConditions.push(`SUMMARY_BEGIN_TIME >= '${formatDateTime2(from)}'`);
-    }
-    if (to) {
-      timeConditions.push(`SUMMARY_END_TIME <= '${formatDateTime2(to)}'`);
-    }
-    let whereClauses;
-    if (tableConditions?.length) {
-      whereClauses = [tableConditions ? `(${tableConditions})` : "", ...timeConditions];
-    } else {
-      whereClauses = timeConditions;
-    }
-    return `
-      SELECT *
-      FROM (
-        SELECT * FROM INFORMATION_SCHEMA.CLUSTER_STATEMENTS_SUMMARY
-        UNION ALL
-        SELECT * FROM INFORMATION_SCHEMA.CLUSTER_STATEMENTS_SUMMARY_HISTORY
-      ) AS combined
-      ${whereClauses?.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : ""}
-    `;
-  }
-  /**
-   * Retrieves and analyzes slow queries from the database.
-   * @returns {Promise<SlowQueryNormalized[]>} The normalized slow query data
-   */
-  //  CLUSTER_SLOW_QUERY STATISTICS
-  async analyzeSlowQueries() {
-    const results = await this.forgeOperations.fetch().executeRawSQL(`
-      SELECT *
-      FROM information_schema.slow_query 
-      ORDER BY time DESC
-    `);
-    return results.map((row) => this.normalizeSlowQuery(row));
-  }
-  /**
-   * Converts a cluster statement row to camelCase format.
-   * @param {Record<string, any>} input - The input row data
-   * @returns {ClusterStatementRowCamelCase} The converted row data
-   */
-  mapToCamelCaseClusterStatement(input) {
-    if (!input) {
-      return {};
-    }
-    const result = {};
-    result.parsedPlan = this.decodedPlan(input["PLAN"] ?? "");
-    for (const key in input) {
-      const camelKey = key.toLowerCase().replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-      result[camelKey] = input[key];
-    }
-    return result;
-  }
-  /**
-   * Analyzes query history for specific tables using raw table names.
-   * @param {string[]} tables - The table names to analyze
-   * @param {Date} [fromDate] - The start date for the analysis
-   * @param {Date} [toDate] - The end date for the analysis
-   * @returns {Promise<ClusterStatementRowCamelCase[]>} The analyzed query history
-   */
-  async analyzeQueriesHistoryRaw(tables, fromDate, toDate) {
-    const results = await this.forgeOperations.fetch().executeRawSQL(
-      this.buildClusterStatementQuery(tables ?? [], fromDate, toDate)
-    );
-    return results.map((r) => this.mapToCamelCaseClusterStatement(r));
-  }
-  /**
-   * Analyzes query history for specific tables using Drizzle table objects.
-   * @param {AnyMySqlTable[]} tables - The Drizzle table objects to analyze
-   * @param {Date} [fromDate] - The start date for the analysis
-   * @param {Date} [toDate] - The end date for the analysis
-   * @returns {Promise<ClusterStatementRowCamelCase[]>} The analyzed query history
-   */
-  async analyzeQueriesHistory(tables, fromDate, toDate) {
-    const tableNames = tables?.map((table) => getTableName(table)) ?? [];
-    return this.analyzeQueriesHistoryRaw(tableNames, fromDate, toDate);
-  }
-}
-class ForgeSQLCacheOperations {
-  options;
-  forgeOperations;
-  /**
-   * Creates a new instance of ForgeSQLCacheOperations.
-   *
-   * @param options - Configuration options for the ORM
-   * @param forgeOperations - The ForgeSQL operations instance
-   */
-  constructor(options, forgeOperations) {
-    this.options = options;
-    this.forgeOperations = forgeOperations;
-  }
-  /**
-   * Evicts cache for multiple tables using Drizzle table objects.
-   *
-   * @param tables - Array of Drizzle table objects to clear cache for
-   * @returns Promise that resolves when cache eviction is complete
-   * @throws Error if cacheEntityName is not configured
-   */
-  async evictCacheEntities(tables) {
-    if (!this.options.cacheEntityName) {
-      throw new Error("cacheEntityName is not configured");
-    }
-    await this.evictCache(tables.map((t) => getTableName(t)));
-  }
-  /**
-   * Evicts cache for multiple tables by their names.
-   *
-   * @param tables - Array of table names to clear cache for
-   * @returns Promise that resolves when cache eviction is complete
-   * @throws Error if cacheEntityName is not configured
-   */
-  async evictCache(tables) {
-    if (!this.options.cacheEntityName) {
-      throw new Error("cacheEntityName is not configured");
-    }
-    await clearTablesCache(tables, this.options);
-  }
-  /**
-   * Inserts records with optimistic locking/versioning and automatically evicts cache.
-   *
-   * This method uses `modifyWithVersioning().insert()` internally, providing:
-   * - Automatic version field initialization
-   * - Optimistic locking support
-   * - Cache eviction after successful operation
-   *
-   * @param schema - The table schema
-   * @param models - Array of entities to insert
-   * @param updateIfExists - Whether to update existing records
-   * @returns Promise that resolves to the number of inserted rows
-   * @throws Error if cacheEntityName is not configured
-   * @throws Error if optimistic locking check fails
-   */
-  async insert(schema, models, updateIfExists) {
-    this.validateCacheConfiguration();
-    const number = await this.forgeOperations.modifyWithVersioning().insert(schema, models, updateIfExists);
-    await clearCache(schema, this.options);
-    return number;
-  }
-  /**
-   * Deletes a record by ID with optimistic locking/versioning and automatically evicts cache.
-   *
-   * This method uses `modifyWithVersioning().deleteById()` internally, providing:
-   * - Optimistic locking checks before deletion
-   * - Version field validation
-   * - Cache eviction after successful operation
-   *
-   * @param id - The ID of the record to delete
-   * @param schema - The table schema
-   * @returns Promise that resolves to the number of affected rows
-   * @throws Error if cacheEntityName is not configured
-   * @throws Error if optimistic locking check fails
-   */
-  async deleteById(id, schema) {
-    this.validateCacheConfiguration();
-    const number = await this.forgeOperations.modifyWithVersioning().deleteById(id, schema);
-    await clearCache(schema, this.options);
-    return number;
-  }
-  /**
-   * Updates a record by ID with optimistic locking/versioning and automatically evicts cache.
-   *
-   * This method uses `modifyWithVersioning().updateById()` internally, providing:
-   * - Optimistic locking checks before update
-   * - Version field incrementation
-   * - Cache eviction after successful operation
-   *
-   * @param entity - The entity with updated values (must include primary key)
-   * @param schema - The table schema
-   * @returns Promise that resolves to the number of affected rows
-   * @throws Error if cacheEntityName is not configured
-   * @throws Error if optimistic locking check fails
-   */
-  async updateById(entity, schema) {
-    this.validateCacheConfiguration();
-    const number = await this.forgeOperations.modifyWithVersioning().updateById(entity, schema);
-    await clearCache(schema, this.options);
-    return number;
-  }
-  /**
-   * Updates fields based on conditions with optimistic locking/versioning and automatically evicts cache.
-   *
-   * This method uses `modifyWithVersioning().updateFields()` internally, providing:
-   * - Optimistic locking support (if version field is configured)
-   * - Version field validation and incrementation
-   * - Cache eviction after successful operation
-   *
-   * @param updateData - The data to update
-   * @param schema - The table schema
-   * @param where - Optional WHERE conditions
-   * @returns Promise that resolves to the number of affected rows
-   * @throws Error if cacheEntityName is not configured
-   * @throws Error if optimistic locking check fails
-   */
-  async updateFields(updateData, schema, where) {
-    this.validateCacheConfiguration();
-    const number = await this.forgeOperations.modifyWithVersioning().updateFields(updateData, schema, where);
-    await clearCache(schema, this.options);
-    return number;
-  }
-  /**
-   * Executes a query with caching support.
-   * First checks cache, if not found executes query and stores result in cache.
-   *
-   * @param query - The Drizzle query to execute
-   * @param cacheTtl - Optional cache TTL override
-   * @returns Promise that resolves to the query results
-   * @throws Error if cacheEntityName is not configured
-   */
-  async executeQuery(query, cacheTtl) {
-    this.validateCacheConfiguration();
-    const sqlQuery = query;
-    const cacheResult = await getFromCache(sqlQuery, this.options);
-    if (cacheResult) {
-      return cacheResult;
-    }
-    const results = await query;
-    await setCacheResult(sqlQuery, this.options, results, cacheTtl ?? this.options.cacheTTL ?? 60);
-    return results;
-  }
-  /**
-   * Validates that cache configuration is properly set up.
-   *
-   * @throws Error if cacheEntityName is not configured
-   * @private
-   */
-  validateCacheConfiguration() {
-    if (!this.options.cacheEntityName) {
-      throw new Error("cacheEntityName is not configured");
-    }
-  }
-}
-class ForgeSQLORMImpl {
-  static instance = null;
-  drizzle;
-  crudOperations;
-  fetchOperations;
-  analyzeOperations;
-  cacheOperations;
-  options;
-  /**
-   * Private constructor to enforce singleton behavior.
-   * @param options - Options for configuring ForgeSQL ORM behavior.
-   */
-  constructor(options) {
-    try {
-      const newOptions = options ?? {
-        logRawSqlQuery: false,
-        logCache: false,
-        disableOptimisticLocking: false,
-        cacheWrapTable: true,
-        cacheTTL: 120,
-        cacheEntityQueryName: "sql",
-        cacheEntityExpirationName: "expiration",
-        cacheEntityDataName: "data"
-      };
-      this.options = newOptions;
-      if (newOptions.logRawSqlQuery) {
-        console.debug("Initializing ForgeSQLORM...");
-      }
-      const proxiedDriver = createForgeDriverProxy(
-        this,
-        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;
-    }
-  }
-  /**
-   * Executes a query and provides access to execution metadata with performance monitoring.
-   * This method allows you to capture detailed information about query execution
-   * including database execution time, response size, and query analysis capabilities.
-   *
-   * The method aggregates metrics across all database operations within the query function,
-   * making it ideal for monitoring resolver performance and detecting performance issues.
-   *
-   * @template T - The return type of the query
-   * @param query - A function that returns a Promise with the query result. Can contain multiple database operations.
-   * @param onMetadata - Callback function that receives aggregated execution metadata
-   * @param onMetadata.totalDbExecutionTime - Total database execution time across all operations in the query function (in milliseconds)
-   * @param onMetadata.totalResponseSize - Total response size across all operations (in bytes)
-   * @param onMetadata.printQueries - Function to analyze and print query execution plans from CLUSTER_STATEMENTS_SUMMARY
-   * @returns Promise with the query result
-   *
-   * @example
-   * ```typescript
-   * // Basic usage with performance monitoring
-   * const result = await forgeSQL.executeWithMetadata(
-   *   async () => {
-   *     const users = await forgeSQL.selectFrom(usersTable);
-   *     const orders = await forgeSQL.selectFrom(ordersTable).where(eq(ordersTable.userId, usersTable.id));
-   *     return { users, orders };
-   *   },
-   *   (totalDbExecutionTime, totalResponseSize, printQueries) => {
-   *     const threshold = 500; // ms baseline for this resolver
-   *
-   *     if (totalDbExecutionTime > threshold * 1.5) {
-   *       console.warn(`[Performance Warning] Resolver exceeded DB time: ${totalDbExecutionTime} ms`);
-   *       await printQueries(); // Analyze and print query execution plans
-   *     } else if (totalDbExecutionTime > threshold) {
-   *       console.debug(`[Performance Debug] High DB time: ${totalDbExecutionTime} ms`);
-   *     }
-   *
-   *     console.log(`DB response size: ${totalResponseSize} bytes`);
-   *   }
-   * );
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Resolver with performance monitoring
-   * resolver.define("fetch", async (req: Request) => {
-   *   try {
-   *     return await forgeSQL.executeWithMetadata(
-   *       async () => {
-   *         // Resolver logic with multiple queries
-   *         const users = await forgeSQL.selectFrom(demoUsers);
-   *         const orders = await forgeSQL.selectFrom(demoOrders)
-   *           .where(eq(demoOrders.userId, demoUsers.id));
-   *         return { users, orders };
-   *       },
-   *       async (totalDbExecutionTime, totalResponseSize, printQueries) => {
-   *         const threshold = 500; // ms baseline for this resolver
-   *
-   *         if (totalDbExecutionTime > threshold * 1.5) {
-   *           console.warn(`[Performance Warning fetch] Resolver exceeded DB time: ${totalDbExecutionTime} ms`);
-   *           await printQueries(); // Optionally log or capture diagnostics for further analysis
-   *         } else if (totalDbExecutionTime > threshold) {
-   *           console.debug(`[Performance Debug] High DB time: ${totalDbExecutionTime} ms`);
-   *         }
-   *
-   *         console.log(`DB response size: ${totalResponseSize} bytes`);
-   *       }
-   *     );
-   *   } catch (e) {
-   *     const error = e?.cause?.debug?.sqlMessage ?? e?.cause;
-   *     console.error(error, e);
-   *     throw error;
-   *   }
-   * });
-   * ```
-   *
-   * @note **Important**: When multiple resolvers are running concurrently, their query data may also appear in `printQueries()` analysis, as it queries the global `CLUSTER_STATEMENTS_SUMMARY` table.
-   */
-  async executeWithMetadata(query, onMetadata) {
-    return metadataQueryContext.run(
-      {
-        totalDbExecutionTime: 0,
-        totalResponseSize: 0,
-        beginTime: /* @__PURE__ */ new Date(),
-        forgeSQLORM: this,
-        printQueriesWithPlan: async () => {
-          return;
-        }
-      },
-      async () => {
-        const result = await query();
-        const metadata = await getLastestMetadata();
-        try {
-          if (metadata) {
-            await onMetadata(
-              metadata.totalDbExecutionTime,
-              metadata.totalResponseSize,
-              metadata.printQueriesWithPlan
-            );
-          }
-        } catch (e) {
-          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;
-      }
-    );
-  }
-  /**
-   * 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.
-   * Queries executed within this context will bypass cache for tables that were marked for clearing.
-   *
-   * This is useful for:
-   * - Batch operations that affect multiple tables
-   * - Transaction-like operations where you want to clear cache only at the end
-   * - Performance optimization by reducing cache clear operations
-   *
-   * @param cacheContext - Function containing operations that may trigger cache evictions
-   * @returns Promise that resolves when all operations and cache clearing are complete
-   *
-   * @example
-   * ```typescript
-   * await forgeSQL.executeWithCacheContext(async () => {
-   *   await forgeSQL.modifyWithVersioning().insert(users, userData);
-   *   await forgeSQL.modifyWithVersioning().insert(orders, orderData);
-   *   // Cache for both users and orders tables will be cleared at the end
-   * });
-   * ```
-   */
-  executeWithCacheContext(cacheContext) {
-    return this.executeWithCacheContextAndReturnValue(cacheContext);
-  }
-  /**
-   * Executes operations within a cache context and returns a value.
-   * All clearCache calls within the context are collected and executed in batch at the end.
-   * Queries executed within this context will bypass cache for tables that were marked for clearing.
-   *
-   * @param cacheContext - Function containing operations that may trigger cache evictions
-   * @returns Promise that resolves to the return value of the cacheContext function
-   *
-   * @example
-   * ```typescript
-   * const result = await forgeSQL.executeWithCacheContextAndReturnValue(async () => {
-   *   await forgeSQL.modifyWithVersioning().insert(users, userData);
-   *   return await forgeSQL.fetch().executeQueryOnlyOne(selectUserQuery);
-   * });
-   * ```
-   */
-  async executeWithCacheContextAndReturnValue(cacheContext) {
-    return await this.executeWithLocalCacheContextAndReturnValue(
-      async () => await cacheApplicationContext.run(
-        cacheApplicationContext.getStore() ?? { tables: /* @__PURE__ */ new Set() },
-        async () => {
-          try {
-            return await cacheContext();
-          } finally {
-            await clearTablesCache(
-              Array.from(cacheApplicationContext.getStore()?.tables ?? []),
-              this.options
-            );
-          }
-        }
-      )
-    );
-  }
-  /**
-   * Executes operations within a local cache context and returns a value.
-   * This provides in-memory caching for select queries within a single request scope.
-   *
-   * @param cacheContext - Function containing operations that will benefit from local caching
-   * @returns Promise that resolves to the return value of the cacheContext function
-   */
-  async executeWithLocalCacheContextAndReturnValue(cacheContext) {
-    return await localCacheApplicationContext.run(
-      localCacheApplicationContext.getStore() ?? { cache: {} },
-      async () => {
-        return await cacheContext();
-      }
-    );
-  }
-  /**
-   * Executes operations within a local cache context.
-   * This provides in-memory caching for select queries within a single request scope.
-   *
-   * @param cacheContext - Function containing operations that will benefit from local caching
-   * @returns Promise that resolves when all operations are complete
-   */
-  executeWithLocalContext(cacheContext) {
-    return this.executeWithLocalCacheContextAndReturnValue(cacheContext);
-  }
-  /**
-   * Creates an insert query builder.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned inserts, use `modifyWithVersioning().insert()` or `modifyWithVersioningAndEvictCache().insert()` instead.
-   *
-   * @param table - The table to insert into
-   * @returns Insert query builder (no versioning, no cache management)
-   */
-  insert(table) {
-    return this.drizzle.insertWithCacheContext(table);
-  }
-  /**
-   * Creates an insert query builder that automatically evicts cache after execution.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned inserts, use `modifyWithVersioning().insert()` or `modifyWithVersioningAndEvictCache().insert()` instead.
-   *
-   * @param table - The table to insert into
-   * @returns Insert query builder with automatic cache eviction (no versioning)
-   */
-  insertAndEvictCache(table) {
-    return this.drizzle.insertAndEvictCache(table);
-  }
-  /**
-   * Creates an update query builder that automatically evicts cache after execution.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned updates, use `modifyWithVersioning().updateById()` or `modifyWithVersioningAndEvictCache().updateById()` instead.
-   *
-   * @param table - The table to update
-   * @returns Update query builder with automatic cache eviction (no versioning)
-   */
-  updateAndEvictCache(table) {
-    return this.drizzle.updateAndEvictCache(table);
-  }
-  /**
-   * Creates an update query builder.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned updates, use `modifyWithVersioning().updateById()` or `modifyWithVersioningAndEvictCache().updateById()` instead.
-   *
-   * @param table - The table to update
-   * @returns Update query builder (no versioning, no cache management)
-   */
-  update(table) {
-    return this.drizzle.updateWithCacheContext(table);
-  }
-  /**
-   * Creates a delete query builder.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned deletes, use `modifyWithVersioning().deleteById()` or `modifyWithVersioningAndEvictCache().deleteById()` instead.
-   *
-   * @param table - The table to delete from
-   * @returns Delete query builder (no versioning, no cache management)
-   */
-  delete(table) {
-    return this.drizzle.deleteWithCacheContext(table);
-  }
-  /**
-   * Creates a delete query builder that automatically evicts cache after execution.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned deletes, use `modifyWithVersioning().deleteById()` or `modifyWithVersioningAndEvictCache().deleteById()` instead.
-   *
-   * @param table - The table to delete from
-   * @returns Delete query builder with automatic cache eviction (no versioning)
-   */
-  deleteAndEvictCache(table) {
-    return this.drizzle.deleteAndEvictCache(table);
-  }
-  /**
-   * Create the modify operations instance.
-   * @returns modify operations.
-   */
-  modifyWithVersioning() {
-    return this.crudOperations;
-  }
-  /**
-   * Returns the singleton instance of ForgeSQLORMImpl.
-   * @param options - Options for configuring ForgeSQL ORM behavior.
-   * @returns The singleton instance of ForgeSQLORMImpl.
-   */
-  static getInstance(options) {
-    ForgeSQLORMImpl.instance ??= new ForgeSQLORMImpl(options);
-    return ForgeSQLORMImpl.instance;
-  }
-  /**
-   * Retrieves the fetch operations instance.
-   * @returns Fetch operations.
-   */
-  fetch() {
-    return this.fetchOperations;
-  }
-  /**
-   * Provides query analysis capabilities including EXPLAIN ANALYZE and slow query analysis.
-   * @returns {SchemaAnalyzeForgeSql} Interface for analyzing query performance
-   */
-  analyze() {
-    return this.analyzeOperations;
-  }
-  /**
-   * Provides schema-level SQL operations with optimistic locking/versioning and automatic cache eviction.
-   *
-   * This method returns operations that use `modifyWithVersioning()` internally, providing:
-   * - Optimistic locking support
-   * - Automatic version field management
-   * - Cache eviction after successful operations
-   *
-   * @returns {ForgeSQLCacheOperations} Interface for executing versioned SQL operations with cache management
-   */
-  modifyWithVersioningAndEvictCache() {
-    return this.cacheOperations;
-  }
-  /**
-   * Returns a Drizzle query builder instance.
-   *
-   * ⚠️ IMPORTANT: This method should be used ONLY for query building purposes.
-   * The returned instance should NOT be used for direct database connections or query execution.
-   * All database operations should be performed through Forge SQL's executeRawSQL or executeRawUpdateSQL methods.
-   *
-   * @returns A Drizzle query builder instance for query construction only.
-   */
-  getDrizzleQueryBuilder() {
-    return this.drizzle;
-  }
-  /**
-   * Creates a select query with unique field aliases to prevent field name collisions in joins.
-   * This is particularly useful when working with Atlassian Forge SQL, which collapses fields with the same name in joined tables.
-   *
-   * @template TSelection - The type of the selected fields
-   * @param {TSelection} fields - Object containing the fields to select, with table schemas as values
-   * @returns {MySqlSelectBuilder<TSelection, MySql2PreparedQueryHKT>} A select query builder with unique field aliases
-   * @throws {Error} If fields parameter is empty
-   * @example
-   * ```typescript
-   * await forgeSQL
-   *   .select({user: users, order: orders})
-   *   .from(orders)
-   *   .innerJoin(users, eq(orders.userId, users.id));
-   * ```
-   */
-  select(fields) {
-    if (!fields) {
-      throw new Error("fields is empty");
-    }
-    return this.drizzle.selectAliased(fields);
-  }
-  /**
-   * Creates a distinct select query with unique field aliases to prevent field name collisions in joins.
-   * This is particularly useful when working with Atlassian Forge SQL, which collapses fields with the same name in joined tables.
-   *
-   * @template TSelection - The type of the selected fields
-   * @param {TSelection} fields - Object containing the fields to select, with table schemas as values
-   * @returns {MySqlSelectBuilder<TSelection, MySql2PreparedQueryHKT>} A distinct select query builder with unique field aliases
-   * @throws {Error} If fields parameter is empty
-   * @example
-   * ```typescript
-   * await forgeSQL
-   *   .selectDistinct({user: users, order: orders})
-   *   .from(orders)
-   *   .innerJoin(users, eq(orders.userId, users.id));
-   * ```
-   */
-  selectDistinct(fields) {
-    if (!fields) {
-      throw new Error("fields is empty");
-    }
-    return this.drizzle.selectAliasedDistinct(fields);
-  }
-  /**
-   * Creates a cacheable select query with unique field aliases to prevent field name collisions in joins.
-   * This is particularly useful when working with Atlassian Forge SQL, which collapses fields with the same name in joined tables.
-   *
-   * @template TSelection - The type of the selected fields
-   * @param {TSelection} fields - Object containing the fields to select, with table schemas as values
-   * @param {number} cacheTTL - cache ttl optional default is 60 sec.
-   * @returns {MySqlSelectBuilder<TSelection, MySql2PreparedQueryHKT>} A select query builder with unique field aliases
-   * @throws {Error} If fields parameter is empty
-   * @example
-   * ```typescript
-   * await forgeSQL
-   *   .selectCacheable({user: users, order: orders},60)
-   *   .from(orders)
-   *   .innerJoin(users, eq(orders.userId, users.id));
-   * ```
-   */
-  selectCacheable(fields, cacheTTL) {
-    if (!fields) {
-      throw new Error("fields is empty");
-    }
-    return this.drizzle.selectAliasedCacheable(fields, cacheTTL);
-  }
-  /**
-   * Creates a cacheable distinct select query with unique field aliases to prevent field name collisions in joins.
-   * This is particularly useful when working with Atlassian Forge SQL, which collapses fields with the same name in joined tables.
-   *
-   * @template TSelection - The type of the selected fields
-   * @param {TSelection} fields - Object containing the fields to select, with table schemas as values
-   * @param {number} cacheTTL - cache ttl optional default is 60 sec.
-   * @returns {MySqlSelectBuilder<TSelection, MySql2PreparedQueryHKT>} A distinct select query builder with unique field aliases
-   * @throws {Error} If fields parameter is empty
-   * @example
-   * ```typescript
-   * await forgeSQL
-   *   .selectDistinctCacheable({user: users, order: orders}, 60)
-   *   .from(orders)
-   *   .innerJoin(users, eq(orders.userId, users.id));
-   * ```
-   */
-  selectDistinctCacheable(fields, cacheTTL) {
-    if (!fields) {
-      throw new Error("fields is empty");
-    }
-    return this.drizzle.selectAliasedDistinctCacheable(fields, cacheTTL);
-  }
-  /**
-   * Creates a select query builder for all columns from a table with field aliasing support.
-   * This is a convenience method that automatically selects all columns from the specified table.
-   *
-   * @template T - The type of the table
-   * @param table - The table to select from
-   * @returns Select query builder with all table columns and field aliasing support
-   * @example
-   * ```typescript
-   * const users = await forgeSQL.selectFrom(userTable).where(eq(userTable.id, 1));
-   * ```
-   */
-  selectFrom(table) {
-    return this.drizzle.selectFrom(table);
-  }
-  /**
-   * Creates a select distinct query builder for all columns from a table with field aliasing support.
-   * This is a convenience method that automatically selects all distinct columns from the specified table.
-   *
-   * @template T - The type of the table
-   * @param table - The table to select from
-   * @returns Select distinct query builder with all table columns and field aliasing support
-   * @example
-   * ```typescript
-   * const uniqueUsers = await forgeSQL.selectDistinctFrom(userTable).where(eq(userTable.status, 'active'));
-   * ```
-   */
-  selectDistinctFrom(table) {
-    return this.drizzle.selectDistinctFrom(table);
-  }
-  /**
-   * Creates a cacheable select query builder for all columns from a table with field aliasing and caching support.
-   * This is a convenience method that automatically selects all columns from the specified table with caching enabled.
-   *
-   * @template T - The type of the table
-   * @param table - The table to select from
-   * @param cacheTTL - Optional cache TTL override (defaults to global cache TTL)
-   * @returns Select query builder with all table columns, field aliasing, and caching support
-   * @example
-   * ```typescript
-   * const users = await forgeSQL.selectCacheableFrom(userTable, 300).where(eq(userTable.id, 1));
-   * ```
-   */
-  selectCacheableFrom(table, cacheTTL) {
-    return this.drizzle.selectFromCacheable(table, cacheTTL);
-  }
-  /**
-   * Creates a cacheable select distinct query builder for all columns from a table with field aliasing and caching support.
-   * This is a convenience method that automatically selects all distinct columns from the specified table with caching enabled.
-   *
-   * @template T - The type of the table
-   * @param table - The table to select from
-   * @param cacheTTL - Optional cache TTL override (defaults to global cache TTL)
-   * @returns Select distinct query builder with all table columns, field aliasing, and caching support
-   * @example
-   * ```typescript
-   * const uniqueUsers = await forgeSQL.selectDistinctCacheableFrom(userTable, 300).where(eq(userTable.status, 'active'));
-   * ```
-   */
-  selectDistinctCacheableFrom(table, cacheTTL) {
-    return this.drizzle.selectDistinctFromCacheable(table, cacheTTL);
-  }
-  /**
-   * Executes a raw SQL query with local cache support.
-   * This method provides local caching for raw SQL queries within the current invocation context.
-   * Results are cached locally and will be returned from cache on subsequent identical queries.
-   *
-   * @param query - The SQL query to execute (SQLWrapper or string)
-   * @returns Promise with query results
-   * @example
-   * ```typescript
-   * // Using SQLWrapper
-   * const result = await forgeSQL.execute(sql`SELECT * FROM users WHERE id = ${userId}`);
-   *
-   * // Using string
-   * const result = await forgeSQL.execute("SELECT * FROM users WHERE status = 'active'");
-   * ```
-   */
-  execute(query) {
-    return this.drizzle.executeQuery(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(query) {
-    return this.executeDDLActions(async () => this.drizzle.executeQuery(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(actions) {
-    return operationTypeQueryContext.run({ operationType: "DDL" }, async () => actions());
-  }
-  /**
-   * Executes a raw SQL query with both local and global cache support.
-   * This method provides comprehensive caching for raw SQL queries:
-   * - Local cache: Within the current invocation context
-   * - Global cache: Cross-invocation caching using @forge/kvs
-   *
-   * @param query - The SQL query to execute (SQLWrapper or string)
-   * @param cacheTtl - Optional cache TTL override (defaults to global cache TTL)
-   * @returns Promise with query results
-   * @example
-   * ```typescript
-   * // Using SQLWrapper with custom TTL
-   * const result = await forgeSQL.executeCacheable(sql`SELECT * FROM users WHERE id = ${userId}`, 300);
-   *
-   * // Using string with default TTL
-   * const result = await forgeSQL.executeCacheable("SELECT * FROM users WHERE status = 'active'");
-   * ```
-   */
-  executeCacheable(query, cacheTtl) {
-    return this.drizzle.executeQueryCacheable(query, cacheTtl);
-  }
-  /**
-   * 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.
-   *
-   * @returns WithBuilder for creating CTEs
-   * @example
-   * ```typescript
-   * const withQuery = forgeSQL.$with('userStats').as(
-   *   forgeSQL.select({ userId: users.id, count: sql<number>`count(*)` })
-   *     .from(users)
-   *     .groupBy(users.id)
-   * );
-   * ```
-   */
-  get $with() {
-    return this.drizzle.$with;
-  }
-  /**
-   * Creates a query builder that uses Common Table Expressions (CTEs).
-   * CTEs allow you to define temporary named result sets that exist within the scope of a single query.
-   *
-   * @param queries - Array of CTE queries created with $with()
-   * @returns Query builder with CTE support
-   * @example
-   * ```typescript
-   * const withQuery = forgeSQL.$with('userStats').as(
-   *   forgeSQL.select({ userId: users.id, count: sql<number>`count(*)` })
-   *     .from(users)
-   *     .groupBy(users.id)
-   * );
-   *
-   * const result = await forgeSQL.with(withQuery)
-   *   .select({ userId: withQuery.userId, count: withQuery.count })
-   *   .from(withQuery);
-   * ```
-   */
-  with(...queries) {
-    return this.drizzle.with(...queries);
-  }
-}
-class ForgeSQLORM {
-  ormInstance;
-  constructor(options) {
-    this.ormInstance = ForgeSQLORMImpl.getInstance(options);
-  }
-  /**
-   * Executes a query and provides access to execution metadata with performance monitoring.
-   * This method allows you to capture detailed information about query execution
-   * including database execution time, response size, and query analysis capabilities.
-   *
-   * The method aggregates metrics across all database operations within the query function,
-   * making it ideal for monitoring resolver performance and detecting performance issues.
-   *
-   * @template T - The return type of the query
-   * @param query - A function that returns a Promise with the query result. Can contain multiple database operations.
-   * @param onMetadata - Callback function that receives aggregated execution metadata
-   * @param onMetadata.totalDbExecutionTime - Total database execution time across all operations in the query function (in milliseconds)
-   * @param onMetadata.totalResponseSize - Total response size across all operations (in bytes)
-   * @param onMetadata.printQueries - Function to analyze and print query execution plans from CLUSTER_STATEMENTS_SUMMARY
-   * @returns Promise with the query result
-   *
-   * @example
-   * ```typescript
-   * // Basic usage with performance monitoring
-   * const result = await forgeSQL.executeWithMetadata(
-   *   async () => {
-   *     const users = await forgeSQL.selectFrom(usersTable);
-   *     const orders = await forgeSQL.selectFrom(ordersTable).where(eq(ordersTable.userId, usersTable.id));
-   *     return { users, orders };
-   *   },
-   *   (totalDbExecutionTime, totalResponseSize, printQueries) => {
-   *     const threshold = 500; // ms baseline for this resolver
-   *
-   *     if (totalDbExecutionTime > threshold * 1.5) {
-   *       console.warn(`[Performance Warning] Resolver exceeded DB time: ${totalDbExecutionTime} ms`);
-   *       await printQueries(); // Analyze and print query execution plans
-   *     } else if (totalDbExecutionTime > threshold) {
-   *       console.debug(`[Performance Debug] High DB time: ${totalDbExecutionTime} ms`);
-   *     }
-   *
-   *     console.log(`DB response size: ${totalResponseSize} bytes`);
-   *   }
-   * );
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Resolver with performance monitoring
-   * resolver.define("fetch", async (req: Request) => {
-   *   try {
-   *     return await forgeSQL.executeWithMetadata(
-   *       async () => {
-   *         // Resolver logic with multiple queries
-   *         const users = await forgeSQL.selectFrom(demoUsers);
-   *         const orders = await forgeSQL.selectFrom(demoOrders)
-   *           .where(eq(demoOrders.userId, demoUsers.id));
-   *         return { users, orders };
-   *       },
-   *       async (totalDbExecutionTime, totalResponseSize, printQueries) => {
-   *         const threshold = 500; // ms baseline for this resolver
-   *
-   *         if (totalDbExecutionTime > threshold * 1.5) {
-   *           console.warn(`[Performance Warning fetch] Resolver exceeded DB time: ${totalDbExecutionTime} ms`);
-   *           await printQueries(); // Optionally log or capture diagnostics for further analysis
-   *         } else if (totalDbExecutionTime > threshold) {
-   *           console.debug(`[Performance Debug] High DB time: ${totalDbExecutionTime} ms`);
-   *         }
-   *
-   *         console.log(`DB response size: ${totalResponseSize} bytes`);
-   *       }
-   *     );
-   *   } catch (e) {
-   *     const error = e?.cause?.debug?.sqlMessage ?? e?.cause;
-   *     console.error(error, e);
-   *     throw error;
-   *   }
-   * });
-   * ```
-   *
-   * @note **Important**: When multiple resolvers are running concurrently, their query data may also appear in `printQueries()` analysis, as it queries the global `CLUSTER_STATEMENTS_SUMMARY` table.
-   */
-  async executeWithMetadata(query, onMetadata) {
-    return this.ormInstance.executeWithMetadata(query, onMetadata);
-  }
-  selectCacheable(fields, cacheTTL) {
-    return this.ormInstance.selectCacheable(fields, cacheTTL);
-  }
-  selectDistinctCacheable(fields, cacheTTL) {
-    return this.ormInstance.selectDistinctCacheable(fields, cacheTTL);
-  }
-  /**
-   * Creates a select query builder for all columns from a table with field aliasing support.
-   * This is a convenience method that automatically selects all columns from the specified table.
-   *
-   * @template T - The type of the table
-   * @param table - The table to select from
-   * @returns Select query builder with all table columns and field aliasing support
-   * @example
-   * ```typescript
-   * const users = await forgeSQL.selectFrom(userTable).where(eq(userTable.id, 1));
-   * ```
-   */
-  selectFrom(table) {
-    return this.ormInstance.getDrizzleQueryBuilder().selectFrom(table);
-  }
-  /**
-   * Creates a select distinct query builder for all columns from a table with field aliasing support.
-   * This is a convenience method that automatically selects all distinct columns from the specified table.
-   *
-   * @template T - The type of the table
-   * @param table - The table to select from
-   * @returns Select distinct query builder with all table columns and field aliasing support
-   * @example
-   * ```typescript
-   * const uniqueUsers = await forgeSQL.selectDistinctFrom(userTable).where(eq(userTable.status, 'active'));
-   * ```
-   */
-  selectDistinctFrom(table) {
-    return this.ormInstance.getDrizzleQueryBuilder().selectDistinctFrom(table);
-  }
-  /**
-   * Creates a cacheable select query builder for all columns from a table with field aliasing and caching support.
-   * This is a convenience method that automatically selects all columns from the specified table with caching enabled.
-   *
-   * @template T - The type of the table
-   * @param table - The table to select from
-   * @param cacheTTL - Optional cache TTL override (defaults to global cache TTL)
-   * @returns Select query builder with all table columns, field aliasing, and caching support
-   * @example
-   * ```typescript
-   * const users = await forgeSQL.selectCacheableFrom(userTable, 300).where(eq(userTable.id, 1));
-   * ```
-   */
-  selectCacheableFrom(table, cacheTTL) {
-    return this.ormInstance.getDrizzleQueryBuilder().selectFromCacheable(table, cacheTTL);
-  }
-  /**
-   * Creates a cacheable select distinct query builder for all columns from a table with field aliasing and caching support.
-   * This is a convenience method that automatically selects all distinct columns from the specified table with caching enabled.
-   *
-   * @template T - The type of the table
-   * @param table - The table to select from
-   * @param cacheTTL - Optional cache TTL override (defaults to global cache TTL)
-   * @returns Select distinct query builder with all table columns, field aliasing, and caching support
-   * @example
-   * ```typescript
-   * const uniqueUsers = await forgeSQL.selectDistinctCacheableFrom(userTable, 300).where(eq(userTable.status, 'active'));
-   * ```
-   */
-  selectDistinctCacheableFrom(table, cacheTTL) {
-    return this.ormInstance.getDrizzleQueryBuilder().selectDistinctFromCacheable(table, cacheTTL);
-  }
-  executeWithCacheContext(cacheContext) {
-    return this.ormInstance.executeWithCacheContext(cacheContext);
-  }
-  executeWithCacheContextAndReturnValue(cacheContext) {
-    return this.ormInstance.executeWithCacheContextAndReturnValue(cacheContext);
-  }
-  /**
-   * Executes operations within a local cache context.
-   * This provides in-memory caching for select queries within a single request scope.
-   *
-   * @param cacheContext - Function containing operations that will benefit from local caching
-   * @returns Promise that resolves when all operations are complete
-   */
-  executeWithLocalContext(cacheContext) {
-    return this.ormInstance.executeWithLocalContext(cacheContext);
-  }
-  /**
-   * Executes operations within a local cache context and returns a value.
-   * This provides in-memory caching for select queries within a single request scope.
-   *
-   * @param cacheContext - Function containing operations that will benefit from local caching
-   * @returns Promise that resolves to the return value of the cacheContext function
-   */
-  executeWithLocalCacheContextAndReturnValue(cacheContext) {
-    return this.ormInstance.executeWithLocalCacheContextAndReturnValue(cacheContext);
-  }
-  /**
-   * Creates an insert query builder.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned inserts, use `modifyWithVersioning().insert()` or `modifyWithVersioningAndEvictCache().insert()` instead.
-   *
-   * @param table - The table to insert into
-   * @returns Insert query builder (no versioning, no cache management)
-   */
-  insert(table) {
-    return this.ormInstance.insert(table);
-  }
-  /**
-   * Creates an insert query builder that automatically evicts cache after execution.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned inserts, use `modifyWithVersioning().insert()` or `modifyWithVersioningAndEvictCache().insert()` instead.
-   *
-   * @param table - The table to insert into
-   * @returns Insert query builder with automatic cache eviction (no versioning)
-   */
-  insertAndEvictCache(table) {
-    return this.ormInstance.insertAndEvictCache(table);
-  }
-  /**
-   * Creates an update query builder.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned updates, use `modifyWithVersioning().updateById()` or `modifyWithVersioningAndEvictCache().updateById()` instead.
-   *
-   * @param table - The table to update
-   * @returns Update query builder (no versioning, no cache management)
-   */
-  update(table) {
-    return this.ormInstance.update(table);
-  }
-  /**
-   * Creates an update query builder that automatically evicts cache after execution.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned updates, use `modifyWithVersioning().updateById()` or `modifyWithVersioningAndEvictCache().updateById()` instead.
-   *
-   * @param table - The table to update
-   * @returns Update query builder with automatic cache eviction (no versioning)
-   */
-  updateAndEvictCache(table) {
-    return this.ormInstance.updateAndEvictCache(table);
-  }
-  /**
-   * Creates a delete query builder.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned deletes, use `modifyWithVersioning().deleteById()` or `modifyWithVersioningAndEvictCache().deleteById()` instead.
-   *
-   * @param table - The table to delete from
-   * @returns Delete query builder (no versioning, no cache management)
-   */
-  delete(table) {
-    return this.ormInstance.delete(table);
-  }
-  /**
-   * Creates a delete query builder that automatically evicts cache after execution.
-   *
-   * ⚠️ **IMPORTANT**: This method does NOT support optimistic locking/versioning.
-   * For versioned deletes, use `modifyWithVersioning().deleteById()` or `modifyWithVersioningAndEvictCache().deleteById()` instead.
-   *
-   * @param table - The table to delete from
-   * @returns Delete query builder with automatic cache eviction (no versioning)
-   */
-  deleteAndEvictCache(table) {
-    return this.ormInstance.deleteAndEvictCache(table);
-  }
-  /**
-   * Creates a select query with unique field aliases to prevent field name collisions in joins.
-   * This is particularly useful when working with Atlassian Forge SQL, which collapses fields with the same name in joined tables.
-   *
-   * @template TSelection - The type of the selected fields
-   * @param {TSelection} fields - Object containing the fields to select, with table schemas as values
-   * @returns {MySqlSelectBuilder<TSelection, MySql2PreparedQueryHKT>} A select query builder with unique field aliases
-   * @throws {Error} If fields parameter is empty
-   * @example
-   * ```typescript
-   * await forgeSQL
-   *   .select({user: users, order: orders})
-   *   .from(orders)
-   *   .innerJoin(users, eq(orders.userId, users.id));
-   * ```
-   */
-  select(fields) {
-    return this.ormInstance.select(fields);
-  }
-  /**
-   * Creates a distinct select query with unique field aliases to prevent field name collisions in joins.
-   * This is particularly useful when working with Atlassian Forge SQL, which collapses fields with the same name in joined tables.
-   *
-   * @template TSelection - The type of the selected fields
-   * @param {TSelection} fields - Object containing the fields to select, with table schemas as values
-   * @returns {MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>} A distinct select query builder with unique field aliases
-   * @throws {Error} If fields parameter is empty
-   * @example
-   * ```typescript
-   * await forgeSQL
-   *   .selectDistinct({user: users, order: orders})
-   *   .from(orders)
-   *   .innerJoin(users, eq(orders.userId, users.id));
-   * ```
-   */
-  selectDistinct(fields) {
-    return this.ormInstance.selectDistinct(fields);
-  }
-  /**
-   * Proxies the `modify` method from `ForgeSQLORMImpl`.
-   * @returns Modify operations.
-   */
-  modifyWithVersioning() {
-    return this.ormInstance.modifyWithVersioning();
-  }
-  /**
-   * Proxies the `fetch` method from `ForgeSQLORMImpl`.
-   * @returns Fetch operations.
-   */
-  fetch() {
-    return this.ormInstance.fetch();
-  }
-  /**
-   * Provides query analysis capabilities including EXPLAIN ANALYZE and slow query analysis.
-   * @returns {SchemaAnalyzeForgeSql} Interface for analyzing query performance
-   */
-  analyze() {
-    return this.ormInstance.analyze();
-  }
-  /**
-   * Provides schema-level SQL cacheable operations with type safety.
-   * @returns {ForgeSQLCacheOperations} Interface for executing schema-bound SQL queries
-   */
-  modifyWithVersioningAndEvictCache() {
-    return this.ormInstance.modifyWithVersioningAndEvictCache();
-  }
-  /**
-   * Returns a Drizzle query builder instance.
-   *
-   * @returns A Drizzle query builder instance for query construction only.
-   */
-  getDrizzleQueryBuilder() {
-    return this.ormInstance.getDrizzleQueryBuilder();
-  }
-  /**
-   * Executes a raw SQL query with local cache support.
-   * This method provides local caching for raw SQL queries within the current invocation context.
-   * Results are cached locally and will be returned from cache on subsequent identical queries.
-   *
-   * @param query - The SQL query to execute (SQLWrapper or string)
-   * @returns Promise with query results
-   * @example
-   * ```typescript
-   * // Using SQLWrapper
-   * const result = await forgeSQL.execute(sql`SELECT * FROM users WHERE id = ${userId}`);
-   *
-   * // Using string
-   * const result = await forgeSQL.execute("SELECT * FROM users WHERE status = 'active'");
-   * ```
-   */
-  execute(query) {
-    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) {
-    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(actions) {
-    return this.ormInstance.executeDDLActions(actions);
-  }
-  /**
-   * Executes a raw SQL query with both local and global cache support.
-   * This method provides comprehensive caching for raw SQL queries:
-   * - Local cache: Within the current invocation context
-   * - Global cache: Cross-invocation caching using @forge/kvs
-   *
-   * @param query - The SQL query to execute (SQLWrapper or string)
-   * @param cacheTtl - Optional cache TTL override (defaults to global cache TTL)
-   * @returns Promise with query results
-   * @example
-   * ```typescript
-   * // Using SQLWrapper with custom TTL
-   * const result = await forgeSQL.executeCacheable(sql`SELECT * FROM users WHERE id = ${userId}`, 300);
-   *
-   * // Using string with default TTL
-   * const result = await forgeSQL.executeCacheable("SELECT * FROM users WHERE status = 'active'");
-   * ```
-   */
-  executeCacheable(query, cacheTtl) {
-    return this.ormInstance.executeCacheable(query, cacheTtl);
-  }
-  /**
-   * 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.
-   *
-   * @returns WithBuilder for creating CTEs
-   * @example
-   * ```typescript
-   * const withQuery = forgeSQL.$with('userStats').as(
-   *   forgeSQL.getDrizzleQueryBuilder().select({ userId: users.id, count: sql<number>`count(*)` })
-   *     .from(users)
-   *     .groupBy(users.id)
-   * );
-   * ```
-   */
-  get $with() {
-    return this.ormInstance.getDrizzleQueryBuilder().$with;
-  }
-  /**
-   * Creates a query builder that uses Common Table Expressions (CTEs).
-   * CTEs allow you to define temporary named result sets that exist within the scope of a single query.
-   *
-   * @param queries - Array of CTE queries created with $with()
-   * @returns Query builder with CTE support
-   * @example
-   * ```typescript
-   * const withQuery = forgeSQL.$with('userStats').as(
-   *   forgeSQL.getDrizzleQueryBuilder().select({ userId: users.id, count: sql<number>`count(*)` })
-   *     .from(users)
-   *     .groupBy(users.id)
-   * );
-   *
-   * const result = await forgeSQL.with(withQuery)
-   *   .select({ userId: withQuery.userId, count: withQuery.count })
-   *   .from(withQuery);
-   * ```
-   */
-  with(...queries) {
-    return this.ormInstance.getDrizzleQueryBuilder().with(...queries);
-  }
-}
-const forgeDateTimeString = customType({
-  dataType() {
-    return "datetime";
-  },
-  toDriver(value) {
-    return formatDateTime(value, "yyyy-MM-dd' 'HH:mm:ss.SSS", false);
-  },
-  fromDriver(value) {
-    const format = "yyyy-MM-dd' 'HH:mm:ss.SSS";
-    return parseDateTime(value, format);
-  }
-});
-const forgeTimestampString = customType({
-  dataType() {
-    return "timestamp";
-  },
-  toDriver(value) {
-    return formatDateTime(value, "yyyy-MM-dd' 'HH:mm:ss.SSS", true);
-  },
-  fromDriver(value) {
-    const format = "yyyy-MM-dd' 'HH:mm:ss.SSS";
-    return parseDateTime(value, format);
-  }
-});
-const forgeDateString = customType({
-  dataType() {
-    return "date";
-  },
-  toDriver(value) {
-    return formatDateTime(value, "yyyy-MM-dd", false);
-  },
-  fromDriver(value) {
-    const format = "yyyy-MM-dd";
-    return parseDateTime(value, format);
-  }
-});
-const forgeTimeString = customType({
-  dataType() {
-    return "time";
-  },
-  toDriver(value) {
-    return formatDateTime(value, "HH:mm:ss.SSS", false);
-  },
-  fromDriver(value) {
-    return parseDateTime(value, "HH:mm:ss.SSS");
-  }
-});
-async function dropSchemaMigrations() {
-  try {
-    const tables = await getTables();
-    const dropStatements = generateDropTableStatements(tables, { sequence: true, table: true });
-    for (const statement of dropStatements) {
-      console.debug(`execute DDL: ${statement}`);
-      await sql.executeDDL(statement);
-    }
-    return getHttpResponse(
-      200,
-      "⚠️ All data in these tables has been permanently deleted. This operation cannot be undone."
-    );
-  } catch (error) {
-    const errorMessage = error?.debug?.sqlMessage ?? error?.debug?.message ?? error.message ?? "Unknown error occurred";
-    console.error(errorMessage);
-    return getHttpResponse(500, errorMessage);
-  }
-}
-const applySchemaMigrations = async (migration) => {
-  try {
-    if (typeof migration !== "function") {
-      throw new Error("migration is not a function");
-    }
-    console.debug("Provisioning the database");
-    await sql._provision();
-    console.debug("Running schema migrations");
-    const migrations2 = await migration(migrationRunner);
-    const successfulMigrations = await migrations2.run();
-    console.debug("Migrations applied:", successfulMigrations);
-    const migrationList = await migrationRunner.list();
-    let migrationHistory = "No migrations found";
-    if (Array.isArray(migrationList) && migrationList.length > 0) {
-      const sortedMigrations = migrationList.toSorted(
-        (a, b) => a.migratedAt.getTime() - b.migratedAt.getTime()
-      );
-      migrationHistory = sortedMigrations.map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`).join("\n");
-    }
-    console.debug("Migrations history:\nid, name, migrated_at\n", migrationHistory);
-    return {
-      headers: { "Content-Type": ["application/json"] },
-      statusCode: 200,
-      statusText: "OK",
-      body: "Migrations successfully executed"
-    };
-  } catch (error) {
-    const errorMessage = error?.cause?.context?.debug?.sqlMessage ?? error?.cause?.context?.debug?.message ?? error?.debug?.context?.sqlMessage ?? error?.debug?.context?.message ?? error.message ?? "Unknown error occurred";
-    console.error("Error during migration:", errorMessage);
-    return {
-      headers: { "Content-Type": ["application/json"] },
-      statusCode: 500,
-      statusText: "Internal Server Error",
-      body: error instanceof Error ? errorMessage : "Unknown error during migration"
-    };
-  }
-};
-async function fetchSchemaWebTrigger() {
-  try {
-    const tables = await getTables();
-    const createTableStatements = await generateCreateTableStatements(tables);
-    const sqlStatements = wrapWithForeignKeyChecks(createTableStatements);
-    return getHttpResponse(200, sqlStatements.join(";\n"));
-  } catch (error) {
-    const errorMessage = error?.debug?.sqlMessage ?? error?.debug?.message ?? error.message ?? "Unknown error occurred";
-    console.error(errorMessage);
-    return getHttpResponse(500, errorMessage);
-  }
-}
-async function generateCreateTableStatements(tables) {
-  const statements = [];
-  for (const table of tables) {
-    const createTableResult = await sql.executeDDL(`SHOW CREATE TABLE "${table}"`);
-    const createTableStatements = createTableResult.rows.filter((row) => !isSystemTable(row.Table)).map((row) => formatCreateTableStatement(row["Create Table"]));
-    statements.push(...createTableStatements);
-  }
-  return statements;
-}
-function isSystemTable(tableName) {
-  return forgeSystemTables.some((st) => getTableName(st) === tableName);
-}
-function formatCreateTableStatement(statement) {
-  return statement.replace(/"/g, "").replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS");
-}
-function wrapWithForeignKeyChecks(statements) {
-  return ["SET foreign_key_checks = 0", ...statements, "SET foreign_key_checks = 1"];
-}
-async function dropTableSchemaMigrations() {
-  try {
-    const tables = await getTables();
-    const dropStatements = generateDropTableStatements(tables, { sequence: false, table: true });
-    for (const statement of dropStatements) {
-      console.debug(`execute DDL: ${statement}`);
-      await sql.executeDDL(statement);
-    }
-    return getHttpResponse(
-      200,
-      "⚠️ All data in these tables has been permanently deleted. This operation cannot be undone."
-    );
-  } catch (error) {
-    const errorMessage = error?.debug?.sqlMessage ?? error?.debug?.message ?? error.message ?? "Unknown error occurred";
-    console.error(errorMessage);
-    return getHttpResponse(500, errorMessage);
-  }
-}
-const clearCacheSchedulerTrigger = async (options) => {
-  try {
-    const newOptions = options ?? {
-      logRawSqlQuery: false,
-      disableOptimisticLocking: false,
-      cacheTTL: 120,
-      cacheEntityName: "cache",
-      cacheEntityQueryName: "sql",
-      cacheEntityExpirationName: "expiration",
-      cacheEntityDataName: "data"
-    };
-    if (!newOptions.cacheEntityName) {
-      throw new Error("cacheEntityName is not configured");
-    }
-    await clearExpiredCache(newOptions);
-    return {
-      headers: { "Content-Type": ["application/json"] },
-      statusCode: 200,
-      statusText: "OK",
-      body: JSON.stringify({
-        success: true,
-        message: "Cache cleanup completed successfully",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })
-    };
-  } catch (error) {
-    console.error("Error during cache cleanup: ", JSON.stringify(error));
-    return {
-      headers: { "Content-Type": ["application/json"] },
-      statusCode: 500,
-      statusText: "Internal Server Error",
-      body: JSON.stringify({
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error during cache cleanup",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })
-    };
-  }
-};
-async function slowQuerySchedulerTrigger(forgeSQLORM, options) {
-  try {
-    return getHttpResponse(
-      200,
-      JSON.stringify(
-        await slowQueryPerHours(forgeSQLORM, options?.hours ?? 1, options?.timeout ?? 3e3)
-      )
-    );
-  } catch (error) {
-    const errorMessage = error?.debug?.sqlMessage ?? error?.debug?.message ?? error.message ?? "Unknown error occurred";
-    console.error(errorMessage);
-    return getHttpResponse(500, errorMessage);
-  }
-}
-const getHttpResponse = (statusCode, body) => {
-  let statusText = "";
-  if (statusCode === 200) {
-    statusText = "Ok";
-  } else {
-    statusText = "Bad Request";
-  }
-  return {
-    headers: { "Content-Type": ["application/json"] },
-    statusCode,
-    statusText,
-    body
-  };
-};
-export {
-  ForgeSQLCrudOperations,
-  ForgeSQLSelectOperations,
-  applyFromDriverTransform,
-  applySchemaMigrations,
-  clearCacheSchedulerTrigger,
-  clusterStatementsSummary,
-  clusterStatementsSummaryHistory,
-  ForgeSQLORM as default,
-  dropSchemaMigrations,
-  dropTableSchemaMigrations,
-  fetchSchemaWebTrigger,
-  forgeDateString,
-  forgeDateTimeString,
-  forgeDriver,
-  forgeSystemTables,
-  forgeTimeString,
-  forgeTimestampString,
-  formatDateTime,
-  formatLimitOffset,
-  generateDropTableStatements,
-  getHttpResponse,
-  getPrimaryKeys,
-  getTableMetadata,
-  getTables,
-  isUpdateQueryResponse,
-  mapSelectAllFieldsToAlias,
-  mapSelectFieldsWithAlias,
-  migrations,
-  nextVal,
-  parseDateTime,
-  patchDbWithSelectAliased,
-  printQueriesWithPlan,
-  slowQuery,
-  slowQueryPerHours,
-  slowQuerySchedulerTrigger,
-  statementsSummary,
-  statementsSummaryHistory,
-  withTidbHint,
-  withTimeout
-};
-//# sourceMappingURL=ForgeSQLORM.mjs.map