@smartive/graphql-magic 1.0.1

package/src/resolvers/arguments.ts

@@ -0,0 +1,129 @@
+import type { GraphQLObjectType, GraphQLSchema, TypeDefinitionNode, TypeNode, ValueNode } from 'graphql';
+import { Kind } from 'graphql';
+import { summonByKey } from '../utils';
+import { Value } from '../values';
+import { FieldResolverNode } from './node';
+import { Maybe, VariableValues } from './utils';
+
+export type Where = Record<string, Value>;
+
+export type OrderBy = Record<string, 'ASC' | 'DESC'>[];
+
+export type Args = {
+  where?: Where | null;
+};
+
+export type ListArgs = {
+  limit?: number | null | undefined;
+  offset?: number | null | undefined;
+  orderBy?: string[];
+};
+
+export type NormalizedArguments = {
+  limit?: number;
+  offset?: number;
+  orderBy?: OrderBy;
+  where?: Where;
+  search?: string;
+  mine?: boolean;
+  language?: string;
+};
+
+function getRawValue(value: ValueNode, values?: VariableValues): Value {
+  switch (value.kind) {
+    case Kind.LIST:
+      if (!values) {
+        return;
+      }
+      return value.values.map((value) => getRawValue(value, values));
+    case Kind.VARIABLE:
+      return values?.[value.name.value];
+    case Kind.INT:
+      return parseInt(value.value, 10);
+    case Kind.NULL:
+      return null;
+    case Kind.FLOAT:
+      return parseFloat(value.value);
+    case Kind.STRING:
+    case Kind.BOOLEAN:
+    case Kind.ENUM:
+      return value.value;
+    case Kind.OBJECT: {
+      if (!value.fields.length) {
+        return;
+      }
+      const res: Record<string, Value> = {};
+      for (const field of value.fields) {
+        res[field.name.value] = getRawValue(field.value, values);
+      }
+      return res;
+    }
+  }
+}
+
+export const normalizeArguments = (node: FieldResolverNode) => {
+  const normalizedArguments: NormalizedArguments = {};
+  if (node.field.arguments) {
+    for (const argument of node.field.arguments) {
+      const rawValue = getRawValue(argument.value, node.ctx.info.variableValues);
+      const normalizedValue = normalizeValue(
+        rawValue,
+        summonByKey(node.fieldDefinition.arguments || [], 'name.value', argument.name.value).type,
+        node.ctx.info.schema
+      );
+      if (normalizedValue === undefined) {
+        continue;
+      }
+      normalizedArguments[argument.name.value] = normalizedValue as any;
+    }
+  }
+  return normalizedArguments;
+};
+
+export function normalizeValue(value: Value, type: TypeNode, schema: GraphQLSchema): Value {
+  switch (type.kind) {
+    case Kind.LIST_TYPE: {
+      if (Array.isArray(value)) {
+        const res: Value[] = [];
+        for (const v of value) {
+          res.push(normalizeValue(v, type.type, schema));
+        }
+        return res;
+      }
+
+      const normalizedValue = normalizeValue(value, type.type, schema);
+      if (normalizedValue === undefined) {
+        return;
+      }
+
+      return [normalizedValue];
+    }
+    case Kind.NON_NULL_TYPE:
+      return normalizeValue(value, type.type, schema);
+    case Kind.NAMED_TYPE:
+      return normalizeValueByTypeDefinition(
+        value,
+        (schema.getType(type.name.value) as Maybe<GraphQLObjectType>)?.astNode,
+        schema
+      );
+  }
+}
+
+export const normalizeValueByTypeDefinition = (value: Value, type: Maybe<TypeDefinitionNode>, schema: GraphQLSchema) => {
+  if (!type || type.kind !== Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+    return value;
+  }
+  if (!value) {
+    return;
+  }
+  const res: Record<string, Value> = {};
+  for (const key of Object.keys(value)) {
+    const field = summonByKey(type.fields, 'name.value', key);
+    const normalizedValue = normalizeValue((value as Record<string, Value>)[key], field.type, schema);
+    if (normalizedValue === undefined) {
+      continue;
+    }
+    res[key] = normalizedValue;
+  }
+  return res;
+};

