chore: Extend use of Event.createFromContext (#7010)

server/routes/api/apiKeys/apiKeys.ts

@@ -31,16 +31,14 @@ router.post(
       { transaction }
     );
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "api_keys.create",
         modelId: key.id,
-        teamId: user.teamId,
-        actorId: user.id,
         data: {
           name,
         },
-        ip: ctx.request.ip,
       },
       { transaction }
     );
@@ -90,16 +88,14 @@ router.post(
     authorize(user, "delete", key);
 
     await key.destroy({ transaction });
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "api_keys.delete",
         modelId: key.id,
-        teamId: user.teamId,
-        actorId: user.id,
         data: {
           name: key.name,
         },
-        ip: ctx.request.ip,
       },
       { transaction }
     );

server/routes/api/attachments/attachments.ts

@@ -78,16 +78,14 @@ router.post(
       },
       { transaction }
     );
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "attachments.create",
         data: {
           name,
         },
         modelId,
-        teamId: user.teamId,
-        actorId: user.id,
-        ip: ctx.request.ip,
       },
       { transaction }
     );
@@ -141,11 +139,8 @@ router.post(
 
     authorize(user, "delete", attachment);
     await attachment.destroy();
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "attachments.delete",
-      teamId: user.teamId,
-      actorId: user.id,
-      ip: ctx.request.ip,
     });
 
     ctx.body = {

server/routes/api/auth/auth.ts

@@ -163,16 +163,14 @@ router.post(
     const { user } = auth;
 
     await user.rotateJwtSecret({ transaction });
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "users.signout",
-        actorId: user.id,
         userId: user.id,
-        teamId: user.teamId,
         data: {
           name: user.name,
         },
-        ip: ctx.request.ip,
       },
       {
         transaction,

server/routes/api/authenticationProviders/authenticationProviders.ts

@@ -57,16 +57,14 @@ router.post(
       await authenticationProvider.disable({ transaction });
     }
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "authenticationProviders.update",
         data: {
           enabled,
         },
         modelId: id,
-        teamId: user.teamId,
-        actorId: user.id,
-        ip: ctx.request.ip,
       },
       { transaction }
     );

server/routes/api/collections/collections.ts

@@ -103,16 +103,14 @@ router.post(
 
     await collection.save({ transaction });
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "collections.create",
         collectionId: collection.id,
-        teamId: collection.teamId,
-        actorId: user.id,
         data: {
           name,
         },
-        ip: ctx.request.ip,
       },
       {
         transaction,
@@ -208,11 +206,10 @@ router.post(
       }
     );
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "fileOperations.create",
-        teamId: user.teamId,
-        actorId: user.id,
         modelId: fileOperation.id,
         data: {
           type: FileOperationType.Import,
@@ -264,17 +261,14 @@ router.post(
       await membership.save();
     }
 
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "collections.add_group",
       collectionId: collection.id,
-      teamId: collection.teamId,
-      actorId: user.id,
       modelId: groupId,
       data: {
         name: group.name,
         membershipId: membership.id,
       },
-      ip: ctx.request.ip,
     });
 
     ctx.body = {
@@ -315,18 +309,16 @@ router.post(
     }
 
     await collection.$remove("group", group);
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "collections.remove_group",
         collectionId: collection.id,
-        teamId: collection.teamId,
-        actorId: user.id,
         modelId: groupId,
         data: {
           name: group.name,
           membershipId: membership.id,
         },
-        ip: ctx.request.ip,
       },
       { transaction }
     );
@@ -439,19 +431,17 @@ router.post(
       await membership.save({ transaction });
     }
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "collections.add_user",
         userId,
         modelId: membership.id,
         collectionId: collection.id,
-        teamId: collection.teamId,
-        actorId: actor.id,
         data: {
           isNew,
           permission: membership.permission,
         },
-        ip: ctx.request.ip,
       },
       {
         transaction,
@@ -495,18 +485,16 @@ router.post(
 
     await collection.$remove("user", user, { transaction });
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "collections.remove_user",
         userId,
         modelId: membership.id,
         collectionId: collection.id,
-        teamId: collection.teamId,
-        actorId: actor.id,
         data: {
           name: user.name,
         },
-        ip: ctx.request.ip,
       },
       { transaction }
     );
@@ -737,16 +725,14 @@ router.post(
     }
 
     await collection.save({ transaction });
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "collections.update",
         collectionId: collection.id,
-        teamId: collection.teamId,
-        actorId: user.id,
         data: {
           name,
         },
