eventsourcingdb 1.8.1 → 1.8.3

package/dist/Bound.d.ts

@@ -0,0 +1,6 @@
+type BoundType = 'inclusive' | 'exclusive';
+interface Bound {
+    id: string;
+    type: BoundType;
+}
+export type { Bound, BoundType };

package/dist/Bound.js

@@ -0,0 +1 @@
+export {};

package/dist/Client.d.ts

@@ -0,0 +1,21 @@
+import type { Event } from './Event.js';
+import type { EventCandidate } from './EventCandidate.js';
+import type { EventType } from './EventType.js';
+import type { ObserveEventsOptions } from './ObserveEventsOptions.js';
+import type { Precondition } from './Precondition.js';
+import type { ReadEventsOptions } from './ReadEventsOptions.js';
+declare class Client {
+    #private;
+    constructor(url: URL, apiToken: string);
+    ping(): Promise<void>;
+    verifyApiToken(): Promise<void>;
+    writeEvents(events: EventCandidate[], preconditions?: Precondition[]): Promise<Event[]>;
+    readEvents(subject: string, options: ReadEventsOptions, signal?: AbortSignal): AsyncGenerator<Event, void, void>;
+    runEventQlQuery(query: string, signal?: AbortSignal): AsyncGenerator<unknown, void, void>;
+    observeEvents(subject: string, options: ObserveEventsOptions, signal?: AbortSignal): AsyncGenerator<Event, void, void>;
+    registerEventSchema(eventType: string, schema: Record<string, unknown>): Promise<void>;
+    readSubjects(baseSubject: string, signal?: AbortSignal): AsyncGenerator<string, void, void>;
+    readEventType(eventType: string): Promise<EventType>;
+    readEventTypes(signal?: AbortSignal): AsyncGenerator<EventType, void, void>;
+}
+export { Client };

package/dist/Client.js

