eventsourcingdb 1.8.2 → 1.8.3

package/dist/Event.d.ts

@@ -0,0 +1,36 @@
+import crypto from 'node:crypto';
+declare class Event {
+    #private;
+    specversion: string;
+    id: string;
+    time: Date;
+    source: string;
+    subject: string;
+    type: string;
+    datacontenttype: string;
+    data: Record<string, unknown>;
+    hash: string;
+    predecessorhash: string;
+    traceparent?: string;
+    tracestate?: string;
+    signature: string | null;
+    constructor({ specversion, id, time, timeFromServer, source, subject, type, datacontenttype, data, hash, predecessorhash, traceparent, tracestate, signature, }: {
+        specversion: string;
+        id: string;
+        time: Date;
+        timeFromServer: string;
+        source: string;
+        subject: string;
+        type: string;
+        datacontenttype: string;
+        data: Record<string, unknown>;
+        hash: string;
+        predecessorhash: string;
+        traceparent?: string;
+        tracestate?: string;
+        signature: string | null;
+    });
+    verifyHash(): void;
+    verifySignature(verificationKey: crypto.KeyObject): void;
+}
+export { Event };

package/dist/Event.js

@@ -0,0 +1,63 @@
+import crypto from 'node:crypto';
+class Event {
+    specversion;
+    id;
+    time;
+    #timeFromServer;
+    source;
+    subject;
+    type;
+    datacontenttype;
+    data;
+    hash;
+    predecessorhash;
+    traceparent;
+    tracestate;
+    signature;
+    constructor({ specversion, id, time, timeFromServer, source, subject, type, datacontenttype, data, hash, predecessorhash, traceparent, tracestate, signature, }) {
+        this.specversion = specversion;
+        this.id = id;
+        this.time = time;
+        this.#timeFromServer = timeFromServer;
+        this.source = source;
+        this.subject = subject;
+        this.type = type;
+        this.datacontenttype = datacontenttype;
+        this.data = data;
+        this.hash = hash;
+        this.predecessorhash = predecessorhash;
+        this.traceparent = traceparent;
+        this.tracestate = tracestate;
+        this.signature = signature;
+    }
+    verifyHash() {
+        const metadata = `${this.specversion}|${this.id}|${this.predecessorhash}|${this.#timeFromServer}|${this.source}|${this.subject}|${this.type}|${this.datacontenttype}`;
+        const metadataHash = crypto.createHash('sha256').update(metadata).digest('hex');
+        const dataHash = crypto.createHash('sha256').update(JSON.stringify(this.data)).digest('hex');
+        const finalHash = crypto
+            .createHash('sha256')
+            .update(`${metadataHash}${dataHash}`)
+            .digest('hex');
+        if (finalHash !== this.hash) {
+            throw new Error('Failed to verify hash.');
+        }
+    }
+    verifySignature(verificationKey) {
+        if (this.signature === null) {
+            throw new Error('Signature must not be null.');
+        }
+        this.verifyHash();
+        const signaturePrefix = 'esdb:signature:v1:';
+        if (!this.signature.startsWith(signaturePrefix)) {
+            throw new Error(`Signature must start with '${signaturePrefix}'`);
+        }
+        const signature = this.signature.slice(signaturePrefix.length);
+        const signatureBytes = Buffer.from(signature, 'hex');
+        const hashBytes = Buffer.from(this.hash, 'utf8');
+        const isSignatureValid = crypto.verify(null, hashBytes, verificationKey, signatureBytes);
+        if (!isSignatureValid) {
+            throw new Error('Signature verification failed.');
+        }
+    }
+}
+export { Event };

package/dist/EventCandidate.d.ts

@@ -0,0 +1,9 @@
+interface EventCandidate {
+    source: string;
+    subject: string;
+    type: string;
+    data: Record<string, unknown>;
+    traceparent?: string;
+    tracestate?: string;
+}
+export type { EventCandidate };

package/dist/EventCandidate.js

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

package/dist/EventType.d.ts

@@ -0,0 +1,6 @@
+interface EventType {
+    eventType: string;
+    isPhantom: boolean;
+    schema?: Record<string, unknown>;
+}
+export type { EventType };

package/dist/EventType.js

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

package/dist/ObserveEventsOptions.d.ts

