@graphoria/server 0.1.0

package/src/databases/engines/mysql/connection.ts

@@ -0,0 +1,100 @@
+import { SQL } from "bun";
+
+import type { BunSQLConnectionOptions } from "../../../config";
+import type { VariableDefinition } from "../../../analyzeQuery/types";
+import type { Database } from "../../../types/configuration";
+import type { ProcedureResolver } from "../../../types/db";
+
+import { databasesConnections } from "../../../singletons/databases";
+
+export const getPool = async (db: Database) => {
+  const opts = db.connectionOptions as BunSQLConnectionOptions | undefined;
+  const pool = new SQL({
+    host: db.connection.host,
+    port: db.connection.port,
+    username: db.connection.user,
+    password: db.connection.password,
+    database: db.connection.database,
+    adapter: "mysql",
+    max: opts?.max ?? 50,
+    idleTimeout: opts?.idleTimeout ?? 30,
+    connectionTimeout: opts?.connectionTimeout,
+    maxLifetime: opts?.maxLifetime,
+    tls: opts?.tls,
+    prepare: opts?.prepare,
+    bigint: opts?.bigint,
+  });
+
+  await pool.connect(); // Connect to the database
+
+  return pool;
+};
+
+export const getPoolSingleton = async (db: Database) => databasesConnections[db.name] as SQL;
+
+export const executeQueryFactory =
+  (singleQuery = false) =>
+  async <T>(
+    query: string,
+    db: Database,
+    variablesDefinition: VariableDefinition[] = [],
+    values: Record<string, unknown> = {},
+  ) => {
+    const pool = singleQuery ? await getPool(db) : await getPoolSingleton(db);
+
+    const result = await pool.unsafe<T>(
+      query,
+      variablesDefinition.map((v) => values[v.name]),
+    );
+
+    if (singleQuery) {
+      await pool.close();
+    }
+
+    return result;
+  };
+
+export const executeQuery = executeQueryFactory();
+export const executeQuerySingle = executeQueryFactory(true);
+
+export const executeQueryJSONFactory =
+  (singleQuery = false) =>
+  async <T>(
+    query: string,
+    db: Database,
+    variablesDefinition: VariableDefinition[] = [],
+    values: Record<string, unknown> = {},
+  ) => {
+    const result = await (singleQuery ? executeQuerySingle : executeQuery)<[{ json_result: T }]>(
+      query,
+      db,
+      variablesDefinition,
+      values,
+    );
+
+    return result[0].json_result as T;
+  };
+
+export const executeQueryJSON = executeQueryJSONFactory();
+export const executeQueryJSONSingle = executeQueryJSONFactory(true);
+
+export const callStoredProcedure = async (
+  sp: ProcedureResolver,
+  variablesDefinition: VariableDefinition[],
+  variables: Record<string, unknown>,
+) => {
+  try {
+    const data = await executeQuery(
+      `CALL ${sp.dottedName}(${Object.keys(variables)
+        .map((_, i) => `$${i + 1}`)
+        .join(", ")});`,
+      sp.db!,
+      variablesDefinition,
+      variables,
+    );
+
+    return data;
+  } catch {
+    return false;
+  }
+};

package/src/databases/engines/mysql/format.ts

@@ -0,0 +1,23 @@
+import { format as sqlFormatter } from "sql-formatter";
+
+import type { AnalysisResult } from "../../../analyzeQuery/types";
+import type { MergedEntities } from "../../../configuration/getSchemas/mergeEntities";
+
+import { generateSQL } from "../../core/query-builder";
+
+export const format = (sql: string) =>
+  sqlFormatter(sql, {
+    language: "mysql",
+    paramTypes: { custom: [{ regex: String.raw`\$\d+` }] },
+  });
+
+export const genSql = (
+  entitites: MergedEntities,
+  query: AnalysisResult,
+  variables: Record<string, unknown> = {},
+  hash = false,
+) => {
+  const [[, sql]] = generateSQL(entitites, query, variables, hash);
+
+  return format(sql);
+};

package/src/databases/engines/mysql/getStructure.ts

