@smartive/graphql-magic 9.1.2 → 10.0.0

package/src/resolvers/mutations.ts

@@ -3,9 +3,9 @@ import { DateTime } from 'luxon';
 import { v4 as uuid } from 'uuid';
 import { Context, FullContext } from '../context';
 import { ForbiddenError, GraphQLError } from '../errors';
-import { Model, ModelField } from '../models/models';
+import { EntityField, EntityModel } from '../models/models';
 import { Entity, FullEntity } from '../models/mutation-hook';
-import { get, isEnumList, isPrimitive, it, summonByName, typeToField } from '../models/utils';
+import { get, isPrimitive, it, typeToField } from '../models/utils';
 import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
 import { resolve } from './resolver';
 import { AliasGenerator } from './utils';
@@ -14,7 +14,7 @@ export const mutationResolver = async (_parent: any, args: any, partialCtx: Cont
   return await partialCtx.knex.transaction(async (knex) => {
     const [, mutation, modelName] = it(info.fieldName.match(/^(create|update|delete|restore)(.+)$/));
     const ctx = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
-    const model = summonByName(ctx.models, modelName);
+    const model = ctx.models.getModel(modelName, 'entity');
     switch (mutation) {
       case 'create':
         return await create(model, args, ctx);
@@ -28,11 +28,14 @@ export const mutationResolver = async (_parent: any, args: any, partialCtx: Cont
   });
 };
 
-const create = async (model: Model, { data: input }: { data: any }, ctx: FullContext) => {
+const create = async (model: EntityModel, { data: input }: { data: any }, ctx: FullContext) => {
   const normalizedInput = { ...input };
   normalizedInput.id = uuid();
   normalizedInput.createdAt = ctx.now;
   normalizedInput.createdById = ctx.user.id;
+  if (model.parent) {
+    normalizedInput.type = model.name;
+  }
   sanitize(ctx, model, normalizedInput);
 
   await checkCanWrite(ctx, model, normalizedInput, 'CREATE');
@@ -40,14 +43,31 @@ const create = async (model: Model, { data: input }: { data: any }, ctx: FullCon
 
   const data = { prev: {}, input, normalizedInput, next: normalizedInput };
   await ctx.mutationHook?.(model, 'create', 'before', data, ctx);
-  await ctx.knex(model.name).insert(normalizedInput);
+  if (model.parent) {
+    const rootInput = {};
+    const childInput = { id: normalizedInput.id };
+    for (const field of model.fields) {
+      const columnName = field.kind === 'relation' ? `${field.name}Id` : field.name;
+      if (columnName in normalizedInput) {
+        if (field.inherited) {
+          rootInput[columnName] = normalizedInput[columnName];
+        } else {
+          childInput[columnName] = normalizedInput[columnName];
+        }
+      }
+    }
+    await ctx.knex(model.parent).insert(rootInput);
+    await ctx.knex(model.name).insert(childInput);
+  } else {
+    await ctx.knex(model.name).insert(normalizedInput);
+  }
   await createRevision(model, normalizedInput, ctx);
   await ctx.mutationHook?.(model, 'create', 'after', data, ctx);
 
   return await resolve(ctx, normalizedInput.id);
 };
 
-const update = async (model: Model, { where, data: input }: { where: any; data: any }, ctx: FullContext) => {
+const update = async (model: EntityModel, { where, data: input }: { where: any; data: any }, ctx: FullContext) => {
   if (Object.keys(where).length === 0) {
     throw new Error(`No ${model.name} specified.`);
   }
@@ -72,7 +92,30 @@ const update = async (model: Model, { where, data: input }: { where: any; data:
     const next = { ...prev, ...normalizedInput };
     const data = { prev, input, normalizedInput, next };
     await ctx.mutationHook?.(model, 'update', 'before', data, ctx);
-    await ctx.knex(model.name).where(where).update(normalizedInput);
+
+    if (model.parent) {
+      const rootInput = {};
+      const childInput = {};
+      for (const field of model.fields) {
+        const columnName = field.kind === 'relation' ? `${field.name}Id` : field.name;
+        if (columnName in normalizedInput) {
+          if (field.inherited) {
+            rootInput[columnName] = normalizedInput[columnName];
+          } else {
+            childInput[columnName] = normalizedInput[columnName];
+          }
+        }
+      }
+      if (Object.keys(rootInput).length) {
+        await ctx.knex(model.parent).where({ id: prev.id }).update(rootInput);
+      }
+      if (Object.keys(childInput).length) {
+        await ctx.knex(model.name).where({ id: prev.id }).update(childInput);
+      }
+    } else {
+      await ctx.knex(model.name).where({ id: prev.id }).update(normalizedInput);
+    }
+
     await createRevision(model, next, ctx);
     await ctx.mutationHook?.(model, 'update', 'after', data, ctx);
   }
@@ -82,12 +125,13 @@ const update = async (model: Model, { where, data: input }: { where: any; data:
 
 type Callbacks = (() => Promise<void>)[];
 
-const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolean }, ctx: FullContext) => {
+const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun: boolean }, ctx: FullContext) => {
   if (Object.keys(where).length === 0) {
     throw new Error(`No ${model.name} specified.`);
   }
 
-  const entity = await getEntityToMutate(ctx, model, where, 'DELETE');
+  const rootModel = model.rootModel;
+  const entity = await getEntityToMutate(ctx, rootModel, where, 'DELETE');
 
   if (entity.deleted) {
     throw new ForbiddenError('Entity is already deleted.');
@@ -107,7 +151,7 @@ const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolea
   const mutations: Callbacks = [];
   const afterHooks: Callbacks = [];
 
-  const deleteCascade = async (currentModel: Model, entity: FullEntity) => {
+  const deleteCascade = async (currentModel: EntityModel, entity: FullEntity) => {
     if (entity.deleted) {
       return;
     }
@@ -140,10 +184,9 @@ const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolea
     }
 
     for (const {
-      model: descendantModel,
-      foreignKey,
-      field: { name, onDelete },
-    } of currentModel.reverseRelations) {
+      targetModel: descendantModel,
+      field: { name, foreignKey, onDelete },
+    } of currentModel.reverseRelations.filter((reverseRelation) => !reverseRelation.field.inherited)) {
       const query = ctx.knex(descendantModel.name).where({ [foreignKey]: entity.id });
       switch (onDelete) {
         case 'set-null': {
@@ -189,7 +232,7 @@ const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolea
     }
   };
 
-  await deleteCascade(model, entity);
+  await deleteCascade(rootModel, entity);
 
   for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
     await callback();
@@ -206,12 +249,14 @@ const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolea
   return entity.id;
 };
 
-const restore = async (model: Model, { where }: { where: any }, ctx: FullContext) => {
+const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullContext) => {
   if (Object.keys(where).length === 0) {
     throw new Error(`No ${model.name} specified.`);
   }
 
-  const entity = await getEntityToMutate(ctx, model, where, 'RESTORE');
+  const rootModel = model.rootModel;
+
+  const entity = await getEntityToMutate(ctx, rootModel, where, 'RESTORE');
 
   if (!entity.deleted) {
     throw new ForbiddenError('Entity is not deleted.');
@@ -221,7 +266,7 @@ const restore = async (model: Model, { where }: { where: any }, ctx: FullContext
   const mutations: Callbacks = [];
   const afterHooks: Callbacks = [];
 
-  const restoreCascade = async (currentModel: Model, relatedEntity: FullEntity) => {
+  const restoreCascade = async (currentModel: EntityModel, relatedEntity: FullEntity) => {
     if (!relatedEntity.deleted || !relatedEntity.deletedAt || !relatedEntity.deletedAt.equals(entity.deletedAt)) {
       return;
     }
@@ -243,9 +288,12 @@ const restore = async (model: Model, { where }: { where: any }, ctx: FullContext
       });
     }
 
-    for (const { model: descendantModel, foreignKey } of currentModel.reverseRelations.filter(
-      ({ model: { deletable } }) => deletable
-    )) {
+    for (const {
+      targetModel: descendantModel,
+      field: { foreignKey },
+    } of currentModel.reverseRelations
+      .filter((reverseRelation) => !reverseRelation.field.inherited)
+      .filter(({ targetModel: { deletable } }) => deletable)) {
       const query = ctx.knex(descendantModel.name).where({ [foreignKey]: relatedEntity.id });
       applyPermissions(ctx, descendantModel.name, descendantModel.name, query, 'RESTORE');
       const descendants = await query;
@@ -255,7 +303,7 @@ const restore = async (model: Model, { where }: { where: any }, ctx: FullContext
     }
   };
 
-  await restoreCascade(model, entity);
+  await restoreCascade(rootModel, entity);
 
   for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
     await callback();
@@ -264,32 +312,46 @@ const restore = async (model: Model, { where }: { where: any }, ctx: FullContext
   return entity.id;
 };
 
-const createRevision = async (model: Model, data: Entity, ctx: Context) => {
+const createRevision = async (model: EntityModel, data: Entity, ctx: Context) => {
   if (model.updatable) {
-    const revisionData: Entity = {
-      id: uuid(),
-      [`${typeToField(model.name)}Id`]: data.id,
+    const revisionId = uuid();
+    const rootRevisionData: Entity = {
+      id: revisionId,
+      [`${typeToField(model.parent || model.name)}Id`]: data.id,
       createdAt: ctx.now,
       createdById: ctx.user.id,
     };
 
     if (model.deletable) {
-      revisionData.deleted = data.deleted || false;
+      rootRevisionData.deleted = data.deleted || false;
     }
+    const childRevisionData = { id: revisionId };
 
-    for (const { kind: type, name, nonNull, ...field } of model.fields.filter(({ updatable }) => updatable)) {
-      const col = type === 'relation' ? `${name}Id` : name;
-      if (nonNull && (!(col in data) || col === undefined || col === null)) {
-        revisionData[col] = get(field, 'defaultValue');
+    for (const field of model.fields.filter(({ updatable }) => updatable)) {
+      const col = field.kind === 'relation' ? `${field.name}Id` : field.name;
+      let value;
+      if (field.nonNull && (!(col in data) || col === undefined || col === null)) {
+        value = get(field, 'defaultValue');
       } else {
-        revisionData[col] = data[col];
+        value = data[col];
       }
+      if (!model.parent || field.inherited) {
+        rootRevisionData[col] = value;
+      } else {
+        childRevisionData[col] = value;
+      }
+    }
+
+    if (model.parent) {
+      await ctx.knex(`${model.parent}Revision`).insert(rootRevisionData);
+      await ctx.knex(`${model.name}Revision`).insert(childRevisionData);
+    } else {
+      await ctx.knex(`${model.name}Revision`).insert(rootRevisionData);
     }
-    await ctx.knex(`${model.name}Revision`).insert(revisionData);
   }
 };
 
-const sanitize = (ctx: FullContext, model: Model, data: Entity) => {
+const sanitize = (ctx: FullContext, model: EntityModel, data: Entity) => {
   if (model.updatable) {
     data.updatedAt = ctx.now;
     data.updatedById = ctx.user.id;
@@ -307,12 +369,12 @@ const sanitize = (ctx: FullContext, model: Model, data: Entity) => {
       continue;
     }
 
-    if (isEnumList(ctx.rawModels, field) && Array.isArray(data[key])) {
+    if (field.list && field.kind === 'enum' && Array.isArray(data[key])) {
       data[key] = `{${(data[key] as string[]).join(',')}}`;
       continue;
     }
   }
 };
 
-const isEndOfDay = (field?: ModelField) =>
+const isEndOfDay = (field?: EntityField) =>
   isPrimitive(field) && field.type === 'DateTime' && field?.endOfDay === true && field?.dateTimeType === 'date';

package/src/resolvers/node.ts

@@ -8,8 +8,8 @@ import type {
 } from 'graphql';
 
 import { FullContext } from '../context';
-import { Model } from '../models/models';
-import { get, isObjectModel, summonByKey, summonByName } from '../models/utils';
+import { EntityModel, Relation } from '../models/models';
+import { get, isObjectModel, summonByKey } from '../models/utils';
 import {
   getFragmentTypeName,
   getNameOrAlias,
@@ -24,15 +24,18 @@ import {
 export type ResolverNode = {
   ctx: FullContext;
 
-  tableName: string;
+  rootModel: EntityModel;
+  rootTableAlias: string;
+
+  model: EntityModel;
   tableAlias: string;
-  shortTableAlias: string;
+
+  resultAlias: string;
 
   baseTypeDefinition: ObjectTypeDefinitionNode;
-  baseModel?: Model;
+  baseModel?: EntityModel;
 
   typeDefinition: ObjectTypeDefinitionNode;
-  model: Model;
 
   selectionSet: readonly SelectionNode[];
 };
@@ -40,24 +43,20 @@ export type ResolverNode = {
 export type FieldResolverNode = ResolverNode & {
   field: FieldNode;
   fieldDefinition: FieldDefinitionNode;
-  foreignKey?: string;
   isList: boolean;
 };
 
-export type WhereNode = {
-  ctx: FullContext;
-  tableName: string;
-  tableAlias: string;
-  shortTableAlias: string;
-  model: Model;
-
-  foreignKey?: string;
+export type RelationResolverNode = FieldResolverNode & {
+  relation: Relation;
+  foreignKey: string;
 };
 
 export const getResolverNode = ({
   ctx,
   node,
   tableAlias,
+  rootTableAlias,
+  resultAlias,
   baseTypeDefinition,
   typeName,
 }: {
@@ -65,18 +64,30 @@ export const getResolverNode = ({
   node: FieldNode | InlineFragmentNode | FragmentDefinitionNode;
   baseTypeDefinition: ObjectTypeDefinitionNode;
   tableAlias: string;
+  rootTableAlias: string;
+  resultAlias: string;
   typeName: string;
-}): ResolverNode => ({
-  ctx,
-  tableName: typeName,
-  tableAlias,
-  shortTableAlias: ctx.aliases.getShort(tableAlias),
-  baseTypeDefinition,
-  baseModel: ctx.models.find((model) => model.name === baseTypeDefinition.name.value),
-  typeDefinition: getType(ctx.info.schema, typeName),
-  model: summonByName(ctx.models, typeName),
-  selectionSet: get(node.selectionSet, 'selections'),
-});
+}): ResolverNode => {
+  const model = ctx.models.getModel(typeName, 'entity');
+  const rootModel = model.parent ? ctx.models.getModel(model.parent, 'entity') : model;
+
+  return {
+    ctx,
+
+    rootModel,
+    rootTableAlias,
+
+    model,
+    tableAlias,
+
+    resultAlias,
+
+    baseTypeDefinition,
+    baseModel: ctx.models.entities.find((model) => model.name === baseTypeDefinition.name.value),
+    typeDefinition: getType(ctx.info.schema, typeName),
+    selectionSet: get(node.selectionSet, 'selections'),
+  };
+};
 
 export const getRootFieldNode = ({
   ctx,
@@ -91,15 +102,22 @@ export const getRootFieldNode = ({
   const fieldDefinition = summonByKey(baseTypeDefinition.fields || [], 'name.value', fieldName);
 
   const typeName = getTypeName(fieldDefinition.type);
+  const model = ctx.models.getModel(typeName, 'entity');
+  const rootModel = model.parent ? ctx.models.getModel(model.parent, 'entity') : model;
 
   return {
     ctx,
-    tableName: typeName,
-    tableAlias: typeName,
-    shortTableAlias: ctx.aliases.getShort(typeName),
+
+    rootModel,
+    rootTableAlias: rootModel.name,
+
+    model,
+    tableAlias: model.name,
+
+    resultAlias: rootModel.name,
+
     baseTypeDefinition,
     typeDefinition: getType(ctx.info.schema, typeName),
-    model: summonByName(ctx.models, typeName),
     selectionSet: get(node.selectionSet, 'selections'),
     field: node,
     fieldDefinition,
@@ -122,7 +140,13 @@ export const getInlineFragments = (node: ResolverNode) =>
     getResolverNode({
       ctx: node.ctx,
       node: subNode,
+
+      rootTableAlias: node.rootTableAlias,
+
       tableAlias: node.tableAlias + '__' + getFragmentTypeName(subNode),
+
+      resultAlias: node.resultAlias,
+
       baseTypeDefinition: node.baseTypeDefinition,
       typeName: getFragmentTypeName(subNode),
     })
@@ -133,14 +157,20 @@ export const getFragmentSpreads = (node: ResolverNode) =>
     getResolverNode({
       ctx: node.ctx,
       node: node.ctx.info.fragments[subNode.name.value],
+
+      rootTableAlias: node.rootTableAlias,
+
       tableAlias: node.tableAlias,
+
+      resultAlias: node.resultAlias,
+
       baseTypeDefinition: node.baseTypeDefinition,
       typeName: node.model.name,
     })
   );
 
 export const getJoins = (node: ResolverNode, toMany: boolean) => {
-  const nodes: FieldResolverNode[] = [];
+  const nodes: RelationResolverNode[] = [];
   for (const subNode of node.selectionSet.filter(isFieldNode).filter(({ selectionSet }) => selectionSet)) {
     const ctx = node.ctx;
     const baseTypeDefinition = node.typeDefinition;
@@ -150,42 +180,40 @@ export const getJoins = (node: ResolverNode, toMany: boolean) => {
 
     const typeName = getTypeName(fieldDefinition.type);
 
-    if (isObjectModel(summonByName(ctx.rawModels, typeName))) {
+    if (isObjectModel(ctx.models.getModel(typeName))) {
       continue;
     }
 
-    const baseModel = summonByName(ctx.models, baseTypeDefinition.name.value);
-
-    let foreignKey: string | undefined;
-    if (toMany) {
-      const reverseRelation = baseModel.reverseRelationsByName[fieldName];
-      if (!reverseRelation) {
-        continue;
-      }
-      foreignKey = reverseRelation.foreignKey;
-    } else {
-      const modelField = baseModel.fieldsByName[fieldName];
-      if (modelField?.kind !== 'relation') {
-        continue;
-      }
-      foreignKey = modelField.foreignKey;
+    const baseModel = ctx.models.getModel(baseTypeDefinition.name.value, 'entity');
+
+    const relation = (toMany ? baseModel.reverseRelationsByName : baseModel.relationsByName)[fieldName];
+    if (!relation) {
+      continue;
     }
 
     const tableAlias = node.tableAlias + '__' + fieldNameOrAlias;
+    const model = ctx.models.getModel(typeName, 'entity');
+    const rootModel = model;
 
     nodes.push({
       ctx,
-      tableName: typeName,
+
+      rootModel,
+      rootTableAlias: tableAlias,
+
+      model,
       tableAlias,
-      shortTableAlias: ctx.aliases.getShort(tableAlias),
+
+      resultAlias: tableAlias,
+
       baseTypeDefinition,
       baseModel,
       typeDefinition: getType(ctx.info.schema, typeName),
-      model: summonByName(ctx.models, typeName),
       selectionSet: get(subNode.selectionSet, 'selections'),
       field: subNode,
       fieldDefinition,
-      foreignKey,
+      relation,
+      foreignKey: relation.field.foreignKey,
       isList: isListType(fieldDefinition.type),
     });
   }

package/src/resolvers/resolver.ts

@@ -3,21 +3,14 @@ import { Knex } from 'knex';
 import cloneDeep from 'lodash/cloneDeep';
 import flatMap from 'lodash/flatMap';
 import { Context, FullContext } from '../context';
-import { NotFoundError, PermissionError } from '../errors';
+import { NotFoundError } from '../errors';
 import { get, summonByKey } from '../models/utils';
 import { applyPermissions } from '../permissions/check';
 import { PermissionStack } from '../permissions/generate';
 import { applyFilters } from './filters';
-import {
-  FieldResolverNode,
-  ResolverNode,
-  getFragmentSpreads,
-  getInlineFragments,
-  getJoins,
-  getRootFieldNode,
-  getSimpleFields,
-} from './node';
-import { AliasGenerator, Entry, ID_ALIAS, Joins, addJoin, applyJoins, getNameOrAlias, hydrate, isListType } from './utils';
+import { FieldResolverNode, ResolverNode, getFragmentSpreads, getInlineFragments, getJoins, getRootFieldNode } from './node';
+import { applySelects } from './selects';
+import { AliasGenerator, Entry, ID_ALIAS, Joins, applyJoins, getColumn, getNameOrAlias, hydrate, isListType } from './utils';
 
 export const queryResolver = (_parent: any, _args: any, ctx: Context, info: GraphQLResolveInfo) =>
   resolve({ ...ctx, info, aliases: new AliasGenerator() });
@@ -36,18 +29,15 @@ export const resolve = async (ctx: FullContext, id?: string) => {
   const { query, verifiedPermissionStacks } = await buildQuery(node);
 
   if (ctx.info.fieldName === 'me') {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-    query.where({ [`${node.shortTableAlias}.id`]: node.ctx.user.id });
+    void query.where({ [getColumn(node, 'id')]: node.ctx.user.id });
   }
 
-  if (!node.isList) {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-    query.limit(1);
+  if (id) {
+    void query.where({ [getColumn(node, 'id')]: id });
   }
 
-  if (id) {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-    query.where({ id });
+  if (!node.isList) {
+    void query.limit(1);
   }
 
   const raw = await query;
@@ -74,22 +64,22 @@ const buildQuery = async (
   node: FieldResolverNode,
   parentVerifiedPermissionStacks?: VerifiedPermissionStacks
 ): Promise<{ query: Knex.QueryBuilder; verifiedPermissionStacks: VerifiedPermissionStacks }> => {
-  const { tableAlias, shortTableAlias, tableName, model, ctx } = node;
-  const query = ctx.knex.fromRaw(`"${tableName}" as "${shortTableAlias}"`);
+  const query = node.ctx.knex.fromRaw(`"${node.rootModel.name}" as "${node.ctx.aliases.getShort(node.resultAlias)}"`);
 
-  const joins: Joins = {};
+  const joins: Joins = [];
   applyFilters(node, query, joins);
   applySelects(node, query, joins);
   applyJoins(node.ctx.aliases, query, joins);
 
   const tables = [
-    [model.name, tableAlias] as const,
-    ...Object.keys(joins).map((tableName) => tableName.split(':') as [string, string]),
+    [node.rootModel.name, node.rootTableAlias] satisfies [string, string],
+    ...joins.map(({ table2Name, table2Alias }) => [table2Name, table2Alias] satisfies [string, string]),
   ];
+
   const verifiedPermissionStacks: VerifiedPermissionStacks = {};
   for (const [table, alias] of tables) {
     const verifiedPermissionStack = applyPermissions(
-      ctx,
+      node.ctx,
       table,
       node.ctx.aliases.getShort(alias),
       query,
@@ -105,52 +95,6 @@ const buildQuery = async (
   return { query, verifiedPermissionStacks };
 };
 
-const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins: Joins) => {
-  // Simple field selects
-  // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-  query.select(
-    ...[
-      { field: 'id', alias: ID_ALIAS },
-      ...getSimpleFields(node)
-        .filter((n) => {
-          const field = node.model.fields.find(({ name }) => name === n.name.value);
-
-          if (!field || field.kind === 'relation' || field.kind === 'custom') {
-            return false;
-          }
-
-          if (typeof field.queriable === 'object' && !field.queriable.roles?.includes(node.ctx.user.role)) {
-            throw new PermissionError(
-              'READ',
-              `${node.model.name}'s field "${field.name}"`,
-              'field permission not available'
-            );
-          }
-
-          return true;
-        })
-        .map((n) => ({ field: n.name.value, alias: getNameOrAlias(n) })),
-    ].map(
-      ({ field, alias }: { field: string; alias: string }) =>
-        `${node.shortTableAlias}.${field} as ${node.shortTableAlias}__${alias}`
-    )
-  );
-
-  for (const subNode of getInlineFragments(node)) {
-    applySelects(subNode, query, joins);
-  }
-
-  for (const subNode of getFragmentSpreads(node)) {
-    applySelects(subNode, query, joins);
-  }
-
-  for (const subNode of getJoins(node, false)) {
-    addJoin(joins, node.tableAlias, subNode.tableName, subNode.tableAlias, get(subNode, 'foreignKey'), 'id');
-
-    applySelects(subNode, query, joins);
-  }
-};
-
 const applySubQueries = async (
   node: ResolverNode,
   entries: Entry[],
@@ -174,13 +118,15 @@ const applySubQueries = async (
     const fieldName = getNameOrAlias(subNode.field);
     const isList = isListType(subNode.fieldDefinition.type);
     entries.forEach((entry) => (entry[fieldName] = isList ? [] : null));
-    const foreignKey = get(subNode, 'foreignKey');
+    const foreignKey = subNode.foreignKey;
     const { query, verifiedPermissionStacks } = await buildQuery(subNode, parentVerifiedPermissionStacks);
+    const shortTableAlias = subNode.ctx.aliases.getShort(subNode.tableAlias);
+    const shortResultAlias = subNode.ctx.aliases.getShort(subNode.resultAlias);
     const queries = ids.map((id) =>
       query
         .clone()
-        .select(`${subNode.shortTableAlias}.${foreignKey} as ${subNode.shortTableAlias}__${foreignKey}`)
-        .where({ [`${subNode.shortTableAlias}.${foreignKey}`]: id })
+        .select(`${shortTableAlias}.${foreignKey} as ${shortResultAlias}__${foreignKey}`)
+        .where({ [`${shortTableAlias}.${foreignKey}`]: id })
     );
 
     // TODO: make unionAll faster then promise.all...