@smartive/graphql-magic 1.0.1

package/src/resolvers/node.ts

@@ -0,0 +1,193 @@
+import type {
+  FieldDefinitionNode,
+  FieldNode,
+  FragmentDefinitionNode,
+  InlineFragmentNode,
+  ObjectTypeDefinitionNode,
+  SelectionNode,
+} from 'graphql';
+
+import { FullContext } from '../context';
+import { isJsonObjectModel, Model } from '../models';
+import { get, summonByKey, summonByName } from '../utils';
+import {
+  getFragmentTypeName,
+  getNameOrAlias,
+  getType,
+  getTypeName,
+  isFieldNode,
+  isFragmentSpreadNode,
+  isInlineFragmentNode,
+  isListType,
+} from './utils';
+
+export type ResolverNode = {
+  ctx: FullContext;
+
+  tableName: string;
+  tableAlias: string;
+  shortTableAlias: string;
+
+  baseTypeDefinition: ObjectTypeDefinitionNode;
+  baseModel?: Model;
+
+  typeDefinition: ObjectTypeDefinitionNode;
+  model: Model;
+
+  selectionSet: readonly SelectionNode[];
+};
+
+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 const getResolverNode = ({
+  ctx,
+  node,
+  tableAlias,
+  baseTypeDefinition,
+  typeName,
+}: {
+  ctx: FullContext;
+  node: FieldNode | InlineFragmentNode | FragmentDefinitionNode;
+  baseTypeDefinition: ObjectTypeDefinitionNode;
+  tableAlias: 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'),
+});
+
+export const getRootFieldNode = ({
+  ctx,
+  node,
+  baseTypeDefinition,
+}: {
+  ctx: FullContext;
+  node: FieldNode;
+  baseTypeDefinition: ObjectTypeDefinitionNode;
+}): FieldResolverNode => {
+  const fieldName = node.name.value;
+  const fieldDefinition = summonByKey(baseTypeDefinition.fields || [], 'name.value', fieldName);
+
+  const typeName = getTypeName(fieldDefinition.type);
+
+  return {
+    ctx,
+    tableName: typeName,
+    tableAlias: typeName,
+    shortTableAlias: ctx.aliases.getShort(typeName),
+    baseTypeDefinition,
+    typeDefinition: getType(ctx.info.schema, typeName),
+    model: summonByName(ctx.models, typeName),
+    selectionSet: get(node.selectionSet, 'selections'),
+    field: node,
+    fieldDefinition,
+    isList: isListType(fieldDefinition.type),
+  };
+};
+
+export const getSimpleFields = (node: ResolverNode) => {
+  return node.selectionSet.filter(isFieldNode).filter((selection) => {
+    if (!selection.selectionSet) {
+      return true;
+    }
+
+    return node.model.fields.some(({ json, name }) => json && name === selection.name.value);
+  });
+};
+
+export const getInlineFragments = (node: ResolverNode) =>
+  node.selectionSet.filter(isInlineFragmentNode).map((subNode) =>
+    getResolverNode({
+      ctx: node.ctx,
+      node: subNode,
+      tableAlias: node.tableAlias + '__' + getFragmentTypeName(subNode),
+      baseTypeDefinition: node.baseTypeDefinition,
+      typeName: getFragmentTypeName(subNode),
+    })
+  );
+
+export const getFragmentSpreads = (node: ResolverNode) =>
+  node.selectionSet.filter(isFragmentSpreadNode).map((subNode) =>
+    getResolverNode({
+      ctx: node.ctx,
+      node: node.ctx.info.fragments[subNode.name.value]!,
+      tableAlias: node.tableAlias,
+      baseTypeDefinition: node.baseTypeDefinition,
+      typeName: node.model.name,
+    })
+  );
+
+export const getJoins = (node: ResolverNode, toMany: boolean) => {
+  const nodes: FieldResolverNode[] = [];
+  for (const subNode of node.selectionSet.filter(isFieldNode).filter(({ selectionSet }) => selectionSet)) {
+    const ctx = node.ctx;
+    const baseTypeDefinition = node.typeDefinition;
+    const fieldName = subNode.name.value;
+    const fieldNameOrAlias = getNameOrAlias(subNode);
+    const fieldDefinition = summonByKey(baseTypeDefinition.fields || [], 'name.value', fieldName);
+
+    const typeName = getTypeName(fieldDefinition.type);
+
+    if (isJsonObjectModel(summonByName(ctx.rawModels, typeName))) {
+      continue;
+    }
+
+    const baseModel = summonByName(ctx.models, baseTypeDefinition.name.value);
+
+    let foreignKey;
+    if (toMany) {
+      const reverseRelation = baseModel.reverseRelationsByName[fieldName];
+      if (!reverseRelation) {
+        continue;
+      }
+      foreignKey = reverseRelation.foreignKey;
+    } else {
+      const modelField = baseModel.fieldsByName[fieldName];
+      if (!modelField || modelField.raw) {
+        continue;
+      }
+      foreignKey = modelField.foreignKey;
+    }
+
+    const tableAlias = node.tableAlias + '__' + fieldNameOrAlias;
+
+    nodes.push({
+      ctx,
+      tableName: typeName,
+      tableAlias,
+      shortTableAlias: ctx.aliases.getShort(tableAlias),
+      baseTypeDefinition,
+      baseModel,
+      typeDefinition: getType(ctx.info.schema, typeName),
+      model: summonByName(ctx.models, typeName),
+      selectionSet: get(subNode.selectionSet, 'selections'),
+      field: subNode,
+      fieldDefinition,
+      foreignKey,
+      isList: isListType(fieldDefinition.type),
+    });
+  }
+  return nodes;
+};

