@graphoria/server 0.1.1 → 0.1.3

package/src/databases/common.ts

@@ -47,7 +47,6 @@ export const buildConditions = (
   tableAlias: string,
   level: number,
   aliasMap: { [alias: string]: string },
-  quoted = false,
 ): string => {
   if (!whereArgs) return "";
 
@@ -71,7 +70,7 @@ export const buildConditions = (
             ? `${mappingDbTypeCharVar[dbType]}${variablesDefinition.findIndex((v) => v.name === operand.substring(1)) + 1}`
             : operand;
 
-        const condition = buildCondition(tableAlias, fieldName, operator, resolvedValue, quoted);
+        const condition = buildCondition(tableAlias, fieldName, operator, resolvedValue, dbType);
 
         if (condition) {
           conditions.push(condition);
@@ -88,7 +87,7 @@ export const buildConditions = (
         fieldName,
         tableAlias,
         nestedTableAlias,
-        quoted,
+        dbType,
       );
 
       const nestedConditions = buildConditions(
@@ -100,12 +99,11 @@ export const buildConditions = (
         nestedTableAlias,
         level + 1,
         aliasMap,
-        quoted,
       );
 
       const existsClause = `EXISTS (
       SELECT 1
-      FROM ${entities.queriesMap[fieldName]!.dottedName} ${nestedTableAlias}
+      FROM ${entities.queriesMap[fieldName]!.dottedQuotedName} ${nestedTableAlias}
       WHERE ${joinCondition}${nestedConditions ? ` AND (${nestedConditions})` : ""}
     )`;
 
@@ -116,7 +114,33 @@ export const buildConditions = (
   return conditions.length > 0 ? conditions.join(" AND ") : "";
 };
 
-const wrapIf = (value: string, quoted: boolean): string => (quoted ? `"${value}"` : value);
+// Reserved words (e.g. PRINT, ORDER) are valid GraphQL names; always delimit
+// identifiers so they parse as identifiers in every dialect.
+const identifierDelimiters: Record<DatabaseType, [string, string]> = {
+  pg: ['"', '"'],
+  mysql: ["`", "`"],
+  mssql: ["[", "]"],
+};
+
+export const wrapIdentifierFp =
+  (dbType: DatabaseType) =>
+  (value: string): string => {
+    const [open, close] = identifierDelimiters[dbType];
+    // Doubling the closing delimiter is the escape in all three dialects; only
+    // introspected names can contain one (GraphQL names never do).
+    return `${open}${value.replaceAll(close, `${close}${close}`)}${close}`;
+  };
+
+export const wrapIdentifierPG = wrapIdentifierFp("pg");
+export const wrapIdentifierMSSQL = wrapIdentifierFp("mssql");
+export const wrapIdentifierMySQL = wrapIdentifierFp("mysql");
+
+export const qualifiedNameFp =
+  (dbType: DatabaseType) =>
+  ({ schema, name }: { schema: string; name: string }): string => {
+    const wrap = wrapIdentifierFp(dbType);
+    return `${wrap(schema)}.${wrap(name)}`;
+  };
 
 // Helper to resolve variable values
 const resolveVariable = <T>(value: unknown, variables: Record<string, unknown>): T => {
@@ -131,9 +155,9 @@ const buildCondition = (
   field: string,
   operator: string,
   value: unknown,
-  quoted = false,
+  dbType: DatabaseType,
 ): string | null => {
-  const wrappedField = wrapIf(field, quoted);
+  const wrappedField = wrapIdentifierFp(dbType)(field);
 
   switch (operator) {
     case "eq":
@@ -174,14 +198,13 @@ const pairsToAnd = (
     parentColumn: string;
     childColumn: string;
   }[],
-  quoted = false,
-) =>
-  pairs
-    .map(
-      (p) =>
-        `${p.parentAlias}.${wrapIf(p.parentColumn, quoted)} = ${p.childAlias}.${wrapIf(p.childColumn, quoted)}`,
-    )
+  dbType: DatabaseType,
+) => {
+  const wrap = wrapIdentifierFp(dbType);
+  return pairs
+    .map((p) => `${p.parentAlias}.${wrap(p.parentColumn)} = ${p.childAlias}.${wrap(p.childColumn)}`)
     .join(" AND ");
+};
 
 export const findJoinCondition = (
   entities: MergedEntities,
@@ -189,7 +212,7 @@ export const findJoinCondition = (
   childTableName: string,
   parentAlias: string,
   childAlias: string,
-  quoted = false,
+  dbType: DatabaseType,
 ): string => {
   const relations = entities.getForeignKeysBetweenTables(parentTableName, childTableName);
 
@@ -204,7 +227,7 @@ export const findJoinCondition = (
           parentColumn: c.source,
           childColumn: c.target,
         })),
-        quoted,
+        dbType,
       ),
     ) ?? []),
     ...(relations.relationshipsReversed?.map((relation) =>
@@ -215,7 +238,7 @@ export const findJoinCondition = (
           parentColumn: c.target,
           childColumn: c.source,
         })),
-        quoted,
+        dbType,
       ),
     ) ?? []),
   ].join(" AND ");