@@ -0,0 +1,13 @@
+import type { Bound } from './Bound.js';
+type ObserveIfEventIsMissing = 'read-everything' | 'wait-for-event';
+interface ObserveFromLatestEvent {
+    subject: string;
+    type: string;
+    ifEventIsMissing: ObserveIfEventIsMissing;
+}
+interface ObserveEventsOptions {
+    recursive: boolean;
+    lowerBound?: Bound;
+    fromLatestEvent?: ObserveFromLatestEvent;
+}
+export type { ObserveEventsOptions, ObserveFromLatestEvent, ObserveIfEventIsMissing };

package/dist/ObserveEventsOptions.js

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

package/dist/Precondition.d.ts

@@ -0,0 +1,27 @@
+interface IsSubjectPristinePrecondition {
+    subject: string;
+}
+interface IsSubjectPopulatedPrecondition {
+    subject: string;
+}
+interface IsSubjectOnEventIdPrecondition {
+    subject: string;
+    eventId: string;
+}
+interface IsEventQlQueryTruePrecondition {
+    query: string;
+}
+type Precondition = {
+    type: 'isSubjectPristine';
+    payload: IsSubjectPristinePrecondition;
+} | {
+    type: 'isSubjectOnEventId';
+    payload: IsSubjectOnEventIdPrecondition;
+} | {
+    type: 'isSubjectPopulated';
+    payload: IsSubjectPopulatedPrecondition;
+} | {
+    type: 'isEventQlQueryTrue';
+    payload: IsEventQlQueryTruePrecondition;
+};
+export type { Precondition };

package/dist/Precondition.js

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

package/dist/ReadEventsOptions.d.ts

@@ -0,0 +1,16 @@
+import type { Bound } from './Bound.js';
+type Order = 'chronological' | 'antichronological';
+type ReadIfEventIsMissing = 'read-nothing' | 'read-everything';
+interface ReadFromLatestEvent {
+    subject: string;
+    type: string;
+    ifEventIsMissing: ReadIfEventIsMissing;
+}
+interface ReadEventsOptions {
+    recursive: boolean;
+    order?: Order;
+    lowerBound?: Bound;
+    upperBound?: Bound;
+    fromLatestEvent?: ReadFromLatestEvent;
+}
+export type { Order, ReadEventsOptions, ReadFromLatestEvent, ReadIfEventIsMissing };

package/dist/ReadEventsOptions.js

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

package/dist/convertCloudEventToEvent.d.ts

@@ -0,0 +1,4 @@
+import type { CloudEvent } from './CloudEvent.js';
+import { Event } from './Event.js';
+declare const convertCloudEventToEvent: (cloudEvent: CloudEvent) => Event;
+export { convertCloudEventToEvent };

package/dist/convertCloudEventToEvent.js

@@ -0,0 +1,18 @@
+import { Event } from './Event.js';
+const convertCloudEventToEvent = (cloudEvent) => new Event({
+    specversion: cloudEvent.specversion,
+    id: cloudEvent.id,
+    time: new Date(cloudEvent.time),
+    timeFromServer: cloudEvent.time,
+    source: cloudEvent.source,
+    subject: cloudEvent.subject,
+    type: cloudEvent.type,
+    datacontenttype: cloudEvent.datacontenttype,
+    data: cloudEvent.data,
+    hash: cloudEvent.hash,
+    predecessorhash: cloudEvent.predecessorhash,
+    traceparent: cloudEvent.traceparent,
+    tracestate: cloudEvent.tracestate,
+    signature: cloudEvent.signature,
+});
+export { convertCloudEventToEvent };

package/dist/getImageVersionFromDockerfile.d.ts

@@ -0,0 +1,2 @@
+declare const getImageVersionFromDockerfile: () => string;
+export { getImageVersionFromDockerfile };

package/dist/getImageVersionFromDockerfile.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const versionRegex = /^FROM\sthenativeweb\/eventsourcingdb:(.+)$/mu;
+const getImageVersionFromDockerfile = () => {
+    const dockerfile = path.join(import.meta.dirname, '..', 'docker', 'Dockerfile');
+    const data = fs.readFileSync(dockerfile, 'utf-8');
+    const matches = data.match(versionRegex);
+    const version = matches?.[1];
+    if (version === undefined) {
+        throw new Error('Failed to find image version in Dockerfile.');
+    }
+    return version;
+};
+export { getImageVersionFromDockerfile };

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { Client } from './Client.js';
+import { Container } from './Container.js';
+import type { Event } from './Event.js';
+import type { EventCandidate } from './EventCandidate.js';
+import type { EventType } from './EventType.js';
+import { isEventQlQueryTrue } from './isEventQlQueryTrue.js';
+import { isSubjectOnEventId } from './isSubjectOnEventId.js';
+import { isSubjectPopulated } from './isSubjectPopulated.js';
+import { isSubjectPristine } from './isSubjectPristine.js';
+import type { ObserveEventsOptions } from './ObserveEventsOptions.js';
+import type { Precondition } from './Precondition.js';
+import type { ReadEventsOptions } from './ReadEventsOptions.js';
+export type { Event, EventCandidate, EventType, ObserveEventsOptions, Precondition, ReadEventsOptions, };
+export { Client, Container, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, };

