list invitations

Author: nikgraf

apps/events/src/routes/playground.tsx

@@ -5,7 +5,14 @@ import { assertExhaustive } from '@/lib/assertExhaustive';
 import { createFileRoute } from '@tanstack/react-router';
 import { Effect, Exit } from 'effect';
 import * as Schema from 'effect/Schema';
-import type { EventMessage, RequestListSpaces, RequestSubscribeToSpace, SpaceEvent, SpaceState } from 'graph-framework';
+import type {
+  EventMessage,
+  RequestListInvitations,
+  RequestListSpaces,
+  RequestSubscribeToSpace,
+  SpaceEvent,
+  SpaceState,
+} from 'graph-framework';
 import { ResponseMessage, applyEvent, createInvitation, createSpace } from 'graph-framework';
 import { useEffect, useState } from 'react';
 
@@ -101,6 +108,10 @@ const App = ({ accountId, signaturePrivateKey }: { accountId: string; signatureP
             console.log('event', response);
             break;
           }
+          case 'list-invitations': {
+            console.log('list-invitations', response);
+            break;
+          }
           default:
             assertExhaustive(response);
         }
@@ -161,6 +172,15 @@ const App = ({ accountId, signaturePrivateKey }: { accountId: string; signatureP
         >
           List Spaces
         </Button>
+
+        <Button
+          onClick={() => {
+            const message: RequestListInvitations = { type: 'list-invitations' };
+            websocketConnection?.send(JSON.stringify(message));
+          }}
+        >
+          List Invitations
+        </Button>
       </div>
       <h2>Spaces</h2>
       <ul>

apps/server/prisma/migrations/20241114170708_add_invitation/migration.sql

@@ -0,0 +1,9 @@
+-- CreateTable
+CREATE TABLE "Invitation" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "spaceId" TEXT NOT NULL,
+    "accountId" 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
+);

apps/server/prisma/schema.prisma

@@ -23,12 +23,23 @@ model SpaceEvent {
 }
 
 model Space {
-  id      String       @id
-  events  SpaceEvent[]
-  members Account[]
+  id          String       @id
+  events      SpaceEvent[]
+  members     Account[]
+  invitations Invitation[]
 }
 
 model Account {
-  id     String  @id
-  spaces Space[]
+  id          String       @id
+  spaces      Space[]
+  invitations Invitation[]
+}
+
+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())
 }

apps/server/src/handlers/applySpaceEvent.ts

@@ -32,6 +32,16 @@ export async function applySpaceEvent({ accountId, spaceId, event }: Params) {
       throw new Error('Invalid event');
     }
 
+    if (event.transaction.type === 'create-invitation') {
+      await transaction.invitation.create({
+        data: {
+          id: event.transaction.id,
+          spaceId,
+          accountId: event.transaction.signaturePublicKey,
+        },
+      });
+    }
+
     return await transaction.spaceEvent.create({
       data: {
         spaceId,

apps/server/src/handlers/listInvitations.ts

@@ -0,0 +1,35 @@
+import type { SpaceState } from 'graph-framework-space-events';
+import { prisma } from '../prisma.js';
+
+type Params = {
+  accountId: string;
+};
+
+export const listInvitations = async ({ accountId }: Params) => {
+  const result = await prisma.invitation.findMany({
+    where: {
+      accountId,
+    },
+    include: {
+      space: {
+        include: {
+          events: {
+            orderBy: {
+              counter: 'asc',
+            },
+            take: 1,
+          },
+        },
+      },
+    },
+  });
+
+  return result.map((invitation) => {
+    const state = JSON.parse(invitation.space.events[0].state) as SpaceState;
+    return {
+      id: invitation.id,
+      previousEventHash: state.lastEventHash,
+      spaceId: invitation.spaceId,
+    };
+  });
+};

apps/server/src/index.ts

@@ -1,16 +1,17 @@
 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 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';
 import { createSpace } from './handlers/createSpace.js';
 import { getSpace } from './handlers/getSpace.js';
+import { listInvitations } from './handlers/listInvitations.js';
 import { listSpaces } from './handlers/listSpaces.js';
 import { tmpInitAccount } from './handlers/tmpInitAccount.js';
 import { assertExhaustive } from './utils/assertExhaustive.js';
@@ -68,6 +69,12 @@ webSocketServer.on('connection', async (webSocket: WebSocket, request: Request)
           webSocket.send(JSON.stringify(outgoingMessage));
           break;
         }
+        case 'list-invitations': {
+          const invitations = await listInvitations({ accountId });
+          const outgoingMessage: ResponseListInvitations = { type: 'list-invitations', invitations: invitations };
+          webSocket.send(JSON.stringify(outgoingMessage));
+          break;
+        }
         case 'event': {
           switch (data.event.transaction.type) {
             case 'create-space': {

packages/graph-framework-messages/src/types.ts

@@ -22,7 +22,18 @@ export const RequestListSpaces = Schema.Struct({
 
 export type RequestListSpaces = Schema.Schema.Type<typeof RequestListSpaces>;
 
-export const RequestMessage = Schema.Union(EventMessage, RequestSubscribeToSpace, RequestListSpaces);
+export const RequestListInvitations = Schema.Struct({
+  type: Schema.Literal('list-invitations'),
+});
+
+export type RequestListInvitations = Schema.Schema.Type<typeof RequestListInvitations>;
+
+export const RequestMessage = Schema.Union(
+  EventMessage,
+  RequestSubscribeToSpace,
+  RequestListSpaces,
+  RequestListInvitations,
+);
 
 export type RequestMessage = Schema.Schema.Type<typeof RequestMessage>;
 
@@ -37,6 +48,19 @@ export const ResponseListSpaces = Schema.Struct({
 
 export type ResponseListSpaces = Schema.Schema.Type<typeof ResponseListSpaces>;
 
+export const ResponseListInvitations = Schema.Struct({
+  type: Schema.Literal('list-invitations'),
+  invitations: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      previousEventHash: Schema.String,
+      spaceId: Schema.String,
+    }),
+  ),
+});
+
+export type ResponseListInvitations = Schema.Schema.Type<typeof ResponseListInvitations>;
+
 export const ResponseSpace = Schema.Struct({
   type: Schema.Literal('space'),
   id: Schema.String,
@@ -45,6 +69,6 @@ export const ResponseSpace = Schema.Struct({
 
 export type ResponseSpace = Schema.Schema.Type<typeof ResponseSpace>;
 
-export const ResponseMessage = Schema.Union(EventMessage, ResponseListSpaces, ResponseSpace);
+export const ResponseMessage = Schema.Union(EventMessage, ResponseListSpaces, ResponseListInvitations, ResponseSpace);
 
 export type ResponseMessage = Schema.Schema.Type<typeof ResponseMessage>;