@decentrl/sdk 0.0.7 → 0.0.8

package/src/define-app.ts

@@ -1,23 +1,37 @@
 import { DecentrlClient } from './client.js';
 import type {
+	ChannelDefinitions,
 	DecentrlAppConfig,
 	DecentrlClientConfig,
 	EventDefinitions,
+	PublicEventDefinitions,
 	StateDefinitions,
 } from './types.js';
 
 export interface DecentrlApp<
 	TEvents extends EventDefinitions,
-	TState extends StateDefinitions<TEvents>,
+	TPublicEvents extends PublicEventDefinitions,
+	TChannels extends ChannelDefinitions,
+	TState extends StateDefinitions<TEvents, TPublicEvents, TChannels>,
 > {
-	config: DecentrlAppConfig<TEvents, TState>;
-	createClient(clientConfig: DecentrlClientConfig): DecentrlClient<TEvents, TState>;
+	config: DecentrlAppConfig<TEvents, TPublicEvents, TChannels, TState>;
+	createClient(
+		clientConfig: DecentrlClientConfig,
+	): DecentrlClient<TEvents, TPublicEvents, TChannels, TState>;
 }
 
 export function defineDecentrlApp<
 	TEvents extends EventDefinitions,
-	TState extends StateDefinitions<TEvents>,
->(config: DecentrlAppConfig<TEvents, TState>): DecentrlApp<TEvents, TState> {
+	TPublicEvents extends PublicEventDefinitions = PublicEventDefinitions,
+	TChannels extends ChannelDefinitions = ChannelDefinitions,
+	TState extends StateDefinitions<TEvents, TPublicEvents, TChannels> = StateDefinitions<
+		TEvents,
+		TPublicEvents,
+		TChannels
+	>,
+>(
+	config: DecentrlAppConfig<TEvents, TPublicEvents, TChannels, TState>,
+): DecentrlApp<TEvents, TPublicEvents, TChannels, TState> {
 	return {
 		config,
 		createClient: (clientConfig: DecentrlClientConfig) => new DecentrlClient(config, clientConfig),

package/src/direct-transport-public.test.ts

@@ -0,0 +1,139 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DirectTransport } from './direct-transport.js';
+
+vi.mock('@decentrl/event-store', () => {
+	const mockPublishPublicEvent = vi.fn(async () => ({ publicEventId: 'pub-123' }));
+	const mockDeletePublicEvent = vi.fn(async () => {});
+	const mockFetchPublicEvents = vi.fn(async () => ({
+		data: [
+			{
+				id: 'evt-1',
+				channelId: 'blog',
+				event: '{"type":"blog.post","data":{"title":"Hello"}}',
+				tags: ['blog'],
+				timestamp: 1710000000,
+				eventSignature: 'sig-1',
+			},
+		],
+		pagination: { page: 0, pageSize: 20, total: 1 },
+	}));
+
+	return {
+		DecentrlEventStore: class {
+			publishPublicEvent = mockPublishPublicEvent;
+			deletePublicEvent = mockDeletePublicEvent;
+			static fetchPublicEvents = mockFetchPublicEvents;
+		},
+		__mockPublishPublicEvent: mockPublishPublicEvent,
+		__mockDeletePublicEvent: mockDeletePublicEvent,
+		__mockFetchPublicEvents: mockFetchPublicEvents,
+	};
+});
+
+vi.mock(
+	'@decentrl/identity/communication-channels/mediator/direct-authenticated/command/command.service',
+	() => ({
+		generateDirectAuthenticatedMediatorCommand: vi.fn(() => ({ mock: 'command' })),
+		generateTwoWayPrivateMediatorCommand: vi.fn(() => ({ mock: 'two-way-command' })),
+	}),
+);
+
+vi.mock('@decentrl/identity/communication-contract/communication-contract.service', () => ({
+	createCommunicationContractRequest: vi.fn(),
+	decryptContractRequest: vi.fn(),
+	signCommunicationContract: vi.fn(),
+	generateContractId: vi.fn(),
+}));
+
+vi.mock('@decentrl/identity/did-decentrl/did-decentrl.service', () => ({
+	createDecentrlDidFromKeys: vi.fn(),
+}));
+
+vi.mock('@decentrl/identity/mediator/mediator.resolver', () => ({
+	resolveMediatorServiceEndpoint: vi.fn(),
+}));
+
+vi.mock('@decentrl/identity/did-resolver/resolver', () => ({
+	resolveDid: vi.fn(),
+}));
+
+vi.mock('@decentrl/crypto', () => ({
+	base64Decode: vi.fn((s: string) => new TextEncoder().encode(s)),
+	base64Encode: vi.fn((u: Uint8Array) => new TextDecoder().decode(u)),
+	decryptString: vi.fn(),
+	encryptString: vi.fn((plaintext: string) => `encrypted:${plaintext}`),
+	generateEncryptedTag: vi.fn((_key: unknown, tag: string) => `etag:${tag}`),
+	signJsonObject: vi.fn(() => 'mock-signature'),
+	verifyJsonSignature: vi.fn(() => true),
+	multibaseDecode: vi.fn(() => new Uint8Array(32)),
+	generateIdentityKeys: vi.fn(),
+	deriveSharedSecret: vi.fn(),
+}));
+
+describe('DirectTransport — public events', () => {
+	let transport: DirectTransport;
+
+	beforeEach(() => {
+		transport = new DirectTransport({
+			httpPost: vi.fn(async () => ({ data: { type: 'SUCCESS' } })) as any,
+		});
+
+		// Inject identity so the event store can be created
+		(transport as any).identity = {
+			did: 'did:decentrl:alice',
+			alias: 'alice',
+			mediatorDid: 'did:web:mediator',
+			mediatorEndpoint: 'http://mediator:8080',
+			keys: {
+				signing: { privateKey: new Uint8Array(32), publicKey: new Uint8Array(32) },
+				encryption: { privateKey: new Uint8Array(32), publicKey: new Uint8Array(32) },
+				storageKey: new Uint8Array(32),
+			},
+			mediatorContract: null,
+		};
+	});
+
+	describe('publishPublicEvent', () => {
+		it('delegates to event store and returns publicEventId', async () => {
+			const result = await transport.publishPublicEvent({
+				channelId: 'blog',
+				event: '{"type":"blog.post","data":{"title":"Hello"}}',
+				tags: ['blog'],
+			});
+
+			expect(result.publicEventId).toBe('pub-123');
+		});
+	});
+
+	describe('deletePublicEvent', () => {
+		it('delegates to event store', async () => {
+			await expect(transport.deletePublicEvent('pub-123')).resolves.toBeUndefined();
+		});
+	});
+
+	describe('fetchPublicEvents', () => {
+		it('fetches events via static method (no identity needed)', async () => {
+			const result = await transport.fetchPublicEvents({
+				mediatorEndpoint: 'http://mediator:8080',
+				publisherDid: 'did:decentrl:bob',
+				channelId: 'blog',
+			});
+
+			expect(result.events).toHaveLength(1);
+			expect(result.events[0].id).toBe('evt-1');
+			expect(result.events[0].channelId).toBe('blog');
+			expect(result.pagination.total).toBe(1);
+		});
+
+		it('returns events and pagination from result', async () => {
+			const result = await transport.fetchPublicEvents({
+				mediatorEndpoint: 'http://mediator:8080',
+				publisherDid: 'did:decentrl:bob',
+			});
+
+			expect(result.events).toHaveLength(1);
+			expect(result.events[0].channelId).toBe('blog');
+			expect(result.pagination).toEqual({ page: 0, pageSize: 20, total: 1 });
+		});
+	});
+});

package/src/direct-transport.ts

@@ -685,6 +685,61 @@ export class DirectTransport implements DecentrlTransport {
 			.map((e) => e.data);
 	}
 
+	async publishPublicEvent(options: {
+		channelId: string;
+		event: string;
+		tags: string[];
+	}): Promise<{ publicEventId: string }> {
+		const eventStore = this.requireEventStore();
+
+		return eventStore.publishPublicEvent(options.event, {
+			channelId: options.channelId,
+			tags: options.tags,
+		});
+	}
+
+	async deletePublicEvent(publicEventId: string): Promise<void> {
+		const eventStore = this.requireEventStore();
+		await eventStore.deletePublicEvent(publicEventId);
+	}
+
+	async fetchPublicEvents(options: {
+		mediatorEndpoint: string;
+		publisherDid: string;
+		channelId?: string;
+		tags?: string[];
+		afterTimestamp?: number;
+		beforeTimestamp?: number;
+		page?: number;
+		pageSize?: number;
+	}): Promise<{
+		events: Array<{
+			id: string;
+			channelId: string;
+			event: string;
+			tags: string[];
+			timestamp: number;
+			eventSignature: string;
+		}>;
+		pagination: { page: number; pageSize: number; total: number };
+	}> {
+		const result = await DecentrlEventStore.fetchPublicEvents({
+			mediatorEndpoint: options.mediatorEndpoint,
+			publisherDid: options.publisherDid,
+			channelId: options.channelId,
+			tags: options.tags,
+			afterTimestamp: options.afterTimestamp,
+			beforeTimestamp: options.beforeTimestamp,
+			pagination:
+				options.page != null ? { page: options.page, pageSize: options.pageSize ?? 20 } : undefined,
+		});
+
+		return {
+			events: result.data,
+			pagination: result.pagination,
+		};
+	}
+
 	dispose(): void {
 		this.eventStore = null;
 	}

package/src/event-processor-public.test.ts

@@ -0,0 +1,343 @@
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { EventProcessor } from './event-processor.js';
+import { StateStore } from './state-store.js';
+import type { EventDefinitions, StateDefinitions } from './types.js';
+
+// Helper to create processor without strict generics in tests
+function createProcessor(
+	stateDefinitions: Record<string, { initial: unknown; reduce: Record<string, unknown> }>,
+	publicEventDefinitions?: Record<string, { schema: z.ZodType; tags: string[]; channelId: string }>,
+	channelDefinitions?: Record<string, { schema: z.ZodType }>,
+) {
+	const store = new StateStore(
+		Object.fromEntries(Object.entries(stateDefinitions).map(([k, v]) => [k, v.initial])),
+	);
+	const processor = new EventProcessor(
+		eventDefinitions as EventDefinitions,
+		stateDefinitions as StateDefinitions,
+		store as StateStore<Record<string, unknown>>,
+		publicEventDefinitions,
+		channelDefinitions,
+	);
+
+	return { processor, store };
+}
+
+const eventDefinitions = {
+	'chat.message': {
+		schema: z.object({ text: z.string() }),
+		tags: ['chat'],
+	},
+};
+
+const publicEventDefinitions = {
+	'blog.post': {
+		schema: z.object({ title: z.string(), body: z.string() }),
+		tags: ['blog', 'post:${title}'],
+		channelId: 'blog',
+	},
+};
+
+const channelDefinitions = {
+	'feed.item': {
+		schema: z.object({ content: z.string() }),
+	},
+};
+
+describe('EventProcessor — public events', () => {
+	describe('validatePublicEvent', () => {
+		it('validates known public event types', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+			);
+
+			expect(() =>
+				processor.validatePublicEvent('blog.post', { title: 'Hi', body: 'World' }),
+			).not.toThrow();
+		});
+
+		it('throws for unknown public event type', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+			);
+
+			expect(() => processor.validatePublicEvent('blog.unknown', { foo: 'bar' })).toThrow(
+				'Unknown public event type',
+			);
+		});
+
+		it('throws for invalid data', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+			);
+
+			expect(() => processor.validatePublicEvent('blog.post', { title: 123 })).toThrow(
+				'Schema validation failed',
+			);
+		});
+	});
+
+	describe('computePublicTags', () => {
+		it('evaluates tag templates for public events', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+			);
+
+			const tags = processor.computePublicTags('blog.post', {
+				title: 'Hello',
+				body: 'Content',
+			});
+			expect(tags).toEqual(['blog', 'post:Hello']);
+		});
+
+		it('throws for unknown public event type', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+			);
+
+			expect(() => processor.computePublicTags('unknown', {})).toThrow('Unknown public event type');
+		});
+	});
+
+	describe('getPublicChannelId', () => {
+		it('returns the channelId for a public event type', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+			);
+
+			expect(processor.getPublicChannelId('blog.post')).toBe('blog');
+		});
+	});
+
+	describe('processPublicEvent', () => {
+		it('dispatches to public: prefixed reducers', () => {
+			const { processor, store } = createProcessor(
+				{
+					posts: {
+						initial: [] as Array<{ title: string }>,
+						reduce: {
+							'public:blog.post': (state: unknown[], data: unknown) => [
+								...state,
+								{ title: (data as { title: string }).title },
+							],
+						},
+					},
+				},
+				publicEventDefinitions,
+			);
+
+			const processed = processor.processPublicEvent({
+				type: 'blog.post',
+				data: { title: 'Test', body: 'Content' },
+				meta: {
+					publisherDid: 'did:decentrl:alice',
+					timestamp: 1234567890,
+					eventId: 'evt-1',
+					channelId: 'blog',
+				},
+			});
+
+			expect(processed).toBe(true);
+			expect(store.getState().posts).toEqual([{ title: 'Test' }]);
+		});
+
+		it('deduplicates by eventId', () => {
+			const { processor, store } = createProcessor(
+				{
+					count: {
+						initial: 0,
+						reduce: {
+							'public:blog.post': (state: number) => state + 1,
+						},
+					},
+				},
+				publicEventDefinitions,
+			);
+
+			const envelope = {
+				type: 'blog.post',
+				data: { title: 'Test', body: 'Content' },
+				meta: {
+					publisherDid: 'did:decentrl:alice',
+					timestamp: 1234567890,
+					eventId: 'same-id',
+					channelId: 'blog',
+				},
+			};
+
+			processor.processPublicEvent(envelope);
+			processor.processPublicEvent(envelope);
+
+			expect(store.getState().count).toBe(1);
+		});
+
+		it('notifies public event listeners', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+			);
+
+			const received: unknown[] = [];
+			processor.onPublicEvent((envelope) => received.push(envelope));
+
+			processor.processPublicEvent({
+				type: 'blog.post',
+				data: { title: 'Test', body: 'Content' },
+				meta: {
+					publisherDid: 'did:decentrl:alice',
+					timestamp: 1234567890,
+					eventId: 'evt-1',
+					channelId: 'blog',
+				},
+			});
+
+			expect(received).toHaveLength(1);
+			expect((received[0] as { type: string }).type).toBe('blog.post');
+		});
+	});
+
+	describe('processChannelEvent', () => {
+		it('dispatches to channel: prefixed reducers', () => {
+			const { processor, store } = createProcessor(
+				{
+					feed: {
+						initial: [] as Array<{ content: string; from: string }>,
+						reduce: {
+							'channel:feed.item': (state: unknown[], data: unknown, meta: unknown) => [
+								...state,
+								{
+									content: (data as { content: string }).content,
+									from: (meta as { publisherDid: string }).publisherDid,
+								},
+							],
+						},
+					},
+				},
+				publicEventDefinitions,
+				channelDefinitions,
+			);
+
+			const processed = processor.processChannelEvent({
+				type: 'feed.item',
+				data: { content: 'Hello from external' },
+				meta: {
+					publisherDid: 'did:decentrl:bob',
+					timestamp: 1234567890,
+					eventId: 'ch-1',
+					channelId: 'feed',
+				},
+			});
+
+			expect(processed).toBe(true);
+			expect(store.getState().feed).toEqual([
+				{ content: 'Hello from external', from: 'did:decentrl:bob' },
+			]);
+		});
+
+		it('deduplicates channel events separately from public events', () => {
+			const { processor, store } = createProcessor(
+				{
+					count: {
+						initial: 0,
+						reduce: {
+							'channel:feed.item': (state: number) => state + 1,
+							'public:blog.post': (state: number) => state + 1,
+						},
+					},
+				},
+				publicEventDefinitions,
+				channelDefinitions,
+			);
+
+			processor.processPublicEvent({
+				type: 'blog.post',
+				data: { title: 'Test', body: 'Content' },
+				meta: { publisherDid: 'a', timestamp: 0, eventId: 'same', channelId: 'blog' },
+			});
+
+			processor.processChannelEvent({
+				type: 'feed.item',
+				data: { content: 'Hello' },
+				meta: { publisherDid: 'b', timestamp: 0, eventId: 'same', channelId: 'feed' },
+			});
+
+			expect(store.getState().count).toBe(2);
+		});
+	});
+
+	describe('validateChannelEvent', () => {
+		it('validates known channel event types', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+				channelDefinitions,
+			);
+
+			expect(processor.validateChannelEvent('feed.item', { content: 'hi' })).toBe(true);
+		});
+
+		it('returns false for invalid data', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+				channelDefinitions,
+			);
+
+			expect(processor.validateChannelEvent('feed.item', { content: 123 })).toBe(false);
+		});
+
+		it('returns false for unknown channel types', () => {
+			const { processor } = createProcessor(
+				{ items: { initial: [], reduce: {} } },
+				publicEventDefinitions,
+				channelDefinitions,
+			);
+
+			expect(processor.validateChannelEvent('unknown.type', { foo: 'bar' })).toBe(false);
+		});
+	});
+
+	describe('reset', () => {
+		it('clears public event listeners and dedup cache', () => {
+			const { processor, store } = createProcessor(
+				{
+					count: {
+						initial: 0,
+						reduce: { 'public:blog.post': (s: number) => s + 1 },
+					},
+				},
+				publicEventDefinitions,
+			);
+
+			const received: unknown[] = [];
+			processor.onPublicEvent((e) => received.push(e));
+
+			processor.processPublicEvent({
+				type: 'blog.post',
+				data: { title: 'T', body: 'B' },
+				meta: { publisherDid: 'a', timestamp: 0, eventId: 'e1', channelId: 'blog' },
+			});
+
+			expect(received).toHaveLength(1);
+
+			processor.reset();
+
+			// Same eventId should process again (dedup cleared), but listener cleared
+			processor.processPublicEvent({
+				type: 'blog.post',
+				data: { title: 'T2', body: 'B2' },
+				meta: { publisherDid: 'a', timestamp: 0, eventId: 'e1', channelId: 'blog' },
+			});
+
+			expect(received).toHaveLength(1);
+			expect(store.getState().count).toBe(2);
+		});
+	});
+});