@graphoria/server 0.1.0

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

@@ -0,0 +1,151 @@
+import { isString } from "es-toolkit";
+import { ConnectionPool, Decimal, Int, NVarChar, Numeric, VarChar } from "mssql";
+
+import type { MSSQLConnectionOptions } 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";
+import { logger } from "../../../logging";
+
+export const getPool = async (db: Database) => {
+  const ci = db.connection;
+  const opts = db.connectionOptions as MSSQLConnectionOptions | undefined;
+  const pool = new ConnectionPool({
+    server: ci.host,
+    port: ci.port,
+    user: ci.user,
+    password: ci.password,
+    database: ci.database,
+    connectionTimeout: opts?.connectionTimeout ? opts.connectionTimeout * 1000 : undefined,
+    requestTimeout: opts?.requestTimeout ? opts.requestTimeout * 1000 : undefined,
+    options: {
+      encrypt: opts?.encrypt ?? false,
+      trustServerCertificate: opts?.trustServerCertificate ?? true,
+      trustedConnection: opts?.trustedConnection ?? true,
+    },
+    pool: {
+      max: opts?.pool?.max ?? 50,
+      min: opts?.pool?.min ?? 1,
+      idleTimeoutMillis: (opts?.pool?.idleTimeout ?? 30) * 1000,
+    },
+    parseJSON: opts?.parseJSON ?? true,
+  });
+
+  await pool.connect(); // Connect to the database
+
+  while (!pool.connected) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+
+  return pool;
+};
+
+export const getPoolSingleton = async (db: Database) =>
+  databasesConnections[db.name] as ConnectionPool;
+
+export const executeQueryFactory =
+  (singleQuery = false) =>
+  async <T>(
+    query: string,
+    db: Database,
+    variablesDefinition: VariableDefinition[] = [],
+    params: Record<string, unknown> = {},
+  ) => {
+    const pool = singleQuery ? await getPool(db) : await getPoolSingleton(db);
+
+    while (!pool!.connected) {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+
+    const request = pool!.request();
+
+    variablesDefinition.forEach((v, i) => {
+      const varName = (i + 1).toString();
+      const varValue = params[v.name];
+
+      if (isString(varValue)) {
+        request.input(varName, VarChar, varValue);
+      } else if (typeof varValue === "number") {
+        request.input(varName, Int, varValue);
+      } else if (typeof varValue === "boolean") {
+        request.input(varName, Int, varValue ? 1 : 0);
+      }
+    });
+
+    const result = await request.query<T>(query);
+
+    if (singleQuery) {
+      await pool.close();
+    }
+
+    return result.recordset;
+  };
+
+export const executeQuery = executeQueryFactory();
+export const executeQuerySingle = executeQueryFactory(true);
+
+export const executeQueryJSONFactory =
+  (singleQuery = false) =>
+  async <T>(
+    query: string,
+    db: Database,
+    variablesDefinition: VariableDefinition[] = [],
+    params: Record<string, unknown> = {},
+  ): Promise<T> => {
+    const result = await (singleQuery ? executeQuerySingle : executeQuery)(
+      query,
+      db,
+      variablesDefinition,
+      params,
+    );
+
+    return result[0] 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 pool = await getPoolSingleton(sp.db!);
+
+    const request = pool!.request();
+
+    for (const [key, value] of Object.entries(variables)) {
+      if (!value) continue;
+
+      const paramFound = sp.parameters.find((p) => p.name === `@${key}`);
+
+      if (paramFound?.dataType === "varchar") {
+        request.input(key, VarChar(paramFound.maxLength), value);
+      } else if (paramFound?.dataType === "nvarchar") {
+        request.input(
+          key,
+          paramFound.maxLength > -1 ? NVarChar(paramFound.maxLength) : NVarChar(),
+          value,
+        );
+      } else if (paramFound?.dataType === "numeric") {
+        request.input(key, Numeric(paramFound.precision, paramFound.scale), value);
+      } else if (paramFound?.dataType === "decimal") {
+        request.input(key, Decimal(paramFound.precision, paramFound.scale), value);
+      } else if (paramFound?.dataType === "int") {
+        request.input(key, Int, value);
+      } else {
+        request.input(key, value);
+      }
+    }
+
+    const data = await request.execute(sp.dottedName);
+
+    return data?.recordset ?? false;
+  } catch (e: unknown) {
+    logger("mssql").error({ err: e }, "stored procedure execution failed");
+    return false;
+  }
+};

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

