@smartive/graphql-magic 19.1.3-next.2 → 19.2.0-next.2

package/src/resolvers/mutations.ts

@@ -1,9 +1,9 @@
 import { GraphQLResolveInfo } from 'graphql';
 import { v4 as uuid } from 'uuid';
-import { Context, FullContext } from '../context';
+import { Context } from '../context';
 import { ForbiddenError, GraphQLError } from '../errors';
 import { EntityField, EntityModel } from '../models/models';
-import { Entity } from '../models/mutation-hook';
+import { Entity, MutationContext, Trigger } from '../models/mutation-hook';
 import { get, isPrimitive, it, typeToField } from '../models/utils';
 import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
 import { anyDateToLuxon } from '../utils';
@@ -16,23 +16,53 @@ export const mutationResolver = async (_parent: any, args: any, partialCtx: Cont
     const ctx = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
     const model = ctx.models.getModel(modelName, 'entity');
     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);
+      case 'create': {
+        const id = await createEntity(model, args.data, ctx, 'mutation');
+
+        return await resolve(ctx, id);
+      }
+      case 'update': {
+        const id = args.where.id;
+
+        await updateEntity(model, id, args.data, ctx);
+
+        return await resolve(ctx, id);
+      }
+      case 'delete': {
+        const id = args.where.id;
+
+        await deleteEntity(model, id, args.dryRun, model.rootModel.name, id, ctx, 'mutation');
+
+        return id;
+      }
+      case 'restore': {
+        const id = args.where.id;
+
+        await restoreEntity(model, id, ctx, 'mutation');
+
+        return id;
+      }
     }
   });
 };
 