@@ -233,7 +256,6 @@ export const buildWhereClauseFp =
     parentTableAlias: string | null,
     level: number,
     aliasMap: { [alias: string]: string },
-    quoted = false,
   ): string => {
     const whereConditions: string[] = [
       buildConditions(
@@ -245,7 +267,6 @@ export const buildWhereClauseFp =
         tableAlias,
         level + 1,
         aliasMap,
-        quoted,
       ),
       parentTableName && parentTableAlias
         ? findJoinCondition(
@@ -254,7 +275,7 @@ export const buildWhereClauseFp =
             field.name,
             parentTableAlias,
             tableAlias,
-            quoted,
+            dbType,
           )
         : null,
     ].filter(Boolean) as string[];
@@ -282,6 +303,7 @@ const parseOrderDirection = (direction: string): { sort: string; nulls?: string
 export const buildOrderByClauseFp =
   (dbType: DatabaseType = "pg") =>
   (entities: MergedEntities, field: SelectionAnalysis, tableAlias: string): string => {
+    const wrap = wrapIdentifierFp(dbType);
     if (field.arguments?.["orderBy"]) {
       const orderBy = field.arguments?.["orderBy"];
       // orderBy is an array or object of { column: direction } - no variable resolution needed
@@ -306,11 +328,11 @@ export const buildOrderByClauseFp =
           if (nulls) {
             if (dbType === "pg") {
               // PostgreSQL supports NULLS FIRST/LAST natively
-              return `${tableAlias}."${colName}" ${sort} NULLS ${nulls}`;
+              return `${tableAlias}.${wrap(colName)} ${sort} NULLS ${nulls}`;
             } else if (dbType === "mysql") {
               // MySQL: Use CASE statement for NULL handling
               const nullFirst = nulls === "FIRST";
-              return `CASE WHEN ${tableAlias}.${colName} IS NULL THEN ${nullFirst ? 0 : 1} ELSE ${nullFirst ? 1 : 0} END, ${tableAlias}.${colName} ${sort}`;
+              return `CASE WHEN ${tableAlias}.${wrap(colName)} IS NULL THEN ${nullFirst ? 0 : 1} ELSE ${nullFirst ? 1 : 0} END, ${tableAlias}.${wrap(colName)} ${sort}`;
             } else {
               // MSSQL requires CASE statements for NULL handling
               const nullFirst = nulls === "FIRST";
@@ -318,10 +340,10 @@ export const buildOrderByClauseFp =
 
               if ((nullFirst && isAsc) || (!nullFirst && !isAsc)) {
                 // NULLs naturally come first in this combination
-                return `${tableAlias}.[${colName}] ${sort}`;
+                return `${tableAlias}.${wrap(colName)} ${sort}`;
               } else {
                 // Need to force NULL positioning with CASE
-                return `CASE WHEN ${tableAlias}.${colName} IS NULL THEN ${nullFirst ? 0 : 1} ELSE ${nullFirst ? 1 : 0} END, ${tableAlias}.${colName} ${sort}`;
+                return `CASE WHEN ${tableAlias}.${wrap(colName)} IS NULL THEN ${nullFirst ? 0 : 1} ELSE ${nullFirst ? 1 : 0} END, ${tableAlias}.${wrap(colName)} ${sort}`;
               }
             }
           } else {
@@ -333,13 +355,7 @@ export const buildOrderByClauseFp =
               ) ${sort}`;
             }
 
-            if (dbType === "pg") {
-              return `${tableAlias}."${colName}" ${sort}`;
-            } else if (dbType === "mysql") {
-              return `${tableAlias}.${colName} ${sort}`;
-            } else {
-              return `${tableAlias}.${colName} ${sort}`;
-            }
+            return `${tableAlias}.${wrap(colName)} ${sort}`;
           }
         })
         .join(", ");
@@ -463,7 +479,6 @@ export const processFieldSelectionsFp =
     level: number,
     buildSubquery: (sel: SelectionAnalysis, level: number) => string,
     selectBuilder: (entry: [name: string, selector: string]) => string,
-    quoted = false,
   ): string => {
     const selectClauses: [string, string][] = [];
     const subQueries: [string, string][] = [];
@@ -487,7 +502,7 @@ export const processFieldSelectionsFp =
               selectClauses.push([`${colName}`, `(${vc.expression})`]);
             }
           } else {
-            let querySelector = `${tableAlias}.${wrapIf(sel.name, quoted)}`;
+            let querySelector = `${tableAlias}.${wrapIdentifierFp(dbType)(sel.name)}`;
 
             // Apply all directives using the handler registry
             querySelector = applyDirectives(

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

@@ -141,6 +141,8 @@ export const callStoredProcedure = async (
       }
     }
 
+    // Unquoted on purpose: tedious sends this as the TDS RPC procedure name,
+    // never as SQL text, so reserved words need no delimiting here.
     const data = await request.execute(sp.dottedName);
 
     return data?.recordset ?? false;

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

@@ -16,12 +16,16 @@ import {
   isAggregationField,
   isSingleQuery,
   processFieldSelectionsMSSQL,
+  wrapIdentifierMSSQL,
 } from "../../../common";
 
+// FOR JSON PATH uses the unbracketed alias as the JSON key, so bracket-quoting
+// (required for reserved words like PRINT) never leaks into results.
+
 // Generate CTE for aggregations
 const buildAggregationCTE = (
   groupByInfo: GroupByInfo,
-  dottedName: string,
+  dottedQuotedName: string,
   tableAlias: string,
   whereClause: string,
 ): string => {
@@ -31,7 +35,7 @@ const buildAggregationCTE = (
 
   // Add group by fields
   groupByFields.forEach((field) => {
-    selectClauses.push(`${tableAlias}.${field}`);
+    selectClauses.push(`${tableAlias}.${wrapIdentifierMSSQL(field)}`);
   });
 
   // Add aggregations
@@ -40,16 +44,18 @@ 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}.${wrapIdentifierMSSQL(agg.fieldName)}) AS ${agg.alias}`,
+      );
     }
   });
 