@@ -0,0 +1,112 @@
+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 
+        (
+          SELECT 
+            t.[schema] as 'schema',
+            t.[table] as 'name',
+            t.entityType as entityType,
+            (
+              SELECT CAST(value AS NVARCHAR(MAX))
+              FROM sys.extended_properties ep
+              INNER JOIN sys.objects o ON ep.major_id = o.object_id
+              WHERE ep.name = 'MS_Description'
+                AND o.name = t.[table]
+                AND SCHEMA_NAME(o.schema_id) = t.[schema]
+                AND ep.minor_id = 0
+            ) AS tableDescription,
+            ISNULL((
+              SELECT
+                c.COLUMN_NAME AS name,
+                c.DATA_TYPE AS dataType,
+                CAST(CASE WHEN c.IS_NULLABLE = 'YES' THEN 1 ELSE 0 END AS bit) AS isNullable,
+                (
+                  SELECT CAST(value AS NVARCHAR(MAX))
+                  FROM sys.extended_properties ep
+                  INNER JOIN sys.objects o ON ep.major_id = o.object_id
+                  INNER JOIN sys.columns col ON col.object_id = o.object_id AND col.column_id = ep.minor_id
+                  WHERE ep.name = 'MS_Description'
+                    AND o.name = t.[table]
+                    AND SCHEMA_NAME(o.schema_id) = t.[schema]
+                    AND col.name = c.COLUMN_NAME
+                ) AS description
+              FROM INFORMATION_SCHEMA.COLUMNS AS c
+              WHERE c.TABLE_SCHEMA = t.[schema]
+                AND c.TABLE_NAME = t.[table]
+              FOR JSON PATH
+            ), '[]') AS columns,
+            ISNULL((
+              SELECT
+                SCHEMA_NAME(tr.schema_id) AS [schema],
+                tr.name AS [name],
+                ISNULL((
+                  SELECT
+                    cp.name AS [source],
+                    cr.name AS [target]
+                  FROM sys.foreign_key_columns AS fkc_inner
+                  JOIN sys.columns AS cp 
+                    ON fkc_inner.parent_object_id = cp.object_id 
+                  AND fkc_inner.parent_column_id = cp.column_id
+                  JOIN sys.columns AS cr 
+                    ON fkc_inner.referenced_object_id = cr.object_id 
+                  AND fkc_inner.referenced_column_id = cr.column_id
+                  WHERE fkc_inner.constraint_object_id = fk.object_id
+                  FOR JSON PATH
+                ), '[]') AS columns
+              FROM sys.foreign_keys AS fk
+              JOIN sys.foreign_key_columns AS fkc 
+                ON fk.object_id = fkc.constraint_object_id
+              JOIN sys.tables AS tp 
+                ON fkc.parent_object_id = tp.object_id
+              JOIN sys.tables AS tr 
+                ON fkc.referenced_object_id = tr.object_id
+              WHERE tp.name = t.[table]
+              GROUP BY fk.object_id, fk.name, tp.name, tp.schema_id, tr.name, tr.schema_id
+              FOR JSON PATH
+            ), '[]') AS foreignKeys
+          FROM (
+            SELECT DISTINCT
+              TABLE_SCHEMA AS [schema],
+              TABLE_NAME AS [table],
+              CASE WHEN TABLE_TYPE = 'BASE TABLE' THEN 'table' ELSE 'view' END AS entityType
+            FROM INFORMATION_SCHEMA.TABLES
+            WHERE TABLE_TYPE IN ('BASE TABLE', 'VIEW')
+          ) t
+          FOR JSON PATH, INCLUDE_NULL_VALUES
+        ) AS tables,
+        (
+          SELECT 
+            SCHEMA_NAME(p.schema_id) AS 'schema',
+            p.name AS name,
+            ISNULL (
+              (
+                SELECT 
+                  name as name,
+                  TYPE_NAME(user_type_id) AS dataType,
+                  max_length as maxLength,
+                  precision,
+                  scale
+                FROM sys.parameters
+                WHERE object_id = p.object_id
+                ORDER BY parameter_id
+                FOR JSON PATH
+              ),
+              '[]'
+            ) AS parameters
+          FROM sys.procedures p
+          INNER JOIN sys.objects o ON p.object_id = o.object_id
+          FOR JSON PATH, INCLUDE_NULL_VALUES
+        ) AS storedProcedures
+      FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
+    `,
+    db,
+  );
+
+  return DatabaseStructureZod.parse(res);
+};

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

@@ -0,0 +1,17 @@
+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 
+      LOWER(SCHEMA_NAME(v.schema_id)) AS schema,
+      LOWER(v.name) AS name,
+      OBJECT_DEFINITION(v.object_id) AS definition
+    FROM sys.views v
+    FOR JSON PATH, INCLUDE_NULL_VALUES
+    `,
+    db,
+  );

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