package/src/resolvers/resolver.ts

@@ -0,0 +1,223 @@
+import { GraphQLResolveInfo } from 'graphql';
+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 { applyPermissions } from '../permissions/check';
+import { PermissionStack } from '../permissions/generate';
+import { get, summonByKey } from '../utils';
+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';
+
+export const queryResolver = (_parent: any, _args: any, ctx: Context, info: GraphQLResolveInfo) =>
+  resolve({ ...ctx, info, aliases: new AliasGenerator() });
+
+export const resolve = async (ctx: FullContext, id?: string) => {
+  const fieldNode = summonByKey(ctx.info.fieldNodes, 'name.value', ctx.info.fieldName);
+  const baseTypeDefinition = get(
+    ctx.info.operation.operation === 'query' ? ctx.info.schema.getQueryType() : ctx.info.schema.getMutationType(),
+    'astNode'
+  );
+  const node = getRootFieldNode({
+    ctx,
+    node: fieldNode,
+    baseTypeDefinition,
+  });
+  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 });
+  }
+
+  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) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+    query.where({ id });
+  }
+
+  const raw = await query;
+
+  const res = hydrate(node, raw);
+
+  await applySubQueries(node, res, verifiedPermissionStacks);
+
+  if (node.isList) {
+    return res;
+  }
+
+  if (!res[0]) {
+    throw new NotFoundError('Entity not found');
+  }
+
+  return res[0];
+};
+
+type VerifiedPermissionStacks = Record<string, PermissionStack>;
+
+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 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]),
+  ];
+  const verifiedPermissionStacks: VerifiedPermissionStacks = {};
+  for (const [table, alias] of tables) {
+    const verifiedPermissionStack = applyPermissions(
+      ctx,
+      table,
+      node.ctx.aliases.getShort(alias),
+      query,
+      'READ',
+      parentVerifiedPermissionStacks?.[alias.split('__').slice(0, -1).join('__')]
+    );
+
+    if (typeof verifiedPermissionStack !== 'boolean') {
+      verifiedPermissionStacks[alias] = verifiedPermissionStack;
+    }
+  }
+
+  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.relation || field.raw) {
+            return false;
+          }
+
+          if (field.queriableBy && !field.queriableBy.includes(node.ctx.user.role)) {
+            throw new PermissionError('READ', `${node.model.name}'s field "${field.name}"`);
+          }
+
+          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[],
+  parentVerifiedPermissionStacks: VerifiedPermissionStacks
+): Promise<void> => {
+  if (!entries.length) {
+    return;
+  }
+
+  const entriesById: { [id: string]: Entry[] } = {};
+  for (const entry of entries) {
+    if (!entriesById[entry[ID_ALIAS]]) {
+      entriesById[entry[ID_ALIAS]] = [];
+    }
+    entriesById[entry[ID_ALIAS]!]!.push(entry);
+  }
+  const ids = Object.keys(entriesById);
+
+  // One to many
+  for (const subNode of getJoins(node, true)) {
+    const fieldName = getNameOrAlias(subNode.field);
+    const isList = isListType(subNode.fieldDefinition.type);
+    entries.forEach((entry) => (entry[fieldName] = isList ? [] : null));
+    const foreignKey = get(subNode, 'foreignKey');
+    const { query, verifiedPermissionStacks } = await buildQuery(subNode, parentVerifiedPermissionStacks);
+    const queries = ids.map((id) =>
+      query
+        .clone()
+        .select(`${subNode.shortTableAlias}.${foreignKey} as ${subNode.shortTableAlias}__${foreignKey}`)
+        .where({ [`${subNode.shortTableAlias}.${foreignKey}`]: id })
+    );
+
+    // TODO: make unionAll faster then promise.all...
+    // const rawChildren = await node.ctx.knex.queryBuilder().unionAll(queries, true);
+    const rawChildren = (await Promise.all(queries)).flat();
+    const children = hydrate(subNode, rawChildren);
+
+    for (const child of children) {
+      for (const entry of entriesById[child[foreignKey] as string]!) {
+        if (isList) {
+          (entry[fieldName] as Entry[]).push(cloneDeep(child));
+        } else {
+          entry[fieldName] = cloneDeep(child);
+        }
+      }
+    }
+
+    await applySubQueries(
+      subNode,
+      flatMap(
+        entries.map((entry) => {
+          const children = entry[fieldName];
+          return (isList ? children : children ? [children] : []) as Entry[];
+        })
+      ),
+      verifiedPermissionStacks
+    );
+  }
+
+  for (const subNode of getInlineFragments(node)) {
+    await applySubQueries(subNode, entries, parentVerifiedPermissionStacks);
+  }
+
+  for (const subNode of getFragmentSpreads(node)) {
+    await applySubQueries(subNode, entries, parentVerifiedPermissionStacks);
+  }
+
+  for (const subNode of getJoins(node, false)) {
+    await applySubQueries(
+      subNode,
+      entries.map((item) => item[getNameOrAlias(subNode.field)] as Entry).filter(Boolean),
+      parentVerifiedPermissionStacks
+    );
+  }
+};

