@graphoria/server 0.3.0 → 0.5.0

package/src/databases/common.ts

@@ -59,6 +59,18 @@ const resolveBooleanOperand = (
 
 export const generateTableAlias = (level: number): string => `t${level}`;
 
+/**
+ * A table whose alias is lexically in scope above the join being emitted, outermost
+ * first and including the immediate parent. Nested selections compile to correlated
+ * subqueries, so every enclosing alias stays referenceable — this is what lets a
+ * relationship condition name a column on an ancestor rather than a literal.
+ *
+ * Built fresh at each recursion rather than read off `aliasMap`: that map is flat,
+ * shared and written by two different level counters, so it cannot distinguish an
+ * enclosing scope from a sibling that merely ran earlier.
+ */
+export type QueryPathFrame = { table: string; alias: string };
+
 const mappingDbTypeCharVar: Record<DatabaseType, string> = {
   pg: "$",
   mysql: "$",
@@ -76,6 +88,7 @@ export const buildConditions = (
   aliasMap: { [alias: string]: string },
   /** Query name of the table being filtered — resolves its virtual columns. */
   tableName?: string,
+  ancestors: readonly QueryPathFrame[] = [],
 ): string => {
   if (!whereArgs) return "";
 
@@ -135,6 +148,13 @@ export const buildConditions = (
 
       const parentTableName = aliasMap[tableAlias];
 
+      // An EXISTS sits inside the WHERE of the block that binds `tableAlias`, so that
+      // block encloses it just as a selection subquery would. Extending the scope here
+      // is what makes a relation filter emit the same predicate as the selection form.
+      const scope = parentTableName
+        ? [...ancestors, { table: parentTableName, alias: tableAlias }]
+        : ancestors;
+
       const joinCondition = findJoinCondition(
         entities,
         parentTableName,
@@ -142,6 +162,7 @@ export const buildConditions = (
         tableAlias,
         nestedTableAlias,
         dbType,
+        scope,
       );
 
       // Record this relation's alias→table so a deeper nested where (3+ levels) can resolve
@@ -159,6 +180,7 @@ export const buildConditions = (
         level + 1,
         aliasMap,
         fieldName,
+        scope,
       );
 
       const existsClause = `EXISTS (
@@ -324,6 +346,47 @@ const columnCollation = (
   return column && "collation" in column ? column.collation : undefined;
 };
 
+// Resolves an `ancestor` condition to a qualified column on an enclosing alias.
+// Matches on entity identity rather than on the frame's key, because a frame may be
+// keyed by a suffixed relationship name (`app_users_ref`) and because resolverName
+// depends on the database's configurable `fieldNaming` — neither is comparable to
+// the schema/name pair the config declares. Nearest enclosing match wins, so a
+// self-referential chain binds to the closest occurrence.
+const ancestorOperand = (
+  entities: MergedEntities,
+  ancestors: readonly QueryPathFrame[],
+  ancestor: { schema: string; name: string; column: string },
+  leftTable: string,
+  leftColumn: string,
+  dbType: DatabaseType,
+): { sql: string; collate: string } => {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const frame = ancestors[i]!;
+    const entity = entities.queriesMap[frame.table];
+
+    if (entity?.schema !== ancestor.schema || entity.name !== ancestor.name) continue;
+
+    return {
+      sql: `${frame.alias}.${wrapIdentifierFp(dbType)(ancestor.column)}`,
+      // Unlike a literal comparison, this equates two character columns that may
+      // carry different collations — the case collateSuffix exists for.
+      collate: collateSuffix(
+        dbType,
+        columnCollation(entities, leftTable, leftColumn),
+        columnCollation(entities, frame.table, ancestor.column),
+      ),
+    };
+  }
+
+  const inScope = ancestors.map((a) => a.table).join(" > ");
+
+  throw new Error(
+    `Relationship condition references ancestor table "${ancestor.schema}.${ancestor.name}", which is not in this query's path. ` +
+      `In scope here: ${inScope || "(none)"}. ` +
+      `Nest this selection under ${ancestor.schema}.${ancestor.name}, or drop the "ancestor" condition.`,
+  );
+};
+
 const pairsToAnd = (
   pairs: {
     parentAlias: string;
@@ -377,6 +440,7 @@ const renderCondition = (
   column: string,
   operator: string,
   value: string | number | boolean | undefined,
+  ancestor?: { sql: string; collate: string },
 ): string => {
   const target = `${alias}.${wrapIdentifierFp(dbType)(column)}`;
 
@@ -384,7 +448,13 @@ const renderCondition = (
   if (operator === "is_not_null") return `${target} IS NOT NULL`;
 
   const sqlOperator = RELATIONSHIP_CONDITION_SQL_OPERATORS[operator];
-  if (!sqlOperator || value === undefined) {
+  if (!sqlOperator) {
+    throw new Error(`Invalid relationship condition operator "${operator}"`);
+  }
+
+  if (ancestor) return `${target} ${sqlOperator} ${ancestor.sql}${ancestor.collate}`;
+
+  if (value === undefined) {
     throw new Error(`Invalid relationship condition operator "${operator}"`);
   }
 
@@ -396,16 +466,25 @@ const renderCondition = (
 // toAlias). The from/to aliases flip between forward and reverse joins.
 const conditionsToAnd = (
   conditions: readonly RelationshipCondition[] | undefined,
-  fromAlias: string,
-  toAlias: string,
+  from: { alias: string; table: string },
+  to: { alias: string; table: string },
   dbType: DatabaseType,
+  entities: MergedEntities,
+  ancestors: readonly QueryPathFrame[],
 ): string =>
   (conditions ?? [])
-    .map((c) =>
-      c.source !== undefined
-        ? renderCondition(dbType, fromAlias, c.source, c.operator ?? "eq", c.value)
-        : renderCondition(dbType, toAlias, c.target!, c.operator ?? "eq", c.value),
-    )
+    .map((c) => {
+      const side = c.source !== undefined ? from : to;
+      const column = (c.source ?? c.target)!;
+
+      // The from/to flip above picks the left operand only; an ancestor is the right
+      // operand and resolves by table identity, so it is direction-independent.
+      const ancestor = c.ancestor
+        ? ancestorOperand(entities, ancestors, c.ancestor, side.table, column, dbType)
+        : undefined;
+
+      return renderCondition(dbType, side.alias, column, c.operator ?? "eq", c.value, ancestor);
+    })
     .join(" AND ");
 
 const joinParts = (...parts: string[]): string => parts.filter(Boolean).join(" AND ");
@@ -417,6 +496,7 @@ export const findJoinCondition = (
   parentAlias: string,
   childAlias: string,
   dbType: DatabaseType,
+  ancestors: readonly QueryPathFrame[] = [],
 ): string => {
   const relations = entities.getForeignKeysBetweenTables(parentTableName, childTableName);
 
@@ -436,7 +516,14 @@ export const findJoinCondition = (
           })),
           dbType,
         ),
-        conditionsToAnd(relation.conditions, parentAlias, childAlias, dbType),
+        conditionsToAnd(
+          relation.conditions,
+          { alias: parentAlias, table: parentTableName },
+          { alias: childAlias, table: childTableName },
+          dbType,
+          entities,
+          ancestors,
+        ),
       ),
     ) ?? []),
     ...(relations.relationshipsReversed?.map((relation) =>
@@ -452,7 +539,14 @@ export const findJoinCondition = (
           })),
           dbType,
         ),
-        conditionsToAnd(relation.conditions, childAlias, parentAlias, dbType),
+        conditionsToAnd(
+          relation.conditions,
+          { alias: childAlias, table: childTableName },
+          { alias: parentAlias, table: parentTableName },
+          dbType,
+          entities,
+          ancestors,
+        ),
       ),
     ) ?? []),
   ].join(" AND ");
