forge-sql-orm 2.0.8 → 2.0.10

package/README.md

@@ -11,7 +11,8 @@
 - ✅ **Automatic entity generation** from MySQL/tidb databases
 - ✅ **Automatic migration generation** from MySQL/tidb databases
 - ✅ **Drop Migrations** Generate a migration to drop all tables and clear migrations history for subsequent schema recreation
-- ✅ **Ready-to-use Migration Triggers** Built-in web triggers for applying and dropping migrations with proper error handling and security controls
+- ✅ **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
 
@@ -19,7 +20,7 @@
 
 ### 1. Direct Drizzle Usage
 ```typescript
-import { drizzle } from "drizzle-orm/mysql-core";
+import { drizzle } from "drizzle-orm/mysql-proxy";
 import { forgeDriver } from "forge-sql-orm";
 const db = drizzle(forgeDriver);
 ```
@@ -53,7 +54,7 @@ await forgeSQL
 
 ### Using Direct Drizzle
 ```typescript
-import { drizzle } from "drizzle-orm/mysql-core";
+import { drizzle } from "drizzle-orm/mysql-proxy";
 import { forgeDriver, mapSelectFieldsWithAlias } from "forge-sql-orm";
 
 const db = drizzle(forgeDriver);
@@ -71,6 +72,7 @@ await db
 - The solution automatically creates unique aliases for each field by prefixing them with the table name
 - This ensures that fields with the same name from different tables remain distinct in the query results
 
+
 ## Installation
 
 Forge-SQL-ORM is designed to work with @forge/sql and requires some additional setup to ensure compatibility within Atlassian Forge.
@@ -93,7 +95,7 @@ This will:
 If you prefer to use Drizzle ORM directly without the additional features of Forge-SQL-ORM (like optimistic locking), you can use the custom driver:
 
 ```typescript
-import { drizzle } from "drizzle-orm/mysql-core";
+import { drizzle } from "drizzle-orm/mysql-proxy";
 import { forgeDriver } from "forge-sql-orm";
 
 // Initialize drizzle with the custom driver
@@ -314,7 +316,7 @@ const forgeSQL = new ForgeSQL();
 or 
 
 ```typescript
-import { drizzle } from "drizzle-orm/mysql-core";
+import { drizzle } from "drizzle-orm/mysql-proxy";
 import { forgeDriver } from "forge-sql-orm";
 
 // Initialize drizzle with the custom driver
@@ -575,7 +577,7 @@ Commands:
 
 ## Web Triggers for Migrations
 
-Forge-SQL-ORM provides two web triggers for managing database migrations in Atlassian Forge:
+Forge-SQL-ORM provides web triggers for managing database migrations in Atlassian Forge:
 
 ### 1. Apply Migrations Trigger
 
@@ -647,12 +649,58 @@ Configure in `manifest.yml`:
        handler: index.dropMigrations
 ```
 
+### 3. Fetch Schema Trigger
+
+⚠️ **DEVELOPMENT ONLY**: This trigger is designed for development environments only and should not be used in production.
+
+This trigger retrieves the current database schema from Atlassian Forge SQL and generates SQL statements that can be used to recreate the database structure. It's useful for:
+- Development environment setup
+- Schema documentation
+- Database structure verification
+- Creating backup scripts
+
+**Security Considerations**:
+- This trigger exposes your database structure
+- It temporarily disables foreign key checks
+- It may expose sensitive table names and structures
+- Should only be used in development environments
+
+```typescript
+// Example usage in your Forge app
+import { fetchSchemaWebTrigger } from "forge-sql-orm";
+
+export const fetchSchema = async () => {
+  return fetchSchemaWebTrigger();
+};
+```
+
+Configure in `manifest.yml`:
+```yaml
+  webtrigger:
+     - key: fetch-schema
+       function: fetchSchema
+  sql:
+     - key: main
+       engine: mysql
+  function:
+     - key: fetchSchema
+       handler: index.fetchSchema
+```
+
+The response will contain SQL statements like:
+```sql
+SET foreign_key_checks = 0;
+CREATE TABLE IF NOT EXISTS users (...);
+CREATE TABLE IF NOT EXISTS orders (...);
+SET foreign_key_checks = 1;
+```
+
 ### Important Notes
 
 **Security Considerations**:
    - The drop migrations trigger should be restricted to development environments
+   - The fetch schema trigger should only be used in development
    - Consider implementing additional authentication for these endpoints
