implement create-invitation

nikgraf · nikgraf · commit e71b680f278b · 2024-11-14T18:01:24.000+01:00
diff --git a/apps/events/src/components/debug-space-events.tsx b/apps/events/src/components/debug-space-events.tsx
@@ -0,0 +1,15 @@
+import type { SpaceEvent } from 'graph-framework';
+
+export function DebugSpaceEvents({ events }: { events: SpaceEvent[] }) {
+  return (
+    <ul className="text-xs">
+      {events.map((event) => {
+        return (
+          <li key={event.transaction.id} className="border border-gray-300">
+            <pre>{JSON.stringify(event, null, 2)}</pre>
+          </li>
+        );
+      })}
+    </ul>
+  );
+}
diff --git a/apps/events/src/components/debug-space-state.tsx b/apps/events/src/components/debug-space-state.tsx
@@ -0,0 +1,9 @@
+import type { SpaceState } from 'graph-framework';
+
+export function DebugSpaceState(props: { state: SpaceState | undefined }) {
+  return (
+    <div className="text-xs">
+      <pre>{JSON.stringify(props, null, 2)}</pre>
+    </div>
+  );
+}
diff --git a/apps/events/src/routes/playground.tsx b/apps/events/src/routes/playground.tsx
@@ -1,12 +1,35 @@
+import { DebugSpaceEvents } from '@/components/debug-space-events';
+import { DebugSpaceState } from '@/components/debug-space-state';
 import { Button } from '@/components/ui/button';
 import { assertExhaustive } from '@/lib/assertExhaustive';
 import { createFileRoute } from '@tanstack/react-router';
-import { Effect } from 'effect';
+import { Effect, Exit } from 'effect';
 import * as Schema from 'effect/Schema';
-import type { EventMessage, RequestListSpaces, RequestSubscribeToSpace } from 'graph-framework';
-import { ResponseMessage, createSpace } from 'graph-framework';
+import type { EventMessage, RequestListSpaces, RequestSubscribeToSpace, SpaceEvent, SpaceState } from 'graph-framework';
+import { ResponseMessage, applyEvent, createInvitation, createSpace } from 'graph-framework';
 import { useEffect, useState } from 'react';
 