-  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}.${field}`).join(", ")}`;
+  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}.${wrapIdentifierMSSQL(field)}`).join(", ")}`;
 
   return `${cteAlias} AS (
     SELECT
       ${selectClauses.join(",\n      ")}
-    FROM ${dottedName} ${tableAlias}
+    FROM ${dottedQuotedName} ${tableAlias}
     ${whereClause}
     ${groupByClause}
   )`;
@@ -60,7 +66,7 @@ const buildGroupedQuery = (
   entities: MergedEntities,
   field: SelectionAnalysis,
   groupByInfo: GroupByInfo,
-  dottedName: string,
+  dottedQuotedName: string,
   tableAlias: string,
   whereClause: string,
 ): string => {
@@ -72,21 +78,24 @@ const buildGroupedQuery = (
   if (hasKey) {
     // Add key object with group by fields
     const keyFields = keys
-      .map((field) => `${cteAlias}.${field.name} AS ${field.alias || field.name}`)
+      .map(
+        (field) =>
+          `${cteAlias}.${wrapIdentifierMSSQL(field.name)} AS ${wrapIdentifierMSSQL(field.alias || field.name)}`,
+      )
       .join(", ");
 
     selectClauses.push(
-      `JSON_QUERY((SELECT ${keyFields} FOR JSON PATH, WITHOUT_ARRAY_WRAPPER, INCLUDE_NULL_VALUES)) AS [${keyResolved}]`,
+      `JSON_QUERY((SELECT ${keyFields} FOR JSON PATH, WITHOUT_ARRAY_WRAPPER, INCLUDE_NULL_VALUES)) AS ${wrapIdentifierMSSQL(keyResolved)}`,
     );
   }
 
   // Add aggregation results
   aggregations.forEach((agg) => {
     if (agg.name === "count") {
-      selectClauses.push(`${cteAlias}.${agg.alias} AS ${agg.nameResolved}`);
+      selectClauses.push(`${cteAlias}.${agg.alias} AS ${wrapIdentifierMSSQL(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}`,
+        `JSON_QUERY((SELECT ${cteAlias}.${agg.alias} AS ${wrapIdentifierMSSQL(agg.fieldAlias)} FOR JSON PATH, WITHOUT_ARRAY_WRAPPER, INCLUDE_NULL_VALUES)) AS ${wrapIdentifierMSSQL(agg.nameResolved)}`,
       );
     }
   });
@@ -98,20 +107,24 @@ const buildGroupedQuery = (
     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}`)
+        .map(
+          (sel) =>
+            `${tableAlias}.${wrapIdentifierMSSQL(sel.name)} AS ${wrapIdentifierMSSQL(sel.alias || sel.name)}`,
+        )
         .join(", ");
 
       if (itemFields) {
         const joinConditions = groupByFields.map(
-          (field) => `${tableAlias}.${field} = ${cteAlias}.${field}`,
+          (field) =>
+            `${tableAlias}.${wrapIdentifierMSSQL(field)} = ${cteAlias}.${wrapIdentifierMSSQL(field)}`,
         );
 
         selectClauses.push(`JSON_QUERY(ISNULL((
           SELECT ${itemFields}
-          FROM ${dottedName} ${tableAlias}
+          FROM ${dottedQuotedName} ${tableAlias}
           ${whereClause ? [whereClause, ...joinConditions].join(" AND ") : `WHERE ${joinConditions.join(" AND ")}`}
           FOR JSON PATH, INCLUDE_NULL_VALUES
-        ), '[]')) AS ${itemsSelection.alias || itemsSelection.name}`);
+        ), '[]')) AS ${wrapIdentifierMSSQL(itemsSelection.alias || itemsSelection.name)}`);
       }
     }
   }
