forge-sql-orm 2.0.18 → 2.0.19

package/src/core/ForgeSQLQueryBuilder.ts

@@ -10,40 +10,61 @@ import {
   MySqlSelectDynamic,
   type SelectedFields,
 } from "drizzle-orm/mysql-core/query-builders/select.types";
-import { InferInsertModel, SQL } from "drizzle-orm";
+import { InferInsertModel, Query, SQL } from "drizzle-orm";
 import moment from "moment/moment";
 import { parseDateTime } from "../utils/sqlUtils";
 import { MySqlRemoteDatabase, MySqlRemotePreparedQueryHKT } from "drizzle-orm/mysql-proxy/index";
 import { SqlHints } from "../utils/sqlHints";
-
-// ============= Core Types =============
+import {
+  ClusterStatementRowCamelCase,
+  ExplainAnalyzeRow,
+  SlowQueryNormalized,
+} from "./SystemTables";
 
 /**
- * Interface representing the main ForgeSQL operations.
- * Provides access to CRUD operations and schema-level SQL operations.
+ * Core interface for ForgeSQL operations.
+ * Provides access to CRUD operations, schema-level SQL operations, and query analysis capabilities.
+ *
+ * @interface ForgeSqlOperation
+ * @extends {QueryBuilderForgeSql}
  */
 export interface ForgeSqlOperation extends QueryBuilderForgeSql {
   /**
-   * Provides CRUD (Create, Read, Update, Delete) operations.
+   * Provides CRUD (Create, Update, Delete) operations.
+   * @deprecated Use modify() instead for better type safety and consistency
    * @returns {CRUDForgeSQL} Interface for performing CRUD operations
    */
   crud(): CRUDForgeSQL;
 
   /**
-   * Provides schema-level SQL fetch operations.
+   * Provides modify (Create, Update, Delete) operations with optimistic locking support.
+   * @returns {CRUDForgeSQL} Interface for performing CRUD operations
+   */
+  modify(): CRUDForgeSQL;
+
+  /**
+   * Provides schema-level SQL fetch operations with type safety.
    * @returns {SchemaSqlForgeSql} Interface for executing schema-bound SQL queries
    */
   fetch(): SchemaSqlForgeSql;
+
+  /**
+   * Provides query analysis capabilities including EXPLAIN ANALYZE and slow query analysis.
+   * @returns {SchemaAnalyzeForgeSql} Interface for analyzing query performance
+   */
+  analyze(): SchemaAnalyzeForgeSql;
 }
 
 /**
  * Interface for Query Builder operations.
- * Provides access to the underlying Drizzle ORM query builder.
+ * Provides access to the underlying Drizzle ORM query builder with enhanced functionality.
+ *
+ * @interface QueryBuilderForgeSql
  */
 export interface QueryBuilderForgeSql {
   /**
    * Creates a new query builder for the given entity.
-   * @returns {MySql2Database<Record<string, unknown>>} The Drizzle database instance for building queries
+   * @returns {MySqlRemoteDatabase<Record<string, unknown>>} The Drizzle database instance for building queries
    */
   getDrizzleQueryBuilder(): MySqlRemoteDatabase<Record<string, unknown>>;
 
@@ -88,18 +109,18 @@ export interface QueryBuilderForgeSql {
   ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>;
 }
 
-// ============= CRUD Operations =============
-
 /**
- * Interface for CRUD (Create, Read, Update, Delete) operations.
+ * Interface for Modify (Create, Update, Delete) operations.
  * Provides methods for basic database operations with support for optimistic locking.
+ *
+ * @interface CRUDForgeSQL
  */
 export interface CRUDForgeSQL {
   /**
    * Inserts multiple records into the database.
    * @template T - The type of the table schema
    * @param {T} schema - The entity schema
-   * @param {<InferInsertModel<T>[]} models - The list of entities to insert
+   * @param {InferInsertModel<T>[]} models - The list of entities to insert
    * @param {boolean} [updateIfExists] - Whether to update the row if it already exists (default: false)
    * @returns {Promise<number>} The number of inserted rows
    * @throws {Error} If the insert operation fails
@@ -159,11 +180,81 @@ export interface CRUDForgeSQL {
   ): Promise<number>;
 }
 
-// ============= Schema SQL Operations =============
+/**
+ * Interface for schema analysis operations.
+ * Provides methods for analyzing query performance and execution plans.
+ *
+ * @interface SchemaAnalyzeForgeSql
+ */
+export interface SchemaAnalyzeForgeSql {
+  /**
+   * Executes EXPLAIN on a Drizzle query.
+   * @param {{ toSQL: () => Query }} query - The Drizzle query to analyze
+   * @returns {Promise<ExplainAnalyzeRow[]>} The execution plan analysis results
+   */
+  explain(query: { toSQL: () => Query }): Promise<ExplainAnalyzeRow[]>;
+
+  /**
+   * 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
+   */
+  explainRaw(query: string, bindParams: unknown[]): Promise<ExplainAnalyzeRow[]>;
+
+  /**
+   * Executes EXPLAIN ANALYZE on a Drizzle query.
+   * @param {{ toSQL: () => Query }} query - The Drizzle query to analyze
+   * @returns {Promise<ExplainAnalyzeRow[]>} The execution plan analysis results
+   */
+  explainAnalyze(query: { toSQL: () => Query }): Promise<ExplainAnalyzeRow[]>;
+
+  /**
+   * 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
+   */
+  explainAnalyzeRaw(query: string, bindParams: unknown[]): Promise<ExplainAnalyzeRow[]>;
+
+  /**
+   * Analyzes slow queries from the database.
+   * @returns {Promise<SlowQueryNormalized[]>} The normalized slow query data
+   */
+  analyzeSlowQueries(): Promise<SlowQueryNormalized[]>;
+
+  /**
+   * 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
+   */
+  analyzeQueriesHistory(
+    tables: AnyMySqlTable[],
+    fromDate?: Date,
+    toDate?: Date,
+  ): Promise<ClusterStatementRowCamelCase[]>;
+
+  /**
+   * 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
+   */
+  analyzeQueriesHistoryRaw(
+    tables: string[],
+    fromDate?: Date,
+    toDate?: Date,
+  ): Promise<ClusterStatementRowCamelCase[]>;
+}
 
 /**
  * Interface for schema-level SQL operations.
  * Provides methods for executing SQL queries with schema binding and type safety.
+ *
+ * @interface SchemaSqlForgeSql
  */
 export interface SchemaSqlForgeSql {
   /**
@@ -200,11 +291,11 @@ export interface SchemaSqlForgeSql {
   executeRawUpdateSQL(query: string, params?: unknown[]): Promise<UpdateQueryResponse>;
 }
 
-// ============= Configuration Types =============
-
 /**
  * Interface for version field metadata.
  * Defines the configuration for optimistic locking version fields.
+ *
+ * @interface VersionFieldMetadata
  */
 export interface VersionFieldMetadata {
   /** Name of the version field */
@@ -214,6 +305,8 @@ export interface VersionFieldMetadata {
 /**
  * Interface for table metadata.
  * Defines the configuration for a specific table.
+ *
+ * @interface TableMetadata
  */
 export interface TableMetadata {
   /** Name of the table */
@@ -225,11 +318,15 @@ export interface TableMetadata {
 /**
  * Type for additional metadata configuration.
  * Maps table names to their metadata configuration.
+ *
+ * @type {AdditionalMetadata}
  */
 export type AdditionalMetadata = Record<string, TableMetadata>;
 
 /**
  * Interface for ForgeSQL ORM options
+ *
+ * @interface ForgeSqlOrmOptions
  */
 export interface ForgeSqlOrmOptions {
   /** Whether to log raw SQL queries */
@@ -259,11 +356,11 @@ export interface ForgeSqlOrmOptions {
   additionalMetadata?: AdditionalMetadata;
 }
 
-// ============= Custom Types =============
-
 /**
  * Custom type for MySQL datetime fields.
  * Handles conversion between JavaScript Date objects and MySQL datetime strings.
+ *
+ * @type {CustomType}
  */
 export const forgeDateTimeString = customType<{
   data: Date;
@@ -285,6 +382,8 @@ export const forgeDateTimeString = customType<{
 /**
  * Custom type for MySQL timestamp fields.
  * Handles conversion between JavaScript Date objects and MySQL timestamp strings.
+ *
+ * @type {CustomType}
  */
 export const forgeTimestampString = customType<{
   data: Date;
@@ -306,6 +405,8 @@ export const forgeTimestampString = customType<{
 /**
  * Custom type for MySQL date fields.
  * Handles conversion between JavaScript Date objects and MySQL date strings.
+ *
+ * @type {CustomType}
  */
 export const forgeDateString = customType<{
   data: Date;
@@ -327,6 +428,8 @@ export const forgeDateString = customType<{
 /**
  * Custom type for MySQL time fields.
  * Handles conversion between JavaScript Date objects and MySQL time strings.
+ *
+ * @type {CustomType}
  */
 export const forgeTimeString = customType<{
   data: Date;

package/src/core/ForgeSQLSelectOperations.ts

@@ -57,9 +57,8 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
    */
   async executeRawSQL<T extends object | unknown>(query: string, params?: unknown[]): Promise<T[]> {
     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.prepare<T>(query);
     if (params) {
@@ -82,9 +81,8 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
     }
     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();

package/src/core/SystemTables.ts

@@ -1,5 +1,6 @@
 import { bigint, mysqlTable, timestamp, varchar } from "drizzle-orm/mysql-core";
 import { Table } from "drizzle-orm";
+import { sql } from "@forge/sql";
 
 export const migrations = mysqlTable("__migrations", {
   id: bigint("id", { mode: "number" }).primaryKey().autoincrement(),
@@ -7,4 +8,178 @@ export const migrations = mysqlTable("__migrations", {
   migratedAt: timestamp("migratedAt").defaultNow().notNull(),
 });
 
+export interface ExplainAnalyzeRow {
+  id: string;
+  estRows?: string;
+  estCost?: string;
+  actRows?: string;
+  task?: string;
+  accessObject?: string;
+  executionInfo?: string;
+  operatorInfo?: string;
+  memory?: string;
+  disk?: string;
+}
+
+export interface SlowQueryNormalized {
+  time: string;
+  txnStartTs: number;
+  user: string;
+  host: string;
+  connId: number;
+  db: string;
+  query: string;
+  digest: string;
+  queryTime: number;
+  compileTime: number;
+  optimizeTime: number;
+  processTime: number;
+  waitTime: number;
+  parseTime: number;
+  rewriteTime: number;
+  copTime: number;
+  copProcAvg: number;
+  copProcMax: number;
+  copProcP90: number;
+  copProcAddr: string;
+  copWaitAvg: number;
+  copWaitMax: number;
+  copWaitP90: number;
+  copWaitAddr: string;
+  memMax: number;
+  diskMax: number;
+  totalKeys: number;
+  processKeys: number;
+  requestCount: number;
+  kvTotal: number;
+  pdTotal: number;
+  resultRows: number;
+  rocksdbBlockCacheHitCount: number;
+  rocksdbBlockReadCount: number;
+  rocksdbBlockReadByte: number;
+  plan: string;
+  parsedPlan?: ExplainAnalyzeRow[];
+  binaryPlan: string;
+  planDigest: string;
+}
+
+export interface ClusterStatementRowCamelCase {
+  instance: string;
+  summaryBeginTime: string;
+  summaryEndTime: string;
+  stmtType: string;
+  schemaName: string;
+  digest: string;
+  digestText: string;
+  tableNames: string;
+  indexNames: string | null;
+  sampleUser: string;
+  execCount: number;
+  sumErrors: number;
+  sumWarnings: number;
+  sumLatency: number;
+  maxLatency: number;
+  minLatency: number;
+  avgLatency: number;
+  avgParseLatency: number;
+  maxParseLatency: number;
+  avgCompileLatency: number;
+  maxCompileLatency: number;
+  sumCopTaskNum: number;
+  maxCopProcessTime: number;
+  maxCopProcessAddress: string;
+  maxCopWaitTime: number;
+  maxCopWaitAddress: string;
+  avgProcessTime: number;
+  maxProcessTime: number;
+  avgWaitTime: number;
+  maxWaitTime: number;
+  avgBackoffTime: number;
+  maxBackoffTime: number;
+  avgTotalKeys: number;
+  maxTotalKeys: number;
+  avgProcessedKeys: number;
+  maxProcessedKeys: number;
+  avgRocksdbDeleteSkippedCount: number;
+  maxRocksdbDeleteSkippedCount: number;
+  avgRocksdbKeySkippedCount: number;
+  maxRocksdbKeySkippedCount: number;
+  avgRocksdbBlockCacheHitCount: number;
+  maxRocksdbBlockCacheHitCount: number;
+  avgRocksdbBlockReadCount: number;
+  maxRocksdbBlockReadCount: number;
+  avgRocksdbBlockReadByte: number;
+  maxRocksdbBlockReadByte: number;
+  avgPrewriteTime: number;
+  maxPrewriteTime: number;
+  avgCommitTime: number;
+  maxCommitTime: number;
+  avgGetCommitTsTime: number;
+  maxGetCommitTsTime: number;
+  avgCommitBackoffTime: number;
+  maxCommitBackoffTime: number;
+  avgResolveLockTime: number;
+  maxResolveLockTime: number;
+  avgLocalLatchWaitTime: number;
+  maxLocalLatchWaitTime: number;
+  avgWriteKeys: number;
+  maxWriteKeys: number;
+  avgWriteSize: number;
+  maxWriteSize: number;
+  avgPrewriteRegions: number;
+  maxPrewriteRegions: number;
+  avgTxnRetry: number;
+  maxTxnRetry: number;
+  sumExecRetry: number;
+  sumExecRetryTime: number;
+  sumBackoffTimes: number;
+  backoffTypes: string | null;
+  avgMem: number;
+  maxMem: number;
+  avgDisk: number;
+  maxDisk: number;
+  avgKvTime: number;
+  avgPdTime: number;
+  avgBackoffTotalTime: number;
+  avgWriteSqlRespTime: number;
+  avgTidbCpuTime: number;
+  avgTikvCpuTime: number;
+  maxResultRows: number;
+  minResultRows: number;
+  avgResultRows: number;
+  prepared: number;
+  avgAffectedRows: number;
+  firstSeen: string;
+  lastSeen: string;
+  planInCache: number;
+  planCacheHits: number;
+  planInBinding: number;
+  querySampleText: string;
+  prevSampleText: string;
+  planDigest: string;
+  plan: string;
+  binaryPlan: string;
+  charset: string;
+  collation: string;
+  planHint: string;
+  maxRequestUnitRead: number;
+  avgRequestUnitRead: number;
+  maxRequestUnitWrite: number;
+  avgRequestUnitWrite: number;
+  maxQueuedRcTime: number;
+  avgQueuedRcTime: number;
+  resourceGroup: string;
+  planCacheUnqualified: number;
+  planCacheUnqualifiedLastReason: string;
+  parsedPlan?: ExplainAnalyzeRow[];
+}
+
+/**
+ * Retrieves all tables from the database
+ */
+export async function getTables(): Promise<string[]> {
+  const tables = await sql.executeDDL<string>("SHOW TABLES");
+  return tables.rows.flatMap((tableInfo) => Object.values(tableInfo));
+}
+
 export const forgeSystemTables: Table[] = [migrations];

package/src/index.ts

@@ -7,5 +7,6 @@ export * from "./utils/sqlUtils";
 export * from "./utils/forgeDriver";
 export * from "./webtriggers";
 export * from "./lib/drizzle/extensions/selectAliased";
+export * from "./core/SystemTables";
 
 export default ForgeSQLORM;

package/src/utils/forgeDriverProxy.ts

@@ -18,7 +18,7 @@ export function createForgeDriverProxy(options?: SqlHints, logRawSqlQuery?: bool
     // Inject SQL hints into the query
     const modifiedQuery = injectSqlHints(query, options);
 
-    if (options && logRawSqlQuery) {
+    if (options && logRawSqlQuery && modifiedQuery !== query) {
       console.warn("modified query: " + modifiedQuery);
     }
     // Call the original forgeDriver with the modified query

package/src/utils/sqlUtils.ts

@@ -145,7 +145,7 @@ function processForeignKeys(
         const configBuilders = Array.isArray(configBuilderData)
           ? configBuilderData
           : Object.values(configBuilderData).map(
-              (item) => (item as ConfigBuilderData).value || item,
+              (item) => (item as ConfigBuilderData).value ?? item,
             );
 
         configBuilders.forEach((builder) => {
@@ -199,7 +199,7 @@ export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
         const configBuilders = Array.isArray(configBuilderData)
           ? configBuilderData
           : Object.values(configBuilderData).map(
-              (item) => (item as ConfigBuilderData).value || item,
+              (item) => (item as ConfigBuilderData).value ?? item,
             );
 
         // Process each builder
@@ -240,22 +240,16 @@ export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
 
 /**
  * Generates SQL statements to drop tables
- * @param tables - Array of table schemas
+ * @param tables - Array of table names
  * @returns Array of SQL statements for dropping tables
  */
-export function generateDropTableStatements(tables: AnyMySqlTable[]): string[] {
+export function generateDropTableStatements(tables: string[]): string[] {
   const dropStatements: string[] = [];
 
-  tables.forEach((table) => {
-    const tableMetadata = getTableMetadata(table);
-    if (tableMetadata.tableName) {
-      dropStatements.push(`DROP TABLE IF EXISTS \`${tableMetadata.tableName}\`;`);
-    }
+  tables.forEach((tableName) => {
+    dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);
   });
 
-  // Add statement to clear migrations table
-  dropStatements.push(`DELETE FROM __migrations;`);
-
   return dropStatements;
 }
 
@@ -332,9 +326,9 @@ function getAliasFromDrizzleAlias(value: unknown): string | undefined {
       const aliasNameChunk = queryChunks[queryChunks.length - 2];
       if (isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {
         const aliasNameChunkSql = aliasNameChunk as SQL;
-        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 as StringChunk).value;
             if (values && values.length === 1) {
               return values[0];
@@ -407,7 +401,7 @@ export function applyFromDriverTransform<T, TSelection>(
 }
 
 function processNullBranches(obj: Record<string, unknown>): Record<string, unknown> | null {
-  if (obj === null || typeof obj !== "object" || obj === undefined) {
+  if (obj === null || typeof obj !== "object") {
     return obj;
   }
 
@@ -425,7 +419,7 @@ function processNullBranches(obj: Record<string, unknown>): Record<string, unkno
       continue;
     }
 
-    if (typeof value === "object" && value !== null && value !== undefined) {
+    if (typeof value === "object") {
       const processed = processNullBranches(value as Record<string, unknown>);
       result[key] = processed;
       if (processed !== null) {

package/src/webtriggers/applyMigrationsWebTrigger.ts

@@ -27,23 +27,39 @@ import { MigrationRunner } from "@forge/sql/out/migration";
 export const applySchemaMigrations = async (
   migration: (migrationRunner: MigrationRunner) => Promise<MigrationRunner>,
 ) => {
-  console.log("Provisioning the database");
-  await sql._provision();
-  console.info("Running schema migrations");
-  const migrations = await migration(migrationRunner);
-  const successfulMigrations = await migrations.run();
-  console.info("Migrations applied:", successfulMigrations);
+  try {
+    if (typeof migration !== "function") {
+      throw new Error("migration is not a function");
+    }
 
-  const migrationHistory = (await migrationRunner.list())
-    .map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`)
-    .join("\n");
+    console.log("Provisioning the database");
+    await sql._provision();
+    console.info("Running schema migrations");
+    const migrations = await migration(migrationRunner);
+    const successfulMigrations = await migrations.run();
+    console.info("Migrations applied:", successfulMigrations);
 
-  console.info("Migrations history:\nid, name, migrated_at\n", migrationHistory);
+    const migrationList = await 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";
 
-  return {
-    headers: { "Content-Type": ["application/json"] },
-    statusCode: 200,
-    statusText: "OK",
-    body: "Migrations successfully executed",
-  };
+    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",
+    };
+  }
 };

package/src/webtriggers/dropMigrationWebTrigger.ts

@@ -1,7 +1,7 @@
 import { sql } from "@forge/sql";
-import { AnyMySqlTable } from "drizzle-orm/mysql-core";
 import { generateDropTableStatements as generateStatements } from "../utils/sqlUtils";
 import { getHttpResponse, TriggerResponse } from "./index";
+import { getTables } from "../core/SystemTables";
 
 /**
  * ⚠️ DEVELOPMENT ONLY WEB TRIGGER ⚠️
@@ -15,7 +15,6 @@ import { getHttpResponse, TriggerResponse } from "./index";
  * - It may affect application functionality
  * - It could lead to data loss and system instability
  *
- * @param tables - Array of table schemas to drop
  * @returns {Promise<TriggerResponse<string>>} A response containing:
  * - On success: 200 status with warning message about permanent deletion
  * - On failure: 500 status with error message
@@ -23,14 +22,13 @@ import { getHttpResponse, TriggerResponse } from "./index";
  * @example
  * ```typescript
  * // Example usage in development only
- * await dropSchemaMigrations([users, orders]);
+ * await dropSchemaMigrations();
  * // ⚠️ Warning: This will permanently delete all data in users and orders tables
  * ```
  */
-export async function dropSchemaMigrations(
-  tables: AnyMySqlTable[],
-): Promise<TriggerResponse<string>> {
+export async function dropSchemaMigrations(): Promise<TriggerResponse<string>> {
   try {
+    const tables = await getTables();
     // Generate drop statements
     const dropStatements = generateStatements(tables);
 
@@ -45,6 +43,7 @@ export async function dropSchemaMigrations(
       "⚠️ All data in these tables has been permanently deleted. This operation cannot be undone.",
     );
   } catch (error: unknown) {
+    console.error(error);
     const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
     return getHttpResponse<string>(500, errorMessage);
   }

package/src/webtriggers/fetchSchemaWebTrigger.ts

@@ -1,6 +1,6 @@
 import { sql } from "@forge/sql";
 import { getHttpResponse, TriggerResponse } from "./index";
-import { forgeSystemTables } from "../core/SystemTables";
+import { forgeSystemTables, getTables } from "../core/SystemTables";
 import { getTableName } from "drizzle-orm/table";
 
 interface CreateTableRow {
@@ -47,14 +47,6 @@ export async function fetchSchemaWebTrigger(): Promise<TriggerResponse<string>>
   }
 }
 
-/**
- * Retrieves all tables from the database
- */
-async function getTables(): Promise<string[]> {
-  const tables = await sql.executeDDL<string>("SHOW TABLES");
-  return tables.rows.flatMap((tableInfo) => Object.values(tableInfo));
-}
-
 /**
  * Generates CREATE TABLE statements for each table
  */
@@ -62,7 +54,7 @@ async function generateCreateTableStatements(tables: string[]): Promise<string[]
   const statements: string[] = [];
 
   for (const table of tables) {
-    const createTableResult = await sql.executeDDL<CreateTableRow>(`SHOW CREATE TABLE ${table}`);
+    const createTableResult = await sql.executeDDL<CreateTableRow>(`SHOW CREATE TABLE "${table}"`);
 
     const createTableStatements = createTableResult.rows
       .filter((row) => !isSystemTable(row.Table))