-   - Use the `security` section in `manifest.yml` to control access
 
 **Best Practices**:
    - Always backup your data before using the drop migrations trigger
@@ -660,7 +708,6 @@ Configure in `manifest.yml`:
    - Use these triggers as part of your deployment pipeline
    - Monitor the execution logs in the Forge Developer Console
 
-
 ## License
 This project is licensed under the **MIT License**.  
 Feel free to use it for commercial and personal projects.

package/dist/ForgeSQLORM.js

@@ -5,7 +5,7 @@ const moment = require("moment");
 const table = require("drizzle-orm/table");
 const sql = require("drizzle-orm/sql/sql");
 const sql$1 = require("@forge/sql");
-const mysql2 = require("drizzle-orm/mysql2");
+const mysqlProxy = require("drizzle-orm/mysql-proxy");
 const mysqlCore = require("drizzle-orm/mysql-core");
 const moment$1 = require("moment/moment.js");
 const parseDateTime = (value, format) => {
@@ -524,25 +524,29 @@ class ForgeSQLSelectOperations {
     return updateQueryResponseResults.rows;
   }
 }
-const forgeDriver = {
-  query: async (query, params) => {
-    try {
-      const sqlStatement = await sql$1.sql.prepare(query.sql);
+const forgeDriver = async (query, params, method) => {
+  try {
+    if (method == "execute") {
+      const sqlStatement = sql$1.sql.prepare(query);
+      if (params) {
+        sqlStatement.bindParams(...params);
+      }
+      const updateQueryResponseResults = await sqlStatement.execute();
+      let result = updateQueryResponseResults.rows;
+      return { ...result, rows: [result] };
+    } else {
+      const sqlStatement = await sql$1.sql.prepare(query);
       if (params) {
         await sqlStatement.bindParams(...params);
       }
       const result = await sqlStatement.execute();
       let rows;
-      if (Array.isArray(result.rows)) {
-        rows = [result.rows.map((r) => Object.values(r))];
-      } else {
-        rows = [result.rows];
-      }
-      return rows;
-    } catch (error) {
-      console.error("SQL Error:", JSON.stringify(error));
-      throw error;
+      rows = result.rows.map((r) => Object.values(r));
+      return { rows };
     }
+  } catch (error) {
+    console.error("SQL Error:", JSON.stringify(error));
+    throw error;
   }
 };
 class ForgeSQLORMImpl {
@@ -563,7 +567,7 @@ class ForgeSQLORMImpl {
       if (newOptions.logRawSqlQuery) {
         console.debug("Initializing ForgeSQLORM...");
       }
-      this.drizzle = mysql2.drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery });
+      this.drizzle = mysqlProxy.drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery });
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {
@@ -611,7 +615,7 @@ class ForgeSQLORMImpl {
   /**
    * 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
@@ -633,7 +637,7 @@ class ForgeSQLORMImpl {
   /**
    * 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
@@ -661,7 +665,7 @@ class ForgeSQLORM {
   /**
    * 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
@@ -680,7 +684,7 @@ class ForgeSQLORM {
   /**
    * 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
@@ -790,8 +794,8 @@ const applySchemaMigrations = async (migration) => {
   console.log("Provisioning the database");
   await sql$1.sql._provision();
   console.info("Running schema migrations");
-  const migrations = await migration(sql$1.migrationRunner);
-  const successfulMigrations = await migrations.run();
+  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);
@@ -802,6 +806,46 @@ const applySchemaMigrations = async (migration) => {
     body: "Migrations successfully executed"
   };
 };
+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();
+    const createTableStatements = await generateCreateTableStatements(tables);
+    const sqlStatements = wrapWithForeignKeyChecks(createTableStatements);
+    return getHttpResponse(200, sqlStatements.join(";\n"));
+  } catch (error) {
+    console.error(JSON.stringify(error));
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    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 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) => table.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"];
+}
 const getHttpResponse = (statusCode, body) => {
   let statusText = "";
   if (statusCode === 200) {
@@ -822,6 +866,7 @@ exports.applySchemaMigrations = applySchemaMigrations;
 exports.default = ForgeSQLORM;
 exports.dropSchemaMigrations = dropSchemaMigrations;
 exports.extractAlias = extractAlias;
+exports.fetchSchemaWebTrigger = fetchSchemaWebTrigger;
 exports.forgeDateString = forgeDateString;
 exports.forgeDateTimeString = forgeDateTimeString;
 exports.forgeDriver = forgeDriver;