forge-sql-orm 2.0.9 → 2.0.11

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,11 +20,11 @@
 
 ### 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);
 ```
-Best for: Simple CRUD operations without optimistic locking. Note that you need to manually set `mapSelectFieldsWithAlias` for select fields to prevent field name collisions in Atlassian Forge SQL.
+Best for: Simple CRUD operations without optimistic locking. Note that you need to manually patch drizzle `patchDbWithSelectAliased` for select fields to prevent field name collisions in Atlassian Forge SQL.
 
 ### 2. Full Forge-SQL-ORM Usage
 ```typescript
@@ -53,14 +54,14 @@ await forgeSQL
 
 ### Using Direct Drizzle
 ```typescript
-import { drizzle } from "drizzle-orm/mysql-core";
-import { forgeDriver, mapSelectFieldsWithAlias } from "forge-sql-orm";
+import { drizzle } from "drizzle-orm/mysql-proxy";
+import { forgeDriver, patchDbWithSelectAliased } from "forge-sql-orm";
 
-const db = drizzle(forgeDriver);
+const db = patchDbWithSelectAliased(drizzle(forgeDriver));
 
 // Manual field name collision prevention
 await db
-  .select(mapSelectFieldsWithAlias({user: users, order: orders}))
+  .selectAliased({user: users, order: orders})
   .from(orders)
   .innerJoin(users, eq(orders.userId, users.id));
 ```
@@ -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.
@@ -94,10 +96,10 @@ If you prefer to use Drizzle ORM directly without the additional features of For
 
 ```typescript
 import { drizzle } from "drizzle-orm/mysql-proxy";
-import { forgeDriver } from "forge-sql-orm";
+import { forgeDriver, patchDbWithSelectAliased } from "forge-sql-orm";
 
-// Initialize drizzle with the custom driver
-const db = drizzle(forgeDriver);
+// Initialize drizzle with the custom driver and patch it for aliased selects
+const db = patchDbWithSelectAliased(drizzle(forgeDriver));
 
 // Use drizzle directly
 const users = await db.select().from(users);
@@ -377,7 +379,6 @@ const result = await db
 
 ### Complex Queries
 ```js
-
 // Using joins with automatic field name collision prevention
 // With forgeSQL
 const orderWithUser = await forgeSQL
@@ -386,9 +387,9 @@ const orderWithUser = await forgeSQL
   .innerJoin(users, eq(orders.userId, users.id));
 
 // OR with direct drizzle
-const db = drizzle(forgeDriver);
+const db = patchDbWithSelectAliased(drizzle(forgeDriver));
 const orderWithUser = await db
-  .select(mapSelectFieldsWithAlias({user: users, order: orders}))
+  .selectAliased({user: users, order: orders})
   .from(orders)
   .innerJoin(users, eq(orders.userId, users.id));
 // Returns: { 
@@ -398,33 +399,11 @@ const orderWithUser = await db
 //   order_product: "Product 1"
 // }
 
-// Using distinct select with automatic field name collision prevention
-const uniqueOrdersWithUsers = await forgeSQL
-  .selectDistinct({user: users, order: orders})
-  .from(orders)
-  .innerJoin(users, eq(orders.userId, users.id));
-
-// Finding duplicates
-// With forgeSQL
-const duplicates = await forgeSQL
-  .getDrizzleQueryBuilder()
-  .select({
-    name: Users.name,
-    count: sql<number>`COUNT(*) as \`count\``
-  }).from(Users)
-  .groupBy(Users.name)
-  .having(sql`COUNT(*) > 1`);
-
-// OR with direct drizzle
-const db = drizzle(forgeDriver);
-const duplicates = await db
-  .select({
-    name: Users.name,
-    count: sql<number>`COUNT(*) as \`count\``
-  }).from(Users)
-  .groupBy(Users.name)
-  .having(sql`COUNT(*) > 1`);
-// Returns: { name: "John Doe", count: 2 }
+// Using distinct with aliases
+const uniqueUsers = await db
+  .selectAliasedDistinct({user: users})
+  .from(users);
+// Returns unique users with aliased fields
 
 // Using executeQueryOnlyOne for unique results
 const userStats = await forgeSQL