package/dist/index.js

@@ -0,0 +1,7 @@
+import { Client } from './Client.js';
+import { Container } from './Container.js';
+import { isEventQlQueryTrue } from './isEventQlQueryTrue.js';
+import { isSubjectOnEventId } from './isSubjectOnEventId.js';
+import { isSubjectPopulated } from './isSubjectPopulated.js';
+import { isSubjectPristine } from './isSubjectPristine.js';
+export { Client, Container, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, };

package/dist/isCloudEvent.d.ts

@@ -0,0 +1,3 @@
+import type { CloudEvent } from './CloudEvent.js';
+declare const isCloudEvent: (value: unknown) => value is CloudEvent;
+export { isCloudEvent };

package/dist/isCloudEvent.js

@@ -0,0 +1,21 @@
+import { hasShapeOf } from './types/hasShapeOf.js';
+import { isRecord } from './types/isRecord.js';
+import { isString } from './types/isString.js';
+import { isStringOrNull } from './types/isStringOrNull.js';
+import { isStringOrUndefined } from './types/isStringOrUndefined.js';
+const isCloudEvent = (value) => hasShapeOf(value, {
+    specversion: isString,
+    id: isString,
+    time: isString,
+    source: isString,
+    subject: isString,
+    type: isString,
+    datacontenttype: isString,
+    data: isRecord,
+    hash: isString,
+    predecessorhash: isString,
+    traceparent: isStringOrUndefined,
+    tracestate: isStringOrUndefined,
+    signature: isStringOrNull,
+});
+export { isCloudEvent };

package/dist/isEventQlQueryTrue.d.ts

@@ -0,0 +1,3 @@
+import type { Precondition } from './Precondition.js';
+declare const isEventQlQueryTrue: (query: string) => Precondition;
+export { isEventQlQueryTrue };

package/dist/isEventQlQueryTrue.js

@@ -0,0 +1,5 @@
+const isEventQlQueryTrue = (query) => ({
+    type: 'isEventQlQueryTrue',
+    payload: { query },
+});
+export { isEventQlQueryTrue };

package/dist/isSubjectOnEventId.d.ts

@@ -0,0 +1,3 @@
+import type { Precondition } from './Precondition.js';
+declare const isSubjectOnEventId: (subject: string, eventId: string) => Precondition;
+export { isSubjectOnEventId };

package/dist/isSubjectOnEventId.js

@@ -0,0 +1,5 @@
+const isSubjectOnEventId = (subject, eventId) => ({
+    type: 'isSubjectOnEventId',
+    payload: { subject, eventId },
+});
+export { isSubjectOnEventId };

package/dist/isSubjectPopulated.d.ts

@@ -0,0 +1,3 @@
+import type { Precondition } from './Precondition.js';
+declare const isSubjectPopulated: (subject: string) => Precondition;
+export { isSubjectPopulated };

package/dist/isSubjectPopulated.js

@@ -0,0 +1,5 @@
+const isSubjectPopulated = (subject) => ({
+    type: 'isSubjectPopulated',
+    payload: { subject },
+});
+export { isSubjectPopulated };

package/dist/isSubjectPristine.d.ts

@@ -0,0 +1,3 @@
+import type { Precondition } from './Precondition.js';
+declare const isSubjectPristine: (subject: string) => Precondition;
+export { isSubjectPristine };

package/dist/isSubjectPristine.js

@@ -0,0 +1,5 @@
+const isSubjectPristine = (subject) => ({
+    type: 'isSubjectPristine',
+    payload: { subject },
+});
+export { isSubjectPristine };

package/dist/isValidServerHeader.d.ts

@@ -0,0 +1,2 @@
+declare const isValidServerHeader: (response: Response) => boolean;
+export { isValidServerHeader };

package/dist/isValidServerHeader.js

@@ -0,0 +1,11 @@
+const isValidServerHeader = (response) => {
+    const serverHeader = response.headers.get('Server');
+    if (!serverHeader) {
+        return false;
+    }
+    if (!serverHeader.startsWith('EventSourcingDB/')) {
+        return false;
+    }
+    return true;
+};
+export { isValidServerHeader };