package/src/resolvers/filters.ts

@@ -0,0 +1,163 @@
+import { Knex } from 'knex';
+import { ForbiddenError, UserInputError } from '../errors';
+import { get, summonByName } from '../utils';
+import { OrderBy, Where, normalizeArguments } from './arguments';
+import { FieldResolverNode, WhereNode } from './node';
+import { Joins, Ops, addJoin, apply, ors } from './utils';
+
+export const SPECIAL_FILTERS: Record<string, string> = {
+  GT: '?? > ?',
+  GTE: '?? >= ?',
+  LT: '?? < ?',
+  LTE: '?? <= ?',
+};
+
+export const applyFilters = (node: FieldResolverNode, query: Knex.QueryBuilder, joins: Joins) => {
+  const normalizedArguments = normalizeArguments(node);
+  if (!normalizedArguments.orderBy) {
+    if (node.model.defaultOrderBy) {
+      normalizedArguments.orderBy = node.model.defaultOrderBy;
+    } else if (node.model.creatable) {
+      normalizedArguments.orderBy = [{ createdAt: 'DESC' }];
+    }
+  }
+  if (node.model.deletable) {
+    if (!normalizedArguments.where) {
+      normalizedArguments.where = {};
+    }
+    if (
+      normalizedArguments.where.deleted &&
+      (!Array.isArray(normalizedArguments.where.deleted) || normalizedArguments.where.deleted.some((v) => v))
+    ) {
+      if (node.ctx.user.role !== 'ADMIN') {
+        throw new ForbiddenError('You cannot access deleted entries.');
+      }
+    } else {
+      normalizedArguments.where.deleted = false;
+    }
+  }
+  const { limit, offset, orderBy, where, search } = normalizedArguments;
+
+  if (limit) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+    query.limit(limit);
+  }
+
+  if (offset) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+    query.offset(offset);
+  }
+
+  if (orderBy) {
+    applyOrderBy(node, orderBy, query);
+  }
+
+  if (where) {
+    const ops: Ops<Knex.QueryBuilder> = [];
+    applyWhere(node, where, ops, joins);
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+    apply(query, ops);
+  }
+
+  if (search) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+    applySearch(node, search, query);
+  }
+};
+
+const applyWhere = (node: WhereNode, where: Where, ops: Ops<Knex.QueryBuilder>, joins: Joins) => {
+  for (const key of Object.keys(where)) {
+    const value = where[key];
+
+    const specialFilter = key.match(/^(\w+)_(\w+)$/);
+    if (specialFilter) {
+      const [, actualKey, filter] = specialFilter;
+      if (!SPECIAL_FILTERS[filter!]) {
+        // Should not happen
+        throw new Error(`Invalid filter ${key}.`);
+      }
+      ops.push((query) =>
+        query.whereRaw(SPECIAL_FILTERS[filter!]!, [`${node.shortTableAlias}.${actualKey}`, value as string])
+      );
+      continue;
+    }
+
+    const field = summonByName(node.model.fields, key);
+    const fullKey = `${node.shortTableAlias}.${key}`;
+
+    if (field.relation) {
+      const relation = get(node.model.relationsByName, field.name);
+      const tableAlias = `${node.model.name}__W__${key}`;
+      const subNode: WhereNode = {
+        ctx: node.ctx,
+        model: relation.model,
+        tableName: relation.model.name,
+        tableAlias,
+        shortTableAlias: node.ctx.aliases.getShort(tableAlias),
+        foreignKey: relation.field.foreignKey,
+      };
+      addJoin(joins, node.tableAlias, subNode.tableName, subNode.tableAlias, get(subNode, 'foreignKey'), 'id');
+      applyWhere(subNode, value as Where, ops, joins);
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      if (field && field.list) {
+        ops.push((query) =>
+          ors(
+            query,
+            value.map((v) => (subQuery) => subQuery.whereRaw('? = ANY(??)', [v, fullKey] as string[]))
+          )
+        );
+        continue;
+      }
+
+      if (value.some((v) => v === null)) {
+        if (value.some((v) => v !== null)) {
+          ops.push((query) =>
+            ors(query, [
+              (subQuery) => subQuery.whereIn(fullKey, value.filter((v) => v !== null) as string[]),
+              (subQuery) => subQuery.whereNull(fullKey),
+            ])
+          );
+          continue;
+        }
+
+        ops.push((query) => query.whereNull(fullKey));
+        continue;
+      }
+
+      ops.push((query) => query.whereIn(fullKey, value as string[]));
+      continue;
+    }
+
+    ops.push((query) => query.where({ [fullKey]: value }));
+  }
+};
+
+const applySearch = (node: FieldResolverNode, search: string, query: Knex.QueryBuilder) =>
+  ors(
+    query,
+    node.model.fields
+      .filter(({ searchable }) => searchable)
+      .map(
+        ({ name }) =>
+          (query) =>
+            query.whereILike(`${node.shortTableAlias}.${name}`, `%${search}%`)
+      )
+  );
+
+const applyOrderBy = (node: FieldResolverNode, orderBy: OrderBy, query: Knex.QueryBuilder) => {
+  for (const vals of orderBy) {
+    const keys = Object.keys(vals);
+    if (keys.length !== 1) {
+      throw new UserInputError(`You need to specify exactly 1 value to order by for each orderBy entry.`);
+    }
+    const key = keys[0];
+    const value = vals[key!];
+
+    // Simple field
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+    query.orderBy(`${node.shortTableAlias}.${key}`, value);
+  }
+};