-const create = async (model: EntityModel, { data: input }: { data: any }, ctx: FullContext) => {
+export const createEntity = async (
+  model: EntityModel,
+  input: Entity,
+  ctx: MutationContext,
+  trigger: Trigger = 'direct-call',
+) => {
   const normalizedInput = { ...input };
-  normalizedInput.id = uuid();
-  normalizedInput.createdAt = ctx.now;
-  normalizedInput.createdById = ctx.user?.id;
+  if (!normalizedInput.id) {
+    normalizedInput.id = uuid();
+  }
+  const id = normalizedInput.id as string;
+  if (!normalizedInput.createdAt) {
+    normalizedInput.createdAt = ctx.now;
+  }
+  if (!normalizedInput.createdById) {
+    normalizedInput.createdById = ctx.user?.id;
+  }
   if (model.parent) {
     normalizedInput.type = model.name;
   }
@@ -42,10 +72,11 @@ const create = async (model: EntityModel, { data: input }: { data: any }, ctx: F
   await ctx.handleUploads?.(normalizedInput);
 
   const data = { prev: {}, input, normalizedInput, next: normalizedInput };
-  await ctx.mutationHook?.({ model, action: 'create', trigger: 'mutation', when: 'before', data, ctx });
+  await ctx.mutationHook?.({ model, action: 'create', trigger, when: 'before', data, ctx });
+
   if (model.parent) {
     const rootInput = {};
-    const childInput = { id: normalizedInput.id };
+    const childInput = { id };
     for (const field of model.fields) {
       const columnName = field.kind === 'relation' ? `${field.name}Id` : field.name;
       if (columnName in normalizedInput) {
@@ -62,25 +93,39 @@ const create = async (model: EntityModel, { data: input }: { data: any }, ctx: F
     await ctx.knex(model.name).insert(normalizedInput);
   }
   await createRevision(model, normalizedInput, ctx);
-  await ctx.mutationHook?.({ model, action: 'create', trigger: 'mutation', when: 'after', data, ctx });
+  await ctx.mutationHook?.({ model, action: 'create', trigger, when: 'after', data, ctx });
 
-  return await resolve(ctx, normalizedInput.id);
+  return normalizedInput.id as string;
 };
 
-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.`);
+export const updateEntities = async (
+  model: EntityModel,
+  where: Record<string, unknown>,
+  updateFields: Entity,
+  ctx: MutationContext,
+) => {
+  const entities = await ctx.knex(model.name).where(where).select('id');
+  for (const entity of entities) {
+    await updateEntity(model, entity.id, updateFields, ctx);
   }
+};
 
+export const updateEntity = async (
+  model: EntityModel,
+  id: string,
+  input: Entity,
+  ctx: MutationContext,
+  trigger: Trigger = 'direct-call',
+) => {
   const normalizedInput = { ...input };
 
   sanitize(ctx, model, normalizedInput);
 
-  const prev = await getEntityToMutate(ctx, model, where, 'UPDATE');
+  const currentEntity = await getEntityToMutate(ctx, model, { id }, '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]) {
+    if (normalizedInput[key] === currentEntity[key]) {
       delete normalizedInput[key];
     }
   }
@@ -89,49 +134,52 @@ const update = async (model: EntityModel, { where, data: input }: { where: any;
     await checkCanWrite(ctx, model, normalizedInput, 'UPDATE');
     await ctx.handleUploads?.(normalizedInput);
 
-    const next = { ...prev, ...normalizedInput };
-    const data = { prev, input, normalizedInput, next };
-    await ctx.mutationHook?.({ model, action: 'update', trigger: 'mutation', when: 'before', data, ctx });
-
-    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, action: 'update', trigger: 'mutation', when: 'after', data, ctx });
+    await ctx.mutationHook?.({
+      model,
+      action: 'update',
+      trigger,
+      when: 'before',
+      data: { prev: currentEntity, input, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
+      ctx,
+    });
+    await doUpdate(model, currentEntity, normalizedInput, ctx);
+    await ctx.mutationHook?.({
+      model,
+      action: 'update',
+      trigger,
+      when: 'after',
+      data: { prev: currentEntity, input, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
+      ctx,
+    });
   }
-
-  return await resolve(ctx);
 };
 
 type Callbacks = (() => Promise<void>)[];
 
-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.`);
+export const deleteEntities = async (
+  model: EntityModel,
+  where: Record<string, unknown>,
+  deleteRootType: string | undefined,
+  deleteRootId: string | undefined,
+  ctx: MutationContext,
+) => {
+  const entities = await ctx.knex(model.name).where(where).select('id');
+  for (const entity of entities) {
+    await deleteEntity(model, entity.id, false, deleteRootType, deleteRootId, ctx);
   }
+};
 
+export const deleteEntity = async (
+  model: EntityModel,
+  id: string,
+  dryRun: boolean,
+  deleteRootType: string | undefined = model.rootModel.name,
+  deleteRootId: string | undefined = id,
+  ctx: MutationContext,
+  trigger: Trigger = 'direct-call',
+) => {
   const rootModel = model.rootModel;
-  const entity = await getEntityToMutate(ctx, rootModel, where, 'DELETE');
+  const entity = await getEntityToMutate(ctx, rootModel, { id }, 'DELETE');
 
   if (entity.deleted) {
     throw new ForbiddenError(`${getTechnicalDisplay(model, entity)} is already deleted.`);
@@ -164,7 +212,7 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
   const afterHooks: Callbacks = [];
 
   const mutationHook = ctx.mutationHook;
-  const deleteCascade = async (currentModel: EntityModel, currentEntity: Entity) => {
+  const deleteCascade = async (currentModel: EntityModel, currentEntity: Entity, currentTrigger: Trigger) => {
     if (!(currentModel.name in toDelete)) {
       toDelete[currentModel.name] = {};
     }
@@ -172,42 +220,38 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
       return;
     }
     toDelete[currentModel.name][currentEntity.id as string] = await fetchDisplay(ctx.knex, currentModel, currentEntity);
-    const trigger = currentModel.name === rootModel.name && currentEntity.id === entity.id ? 'mutation' : 'cascade';
 
     if (!dryRun) {
       const normalizedInput = {
         deleted: true,
         deletedAt: ctx.now,
         deletedById: ctx.user?.id,
-        deleteRootType: rootModel.name,
-        deleteRootId: entity.id,
+        deleteRootType,
+        deleteRootId,
       };
-      const next = { ...currentEntity, ...normalizedInput };
-      const data = { prev: currentEntity, input: {}, normalizedInput, next };
       if (mutationHook) {
         beforeHooks.push(async () => {
           await mutationHook({
             model: currentModel,
             action: 'delete',
-            trigger,
+            trigger: currentTrigger,
             when: 'before',
-            data,
+            data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
             ctx,
           });
         });
       }
       mutations.push(async () => {
-        await ctx.knex(currentModel.name).where({ id: currentEntity.id }).update(normalizedInput);
-        await createRevision(currentModel, next, ctx);
+        await doUpdate(currentModel, currentEntity, normalizedInput, ctx);
       });
       if (mutationHook) {
         afterHooks.push(async () => {
           await mutationHook({
             model: currentModel,
             action: 'delete',
-            trigger,
+            trigger: currentTrigger,
             when: 'after',
-            data,
+            data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
             ctx,
           });
         });
@@ -237,8 +281,6 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
                 toUnlink[descendantModel.name][descendant.id].fields.push(name);
               } else {
                 const normalizedInput = { [`${name}Id`]: null };
-                const next = { ...descendant, ...normalizedInput };
-                const data = { prev: descendant, input: {}, normalizedInput, next };
                 if (mutationHook) {
                   beforeHooks.push(async () => {
                     await mutationHook({
@@ -246,14 +288,13 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
                       action: 'update',
                       trigger: 'set-null',
                       when: 'before',
-                      data,
+                      data: { prev: descendant, input: {}, normalizedInput, next: { ...descendant, ...normalizedInput } },
                       ctx,
                     });
                   });
                 }
                 mutations.push(async () => {
-                  await ctx.knex(descendantModel.name).where({ id: descendant.id }).update(normalizedInput);
-                  await createRevision(descendantModel, next, ctx);
+                  await doUpdate(descendantModel, descendant, normalizedInput, ctx);
                 });
                 if (mutationHook) {
                   afterHooks.push(async () => {
@@ -262,7 +303,7 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
                       action: 'update',
                       trigger: 'set-null',
                       when: 'after',
-                      data,
+                      data: { prev: descendant, input: {}, normalizedInput, next: { ...descendant, ...normalizedInput } },
                       ctx,
                     });
                   });
@@ -308,7 +349,7 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
               );
             }
             for (const descendant of descendants) {
-              await deleteCascade(descendantModel, descendant);
+              await deleteCascade(descendantModel, descendant, 'cascade');
             }
             break;
           }
@@ -317,7 +358,7 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
     }
   };
 
-  await deleteCascade(rootModel, entity);
+  await deleteCascade(rootModel, entity, trigger);
 
   for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
     await callback();
@@ -331,18 +372,17 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
       restricted,
     });
   }