-        ip: ctx.request.ip,
       },
       {
         transaction,
@@ -754,17 +740,15 @@ router.post(
     );
 
     if (privacyChanged || sharingChanged) {
-      await Event.create(
+      await Event.createFromContext(
+        ctx,
         {
           name: "collections.permission_changed",
           collectionId: collection.id,
-          teamId: collection.teamId,
-          actorId: user.id,
           data: {
             privacyChanged,
             sharingChanged,
           },
-          ip: ctx.request.ip,
         },
         {
           transaction,
@@ -912,16 +896,14 @@ router.post(
         transaction,
       }
     );
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "collections.move",
         collectionId: collection.id,
-        teamId: collection.teamId,
-        actorId: user.id,
         data: {
           index,
         },
-        ip: ctx.request.ip,
       },
       {
         transaction,

server/routes/api/documents/documents.ts

@@ -681,31 +681,25 @@ router.post(
       authorize(user, "restore", document);
       // restore a previously deleted document
       await document.unarchive(user.id);
-      await Event.create({
+      await Event.createFromContext(ctx, {
         name: "documents.restore",
         documentId: document.id,
         collectionId: document.collectionId,
-        teamId: document.teamId,
-        actorId: user.id,
         data: {
           title: document.title,
         },
-        ip: ctx.request.ip,
       });
     } else if (document.archivedAt) {
       authorize(user, "unarchive", document);
       // restore a previously archived document
       await document.unarchive(user.id);
-      await Event.create({
+      await Event.createFromContext(ctx, {
         name: "documents.unarchive",
         documentId: document.id,
         collectionId: document.collectionId,
-        teamId: document.teamId,
-        actorId: user.id,
         data: {
           title: document.title,
         },
-        ip: ctx.request.ip,
       });
     } else if (revisionId) {
       // restore a document to a specific revision
@@ -716,16 +710,13 @@ router.post(
       document.restoreFromRevision(revision);
       await document.save();
 
-      await Event.create({
+      await Event.createFromContext(ctx, {
         name: "documents.restore",
         documentId: document.id,
         collectionId: document.collectionId,
-        teamId: document.teamId,
-        actorId: user.id,
         data: {
           title: document.title,
         },
-        ip: ctx.request.ip,
       });
     } else {
       assertPresent(revisionId, "revisionId is required");
@@ -960,18 +951,16 @@ router.post(
         transaction,
       }
     );
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "documents.create",
         documentId: document.id,
         collectionId: document.collectionId,
-        teamId: document.teamId,
-        actorId: user.id,
         data: {
           title: document.title,
           template: true,
         },
-        ip: ctx.request.ip,
       },
       {
         transaction,
@@ -1195,16 +1184,13 @@ router.post(
     authorize(user, "archive", document);
 
     await document.archive(user.id);
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "documents.archive",
       documentId: document.id,
       collectionId: document.collectionId,
-      teamId: document.teamId,
-      actorId: user.id,
       data: {
         title: document.title,
       },
-      ip: ctx.request.ip,
     });
 
     ctx.body = {
@@ -1230,16 +1216,13 @@ router.post(
       authorize(user, "permanentDelete", document);
 
       await documentPermanentDeleter([document]);
-      await Event.create({
+      await Event.createFromContext(ctx, {
         name: "documents.permanent_delete",
         documentId: document.id,
         collectionId: document.collectionId,
-        teamId: document.teamId,
-        actorId: user.id,
         data: {
           title: document.title,
         },
-        ip: ctx.request.ip,
       });
     } else {
       const document = await Document.findByPk(id, {
@@ -1249,16 +1232,13 @@ router.post(
       authorize(user, "delete", document);
 
       await document.delete(user.id);
-      await Event.create({
+      await Event.createFromContext(ctx, {
         name: "documents.delete",
         documentId: document.id,
         collectionId: document.collectionId,
-        teamId: document.teamId,
-        actorId: user.id,
         data: {
           title: document.title,
         },
-        ip: ctx.request.ip,
       });
     }
 
@@ -1293,16 +1273,13 @@ router.post(
     }
 
     await document.unpublish(user.id);
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "documents.unpublish",
       documentId: document.id,
       collectionId: document.collectionId,
-      teamId: document.teamId,
-      actorId: user.id,
       data: {
         title: document.title,
       },
-      ip: ctx.request.ip,
     });
 
     ctx.body = {
@@ -1550,15 +1527,13 @@ router.post(
       await membership.save({ transaction });
     }
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "documents.add_user",
         userId,
         modelId: membership.id,
         documentId: document.id,
-        teamId: document.teamId,
-        actorId: actor.id,
-        ip: ctx.request.ip,
         data: {
           title: document.title,
           isNew,
@@ -1618,15 +1593,13 @@ router.post(
 
     await membership.destroy({ transaction });
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "documents.remove_user",
         userId,
         modelId: membership.id,
         documentId: document.id,
-        teamId: document.teamId,
-        actorId: actor.id,
-        ip: ctx.request.ip,
       },
       { transaction }
     );
@@ -1736,11 +1709,8 @@ router.post(
     });
 
     await documentPermanentDeleter(documents);
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "documents.empty_trash",
-      teamId: user.teamId,
-      actorId: user.id,
-      ip: ctx.request.ip,
     });
 
     ctx.body = {

server/routes/api/groups/groups.ts

@@ -105,15 +105,12 @@ router.post(
     // reload to get default scope
     const group = await Group.findByPk(g.id, { rejectOnEmpty: true });
 
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "groups.create",
-      actorId: user.id,
-      teamId: user.teamId,
       modelId: group.id,
       data: {
         name: group.name,
       },
-      ip: ctx.request.ip,
     });
 
     ctx.body = {
@@ -138,15 +135,12 @@ router.post(
 
     if (group.changed()) {
       await group.save();
-      await Event.create({
+      await Event.createFromContext(ctx, {
         name: "groups.update",
-        teamId: user.teamId,
-        actorId: user.id,
         modelId: group.id,
         data: {
           name,
         },
-        ip: ctx.request.ip,
       });
     }
 
@@ -169,15 +163,12 @@ router.post(
     authorize(user, "delete", group);
 
     await group.destroy();
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "groups.delete",
-      actorId: user.id,
       modelId: group.id,
-      teamId: group.teamId,
       data: {
         name: group.name,
       },
-      ip: ctx.request.ip,
     });
 
     ctx.body = {
@@ -275,16 +266,13 @@ router.post(
       // reload to get default scope
       group = await Group.findByPk(id, { rejectOnEmpty: true });
 
-      await Event.create({
+      await Event.createFromContext(ctx, {
         name: "groups.add_user",
         userId,
-        teamId: user.teamId,
         modelId: group.id,
-        actorId: actor.id,
         data: {
           name: user.name,
         },
-        ip: ctx.request.ip,
       });
     }
 
@@ -315,16 +303,13 @@ router.post(
     authorize(actor, "read", user);
 
     await group.$remove("user", user);
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "groups.remove_user",
       userId,
       modelId: group.id,
-      teamId: user.teamId,
-      actorId: actor.id,
       data: {
         name: user.name,
       },
-      ip: ctx.request.ip,
     });
 
     // reload to get default scope

server/routes/api/integrations/integrations.ts

@@ -157,13 +157,11 @@ router.post(
 
     await integration.destroy({ transaction });
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "integrations.delete",
         modelId: integration.id,
-        teamId: integration.teamId,
-        actorId: user.id,
-        ip: ctx.request.ip,
       },
       { transaction }
     );

server/routes/api/shares/shares.ts

@@ -200,20 +200,17 @@ router.post(
     });
 
     if (isCreated) {
-      await Event.create({
+      await Event.createFromContext(ctx, {
         name: "shares.create",
         documentId,
         collectionId: document.collectionId,
         modelId: share.id,
-        teamId: user.teamId,
-        actorId: user.id,
         data: {
           name: document.title,
           published,
           includeChildDocuments,
           urlId,
         },
-        ip: ctx.request.ip,
       });
     }
 
@@ -261,16 +258,13 @@ router.post(
     }
 
     await share.save();
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "shares.update",
       documentId: share.documentId,
       modelId: share.id,
-      teamId: user.teamId,
-      actorId: user.id,
       data: {
         published,
       },
-      ip: ctx.request.ip,
     });
 
     ctx.body = {
@@ -297,17 +291,14 @@ router.post(
     const { document } = share;
 
     await share.revoke(user.id);
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "shares.revoke",
       documentId: document.id,
       collectionId: document.collectionId,
       modelId: share.id,
-      teamId: user.teamId,
-      actorId: user.id,
       data: {
         name: document.title,
       },
-      ip: ctx.request.ip,
     });
 
     ctx.body = {

server/routes/api/userMemberships/userMemberships.ts

@@ -90,15 +90,13 @@ router.post(
     membership.index = index;
     await membership.save({ transaction });
 
-    await Event.create(
+    await Event.createFromContext(
+      ctx,
       {
         name: "userMemberships.update",
         modelId: membership.id,
         userId: membership.userId,
-        teamId: user.teamId,
-        actorId: user.id,
         documentId: membership.documentId,
-        ip: ctx.request.ip,
         data: {
           index: membership.index,
         },

server/routes/api/users/users.ts

@@ -335,17 +335,15 @@ async function updateRole(ctx: APIContext<T.UsersChangeRoleReq>) {
 
   await user.update({ role }, { transaction });
 
-  await Event.create(
+  await Event.createFromContext(
+    ctx,
     {
       name,
       userId,
-      actorId: actor.id,
-      teamId: actor.teamId,
       data: {
         name: user.name,
         role,
       },
-      ip: ctx.request.ip,
     },
     {
       transaction,

server/routes/api/views/views.ts

@@ -56,17 +56,14 @@ router.post(
       userId: user.id,
     });
 
-    await Event.create({
+    await Event.createFromContext(ctx, {
       name: "views.create",
-      actorId: user.id,
       documentId: document.id,
       collectionId: document.collectionId,
-      teamId: user.teamId,
       modelId: view.id,
       data: {
         title: document.title,
       },
-      ip: ctx.request.ip,
     });
     view.user = user;