@@ -470,6 +564,7 @@ export const buildWhereClauseFp =
     parentTableAlias: string | null,
     level: number,
     aliasMap: { [alias: string]: string },
+    ancestors: readonly QueryPathFrame[] = [],
   ): string => {
     const whereConditions: string[] = [
       buildConditions(
@@ -482,7 +577,10 @@ export const buildWhereClauseFp =
         level + 1,
         aliasMap,
         field.name ?? aliasMap[tableAlias],
+        ancestors,
       ),
+      // `ancestors` already ends with this join's parent, and the child is the field
+      // being emitted, so the scope needs no splicing here.
       parentTableName && parentTableAlias
         ? findJoinCondition(
             entities,
@@ -491,6 +589,7 @@ export const buildWhereClauseFp =
             parentTableAlias,
             tableAlias,
             dbType,
+            ancestors,
           )
         : null,
     ].filter(Boolean) as string[];

package/src/databases/core/executor.ts

@@ -1,14 +1,24 @@
 import type { VariableDefinition } from "../../analyzeQuery/types";
+import type { QuerySource } from "../../logging/slowQuery";
 import type { Database } from "../../types/configuration";
 import type { ProcedureResolver } from "../../types/db";
 
 import { databaseAdapters } from "./function-mapping";
 import { logger } from "../../logging";
+import { reportQueryDuration } from "../../logging/slowQuery";
+import { startSpan } from "../../observability/tracing";
 
 /**
  * Core database execution functions
  */
 
+/** Names only. The variable values are caller data and never reach a span. */
+const sourceAttributes = (source?: QuerySource) => ({
+  "graphql.operation.name": source?.operation.name ?? undefined,
+  "graphql.operation.type": source?.operation.type,
+  "graphoria.role": source?.role,
+});
+
 export const executeQuery = async <T>(
   query: string,
   db: Database,
@@ -16,6 +26,7 @@ export const executeQuery = async <T>(
   variables: Record<string, unknown>,
   /** Per-operation override. `undefined` leaves the engine on its own default. */
   timeoutMs?: number,
+  source?: QuerySource,
 ) => {
   const adapter = databaseAdapters[db?.type];
   if (!adapter) {
@@ -24,16 +35,40 @@ export const executeQuery = async <T>(
 
   const log = logger("db").child({ dbType: db.type, dbName: db.name });
   const startTime = Bun.nanoseconds();
+  const report = (durationMs: number, outcome: "success" | "error") =>
+    reportQueryDuration({
+      durationMs,
+      dbType: db.type,
+      dbName: db.name,
+      sql: query,
+      outcome,
+      ...source,
+    });
+  // Every literal is hoisted into a bound parameter, so the statement text
+  // carries no caller data and is safe to export.
+  const span = startSpan("db.query", {
+    kind: "client",
+    attributes: {
+      "db.system": db.type,
+      "db.name": db.name,
+      "db.statement": query,
+      ...sourceAttributes(source),
+    },
+  });
 
   try {
     const result = await adapter.execute<T>(query, db, variablesDefinition, variables, timeoutMs);
-    log.debug(
-      { durationMs: (Bun.nanoseconds() - startTime) / 1e6, queryLength: query.length },
-      "query executed",
-    );
+    const durationMs = (Bun.nanoseconds() - startTime) / 1e6;
+    log.debug({ durationMs, queryLength: query.length }, "query executed");
+    report(durationMs, "success");
+    span?.end();
     return result;
   } catch (error) {
-    log.error({ err: error, durationMs: (Bun.nanoseconds() - startTime) / 1e6 }, "query failed");
+    const durationMs = (Bun.nanoseconds() - startTime) / 1e6;
+    log.error({ err: error, durationMs }, "query failed");
+    report(durationMs, "error");
+    span?.recordError(error);
+    span?.end();
     throw error;
   }
 };
@@ -45,6 +80,7 @@ export const executeQueryJSON = async <T>(
   variables: Record<string, unknown>,
   /** Per-operation override. `undefined` leaves the engine on its own default. */
   timeoutMs?: number,
+  source?: QuerySource,
 ) => {
   const adapter = databaseAdapters[db.type];
   if (!adapter) {
@@ -53,6 +89,24 @@ export const executeQueryJSON = async <T>(
 
   const log = logger("db").child({ dbType: db.type, dbName: db.name });
   const startTime = Bun.nanoseconds();
+  const report = (durationMs: number, outcome: "success" | "error") =>
+    reportQueryDuration({
+      durationMs,
+      dbType: db.type,
+      dbName: db.name,
+      sql: query,
+      outcome,
+      ...source,
+    });
+  const span = startSpan("db.query", {
+    kind: "client",
+    attributes: {
+      "db.system": db.type,
+      "db.name": db.name,
+      "db.statement": query,
+      ...sourceAttributes(source),
+    },
+  });
 
   try {
     const result = await adapter.executeJson<T>(
@@ -62,24 +116,25 @@ export const executeQueryJSON = async <T>(
       variables,
       timeoutMs,
     );
-    log.debug(
-      { durationMs: (Bun.nanoseconds() - startTime) / 1e6, queryLength: query.length },
-      "query executed (json)",
-    );
+    const durationMs = (Bun.nanoseconds() - startTime) / 1e6;
+    log.debug({ durationMs, queryLength: query.length }, "query executed (json)");
+    report(durationMs, "success");
+    span?.end();
     return result;
   } catch (error) {
-    log.error(
-      { err: error, durationMs: (Bun.nanoseconds() - startTime) / 1e6 },
-      "query failed (json)",
-    );
+    const durationMs = (Bun.nanoseconds() - startTime) / 1e6;
+    log.error({ err: error, durationMs }, "query failed (json)");
+    report(durationMs, "error");
+    span?.recordError(error);
+    span?.end();
     throw error;
   }
 };
 
 export const callStoredProcedure = async (
   sp: ProcedureResolver,
-  variablesDefinition: VariableDefinition[],
   variables: Record<string, unknown> = {},
+  source?: QuerySource,
 ) => {
   const adapter = databaseAdapters[sp.db!.type];
   if (!adapter) {
@@ -92,16 +147,38 @@ export const callStoredProcedure = async (
     procedure: sp.dottedName,
   });
   const startTime = Bun.nanoseconds();
+  const report = (durationMs: number, outcome: "success" | "error") =>
+    reportQueryDuration({
+      durationMs,
+      dbType: sp.db!.type,
+      dbName: sp.db!.name,
+      procedure: sp.dottedName,
+      outcome,
+      ...source,
+    });
+  const span = startSpan("db.procedure", {
+    kind: "client",
+    attributes: {
+      "db.system": sp.db!.type,
+      "db.name": sp.db!.name,
+      "db.operation": sp.dottedName,
+      ...sourceAttributes(source),
+    },
+  });
 
   try {
-    const result = await adapter.callStoredProcedure(sp, variablesDefinition, variables);
-    log.debug({ durationMs: (Bun.nanoseconds() - startTime) / 1e6 }, "stored procedure executed");
+    const result = await adapter.callStoredProcedure(sp, variables);
+    const durationMs = (Bun.nanoseconds() - startTime) / 1e6;
+    log.debug({ durationMs }, "stored procedure executed");
+    report(durationMs, "success");
+    span?.end();
     return result;
   } catch (error) {
-    log.error(
-      { err: error, durationMs: (Bun.nanoseconds() - startTime) / 1e6 },
-      "stored procedure failed",
-    );
+    const durationMs = (Bun.nanoseconds() - startTime) / 1e6;
+    log.error({ err: error, durationMs }, "stored procedure failed");
+    report(durationMs, "error");
+    span?.recordError(error);
+    span?.end();
     throw error;
   }
 };

package/src/databases/core/function-mapping.ts

@@ -80,7 +80,7 @@ export type InsertAuthUserInput = {
   claims?: Record<string, unknown>;
 };
 
-type DatabaseFunctions = {
+export type DatabaseFunctions = {
   query: (
     entities: MergedEntities,
     operation: OperationAnalysis,
@@ -105,7 +105,6 @@ type DatabaseFunctions = {
   ) => Promise<T>;
   callStoredProcedure: (
     sp: ProcedureResolver,
-    variablesDefinition: VariableDefinition[],
     parameters: Record<string, unknown>,
     // oxlint-disable-next-line typescript/no-explicit-any
   ) => Promise<any>;

package/src/databases/core/procedure-arguments.ts

@@ -0,0 +1,25 @@
+import type { VariableDefinition } from "../../analyzeQuery/types";
+import type { ProcedureResolver } from "../../types/db";
+
+/**
+ * Orders a procedure call's arguments for the engines that bind positionally.
+ *
+ * `$1, $2, …` are numbered by one list and filled from another, so the two have
+ * to be the same list or the values land on the wrong parameters. Signature
+ * order comes from the introspected metadata; the caller's argument object is
+ * unordered and reflects the GraphQL query text.
+ *
+ * Arguments the metadata doesn't account for keep their supplied order and
+ * follow: an unnamed procedure parameter is introspected under a synthesized
+ * name that no caller can match, and dropping the value there would be worse
+ * than binding it where it was already going.
+ */
+export const orderProcedureArguments = (
+  sp: ProcedureResolver,
+  variables: Record<string, unknown>,
+): VariableDefinition[] => {
+  const declared = sp.parameters.map((p) => p.name).filter((name) => name in variables);
+  const undeclared = Object.keys(variables).filter((name) => !declared.includes(name));
+
+  return [...declared, ...undeclared].map((name) => ({ name, type: "", required: false }));
+};

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

@@ -161,7 +161,6 @@ export const executeQueryJSONSingle = executeQueryJSONFactory(true);
 
 export const callStoredProcedure = async (
   sp: ProcedureResolver,
-  variablesDefinition: VariableDefinition[],
   variables: Record<string, unknown> = {},
 ) => {
   try {
@@ -170,8 +169,6 @@ export const callStoredProcedure = async (
     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") {

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

@@ -4,7 +4,7 @@ import type {
   VariableDefinition,
 } from "../../../../analyzeQuery/types";
 import type { MergedEntities } from "../../../../configuration/getSchemas/mergeEntities";
-import type { GroupByInfo, PageLimits } from "../../../common";
+import type { GroupByInfo, PageLimits, QueryPathFrame } from "../../../common";
 
 import {
   buildOrderByClauseMSSQL,
@@ -265,6 +265,7 @@ export const buildSQLForField = (
   level: number,
   aliasMap: { [alias: string]: string },
   pageLimits: PageLimits | null,
+  ancestors: readonly QueryPathFrame[] = [],
 ): string => {
   const tableAlias = generateTableAlias(level);
 
@@ -290,6 +291,7 @@ export const buildSQLForField = (
     parentTableAlias,
     level,
     aliasMap,
+    ancestors,
   );
 
   // Check if this is a GROUP BY query
@@ -330,6 +332,7 @@ export const buildSQLForField = (
         level,
         aliasMap,
         pageLimits,
+        [...ancestors, { table: resolverName, alias: tableAlias }],
       ),
     ([name, selector]) => `${selector} AS ${wrapIdentifierMSSQL(name)}`,
   );

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

@@ -7,6 +7,7 @@ import type { ProcedureResolver } from "../../../types/db";
 
 import { BunSQLConnectionOptionsZod } from "../../../config/types/db";
 import { databasesConnections } from "../../../singletons/databases";
+import { orderProcedureArguments } from "../../core/procedure-arguments";
 import { toMySQLPlaceholders } from "./placeholders";
 
 // Every pool bound comes from the schema, which is the only place they are
@@ -97,22 +98,24 @@ export const executeQueryJSONFactory =
 export const executeQueryJSON = executeQueryJSONFactory();
 export const executeQueryJSONSingle = executeQueryJSONFactory(true);
 
+// The generated schema types every stored procedure mutation as `Boolean!`, so
+// the call reports whether it ran, not what it selected. Returning the rows here
+// would put an array behind a field the schema promises is a boolean.
 export const callStoredProcedure = async (
   sp: ProcedureResolver,
-  variablesDefinition: VariableDefinition[],
   variables: Record<string, unknown>,
 ) => {
   try {
-    const data = await executeQuery(
-      `CALL ${sp.dottedQuotedName}(${Object.keys(variables)
-        .map((_, i) => `$${i + 1}`)
-        .join(", ")});`,
+    const args = orderProcedureArguments(sp, variables);
+
+    await executeQuery(
+      `CALL ${sp.dottedQuotedName}(${args.map((_, i) => `$${i + 1}`).join(", ")});`,
       sp.db!,
-      variablesDefinition,
+      args,
       variables,
     );
 
-    return data;
+    return true;
   } catch {
     return false;
   }

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

@@ -4,7 +4,7 @@ import type {
   VariableDefinition,
 } from "../../../../analyzeQuery/types";
 import type { MergedEntities } from "../../../../configuration/getSchemas/mergeEntities";
-import type { GroupByInfo, PageLimits } from "../../../common";
+import type { GroupByInfo, PageLimits, QueryPathFrame } from "../../../common";
 
 import {
   buildOrderByClauseMySQL,
@@ -105,7 +105,7 @@ const buildGroupedQuery = (
       selectClauses.push(`'${agg.nameResolved}', ${cteAlias}.${agg.alias}`);
     } else {
       selectClauses.push(
-        `'${agg.nameResolved}', JSON_OBJECT('${agg.fieldAlias}', COALESCE(${cteAlias}.${agg.alias}, NULL))`,
+        `'${agg.nameResolved}', JSON_OBJECT('${agg.fieldAlias}', ${cteAlias}.${agg.alias})`,
       );
     }
   });
@@ -257,6 +257,7 @@ export const buildSQLForField = (
   level: number,
   aliasMap: { [alias: string]: string },
   pageLimits: PageLimits | null,
+  ancestors: readonly QueryPathFrame[] = [],
 ): string => {
   const tableAlias = generateTableAlias(level);
 
@@ -282,6 +283,7 @@ export const buildSQLForField = (
     parentTableAlias,
     level,
     aliasMap,
+    ancestors,
   );
 
   // Check if this is a GROUP BY query
@@ -322,6 +324,7 @@ export const buildSQLForField = (
         level,
         aliasMap,
         pageLimits,
+        [...ancestors, { table: resolverName, alias: tableAlias }],
       ),
     ([name, selector]) => `'${name}', ${selector}`,
   );

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

@@ -7,6 +7,7 @@ import type { ProcedureResolver } from "../../../types/db";
 
 import { BunSQLConnectionOptionsZod } from "../../../config/types/db";
 import { databasesConnections } from "../../../singletons/databases";
+import { orderProcedureArguments } from "../../core/procedure-arguments";
 import { getQueryTimeoutMs } from "../../../singletons/queryTimeout";
 
 // Every pool bound comes from the schema, which is the only place they are
@@ -138,22 +139,24 @@ export const executeQueryJSONFactory =
 export const executeQueryJSON = executeQueryJSONFactory();
 export const executeQueryJSONSingle = executeQueryJSONFactory(true);
 
+// The generated schema types every stored procedure mutation as `Boolean!`, so
+// the call reports whether it ran, not what it selected. Returning the rows here
+// would put an array behind a field the schema promises is a boolean.
 export const callStoredProcedure = async (
   sp: ProcedureResolver,
-  variablesDefinition: VariableDefinition[],
   variables: Record<string, unknown>,
 ) => {
   try {
-    const data = await executeQuery(
-      `SELECT * FROM ${sp.dottedQuotedName}(${Object.keys(variables)
-        .map((_, i) => `$${i + 1}`)
-        .join(", ")});`,
+    const args = orderProcedureArguments(sp, variables);
+
+    await executeQuery(
+      `SELECT * FROM ${sp.dottedQuotedName}(${args.map((_, i) => `$${i + 1}`).join(", ")});`,
       sp.db!,
-      variablesDefinition,
+      args,
       variables,
     );
 
-    return data;
+    return true;
   } catch {
     return false;
   }

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

@@ -4,7 +4,7 @@ import type {
   VariableDefinition,
 } from "../../../../analyzeQuery/types";
 import type { MergedEntities } from "../../../../configuration/getSchemas/mergeEntities";
-import type { GroupByInfo, PageLimits } from "../../../common";
+import type { GroupByInfo, PageLimits, QueryPathFrame } from "../../../common";
 
 import {
   buildOrderByClausePG,
@@ -101,7 +101,7 @@ const buildGroupedQuery = (
       selectClauses.push(`'${agg.nameResolved}', ${cteAlias}.${agg.alias}`);
     } else {
       selectClauses.push(
-        `'${agg.nameResolved}', json_build_object('${agg.fieldAlias}', COALESCE(${cteAlias}.${agg.alias}, null))`,
+        `'${agg.nameResolved}', json_build_object('${agg.fieldAlias}', ${cteAlias}.${agg.alias})`,
       );
     }
   });
@@ -242,6 +242,7 @@ export const buildSQLForField = (
   level: number,
   aliasMap: { [alias: string]: string },
   pageLimits: PageLimits | null,
+  ancestors: readonly QueryPathFrame[] = [],
 ): string => {
   const tableAlias = generateTableAlias(level);
 
@@ -267,6 +268,7 @@ export const buildSQLForField = (
     parentTableAlias,
     level,
     aliasMap,
+    ancestors,
   );
 
   // Check if this is a GROUP BY query
@@ -307,6 +309,7 @@ export const buildSQLForField = (
         level,
         aliasMap,
         pageLimits,
+        [...ancestors, { table: resolverName, alias: tableAlias }],
       ),
     ([name, selector]) => `'${name}', ${selector}`,
   );