package/src/resolvers/resolvers.ts

@@ -0,0 +1,40 @@
+import { Models } from '../models';
+import { getModelPluralField, merge, typeToField } from '../utils';
+import { mutationResolver } from './mutations';
+import { queryResolver } from './resolver';
+
+export const getResolvers = (models: Models) => ({
+  Query: merge([
+    {
+      me: queryResolver,
+    },
+    ...models
+      .filter(({ queriable }) => queriable)
+      .map((model) => ({
+        [typeToField(model.name)]: queryResolver,
+      })),
+    ...models
+      .filter(({ listQueriable }) => listQueriable)
+      .map((model) => ({
+        [getModelPluralField(model)]: queryResolver,
+      })),
+  ]),
+  Mutation: merge<unknown>([
+    ...models
+      .filter(({ creatable }) => creatable)
+      .map((model) => ({
+        [`create${model.name}`]: mutationResolver,
+      })),
+    ...models
+      .filter(({ updatable }) => updatable)
+      .map((model) => ({
+        [`update${model.name}`]: mutationResolver,
+      })),
+    ...models
+      .filter(({ deletable }) => deletable)
+      .map((model) => ({
+        [`delete${model.name}`]: mutationResolver,
+        [`restore${model.name}`]: mutationResolver,
+      })),
+  ]),
+});

package/src/resolvers/utils.ts