+const availableAccounts = [
+  {
+    accountId: '0262701b2eb1b6b37ad03e24445dfcad1b91309199e43017b657ce2604417c12f5',
+    signaturePrivateKey: '88bb6f20de8dc1787c722dc847f4cf3d00285b8955445f23c483d1237fe85366',
+  },
+  {
+    accountId: '03bf5d2a1badf15387b08a007d1a9a13a9bfd6e1c56f681e251514d9ba10b57462',
+    signaturePrivateKey: '1eee32d3bc202dcb5d17c3b1454fb541d2290cb941860735408f1bfe39e7bc15',
+  },
+  {
+    accountId: '0351460706cf386282d9b6ebee2ccdcb9ba61194fd024345e53037f3036242e6a2',
+    signaturePrivateKey: '434518a2c9a665a7c20da086232c818b6c1592e2edfeecab29a40cf5925ca8fe',
+  },
+];
+
+type SpaceStorageEntry = {
+  id: string;
+  events: SpaceEvent[];
+  state: SpaceState | undefined;
+};
+
 const decodeResponseMessage = Schema.decodeUnknownEither(ResponseMessage);
 
 export const Route = createFileRoute('/playground')({
@@ -15,26 +38,63 @@ export const Route = createFileRoute('/playground')({
 
 const App = ({ accountId, signaturePrivateKey }: { accountId: string; signaturePrivateKey: string }) => {
   const [websocketConnection, setWebsocketConnection] = useState<WebSocket>();
-  const [spaces, setSpaces] = useState<{ id: string }[]>([]);
+  const [spaces, setSpaces] = useState<SpaceStorageEntry[]>([]);
 
   useEffect(() => {
     // temporary until we have a way to create accounts and authenticate them
     const websocketConnection = new WebSocket(`ws://localhost:3030/?accountId=${accountId}`);
     setWebsocketConnection(websocketConnection);
 
-    const onMessage = (event: MessageEvent) => {
+    const onMessage = async (event: MessageEvent) => {
       console.log('message received', event.data);
       const data = JSON.parse(event.data);
       const message = decodeResponseMessage(data);
       if (message._tag === 'Right') {
         const response = message.right;
         switch (response.type) {
           case 'list-spaces': {
-            setSpaces(response.spaces.map((space) => ({ id: space.id })));
+            setSpaces((existingSpaces) => {
+              return response.spaces.map((space) => {
+                const existingSpace = existingSpaces.find((s) => s.id === space.id);
+                return { id: space.id, events: existingSpace?.events ?? [], state: existingSpace?.state };
+              });
+            });
+            // fetch all spaces (for debugging purposes)
+            for (const space of response.spaces) {
+              const message: RequestSubscribeToSpace = { type: 'subscribe-space', id: space.id };
+              websocketConnection?.send(JSON.stringify(message));
+            }
             break;
           }
           case 'space': {
-            console.log('space', response);
+            let state: SpaceState | undefined = undefined;
+
+            // TODO fix typing
+            for (const event of response.events) {
+              if (state === undefined) {
+                const applyEventResult = await Effect.runPromiseExit(applyEvent({ event }));
+                if (Exit.isSuccess(applyEventResult)) {
+                  state = applyEventResult.value;
+                }
+              } else {
+                const applyEventResult = await Effect.runPromiseExit(applyEvent({ event, state }));
+                if (Exit.isSuccess(applyEventResult)) {
+                  state = applyEventResult.value;
+                }
+              }
+            }
+
+            const newState = state as SpaceState;
+
+            setSpaces((spaces) =>
+              spaces.map((space) => {
+                if (space.id === response.id) {
+                  // TODO fix readonly type issue
+                  return { ...space, events: response.events as SpaceEvent[], state: newState };
+                }
+                return space;
+              }),
+            );
             break;
           }
           case 'event': {
@@ -86,7 +146,7 @@ const App = ({ accountId, signaturePrivateKey }: { accountId: string; signatureP
                 },
               }),
             );
-            const message: EventMessage = { type: 'event', event: spaceEvent };
+            const message: EventMessage = { type: 'event', event: spaceEvent, spaceId: spaceEvent.transaction.id };
             websocketConnection?.send(JSON.stringify(message));
           }}
         >
@@ -107,7 +167,7 @@ const App = ({ accountId, signaturePrivateKey }: { accountId: string; signatureP
         {spaces.map((space) => {
           return (
             <li key={space.id}>
-              <h3>{space.id}</h3>
+              <h3>Space id: {space.id}</h3>
               <Button
                 onClick={() => {
                   const message: RequestSubscribeToSpace = { type: 'subscribe-space', id: space.id };
@@ -116,6 +176,47 @@ const App = ({ accountId, signaturePrivateKey }: { accountId: string; signatureP
               >
                 Get data and subscribe to Space
               </Button>
+              <br />
+              {availableAccounts.map((invitee) => {
+                return (
+                  <Button
+                    key={invitee.accountId}
+                    onClick={async () => {
+                      if (!space.state) {
+                        console.error('No state found for space');
+                        return;
+                      }
+                      const spaceEvent = await Effect.runPromiseExit(
+                        createInvitation({
+                          author: {
+                            signaturePublicKey: accountId,
+                            encryptionPublicKey: 'TODO',
+                            signaturePrivateKey,
+                          },
+                          previousEventHash: space.state.lastEventHash,
+                          invitee: {
+                            signaturePublicKey: invitee.accountId,
+                            encryptionPublicKey: 'TODO',
+                          },
+                        }),
+                      );
+                      if (Exit.isFailure(spaceEvent)) {
+                        console.error('Failed to create invitation', spaceEvent);
+                        return;
+                      }
+                      const message: EventMessage = { type: 'event', event: spaceEvent.value, spaceId: space.id };
+                      websocketConnection?.send(JSON.stringify(message));
+                    }}
+                  >
+                    Invite {invitee.accountId.substring(0, 4)}
+                  </Button>
+                );
+              })}
+              <h3>State</h3>
+              <DebugSpaceState state={space.state} />
+              <h3>Events</h3>
+              <DebugSpaceEvents events={space.events} />
+              <hr />
             </li>
           );
         })}
@@ -132,33 +233,24 @@ export const ChooseAccount = () => {
       <h1>Choose account</h1>
       <Button
         onClick={() => {
-          setAccount({
-            accountId: '0262701b2eb1b6b37ad03e24445dfcad1b91309199e43017b657ce2604417c12f5',
-            signaturePrivateKey: '88bb6f20de8dc1787c722dc847f4cf3d00285b8955445f23c483d1237fe85366',
-          });
+          setAccount(availableAccounts[0]);
         }}
       >
-        `abc`
+        {availableAccounts[0].accountId.substring(0, 4)}
       </Button>
       <Button
         onClick={() => {
-          setAccount({
-            accountId: '03bf5d2a1badf15387b08a007d1a9a13a9bfd6e1c56f681e251514d9ba10b57462',
-            signaturePrivateKey: '1eee32d3bc202dcb5d17c3b1454fb541d2290cb941860735408f1bfe39e7bc15',
-          });
+          setAccount(availableAccounts[1]);
         }}
       >
-        `cde`
+        {availableAccounts[1].accountId.substring(0, 4)}
       </Button>
       <Button
         onClick={() => {
-          setAccount({
-            accountId: '0351460706cf386282d9b6ebee2ccdcb9ba61194fd024345e53037f3036242e6a2',
-            signaturePrivateKey: '434518a2c9a665a7c20da086232c818b6c1592e2edfeecab29a40cf5925ca8fe',
-          });
+          setAccount(availableAccounts[2]);
         }}
       >
-        `def`
+        {availableAccounts[2].accountId.substring(0, 4)}
       </Button>
       Account: {account?.accountId ? account.accountId : 'none'}
       <hr />
diff --git a/apps/server/src/handlers/applySpaceEvent.ts b/apps/server/src/handlers/applySpaceEvent.ts
@@ -10,11 +10,11 @@ type Params = {
 };
 
 export async function applySpaceEvent({ accountId, spaceId, event }: Params) {
-  return await prisma.$transaction(async (transaction) => {
-    if (event.transaction.type === 'create-space') {
-      throw new Error('applySpaceEvent does not support create-space events.');
-    }
+  if (event.transaction.type === 'create-space') {
+    throw new Error('applySpaceEvent does not support create-space events.');
+  }
 
+  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({
@@ -26,8 +26,9 @@ export async function applySpaceEvent({ accountId, spaceId, event }: Params) {
       orderBy: { counter: 'desc' },
     });
 
-    const result = await Effect.runPromiseExit(applyEvent({ event }));
+    const result = await Effect.runPromiseExit(applyEvent({ event, state: JSON.parse(lastEvent.state) }));
     if (Exit.isFailure(result)) {
+      console.log('Failed to apply event', result);
       throw new Error('Invalid event');
     }
 
diff --git a/apps/server/src/index.ts b/apps/server/src/index.ts
@@ -1,13 +1,14 @@
 import cors from 'cors';
 import 'dotenv/config';
-import { parse } from 'node:url';
 import { Effect, Exit, Schema } from 'effect';
 import express from 'express';
 import type { 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';
 import { createSpace } from './handlers/createSpace.js';
 import { getSpace } from './handlers/getSpace.js';
 import { listSpaces } from './handlers/listSpaces.js';
@@ -88,6 +89,14 @@ webSocketServer.on('connection', async (webSocket: WebSocket, request: Request)
               break;
             }
             case 'create-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;
             }
           }
diff --git a/packages/graph-framework-messages/src/types.ts b/packages/graph-framework-messages/src/types.ts
@@ -3,6 +3,7 @@ import { SpaceEvent } from 'graph-framework-space-events';
 
 export const EventMessage = Schema.Struct({
   type: Schema.Literal('event'),
+  spaceId: Schema.String,
   event: SpaceEvent,
 });
 
diff --git a/packages/graph-framework-space-events/src/apply-event.test.ts b/packages/graph-framework-space-events/src/apply-event.test.ts
@@ -7,13 +7,19 @@ import { createInvitation } from './create-invitation.js';
 import { createSpace } from './create-space.js';
 import { InvalidEventError, VerifySignatureError } from './types.js';
 
-it('should fail in case of an invalid signature', async () => {
-  const author = {
-    signaturePublicKey: '03594161eed61407084114a142d1ce05ef4c5a5279479fdd73a2b16944fbff003b',
-    signaturePrivateKey: '76b78f644c19d6133018a97a3bc2d5038be0af5a2858b9e640ff3e2f2db63a0b',
-    encryptionPublicKey: 'encryption',
-  };
+const author = {
+  signaturePublicKey: '03594161eed61407084114a142d1ce05ef4c5a5279479fdd73a2b16944fbff003b',
+  signaturePrivateKey: '76b78f644c19d6133018a97a3bc2d5038be0af5a2858b9e640ff3e2f2db63a0b',
+  encryptionPublicKey: 'encryption',
+};
+
+const invitee = {
+  signaturePublicKey: '03bf5d2a1badf15387b08a007d1a9a13a9bfd6e1c56f681e251514d9ba10b57462',
+  signaturePrivateKey: '1eee32d3bc202dcb5d17c3b1454fb541d2290cb941860735408f1bfe39e7bc15',
+  encryptionPublicKey: 'encryption',
+};
 
+it('should fail in case of an invalid signature', async () => {
   const result = await Effect.runPromiseExit(
     Effect.gen(function* () {
       const spaceEvent = yield* createSpace({ author });
@@ -37,18 +43,12 @@ it('should fail in case of an invalid signature', async () => {
 });
 
 it('should fail in case state is not provided for an event other than createSpace', async () => {
-  const author = {
-    signaturePublicKey: '03594161eed61407084114a142d1ce05ef4c5a5279479fdd73a2b16944fbff003b',
-    signaturePrivateKey: '76b78f644c19d6133018a97a3bc2d5038be0af5a2858b9e640ff3e2f2db63a0b',
-    encryptionPublicKey: 'encryption',
-  };
-
   const result = await Effect.runPromiseExit(
     Effect.gen(function* () {
       const spaceEvent = yield* createSpace({ author });
       const state = yield* applyEvent({ event: spaceEvent });
 
-      const spaceEvent2 = yield* createInvitation({ author, id: state.id, previousEventHash: state.lastEventHash });
+      const spaceEvent2 = yield* createInvitation({ author, previousEventHash: state.lastEventHash, invitee });
       return yield* applyEvent({ event: spaceEvent2 });
     }),
   );
@@ -63,12 +63,6 @@ it('should fail in case state is not provided for an event other than createSpac
 });
 
 it('should fail in case of an event is applied that is not based on the previous event', async () => {
-  const author = {
-    signaturePublicKey: '03594161eed61407084114a142d1ce05ef4c5a5279479fdd73a2b16944fbff003b',
-    signaturePrivateKey: '76b78f644c19d6133018a97a3bc2d5038be0af5a2858b9e640ff3e2f2db63a0b',
-    encryptionPublicKey: 'encryption',
-  };
-
   const result = await Effect.runPromiseExit(
     Effect.gen(function* () {
       const spaceEvent = yield* createSpace({ author });
@@ -77,7 +71,7 @@ it('should fail in case of an event is applied that is not based on the previous
       const spaceEvent2 = yield* createSpace({ author });
       const state2 = yield* applyEvent({ state, event: spaceEvent2 });
 
-      const spaceEvent3 = yield* createInvitation({ author, id: state.id, previousEventHash: state.lastEventHash });
+      const spaceEvent3 = yield* createInvitation({ author, previousEventHash: state.lastEventHash, invitee });
       return yield* applyEvent({ state: state2, event: spaceEvent3 });
     }),
   );
diff --git a/packages/graph-framework-space-events/src/apply-event.ts b/packages/graph-framework-space-events/src/apply-event.ts
@@ -70,6 +70,15 @@ export const applyEvent = ({
       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,
diff --git a/packages/graph-framework-space-events/src/create-invitation.test.ts b/packages/graph-framework-space-events/src/create-invitation.test.ts
diff --git a/packages/graph-framework-space-events/src/create-invitation.ts b/packages/graph-framework-space-events/src/create-invitation.ts