@@ -575,7 +554,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,10 +626,57 @@ 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
 
 **Best Practices**:
@@ -659,7 +685,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

@@ -131,32 +131,36 @@ function generateDropTableStatements(tables) {
   dropStatements.push(`DELETE FROM __migrations;`);
   return dropStatements;
 }
-function mapSelectTableToAlias(table2) {
+function mapSelectTableToAlias(table2, aliasMap) {
   const { columns, tableName } = getTableMetadata(table2);
   const selectionsTableFields = {};
   Object.keys(columns).forEach((name) => {
     const column = columns[name];
-    const fieldAlias = drizzleOrm.sql.raw(`${tableName}_${column.name}`);
+    const uniqName = `a_${tableName}_${column.name}`;
+    const fieldAlias = drizzleOrm.sql.raw(uniqName);
     selectionsTableFields[name] = drizzleOrm.sql`${column} as \`${fieldAlias}\``;
+    aliasMap[uniqName] = column;
   });
   return selectionsTableFields;
 }
 function isDrizzleColumn(column) {
   return column && typeof column === "object" && "table" in column;
 }
-function mapSelectAllFieldsToAlias(selections, name, fields) {
+function mapSelectAllFieldsToAlias(selections, name, fields, aliasMap) {
   if (drizzleOrm.isTable(fields)) {
-    selections[name] = mapSelectTableToAlias(fields);
+    selections[name] = mapSelectTableToAlias(fields, aliasMap);
   } else if (isDrizzleColumn(fields)) {
     const column = fields;
-    let aliasName = drizzleOrm.sql.raw(`${table.getTableName(column.table)}_${column.name}`);
+    const uniqName = `a_${table.getTableName(column.table)}_${column.name}`;
+    let aliasName = drizzleOrm.sql.raw(uniqName);
     selections[name] = drizzleOrm.sql`${column} as \`${aliasName}\``;
+    aliasMap[uniqName] = column;
   } else if (sql.isSQLWrapper(fields)) {
     selections[name] = fields;
   } else {
     const innerSelections = {};
     Object.entries(fields).forEach(([iname, ifields]) => {
-      mapSelectAllFieldsToAlias(innerSelections, iname, ifields);
+      mapSelectAllFieldsToAlias(innerSelections, iname, ifields, aliasMap);
     });
     selections[name] = innerSelections;
   }
@@ -166,11 +170,65 @@ function mapSelectFieldsWithAlias(fields) {
   if (!fields) {
     throw new Error("fields is empty");
   }
+  const aliasMap = {};
   const selections = {};
   Object.entries(fields).forEach(([name, fields2]) => {
-    mapSelectAllFieldsToAlias(selections, name, fields2);
+    mapSelectAllFieldsToAlias(selections, name, fields2, aliasMap);
+  });
+  return { selections, aliasMap };
+}
+function getAliasFromDrizzleAlias(value) {
+  const isSQL = value !== null && typeof value === "object" && sql.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 (sql.isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {
+        const aliasNameChunkSql = aliasNameChunk;
+        if (aliasNameChunkSql && aliasNameChunkSql.queryChunks.length === 1) {
+          const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];
+          if (queryChunksStringChunc && "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" && !sql.isSQLWrapper(selection)) {
+      result[key] = transformObject(value, selection, aliasMap);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function applyFromDriverTransform(rows, selections, aliasMap) {
+  return rows.map((row) => {
+    return transformObject(row, selections, aliasMap);
   });
-  return selections;
 }
 class ForgeSQLCrudOperations {
   forgeOperations;
@@ -549,6 +607,52 @@ const forgeDriver = async (query, params, method) => {
     throw error;
   }
 };
+function createAliasedSelectBuilder(db, fields, selectFn) {
+  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) => target.execute().then(
+            (rows) => {
+              const transformed = applyFromDriverTransform(rows, selections, aliasMap);
+              return onfulfilled?.(transformed);
+            },
+            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);
+}
+function patchDbWithSelectAliased(db) {
+  db.selectAliased = function(fields) {
+    return createAliasedSelectBuilder(db, fields, (selections) => db.select(selections));
+  };
+  db.selectAliasedDistinct = function(fields) {
+    return createAliasedSelectBuilder(db, fields, (selections) => db.selectDistinct(selections));
+  };
+  return db;
+}
 class ForgeSQLORMImpl {
   static instance = null;
   drizzle;
@@ -567,7 +671,7 @@ class ForgeSQLORMImpl {
       if (newOptions.logRawSqlQuery) {
         console.debug("Initializing ForgeSQLORM...");
       }
-      this.drizzle = mysqlProxy.drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery });
+      this.drizzle = patchDbWithSelectAliased(mysqlProxy.drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery }));
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {
@@ -632,7 +736,7 @@ class ForgeSQLORMImpl {
     if (!fields) {
       throw new Error("fields is empty");
     }
-    return this.drizzle.select(mapSelectFieldsWithAlias(fields));
+    return this.drizzle.selectAliased(fields);
   }
   /**
    * Creates a distinct select query with unique field aliases to prevent field name collisions in joins.
@@ -654,7 +758,7 @@ class ForgeSQLORMImpl {
     if (!fields) {
       throw new Error("fields is empty");
     }
-    return this.drizzle.selectDistinct(mapSelectFieldsWithAlias(fields));
+    return this.drizzle.selectAliasedDistinct(fields);
   }
 }
 class ForgeSQLORM {
@@ -679,7 +783,7 @@ class ForgeSQLORM {
    * ```
    */
   select(fields) {
-    return this.ormInstance.getDrizzleQueryBuilder().select(mapSelectFieldsWithAlias(fields));
+    return this.ormInstance.select(fields);
   }
   /**
    * Creates a distinct select query with unique field aliases to prevent field name collisions in joins.
@@ -698,7 +802,7 @@ class ForgeSQLORM {
    * ```
    */
   selectDistinct(fields) {
-    return this.ormInstance.getDrizzleQueryBuilder().selectDistinct(mapSelectFieldsWithAlias(fields));
+    return this.ormInstance.selectDistinct(fields);
   }
   /**
    * Proxies the `crud` method from `ForgeSQLORMImpl`.
@@ -794,8 +898,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);
@@ -806,6 +910,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,10 +966,12 @@ const getHttpResponse = (statusCode, body) => {
 };
 exports.ForgeSQLCrudOperations = ForgeSQLCrudOperations;
 exports.ForgeSQLSelectOperations = ForgeSQLSelectOperations;
+exports.applyFromDriverTransform = applyFromDriverTransform;
 exports.applySchemaMigrations = applySchemaMigrations;
 exports.default = ForgeSQLORM;
 exports.dropSchemaMigrations = dropSchemaMigrations;
 exports.extractAlias = extractAlias;
+exports.fetchSchemaWebTrigger = fetchSchemaWebTrigger;
 exports.forgeDateString = forgeDateString;
 exports.forgeDateTimeString = forgeDateTimeString;
 exports.forgeDriver = forgeDriver;
@@ -837,6 +983,6 @@ exports.getPrimaryKeys = getPrimaryKeys;
 exports.getTableMetadata = getTableMetadata;
 exports.mapSelectAllFieldsToAlias = mapSelectAllFieldsToAlias;
 exports.mapSelectFieldsWithAlias = mapSelectFieldsWithAlias;
-exports.mapSelectTableToAlias = mapSelectTableToAlias;
 exports.parseDateTime = parseDateTime;
+exports.patchDbWithSelectAliased = patchDbWithSelectAliased;
 //# sourceMappingURL=ForgeSQLORM.js.map