forge-sql-orm 2.0.7 → 2.0.9

package/src/core/ForgeSQLORM.ts

@@ -6,8 +6,11 @@ import {
   SchemaSqlForgeSql,
 } from "./ForgeSQLQueryBuilder";
 import { ForgeSQLSelectOperations } from "./ForgeSQLSelectOperations";
-import { drizzle } from "drizzle-orm/mysql2";
+import { drizzle, MySqlRemoteDatabase, MySqlRemotePreparedQueryHKT } from "drizzle-orm/mysql-proxy";
 import { forgeDriver } from "../utils/forgeDriver";
+import type { SelectedFields } from "drizzle-orm/mysql-core/query-builders/select.types";
+import { mapSelectFieldsWithAlias } from "../utils/sqlUtils";
+import { MySqlSelectBuilder } from "drizzle-orm/mysql-core";
 
 /**
  * Implementation of ForgeSQLORM that uses Drizzle ORM for query building.
@@ -34,7 +37,7 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
         console.debug("Initializing ForgeSQLORM...");
       }
       // Initialize Drizzle instance with our custom driver
-      this.drizzle = drizzle(forgeDriver);
+      this.drizzle = drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery });
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {
@@ -80,22 +83,118 @@ class ForgeSQLORMImpl implements ForgeSqlOperation {
    *
    * @returns A Drizzle query builder instance for query construction only.
    */