@@ -0,0 +1,306 @@
+import type {
+  OperationAnalysis,
+  SelectionAnalysis,
+  VariableDefinition,
+} from "../../../../analyzeQuery/types";
+import type { MergedEntities } from "../../../../configuration/getSchemas/mergeEntities";
+import type { GroupByInfo } from "../../../common";
+
+import {
+  buildOrderByClauseMSSQL,
+  buildPaginationClauseMSSQL,
+  buildWhereClauseMSSQL,
+  extractAggregationInfo,
+  filterBasedOnDirective,
+  generateTableAlias,
+  isAggregationField,
+  isSingleQuery,
+  processFieldSelectionsMSSQL,
+} 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((field) => `${cteAlias}.${field.name} AS ${field.alias || field.name}`)
+      .join(", ");
+
+    selectClauses.push(
+      `JSON_QUERY((SELECT ${keyFields} FOR JSON PATH, WITHOUT_ARRAY_WRAPPER, INCLUDE_NULL_VALUES)) AS [${keyResolved}]`,
+    );
+  }
+
+  // Add aggregation results
+  aggregations.forEach((agg) => {
+    if (agg.name === "count") {
+      selectClauses.push(`${cteAlias}.${agg.alias} AS ${agg.nameResolved}`);
+    } else {
+      selectClauses.push(
+        `JSON_QUERY((SELECT ${cteAlias}.${agg.alias} AS ${agg.fieldAlias} FOR JSON PATH, WITHOUT_ARRAY_WRAPPER, INCLUDE_NULL_VALUES)) AS ${agg.nameResolved}`,
+      );
+    }
+  });
+
+  // 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) => `${tableAlias}.${sel.name} AS ${sel.alias || sel.name}`)
+        .join(", ");
+
+      if (itemFields) {
+        const joinConditions = groupByFields.map(
+          (field) => `${tableAlias}.${field} = ${cteAlias}.${field}`,
+        );
+
+        selectClauses.push(`JSON_QUERY(ISNULL((
+          SELECT ${itemFields}
+          FROM ${dottedName} ${tableAlias}
+          ${whereClause ? [whereClause, ...joinConditions].join(" AND ") : `WHERE ${joinConditions.join(" AND ")}`}
+          FOR JSON PATH, INCLUDE_NULL_VALUES
+        ), '[]')) AS ${itemsSelection.alias || itemsSelection.name}`);
+      }
+    }
+  }
+
+  const orderByClause = buildOrderByClauseMSSQL(entities, field, cteAlias);
+
+  return `SELECT ${selectClauses.join(",\n    ")}
+    FROM ${cteAlias} ${orderByClause}
+    FOR JSON PATH, INCLUDE_NULL_VALUES`;
+};
+
+export const generateSQL = (
+  entities: MergedEntities,
+  operation: OperationAnalysis,
+  variables: Record<string, unknown> = {},
+  forHashMethod: boolean = false,
+): string => {
+  if (forHashMethod) {
+    return `SELECT HASHBYTES('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 = buildWhereClauseMSSQL(
+        entities,
+        operation.variables ?? [],
+        variablesWithDefault,
+        field,
+        tableAlias,
+        null,
+        null,
+        index + 1,
+        {},
+      );
+
+      const cte = buildAggregationCTE(groupByInfo, dottedName, tableAlias, whereClause);
+      ctes.push(cte);
+    }
+
+    const fieldSQL = buildSQLForField(
+      entities,
+      operation.variables ?? [],
+      variablesWithDefault,
+      field,
+      null,
+      null,
+      index + 1,
+      {},
+    );
+
+    fieldQueries.push(`(${fieldSQL}) as ${field.alias || field.name}`);
+  });
+
+  const cteClause = ctes.length > 0 ? `WITH\n${ctes.join(",\n")}\n` : "";
+
+  return `
+    ${cteClause}SELECT
+      ${fieldQueries.join(",\n")}
+    FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER
+  `;
+};
+
+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 = buildWhereClauseMSSQL(
+    entities,
+    variablesDefinition,
+    variables,
+    field,
+    tableAlias,
+    parentTableName,
+    parentTableAlias,
+    level,
+    aliasMap,
+  );
+
+  // 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 mainQuery;
+  }
+
+  // Original logic for non-aggregation queries
+  const selectList = processFieldSelectionsMSSQL(
+    entities,
+    variablesDefinition,
+    variables,
+    field,
+    resolverName,
+    tableAlias,
+    level,
+    (sel, level) =>
+      buildSQLForField(
+        entities,
+        variablesDefinition,
+        variables,
+        sel,
+        resolverName,
+        tableAlias,
+        level,
+        aliasMap,
+      ),
+    ([name, selector]) => `${selector} AS ${name}`,
+  );
+
+  const fromClause = `FROM ${dottedName} ${tableAlias}`;
+
+  const orderByClause = buildOrderByClauseMSSQL(entities, field, tableAlias);
+  const paginationClause = buildPaginationClauseMSSQL(field, variablesDefinition);
+
+  const isArray = field.isArray;
+  const forJson =
+    isArray && !withoutArrayWrapper
+      ? "FOR JSON PATH, INCLUDE_NULL_VALUES"
+      : "FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER";
+
+  const baseQuery = `SELECT ${selectList} ${fromClause} ${whereClause} ${orderByClause}${paginationClause ? ` ${paginationClause}` : ""} ${forJson}`;
+
+  if (isArray && !withoutArrayWrapper) {
+    return `JSON_QUERY(ISNULL((${baseQuery}), '[]'))`;
+  } else {
+    return `JSON_QUERY(NULLIF((${baseQuery}), ''))`;
+  }
+};

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

@@ -0,0 +1,100 @@
+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 { 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 JSON DEFAULT ('{}')
+    );
+`;
+
+export const createAuthTables = async (auth: Auth) => {
+  const pool = databasesConnections[auth.databaseEntity.name] as SQL;
+
+  const schema = assertSafeIdentifier(auth.schema!, "schema");
+
+  // In MySQL, CREATE DATABASE is used instead of CREATE SCHEMA
+  await pool.unsafe(`CREATE DATABASE IF NOT EXISTS \`${schema}\`;`);
+
+  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 = await pool.unsafe<UserRecord[]>(
+    `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)`,
+    [input.username, hashed, input.role, JSON.stringify(input.claims ?? {})],
+  );
+};