@@ -168,7 +181,7 @@ export const generateSQL = (
 
     if (groupByInfo) {
       // This field requires a CTE
-      const { dottedName } = entities.queriesMap[field.name]!;
+      const { dottedQuotedName } = entities.queriesMap[field.name]!;
 
       const whereClause = buildWhereClauseMSSQL(
         entities,
@@ -182,7 +195,7 @@ export const generateSQL = (
         {},
       );
 
-      const cte = buildAggregationCTE(groupByInfo, dottedName, tableAlias, whereClause);
+      const cte = buildAggregationCTE(groupByInfo, dottedQuotedName, tableAlias, whereClause);
       ctes.push(cte);
     }
 
@@ -197,7 +210,7 @@ export const generateSQL = (
       {},
     );
 
-    fieldQueries.push(`(${fieldSQL}) as ${field.alias || field.name}`);
+    fieldQueries.push(`(${fieldSQL}) as ${wrapIdentifierMSSQL(field.alias || field.name)}`);
   });
 
   const cteClause = ctes.length > 0 ? `WITH\n${ctes.join(",\n")}\n` : "";
@@ -229,7 +242,7 @@ export const buildSQLForField = (
     throw new Error(`Table not found for field: ${field.name}`);
   }
 
-  const { dottedName, resolverName } = foundTable;
+  const { dottedQuotedName, resolverName } = foundTable;
 
   aliasMap[tableAlias] = resolverName;
 
