17807157011

Committed 17 Sep 2025 06:30PM UTC coverage: 87.32% (+0.04%) from 87.284%

Build # 17807157011

Build Type

push

github

Committed by

vzakharchenko

Commit Message

improved logging

Coverage Stats

460 of 555 branches covered (82.88%)

Branch coverage included in aggregate %.

45 of 62 new or added lines in 9 files covered. (72.58%)

1 existing line in 1 file now uncovered.

2026 of 2292 relevant lines covered (88.39%)

14.97 hits per line

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

92.31

/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: any) {
    const errorMessage =
      error?.debug?.sqlMessage ??
      error?.debug?.message ??
      error.message ??
      "Unknown error occurred";
    console.error(errorMessage);
    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";	1✔
2	import { getHttpResponse, TriggerResponse } from "./index";	1✔
3	import { forgeSystemTables, getTables } from "../core/SystemTables";	1✔
4	import { getTableName } from "drizzle-orm/table";	1✔
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>> {	2✔
37	try {	2✔
38	const tables = await getTables();	2✔
39	const createTableStatements = await generateCreateTableStatements(tables);	1✔
40	const sqlStatements = wrapWithForeignKeyChecks(createTableStatements);	1✔
41
42	return getHttpResponse<string>(200, sqlStatements.join(";\n"));	1✔
43	} catch (error: any) {	1✔
44	const errorMessage =	1✔
45	error?.debug?.sqlMessage ??	1!
46	error?.debug?.message ??	1!
47	error.message ??	1!
NEW 48	"Unknown error occurred";	×
49	console.error(errorMessage);	1✔
50	return getHttpResponse<string>(500, errorMessage);	1✔
51	}	1✔
52	}	2✔
53
54	/**
55	* Generates CREATE TABLE statements for each table
56	*/
57	async function generateCreateTableStatements(tables: string[]): Promise<string[]> {	1✔
58	const statements: string[] = [];	1✔
59
60	for (const table of tables) {	1✔
61	const createTableResult = await sql.executeDDL<CreateTableRow>(`SHOW CREATE TABLE "${table}"`);	2✔
62
63	const createTableStatements = createTableResult.rows	2✔
64	.filter((row) => !isSystemTable(row.Table))	2✔
65	.map((row) => formatCreateTableStatement(row["Create Table"]));	2✔
66
67	statements.push(...createTableStatements);	2✔
68	}	2✔
69
70	return statements;	1✔
71	}	1✔
72
73	/**
74	* Checks if the table is a system table
75	*/
76	function isSystemTable(tableName: string): boolean {	4✔
77	return forgeSystemTables.some((st) => getTableName(st) === tableName);	4✔
78	}	4✔
79
80	/**
81	* Formats the CREATE TABLE statement
82	*/
83	function formatCreateTableStatement(statement: string): string {	4✔
84	return statement.replace(/"/g, "").replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS");	4✔
85	}	4✔
86
87	/**
88	* Wraps the SQL statements with foreign key check controls
89	*/
90	function wrapWithForeignKeyChecks(statements: string[]): string[] {	1✔
91	return ["SET foreign_key_checks = 0", ...statements, "SET foreign_key_checks = 1"];	1✔
92	}	1✔

vzakharchenko / forge-sql-orm / 17807157011

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