@@ -0,0 +1,116 @@
+import type { Database } from "../../../types/configuration";
+
+import { DatabaseStructureZod } from "../../../types/zod/db";
+import { executeQueryJSONSingle } from "./connection";
+
+export const getDatabaseStructure = async (db: Database) => {
+  const res = await executeQueryJSONSingle(
+    `
+    SELECT JSON_OBJECT(
+      'tables', JSON_ARRAYAGG(
+        JSON_OBJECT(
+          'schema', t.table_schema,
+          'name', t.table_name,
+          'entityType', CASE WHEN t.table_type = 'BASE TABLE' THEN 'table' ELSE 'view' END,
+          'columns', COALESCE(col.columns, JSON_ARRAY()),
+          'foreignKeys', COALESCE(fk.fk_agg, JSON_ARRAY())
+        )
+      ),
+      'storedProcedures', COALESCE(
+        (
+          SELECT JSON_ARRAYAGG(
+            JSON_OBJECT(
+              'schema', r.routine_schema,
+              'name', r.routine_name,
+              'type', CASE r.routine_type
+                        WHEN 'FUNCTION' THEN 'function'
+                        WHEN 'PROCEDURE' THEN 'procedure'
+                        ELSE 'unknown'
+                      END,
+              'parameters', COALESCE(params.param_array, JSON_ARRAY())
+            )
+          )
+          FROM information_schema.routines r
+          
+          -- Parameters
+          LEFT JOIN LATERAL (
+            SELECT JSON_ARRAYAGG(
+              JSON_OBJECT(
+                'name', p.parameter_name,
+                'dataType', p.data_type,
+                'maxLength', COALESCE(p.character_maximum_length, 0),
+                'precision', COALESCE(p.numeric_precision, 0),
+                'scale', COALESCE(p.numeric_scale, 0)
+              )
+            ) AS param_array
+            FROM information_schema.parameters p
+            WHERE p.specific_name = r.specific_name
+              AND p.specific_schema = r.routine_schema
+              AND p.parameter_name IS NOT NULL
+            ORDER BY p.ordinal_position
+          ) params ON true
+          
+          WHERE r.routine_type IN ('FUNCTION', 'PROCEDURE')
+          AND r.routine_schema NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')
+        ),
+        JSON_ARRAY()
+      )
+    ) as json_result
+    FROM (
+      SELECT table_schema, table_name, table_type
+      FROM information_schema.tables 
+      WHERE table_type IN ('BASE TABLE', 'VIEW')
+        AND table_schema NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')
+    ) t
+    LEFT JOIN LATERAL (
+      -- build an ordered JSON array of columns using GROUP_CONCAT
+      SELECT IFNULL(
+        CAST(CONCAT('[', GROUP_CONCAT(
+          JSON_OBJECT(
+            'name', isc.column_name,
+            'dataType', isc.data_type,
+            'isNullable', CASE WHEN isc.is_nullable = 'YES' THEN true ELSE false END,
+            'description', NULL
+          ) ORDER BY isc.ordinal_position SEPARATOR ','), ']') AS JSON),
+        JSON_ARRAY()
+      ) AS columns
+      FROM information_schema.columns isc
+      WHERE isc.table_schema = t.table_schema
+        AND isc.table_name = t.table_name
+    ) col ON TRUE
+    LEFT JOIN LATERAL (
+      -- aggregate FKs: first aggregate columns per constraint, then aggregate constraints
+      SELECT IFNULL(
+        CAST(CONCAT('[', GROUP_CONCAT(
+          JSON_OBJECT(
+            'schema', fk_sub.referenced_table_schema,
+            'name', fk_sub.referenced_table_name,
+            'columns', fk_sub.columns_arr
+          ) ORDER BY fk_sub.fk_name SEPARATOR ','), ']') AS JSON),
+        JSON_ARRAY()
+      ) AS fk_agg
+      FROM (
+        SELECT 
+          kcu.constraint_name AS fk_name,
+          kcu.table_schema,
+          kcu.table_name,
+          kcu.referenced_table_schema,
+          kcu.referenced_table_name,
+          CAST(CONCAT('[', GROUP_CONCAT(
+            JSON_OBJECT('source', kcu.column_name, 'target', kcu.referenced_column_name)
+            ORDER BY kcu.ordinal_position SEPARATOR ','
+          ), ']') AS JSON) AS columns_arr
+        FROM information_schema.key_column_usage kcu
+        WHERE kcu.referenced_table_schema IS NOT NULL
+          AND kcu.table_schema = t.table_schema
+          AND kcu.table_name = t.table_name
+        GROUP BY kcu.constraint_name, kcu.table_schema, kcu.table_name,
+                kcu.referenced_table_schema, kcu.referenced_table_name
+      ) fk_sub
+    ) fk ON TRUE;
+    `,
+    db,
+  );
+
+  return DatabaseStructureZod.parse(res);
+};

package/src/databases/engines/mysql/getViews.ts

