@decentrl/sdk 0.0.1

package/src/sdk.e2e.test.ts

@@ -0,0 +1,367 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { defineDecentrlApp } from './define-app.js';
+import { DirectTransport } from './direct-transport.js';
+
+const MEDIATOR_DID = 'did:web:localhost';
+
+// -- Define a chat app using the SDK --
+
+const chatApp = defineDecentrlApp({
+	events: {
+		'chat.create': {
+			schema: z.object({
+				id: z.string(),
+				name: z.string(),
+				participants: z.array(z.string()),
+				createdBy: z.string(),
+			}),
+			tags: ['chat', 'chat:${id}'],
+		},
+		'chat.message': {
+			schema: z.object({
+				chatId: z.string(),
+				messageId: z.string(),
+				text: z.string(),
+				sentBy: z.string(),
+			}),
+			tags: ['chat:${chatId}', 'message'],
+		},
+	},
+	state: {
+		chats: {
+			initial: [] as Array<{
+				id: string;
+				name: string;
+				participants: string[];
+			}>,
+			reduce: {
+				'chat.create': (chats, event) => [
+					...chats,
+					{
+						id: event.id,
+						name: event.name,
+						participants: event.participants,
+					},
+				],
+			},
+		},
+		messages: {
+			initial: {} as Record<string, Array<{ id: string; text: string; sentBy: string }>>,
+			reduce: {
+				'chat.message': (msgs, event) => ({
+					...msgs,
+					[event.chatId]: [
+						...(msgs[event.chatId] || []),
+						{ id: event.messageId, text: event.text, sentBy: event.sentBy },
+					],
+				}),
+			},
+		},
+	},
+});
+
+type ChatClient = ReturnType<typeof chatApp.createClient>;
+
+describe('SDK E2E', () => {
+	// ------- defineDecentrlApp + createClient -------
+
+	describe('defineDecentrlApp', () => {
+		it('should create a client with initial state', () => {
+			const client = chatApp.createClient({ mediatorDid: MEDIATOR_DID });
+
+			const state = client.getState();
+			expect(state.chats).toEqual([]);
+			expect(state.messages).toEqual({});
+		});
+	});
+
+	// ------- Identity creation -------
+
+	describe('Identity', () => {
+		let client: ChatClient;
+
+		beforeAll(() => {
+			client = chatApp.createClient({ mediatorDid: MEDIATOR_DID });
+		});
+
+		afterAll(() => {
+			client.reset();
+		});
+
+		it('should create an identity and register with mediator', async () => {
+			const identity = await client.identity.create({
+				alias: 'identity-test-user',
+				mediatorDid: MEDIATOR_DID,
+			});
+
+			expect(identity.did).toContain('did:decentrl:');
+			expect(identity.alias).toBe('identity-test-user');
+			expect(identity.mediatorDid).toBe(MEDIATOR_DID);
+			expect(identity.mediatorEndpoint).toBe('http://localhost:8080');
+			expect(identity.keys.signing.privateKey).toBeInstanceOf(Uint8Array);
+			expect(identity.keys.encryption.privateKey).toBeInstanceOf(Uint8Array);
+			expect(identity.mediatorContract).toBeDefined();
+		});
+
+		it('should throw when creating identity twice', async () => {
+			await expect(
+				client.identity.create({ alias: 'duplicate', mediatorDid: MEDIATOR_DID }),
+			).rejects.toThrow('Identity already exists');
+		});
+
+		it('should serialize and load identity', () => {
+			const serialized = client.identity.serialize();
+			expect(serialized.did).toBe(client.identity.getIdentity()!.did);
+			expect(typeof serialized.keys.signing.privateKey).toBe('string');
+
+			const client2 = chatApp.createClient({ mediatorDid: MEDIATOR_DID });
+			const loaded = client2.identity.load(serialized);
+			expect(loaded.did).toBe(serialized.did);
+			expect(loaded.keys.signing.privateKey).toBeInstanceOf(Uint8Array);
+			client2.reset();
+		});
+
+		it('should throw IDENTITY_NOT_INITIALIZED when requireIdentity called without identity', () => {
+			const emptyClient = chatApp.createClient({ mediatorDid: MEDIATOR_DID });
+			expect(() => emptyClient.identity.requireIdentity()).toThrow('Identity not initialized');
+		});
+	});
+
+	// ------- Full workflow: Alice <-> Bob -------
+
+	describe('Full workflow: contracts, publish, state, sync', () => {
+		let alice: ChatClient;
+		let bob: ChatClient;
+
+		beforeAll(async () => {
+			alice = chatApp.createClient({
+				mediatorDid: MEDIATOR_DID,
+				transport: new DirectTransport(),
+			});
+			bob = chatApp.createClient({
+				mediatorDid: MEDIATOR_DID,
+				transport: new DirectTransport(),
+			});
+
+			await alice.identity.create({ alias: 'alice-e2e', mediatorDid: MEDIATOR_DID });
+			await bob.identity.create({ alias: 'bob-e2e', mediatorDid: MEDIATOR_DID });
+		});
+
+		afterAll(() => {
+			alice.stopSync();
+			bob.stopSync();
+		});
+
+		// -- Contract request/accept flow --
+
+		it('Alice should request a contract with Bob', async () => {
+			await alice.contracts.request(bob.identity.getIdentity()!.did);
+		});
+
+		it("Bob should see Alice's pending contract request", async () => {
+			const pending = await bob.contracts.getPending();
+			expect(pending.length).toBe(1);
+			expect(pending[0].senderDid).toBe(alice.identity.getIdentity()!.did);
+		});
+
+		it("Bob should accept Alice's contract request", async () => {
+			const pending = await bob.contracts.getPending();
+			await bob.contracts.accept(
+				pending[0].id,
+				pending[0].encryptedPayload,
+				pending[0].requestorEphemeralPublicKey,
+			);
+		});
+
+		it('Both should see active contracts after refresh', async () => {
+			await alice.contracts.refresh();
+			await bob.contracts.refresh();
+
+			const aliceContracts = alice.contracts.getActiveContracts();
+			const bobContracts = bob.contracts.getActiveContracts();
+
+			expect(aliceContracts.length).toBeGreaterThanOrEqual(1);
+			expect(bobContracts.length).toBeGreaterThanOrEqual(1);
+
+			const aliceContractWithBob = aliceContracts.find(
+				(c) => c.participantDid === bob.identity.getIdentity()!.did,
+			);
+			expect(aliceContractWithBob).toBeDefined();
+			expect(aliceContractWithBob!.status).toBe('active');
+		});
+
+		// -- Publish + local state --
+
+		it('Alice should publish a chat.create event and state updates locally', async () => {
+			const bobDid = bob.identity.getIdentity()!.did;
+
+			await alice.publish(
+				'chat.create',
+				{
+					id: 'chat-1',
+					name: 'Alice & Bob',
+					participants: [alice.identity.getIdentity()!.did, bobDid],
+					createdBy: alice.identity.getIdentity()!.did,
+				},
+				{ recipient: bobDid },
+			);
+
+			const state = alice.getState();
+			expect(state.chats).toHaveLength(1);
+			expect(state.chats[0].name).toBe('Alice & Bob');
+			expect(state.messages).toEqual({});
+		});
+
+		it('Alice should publish a chat.message event and state updates locally', async () => {
+			const bobDid = bob.identity.getIdentity()!.did;
+
+			await alice.publish(
+				'chat.message',
+				{
+					chatId: 'chat-1',
+					messageId: 'msg-1',
+					text: 'Hello Bob!',
+					sentBy: alice.identity.getIdentity()!.did,
+				},
+				{ recipient: bobDid },
+			);
+
+			const state = alice.getState();
+			expect(state.chats).toHaveLength(1);
+			expect(state.messages['chat-1']).toHaveLength(1);
+			expect(state.messages['chat-1'][0].text).toBe('Hello Bob!');
+		});
+
+		// -- Schema validation --
+
+		it('should reject invalid event data', async () => {
+			await expect(
+				alice.publish('chat.create', {
+					id: 'bad',
+					// missing required fields
+				} as any),
+			).rejects.toThrow('Schema validation failed');
+		});
+
+		it('should reject unknown event type', async () => {
+			await expect(alice.publish('unknown.event' as any, {} as any)).rejects.toThrow(
+				'Unknown event type',
+			);
+		});
+
+		// -- Sync: Bob receives Alice's events --
+
+		it("Bob should receive Alice's events via sync", async () => {
+			await bob.sync();
+
+			const state = bob.getState();
+			expect(state.chats.length).toBeGreaterThanOrEqual(1);
+
+			const chat = state.chats.find((c) => c.id === 'chat-1');
+			expect(chat).toBeDefined();
+			expect(chat!.name).toBe('Alice & Bob');
+
+			const chatMsgs = state.messages['chat-1'];
+			expect(chatMsgs).toBeDefined();
+			expect(chatMsgs.length).toBeGreaterThanOrEqual(1);
+			expect(chatMsgs[0].text).toBe('Hello Bob!');
+		});
+
+		// -- Tag-based queries --
+
+		it('Alice should query her own events by tag', async () => {
+			const result = await alice.query({ tags: ['chat'] });
+			expect(result.data.length).toBeGreaterThanOrEqual(1);
+
+			const createEvent = result.data.find((e) => e.type === 'chat.create');
+			expect(createEvent).toBeDefined();
+			expect(createEvent!.data).toMatchObject({ id: 'chat-1', name: 'Alice & Bob' });
+		});
+
+		it('Alice should query by specific chat tag', async () => {
+			const result = await alice.query({ tags: ['chat:chat-1'] });
+			expect(result.data.length).toBeGreaterThanOrEqual(2); // chat.create + chat.message
+
+			const types = result.data.map((e) => e.type);
+			expect(types).toContain('chat.create');
+			expect(types).toContain('chat.message');
+		});
+
+		it('Alice should query messages by message tag', async () => {
+			const result = await alice.query({ tags: ['message'] });
+			expect(result.data.length).toBeGreaterThanOrEqual(1);
+			expect(result.data.every((e) => e.type === 'chat.message')).toBe(true);
+		});
+
+		it('Bob should query received events by tag after sync', async () => {
+			const result = await bob.query({ tags: ['chat:chat-1'] });
+			expect(result.data.length).toBeGreaterThanOrEqual(1);
+
+			const createEvent = result.data.find((e) => e.type === 'chat.create');
+			expect(createEvent).toBeDefined();
+		});
+
+		// -- Dedup --
+
+		it('sync should dedup already-processed events', async () => {
+			const stateBefore = bob.getState();
+			const chatCountBefore = stateBefore.chats.length;
+			const msgCountBefore = (stateBefore.messages['chat-1'] || []).length;
+
+			await bob.sync();
+
+			const stateAfter = bob.getState();
+			expect(stateAfter.chats.length).toBe(chatCountBefore);
+			expect((stateAfter.messages['chat-1'] || []).length).toBe(msgCountBefore);
+		});
+
+		// -- Subscribe --
+
+		it('subscribe should fire on state changes', async () => {
+			const states: Array<ReturnType<typeof alice.getState>> = [];
+			const unsub = alice.subscribe((s) => states.push(s));
+
+			await alice.publish(
+				'chat.message',
+				{
+					chatId: 'chat-1',
+					messageId: 'msg-2',
+					text: 'Another message',
+					sentBy: alice.identity.getIdentity()!.did,
+				},
+				{ recipient: bob.identity.getIdentity()!.did },
+			);
+
+			unsub();
+
+			expect(states.length).toBeGreaterThanOrEqual(1);
+			const last = states[states.length - 1];
+			expect(last.messages['chat-1'].some((m) => m.text === 'Another message')).toBe(true);
+		});
+
+		// -- Reset --
+
+		it('reset should clear all state', () => {
+			const client = chatApp.createClient({ mediatorDid: MEDIATOR_DID });
+			client.identity.load(alice.identity.serialize());
+
+			client
+				.publish('chat.create', {
+					id: 'temp',
+					name: 'temp',
+					participants: [],
+					createdBy: 'test',
+				})
+				.catch(() => {
+					// May fail without proper contracts — fine for this test
+				});
+
+			client.reset();
+
+			expect(client.getState().chats).toEqual([]);
+			expect(client.getState().messages).toEqual({});
+			expect(client.identity.getIdentity()).toBeNull();
+		});
+	});
+});

package/src/state-store.ts

@@ -0,0 +1,42 @@
+import type { StateListener } from './types.js';
+
+export class StateStore<TState extends Record<string, unknown>> {
+	private state: TState;
+	private listeners = new Set<StateListener<TState>>();
+
+	constructor(initialState: TState) {
+		this.state = { ...initialState };
+	}
+
+	getState = (): TState => {
+		return this.state;
+	};
+
+	setSlice<K extends keyof TState>(key: K, value: TState[K]): void {
+		if (this.state[key] === value) {
+			return;
+		}
+
+		this.state = { ...this.state, [key]: value };
+		this.notify();
+	}
+
+	subscribe = (listener: StateListener<TState>): (() => void) => {
+		this.listeners.add(listener);
+
+		return () => {
+			this.listeners.delete(listener);
+		};
+	};
+
+	reset(initialState: TState): void {
+		this.state = { ...initialState };
+		this.notify();
+	}
+
+	private notify(): void {
+		for (const listener of this.listeners) {
+			listener(this.state);
+		}
+	}
+}