@graphoria/server 0.2.0 → 0.2.2

package/src/configuration/getSchemas/mergeEntities/index.ts

@@ -6,6 +6,7 @@ import type { ResolverRegistry } from "../../../types/resolver";
 import type { TypedOperation } from "../../../types/zod/operation";
 
 import { EntitySource, createResolverEntry } from "../../../types/resolver";
+import { columnFieldName } from "../../../databases/transformers/graphqlName";
 import { SqlTypeCategory, categorizeSqlType } from "../../../databases/sqlTypeUtils";
 
 const dataTypeToOpenApiType = (dataType: string): string => {
@@ -33,7 +34,23 @@ export const mergeEntities = (
   const resolverRegistry: ResolverRegistry = {};
 
   // Register tables (queries)
+  // Sanitisation is not injective — `categoría` and `categor_a` both produce
+  // `categoria` — so two tables can land on one resolver name. Serving one
+  // table's rows under the other's name is worse than not booting.
+  const sourceOfResolverName: Record<string, string> = {};
+
   const queriesMap = entityOfRole.tables.reduce<Record<string, TableResolver>>((acc, table) => {
+    const source = `${table.schema}.${table.name}`;
+    const previousSource = sourceOfResolverName[table.resolverName];
+
+    if (previousSource) {
+      throw new Error(
+        `Duplicate GraphQL name "${table.resolverName}": both ${previousSource} and ${source} map to it. Rename one of them, or exclude it with schema.excludedTables.`,
+      );
+    }
+
+    sourceOfResolverName[table.resolverName] = source;
+
     acc[table.resolverName] = table;
     acc[`${table.resolverName}_single`] = table;
     acc[`${table.resolverName}_aggregate`] = table;
@@ -207,10 +224,18 @@ export const mergeEntities = (
     },
     isVirtualColumn: (table: string, column: string): VirtualColumn | undefined => {
       const col = queriesMap[table]?.columns.find(
-        (c) => c.name === column && "virtual" in c && c.virtual,
+        (c) => columnFieldName(c) === column && "virtual" in c && c.virtual,
       );
       return col ? (col as VirtualColumn) : undefined;
     },
+    /**
+     * The SQL identifier behind a GraphQL field name. Columns whose name GraphQL
+     * cannot spell are exposed under a sanitised field name, so anything that
+     * emits SQL for a field the client named has to come back through here.
+     * Unknown names pass through: a legal name always sanitises to itself.
+     */
+    columnSqlName: (table: string, fieldName: string): string =>
+      queriesMap[table]?.columns.find((c) => columnFieldName(c) === fieldName)?.name ?? fieldName,
     getColumnTypeForOpenApi: (table: string, column: string) => {
       const tableObj = queriesMap[table];
 

package/src/configuration/getSchemas/type-definition-generator/index.ts

@@ -1,6 +1,7 @@
 import type { OpenAPIV3_1 } from "openapi-types";
 
 import { SqlTypeCategory, categorizeSqlType, isNumericType } from "../../../databases/sqlTypeUtils";
+import { columnFieldName } from "../../../databases/transformers/graphqlName";
 import { convertFromZod } from "../../rest/openApiErrors";
 import { type MergedEntities } from "../mergeEntities";
 
@@ -91,8 +92,8 @@ export const generateTableType = (mergedEntities: MergedEntities) =>
         ${lj([
           lj(
             columns,
-            ({ name, dataType, isNullable, description }) =>
-              `${sdlDesc(description)}${name}: ${mapSQLTypeToGraphQLType(dataType)}${isNullable ? "" : "!"}`,
+            (column) =>
+              `${sdlDesc(column.description)}${columnFieldName(column)}: ${mapSQLTypeToGraphQLType(column.dataType)}${column.isNullable ? "" : "!"}`,
           ),
           lj(
             relationships,
@@ -115,7 +116,11 @@ export const generateWhereInputType = (mergedEntities: MergedEntities) =>
       ({ resolverName, columns, relationships, relationshipsReversed }) => `
         input ${resolverName}WhereInput {
           ${lj([
-            lj(columns, ({ name, dataType }) => `${name}: ${mapSQLTypeToConditionType(dataType)}`),
+            lj(
+              columns,
+              (column) =>
+                `${columnFieldName(column)}: ${mapSQLTypeToConditionType(column.dataType)}`,
+            ),
             lj(
               relationships,
               ({ toResolverName, toInternalName }) =>
@@ -138,7 +143,7 @@ export const generateOrderByInputType = (mergedEntities: MergedEntities) =>
     mergedEntities.tables.map(
       ({ internalName, columns }) => `
       input ${internalName}OrderByInput {
-        ${lj(columns, ({ name }) => `${name}: OrderByEnum`)}
+        ${lj(columns, (column) => `${columnFieldName(column)}: OrderByEnum`)}
       }`,
     ),
   );
@@ -165,7 +170,7 @@ export const generateAggregationTypes = (mergedEntities: MergedEntities) => {
                 ({ name: agg, graphQLType }) =>
                   `
                   type ${resolverName}${agg} {
-                    ${lj(numericColumns, ({ name }) => `${name}: ${graphQLType ?? mapSQLTypeToGraphQLType(columns.find((c) => c.name === name)?.dataType || "")}`)}
+                    ${lj(numericColumns, (column) => `${columnFieldName(column)}: ${graphQLType ?? mapSQLTypeToGraphQLType(column.dataType)}`)}
                   }
                 `,
               )
@@ -187,7 +192,7 @@ export const generateAggregationTypes = (mergedEntities: MergedEntities) => {
       }
       
       enum ${resolverName}GroupByKeys {
-        ${columns.map((c) => c.name).join("\n")}
+        ${columns.map(columnFieldName).join("\n")}
       }
       `;
   });

package/src/configuration/rest/handleRESTRequestFactory.ts

@@ -18,6 +18,7 @@ import { databasesConnections, repositoryMap } from "../../singletons/databases"
 import { queueManager } from "../../singletons/queues";
 import { S200, S401, S404 } from "../../utils/responses";
 import { buildApiRoutes } from "../rest";
+import { parseStringParams } from "./parseStringParams";
 import { logger } from "../../logging";
 
 // Build remote REST route matchers
@@ -118,17 +119,14 @@ export const handleRESTRequestFactory = (
       // left `undefined` when its schema is not configured; that `undefined` is
       // forwarded to `beforeRequest` so the hook can tell the sources apart,
       // while `allVariables` stays identical because spreading `undefined` is a
-      // no-op.
-      const pathVariables = route.rest!.pathParams?.parse(pathParameters) as
-        | Record<string, unknown>
-        | undefined;
+      // no-op. Path and query values are strings on the wire, so
+      // `parseStringParams` converts the keys declared as `z.boolean()` first.
+      const pathVariables = parseStringParams(route.rest!.pathParams, pathParameters);
 
       const paramsQuery = new URLSearchParams(url.search);
       const paramsQueryDictionary = Object.fromEntries(paramsQuery.entries());
 
-      const queryVariables = route.rest!.queryParams?.parse(paramsQueryDictionary) as
-        | Record<string, unknown>
-        | undefined;
+      const queryVariables = parseStringParams(route.rest!.queryParams, paramsQueryDictionary);
 
       let bodyVariables: Record<string, unknown> | undefined;
 

package/src/configuration/rest/parseStringParams.ts

@@ -0,0 +1,92 @@
+import type { z } from "zod";
+
+/**
+ * The slice of Zod's runtime schema internals this module walks to find which
+ * keys of a `z.object()` ultimately validate a boolean.
+ */
+type SchemaDef = {
+  type: string;
+  innerType?: { def: SchemaDef };
+  in?: { def: SchemaDef };
+  shape?: Record<string, { def: SchemaDef }>;
+};
+
+/** Wrappers that keep the validated type of the schema they wrap. */
+const wrappers = new Set([
+  "optional",
+  "nullable",
+  "nonoptional",
+  "default",
+  "prefault",
+  "catch",
+  "readonly",
+]);
+
+/** Accepted spellings, matching the ones `z.stringbool()` recognizes. */
+const truthy = new Set(["true", "1", "yes", "on", "y", "enabled"]);
+const falsy = new Set(["false", "0", "no", "off", "n", "disabled"]);
+
+const defOf = (schema: z.ZodType) => (schema as unknown as { def: SchemaDef }).def;
+
+const resolveType = (def: SchemaDef): string => {
+  if (wrappers.has(def.type) && def.innerType) return resolveType(def.innerType.def);
+  // A pipe validates its input side, so `z.stringbool()` resolves to a string.
+  if (def.type === "pipe" && def.in) return resolveType(def.in.def);
+
+  return def.type;
+};
+
+// Schemas are created once at config time, so the key scan is done once per schema.
+const booleanKeysCache = new WeakMap<z.ZodType, Set<string>>();
+
+const booleanKeys = (schema: z.ZodType) => {
+  const cached = booleanKeysCache.get(schema);
+  if (cached) return cached;
+
+  const keys = new Set<string>();
+  for (const [key, field] of Object.entries(defOf(schema).shape ?? {})) {
+    if (resolveType(field.def) === "boolean") keys.add(key);
+  }
+
+  booleanKeysCache.set(schema, keys);
+
+  return keys;
+};
+
+/**
+ * Parses path or query parameters, which always arrive as strings.
+ *
+ * A parameter declared as `z.boolean()` — the declaration that makes the
+ * OpenAPI docs render a true/false picker instead of a free-text box — would
+ * never parse on its own, so those keys (and only those) are converted before
+ * validation. A value that spells neither true nor false is left as the string
+ * it was, so Zod still reports it as invalid.
+ *
+ * Returns `undefined` when no schema is configured for that source, which is
+ * what the REST handler forwards to `beforeRequest`.
+ */
+export const parseStringParams = (
+  schema: z.ZodType | undefined,
+  values: Record<string, string | string[]>,
+): Record<string, unknown> | undefined => {
+  if (!schema) return undefined;
+
+  const keys = booleanKeys(schema);
+
+  if (keys.size === 0) return schema.parse(values) as Record<string, unknown>;
+
+  const coerced: Record<string, unknown> = { ...values };
+
+  for (const key of keys) {
+    const value = coerced[key];
+
+    if (typeof value !== "string") continue;
+
+    const spelling = value.toLowerCase();
+
+    if (truthy.has(spelling)) coerced[key] = true;
+    else if (falsy.has(spelling)) coerced[key] = false;
+  }
+
+  return schema.parse(coerced) as Record<string, unknown>;
+};

package/src/databases/common.ts

@@ -224,9 +224,20 @@ const columnTargetFp =
 
     return virtualColumn
       ? renderVirtualColumn(virtualColumn as VirtualColumn)
-      : `${tableAlias}.${wrapIdentifierFp(dbType)(colName)}`;
+      : `${tableAlias}.${wrapIdentifierFp(dbType)(sqlColumnName(entities, tableName, colName))}`;
   };
 
+/**
+ * The SQL identifier a GraphQL field name compiles to. A column GraphQL cannot
+ * spell is exposed under a sanitised field name, so the name the client sent is
+ * not necessarily the name the database knows.
+ */
+export const sqlColumnName = (
+  entities: MergedEntities,
+  tableName: string | undefined,
+  fieldName: string,
+): string => (tableName ? entities.columnSqlName(tableName, fieldName) : fieldName);
+
 // Helper to resolve variable values
 const resolveVariable = <T>(value: unknown, variables: Record<string, unknown>): T => {
   if (isString(value) && value.startsWith("$")) {
@@ -700,7 +711,7 @@ export const processFieldSelectionsFp =
               selectClauses.push([`${colName}`, `(${vc.expression})`]);
             }
           } else {
-            let querySelector = `${tableAlias}.${wrapIdentifierFp(dbType)(sel.name)}`;
+            let querySelector = `${tableAlias}.${wrapIdentifierFp(dbType)(sqlColumnName(entities, tableName, sel.name))}`;
 
             // Apply all directives using the handler registry
             querySelector = applyDirectives(

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

@@ -16,6 +16,7 @@ import {
   isAggregationField,
   isSingleQuery,
   processFieldSelectionsMSSQL,
+  sqlColumnName,
   wrapIdentifierMSSQL,
 } from "../../../common";
 
@@ -26,18 +27,21 @@ import { applyDirectives } from "../../../directives";
 
 // Generate CTE for aggregations
 const buildAggregationCTE = (
+  entities: MergedEntities,
+  tableName: string,
   groupByInfo: GroupByInfo,
   dottedQuotedName: string,
   tableAlias: string,
   whereClause: string,
 ): string => {
   const { groupByFields, aggregations, cteAlias } = groupByInfo;
+  const sqlName = (fieldName: string) => sqlColumnName(entities, tableName, fieldName);
 
   const selectClauses: string[] = [];
 
   // Add group by fields
   groupByFields.forEach((field) => {
-    selectClauses.push(`${tableAlias}.${wrapIdentifierMSSQL(field)}`);
+    selectClauses.push(`${tableAlias}.${wrapIdentifierMSSQL(sqlName(field))}`);
   });
 
   // Add aggregations
@@ -50,13 +54,13 @@ const buildAggregationCTE = (
       // 1, 5, 5, 2 is 3, not 3.25 — so the average has to be taken on a float.
       const operand =
         agg.name === "avg"
-          ? `CAST(${tableAlias}.${wrapIdentifierMSSQL(agg.fieldName)} AS FLOAT)`
-          : `${tableAlias}.${wrapIdentifierMSSQL(agg.fieldName)}`;
+          ? `CAST(${tableAlias}.${wrapIdentifierMSSQL(sqlName(agg.fieldName))} AS FLOAT)`
+          : `${tableAlias}.${wrapIdentifierMSSQL(sqlName(agg.fieldName))}`;
       selectClauses.push(`${func}(${operand}) AS ${agg.alias}`);
     }
   });
 
-  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}.${wrapIdentifierMSSQL(field)}`).join(", ")}`;
+  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}.${wrapIdentifierMSSQL(sqlName(field))}`).join(", ")}`;
 
   return `${cteAlias} AS (
     SELECT
@@ -80,19 +84,21 @@ const buildGroupedQuery = (
   const { groupByFields, aggregations, hasItems, keyResolved, hasKey, keys, cteAlias } =
     groupByInfo;
 
+  const sqlName = (fieldName: string) => sqlColumnName(entities, field.name, fieldName);
+
   const selectClauses: string[] = [];
 
   if (hasKey) {
     // Add key object with group by fields
     const keyFields = keys
-      .map((field) => {
+      .map((key) => {
         const selector = applyDirectives(
-          `${cteAlias}.${wrapIdentifierMSSQL(field.name)}`,
-          field.directives,
+          `${cteAlias}.${wrapIdentifierMSSQL(sqlName(key.name))}`,
+          key.directives,
           "mssql",
           variablesDefinition,
         );
-        return `${selector} AS ${wrapIdentifierMSSQL(field.alias || field.name)}`;
+        return `${selector} AS ${wrapIdentifierMSSQL(key.alias || key.name)}`;
       })
       .join(", ");
 
@@ -121,7 +127,7 @@ const buildGroupedQuery = (
         .filter((sel) => !isAggregationField(sel.name) && sel.name !== "items")
         .map((sel) => {
           const selector = applyDirectives(
-            `${tableAlias}.${wrapIdentifierMSSQL(sel.name)}`,
+            `${tableAlias}.${wrapIdentifierMSSQL(sqlName(sel.name))}`,
             sel.directives,
             "mssql",
             variablesDefinition,
@@ -132,8 +138,8 @@ const buildGroupedQuery = (
 
       if (itemFields) {
         const joinConditions = groupByFields.map(
-          (field) =>
-            `${tableAlias}.${wrapIdentifierMSSQL(field)} = ${cteAlias}.${wrapIdentifierMSSQL(field)}`,
+          (groupByField) =>
+            `${tableAlias}.${wrapIdentifierMSSQL(sqlName(groupByField))} = ${cteAlias}.${wrapIdentifierMSSQL(sqlName(groupByField))}`,
         );
 
         selectClauses.push(`JSON_QUERY(ISNULL((
@@ -212,7 +218,14 @@ export const generateSQL = (
         {},
       );
 
-      const cte = buildAggregationCTE(groupByInfo, dottedQuotedName, tableAlias, whereClause);
+      const cte = buildAggregationCTE(
+        entities,
+        field.name,
+        groupByInfo,
+        dottedQuotedName,
+        tableAlias,
+        whereClause,
+      );
       ctes.push(cte);
     }
 

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

@@ -22,6 +22,7 @@ export const getPool = async (db: Database) => {
     connectionTimeout: opts?.connectionTimeout,
     maxLifetime: opts?.maxLifetime,
     tls: opts?.tls,
+    allowPublicKeyRetrieval: opts?.allowPublicKeyRetrieval,
     prepare: opts?.prepare,
     bigint: opts?.bigint,
   });

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

@@ -16,6 +16,7 @@ import {
   isAggregationField,
   isSingleQuery,
   processFieldSelectionsMySQL,
+  sqlColumnName,
   wrapIdentifierMySQL,
 } from "../../../common";
 
@@ -23,18 +24,21 @@ import { applyDirectives } from "../../../directives";
 
 // Generate CTE for aggregations
 const buildAggregationCTE = (
+  entities: MergedEntities,
+  tableName: string,
   groupByInfo: GroupByInfo,
   dottedQuotedName: string,
   tableAlias: string,
   whereClause: string,
 ): string => {
   const { groupByFields, aggregations, cteAlias } = groupByInfo;
+  const sqlName = (fieldName: string) => sqlColumnName(entities, tableName, fieldName);
 
   const selectClauses: string[] = [];
 
   // Add group by fields
   groupByFields.forEach((field) => {
-    selectClauses.push(`${tableAlias}.${wrapIdentifierMySQL(field)}`);
+    selectClauses.push(`${tableAlias}.${wrapIdentifierMySQL(sqlName(field))}`);
   });
 
   // Add aggregations
@@ -44,12 +48,12 @@ const buildAggregationCTE = (
     } else {
       const func = agg.name.toUpperCase();
       selectClauses.push(
-        `${func}(${tableAlias}.${wrapIdentifierMySQL(agg.fieldName)}) AS ${agg.alias}`,
+        `${func}(${tableAlias}.${wrapIdentifierMySQL(sqlName(agg.fieldName))}) AS ${agg.alias}`,
       );
     }
   });
 
-  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}.${wrapIdentifierMySQL(field)}`).join(", ")}`;
+  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}.${wrapIdentifierMySQL(sqlName(field))}`).join(", ")}`;
 
   return `${cteAlias} AS (
     SELECT
@@ -73,6 +77,8 @@ const buildGroupedQuery = (
   const { groupByFields, aggregations, hasItems, keyResolved, hasKey, keys, cteAlias } =
     groupByInfo;
 
+  const sqlName = (fieldName: string) => sqlColumnName(entities, field.name, fieldName);
+
   const selectClauses: string[] = [];
 
   if (hasKey) {
@@ -80,7 +86,7 @@ const buildGroupedQuery = (
     const keyFields = keys
       .map((key) => {
         const selector = applyDirectives(
-          `${cteAlias}.${wrapIdentifierMySQL(key.name)}`,
+          `${cteAlias}.${wrapIdentifierMySQL(sqlName(key.name))}`,
           key.directives,
           "mysql",
           variablesDefinition,
@@ -112,7 +118,7 @@ const buildGroupedQuery = (
         .filter((sel) => !isAggregationField(sel.name) && sel.name !== "items")
         .map((sel) => {
           const selector = applyDirectives(
-            `${tableAlias}.${wrapIdentifierMySQL(sel.name)}`,
+            `${tableAlias}.${wrapIdentifierMySQL(sqlName(sel.name))}`,
             sel.directives,
             "mysql",
             variablesDefinition,
@@ -123,8 +129,8 @@ const buildGroupedQuery = (
 
       if (itemFields) {
         const joinConditions = groupByFields.map(
-          (field) =>
-            `${tableAlias}.${wrapIdentifierMySQL(field)} = ${cteAlias}.${wrapIdentifierMySQL(field)}`,
+          (groupByField) =>
+            `${tableAlias}.${wrapIdentifierMySQL(sqlName(groupByField))} = ${cteAlias}.${wrapIdentifierMySQL(sqlName(groupByField))}`,
         );
 
         const whereConditions = whereClause
@@ -194,7 +200,14 @@ export const generateSQL = (
         {},
       );
 
-      const cte = buildAggregationCTE(groupByInfo, dottedQuotedName, tableAlias, whereClause);
+      const cte = buildAggregationCTE(
+        entities,
+        field.name,
+        groupByInfo,
+        dottedQuotedName,
+        tableAlias,
+        whereClause,
+      );
       ctes.push(cte);
     }
 

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

@@ -16,24 +16,28 @@ import {
   isAggregationField,
   isSingleQuery,
   processFieldSelectionsPG,
+  sqlColumnName,
 } from "../../../common";
 
 import { applyDirectives } from "../../../directives";
 
 // Generate CTE for aggregations
 const buildAggregationCTE = (
+  entities: MergedEntities,
+  tableName: string,
   groupByInfo: GroupByInfo,
   dottedQuotedName: string,
   tableAlias: string,
   whereClause: string,
 ): string => {
   const { groupByFields, aggregations, cteAlias } = groupByInfo;
+  const sqlName = (fieldName: string) => sqlColumnName(entities, tableName, fieldName);
 
   const selectClauses: string[] = [];
 
   // Add group by fields
   groupByFields.forEach((field) => {
-    selectClauses.push(`${tableAlias}."${field}"`);
+    selectClauses.push(`${tableAlias}."${sqlName(field)}"`);
   });
 
   // Add aggregations
@@ -42,11 +46,11 @@ const buildAggregationCTE = (
       selectClauses.push(`COUNT(*) AS ${agg.alias}`);
     } else {
       const func = agg.name.toUpperCase();
-      selectClauses.push(`${func}(${tableAlias}."${agg.fieldName}") AS ${agg.alias}`);
+      selectClauses.push(`${func}(${tableAlias}."${sqlName(agg.fieldName)}") AS ${agg.alias}`);
     }
   });
 
-  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}."${field}"`).join(", ")}`;
+  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}."${sqlName(field)}"`).join(", ")}`;
 
   return `${cteAlias} AS (
     SELECT
@@ -70,6 +74,8 @@ const buildGroupedQuery = (
   const { groupByFields, aggregations, hasItems, keyResolved, hasKey, keys, cteAlias } =
     groupByInfo;
 
+  const sqlName = (fieldName: string) => sqlColumnName(entities, field.name, fieldName);
+
   const selectClauses: string[] = [];
 
   if (hasKey) {
@@ -77,7 +83,7 @@ const buildGroupedQuery = (
     const keyFields = keys
       .map((key) => {
         const selector = applyDirectives(
-          `${cteAlias}."${key.name}"`,
+          `${cteAlias}."${sqlName(key.name)}"`,
           key.directives,
           "pg",
           variablesDefinition,
@@ -109,7 +115,7 @@ const buildGroupedQuery = (
         .filter((sel) => !isAggregationField(sel.name) && sel.name !== "items")
         .map((sel) => {
           const selector = applyDirectives(
-            `${tableAlias}."${sel.name}"`,
+            `${tableAlias}."${sqlName(sel.name)}"`,
             sel.directives,
             "pg",
             variablesDefinition,
@@ -120,7 +126,8 @@ const buildGroupedQuery = (
 
       if (itemFields) {
         const joinConditions = groupByFields.map(
-          (field) => `${tableAlias}."${field}" = ${cteAlias}."${field}"`,
+          (groupByField) =>
+            `${tableAlias}."${sqlName(groupByField)}" = ${cteAlias}."${sqlName(groupByField)}"`,
         );
 
         const whereConditions = whereClause
@@ -190,7 +197,14 @@ export const generateSQL = (
         {},
       );
 
-      const cte = buildAggregationCTE(groupByInfo, dottedQuotedName, tableAlias, whereClause);
+      const cte = buildAggregationCTE(
+        entities,
+        field.name,
+        groupByInfo,
+        dottedQuotedName,
+        tableAlias,
+        whereClause,
+      );
       ctes.push(cte);
     }
 

package/src/databases/high-level-operations.ts

@@ -11,7 +11,7 @@ import type {
   TableFilter,
   VirtualColumns,
 } from "../types/configuration";
-import type { Column, ProcedureResolver, TableResolver, Tables } from "../types/db";
+import type { ProcedureResolver, TableColumn, TableResolver, Tables } from "../types/db";
 
 import { getDatabaseStructure } from "./metadata/structure";
 import { buildProcedureResolver, buildTableResolver } from "./transformers/data-transformers";
@@ -63,7 +63,7 @@ export const getDatabasesStructure = async (
 
         if (tableOverride.columns.length) {
           // Mix database columns with virtual columns from configuration
-          t.columns = [...t.columns, ...tableOverride.columns] as Column[];
+          t.columns = [...t.columns, ...tableOverride.columns] as TableColumn[];
         }
 
         if (tableOverride.relationships.length) {

package/src/databases/transformers/genResolverName.ts

@@ -1,3 +1,5 @@
+import { sanitizeGraphQLName } from "./graphqlName";
+
 export const genResolverName = (
   schema: string,
   name: string,
@@ -12,7 +14,5 @@ export const genResolverName = (
     .replace("{schema}", schema)
     .replace("{name}", name);
 
-  if (suffix) return `${baseName}_${suffix}`;
-
-  return baseName;
+  return sanitizeGraphQLName(suffix ? `${baseName}_${suffix}` : baseName);
 };

package/src/databases/transformers/graphqlName.ts

@@ -0,0 +1,28 @@
+/**
+ * Maps a SQL identifier onto a legal GraphQL name (`/^[_A-Za-z][_0-9A-Za-z]*$/`).
+ *
+ * PostgreSQL, MySQL and SQL Server all accept identifiers GraphQL cannot spell —
+ * spaces, accents, punctuation — and an unmapped one produces an SDL document
+ * that fails to parse, taking the whole server down at boot.
+ *
+ * A name that is already legal is returned unchanged, so this cannot rename a
+ * field in any schema that boots today. Runs of illegal characters are not
+ * collapsed, and diacritics fold to their base letter rather than being dropped,
+ * both so that distinct identifiers stay distinct as often as possible.
+ */
+export const sanitizeGraphQLName = (name: string): string => {
+  const folded = name.normalize("NFD").replace(/[̀-ͯ]/g, "");
+  const replaced = folded.replace(/[^_0-9A-Za-z]/g, "_");
+
+  if (replaced.length === 0) return "_";
+
+  return /^[0-9]/.test(replaced) ? `_${replaced}` : replaced;
+};
+
+/**
+ * The GraphQL field a column is exposed as. Introspected columns carry a
+ * `fieldName` computed once at parse time; virtual columns come from
+ * configuration and carry only a name, so they are sanitised on the spot.
+ */
+export const columnFieldName = (column: { name: string; fieldName?: string }): string =>
+  column.fieldName ?? sanitizeGraphQLName(column.name);

package/src/logging/index.ts

@@ -3,7 +3,9 @@ import pino from "pino";
 const DEFAULT_LEVEL =
   process.env.LOG_LEVEL || (process.env.NODE_ENV === "production" ? "info" : "debug");
 
-const isDev = process.env.NODE_ENV !== "production";
+// `bun test` sets NODE_ENV=test: pino-pretty runs on a worker thread, and
+// Bun's test runner cannot construct one (thread-stream crashes on import).
+const isDev = process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test";
 
 const DEFAULT_OPTIONS: pino.LoggerOptions = {
   level: DEFAULT_LEVEL,

package/src/types/db.ts

@@ -15,7 +15,6 @@ import {
   TableColumnZod,
   TableZod,
   ViewZod,
-  VirtualColumnZod,
 } from "./zod/db";
 
 // Re-export VirtualColumnType from the config module