-  getDrizzleQueryBuilder() {
+  getDrizzleQueryBuilder(): MySqlRemoteDatabase<Record<string, unknown>> {
     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<TSelection extends SelectedFields>(
+    fields: TSelection,
+  ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT> {
+    if (!fields) {
+      throw new Error("fields is empty");
+    }
+    return this.drizzle.select(mapSelectFieldsWithAlias(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<TSelection extends SelectedFields>(
+    fields: TSelection,
+  ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT> {
+    if (!fields) {
+      throw new Error("fields is empty");
+    }
+    return this.drizzle.selectDistinct(mapSelectFieldsWithAlias(fields));
+  }
 }
 
 /**
  * Public class that acts as a wrapper around the private ForgeSQLORMImpl.
  * Provides a clean interface for working with Forge SQL and Drizzle ORM.
  */
-class ForgeSQLORM {
+class ForgeSQLORM implements ForgeSqlOperation {
   private readonly ormInstance: ForgeSqlOperation;
 
   constructor(options?: ForgeSqlOrmOptions) {
     this.ormInstance = ForgeSQLORMImpl.getInstance(options);
   }
 
+  /**
+   * 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<TSelection extends SelectedFields>(
+    fields: TSelection,
+  ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT> {
+    return this.ormInstance.getDrizzleQueryBuilder().select(mapSelectFieldsWithAlias(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<TSelection extends SelectedFields>(
+    fields: TSelection,
+  ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT> {
+    return this.ormInstance
+      .getDrizzleQueryBuilder()
+      .selectDistinct(mapSelectFieldsWithAlias(fields));
+  }
+
   /**
    * Proxies the `crud` method from `ForgeSQLORMImpl`.
    * @returns CRUD operations.

package/src/core/ForgeSQLQueryBuilder.ts

@@ -1,11 +1,19 @@
 import { UpdateQueryResponse } from "@forge/sql";
 import { SqlParameters } from "@forge/sql/out/sql-statement";
-import { MySql2Database } from "drizzle-orm/mysql2/driver";
-import { AnyMySqlSelectQueryBuilder, AnyMySqlTable, customType } from "drizzle-orm/mysql-core";
-import { MySqlSelectDynamic } from "drizzle-orm/mysql-core/query-builders/select.types";
+import {
+  AnyMySqlSelectQueryBuilder,
+  AnyMySqlTable,
+  customType,
+  MySqlSelectBuilder,
+} from "drizzle-orm/mysql-core";
+import {
+  MySqlSelectDynamic,
+  type SelectedFields,
+} from "drizzle-orm/mysql-core/query-builders/select.types";
 import { InferInsertModel, SQL } from "drizzle-orm";
 import moment from "moment/moment";
 import { parseDateTime } from "../utils/sqlUtils";
+import { MySqlRemoteDatabase, MySqlRemotePreparedQueryHKT } from "drizzle-orm/mysql-proxy/index";
 
 // ============= Core Types =============
 
@@ -36,7 +44,15 @@ export interface QueryBuilderForgeSql {
    * Creates a new query builder for the given entity.
    * @returns {MySql2Database<Record<string, unknown>>} The Drizzle database instance for building queries
    */
-  getDrizzleQueryBuilder(): MySql2Database<Record<string, unknown>>;
+  getDrizzleQueryBuilder(): MySqlRemoteDatabase<Record<string, unknown>>;
+
+  select<TSelection extends SelectedFields>(
+    fields: TSelection,
+  ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>;
+
+  selectDistinct<TSelection extends SelectedFields>(
+    fields: TSelection,
+  ): MySqlSelectBuilder<TSelection, MySqlRemotePreparedQueryHKT>;
 }
 
 // ============= CRUD Operations =============
@@ -189,12 +205,6 @@ export interface ForgeSqlOrmOptions {
    * @default false
    */
   logRawSqlQuery?: boolean;
-  /**
-   * Enables logging of raw SQL queries in the Atlassian Forge Developer Console.
-   * Useful for debugging and monitoring SQL operations.
-   * @default false
-   */
-  logRawSqlQueryParams?: boolean;
 
   /**
    * Disables optimistic locking for all operations.

package/src/core/ForgeSQLSelectOperations.ts

@@ -57,13 +57,12 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
    */
   async executeRawSQL<T extends object | unknown>(query: string, params?: unknown[]): Promise<T[]> {
     if (this.options.logRawSqlQuery) {
-      console.debug("Executing raw SQL: " + query);
+      console.debug(
+        `Executing with SQL ${query}` + params ? `, with params: ${JSON.stringify(params)}` : "",
+      );
     }
     const sqlStatement = sql.prepare<T>(query);
     if (params) {
-      if (this.options.logRawSqlQuery && this.options.logRawSqlQueryParams) {
-        console.debug("Executing with SQL Params: " + JSON.stringify(params));
-      }
       sqlStatement.bindParams(...params);
     }
     const result = await sqlStatement.execute();
@@ -81,6 +80,13 @@ export class ForgeSQLSelectOperations implements SchemaSqlForgeSql {
     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;
   }

package/src/utils/forgeDriver.ts

@@ -1,34 +1,39 @@
-import { sql } from "@forge/sql";
-import {AnyMySql2Connection} from "drizzle-orm/mysql2/driver";
+import { sql, UpdateQueryResponse } from "@forge/sql";
 
 interface ForgeSQLResult {
-    rows: Record<string, unknown>[] | Record<string, unknown>;
+  rows: Record<string, unknown>[] | Record<string, unknown>;
 }
 
-export const forgeDriver = {
-    query: async (query: { sql: string }, params?: unknown[]) => {
-        try {
-            const sqlStatement = await sql.prepare<unknown>(query.sql);
-            if (params) {
-                await sqlStatement.bindParams(...params);
-            }
-            const result = await sqlStatement.execute() as ForgeSQLResult;
-
-            let rows;
-            if (Array.isArray(result.rows)) {
-                rows = [
-                    result.rows.map(r => Object.values(r as Record<string, unknown>))
-                ];
-            } else {
-                rows = [
-                    result.rows as Record<string, unknown>
-                ];
-            }
-
-            return rows;
-        } catch (error) {
-            console.error("SQL Error:", JSON.stringify(error));
-            throw error;
-        }
+export const forgeDriver = async (
+  query: string,
+  params: any[],
+  method: "all" | "execute",
+): Promise<{
+  rows: any[];
+  insertId?: number;
+  affectedRows?: number;
+}> => {
+  try {
+    if (method == "execute") {
+      const sqlStatement = sql.prepare<UpdateQueryResponse>(query);
+      if (params) {
+        sqlStatement.bindParams(...params);
+      }
+      const updateQueryResponseResults = await sqlStatement.execute();
+      let result = updateQueryResponseResults.rows as any;
+      return { ...result, rows: [result] };
+    } else {
+      const sqlStatement = await sql.prepare<unknown>(query);
+      if (params) {
+        await sqlStatement.bindParams(...params);
+      }
+      const result = (await sqlStatement.execute()) as ForgeSQLResult;
+      let rows;
+      rows = (result.rows as any[]).map((r) => Object.values(r as Record<string, unknown>));
+      return { rows: rows };
     }
-} as unknown as AnyMySql2Connection;
+  } catch (error) {
+    console.error("SQL Error:", JSON.stringify(error));
+    throw error;
+  }
+};

package/src/utils/sqlUtils.ts

@@ -1,11 +1,15 @@
 import moment from "moment";
-import { AnyColumn } from "drizzle-orm";
+import { AnyColumn, Column, isTable, sql } from "drizzle-orm";
 import { AnyMySqlTable } from "drizzle-orm/mysql-core/index";
 import { PrimaryKeyBuilder } from "drizzle-orm/mysql-core/primary-keys";
 import { AnyIndexBuilder } from "drizzle-orm/mysql-core/indexes";
 import { CheckBuilder } from "drizzle-orm/mysql-core/checks";
 import { ForeignKeyBuilder } from "drizzle-orm/mysql-core/foreign-keys";
 import { UniqueConstraintBuilder } from "drizzle-orm/mysql-core/unique-constraint";
+import type { SelectedFields } from "drizzle-orm/mysql-core/query-builders/select.types";
+import { MySqlTable } from "drizzle-orm/mysql-core";
+import { getTableName } from "drizzle-orm/table";
+import { isSQLWrapper } from "drizzle-orm/sql/sql";
 
 /**
  * Interface representing table metadata information
@@ -113,7 +117,7 @@ export function getPrimaryKeys<T extends AnyMySqlTable>(table: T): [string, AnyC
 function processForeignKeys(
   table: AnyMySqlTable,
   foreignKeysSymbol: symbol | undefined,
-  extraSymbol: symbol | undefined
+  extraSymbol: symbol | undefined,
 ): ForeignKeyBuilder[] {
   const foreignKeys: ForeignKeyBuilder[] = [];
 
@@ -122,7 +126,7 @@ function processForeignKeys(
     // @ts-ignore
     const fkArray: any[] = table[foreignKeysSymbol];
     if (fkArray) {
-      fkArray.forEach(fk => {
+      fkArray.forEach((fk) => {
         if (fk.reference) {
           const item = fk.reference(fk);
           foreignKeys.push(item);
@@ -148,7 +152,7 @@ function processForeignKeys(
           if (!builder?.constructor) return;
 
           const builderName = builder.constructor.name.toLowerCase();
-          if (builderName.includes('foreignkeybuilder')) {
+          if (builderName.includes("foreignkeybuilder")) {
             foreignKeys.push(builder);
           }
         });
@@ -242,7 +246,7 @@ export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
 export function generateDropTableStatements(tables: AnyMySqlTable[]): string[] {
   const dropStatements: string[] = [];
 
-  tables.forEach(table => {
+  tables.forEach((table) => {
     const tableMetadata = getTableMetadata(table);
     if (tableMetadata.tableName) {
       dropStatements.push(`DROP TABLE IF EXISTS \`${tableMetadata.tableName}\`;`);
@@ -254,3 +258,49 @@ export function generateDropTableStatements(tables: AnyMySqlTable[]): string[] {
 
   return dropStatements;
 }
+
+export function mapSelectTableToAlias(table: MySqlTable): any {
+  const { columns, tableName } = getTableMetadata(table);
+  const selectionsTableFields: Record<string, unknown> = {};
+  Object.keys(columns).forEach((name) => {
+    const column = columns[name] as AnyColumn;
+    const fieldAlias = sql.raw(`${tableName}_${column.name}`);
+    selectionsTableFields[name] = sql`${column} as \`${fieldAlias}\``;
+  });
+  return selectionsTableFields;
+}
+
+function isDrizzleColumn(column: any): boolean {
+  return column && typeof column === "object" && "table" in column;
+}
+
+export function mapSelectAllFieldsToAlias(selections: any, name: string, fields: any): any {
+  if (isTable(fields)) {
+    selections[name] = mapSelectTableToAlias(fields as MySqlTable);
+  } else if (isDrizzleColumn(fields)) {
+    const column = fields as Column;
+    let aliasName = sql.raw(`${getTableName(column.table)}_${column.name}`);
+    selections[name] = sql`${column} as \`${aliasName}\``;
+  } else if (isSQLWrapper(fields)) {
+    selections[name] = fields;
+  } else {
+    const innerSelections: any = {};
+    Object.entries(fields).forEach(([iname, ifields]) => {
+      mapSelectAllFieldsToAlias(innerSelections, iname, ifields);
+    });
+    selections[name] = innerSelections;
+  }
+  return selections;
+}
+export function mapSelectFieldsWithAlias<TSelection extends SelectedFields>(
+  fields: TSelection,
+): TSelection {
+  if (!fields) {
+    throw new Error("fields is empty");
+  }
+  const selections: any = {};
+  Object.entries(fields).forEach(([name, fields]) => {
+    mapSelectAllFieldsToAlias(selections, name, fields);
+  });
+  return selections;
+}

package/src/webtriggers/applyMigrationsWebTrigger.ts

@@ -1,7 +1,9 @@
-import {migrationRunner, sql} from "@forge/sql";
-import {MigrationRunner} from "@forge/sql/out/migration";
+import { migrationRunner, sql } from "@forge/sql";
+import { MigrationRunner } from "@forge/sql/out/migration";
 
-export const applySchemaMigrations = async (migration: (migrationRunner:MigrationRunner )=>Promise<MigrationRunner>) => {
+export const applySchemaMigrations = async (
+  migration: (migrationRunner: MigrationRunner) => Promise<MigrationRunner>,
+) => {
   console.log("Provisioning the database");
   await sql._provision();
   console.info("Running schema migrations");
@@ -10,8 +12,8 @@ export const applySchemaMigrations = async (migration: (migrationRunner:Migratio
   console.info("Migrations applied:", successfulMigrations);
 
   const migrationHistory = (await migrationRunner.list())
-      .map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`)
-      .join("\n");
+    .map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`)
+    .join("\n");
 
   console.info("Migrations history:\nid, name, migrated_at\n", migrationHistory);
 
@@ -22,4 +24,3 @@ export const applySchemaMigrations = async (migration: (migrationRunner:Migratio
     body: "Migrations successfully executed",
   };
 };
-

package/src/webtriggers/dropMigrationWebTrigger.ts

@@ -1,14 +1,7 @@
 import { sql } from "@forge/sql";
 import { AnyMySqlTable } from "drizzle-orm/mysql-core";
-import { generateDropTableStatements as generateStatements, getTableMetadata } from "../utils/sqlUtils";
-import {getHttpResponse, TriggerResponse} from "./index";
-
-export interface DropTablesResponse {
-  message: string;
-  droppedTables: string[];
-  warning?: string;
-}
-
+import { generateDropTableStatements as generateStatements } from "../utils/sqlUtils";
+import { getHttpResponse, TriggerResponse } from "./index";
 
 /**
  * ⚠️ WARNING: This web trigger will permanently delete all data in the specified tables.
@@ -19,7 +12,7 @@ export interface DropTablesResponse {
  * @returns Trigger response with execution status and list of dropped tables
  */
 export async function dropSchemaMigrations(
-  tables: AnyMySqlTable[]
+  tables: AnyMySqlTable[],
 ): Promise<TriggerResponse<string>> {
   try {
     // Generate drop statements
@@ -31,17 +24,12 @@ export async function dropSchemaMigrations(
       await sql.executeDDL(statement);
     }
 
-    // Get list of dropped tables
-    const droppedTables = tables
-      .map(table => {
-        const metadata = getTableMetadata(table);
-        return metadata.tableName;
-      })
-      .filter(Boolean);
-
-    return getHttpResponse<string>(200,  "⚠️ All data in these tables has been permanently deleted. This operation cannot be undone.");
+    return getHttpResponse<string>(
+      200,
+      "⚠️ All data in these tables has been permanently deleted. This operation cannot be undone.",
+    );
   } catch (error: unknown) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
     return getHttpResponse<string>(500, errorMessage);
   }
 }

package/src/webtriggers/index.ts

@@ -1,26 +1,25 @@
-
-export * from './dropMigrationWebTrigger'
-export * from './applyMigrationsWebTrigger'
+export * from "./dropMigrationWebTrigger";
+export * from "./applyMigrationsWebTrigger";
 
 export interface TriggerResponse<BODY> {
-    body?: BODY;
-    headers?: Record<string, string[]>;
-    statusCode: number;
-    statusText?: string;
+  body?: BODY;
+  headers?: Record<string, string[]>;
+  statusCode: number;
+  statusText?: string;
 }
 
 export const getHttpResponse = <Body>(statusCode: number, body: Body): TriggerResponse<Body> => {
-    let statusText = "";
-    if (statusCode === 200) {
-        statusText = "Ok";
-    } else {
-        statusText = "Bad Request";
-    }
+  let statusText = "";
+  if (statusCode === 200) {
+    statusText = "Ok";
+  } else {
+    statusText = "Bad Request";
+  }
 
-    return {
-        headers: { "Content-Type": ["application/json"] },
-        statusCode,
-        statusText,
-        body,
-    };
-};
+  return {
+    headers: { "Content-Type": ["application/json"] },
+    statusCode,
+    statusText,
+    body,
+  };
+};