@@ -0,0 +1,20 @@
+import type { Database } from "../../../types/configuration";
+import type { View } from "../../../types/db";
+
+import { executeQueryJSONSingle } from "./connection";
+
+export const getViewsFromDB = async (db: Database) =>
+  executeQueryJSONSingle<View[]>(
+    `
+    SELECT JSON_ARRAYAGG(
+      JSON_OBJECT(
+        'schema', LOWER(table_schema),
+        'name', LOWER(table_name),
+        'definition', view_definition
+      )
+    ) as json_result
+    FROM information_schema.views
+    WHERE table_schema NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys');
+    `,
+    db,
+  );

package/src/databases/engines/mysql/query/index.ts

@@ -0,0 +1,291 @@
+import type {
+  OperationAnalysis,
+  SelectionAnalysis,
+  VariableDefinition,
+} from "../../../../analyzeQuery/types";
+import type { MergedEntities } from "../../../../configuration/getSchemas/mergeEntities";
+import type { GroupByInfo } from "../../../common";
+
+import {
+  buildOrderByClauseMySQL,
+  buildPaginationClauseMySQL,
+  buildWhereClauseMySQL,
+  extractAggregationInfo,
+  filterBasedOnDirective,
+  generateTableAlias,
+  isAggregationField,
+  isSingleQuery,
+  processFieldSelectionsMySQL,
+} from "../../../common";
+
+// Generate CTE for aggregations
+const buildAggregationCTE = (
+  groupByInfo: GroupByInfo,
+  dottedName: string,
+  tableAlias: string,
+  whereClause: string,
+): string => {
+  const { groupByFields, aggregations, cteAlias } = groupByInfo;
+
+  const selectClauses: string[] = [];
+
+  // Add group by fields
+  groupByFields.forEach((field) => {
+    selectClauses.push(`${tableAlias}.${field}`);
+  });
+
+  // Add aggregations
+  aggregations.forEach((agg) => {
+    if (agg.name === "count") {
+      selectClauses.push(`COUNT(*) AS ${agg.alias}`);
+    } else {
+      const func = agg.name.toUpperCase();
+      selectClauses.push(`${func}(${tableAlias}.${agg.fieldName}) AS ${agg.alias}`);
+    }
+  });
+
+  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}.${field}`).join(", ")}`;
+
+  return `${cteAlias} AS (
+    SELECT
+      ${selectClauses.join(",\n      ")}
+    FROM ${dottedName} ${tableAlias}
+    ${whereClause}
+    ${groupByClause}
+  )`;
+};
+
+// Build the main query for grouped results
+const buildGroupedQuery = (
+  entities: MergedEntities,
+  field: SelectionAnalysis,
+  groupByInfo: GroupByInfo,
+  dottedName: string,
+  tableAlias: string,
+  whereClause: string,
+): string => {
+  const { groupByFields, aggregations, hasItems, keyResolved, hasKey, keys, cteAlias } =
+    groupByInfo;
+
+  const selectClauses: string[] = [];
+
+  if (hasKey) {
+    // Add key object with group by fields
+    const keyFields = keys
+      .map((key) => `'${key.alias || key.name}', ${cteAlias}.${key.name}`)
+      .join(", ");
+
+    selectClauses.push(`'${keyResolved}', JSON_OBJECT(${keyFields})`);
+  }
+
+  // Add aggregation results
+  aggregations.forEach((agg) => {
+    if (agg.name === "count") {
+      selectClauses.push(`'${agg.nameResolved}', ${cteAlias}.${agg.alias}`);
+    } else {
+      selectClauses.push(
+        `'${agg.nameResolved}', JSON_OBJECT('${agg.fieldAlias}', COALESCE(${cteAlias}.${agg.alias}, NULL))`,
+      );
+    }
+  });
+
+  // Add items if requested
+  if (hasItems) {
+    const itemsSelection = field.selections?.find((sel) => sel.name === "items");
+
+    if (itemsSelection?.selections) {
+      const itemFields = itemsSelection.selections
+        .filter((sel) => !isAggregationField(sel.name) && sel.name !== "items")
+        .map((sel) => `'${sel.alias || sel.name}', ${tableAlias}.${sel.name}`)
+        .join(", ");
+
+      if (itemFields) {
+        const joinConditions = groupByFields.map(
+          (field) => `${tableAlias}.${field} = ${cteAlias}.${field}`,
+        );
+
+        const whereConditions = whereClause
+          ? `${whereClause} AND ${joinConditions.join(" AND ")}`
+          : `WHERE ${joinConditions.join(" AND ")}`;
+
+        selectClauses.push(`'${itemsSelection.alias || itemsSelection.name}', COALESCE((
+          SELECT JSON_ARRAYAGG(JSON_OBJECT(${itemFields}))
+          FROM ${dottedName} ${tableAlias}
+          ${whereConditions}
+        ), JSON_ARRAY())`);
+      }
+    }
+  }
+
+  const orderByClause = buildOrderByClauseMySQL(entities, field, cteAlias);
+
+  return `SELECT JSON_ARRAYAGG(JSON_OBJECT(${selectClauses.join(",\n    ")}) ${orderByClause})
+    FROM ${cteAlias}`;
+};
+
+export const generateSQL = (
+  entities: MergedEntities,
+  operation: OperationAnalysis,
+  variables: Record<string, unknown> = {},
+  forHashMethod: boolean = false,
+): string => {
+  if (forHashMethod) {
+    return `SELECT MD5((${buildSQLForField(entities, operation.variables ?? [], variables, operation.fields[0], null, null, 1, {})})) AS ResultHash`;
+  }
+
+  const variablesWithDefault = {
+    ...operation.variables?.reduce<Record<string, unknown>>((acc, variable) => {
+      if (variable.defaultValue !== undefined) {
+        acc[variable.name] = variable.defaultValue;
+      }
+      return acc;
+    }, {}),
+    ...variables,
+  };
+
+  // Check if any field requires CTEs (has groupBy)
+  const filteredFields = operation.fields?.filter((f) =>
+    filterBasedOnDirective(f, operation.variables ?? [], variablesWithDefault),
+  );
+
+  const ctes: string[] = [];
+  const fieldQueries: string[] = [];
+
+  filteredFields?.forEach((field, index) => {
+    const tableAlias = generateTableAlias(index + 1);
+    const groupByInfo = extractAggregationInfo(field, tableAlias);
+
+    if (groupByInfo) {
+      // This field requires a CTE
+      const { dottedName } = entities.queriesMap[field.name]!;
+
+      const whereClause = buildWhereClauseMySQL(
+        entities,
+        operation.variables ?? [],
+        variablesWithDefault,
+        field,
+        tableAlias,
+        null,
+        null,
+        index + 1,
+        {},
+        false,
+      );
+
+      const cte = buildAggregationCTE(groupByInfo, dottedName, tableAlias, whereClause);
+      ctes.push(cte);
+    }
+
+    const fieldSQL = buildSQLForField(
+      entities,
+      operation.variables ?? [],
+      variablesWithDefault,
+      field,
+      null,
+      null,
+      index + 1,
+      {},
+    );
+
+    fieldQueries.push(`'${field.alias || field.name}', ${fieldSQL}`);
+  });
+
+  const cteClause = ctes.length > 0 ? `WITH\n${ctes.join(",\n")}\n` : "";
+
+  return `
+    ${cteClause}SELECT JSON_OBJECT(
+      ${fieldQueries.join(",\n")}
+    ) as json_result`;
+};
+
+export const buildSQLForField = (
+  entities: MergedEntities,
+  variablesDefinition: VariableDefinition[],
+  variables: Record<string, unknown> = {},
+  field: SelectionAnalysis,
+  parentTableName: string | null,
+  parentTableAlias: string | null,
+  level: number,
+  aliasMap: { [alias: string]: string },
+): string => {
+  const tableAlias = generateTableAlias(level);
+
+  const withoutArrayWrapper = isSingleQuery(field.name);
+
+  const foundTable = entities.queriesMap[field.name];
+
+  if (!foundTable) {
+    throw new Error(`Table not found for field: ${field.name}`);
+  }
+
+  const { dottedName, resolverName } = foundTable;
+
+  aliasMap[tableAlias] = resolverName;
+
+  const whereClause = buildWhereClauseMySQL(
+    entities,
+    variablesDefinition,
+    variables,
+    field,
+    tableAlias,
+    parentTableName,
+    parentTableAlias,
+    level,
+    aliasMap,
+    false,
+  );
+
+  // Check if this is a GROUP BY query
+  const groupByInfo = extractAggregationInfo(field, tableAlias);
+
+  if (groupByInfo) {
+    // Handle GROUP BY aggregation query
+    const mainQuery = buildGroupedQuery(
+      entities,
+      field,
+      groupByInfo,
+      dottedName,
+      tableAlias,
+      whereClause,
+    );
+
+    return `COALESCE((${mainQuery}), JSON_ARRAY())`;
+  }
+
+  // Original logic for non-aggregation queries
+  const selectList = processFieldSelectionsMySQL(
+    entities,
+    variablesDefinition,
+    variables,
+    field,
+    resolverName,
+    tableAlias,
+    level,
+    (sel, level) =>
+      buildSQLForField(
+        entities,
+        variablesDefinition,
+        variables,
+        sel,
+        resolverName,
+        tableAlias,
+        level,
+        aliasMap,
+      ),
+    ([name, selector]) => `'${name}', ${selector}`,
+    false,
+  );
+
+  const fromClause = `FROM ${dottedName} ${tableAlias}${withoutArrayWrapper ? " LIMIT 1" : ""}`;
+
+  const orderByClause = buildOrderByClauseMySQL(entities, field, tableAlias);
+  const paginationClause = buildPaginationClauseMySQL(field, variablesDefinition);
+
+  const isArraySelection = !!field.isArray && !withoutArrayWrapper;
+
+  return `
+    COALESCE((
+      SELECT ${isArraySelection ? `JSON_ARRAYAGG(JSON_OBJECT(${selectList}))` : `JSON_OBJECT(${selectList})`} ${fromClause} ${orderByClause} ${whereClause} ${paginationClause ? ` ${paginationClause}` : ""}
+    ), ${isArraySelection ? "JSON_ARRAY()" : "null"})
+  `;
+};