package/dist/ndjson/readNdJsonStream.d.ts

@@ -0,0 +1,2 @@
+declare const readNdJsonStream: (stream: ReadableStream<Uint8Array>, signal: AbortSignal) => AsyncGenerator<Record<string, unknown>, void, void>;
+export { readNdJsonStream };

package/dist/ndjson/readNdJsonStream.js

@@ -0,0 +1,43 @@
+const readNdJsonStream = async function* (stream, signal) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    const onAbort = () => {
+        reader.cancel().catch(() => {
+            // Intentionally left blank.
+        });
+    };
+    if (signal.aborted) {
+        await reader.cancel().catch(() => {
+            // Intentionally left blank.
+        });
+        return;
+    }
+    signal.addEventListener('abort', onAbort);
+    try {
+        while (!signal.aborted) {
+            // biome-ignore lint/performance/noAwaitInLoops: Awaiting the result is fine here, although we are in a loop.
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let index = buffer.indexOf('\n');
+            while (index !== -1) {
+                const line = buffer.slice(0, index).trim();
+                buffer = buffer.slice(index + 1);
+                if (line) {
+                    yield JSON.parse(line);
+                }
+                index = buffer.indexOf('\n');
+            }
+        }
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+        await reader.cancel().catch(() => {
+            // Intentionally left blank.
+        });
+    }
+};
+export { readNdJsonStream };

package/dist/stream/StreamCloudEvent.d.ts

