forge-sql-orm 2.0.10 → 2.0.11

package/src/utils/sqlUtils.ts

@@ -1,306 +0,0 @@
-import moment from "moment";
-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
- */
-export interface MetadataInfo {
-  /** The name of the table */
-  tableName: string;
-  /** Record of column names and their corresponding column definitions */
-  columns: Record<string, AnyColumn>;
-  /** Array of index builders */
-  indexes: AnyIndexBuilder[];
-  /** Array of check constraint builders */
-  checks: CheckBuilder[];
-  /** Array of foreign key builders */
-  foreignKeys: ForeignKeyBuilder[];
-  /** Array of primary key builders */
-  primaryKeys: PrimaryKeyBuilder[];
-  /** Array of unique constraint builders */
-  uniqueConstraints: UniqueConstraintBuilder[];
-  /** Array of all extra builders */
-  extras: any[];
-}
-
-/**
- * Interface for config builder data
- */
-interface ConfigBuilderData {
-  value?: any;
-  [key: string]: any;
-}
-
-/**
- * Parses a date string into a Date object using the specified format
- * @param value - The date string to parse
- * @param format - The format to use for parsing
- * @returns Date object
- */
-export const parseDateTime = (value: string, format: string): Date => {
-  const m = moment(value, format, true);
-  if (!m.isValid()) {
-    return moment(value).toDate();
-  }
-  return m.toDate();
-};
-
-/**
- * Extracts the alias from a SQL query
- * @param query - The SQL query to extract the alias from
- * @returns The extracted alias or the original query if no alias found
- */
-export function extractAlias(query: string): string {
-  const match = query.match(/\bas\s+(['"`]?)([\w*]+)\1$/i);
-  return match ? match[2] : query;
-}
-
-/**
- * Gets primary keys from the schema.
- * @template T - The type of the table schema
- * @param {T} table - The table schema
- * @returns {[string, AnyColumn][]} Array of primary key name and column pairs
- */
-export function getPrimaryKeys<T extends AnyMySqlTable>(table: T): [string, AnyColumn][] {
-  const { columns, primaryKeys } = getTableMetadata(table);
-
-  // First try to find primary keys in columns
-  const columnPrimaryKeys = Object.entries(columns).filter(([, column]) => column.primary) as [
-    string,
-    AnyColumn,
-  ][];
-
-  if (columnPrimaryKeys.length > 0) {
-    return columnPrimaryKeys;
-  }
-
-  // If no primary keys found in columns, check primary key builders
-  if (Array.isArray(primaryKeys) && primaryKeys.length > 0) {
-    // Collect all primary key columns from all primary key builders
-    const primaryKeyColumns = new Set<[string, AnyColumn]>();
-
-    primaryKeys.forEach((primaryKeyBuilder) => {
-      // Get primary key columns from each builder
-      Object.entries(columns)
-        .filter(([, column]) => {
-          // @ts-ignore - PrimaryKeyBuilder has internal columns property
-          return primaryKeyBuilder.columns.includes(column);
-        })
-        .forEach(([name, column]) => {
-          primaryKeyColumns.add([name, column]);
-        });
-    });
-
-    return Array.from(primaryKeyColumns);
-  }
-
-  return [];
-}
-
-/**
- * Processes foreign keys from both foreignKeysSymbol and extraSymbol
- * @param table - The table schema
- * @param foreignKeysSymbol - Symbol for foreign keys
- * @param extraSymbol - Symbol for extra configuration
- * @returns Array of foreign key builders
- */
-function processForeignKeys(
-  table: AnyMySqlTable,
-  foreignKeysSymbol: symbol | undefined,
-  extraSymbol: symbol | undefined,
-): ForeignKeyBuilder[] {
-  const foreignKeys: ForeignKeyBuilder[] = [];
-
-  // Process foreign keys from foreignKeysSymbol
-  if (foreignKeysSymbol) {
-    // @ts-ignore
-    const fkArray: any[] = table[foreignKeysSymbol];
-    if (fkArray) {
-      fkArray.forEach((fk) => {
-        if (fk.reference) {
-          const item = fk.reference(fk);
-          foreignKeys.push(item);
-        }
-      });
-    }
-  }
-
-  // Process foreign keys from extraSymbol
-  if (extraSymbol) {
-    // @ts-ignore
-    const extraConfigBuilder = table[extraSymbol];
-    if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
-      const configBuilderData = extraConfigBuilder(table);
-      if (configBuilderData) {
-        const configBuilders = Array.isArray(configBuilderData)
-          ? configBuilderData
-          : Object.values(configBuilderData).map(
-              (item) => (item as ConfigBuilderData).value || item,
-            );
-
-        configBuilders.forEach((builder) => {
-          if (!builder?.constructor) return;
-
-          const builderName = builder.constructor.name.toLowerCase();
-          if (builderName.includes("foreignkeybuilder")) {
-            foreignKeys.push(builder);
-          }
-        });
-      }
-    }
-  }
-
-  return foreignKeys;
-}
-
-/**
- * Extracts table metadata from the schema.
- * @param {AnyMySqlTable} table - The table schema
- * @returns {MetadataInfo} Object containing table metadata
- */
-export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
-  const symbols = Object.getOwnPropertySymbols(table);
-  const nameSymbol = symbols.find((s) => s.toString().includes("Name"));
-  const columnsSymbol = symbols.find((s) => s.toString().includes("Columns"));
-  const foreignKeysSymbol = symbols.find((s) => s.toString().includes("ForeignKeys)"));
-  const extraSymbol = symbols.find((s) => s.toString().includes("ExtraConfigBuilder"));
-
-  // Initialize builders arrays
-  const builders = {
-    indexes: [] as AnyIndexBuilder[],
-    checks: [] as CheckBuilder[],
-    foreignKeys: [] as ForeignKeyBuilder[],
-    primaryKeys: [] as PrimaryKeyBuilder[],
-    uniqueConstraints: [] as UniqueConstraintBuilder[],
-    extras: [] as any[],
-  };
-
-  // Process foreign keys
-  builders.foreignKeys = processForeignKeys(table, foreignKeysSymbol, extraSymbol);
-
-  // Process extra configuration if available
-  if (extraSymbol) {
-    // @ts-ignore
-    const extraConfigBuilder = table[extraSymbol];
-    if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
-      const configBuilderData = extraConfigBuilder(table);
-      if (configBuilderData) {
-        // Convert configBuilderData to array if it's an object
-        const configBuilders = Array.isArray(configBuilderData)
-          ? configBuilderData
-          : Object.values(configBuilderData).map(
-              (item) => (item as ConfigBuilderData).value || item,
-            );
-
-        // Process each builder
-        configBuilders.forEach((builder) => {
-          if (!builder?.constructor) return;
-
-          const builderName = builder.constructor.name.toLowerCase();
-
-          // Map builder types to their corresponding arrays
-          const builderMap = {
-            indexbuilder: builders.indexes,
-            checkbuilder: builders.checks,
-            primarykeybuilder: builders.primaryKeys,
-            uniqueconstraintbuilder: builders.uniqueConstraints,
-          };
-
-          // Add builder to appropriate array if it matches any type
-          for (const [type, array] of Object.entries(builderMap)) {
-            if (builderName.includes(type)) {
-              array.push(builder);
-              break;
-            }
-          }
-
-          // Always add to extras array
-          builders.extras.push(builder);
-        });
-      }
-    }
-  }
-
-  return {
-    tableName: nameSymbol ? (table as any)[nameSymbol] : "",
-    columns: columnsSymbol ? ((table as any)[columnsSymbol] as Record<string, AnyColumn>) : {},
-    ...builders,
-  };
-}
-
-/**
- * Generates SQL statements to drop tables
- * @param tables - Array of table schemas
- * @returns Array of SQL statements for dropping tables
- */
-export function generateDropTableStatements(tables: AnyMySqlTable[]): string[] {
-  const dropStatements: string[] = [];
-
-  tables.forEach((table) => {
-    const tableMetadata = getTableMetadata(table);
-    if (tableMetadata.tableName) {
-      dropStatements.push(`DROP TABLE IF EXISTS \`${tableMetadata.tableName}\`;`);
-    }
-  });
-
-  // Add statement to clear migrations table
-  dropStatements.push(`DELETE FROM __migrations;`);
-
-  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,49 +0,0 @@
-import { migrationRunner, sql } from "@forge/sql";
-import { MigrationRunner } from "@forge/sql/out/migration";
-
-/**
- * Web trigger for applying database schema migrations in Atlassian Forge SQL.
- * This function handles the complete migration process including:
- * - Database provisioning
- * - Migration execution
- * - Migration history tracking
- *
- * @param migration - A function that takes a MigrationRunner instance and returns a Promise of MigrationRunner
- *                     This function should define the sequence of migrations to be applied
- * @returns {Promise<{
- *   headers: { "Content-Type": ["application/json"] },
- *   statusCode: number,
- *   statusText: string,
- *   body: string
- * }>} A response object containing:
- * - headers: Content-Type header set to application/json
- * - statusCode: 200 on success
- * - statusText: "OK" on success
- * - body: Success message or error details
- *
- * @throws {Error} If database provisioning fails
- * @throws {Error} If migration execution fails
- */
-export const applySchemaMigrations = async (
-  migration: (migrationRunner: MigrationRunner) => Promise<MigrationRunner>,
-) => {
-  console.log("Provisioning the database");
-  await sql._provision();
-  console.info("Running schema migrations");
-  const migrations = await migration(migrationRunner);
-  const successfulMigrations = await migrations.run();
-  console.info("Migrations applied:", successfulMigrations);
-
-  const migrationHistory = (await migrationRunner.list())
-    .map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`)
-    .join("\n");
-
-  console.info("Migrations history:\nid, name, migrated_at\n", migrationHistory);
-
-  return {
-    headers: { "Content-Type": ["application/json"] },
-    statusCode: 200,
-    statusText: "OK",
-    body: "Migrations successfully executed",
-  };
-};

package/src/webtriggers/dropMigrationWebTrigger.ts

@@ -1,51 +0,0 @@
-import { sql } from "@forge/sql";
-import { AnyMySqlTable } from "drizzle-orm/mysql-core";
-import { generateDropTableStatements as generateStatements } from "../utils/sqlUtils";
-import { getHttpResponse, TriggerResponse } from "./index";
-
-/**
- * ⚠️ DEVELOPMENT ONLY WEB TRIGGER ⚠️
- *
- * This web trigger is designed for development environments only and will permanently delete all data in the specified tables.
- * It generates and executes SQL statements to drop tables and their associated constraints.
- *
- * @warning This trigger should NEVER be used in production environments because:
- * - It permanently deletes all data in the specified tables
- * - The operation cannot be undone
- * - It may affect application functionality
- * - It could lead to data loss and system instability
- *
- * @param tables - Array of table schemas to drop
- * @returns {Promise<TriggerResponse<string>>} A response containing:
- * - On success: 200 status with warning message about permanent deletion
- * - On failure: 500 status with error message
- *
- * @example
- * ```typescript
- * // Example usage in development only
- * await dropSchemaMigrations([users, orders]);
- * // ⚠️ Warning: This will permanently delete all data in users and orders tables
- * ```
- */
-export async function dropSchemaMigrations(
-  tables: AnyMySqlTable[],
-): Promise<TriggerResponse<string>> {
-  try {
-    // Generate drop statements
-    const dropStatements = generateStatements(tables);
-
-    // Execute each statement
-    for (const statement of dropStatements) {
-      console.warn(statement);
-      await sql.executeDDL(statement);
-    }
-
-    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";
-    return getHttpResponse<string>(500, errorMessage);
-  }
-}

package/src/webtriggers/fetchSchemaWebTrigger.ts

@@ -1,96 +0,0 @@
-import { sql } from "@forge/sql";
-import { getHttpResponse, TriggerResponse } from "./index";
-import { forgeSystemTables } 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);
-  }
-}
-
-/**
- * Retrieves all tables from the database
- */
-async function getTables(): Promise<string[]> {
-  const tables = await sql.executeDDL<string>("SHOW TABLES");
-  return tables.rows.flatMap((tableInfo) => Object.values(tableInfo));
-}
-
-/**
- * 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"];
-}

package/src/webtriggers/index.ts

@@ -1,26 +0,0 @@
-export * from "./dropMigrationWebTrigger";
-export * from "./applyMigrationsWebTrigger";
-export * from "./fetchSchemaWebTrigger";
-
-export interface TriggerResponse<BODY> {
-  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";
-  }
-
-  return {
-    headers: { "Content-Type": ["application/json"] },
-    statusCode,
-    statusText,
-    body,
-  };
-};