@@ -254,7 +267,7 @@ export const buildSQLForField = (
       entities,
       field,
       groupByInfo,
-      dottedName,
+      dottedQuotedName,
       tableAlias,
       whereClause,
     );
@@ -282,10 +295,10 @@ export const buildSQLForField = (
         level,
         aliasMap,
       ),
-    ([name, selector]) => `${selector} AS ${name}`,
+    ([name, selector]) => `${selector} AS ${wrapIdentifierMSSQL(name)}`,
   );
 
-  const fromClause = `FROM ${dottedName} ${tableAlias}`;
+  const fromClause = `FROM ${dottedQuotedName} ${tableAlias}`;
 
   const orderByClause = buildOrderByClauseMSSQL(entities, field, tableAlias);
   const paginationClause = buildPaginationClauseMSSQL(field, variablesDefinition);

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

@@ -85,7 +85,7 @@ export const callStoredProcedure = async (
 ) => {
   try {
     const data = await executeQuery(
-      `CALL ${sp.dottedName}(${Object.keys(variables)
+      `CALL ${sp.dottedQuotedName}(${Object.keys(variables)
         .map((_, i) => `$${i + 1}`)
         .join(", ")});`,
       sp.db!,

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

@@ -16,12 +16,13 @@ import {
   isAggregationField,
   isSingleQuery,
   processFieldSelectionsMySQL,
+  wrapIdentifierMySQL,
 } from "../../../common";
 
 // Generate CTE for aggregations
 const buildAggregationCTE = (
   groupByInfo: GroupByInfo,
-  dottedName: string,
+  dottedQuotedName: string,
   tableAlias: string,
   whereClause: string,
 ): string => {
@@ -31,7 +32,7 @@ const buildAggregationCTE = (
 
   // Add group by fields
   groupByFields.forEach((field) => {
-    selectClauses.push(`${tableAlias}.${field}`);
+    selectClauses.push(`${tableAlias}.${wrapIdentifierMySQL(field)}`);
   });
 
   // Add aggregations
@@ -40,16 +41,18 @@ 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}.${wrapIdentifierMySQL(agg.fieldName)}) AS ${agg.alias}`,
+      );
     }
   });
 
-  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}.${field}`).join(", ")}`;
+  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}.${wrapIdentifierMySQL(field)}`).join(", ")}`;
 
   return `${cteAlias} AS (
     SELECT
       ${selectClauses.join(",\n      ")}
-    FROM ${dottedName} ${tableAlias}
+    FROM ${dottedQuotedName} ${tableAlias}
     ${whereClause}
     ${groupByClause}
   )`;