@@ -0,0 +1,19 @@
+interface StreamCloudEvent {
+    type: 'event';
+    payload: {
+        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 { StreamCloudEvent };

package/dist/stream/StreamCloudEvent.js

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

package/dist/stream/StreamError.d.ts

@@ -0,0 +1,7 @@
+interface StreamError {
+    type: 'error';
+    payload: {
+        error: string;
+    };
+}
+export type { StreamError };

package/dist/stream/StreamError.js

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

package/dist/stream/StreamEventType.d.ts

@@ -0,0 +1,9 @@
+interface StreamEventType {
+    type: 'eventType';
+    payload: {
+        eventType: string;
+        isPhantom: boolean;
+        schema?: Record<string, unknown>;
+    };
+}
+export type { StreamEventType };

package/dist/stream/StreamEventType.js

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

package/dist/stream/StreamHeartbeat.d.ts

@@ -0,0 +1,4 @@
+interface StreamHeartbeat {
+    type: 'heartbeat';
+}
+export type { StreamHeartbeat };

package/dist/stream/StreamHeartbeat.js

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

package/dist/stream/StreamRow.d.ts

@@ -0,0 +1,5 @@
+interface StreamRow {
+    type: 'row';
+    payload: unknown;
+}
+export type { StreamRow };

package/dist/stream/StreamRow.js

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

package/dist/stream/StreamSubject.d.ts

@@ -0,0 +1,7 @@
+interface StreamSubject {
+    type: 'subject';
+    payload: {
+        subject: string;
+    };
+}
+export type { StreamSubject };

package/dist/stream/StreamSubject.js

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

package/dist/stream/isStreamCloudEvent.d.ts

@@ -0,0 +1,3 @@
+import type { StreamCloudEvent } from './StreamCloudEvent.js';
+declare const isStreamCloudEvent: (line: unknown) => line is StreamCloudEvent;
+export { isStreamCloudEvent };

package/dist/stream/isStreamCloudEvent.js

@@ -0,0 +1,24 @@
+import { hasShapeOf } from '../types/hasShapeOf.js';
+import { isRecord } from '../types/isRecord.js';
+import { isString } from '../types/isString.js';
+import { isStringOrNull } from '../types/isStringOrNull.js';
+import { isStringOrUndefined } from '../types/isStringOrUndefined.js';
+const isStreamCloudEvent = (line) => hasShapeOf(line, {
+    type: (value) => value === 'event',
+    payload: {
+        specversion: isString,
+        id: isString,
+        time: isString,
+        source: isString,
+        subject: isString,
+        type: isString,
+        datacontenttype: isString,
+        data: isRecord,
+        hash: isString,
+        predecessorhash: isString,
+        traceparent: isStringOrUndefined,
+        tracestate: isStringOrUndefined,
+        signature: isStringOrNull,
+    },
+});
+export { isStreamCloudEvent };

package/dist/stream/isStreamError.d.ts

@@ -0,0 +1,3 @@
+import type { StreamError } from './StreamError.js';
+declare const isStreamError: (line: unknown) => line is StreamError;
+export { isStreamError };

package/dist/stream/isStreamError.js

@@ -0,0 +1,9 @@
+import { hasShapeOf } from '../types/hasShapeOf.js';
+import { isString } from '../types/isString.js';
+const isStreamError = (line) => hasShapeOf(line, {
+    type: (value) => value === 'error',
+    payload: {
+        error: isString,
+    },
+});
+export { isStreamError };

package/dist/stream/isStreamEventType.d.ts

@@ -0,0 +1,3 @@
+import type { StreamEventType } from './StreamEventType.js';
+declare const isStreamEventType: (line: unknown) => line is StreamEventType;
+export { isStreamEventType };

package/dist/stream/isStreamEventType.js

@@ -0,0 +1,11 @@
+import { hasShapeOf } from '../types/hasShapeOf.js';
+import { isBoolean } from '../types/isBoolean.js';
+import { isString } from '../types/isString.js';
+const isStreamEventType = (line) => hasShapeOf(line, {
+    type: (value) => value === 'eventType',
+    payload: {
+        eventType: isString,
+        isPhantom: isBoolean,
+    },
+});
+export { isStreamEventType };

package/dist/stream/isStreamHeartbeat.d.ts

@@ -0,0 +1,3 @@
+import type { StreamHeartbeat } from './StreamHeartbeat.js';
+declare const isStreamHeartbeat: (line: unknown) => line is StreamHeartbeat;
+export { isStreamHeartbeat };

package/dist/stream/isStreamHeartbeat.js

@@ -0,0 +1,5 @@
+import { hasShapeOf } from '../types/hasShapeOf.js';
+const isStreamHeartbeat = (line) => hasShapeOf(line, {
+    type: (value) => value === 'heartbeat',
+});
+export { isStreamHeartbeat };

package/dist/stream/isStreamRow.d.ts

@@ -0,0 +1,3 @@
+import type { StreamRow } from './StreamRow.js';
+declare const isStreamRow: (line: unknown) => line is StreamRow;
+export { isStreamRow };

package/dist/stream/isStreamRow.js

@@ -0,0 +1,6 @@
+import { hasShapeOf } from '../types/hasShapeOf.js';
+const isStreamRow = (line) => hasShapeOf(line, {
+    type: (value) => value === 'row',
+    payload: (value) => value !== undefined,
+});
+export { isStreamRow };

package/dist/stream/isStreamSubject.d.ts

@@ -0,0 +1,3 @@
+import type { StreamSubject } from './StreamSubject.js';
+declare const isStreamSubject: (line: unknown) => line is StreamSubject;
+export { isStreamSubject };

package/dist/stream/isStreamSubject.js

@@ -0,0 +1,9 @@
+import { hasShapeOf } from '../types/hasShapeOf.js';
+import { isString } from '../types/isString.js';
+const isStreamSubject = (line) => hasShapeOf(line, {
+    type: (value) => value === 'subject',
+    payload: {
+        subject: isString,
+    },
+});
+export { isStreamSubject };

package/dist/types/hasShapeOf.d.ts

@@ -0,0 +1,6 @@
+type Guard<T> = (x: unknown) => x is T;
+type Shape<T> = {
+    [K in keyof T]: T[K] extends object ? Shape<T[K]> | Guard<T[K]> : Guard<T[K]>;
+};
+declare const hasShapeOf: <T extends object>(value: unknown, shape: Shape<T>) => value is T;
+export { hasShapeOf };

package/dist/types/hasShapeOf.js

@@ -0,0 +1,25 @@
+import { isRecord } from './isRecord.js';
+const hasShapeOf = (value, shape) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    for (const key of Object.keys(shape)) {
+        const spec = shape[key];
+        const val = value[key];
+        if (typeof spec === 'function') {
+            const guard = spec;
+            if (!guard(val)) {
+                return false;
+            }
+            continue;
+        }
+        if (!isRecord(val)) {
+            return false;
+        }
+        if (!hasShapeOf(val, spec)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { hasShapeOf };

package/dist/types/isBoolean.d.ts

@@ -0,0 +1,2 @@
+declare const isBoolean: (value: unknown) => value is boolean;
+export { isBoolean };

package/dist/types/isBoolean.js

@@ -0,0 +1,7 @@
+const isBoolean = (value) => {
+    if (typeof value !== 'boolean') {
+        return false;
+    }
+    return true;
+};
+export { isBoolean };

package/dist/types/isRecord.d.ts

@@ -0,0 +1,2 @@
+declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export { isRecord };