14385988882

Committed 10 Apr 2025 04:53PM UTC coverage: 79.009% (+2.5%) from 76.514%

Build # 14385988882

Build Type

Pull #41

github

Committed by

web-flow

Commit Message

Merge 4ed548675 into 0fa3fd4a5

Pull Request Pull Request #41: 2.0.19

Run Details

223 of 278 branches covered (80.22%)

Branch coverage included in aggregate %.

183 of 212 new or added lines in 7 files covered. (86.32%)

2 existing lines in 2 files now uncovered.

925 of 1175 relevant lines covered (78.72%)

19.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

11.11

/src/webtriggers/fetchSchemaWebTrigger.ts

import { sql } from "@forge/sql";
import { getHttpResponse, TriggerResponse } from "./index";
import { forgeSystemTables, getTables } from "../core/SystemTables";
import { getTableName } from "drizzle-orm/table";

interface CreateTableRow {
  Table: string;
  "Create Table": string;
}

/**
 * ⚠️ DEVELOPMENT ONLY WEB TRIGGER ⚠️
 *
 * This web trigger retrieves the current database schema from Atlassian Forge SQL.
 * It generates SQL statements that can be used to recreate the database structure.
 *
 * @warning This trigger should ONLY be used in development environments. It:
 * - Exposes your database structure
 * - Disables foreign key checks temporarily
 * - Generates SQL that could potentially be used maliciously
 * - May expose sensitive table names and structures
 *
 * @returns {Promise<TriggerResponse<string>>} A response containing SQL statements to recreate the database schema
 * - On success: Returns 200 status with SQL statements
 * - On failure: Returns 500 status with error message
 *
 * @example
 * ```typescript
 * // The response will contain SQL statements like:
 * // SET foreign_key_checks = 0;
 * // CREATE TABLE IF NOT EXISTS users (...);
 * // CREATE TABLE IF NOT EXISTS orders (...);
 * // SET foreign_key_checks = 1;
 * ```
 */
export async function fetchSchemaWebTrigger(): Promise<TriggerResponse<string>> {
  try {
    const tables = await getTables();
    const createTableStatements = await generateCreateTableStatements(tables);
    const sqlStatements = wrapWithForeignKeyChecks(createTableStatements);

    return getHttpResponse<string>(200, sqlStatements.join(";\n"));
  } catch (error: unknown) {
    console.error(JSON.stringify(error));
    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
    return getHttpResponse<string>(500, errorMessage);
  }
}

/**
 * Generates CREATE TABLE statements for each table
 */
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 createTableStatements = createTableResult.rows
      .filter((row) => !isSystemTable(row.Table))
      .map((row) => formatCreateTableStatement(row["Create Table"]));

    statements.push(...createTableStatements);
  }

  return statements;
}

/**
 * Checks if the table is a system table
 */
function isSystemTable(tableName: string): boolean {
  return forgeSystemTables.some((st) => getTableName(st) === tableName);
}

/**
 * Formats the CREATE TABLE statement
 */
function formatCreateTableStatement(statement: string): string {
  return statement.replace(/"/g, "").replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS");
}

/**
 * Wraps the SQL statements with foreign key check controls
 */
function wrapWithForeignKeyChecks(statements: string[]): string[] {
  return ["SET foreign_key_checks = 0", ...statements, "SET foreign_key_checks = 1"];
}

1	import { sql } from "@forge/sql";	2✔
2	import { getHttpResponse, TriggerResponse } from "./index";	2✔
3	import { forgeSystemTables, getTables } from "../core/SystemTables";	2✔
4	import { getTableName } from "drizzle-orm/table";	2✔
5
6	interface CreateTableRow {
7	Table: string;
8	"Create Table": string;
9	}
10
11	/**
12	* ⚠️ DEVELOPMENT ONLY WEB TRIGGER ⚠️
13	*
14	* This web trigger retrieves the current database schema from Atlassian Forge SQL.
15	* It generates SQL statements that can be used to recreate the database structure.
16	*
17	* @warning This trigger should ONLY be used in development environments. It:
18	* - Exposes your database structure
19	* - Disables foreign key checks temporarily
20	* - Generates SQL that could potentially be used maliciously
21	* - May expose sensitive table names and structures
22	*
23	* @returns {Promise<TriggerResponse<string>>} A response containing SQL statements to recreate the database schema
24	* - On success: Returns 200 status with SQL statements
25	* - On failure: Returns 500 status with error message
26	*
27	* @example
28	* ```typescript
29	* // The response will contain SQL statements like:
30	* // SET foreign_key_checks = 0;
31	* // CREATE TABLE IF NOT EXISTS users (...);
32	* // CREATE TABLE IF NOT EXISTS orders (...);
33	* // SET foreign_key_checks = 1;
34	* ```
35	*/
36	export async function fetchSchemaWebTrigger(): Promise<TriggerResponse<string>> {	×
37	try {	×
38	const tables = await getTables();	×
39	const createTableStatements = await generateCreateTableStatements(tables);	×
40	const sqlStatements = wrapWithForeignKeyChecks(createTableStatements);	×
41
42	return getHttpResponse<string>(200, sqlStatements.join(";\n"));	×
43	} catch (error: unknown) {	×
44	console.error(JSON.stringify(error));	×
45	const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";	×
46	return getHttpResponse<string>(500, errorMessage);	×
47	}	×
48	}	×
49
50	/**
51	* Generates CREATE TABLE statements for each table
52	*/
53	async function generateCreateTableStatements(tables: string[]): Promise<string[]> {	×
54	const statements: string[] = [];	×
55
56	for (const table of tables) {	×
NEW 57	const createTableResult = await sql.executeDDL<CreateTableRow>(`SHOW CREATE TABLE "${table}"`);	×
58
59	const createTableStatements = createTableResult.rows	×
60	.filter((row) => !isSystemTable(row.Table))	×
61	.map((row) => formatCreateTableStatement(row["Create Table"]));	×
62
63	statements.push(...createTableStatements);	×
64	}	×
65
66	return statements;	×
67	}	×
68
69	/**
70	* Checks if the table is a system table
71	*/
72	function isSystemTable(tableName: string): boolean {	×
73	return forgeSystemTables.some((st) => getTableName(st) === tableName);	×
74	}	×
75
76	/**
77	* Formats the CREATE TABLE statement
78	*/
79	function formatCreateTableStatement(statement: string): string {	×
80	return statement.replace(/"/g, "").replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS");	×
81	}	×
82
83	/**
84	* Wraps the SQL statements with foreign key check controls
85	*/
86	function wrapWithForeignKeyChecks(statements: string[]): string[] {	×
87	return ["SET foreign_key_checks = 0", ...statements, "SET foreign_key_checks = 1"];	×
88	}	×

vzakharchenko / forge-sql-orm / 14385988882

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous