@graphoria/server 0.1.0

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

@@ -0,0 +1,99 @@
+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,
+    user: db.connection.user,
+    password: db.connection.password,
+    database: db.connection.database,
+    max: opts?.max ?? 5,
+    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(
+      `SELECT * FROM ${sp.dottedName}(${Object.keys(variables)
+        .map((_, i) => `$${i + 1}`)
+        .join(", ")});`,
+      sp.db!,
+      variablesDefinition,
+      variables,
+    );
+
+    return data;
+  } catch {
+    return false;
+  }
+};

package/src/databases/engines/postgresql/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: "postgresql",
+    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/postgresql/getStructure.ts

@@ -0,0 +1,149 @@
+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(
+    `
+    WITH tables_data AS (
+      SELECT json_agg(
+        json_build_object(
+          'schema', t.table_schema,
+          'name', t.table_name,
+          'entityType', CASE WHEN t.table_type = 'BASE TABLE' THEN 'table' ELSE 'view' END,
+          'tableDescription', t.table_description,
+          'columns', COALESCE(col.columns, '[]'::json),
+          'foreignKeys', COALESCE(fk.fk_agg, '[]'::json)
+        )
+      ) AS tables
+      FROM (
+        SELECT DISTINCT 
+          ist.table_schema, 
+          ist.table_name, 
+          ist.table_type,
+          obj_description(c.oid) AS table_description
+        FROM information_schema.tables ist
+        LEFT JOIN pg_class c ON c.relname = ist.table_name
+        LEFT JOIN pg_namespace n ON n.oid = c.relnamespace AND n.nspname = ist.table_schema
+        WHERE ist.table_type IN ('BASE TABLE', 'VIEW')
+          AND ist.table_schema NOT IN ('pg_catalog', 'information_schema')
+      ) t
+      LEFT JOIN LATERAL (
+        SELECT json_agg(
+          json_build_object(
+            'name', isc.column_name,
+            'dataType', isc.data_type,
+            'isNullable', isc.is_nullable = 'YES',
+            'description', col_desc.description
+          )
+        ) AS columns
+        FROM information_schema.columns isc
+        LEFT JOIN LATERAL (
+          SELECT col_description(c.oid, a.attnum) AS description
+          FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          JOIN pg_attribute a ON a.attrelid = c.oid
+          WHERE n.nspname = isc.table_schema
+            AND c.relname = isc.table_name
+            AND a.attname = isc.column_name
+            AND a.attnum > 0
+        ) col_desc ON true
+        WHERE isc.table_schema = t.table_schema
+          AND isc.table_name = t.table_name
+      ) col ON true
+      LEFT JOIN LATERAL (
+        SELECT json_agg(
+          json_build_object(
+            'schema', fk_sub.referenced_table_schema,
+            'name', fk_sub.referenced_table_name,
+            'columns', fk_sub.columns_arr
+          )
+        ) AS fk_agg
+        FROM (
+          SELECT 
+            kcu.constraint_name AS fk_name,
+            kcu.table_schema,
+            kcu.table_name,
+            ccu.table_schema AS referenced_table_schema,
+            ccu.table_name AS referenced_table_name,
+            json_agg(
+              json_build_object(
+                'source', kcu.column_name,
+                'target', ccu.column_name
+              )
+              ORDER BY kcu.ordinal_position
+            ) AS columns_arr
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu 
+            ON tc.constraint_name = kcu.constraint_name 
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage ccu 
+            ON tc.constraint_name = ccu.constraint_name 
+            AND tc.table_schema = ccu.table_schema
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+            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,
+                  ccu.table_schema, ccu.table_name
+        ) fk_sub
+      ) fk ON true
+    ),
+    stored_procedures_data AS (
+      SELECT COALESCE(
+        json_agg(
+          json_build_object(
+            'schema', n.nspname,
+            'name', p.proname,
+            'signature', pg_get_function_identity_arguments(p.oid),
+            'type', CASE p.prokind 
+                      WHEN 'f' THEN 'function'
+                      WHEN 'p' THEN 'procedure'
+                      WHEN 'a' THEN 'aggregate'
+                      WHEN 'w' THEN 'window'
+                      ELSE 'unknown'
+                    END,
+            'parameters', COALESCE(params.param_array, '[]'::json)
+          )
+        ),
+        '[]'::json
+      ) AS stored_procedures
+      FROM pg_proc p
+      JOIN pg_namespace n ON p.pronamespace = n.oid
+      LEFT JOIN LATERAL (
+        SELECT json_agg(
+          json_build_object(
+            'name', COALESCE(param.parameter_name, 'arg' || param.idx::text),
+            'dataType', param.data_type,
+            'maxLength', 0,
+            'precision', 0,
+            'scale', 0
+          )
+          ORDER BY param.idx
+        ) AS param_array
+        FROM (
+          SELECT  
+            row_number() OVER () AS idx,
+            arg_name AS parameter_name,
+            arg_type AS data_type
+          FROM (
+            SELECT 
+              unnest(COALESCE(p.proargnames, ARRAY[]::text[])) AS arg_name,
+              unnest(string_to_array(pg_get_function_identity_arguments(p.oid), ', ')) AS arg_type
+          ) args
+          WHERE arg_type IS NOT NULL AND arg_type != ''
+        ) param
+      ) params ON true
+      WHERE p.prokind IN ('f', 'p')
+        AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+    )
+    SELECT json_build_object(
+      'tables', COALESCE((SELECT tables FROM tables_data), '[]'::json),
+      'storedProcedures', COALESCE((SELECT stored_procedures FROM stored_procedures_data), '[]'::json)
+    ) as json_result;
+    `,
+    db,
+  );
+
+  return DatabaseStructureZod.parse(res);
+};

package/src/databases/engines/postgresql/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_agg(
+      json_build_object(
+        'schema', lower(schemaname),
+        'name', lower(viewname),
+        'definition', view_definition
+      )
+    )
+    FROM pg_views
+    WHERE schemaname NOT IN ('pg_catalog', 'information_schema');
+    `,
+    db,
+  );

package/src/databases/engines/postgresql/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 {
+  buildOrderByClausePG,
+  buildPaginationClausePG,
+  buildWhereClausePG,
+  extractAggregationInfo,
+  filterBasedOnDirective,
+  generateTableAlias,
+  isAggregationField,
+  isSingleQuery,
+  processFieldSelectionsPG,
+} from "../../../common";
+
+// Generate CTE for aggregations
+const buildAggregationCTE = (
+  groupByInfo: GroupByInfo,
+  dottedQuotedName: 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 ${dottedQuotedName} ${tableAlias}
+    ${whereClause}
+    ${groupByClause}
+  )`;
+};
+
+// Build the main query for grouped results
+const buildGroupedQuery = (
+  entities: MergedEntities,
+  field: SelectionAnalysis,
+  groupByInfo: GroupByInfo,
+  dottedQuotedName: 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_build_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_build_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_agg(json_build_object(${itemFields}))
+          FROM ${dottedQuotedName} ${tableAlias}
+          ${whereConditions}
+        ), '[]'::json)`);
+      }
+    }
+  }
+
+  const orderByClause = buildOrderByClausePG(entities, field, cteAlias);
+
+  return `SELECT json_agg(json_build_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, {})})::text) 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 { dottedQuotedName } = entities.queriesMap[field.name]!;
+
+      const whereClause = buildWhereClausePG(
+        entities,
+        operation.variables ?? [],
+        variablesWithDefault,
+        field,
+        tableAlias,
+        null,
+        null,
+        index + 1,
+        {},
+        true,
+      );
+
+      const cte = buildAggregationCTE(groupByInfo, dottedQuotedName, 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_build_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 { dottedQuotedName, resolverName } = foundTable;
+
+  aliasMap[tableAlias] = resolverName;
+
+  const whereClause = buildWhereClausePG(
+    entities,
+    variablesDefinition,
+    variables,
+    field,
+    tableAlias,
+    parentTableName,
+    parentTableAlias,
+    level,
+    aliasMap,
+    true,
+  );
+
+  // 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,
+      dottedQuotedName,
+      tableAlias,
+      whereClause,
+    );
+
+    return `COALESCE((${mainQuery}), '[]'::json)`;
+  }
+
+  // Original logic for non-aggregation queries
+  const selectList = processFieldSelectionsPG(
+    entities,
+    variablesDefinition,
+    variables,
+    field,
+    resolverName,
+    tableAlias,
+    level,
+    (sel, level) =>
+      buildSQLForField(
+        entities,
+        variablesDefinition,
+        variables,
+        sel,
+        resolverName,
+        tableAlias,
+        level,
+        aliasMap,
+      ),
+    ([name, selector]) => `'${name}', ${selector}`,
+    true,
+  );
+
+  const fromClause = `FROM ${dottedQuotedName} ${tableAlias}`;
+
+  const orderByClause = buildOrderByClausePG(entities, field, tableAlias);
+  const paginationClause = buildPaginationClausePG(field, variablesDefinition);
+
+  const isArraySelection = !!field.isArray && !withoutArrayWrapper;
+
+  return `
+    COALESCE((
+      SELECT ${isArraySelection ? `json_agg(json_build_object(${selectList}) ${orderByClause})` : `json_build_object(${selectList})`} ${fromClause} ${whereClause} ${withoutArrayWrapper ? " LIMIT 1" : ""} ${paginationClause ? ` ${paginationClause}` : ""}
+    ), '${isArraySelection ? "[]" : "null"}'::json)
+  `;
+};

package/src/databases/engines/shared/claims.ts

@@ -0,0 +1,26 @@
+import { logger } from "../../../logging";
+
+// Returns null when the stored claims are malformed — callers must reject the login
+// (fail closed) rather than issue a token with missing claims.
+export const parseUserClaims = (claims: unknown): Record<string, unknown> | null => {
+  if (claims === null || claims === undefined) return {};
+
+  if (typeof claims === "object" && !Array.isArray(claims)) {
+    return claims as Record<string, unknown>;
+  }
+
+  if (typeof claims === "string") {
+    try {
+      const parsed: unknown = JSON.parse(claims);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        return parsed as Record<string, unknown>;
+      }
+    } catch (error) {
+      logger("auth").warn({ err: error }, "failed to parse user claims");
+      return null;
+    }
+  }
+
+  logger("auth").warn("user claims are not a JSON object");
+  return null;
+};

package/src/databases/engines/shared/types.ts

@@ -0,0 +1,7 @@
+export type UserRecord = {
+  username: string;
+  password: string;
+  role: string;
+  is_active: boolean;
+  claims: unknown; // JSON string or driver-parsed object
+};