-
-  return entity.id;
 };
 
-const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullContext) => {
-  if (Object.keys(where).length === 0) {
-    throw new Error(`No ${model.name} specified.`);
-  }
-
+export const restoreEntity = async (
+  model: EntityModel,
+  id: string,
+  ctx: MutationContext,
+  trigger: Trigger = 'direct-call',
+) => {
   const rootModel = model.rootModel;
 
-  const entity = await getEntityToMutate(ctx, rootModel, where, 'RESTORE');
+  const entity = await getEntityToMutate(ctx, rootModel, { id }, 'RESTORE');
 
   if (!entity.deleted) {
     throw new ForbiddenError(`${getTechnicalDisplay(model, entity)} is not deleted.`);
@@ -362,9 +402,9 @@ const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullC
   const mutations: Callbacks = [];
   const afterHooks: Callbacks = [];
 
-  const restoreCascade = async (currentModel: EntityModel, currentEntity: Entity) => {
+  const restoreCascade = async (currentModel: EntityModel, currentEntity: Entity, currentTrigger: Trigger) => {
     if (entity.deleteRootId) {
-      if (!(currentEntity.deleteRootType === currentModel.name && currentEntity.deleteRootId === entity.id)) {
+      if (!(currentEntity.deleteRootType === model.name && currentEntity.deleteRootId === entity.id)) {
         return;
       }
 
@@ -381,7 +421,7 @@ const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullC
     toRestore[currentModel.name].add(currentEntity.id as string);
 
     for (const relation of currentModel.relations) {
-      const parentId = entity[relation.field.foreignKey];
+      const parentId = currentEntity[relation.field.foreignKey] as string | undefined;
       if (!parentId) {
         continue;
       }
@@ -406,16 +446,29 @@ const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullC
     const data = { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } };
     if (ctx.mutationHook) {
       beforeHooks.push(async () => {
-        await ctx.mutationHook!({ model: currentModel, action: 'restore', trigger: 'mutation', when: 'before', data, ctx });
+        await ctx.mutationHook!({
+          model: currentModel,
+          action: 'restore',
+          trigger: currentTrigger,
+          when: 'before',
+          data,
+          ctx,
+        });
       });
     }
     mutations.push(async () => {
-      await ctx.knex(currentModel.name).where({ id: currentEntity.id }).update(normalizedInput);
-      await createRevision(currentModel, { ...currentEntity, deleted: false }, ctx);
+      await doUpdate(currentModel, currentEntity, normalizedInput, ctx);
     });
     if (ctx.mutationHook) {
       afterHooks.push(async () => {
-        await ctx.mutationHook!({ model: currentModel, action: 'restore', trigger: 'mutation', when: 'after', data, ctx });
+        await ctx.mutationHook!({
+          model: currentModel,
+          action: 'restore',
+          trigger: currentTrigger,
+          when: 'after',
+          data,
+          ctx,
+        });
       });
     }
 
@@ -438,21 +491,19 @@ const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullC
         );
       }
       for (const descendant of deletedDescendants) {
-        await restoreCascade(descendantModel, descendant);
+        await restoreCascade(descendantModel, descendant, 'cascade');
       }
     }
   };
 
-  await restoreCascade(rootModel, entity);
+  await restoreCascade(rootModel, entity, trigger);
 
   for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
     await callback();
   }
-
-  return entity.id;
 };
 
-export const createRevision = async (model: EntityModel, data: Entity, ctx: Pick<Context, 'knex' | 'now' | 'user'>) => {
+export const createRevision = async (model: EntityModel, data: Entity, ctx: MutationContext) => {
   if (model.updatable) {
     const revisionId = uuid();
     const rootRevisionData: Entity = {
@@ -491,10 +542,14 @@ export const createRevision = async (model: EntityModel, data: Entity, ctx: Pick
   }
 };
 
-const sanitize = (ctx: FullContext, model: EntityModel, data: Entity) => {
+const sanitize = (ctx: MutationContext, model: EntityModel, data: Entity) => {
   if (model.updatable) {
-    data.updatedAt = ctx.now;
-    data.updatedById = ctx.user?.id;
+    if (!data.updatedAt) {
+      data.updatedAt = ctx.now;
+    }
+    if (!data.updatedById) {
+      data.updatedById = ctx.user?.id;
+    }
   }
 
   for (const key of Object.keys(data)) {
@@ -526,3 +581,37 @@ const isEndOfDay = (field: EntityField) =>
 
 const isEndOfMonth = (field: EntityField) =>
   isPrimitive(field) && field.type === 'DateTime' && field?.endOfMonth === true && field?.dateTimeType === 'year_and_month';
+
+const doUpdate = async (model: EntityModel, currentEntity: Entity, update: Entity, ctx: MutationContext) => {
+  if (model.updatable) {
+    if (!update.updatedAt) {
+      update.updatedAt = ctx.now;
+    }
+    if (!update.updatedById) {
+      update.updatedById = ctx.user?.id;
+    }
+  }
+  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 update) {
+        if (field.inherited) {
+          rootInput[columnName] = update[columnName];
+        } else {
+          childInput[columnName] = update[columnName];
+        }
+      }
+    }
+    if (Object.keys(rootInput).length) {
+      await ctx.knex(model.parent).where({ id: currentEntity.id }).update(rootInput);
+    }
+    if (Object.keys(childInput).length) {
+      await ctx.knex(model.name).where({ id: currentEntity.id }).update(childInput);
+    }
+  } else {
+    await ctx.knex(model.name).where({ id: currentEntity.id }).update(update);
+  }
+  await createRevision(model, { ...currentEntity, ...update }, ctx);
+};