package/src/resolvers/index.ts

@@ -0,0 +1,9 @@
+// created from 'create-ts-index'
+
+export * from './arguments';
+export * from './filters';
+export * from './mutations';
+export * from './node';
+export * from './resolver';
+export * from './resolvers';
+export * from './utils';

package/src/resolvers/mutations.ts

@@ -0,0 +1,313 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { v4 as uuid } from 'uuid';
+import { Context, FullContext } from '../context';
+import { ForbiddenError, GraphQLError } from '../errors';
+import { Entity, Model, ModelField, isEnumList } from '../models';
+import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
+import { get, it, summonByName, typeToField } from '../utils';
+import { resolve } from './resolver';
+import { AliasGenerator } from './utils';
+
+export const mutationResolver = async (_parent: any, args: any, partialCtx: Context, info: GraphQLResolveInfo) => {
+  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!);
+    switch (mutation) {
+      case 'create':
+        return await create(model, args, ctx);
+      case 'update':
+        return await update(model, args, ctx);
+      case 'delete':
+        return await del(model, args, ctx);
+      case 'restore':
+        return await restore(model, args, ctx);
+    }
+  });
+};
+
+const create = async (model: Model, { data: input }: { data: any }, ctx: FullContext) => {
+  const normalizedInput = { ...input };
+  normalizedInput.id = uuid();
+  normalizedInput.createdAt = ctx.now;
+  normalizedInput.createdById = ctx.user.id;
+  sanitize(ctx, model, normalizedInput);
+
+  await checkCanWrite(ctx, model, normalizedInput, 'CREATE');
+  await ctx.handleUploads?.(normalizedInput);
+
+  const data = { prev: {}, input, normalizedInput, next: normalizedInput };
+  await ctx.mutationHook?.(model, 'create', 'before', data, ctx);
+  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) => {
+  if (Object.keys(where).length === 0) {
+    throw new Error(`No ${model.name} specified.`);
+  }
+
+  const normalizedInput = { ...input };
+
+  sanitize(ctx, model, normalizedInput);
+
+  const prev = await getEntityToMutate(ctx, model, where, 'UPDATE');
+
+  // Remove data that wouldn't mutate given that it's irrelevant for permissions
+  for (const key of Object.keys(normalizedInput)) {
+    if (normalizedInput[key] === prev[key]) {
+      delete normalizedInput[key];
+    }
+  }
+
+  if (Object.keys(normalizedInput).length > 0) {
+    await checkCanWrite(ctx, model, normalizedInput, 'UPDATE');
+    await ctx.handleUploads?.(normalizedInput);
+
+    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);
+    await createRevision(model, next, ctx);
+    await ctx.mutationHook?.(model, 'update', 'after', data, ctx);
+  }
+
+  return await resolve(ctx);
+};
+
+type Callbacks = (() => Promise<void>)[];
+
+const del = async (model: Model, { 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');
+
+  if (entity.deleted) {
+    throw new ForbiddenError('Entity is already deleted.');
+  }
+
+  const toDelete: { [type: string]: { [id: string]: string } } = {};
+  const toUnlink: {
+    [type: string]: {
+      [id: string]: {
+        display: string;
+        fields: string[];
+      };
+    };
+  } = {};
+
+  const beforeHooks: Callbacks = [];
+  const mutations: Callbacks = [];
+  const afterHooks: Callbacks = [];
+
+  const deleteCascade = async (currentModel: Model, entity: Entity) => {
+    if (entity.deleted) {
+      return;
+    }
+
+    if (dryRun) {
+      if (!(currentModel.name in toDelete)) {
+        toDelete[currentModel.name] = {};
+      }
+      toDelete[currentModel.name]![entity.id] = entity[currentModel.displayField || 'id'] || entity.id;
+    } else {
+      const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user.id };
+      const data = { prev: entity, input: {}, normalizedInput, next: { ...entity, ...normalizedInput } };
+      if (ctx.mutationHook) {
+        beforeHooks.push(async () => {
+          await ctx.mutationHook!(currentModel, 'delete', 'before', data, ctx);
+        });
+      }
+      mutations.push(async () => {
+        await ctx.knex(currentModel.name).where({ id: entity.id }).update(normalizedInput);
+        await createRevision(currentModel, { ...entity, deleted: true }, ctx);
+      });
+      if (ctx.mutationHook) {
+        afterHooks.push(async () => {
+          await ctx.mutationHook!(currentModel, 'delete', 'after', data, ctx);
+        });
+      }
+    }
+
+    for (const {
+      model: descendantModel,
+      foreignKey,
+      field: { name, onDelete },
+    } of currentModel.reverseRelations) {
+      const query = ctx.knex(descendantModel.name).where({ [foreignKey]: entity.id });
+      switch (onDelete) {
+        case 'set-null': {
+          const descendants = await query;
+          for (const descendant of descendants) {
+            if (dryRun) {
+              if (!toUnlink[descendantModel.name]) {
+                toUnlink[descendantModel.name] = {};
+              }
+              if (!toUnlink[descendantModel.name]![descendant.id]) {
+                toUnlink[descendantModel.name]![descendant.id] = {
+                  display: descendant[descendantModel.displayField || 'id'] || entity.id,
+                  fields: [],
+                };
+              }
+              toUnlink[descendantModel.name]![descendant.id]!.fields.push(name);
+            } else {
+              mutations.push(async () => {
+                await ctx
+                  .knex(descendantModel.name)
+                  .where({ id: descendant.id })
+                  .update({
+                    [`${name}Id`]: null,
+                  });
+              });
+            }
+          }
+          break;
+        }
+        case 'cascade':
+        default: {
+          applyPermissions(ctx, descendantModel.name, descendantModel.name, query, 'DELETE');
+          const descendants = await query;
+          if (descendants.length && !descendantModel.deletable) {
+            throw new ForbiddenError(`This ${model.name} depends on a ${descendantModel.name} which cannot be deleted.`);
+          }
+          for (const descendant of descendants) {
+            await deleteCascade(descendantModel, descendant);
+          }
+          break;
+        }
+      }
+    }
+  };
+
+  await deleteCascade(model, entity);
+
+  for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
+    await callback();
+  }
+
+  if (dryRun) {
+    throw new GraphQLError(`Delete dry run:`, {
+      code: 'DELETE_DRY_RUN',
+      toDelete,
+      toUnlink,
+    });
+  }
+
+  return entity.id;
+};
+
+const restore = async (model: Model, { 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');
+
+  if (!entity.deleted) {
+    throw new ForbiddenError('Entity is not deleted.');
+  }
+
+  const beforeHooks: Callbacks = [];
+  const mutations: Callbacks = [];
+  const afterHooks: Callbacks = [];
+
+  const restoreCascade = async (currentModel: Model, relatedEntity: Entity) => {
+    if (!relatedEntity.deleted || !relatedEntity.deletedAt || !relatedEntity.deletedAt.equals(entity.deletedAt)) {
+      return;
+    }
+
+    const normalizedInput: Entity = { deleted: false, deletedAt: null, deletedById: null };
+    const data = { prev: relatedEntity, input: {}, normalizedInput, next: { ...relatedEntity, ...normalizedInput } };
+    if (ctx.mutationHook) {
+      beforeHooks.push(async () => {
+        await ctx.mutationHook!(model, 'restore', 'before', data, ctx);
+      });
+    }
+    mutations.push(async () => {
+      await ctx.knex(currentModel.name).where({ id: relatedEntity.id }).update(normalizedInput);
+      await createRevision(currentModel, { ...relatedEntity, deleted: false }, ctx);
+    });
+    if (ctx.mutationHook) {
+      afterHooks.push(async () => {
+        await ctx.mutationHook!(model, 'restore', 'after', data, ctx);
+      });
+    }
+
+    for (const { model: descendantModel, foreignKey } of currentModel.reverseRelations.filter(
+      ({ model: { deletable } }) => deletable
+    )) {
+      const query = ctx.knex(descendantModel.name).where({ [foreignKey]: relatedEntity.id });
+      applyPermissions(ctx, descendantModel.name, descendantModel.name, query, 'RESTORE');
+      const descendants = await query;
+      for (const descendant of descendants) {
+        await restoreCascade(descendantModel, descendant);
+      }
+    }
+  };
+
+  await restoreCascade(model, entity);
+
+  for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
+    await callback();
+  }
+
+  return entity.id;
+};
+
+const createRevision = async (model: Model, data: Entity, ctx: Context) => {
+  if (model.updatable) {
+    const revisionData = {
+      id: uuid(),
+      [`${typeToField(model.name)}Id`]: data.id,
+      createdAt: ctx.now,
+      createdById: ctx.user.id,
+    };
+
+    if (model.deletable) {
+      revisionData.deleted = data.deleted || false;
+    }
+
+    for (const { name, relation, nonNull, ...field } of model.fields.filter(({ updatable }) => updatable)) {
+      const col = relation ? `${name}Id` : name;
+      if (nonNull && (!(col in data) || col === undefined || col === null)) {
+        revisionData[col] = get(field, 'default');
+      } else {
+        revisionData[col] = data[col];
+      }
+    }
+    await ctx.knex(`${model.name}Revision`).insert(revisionData);
+  }
+};
+
+const sanitize = (ctx: FullContext, model: Model, data: Entity) => {
+  if (model.updatable) {
+    data.updatedAt = ctx.now;
+    data.updatedById = ctx.user.id;
+  }
+
+  for (const key of Object.keys(data)) {
+    const field = model.fields.find(({ name }) => name === key);
+
+    if (!field) {
+      continue;
+    }
+
+    if (isEndOfDay(field) && data[key]) {
+      data[key] = data[key].endOf('day');
+      continue;
+    }
+
+    if (isEnumList(ctx.rawModels, field) && Array.isArray(data[key])) {
+      data[key] = `{${data[key].join(',')}}`;
+      continue;
+    }
+  }
+};
+
+const isEndOfDay = (field?: ModelField) =>
+  field?.endOfDay === true && field?.dateTimeType === 'date' && field?.type === 'DateTime';