add accept-invitation

Author: nikgraf

apps/events/src/components/debug-invitations.tsx

@@ -1,7 +1,12 @@
 import type { Invitation } from 'graph-framework';
 import { Button } from './ui/button';
 
-export function DebugInvitations({ invitations }: { invitations: Invitation[] }) {
+type Props = {
+  invitations: Invitation[];
+  accept: (invitation: Invitation) => void;
+};
+
+export function DebugInvitations({ invitations, accept }: Props) {
   return (
     <ul className="text-xs">
       {invitations.map((invitation) => {
@@ -10,7 +15,7 @@ export function DebugInvitations({ invitations }: { invitations: Invitation[] })
             <pre>{JSON.stringify(invitation, null, 2)}</pre>
             <Button
               onClick={() => {
-                alert('TODO');
+                accept(invitation);
               }}
             >
               Accept

apps/events/src/routes/playground.tsx

@@ -15,7 +15,7 @@ import type {
   SpaceEvent,
   SpaceState,
 } from 'graph-framework';
-import { ResponseMessage, applyEvent, createInvitation, createSpace } from 'graph-framework';
+import { ResponseMessage, acceptInvitation, applyEvent, createInvitation, createSpace } from 'graph-framework';
 import { useEffect, useState } from 'react';
 
 const availableAccounts = [
@@ -186,7 +186,27 @@ const App = ({ accountId, signaturePrivateKey }: { accountId: string; signatureP
         </Button>
       </div>
       <h2 className="text-lg">Invitations</h2>
-      <DebugInvitations invitations={invitations} />
+      <DebugInvitations
+        invitations={invitations}
+        accept={async (invitation) => {
+          const spaceEvent = await Effect.runPromiseExit(
+            acceptInvitation({
+              author: {
+                signaturePublicKey: accountId,
+                encryptionPublicKey: 'TODO',
+                signaturePrivateKey,
+              },
+              previousEventHash: invitation.previousEventHash,
+            }),
+          );
+          if (Exit.isFailure(spaceEvent)) {
+            console.error('Failed to accept invitation', spaceEvent);
+            return;
+          }
+          const message: EventMessage = { type: 'event', event: spaceEvent.value, spaceId: invitation.spaceId };
+          websocketConnection?.send(JSON.stringify(message));
+        }}
+      />
       <h2 className="text-lg">Spaces</h2>
       <ul>
         {spaces.map((space) => {

apps/server/prisma/migrations/20241116161206_extend_invitation/migration.sql

@@ -0,0 +1,24 @@
+/*
+  Warnings:
+
+  - Added the required column `inviteeAccountId` to the `Invitation` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- RedefineTables
+PRAGMA defer_foreign_keys=ON;
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Invitation" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "spaceId" TEXT NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "inviteeAccountId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "Invitation_spaceId_fkey" FOREIGN KEY ("spaceId") REFERENCES "Space" ("id") ON DELETE RESTRICT ON UPDATE CASCADE,
+    CONSTRAINT "Invitation_accountId_fkey" FOREIGN KEY ("accountId") REFERENCES "Account" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_Invitation" ("accountId", "createdAt", "id", "spaceId") SELECT "accountId", "createdAt", "id", "spaceId" FROM "Invitation";
+DROP TABLE "Invitation";
+ALTER TABLE "new_Invitation" RENAME TO "Invitation";
+CREATE UNIQUE INDEX "Invitation_spaceId_inviteeAccountId_key" ON "Invitation"("spaceId", "inviteeAccountId");
+PRAGMA foreign_keys=ON;
+PRAGMA defer_foreign_keys=OFF;

apps/server/prisma/schema.prisma

@@ -36,10 +36,13 @@ model Account {
 }
 
 model Invitation {
-  id        String   @id
-  space     Space    @relation(fields: [spaceId], references: [id])
-  spaceId   String
-  account   Account  @relation(fields: [accountId], references: [id])
-  accountId String
-  createdAt DateTime @default(now())
+  id               String   @id
+  space            Space    @relation(fields: [spaceId], references: [id])
+  spaceId          String
+  account          Account  @relation(fields: [accountId], references: [id])
+  accountId        String
+  inviteeAccountId String
+  createdAt        DateTime @default(now())
+
+  @@unique([spaceId, inviteeAccountId])
 }

apps/server/src/handlers/applySpaceEvent.ts

@@ -15,11 +15,18 @@ export async function applySpaceEvent({ accountId, spaceId, event }: Params) {
   }
 
   return await prisma.$transaction(async (transaction) => {
-    // verify that the account is a member of the space
-    // TODO verify that the account is a admin of the space
-    await transaction.space.findUniqueOrThrow({
-      where: { id: spaceId, members: { some: { id: accountId } } },
-    });
+    if (event.transaction.type === 'accept-invitation') {
+      // verify that the account is the invitee
+      await transaction.invitation.findFirstOrThrow({
+        where: { inviteeAccountId: event.author.publicKey },
+      });
+    } else {
+      // verify that the account is a member of the space
+      // TODO verify that the account is a admin of the space
+      await transaction.space.findUniqueOrThrow({
+        where: { id: spaceId, members: { some: { id: accountId } } },
+      });
+    }
 
     const lastEvent = await transaction.spaceEvent.findFirstOrThrow({
       where: { spaceId },
@@ -38,9 +45,20 @@ export async function applySpaceEvent({ accountId, spaceId, event }: Params) {
           id: event.transaction.id,
           spaceId,
           accountId: event.transaction.signaturePublicKey,
+          inviteeAccountId: event.transaction.signaturePublicKey,
         },
       });
     }
+    if (event.transaction.type === 'accept-invitation') {
+      await transaction.invitation.delete({
+        where: { spaceId_inviteeAccountId: { spaceId, inviteeAccountId: event.author.publicKey } },
+      });
+
+      await transaction.space.update({
+        where: { id: spaceId },
+        data: { members: { connect: { id: event.author.publicKey } } },
+      });
+    }
 
     return await transaction.spaceEvent.create({
       data: {

apps/server/src/handlers/listInvitations.ts

@@ -18,7 +18,7 @@ export const listInvitations = async ({ accountId }: Params) => {
         include: {
           events: {
             orderBy: {
-              counter: 'asc',
+              counter: 'desc',
             },
             take: 1,
           },

apps/server/src/index.ts

@@ -1,11 +1,11 @@
 import cors from 'cors';
 import 'dotenv/config';
-import { parse } from 'node:url';
 import { Effect, Exit, Schema } from 'effect';
 import express from 'express';
 import type { ResponseListInvitations, ResponseListSpaces, ResponseSpace } from 'graph-framework-messages';
 import { RequestMessage } from 'graph-framework-messages';
 import { type CreateSpaceEvent, applyEvent } from 'graph-framework-space-events';
+import { parse } from 'node:url';
 import type WebSocket from 'ws';
 import { WebSocketServer } from 'ws';
 import { applySpaceEvent } from './handlers/applySpaceEvent.js';
@@ -106,6 +106,17 @@ webSocketServer.on('connection', async (webSocket: WebSocket, request: Request)
               webSocket.send(JSON.stringify(outgoingMessage));
               break;
             }
+            case 'accept-invitation': {
+              await applySpaceEvent({ accountId, spaceId: data.spaceId, event: data.event });
+              const spaceWithEvents = await getSpace({ accountId, spaceId: data.spaceId });
+              const outgoingMessage: ResponseSpace = {
+                type: 'space',
+                id: data.spaceId,
+                events: spaceWithEvents.events.map((wrapper) => JSON.parse(wrapper.event)),
+              };
+              webSocket.send(JSON.stringify(outgoingMessage));
+              break;
+            }
           }
           break;
         }

packages/graph-framework-space-events/src/accept-invitation.test.ts

@@ -0,0 +1,60 @@
+import { expect, it } from 'vitest';
+
+import { Effect } from 'effect';
+import { acceptInvitation } from './accept-invitation.js';
+import { applyEvent } from './apply-event.js';
+import { createInvitation } from './create-invitation.js';
+import { createSpace } from './create-space.js';
+
+const author = {
+  signaturePublicKey: '03594161eed61407084114a142d1ce05ef4c5a5279479fdd73a2b16944fbff003b',
+  signaturePrivateKey: '76b78f644c19d6133018a97a3bc2d5038be0af5a2858b9e640ff3e2f2db63a0b',
+  encryptionPublicKey: 'encryption',
+};
+
+const invitee = {
+  signaturePublicKey: '03bf5d2a1badf15387b08a007d1a9a13a9bfd6e1c56f681e251514d9ba10b57462',
+  signaturePrivateKey: '1eee32d3bc202dcb5d17c3b1454fb541d2290cb941860735408f1bfe39e7bc15',
+  encryptionPublicKey: 'encryption',
+};
+
+it('should accept an invitation', async () => {
+  const { state3 } = await Effect.runPromise(
+    Effect.gen(function* () {
+      const spaceEvent = yield* createSpace({ author });
+      const state = yield* applyEvent({ event: spaceEvent });
+      const spaceEvent2 = yield* createInvitation({
+        author,
+        previousEventHash: state.lastEventHash,
+        invitee,
+      });
+      const state2 = yield* applyEvent({ state, event: spaceEvent2 });
+      const spaceEvent3 = yield* acceptInvitation({
+        previousEventHash: state2.lastEventHash,
+        author: invitee,
+      });
+      const state3 = yield* applyEvent({ state: state2, event: spaceEvent3 });
+      return {
+        state3,
+        spaceEvent3,
+      };
+    }),
+  );
+
+  expect(state3.id).toBeTypeOf('string');
+  expect(state3.invitations).toEqual({});
+  expect(state3.members).toEqual({
+    [author.signaturePublicKey]: {
+      signaturePublicKey: author.signaturePublicKey,
+      encryptionPublicKey: author.encryptionPublicKey,
+      role: 'admin',
+    },
+    [invitee.signaturePublicKey]: {
+      signaturePublicKey: invitee.signaturePublicKey,
+      encryptionPublicKey: invitee.encryptionPublicKey,
+      role: 'member',
+    },
+  });
+  expect(state3.removedMembers).toEqual({});
+  expect(state3.lastEventHash).toBeTypeOf('string');
+});

packages/graph-framework-space-events/src/accept-invitation.ts

@@ -0,0 +1,30 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { Effect } from 'effect';
+import { canonicalize, generateId, stringToUint8Array } from 'graph-framework-utils';
+import type { AcceptInvitationEvent, Author } from './types.js';
+
+type Params = {
+  author: Author;
+  previousEventHash: string;
+};
+
+export const acceptInvitation = ({
+  author,
+  previousEventHash,
+}: Params): Effect.Effect<AcceptInvitationEvent, undefined> => {
+  const transaction = {
+    id: generateId(),
+    type: 'accept-invitation' as const,
+    previousEventHash,
+  };
+  const encodedTransaction = stringToUint8Array(canonicalize(transaction));
+  const signature = secp256k1.sign(encodedTransaction, author.signaturePrivateKey, { prehash: true }).toCompactHex();
+
+  return Effect.succeed({
+    transaction,
+    author: {
+      publicKey: author.signaturePublicKey,
+      signature,
+    },
+  });
+};

packages/graph-framework-space-events/src/apply-event.ts

@@ -34,11 +34,13 @@ export const applyEvent = ({
       return Effect.fail(new InvalidEventError());
     }
     if (event.transaction.previousEventHash !== state.lastEventHash) {
+      console.log('WEEEEE', event.transaction.previousEventHash, state.lastEventHash);
       return Effect.fail(new InvalidEventError());
     }
   }
 
   const encodedTransaction = stringToUint8Array(canonicalize(event.transaction));
+
   const isValidSignature = secp256k1.verify(event.author.signature, encodedTransaction, event.author.publicKey, {
     prehash: true,
   });
@@ -65,27 +67,58 @@ export const applyEvent = ({
     removedMembers = { ...state.removedMembers };
     invitations = { ...state.invitations };
 
-    if (event.transaction.type === 'delete-space') {
-      removedMembers = { ...members };
-      members = {};
-      invitations = {};
-    } else if (event.transaction.type === 'create-invitation') {
-      if (members[event.transaction.signaturePublicKey] !== undefined) {
+    if (event.transaction.type === 'accept-invitation') {
+      // is already a member
+      if (members[event.author.publicKey] !== undefined) {
         return Effect.fail(new InvalidEventError());
       }
-      for (const invitation of Object.values(invitations)) {
-        if (invitation.signaturePublicKey === event.transaction.signaturePublicKey) {
-          return Effect.fail(new InvalidEventError());
-        }
+
+      // find the invitation
+      const result = Object.entries(invitations).find(
+        ([, invitation]) => invitation.signaturePublicKey === event.author.publicKey,
+      );
+      if (!result) {
+        return Effect.fail(new InvalidEventError());
       }
+      const [id, invitation] = result;
 
-      invitations[event.transaction.id] = {
-        signaturePublicKey: event.transaction.signaturePublicKey,
-        encryptionPublicKey: event.transaction.encryptionPublicKey,
+      members[event.author.publicKey] = {
+        signaturePublicKey: event.author.publicKey,
+        encryptionPublicKey: invitation.encryptionPublicKey,
+        role: 'member',
       };
+      delete invitations[id];
+      if (removedMembers[event.author.publicKey] !== undefined) {
+        delete removedMembers[event.author.publicKey];
+      }
+    } else {
+      // check if the author is an admin
+      if (members[event.author.publicKey]?.role !== 'admin') {
+        return Effect.fail(new InvalidEventError());
+      }
+
+      if (event.transaction.type === 'delete-space') {
+        removedMembers = { ...members };
+        members = {};
+        invitations = {};
+      } else if (event.transaction.type === 'create-invitation') {
+        if (members[event.transaction.signaturePublicKey] !== undefined) {
+          return Effect.fail(new InvalidEventError());
+        }
+        for (const invitation of Object.values(invitations)) {
+          if (invitation.signaturePublicKey === event.transaction.signaturePublicKey) {
+            return Effect.fail(new InvalidEventError());
+          }
+        }
+
+        invitations[event.transaction.id] = {
+          signaturePublicKey: event.transaction.signaturePublicKey,
+          encryptionPublicKey: event.transaction.encryptionPublicKey,
+        };
+      } else {
+        throw new Error('State is required for all events except create-space');
+      }
     }
-  } else {
-    throw new Error('State is required for all events except create-space');
   }
 
   return Effect.succeed({