package/src/databases/engines/postgresql/auth.ts

@@ -0,0 +1,98 @@
+import type { SQL } from "bun";
+import type { Auth, Database } from "../../../types/configuration";
+import type { CheckUserCredentialsResult, InsertAuthUserInput } from "../../core/function-mapping";
+
+import { databasesConnections } from "../../../singletons/databases";
+import { hashPassword, verifyPassword } from "../../auth/password";
+import { assertSafeIdentifier } from "../../core/identifier";
+import { generateSchemaCreationPostgreSQL } from "../../schemaBuilder/generateSchemaCreation";
+import { parseUserClaims } from "../shared/claims";
+import type { UserRecord } from "../shared/types";
+
+export const userTableCreation = (schema: string) => `
+    CREATE TABLE IF NOT EXISTS ${assertSafeIdentifier(schema, "schema")}."user" (
+        username VARCHAR(50) PRIMARY KEY,
+        password VARCHAR(255) NOT NULL,
+        role VARCHAR(20) NOT NULL,
+        is_active BOOLEAN DEFAULT TRUE,
+        claims JSONB DEFAULT '{}'
+    );
+`;
+
+export const createAuthTables = async (auth: Auth) => {
+  const pool = databasesConnections[auth.databaseEntity.name] as SQL;
+
+  await pool.unsafe(generateSchemaCreationPostgreSQL(auth.schema!, true));
+
+  await pool.unsafe(userTableCreation(auth.schema!));
+};
+
+export const checkUserCredentials = async (
+  db: Database,
+  auth: Auth,
+  username: string,
+  password: string,
+  injectedPool?: SQL,
+): Promise<CheckUserCredentialsResult> => {
+  const pool = injectedPool ?? (databasesConnections[db.name] as SQL);
+
+  const schema = assertSafeIdentifier(auth.schema!, "schema");
+
+  const result: UserRecord[] = await pool.unsafe(
+    `SELECT * FROM ${schema}."user" WHERE username = $1 AND is_active = TRUE`,
+    [username],
+  );
+
+  if (result?.length === 0) {
+    return {
+      valid: false,
+      role: null,
+      claims: null,
+    };
+  }
+
+  const { password: hashedPassword, role, claims } = result[0];
+
+  if (!(await verifyPassword(password, hashedPassword))) {
+    return {
+      valid: false,
+      role: null,
+      claims: null,
+    };
+  }
+
+  const parsedClaims = parseUserClaims(claims);
+
+  if (parsedClaims === null) {
+    return {
+      valid: false,
+      role: null,
+      claims: null,
+    };
+  }
+
+  return { valid: true, role, claims: parsedClaims };
+};
+
+export const verifyAuthTablesExist = async (auth: Auth, injectedPool?: SQL): Promise<void> => {
+  const pool = injectedPool ?? (databasesConnections[auth.databaseEntity.name] as SQL);
+  const schema = assertSafeIdentifier(auth.schema!, "schema");
+  await pool.unsafe(`SELECT username FROM ${schema}."user" WHERE 1=0`);
+};
+
+export const insertAuthUser = async (
+  auth: Auth,
+  input: InsertAuthUserInput,
+  injectedPool?: SQL,
+): Promise<void> => {
+  const pool = injectedPool ?? (databasesConnections[auth.databaseEntity.name] as SQL);
+
+  const schema = assertSafeIdentifier(auth.schema!, "schema");
+  const hashed = await hashPassword(input.password);
+
+  await pool.unsafe(
+    `INSERT INTO ${schema}."user" (username, password, role, is_active, claims)
+       VALUES ($1, $2, $3, TRUE, $4::jsonb)`,
+    [input.username, hashed, input.role, JSON.stringify(input.claims ?? {})],
+  );
+};