forge-sql-orm 2.0.18 → 2.0.20

package/README.md

@@ -1,11 +1,23 @@
 # Forge SQL ORM
 
+[![npm version](https://img.shields.io/npm/v/forge-sql-orm)](https://www.npmjs.com/package/forge-sql-orm)
+[![npm downloads](https://img.shields.io/npm/dm/forge-sql-orm)](https://www.npmjs.com/package/forge-sql-orm)
+[![npm version (CLI)](https://img.shields.io/npm/v/forge-sql-orm-cli?label=cli)](https://www.npmjs.com/package/forge-sql-orm-cli)
+[![npm downloads (CLI)](https://img.shields.io/npm/dm/forge-sql-orm-cli?label=cli%20downloads)](https://www.npmjs.com/package/forge-sql-orm-cli)
+
+[![License](https://img.shields.io/github/license/vzakharchenko/forge-sql-orm)](https://github.com/vzakharchenko/forge-sql-orm/blob/master/LICENSE)
+
 [![forge-sql-orm CI](https://github.com/vzakharchenko/forge-sql-orm/actions/workflows/node.js.yml/badge.svg)](https://github.com/vzakharchenko/forge-sql-orm/actions/workflows/node.js.yml)
+[![Coverage Status](https://coveralls.io/repos/github/vzakharchenko/forge-sql-orm/badge.svg?branch=master)](https://coveralls.io/github/vzakharchenko/forge-sql-orm?branch=master)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=vzakharchenko_forge-sql-orm&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=vzakharchenko_forge-sql-orm)
+[![DeepScan grade](https://deepscan.io/api/teams/26652/projects/29272/branches/940614/badge/grade.svg)](https://deepscan.io/dashboard#view=project&tid=26652&pid=29272&bid=940614)
+
 
 **Forge-SQL-ORM** is an ORM designed for working with [@forge/sql](https://developer.atlassian.com/platform/forge/storage-reference/sql-tutorial/) in **Atlassian Forge**. It is built on top of [Drizzle ORM](https://orm.drizzle.team) and provides advanced capabilities for working with relational databases inside Forge.
 
 ## Key Features
 - ✅ **Custom Drizzle Driver** for direct integration with @forge/sql
+- ✅ **Type-Safe Query Building**: Write SQL queries with full TypeScript support
 - ✅ **Supports complex SQL queries** with joins and filtering using Drizzle ORM
 - ✅ **Schema migration support**, allowing automatic schema evolution
 - ✅ **Automatic entity generation** from MySQL/tidb databases
@@ -14,7 +26,7 @@
 - ✅ **Schema Fetching** Development-only web trigger to retrieve current database schema and generate SQL statements for schema recreation
 - ✅ **Ready-to-use Migration Triggers** Built-in web triggers for applying migrations, dropping tables (development-only), and fetching schema (development-only) with proper error handling and security controls
 - ✅ **Optimistic Locking** Ensures data consistency by preventing conflicts when multiple users update the same record
-- ✅ **Type Safety** Full TypeScript support with proper type inference
+- ✅ **Query Plan Analysis**: Detailed execution plan analysis and optimization insights (Performance analysis and Troubleshooting only)
 
 ## Usage Approaches
 
@@ -587,15 +599,14 @@ This trigger allows you to completely reset your database schema. It's useful fo
 - Testing scenarios requiring a clean database
 - Resetting the database before applying new migrations
 
-**Important**: The trigger will only drop tables that are defined in your models. Any tables that exist in the database but are not defined in your models will remain untouched.
+**Important**: The trigger will  drop all tables including migration.
 
 ```typescript
 // Example usage in your Forge app
 import { dropSchemaMigrations } from "forge-sql-orm";
-import * as schema from "./entities/schema";
 
 export const dropMigrations = () => {
-  return dropSchemaMigrations(Object.values(schema));
+  return dropSchemaMigrations();
 };
 ```
 
@@ -671,6 +682,86 @@ SET foreign_key_checks = 1;
    - Use these triggers as part of your deployment pipeline
    - Monitor the execution logs in the Forge Developer Console
 
+## Query Analysis and Performance Optimization
+
+⚠️ **IMPORTANT NOTE**: The query analysis features described below are experimental and should be used only for troubleshooting purposes. These features rely on TiDB's `information_schema` and `performance_schema` which may change in future updates. As of April 2025, these features are available but their future availability is not guaranteed.
+
+### About Atlassian's Built-in Analysis Tools
+
+Atlassian already provides comprehensive query analysis tools in the development console, including:
+- Basic query performance metrics
+- Slow query tracking (queries over 500ms)
+- Basic execution statistics
+- Query history and patterns
+
+Our analysis tools are designed to complement these built-in features by providing additional insights directly from TiDB's system schemas. However, they should be used with caution and only for troubleshooting purposes.
+
+### Usage Guidelines
+
+1. **Development and Troubleshooting Only**
+   - These tools should not be used in production code
+   - Intended only for development and debugging
+   - Use for identifying and fixing performance issues
+
+2. **Schema Stability**
+   - Features rely on TiDB's `information_schema` and `performance_schema`
+   - Schema structure may change in future TiDB updates
+   - No guarantee of long-term availability
+
+3. **Current Availability (April 2025)**
+   - `information_schema` based analysis is currently functional
+   - Query plan analysis is available
+   - Performance metrics collection is working
+
+### Available Analysis Tools
+
+```typescript
+import ForgeSQL from "forge-sql-orm";
+
+const forgeSQL = new ForgeSQL();
+const analyzeForgeSql = forgeSQL.analyze();
+```
+
+#### Query Plan Analysis
+
+⚠️ **For Troubleshooting Only**: This feature should only be used during development and debugging sessions.
+
+```typescript
+// Example usage for troubleshooting a specific query
+const forgeSQL = new ForgeSQL();
+const analyzeForgeSql = forgeSQL.analyze();
+
+// Analyze a Drizzle query
+const plan = await analyzeForgeSql.explain(
+  forgeSQL.select({
+    table1: testEntityJoin1,
+    table2: { name: testEntityJoin2.name, email: testEntityJoin2.email },
+    count: rawSql<number>`COUNT(*)`,
+    table3: {
+      table12: testEntityJoin1.name,
+      table22: testEntityJoin2.email,
+      table32: testEntity.id
+    },
+  })
+  .from(testEntityJoin1)
+  .innerJoin(testEntityJoin2, eq(testEntityJoin1.id, testEntityJoin2.id))
+);
+
+// Analyze a raw SQL query
+const rawPlan = await analyzeForgeSql.explainRaw(
+  "SELECT * FROM users WHERE id = ?",
+  [1]
+);
+```
+
+This analysis helps you understand:
+- How the database executes your query
+- Which indexes are being used
+- Estimated vs actual row counts
+- Resource usage at each step
+- Potential performance bottlenecks
+
+
 ## License
 This project is licensed under the **MIT License**.  
 Feel free to use it for commercial and personal projects.

package/dist/ForgeSQLORM.js

@@ -64,7 +64,7 @@ function processForeignKeys(table2, foreignKeysSymbol, extraSymbol) {
       const configBuilderData = extraConfigBuilder(table2);
       if (configBuilderData) {
         const configBuilders = Array.isArray(configBuilderData) ? configBuilderData : Object.values(configBuilderData).map(
-          (item) => item.value || item
+          (item) => item.value ?? item
         );
         configBuilders.forEach((builder) => {
           if (!builder?.constructor) return;
@@ -99,7 +99,7 @@ function getTableMetadata(table2) {
       const configBuilderData = extraConfigBuilder(table2);
       if (configBuilderData) {
         const configBuilders = Array.isArray(configBuilderData) ? configBuilderData : Object.values(configBuilderData).map(
-          (item) => item.value || item
+          (item) => item.value ?? item
         );
         configBuilders.forEach((builder) => {
           if (!builder?.constructor) return;
@@ -129,13 +129,9 @@ function getTableMetadata(table2) {
 }
 function generateDropTableStatements(tables) {
   const dropStatements = [];
-  tables.forEach((table2) => {
-    const tableMetadata = getTableMetadata(table2);
-    if (tableMetadata.tableName) {
-      dropStatements.push(`DROP TABLE IF EXISTS \`${tableMetadata.tableName}\`;`);
-    }
+  tables.forEach((tableName) => {
+    dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);
   });
-  dropStatements.push(`DELETE FROM __migrations;`);
   return dropStatements;
 }
 function mapSelectTableToAlias(table2, uniqPrefix, aliasMap) {
@@ -193,9 +189,9 @@ function getAliasFromDrizzleAlias(value) {
       const aliasNameChunk = queryChunks[queryChunks.length - 2];
       if (sql.isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {
         const aliasNameChunkSql = aliasNameChunk;
-        if (aliasNameChunkSql && aliasNameChunkSql.queryChunks.length === 1) {
+        if (aliasNameChunkSql.queryChunks?.length === 1 && aliasNameChunkSql.queryChunks[0]) {
           const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];
-          if (queryChunksStringChunc && "value" in queryChunksStringChunc) {
+          if ("value" in queryChunksStringChunc) {
             const values = queryChunksStringChunc.value;
             if (values && values.length === 1) {
               return values[0];
@@ -247,7 +243,7 @@ function applyFromDriverTransform(rows, selections, aliasMap) {
   });
 }
 function processNullBranches(obj) {
-  if (obj === null || typeof obj !== "object" || obj === void 0) {
+  if (obj === null || typeof obj !== "object") {
     return obj;
   }
   if (obj.constructor && obj.constructor.name !== "Object") {
@@ -260,7 +256,7 @@ function processNullBranches(obj) {
       result[key] = null;
       continue;
     }
-    if (typeof value === "object" && value !== null && value !== void 0) {
+    if (typeof value === "object") {
       const processed = processNullBranches(value);
       result[key] = processed;
       if (processed !== null) {
@@ -610,9 +606,8 @@ class ForgeSQLSelectOperations {
    */
   async executeRawSQL(query, params) {
     if (this.options.logRawSqlQuery) {
-      console.debug(
-        `Executing with SQL ${query}` + params ? `, with params: ${JSON.stringify(params)}` : ""
-      );
+      const paramsStr = params ? `, with params: ${JSON.stringify(params)}` : "";
+      console.debug(`Executing with SQL ${query}${paramsStr}`);
     }
     const sqlStatement = sql$1.sql.prepare(query);
     if (params) {
@@ -634,7 +629,7 @@ class ForgeSQLSelectOperations {
     }
     if (this.options.logRawSqlQuery) {
       console.debug(
-        `Executing Update with SQL ${query}` + params ? `, with params: ${JSON.stringify(params)}` : ""
+        `Executing Update with SQL ${query}` + (params ? `, with params: ${JSON.stringify(params)}` : "")
       );
     }
     const updateQueryResponseResults = await sqlStatement.execute();
@@ -699,7 +694,7 @@ function injectSqlHints(query, hints) {
 function createForgeDriverProxy(options, logRawSqlQuery) {
   return async (query, params, method) => {
     const modifiedQuery = injectSqlHints(query, options);
-    if (options && logRawSqlQuery) {
+    if (options && logRawSqlQuery && modifiedQuery !== query) {
       console.warn("modified query: " + modifiedQuery);
     }
     return forgeDriver(modifiedQuery, params, method);
@@ -748,11 +743,240 @@ function patchDbWithSelectAliased(db) {
   };
   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 formatDateTime = (date) => moment(date).format("YYYY-MM-DDTHH:mm:ss.SSS");
+    const tableConditions = tables.map((table2) => `TABLE_NAMES LIKE CONCAT(SCHEMA_NAME, '.', '%', '${table2}', '%')`).join(" OR ");
+    const timeConditions = [];
+    if (from) {
+      timeConditions.push(`SUMMARY_BEGIN_TIME >= '${formatDateTime(from)}'`);
+    }
+    if (to) {
+      timeConditions.push(`SUMMARY_END_TIME <= '${formatDateTime(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$1) => table.getTableName(table$1)) ?? [];
+    return this.analyzeQueriesHistoryRaw(tableNames, fromDate, toDate);
+  }
+}
 class ForgeSQLORMImpl {
   static instance = null;
   drizzle;
   crudOperations;
   fetchOperations;
+  analyzeOperations;
   /**
    * Private constructor to enforce singleton behavior.
    * @param options - Options for configuring ForgeSQL ORM behavior.
@@ -772,20 +996,26 @@ class ForgeSQLORMImpl {
       );
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
+      this.analyzeOperations = new ForgeSQLAnalyseOperation(this);
     } catch (error) {
       console.error("ForgeSQLORM initialization failed:", error);
       throw error;
     }
   }
+  /**
+   * Create the modify operations instance.
+   * @returns modify operations.
+   */
+  modify() {
+    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) {
-    if (!ForgeSQLORMImpl.instance) {
-      ForgeSQLORMImpl.instance = new ForgeSQLORMImpl(options);
-    }
+    ForgeSQLORMImpl.instance ??= new ForgeSQLORMImpl(options);
     return ForgeSQLORMImpl.instance;
   }
   /**
@@ -793,7 +1023,7 @@ class ForgeSQLORMImpl {
    * @returns CRUD operations.
    */
   crud() {
-    return this.crudOperations;
+    return this.modify();
   }
   /**
    * Retrieves the fetch operations instance.
@@ -802,6 +1032,9 @@ class ForgeSQLORMImpl {
   fetch() {
     return this.fetchOperations;
   }
+  analyze() {
+    return this.analyzeOperations;
+  }
   /**
    * Returns a Drizzle query builder instance.
    *
@@ -889,7 +1122,7 @@ class ForgeSQLORM {
    *
    * @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
+   * @returns {MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>} A distinct select query builder with unique field aliases
    * @throws {Error} If fields parameter is empty
    * @example
    * ```typescript
@@ -907,7 +1140,14 @@ class ForgeSQLORM {
    * @returns CRUD operations.
    */
   crud() {
-    return this.ormInstance.crud();
+    return this.ormInstance.modify();
+  }
+  /**
+   * Proxies the `modify` method from `ForgeSQLORMImpl`.
+   * @returns Modify operations.
+   */
+  modify() {
+    return this.ormInstance.modify();
   }
   /**
    * Proxies the `fetch` method from `ForgeSQLORMImpl`.
@@ -916,6 +1156,13 @@ class ForgeSQLORM {
   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();
+  }
   /**
    * Returns a Drizzle query builder instance.
    *
@@ -976,8 +1223,19 @@ const forgeTimeString = mysqlCore.customType({
     return parseDateTime(value, "HH:mm:ss.SSS");
   }
 });
-async function dropSchemaMigrations(tables) {
+const migrations = mysqlCore.mysqlTable("__migrations", {
+  id: mysqlCore.bigint("id", { mode: "number" }).primaryKey().autoincrement(),
+  name: mysqlCore.varchar("name", { length: 255 }).notNull(),
+  migratedAt: mysqlCore.timestamp("migratedAt").defaultNow().notNull()
+});
+async function getTables() {
+  const tables = await sql$1.sql.executeDDL("SHOW TABLES");
+  return tables.rows.flatMap((tableInfo) => Object.values(tableInfo));
+}
+const forgeSystemTables = [migrations];
+async function dropSchemaMigrations() {
   try {
+    const tables = await getTables();
     const dropStatements = generateDropTableStatements(tables);
     for (const statement of dropStatements) {
       console.warn(statement);
@@ -988,32 +1246,41 @@ async function dropSchemaMigrations(tables) {
       "⚠️ All data in these tables has been permanently deleted. This operation cannot be undone."
     );
   } catch (error) {
+    console.error(error);
     const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
     return getHttpResponse(500, errorMessage);
   }
 }
 const applySchemaMigrations = async (migration) => {
-  console.log("Provisioning the database");
-  await sql$1.sql._provision();
-  console.info("Running schema migrations");
-  const migrations2 = await migration(sql$1.migrationRunner);
-  const successfulMigrations = await migrations2.run();
-  console.info("Migrations applied:", successfulMigrations);
-  const migrationHistory = (await sql$1.migrationRunner.list()).map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`).join("\n");
-  console.info("Migrations history:\nid, name, migrated_at\n", migrationHistory);
-  return {
-    headers: { "Content-Type": ["application/json"] },
-    statusCode: 200,
-    statusText: "OK",
-    body: "Migrations successfully executed"
-  };
+  try {
+    if (typeof migration !== "function") {
+      throw new Error("migration is not a function");
+    }
+    console.log("Provisioning the database");
+    await sql$1.sql._provision();
+    console.info("Running schema migrations");
+    const migrations2 = await migration(sql$1.migrationRunner);
+    const successfulMigrations = await migrations2.run();
+    console.info("Migrations applied:", successfulMigrations);
+    const migrationList = await sql$1.migrationRunner.list();
+    const migrationHistory = Array.isArray(migrationList) && migrationList.length > 0 ? migrationList.map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`).join("\n") : "No migrations found";
+    console.info("Migrations history:\nid, name, migrated_at\n", migrationHistory);
+    return {
+      headers: { "Content-Type": ["application/json"] },
+      statusCode: 200,
+      statusText: "OK",
+      body: "Migrations successfully executed"
+    };
+  } catch (error) {
+    console.error("Error during migration:", error);
+    return {
+      headers: { "Content-Type": ["application/json"] },
+      statusCode: 500,
+      statusText: "Internal Server Error",
+      body: error instanceof Error ? error.message : "Unknown error during migration"
+    };
+  }
 };
-const migrations = mysqlCore.mysqlTable("__migrations", {
-  id: mysqlCore.bigint("id", { mode: "number" }).primaryKey().autoincrement(),
-  name: mysqlCore.varchar("name", { length: 255 }).notNull(),
-  migratedAt: mysqlCore.timestamp("migratedAt").defaultNow().notNull()
-});
-const forgeSystemTables = [migrations];
 async function fetchSchemaWebTrigger() {
   try {
     const tables = await getTables();
@@ -1026,14 +1293,10 @@ async function fetchSchemaWebTrigger() {
     return getHttpResponse(500, errorMessage);
   }
 }
-async function getTables() {
-  const tables = await sql$1.sql.executeDDL("SHOW TABLES");
-  return tables.rows.flatMap((tableInfo) => Object.values(tableInfo));
-}
 async function generateCreateTableStatements(tables) {
   const statements = [];
   for (const table2 of tables) {
-    const createTableResult = await sql$1.sql.executeDDL(`SHOW CREATE TABLE ${table2}`);
+    const createTableResult = await sql$1.sql.executeDDL(`SHOW CREATE TABLE "${table2}"`);
     const createTableStatements = createTableResult.rows.filter((row) => !isSystemTable(row.Table)).map((row) => formatCreateTableStatement(row["Create Table"]));
     statements.push(...createTableStatements);
   }
@@ -1072,14 +1335,17 @@ exports.fetchSchemaWebTrigger = fetchSchemaWebTrigger;
 exports.forgeDateString = forgeDateString;
 exports.forgeDateTimeString = forgeDateTimeString;
 exports.forgeDriver = forgeDriver;
+exports.forgeSystemTables = forgeSystemTables;
 exports.forgeTimeString = forgeTimeString;
 exports.forgeTimestampString = forgeTimestampString;
 exports.generateDropTableStatements = generateDropTableStatements;
 exports.getHttpResponse = getHttpResponse;
 exports.getPrimaryKeys = getPrimaryKeys;
 exports.getTableMetadata = getTableMetadata;
+exports.getTables = getTables;
 exports.mapSelectAllFieldsToAlias = mapSelectAllFieldsToAlias;
 exports.mapSelectFieldsWithAlias = mapSelectFieldsWithAlias;
+exports.migrations = migrations;
 exports.parseDateTime = parseDateTime;
 exports.patchDbWithSelectAliased = patchDbWithSelectAliased;
 //# sourceMappingURL=ForgeSQLORM.js.map