@@ -0,0 +1,188 @@
+import { createHash } from 'crypto';
+import type {
+  ASTNode,
+  FieldNode,
+  FragmentDefinitionNode,
+  FragmentSpreadNode,
+  GraphQLObjectType,
+  GraphQLSchema,
+  InlineFragmentNode,
+  TypeNode,
+} from 'graphql';
+import { Kind } from 'graphql';
+import { Knex } from 'knex';
+import { UserInputError } from '../errors';
+import { get, it } from '../utils';
+import { Value } from '../values';
+import { FieldResolverNode } from './node';
+
+export const ID_ALIAS = 'ID';
+
+export type VariableValues = {
+  [variableName: string]: Value;
+};
+
+export const getTypeName = (t: TypeNode): string => {
+  switch (t.kind) {
+    case 'ListType':
+    case 'NonNullType':
+      return getTypeName(t.type);
+    default:
+      return t.name.value;
+  }
+};
+
+export const isListType = (type: TypeNode): boolean => {
+  switch (type.kind) {
+    case 'ListType':
+      return true;
+    case 'NonNullType':
+      return isListType(type.type);
+    default:
+      return false;
+  }
+};
+
+export const isFieldNode = (n: ASTNode): n is FieldNode => n.kind === Kind.FIELD;
+
+export const isInlineFragmentNode = (n: ASTNode): n is InlineFragmentNode => n.kind === Kind.INLINE_FRAGMENT;
+
+export const isFragmentSpreadNode = (n: ASTNode): n is FragmentSpreadNode => n.kind === Kind.FRAGMENT_SPREAD;
+
+export type Maybe<T> = null | undefined | T;
+
+export const getType = (schema: GraphQLSchema, name: string) =>
+  get(schema.getType(name) as Maybe<GraphQLObjectType>, 'astNode');
+
+export const getFragmentTypeName = (node: InlineFragmentNode | FragmentDefinitionNode) =>
+  get(get(node.typeCondition, 'name'), 'value');
+
+export type Entry = {
+  [ID_ALIAS]: string;
+  [field: string]: null | string | number | Entry | Entry[];
+};
+
+export function hydrate<T extends Entry>(
+  node: FieldResolverNode,
+  raw: { [key: string]: undefined | null | string | Date | number }[]
+): T[] {
+  const tableAlias = node.tableAlias;
+  const res = raw.map((entry) => {
+    const res: any = {};
+    outer: for (const [column, value] of Object.entries(entry)) {
+      let current = res;
+      const shortParts = column.split('__');
+      const fieldName = shortParts.pop()!;
+      const columnWithoutField = shortParts.join('__');
+      const longColumn = node.ctx.aliases.getLong(columnWithoutField);
+      const longColumnWithoutRoot = longColumn.replace(new RegExp(`^${tableAlias}(__)?`), '');
+      const allParts = [tableAlias, ...(longColumnWithoutRoot ? longColumnWithoutRoot.split('__') : []), fieldName];
+      for (let i = 0; i < allParts.length - 1; i++) {
+        const part = allParts[i]!;
+
+        if (!current[part]) {
+          const idField = [node.ctx.aliases.getShort(allParts.slice(0, i + 1).join('__')), ID_ALIAS].join('__');
+          if (!entry[idField]) {
+            continue outer;
+          }
+          current[part] = {};
+        }
+        current = current[part];
+      }
+      current[it(fieldName)] = value;
+    }
+    return res[tableAlias];
+  });
+
+  return res;
+}
+
+export const ors = (query: Knex.QueryBuilder, [first, ...rest]: ((query: Knex.QueryBuilder) => Knex.QueryBuilder)[]) => {
+  if (!first) {
+    return query;
+  }
+  return query.where((subQuery) => {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+    subQuery.where((subSubQuery) => {
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+      first(subSubQuery);
+    });
+    for (const cb of rest) {
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+      subQuery.orWhere((subSubQuery) => {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+        cb(subSubQuery);
+      });
+    }
+  });
+};
+
+export const getNameOrAlias = (node: FieldNode) => {
+  const name = node.alias ? node.alias.value : node.name.value;
+
+  if ([ID_ALIAS].indexOf(name) >= 0) {
+    throw new UserInputError(`"${name}" can not be used as alias since it's a reserved word`);
+  }
+
+  return name;
+};
+
+export type Ops<T> = ((target: T) => T)[];
+
+export const apply = <T>(target: T, ops: ((target: T) => T)[]) => ops.reduce((target, op) => op(target), target);
+
+export type Joins = Record<`${string}:${string}`, { table1Alias: string; column1: string; column2: string }>;
+
+export const applyJoins = (aliases: AliasGenerator, query: Knex.QueryBuilder, joins: Joins) => {
+  for (const [tableName, { table1Alias, column1, column2 }] of Object.entries(joins)) {
+    const [table, alias] = tableName.split(':');
+    const table1ShortAlias = aliases.getShort(table1Alias);
+    const table2ShortAlias = aliases.getShort(alias);
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+    query.leftJoin(`${table} as ${table2ShortAlias}`, `${table1ShortAlias}.${column1}`, `${table2ShortAlias}.${column2}`);
+  }
+};
+
+/**
+ * Note: modifies the join parameter.
+ */
+export const addJoin = (
+  joins: Joins,
+  table1Alias: string,
+  table2: string,
+  alias2: string,
+  column1: string,
+  column2: string
+) => {
+  joins[`${table2}:${alias2}`] ||= { table1Alias, column1, column2 };
+};
+
+export class AliasGenerator {
+  private reverse: Record<string, string> = {};
+
+  public getShort(long?: string) {
+    if (!long) {
+      const short = `a${Object.keys(this.reverse).length}`;
+      return (this.reverse[short] = short);
+    }
+
+    const shortPrefix = long
+      .split('__')
+      .map((part) => part[0] + part.slice(1).replaceAll(/[a-z]+/g, ''))
+      .join('__');
+    let postfix = 0;
+    let short = shortPrefix + (postfix || '');
+    while (short in this.reverse && this.reverse[short] !== long) {
+      short = shortPrefix + ++postfix;
+    }
+
+    this.reverse[short] = long;
+    return short;
+  }
+
+  public getLong(short: string) {
+    return get(this.reverse, short);
+  }
+}
+
+export const hash = (s: any) => createHash('md5').update(JSON.stringify(s)).digest('hex');