@@ -60,7 +63,7 @@ const buildGroupedQuery = (
   entities: MergedEntities,
   field: SelectionAnalysis,
   groupByInfo: GroupByInfo,
-  dottedName: string,
+  dottedQuotedName: string,
   tableAlias: string,
   whereClause: string,
 ): string => {
@@ -72,7 +75,7 @@ const buildGroupedQuery = (
   if (hasKey) {
     // Add key object with group by fields
     const keyFields = keys
-      .map((key) => `'${key.alias || key.name}', ${cteAlias}.${key.name}`)
+      .map((key) => `'${key.alias || key.name}', ${cteAlias}.${wrapIdentifierMySQL(key.name)}`)
       .join(", ");
 
     selectClauses.push(`'${keyResolved}', JSON_OBJECT(${keyFields})`);
@@ -96,12 +99,13 @@ const buildGroupedQuery = (
     if (itemsSelection?.selections) {
       const itemFields = itemsSelection.selections
         .filter((sel) => !isAggregationField(sel.name) && sel.name !== "items")
-        .map((sel) => `'${sel.alias || sel.name}', ${tableAlias}.${sel.name}`)
+        .map((sel) => `'${sel.alias || sel.name}', ${tableAlias}.${wrapIdentifierMySQL(sel.name)}`)
         .join(", ");
 
       if (itemFields) {
         const joinConditions = groupByFields.map(
-          (field) => `${tableAlias}.${field} = ${cteAlias}.${field}`,
+          (field) =>
+            `${tableAlias}.${wrapIdentifierMySQL(field)} = ${cteAlias}.${wrapIdentifierMySQL(field)}`,
         );
 
         const whereConditions = whereClause
@@ -110,7 +114,7 @@ const buildGroupedQuery = (
 
         selectClauses.push(`'${itemsSelection.alias || itemsSelection.name}', COALESCE((
           SELECT JSON_ARRAYAGG(JSON_OBJECT(${itemFields}))
-          FROM ${dottedName} ${tableAlias}
+          FROM ${dottedQuotedName} ${tableAlias}
           ${whereConditions}
         ), JSON_ARRAY())`);
       }
@@ -157,7 +161,7 @@ export const generateSQL = (
 
     if (groupByInfo) {
       // This field requires a CTE
-      const { dottedName } = entities.queriesMap[field.name]!;
+      const { dottedQuotedName } = entities.queriesMap[field.name]!;
 
       const whereClause = buildWhereClauseMySQL(
         entities,
@@ -169,10 +173,9 @@ export const generateSQL = (
         null,
         index + 1,
         {},
-        false,
       );
 
-      const cte = buildAggregationCTE(groupByInfo, dottedName, tableAlias, whereClause);
+      const cte = buildAggregationCTE(groupByInfo, dottedQuotedName, tableAlias, whereClause);
       ctes.push(cte);
     }
 
@@ -218,7 +221,7 @@ export const buildSQLForField = (
     throw new Error(`Table not found for field: ${field.name}`);
   }
 
-  const { dottedName, resolverName } = foundTable;
+  const { dottedQuotedName, resolverName } = foundTable;
 
   aliasMap[tableAlias] = resolverName;
 
@@ -232,7 +235,6 @@ export const buildSQLForField = (
     parentTableAlias,
     level,
     aliasMap,
-    false,
   );
 
   // Check if this is a GROUP BY query
@@ -244,7 +246,7 @@ export const buildSQLForField = (
       entities,
       field,
       groupByInfo,
-      dottedName,
+      dottedQuotedName,
       tableAlias,
       whereClause,
     );
@@ -273,10 +275,9 @@ export const buildSQLForField = (
         aliasMap,
       ),
     ([name, selector]) => `'${name}', ${selector}`,
-    false,
   );
 
-  const fromClause = `FROM ${dottedName} ${tableAlias}${withoutArrayWrapper ? " LIMIT 1" : ""}`;
+  const fromClause = `FROM ${dottedQuotedName} ${tableAlias}${withoutArrayWrapper ? " LIMIT 1" : ""}`;
 
   const orderByClause = buildOrderByClauseMySQL(entities, field, tableAlias);
   const paginationClause = buildPaginationClauseMySQL(field, variablesDefinition);

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

@@ -84,7 +84,7 @@ export const callStoredProcedure = async (
 ) => {
   try {
     const data = await executeQuery(
-      `SELECT * FROM ${sp.dottedName}(${Object.keys(variables)
+      `SELECT * FROM ${sp.dottedQuotedName}(${Object.keys(variables)
         .map((_, i) => `$${i + 1}`)
         .join(", ")});`,
       sp.db!,

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

@@ -169,7 +169,6 @@ export const generateSQL = (
         null,
         index + 1,
         {},
-        true,
       );
 
       const cte = buildAggregationCTE(groupByInfo, dottedQuotedName, tableAlias, whereClause);
@@ -232,7 +231,6 @@ export const buildSQLForField = (
     parentTableAlias,
     level,
     aliasMap,
-    true,
   );
 
   // Check if this is a GROUP BY query
@@ -273,7 +271,6 @@ export const buildSQLForField = (
         aliasMap,
       ),
     ([name, selector]) => `'${name}', ${selector}`,
-    true,
   );
 
   const fromClause = `FROM ${dottedQuotedName} ${tableAlias}`;

package/src/databases/schemaBuilder/generateInsert/index.ts

@@ -1,19 +1,13 @@
 import type { DatabaseType } from "../../../types/configuration";
 import type { TableResolver } from "../../../types/db";
 
+import { qualifiedNameFp, wrapIdentifierFp } from "../../common";
+
 export const generateInsertSQL =
   (toDb: DatabaseType) =>
   // oxlint-disable-next-line typescript/no-explicit-any
   (table: TableResolver, data: Record<string, any>[]) => {
-    const columnNames = table.columns.map((column) => {
-      if (toDb === "mssql") {
-        return column.name;
-      } else if (toDb === "mysql") {
-        return `\`${column.name}\``;
-      } else {
-        return `"${column.name}"`;
-      }
-    });
+    const columnNames = table.columns.map((column) => wrapIdentifierFp(toDb)(column.name));
 
     const valueRows = data.map((row) => {
       const values = table.columns.map((column) => {
@@ -26,18 +20,9 @@ export const generateInsertSQL =
       return `(${values.join(",")})`;
     });
 
-    if (toDb === "pg") {
-      return `INSERT INTO ${table?.dottedQuotedName} (${columnNames.join(",")}) VALUES\n${valueRows.join(",\n")}`;
-    } else if (toDb === "mssql") {
-      return `INSERT INTO ${table?.dottedName} (${columnNames.join(",")}) VALUES\n${valueRows.join(",\n")}`;
-    } else if (toDb === "mysql") {
-      // Generate backtick version of dotted name
-      const parts = table.dottedName.split(".");
-      const dottedBacktickName = parts.map((p) => `\`${p}\``).join(".");
-      return `INSERT INTO ${dottedBacktickName} (${columnNames.join(",")}) VALUES\n${valueRows.join(",\n")}`;
-    }
-
-    return "";
+    // Quoted for the target engine, not the source: table.dottedQuotedName
+    // carries the source dialect's delimiters and the two differ when converting.
+    return `INSERT INTO ${qualifiedNameFp(toDb)(table)} (${columnNames.join(",")}) VALUES\n${valueRows.join(",\n")}`;
   };
 
 export type GenerateInsertSQL = ReturnType<typeof generateInsertSQL>;

package/src/databases/transformers/data-transformers.ts

@@ -1,6 +1,7 @@
 import type { Database, Relationships } from "../../types/configuration";
 import type { RelationshipResolver, StoredProcedure, Table, Tables } from "../../types/db";
 
+import { qualifiedNameFp } from "../common";
 import { genResolverName } from "./genResolverName";
 
 /**
@@ -103,6 +104,7 @@ export const buildTableResolver = (tables: Tables, table: Table, db: Database) =
   return {
     ...table,
     db,
+    dottedQuotedName: qualifiedNameFp(db.type)(table),
     internalName,
     resolverName: internalName,
     relationships,
@@ -124,5 +126,6 @@ export const buildProcedureResolver = (sp: StoredProcedure, db: Database) => {
     internalName,
     resolverName,
     dottedName,
+    dottedQuotedName: qualifiedNameFp(db.type)(sp),
   };
 };

package/src/index.ts

@@ -450,8 +450,6 @@ export async function createBunServer(options?: Partial<Env>) {
 
   const server = serve(serverHandlers);
 
-  logger("graphoria").info({ port: server.port, prefixes }, "server ready");
-
   return {
     server,
     prefixes,