@@ -0,0 +1,484 @@
+import { convertCloudEventToEvent } from './convertCloudEventToEvent.js';
+import { isCloudEvent } from './isCloudEvent.js';
+import { isValidServerHeader } from './isValidServerHeader.js';
+import { readNdJsonStream } from './ndjson/readNdJsonStream.js';
+import { isStreamCloudEvent } from './stream/isStreamCloudEvent.js';
+import { isStreamError } from './stream/isStreamError.js';
+import { isStreamEventType } from './stream/isStreamEventType.js';
+import { isStreamHeartbeat } from './stream/isStreamHeartbeat.js';
+import { isStreamRow } from './stream/isStreamRow.js';
+import { isStreamSubject } from './stream/isStreamSubject.js';
+import { hasShapeOf } from './types/hasShapeOf.js';
+import { isBoolean } from './types/isBoolean.js';
+import { isString } from './types/isString.js';
+class Client {
+    #url;
+    #apiToken;
+    #getUrl(path) {
+        return new URL(path, this.#url).toString();
+    }
+    constructor(url, apiToken) {
+        this.#url = url;
+        this.#apiToken = apiToken;
+    }
+    async ping() {
+        const url = this.#getUrl('/api/v1/ping');
+        const response = await fetch(url, {
+            method: 'get',
+        });
+        if (!isValidServerHeader(response)) {
+            throw new Error('Server must be EventSourcingDB.');
+        }
+        if (response.status !== 200) {
+            throw new Error(`Failed to ping, got HTTP status code '${response.status}', expected '200'.`);
+        }
+        const responseBody = await response.json();
+        if (!hasShapeOf(responseBody, {
+            type: isString,
+        })) {
+            throw new Error('Failed to parse response.');
+        }
+        const eventType = 'io.eventsourcingdb.api.ping-received';
+        if (responseBody.type !== eventType) {
+            throw new Error('Failed to ping.');
+        }
+    }
+    async verifyApiToken() {
+        const url = this.#getUrl('/api/v1/verify-api-token');
+        const response = await fetch(url, {
+            method: 'post',
+            headers: {
+                authorization: `Bearer ${this.#apiToken}`,
+            },
+        });
+        if (!isValidServerHeader(response)) {
+            throw new Error('Server must be EventSourcingDB.');
+        }
+        if (response.status !== 200) {
+            throw new Error(`Failed to verify API token, got HTTP status code '${response.status}', expected '200'.`);
+        }
+        const responseBody = await response.json();
+        if (!hasShapeOf(responseBody, {
+            type: isString,
+        })) {
+            throw new Error('Failed to parse response.');
+        }
+        const eventType = 'io.eventsourcingdb.api.api-token-verified';
+        if (responseBody.type !== eventType) {
+            throw new Error('Failed to verify API token.');
+        }
+    }
+    async writeEvents(events, preconditions = []) {
+        const url = this.#getUrl('/api/v1/write-events');
+        const response = await fetch(url, {
+            method: 'post',
+            headers: {
+                authorization: `Bearer ${this.#apiToken}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                events,
+                preconditions,
+            }),
+        });
+        if (!isValidServerHeader(response)) {
+            throw new Error('Server must be EventSourcingDB.');
+        }
+        if (response.status !== 200) {
+            throw new Error(`Failed to write events, got HTTP status code '${response.status}', expected '200'.`);
+        }
+        const responseBody = await response.json();
+        if (!Array.isArray(responseBody)) {
+            throw new Error('Failed to parse response.');
+        }
+        const writtenEvents = responseBody.map(item => {
+            if (!isCloudEvent(item)) {
+                throw new Error('Failed to parse response item.');
+            }
+            const event = convertCloudEventToEvent(item);
+            return event;
+        });
+        return writtenEvents;
+    }
+    readEvents(subject, options, signal) {
+        const url = this.#getUrl('/api/v1/read-events');
+        const apiToken = this.#apiToken;
+        return (async function* () {
+            const internalAbortController = new AbortController();
+            const combinedSignal = signal ?? internalAbortController.signal;
+            const shouldAbortInternally = !signal;
+            let removeAbortListener;
+            if (signal && !signal.aborted) {
+                const onAbort = () => internalAbortController.abort();
+                signal.addEventListener('abort', onAbort, { once: true });
+                removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+            }
+            try {
+                const response = await fetch(url, {
+                    method: 'post',
+                    headers: {
+                        authorization: `Bearer ${apiToken}`,
+                        'content-type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        subject,
+                        options,
+                    }),
+                    signal: combinedSignal,
+                });
+                if (!isValidServerHeader(response)) {
+                    const serverHeader = response.headers.get('Server');
+                    if (!serverHeader) {
+                        throw new Error('Server must be EventSourcingDB, but Server header is missing.');
+                    }
+                    throw new Error(`Server must be EventSourcingDB, got Server header: '${serverHeader}'.`);
+                }
+                if (response.status !== 200) {
+                    throw new Error(`Failed to read events, got HTTP status code '${response.status}', expected '200'.`);
+                }
+                if (!response.body) {
+                    throw new Error('Failed to read events.');
+                }
+                for await (const line of readNdJsonStream(response.body, combinedSignal)) {
+                    if (isStreamError(line)) {
+                        throw new Error(`${line.payload.error}.`);
+                    }
+                    if (isStreamCloudEvent(line)) {
+                        const event = convertCloudEventToEvent(line.payload);
+                        yield event;
+                        continue;
+                    }
+                    throw new Error('Failed to read events.');
+                }
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    return;
+                }
+                throw error;
+            }
+            finally {
+                if (removeAbortListener) {
+                    removeAbortListener();
+                }
+                if (shouldAbortInternally) {
+                    internalAbortController.abort();
+                }
+            }
+        })();
+    }
+    runEventQlQuery(query, signal) {
+        const url = this.#getUrl('/api/v1/run-eventql-query');
+        const apiToken = this.#apiToken;
+        return (async function* () {
+            const internalAbortController = new AbortController();
+            const combinedSignal = signal ?? internalAbortController.signal;
+            const shouldAbortInternally = !signal;
+            let removeAbortListener;
+            if (signal && !signal.aborted) {
+                const onAbort = () => internalAbortController.abort();
+                signal.addEventListener('abort', onAbort, { once: true });
+                removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+            }
+            try {
+                const response = await fetch(url, {
+                    method: 'post',
+                    headers: {
+                        authorization: `Bearer ${apiToken}`,
+                        'content-type': 'application/json',
+                    },
+                    body: JSON.stringify({ query }),
+                    signal: combinedSignal,
+                });
+                if (!isValidServerHeader(response)) {
+                    const serverHeader = response.headers.get('Server');
+                    if (!serverHeader) {
+                        throw new Error('Server must be EventSourcingDB, but Server header is missing.');
+                    }
+                    throw new Error(`Server must be EventSourcingDB, got Server header: '${serverHeader}'.`);
+                }
+                if (response.status !== 200) {
+                    throw new Error(`Failed to run EventQL query, got HTTP status code '${response.status}', expected '200'.`);
+                }
+                if (!response.body) {
+                    throw new Error('Failed to run EventQL query.');
+                }
+                for await (const line of readNdJsonStream(response.body, combinedSignal)) {
+                    if (isStreamHeartbeat(line)) {
+                        continue;
+                    }
+                    if (isStreamError(line)) {
+                        throw new Error(`${line.payload.error}.`);
+                    }
+                    if (isStreamRow(line)) {
+                        const row = line.payload;
+                        yield row;
+                        continue;
+                    }
+                    throw new Error('Failed to run EventQL query.');
+                }
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    return;
+                }
+                throw error;
+            }
+            finally {
+                if (removeAbortListener) {
+                    removeAbortListener();
+                }
+                if (shouldAbortInternally) {
+                    internalAbortController.abort();
+                }
+            }
+        })();
+    }
+    observeEvents(subject, options, signal) {
+        const url = this.#getUrl('/api/v1/observe-events');
+        const apiToken = this.#apiToken;
+        return (async function* () {
+            const internalAbortController = new AbortController();
+            const combinedSignal = signal ?? internalAbortController.signal;
+            const shouldAbortInternally = !signal;
+            let removeAbortListener;
+            if (signal && !signal.aborted) {
+                const onAbort = () => internalAbortController.abort();
+                signal.addEventListener('abort', onAbort, { once: true });
+                removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+            }
+            try {
+                const response = await fetch(url, {
+                    method: 'post',
+                    headers: {
+                        authorization: `Bearer ${apiToken}`,
+                        'content-type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        subject,
+                        options,
+                    }),
+                    signal: combinedSignal,
+                });
+                if (!isValidServerHeader(response)) {
+                    const serverHeader = response.headers.get('Server');
+                    if (!serverHeader) {
+                        throw new Error('Server must be EventSourcingDB, but Server header is missing.');
+                    }
+                    throw new Error(`Server must be EventSourcingDB, got Server header: '${serverHeader}'.`);
+                }
+                if (response.status !== 200) {
+                    throw new Error(`Failed to observe events, got HTTP status code '${response.status}', expected '200'.`);
+                }
+                if (!response.body) {
+                    throw new Error('Failed to observe events.');
+                }
+                for await (const line of readNdJsonStream(response.body, combinedSignal)) {
+                    if (isStreamHeartbeat(line)) {
+                        continue;
+                    }
+                    if (isStreamError(line)) {
+                        throw new Error(`${line.payload.error}.`);
+                    }
+                    if (isStreamCloudEvent(line)) {
+                        const event = convertCloudEventToEvent(line.payload);
+                        yield event;
+                        continue;
+                    }
+                    throw new Error('Failed to observe events.');
+                }
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    return;
+                }
+                throw error;
+            }
+            finally {
+                if (removeAbortListener) {
+                    removeAbortListener();
+                }
+                if (shouldAbortInternally) {
+                    internalAbortController.abort();
+                }
+            }
+        })();
+    }
+    async registerEventSchema(eventType, schema) {
+        const url = this.#getUrl('/api/v1/register-event-schema');
+        const response = await fetch(url, {
+            method: 'post',
+            headers: {
+                authorization: `Bearer ${this.#apiToken}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                eventType,
+                schema,
+            }),
+        });
+        if (!isValidServerHeader(response)) {
+            throw new Error('Server must be EventSourcingDB.');
+        }
+        if (response.status !== 200) {
+            throw new Error(`Failed to register event schema, got HTTP status code '${response.status}', expected '200'.`);
+        }
+    }
+    readSubjects(baseSubject, signal) {
+        const url = this.#getUrl('/api/v1/read-subjects');
+        const apiToken = this.#apiToken;
+        return (async function* () {
+            const internalAbortController = new AbortController();
+            const combinedSignal = signal ?? internalAbortController.signal;
+            const shouldAbortInternally = !signal;
+            let removeAbortListener;
+            if (signal && !signal.aborted) {
+                const onAbort = () => internalAbortController.abort();
+                signal.addEventListener('abort', onAbort, { once: true });
+                removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+            }
+            try {
+                const response = await fetch(url, {
+                    method: 'post',
+                    headers: {
+                        authorization: `Bearer ${apiToken}`,
+                        'content-type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        baseSubject,
+                    }),
+                    signal: combinedSignal,
+                });
+                if (!isValidServerHeader(response)) {
+                    const serverHeader = response.headers.get('Server');
+                    if (!serverHeader) {
+                        throw new Error('Server must be EventSourcingDB, but Server header is missing.');
+                    }
+                    throw new Error(`Server must be EventSourcingDB, got Server header: '${serverHeader}'.`);
+                }
+                if (response.status !== 200) {
+                    throw new Error(`Failed to read subjects, got HTTP status code '${response.status}', expected '200'.`);
+                }
+                if (!response.body) {
+                    throw new Error('Failed to read subjects.');
+                }
+                for await (const line of readNdJsonStream(response.body, combinedSignal)) {
+                    if (isStreamError(line)) {
+                        throw new Error(`${line.payload.error}.`);
+                    }
+                    if (isStreamSubject(line)) {
+                        yield line.payload.subject;
+                        continue;
+                    }
+                    throw new Error('Failed to read subjects.');
+                }
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    return;
+                }
+                throw error;
+            }
+            finally {
+                if (removeAbortListener) {
+                    removeAbortListener();
+                }
+                if (shouldAbortInternally) {
+                    internalAbortController.abort();
+                }
+            }
+        })();
+    }
+    async readEventType(eventType) {
+        const url = this.#getUrl('/api/v1/read-event-type');
+        const response = await fetch(url, {
+            method: 'post',
+            headers: {
+                authorization: `Bearer ${this.#apiToken}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                eventType,
+            }),
+        });
+        if (!isValidServerHeader(response)) {
+            throw new Error('Server must be EventSourcingDB.');
+        }
+        if (response.status !== 200) {
+            throw new Error(`Failed to read event type, got HTTP status code '${response.status}', expected '200'.`);
+        }
+        const responseBody = await response.json();
+        if (!hasShapeOf(responseBody, {
+            eventType: isString,
+            isPhantom: isBoolean,
+        })) {
+            throw new Error('Failed to parse response.');
+        }
+        return responseBody;
+    }
+    readEventTypes(signal) {
+        const url = this.#getUrl('/api/v1/read-event-types');
+        const apiToken = this.#apiToken;
+        return (async function* () {
+            const internalAbortController = new AbortController();
+            const combinedSignal = signal ?? internalAbortController.signal;
+            const shouldAbortInternally = !signal;
+            let removeAbortListener;
+            if (signal && !signal.aborted) {
+                const onAbort = () => internalAbortController.abort();
+                signal.addEventListener('abort', onAbort, { once: true });
+                removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+            }
+            try {
+                const response = await fetch(url, {
+                    method: 'post',
+                    headers: {
+                        authorization: `Bearer ${apiToken}`,
+                    },
+                    signal: combinedSignal,
+                });
+                if (!isValidServerHeader(response)) {
+                    const serverHeader = response.headers.get('Server');
+                    if (!serverHeader) {
+                        throw new Error('Server must be EventSourcingDB, but Server header is missing.');
+                    }
+                    throw new Error(`Server must be EventSourcingDB, got Server header: '${serverHeader}'.`);
+                }
+                if (response.status !== 200) {
+                    throw new Error(`Failed to read event types, got HTTP status code '${response.status}', expected '200'.`);
+                }
+                if (!response.body) {
+                    throw new Error('Failed to read event types.');
+                }
+                for await (const line of readNdJsonStream(response.body, combinedSignal)) {
+                    if (isStreamHeartbeat(line)) {
+                        continue;
+                    }
+                    if (isStreamError(line)) {
+                        throw new Error(`${line.payload.error}.`);
+                    }
+                    if (isStreamEventType(line)) {
+                        yield line.payload;
+                        continue;
+                    }
+                    throw new Error('Failed to read event types.');
+                }
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    return;
+                }
+                throw error;
+            }
+            finally {
+                if (removeAbortListener) {
+                    removeAbortListener();
+                }
+                if (shouldAbortInternally) {
+                    internalAbortController.abort();
+                }
+            }
+        })();
+    }
+}
+export { Client };

package/dist/CloudEvent.d.ts

@@ -0,0 +1,16 @@
+interface CloudEvent {
+    specversion: string;
+    id: string;
+    time: string;
+    source: string;
+    subject: string;
+    type: string;
+    datacontenttype: string;
+    data: Record<string, unknown>;
+    hash: string;
+    predecessorhash: string;
+    traceparent?: string;
+    tracestate?: string;
+    signature: string | null;
+}
+export type { CloudEvent };

package/dist/CloudEvent.js

@@ -0,0 +1 @@
+export {};

package/dist/Container.d.ts

@@ -0,0 +1,20 @@
+import crypto from 'node:crypto';
+import { Client } from './Client.js';
+declare class Container {
+    #private;
+    withImageTag(tag: string): this;
+    withApiToken(token: string): this;
+    withSigningKey(): this;
+    withPort(port: number): this;
+    start(): Promise<void>;
+    getHost(): string;
+    getMappedPort(): number;
+    getBaseUrl(): URL;
+    getApiToken(): string;
+    getSigningKey(): crypto.KeyObject;
+    getVerificationKey(): crypto.KeyObject;
+    isRunning(): boolean;
+    stop(): Promise<void>;
+    getClient(): Client;
+}
+export { Container };

package/dist/Container.js

@@ -0,0 +1,108 @@
+import crypto from 'node:crypto';
+import { GenericContainer, Wait } from 'testcontainers';
+import { Client } from './Client.js';
+class Container {
+    #imageName = 'thenativeweb/eventsourcingdb';
+    #imageTag = 'latest';
+    #internalPort = 3000;
+    #apiToken = 'secret';
+    #signingKey;
+    #container;
+    withImageTag(tag) {
+        this.#imageTag = tag;
+        return this;
+    }
+    withApiToken(token) {
+        this.#apiToken = token;
+        return this;
+    }
+    withSigningKey() {
+        const { privateKey } = crypto.generateKeyPairSync('ed25519');
+        this.#signingKey = privateKey;
+        return this;
+    }
+    withPort(port) {
+        this.#internalPort = port;
+        return this;
+    }
+    async start() {
+        const command = [
+            'run',
+            '--api-token',
+            this.#apiToken,
+            '--data-directory-temporary',
+            '--http-enabled',
+            '--https-enabled=false',
+        ];
+        const contents = [];
+        if (this.#signingKey !== undefined) {
+            command.push('--signing-key-file');
+            command.push('/etc/esdb/signing-key.pem');
+            contents.push({
+                content: this.#signingKey.export({ format: 'pem', type: 'pkcs8' }),
+                target: '/etc/esdb/signing-key.pem',
+                mode: 0o777,
+            });
+        }
+        this.#container = await new GenericContainer(`${this.#imageName}:${this.#imageTag}`)
+            .withExposedPorts(this.#internalPort)
+            .withCommand(command)
+            .withCopyContentToContainer(contents)
+            .withWaitStrategy(Wait.forHttp('/api/v1/ping', this.#internalPort).withStartupTimeout(10_000))
+            .start();
+    }
+    getHost() {
+        if (this.#container === undefined) {
+            throw new Error('Container must be running.');
+        }
+        return this.#container.getHost();
+    }
+    getMappedPort() {
+        if (this.#container === undefined) {
+            throw new Error('Container must be running.');
+        }
+        return this.#container.getMappedPort(this.#internalPort);
+    }
+    getBaseUrl() {
+        if (this.#container === undefined) {
+            throw new Error('Container must be running.');
+        }
+        const host = this.getHost();
+        const port = this.getMappedPort();
+        return new URL(`http://${host}:${port}`);
+    }
+    getApiToken() {
+        return this.#apiToken;
+    }
+    getSigningKey() {
+        if (this.#signingKey === undefined) {
+            throw new Error('Signing key not set.');
+        }
+        return this.#signingKey;
+    }
+    getVerificationKey() {
+        if (this.#signingKey === undefined) {
+            throw new Error('Signing key not set.');
+        }
+        // @types/node >= 26.0.0 dropped the KeyObject overload from createPublicKey,
+        // even though Node accepts a (private) KeyObject at runtime to derive the public
+        // key. Remove this suppression once DefinitelyTyped restores the overload.
+        // @ts-expect-error
+        const verificationKey = crypto.createPublicKey(this.#signingKey);
+        return verificationKey;
+    }
+    isRunning() {
+        return this.#container !== undefined;
+    }
+    async stop() {
+        if (this.#container === undefined) {
+            return;
+        }
+        await this.#container.stop();
+        this.#container = undefined;
+    }
+    getClient() {
+        return new Client(this.getBaseUrl(), this.getApiToken());
+    }
+}
+export { Container };