eventsourcingdb 1.9.1 → 2.0.0

package/dist/ErrorCode.d.ts

@@ -0,0 +1,68 @@
+declare const ErrorCode: {
+    readonly subjectMissing: 'https://docs.eventsourcingdb.io/errors/subject-missing';
+    readonly subjectMalformed: 'https://docs.eventsourcingdb.io/errors/subject-malformed';
+    readonly orderUnknown: 'https://docs.eventsourcingdb.io/errors/order-unknown';
+    readonly eventIdMissing: 'https://docs.eventsourcingdb.io/errors/event-id-missing';
+    readonly eventIdMalformed: 'https://docs.eventsourcingdb.io/errors/event-id-malformed';
+    readonly boundTypeMissing: 'https://docs.eventsourcingdb.io/errors/bound-type-missing';
+    readonly boundTypeUnknown: 'https://docs.eventsourcingdb.io/errors/bound-type-unknown';
+    readonly rangeUnsatisfiable: 'https://docs.eventsourcingdb.io/errors/range-unsatisfiable';
+    readonly fromLatestEventIncomplete: 'https://docs.eventsourcingdb.io/errors/from-latest-event-incomplete';
+    readonly ifEventIsMissingUnknown: 'https://docs.eventsourcingdb.io/errors/if-event-is-missing-unknown';
+    readonly selectionConflicting: 'https://docs.eventsourcingdb.io/errors/selection-conflicting';
+    readonly eventTypeMissing: 'https://docs.eventsourcingdb.io/errors/event-type-missing';
+    readonly eventTypeMalformed: 'https://docs.eventsourcingdb.io/errors/event-type-malformed';
+    readonly eventTypeUnknown: 'https://docs.eventsourcingdb.io/errors/event-type-unknown';
+    readonly sourceMissing: 'https://docs.eventsourcingdb.io/errors/source-missing';
+    readonly sourceMalformed: 'https://docs.eventsourcingdb.io/errors/source-malformed';
+    readonly dataMissing: 'https://docs.eventsourcingdb.io/errors/data-missing';
+    readonly traceparentMalformed: 'https://docs.eventsourcingdb.io/errors/traceparent-malformed';
+    readonly tracestateMalformed: 'https://docs.eventsourcingdb.io/errors/tracestate-malformed';
+    readonly tracestateWithoutTraceparent: 'https://docs.eventsourcingdb.io/errors/tracestate-without-traceparent';
+    readonly eventsMissing: 'https://docs.eventsourcingdb.io/errors/events-missing';
+    readonly preconditionTypeMissing: 'https://docs.eventsourcingdb.io/errors/precondition-type-missing';
+    readonly preconditionUnknown: 'https://docs.eventsourcingdb.io/errors/precondition-unknown';
+    readonly payloadMissing: 'https://docs.eventsourcingdb.io/errors/payload-missing';
+    readonly licenseInvalid: 'https://docs.eventsourcingdb.io/errors/license-invalid';
+    readonly capacityExceeded: 'https://docs.eventsourcingdb.io/errors/capacity-exceeded';
+    readonly eventSchemaViolated: 'https://docs.eventsourcingdb.io/errors/event-schema-violated';
+    readonly eventSchemaUnregistered: 'https://docs.eventsourcingdb.io/errors/event-schema-unregistered';
+    readonly eventSchemaMissing: 'https://docs.eventsourcingdb.io/errors/event-schema-missing';
+    readonly eventSchemaMalformed: 'https://docs.eventsourcingdb.io/errors/event-schema-malformed';
+    readonly eventSchemaNotObject: 'https://docs.eventsourcingdb.io/errors/event-schema-not-object';
+    readonly eventSchemaAlreadyRegistered: 'https://docs.eventsourcingdb.io/errors/event-schema-already-registered';
+    readonly lastAuditedEventMissing: 'https://docs.eventsourcingdb.io/errors/last-audited-event-missing';
+    readonly lastAuditedEventMismatched: 'https://docs.eventsourcingdb.io/errors/last-audited-event-mismatched';
+    readonly lastAuditedEventUnknown: 'https://docs.eventsourcingdb.io/errors/last-audited-event-unknown';
+    readonly eventHashMissing: 'https://docs.eventsourcingdb.io/errors/event-hash-missing';
+    readonly eventHashMalformed: 'https://docs.eventsourcingdb.io/errors/event-hash-malformed';
+    readonly eventChainBroken: 'https://docs.eventsourcingdb.io/errors/event-chain-broken';
+    readonly lastBackedUpEventMissing: 'https://docs.eventsourcingdb.io/errors/last-backed-up-event-missing';
+    readonly lastBackedUpEventMismatched: 'https://docs.eventsourcingdb.io/errors/last-backed-up-event-mismatched';
+    readonly lastBackedUpEventUnknown: 'https://docs.eventsourcingdb.io/errors/last-backed-up-event-unknown';
+    readonly storeNotEmpty: 'https://docs.eventsourcingdb.io/errors/store-not-empty';
+    readonly eventHashVersionUnknown: 'https://docs.eventsourcingdb.io/errors/event-hash-version-unknown';
+    readonly backupMalformed: 'https://docs.eventsourcingdb.io/errors/backup-malformed';
+    readonly backupIncomplete: 'https://docs.eventsourcingdb.io/errors/backup-incomplete';
+    readonly backupFormatUnknown: 'https://docs.eventsourcingdb.io/errors/backup-format-unknown';
+    readonly fullBackupMissing: 'https://docs.eventsourcingdb.io/errors/full-backup-missing';
+    readonly backupIncrementDisconnected: 'https://docs.eventsourcingdb.io/errors/backup-increment-disconnected';
+    readonly backupFailed: 'https://docs.eventsourcingdb.io/errors/backup-failed';
+    readonly backupUnreadable: 'https://docs.eventsourcingdb.io/errors/backup-unreadable';
+    readonly eventTooLarge: 'https://docs.eventsourcingdb.io/errors/event-too-large';
+    readonly dataMalformed: 'https://docs.eventsourcingdb.io/errors/data-malformed';
+    readonly queryMissing: 'https://docs.eventsourcingdb.io/errors/query-missing';
+    readonly queryMalformed: 'https://docs.eventsourcingdb.io/errors/query-malformed';
+    readonly queryUnevaluable: 'https://docs.eventsourcingdb.io/errors/query-unevaluable';
+    readonly queryNotBoolean: 'https://docs.eventsourcingdb.io/errors/query-not-boolean';
+    readonly preconditionViolated: 'https://docs.eventsourcingdb.io/errors/precondition-violated';
+    readonly storeReadOnly: 'https://docs.eventsourcingdb.io/errors/store-read-only';
+    readonly readOnlyModeAlreadyEnabled: 'https://docs.eventsourcingdb.io/errors/read-only-mode-already-enabled';
+    readonly diskFull: 'https://docs.eventsourcingdb.io/errors/disk-full';
+    readonly restoreInProgress: 'https://docs.eventsourcingdb.io/errors/restore-in-progress';
+    readonly storeFailed: 'https://docs.eventsourcingdb.io/errors/store-failed';
+    readonly indexesRebuilding: 'https://docs.eventsourcingdb.io/errors/indexes-rebuilding';
+    readonly serverShuttingDown: 'https://docs.eventsourcingdb.io/errors/server-shutting-down';
+};
+type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+export { ErrorCode };

package/dist/ErrorCode.js

@@ -0,0 +1,70 @@
+// The codes of the errors that the server reports. A code is the URL of the
+// page that documents the error, exactly as the server sends it, so a caller
+// can tell errors apart by comparing the code of a DbApiError with these.
+const ErrorCode = {
+    subjectMissing: 'https://docs.eventsourcingdb.io/errors/subject-missing',
+    subjectMalformed: 'https://docs.eventsourcingdb.io/errors/subject-malformed',
+    orderUnknown: 'https://docs.eventsourcingdb.io/errors/order-unknown',
+    eventIdMissing: 'https://docs.eventsourcingdb.io/errors/event-id-missing',
+    eventIdMalformed: 'https://docs.eventsourcingdb.io/errors/event-id-malformed',
+    boundTypeMissing: 'https://docs.eventsourcingdb.io/errors/bound-type-missing',
+    boundTypeUnknown: 'https://docs.eventsourcingdb.io/errors/bound-type-unknown',
+    rangeUnsatisfiable: 'https://docs.eventsourcingdb.io/errors/range-unsatisfiable',
+    fromLatestEventIncomplete: 'https://docs.eventsourcingdb.io/errors/from-latest-event-incomplete',
+    ifEventIsMissingUnknown: 'https://docs.eventsourcingdb.io/errors/if-event-is-missing-unknown',
+    selectionConflicting: 'https://docs.eventsourcingdb.io/errors/selection-conflicting',
+    eventTypeMissing: 'https://docs.eventsourcingdb.io/errors/event-type-missing',
+    eventTypeMalformed: 'https://docs.eventsourcingdb.io/errors/event-type-malformed',
+    eventTypeUnknown: 'https://docs.eventsourcingdb.io/errors/event-type-unknown',
+    sourceMissing: 'https://docs.eventsourcingdb.io/errors/source-missing',
+    sourceMalformed: 'https://docs.eventsourcingdb.io/errors/source-malformed',
+    dataMissing: 'https://docs.eventsourcingdb.io/errors/data-missing',
+    traceparentMalformed: 'https://docs.eventsourcingdb.io/errors/traceparent-malformed',
+    tracestateMalformed: 'https://docs.eventsourcingdb.io/errors/tracestate-malformed',
+    tracestateWithoutTraceparent: 'https://docs.eventsourcingdb.io/errors/tracestate-without-traceparent',
+    eventsMissing: 'https://docs.eventsourcingdb.io/errors/events-missing',
+    preconditionTypeMissing: 'https://docs.eventsourcingdb.io/errors/precondition-type-missing',
+    preconditionUnknown: 'https://docs.eventsourcingdb.io/errors/precondition-unknown',
+    payloadMissing: 'https://docs.eventsourcingdb.io/errors/payload-missing',
+    licenseInvalid: 'https://docs.eventsourcingdb.io/errors/license-invalid',
+    capacityExceeded: 'https://docs.eventsourcingdb.io/errors/capacity-exceeded',
+    eventSchemaViolated: 'https://docs.eventsourcingdb.io/errors/event-schema-violated',
+    eventSchemaUnregistered: 'https://docs.eventsourcingdb.io/errors/event-schema-unregistered',
+    eventSchemaMissing: 'https://docs.eventsourcingdb.io/errors/event-schema-missing',
+    eventSchemaMalformed: 'https://docs.eventsourcingdb.io/errors/event-schema-malformed',
+    eventSchemaNotObject: 'https://docs.eventsourcingdb.io/errors/event-schema-not-object',
+    eventSchemaAlreadyRegistered: 'https://docs.eventsourcingdb.io/errors/event-schema-already-registered',
+    lastAuditedEventMissing: 'https://docs.eventsourcingdb.io/errors/last-audited-event-missing',
+    lastAuditedEventMismatched: 'https://docs.eventsourcingdb.io/errors/last-audited-event-mismatched',
+    lastAuditedEventUnknown: 'https://docs.eventsourcingdb.io/errors/last-audited-event-unknown',
+    eventHashMissing: 'https://docs.eventsourcingdb.io/errors/event-hash-missing',
+    eventHashMalformed: 'https://docs.eventsourcingdb.io/errors/event-hash-malformed',
+    eventChainBroken: 'https://docs.eventsourcingdb.io/errors/event-chain-broken',
+    lastBackedUpEventMissing: 'https://docs.eventsourcingdb.io/errors/last-backed-up-event-missing',
+    lastBackedUpEventMismatched: 'https://docs.eventsourcingdb.io/errors/last-backed-up-event-mismatched',
+    lastBackedUpEventUnknown: 'https://docs.eventsourcingdb.io/errors/last-backed-up-event-unknown',
+    storeNotEmpty: 'https://docs.eventsourcingdb.io/errors/store-not-empty',
+    eventHashVersionUnknown: 'https://docs.eventsourcingdb.io/errors/event-hash-version-unknown',
+    backupMalformed: 'https://docs.eventsourcingdb.io/errors/backup-malformed',
+    backupIncomplete: 'https://docs.eventsourcingdb.io/errors/backup-incomplete',
+    backupFormatUnknown: 'https://docs.eventsourcingdb.io/errors/backup-format-unknown',
+    fullBackupMissing: 'https://docs.eventsourcingdb.io/errors/full-backup-missing',
+    backupIncrementDisconnected: 'https://docs.eventsourcingdb.io/errors/backup-increment-disconnected',
+    backupFailed: 'https://docs.eventsourcingdb.io/errors/backup-failed',
+    backupUnreadable: 'https://docs.eventsourcingdb.io/errors/backup-unreadable',
+    eventTooLarge: 'https://docs.eventsourcingdb.io/errors/event-too-large',
+    dataMalformed: 'https://docs.eventsourcingdb.io/errors/data-malformed',
+    queryMissing: 'https://docs.eventsourcingdb.io/errors/query-missing',
+    queryMalformed: 'https://docs.eventsourcingdb.io/errors/query-malformed',
+    queryUnevaluable: 'https://docs.eventsourcingdb.io/errors/query-unevaluable',
+    queryNotBoolean: 'https://docs.eventsourcingdb.io/errors/query-not-boolean',
+    preconditionViolated: 'https://docs.eventsourcingdb.io/errors/precondition-violated',
+    storeReadOnly: 'https://docs.eventsourcingdb.io/errors/store-read-only',
+    readOnlyModeAlreadyEnabled: 'https://docs.eventsourcingdb.io/errors/read-only-mode-already-enabled',
+    diskFull: 'https://docs.eventsourcingdb.io/errors/disk-full',
+    restoreInProgress: 'https://docs.eventsourcingdb.io/errors/restore-in-progress',
+    storeFailed: 'https://docs.eventsourcingdb.io/errors/store-failed',
+    indexesRebuilding: 'https://docs.eventsourcingdb.io/errors/indexes-rebuilding',
+    serverShuttingDown: 'https://docs.eventsourcingdb.io/errors/server-shutting-down',
+};
+export { ErrorCode };

package/dist/Event.d.ts

@@ -14,7 +14,7 @@ declare class Event {
     traceparent?: string;
     tracestate?: string;
     signature: string | null;
-    constructor({ specversion, id, time, timeFromServer, source, subject, type, datacontenttype, data, hash, predecessorhash, traceparent, tracestate, signature, }: {
+    constructor({ specversion, id, time, timeFromServer, source, subject, type, datacontenttype, data, dataFromServer, hash, predecessorhash, traceparent, tracestate, signature, }: {
         specversion: string;
         id: string;
         time: Date;
@@ -24,6 +24,7 @@ declare class Event {
         type: string;
         datacontenttype: string;
         data: Record<string, unknown>;
+        dataFromServer: string;
         hash: string;
         predecessorhash: string;
         traceparent?: string;

package/dist/Event.js

@@ -1,4 +1,16 @@
 import crypto from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { HashVerificationFailedError } from './HashVerificationFailedError.js';
+import { SignatureVerificationFailedError } from './SignatureVerificationFailedError.js';
+import { UnsupportedHashVersionError } from './UnsupportedHashVersionError.js';
+// A hash of version 2 starts with this prefix. A hash without a prefix is of
+// version 1, which predates the prefix.
+const hashVersion2Prefix = 'esdb:hash:v2:';
+const hashVersionRegex = /^esdb:hash:(?<version>[^:]*):/u;
+// The input of a hash of version 2 writes a field that the event does not
+// have like this.
+const missingField = '-';
+const getSha256 = (input) => crypto.createHash('sha256').update(input).digest('hex');
 class Event {
     specversion;
     id;
@@ -9,12 +21,13 @@ class Event {
     type;
     datacontenttype;
     data;
+    #dataFromServer;
     hash;
     predecessorhash;
     traceparent;
     tracestate;
     signature;
-    constructor({ specversion, id, time, timeFromServer, source, subject, type, datacontenttype, data, hash, predecessorhash, traceparent, tracestate, signature, }) {
+    constructor({ specversion, id, time, timeFromServer, source, subject, type, datacontenttype, data, dataFromServer, hash, predecessorhash, traceparent, tracestate, signature, }) {
         this.specversion = specversion;
         this.id = id;
         this.time = time;
@@ -24,22 +37,56 @@ class Event {
         this.type = type;
         this.datacontenttype = datacontenttype;
         this.data = data;
+        this.#dataFromServer = dataFromServer;
         this.hash = hash;
         this.predecessorhash = predecessorhash;
         this.traceparent = traceparent;
         this.tracestate = tracestate;
         this.signature = signature;
     }
-    verifyHash() {
+    #computeHashOfVersion1() {
         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.');
+        const metadataHash = getSha256(metadata);
+        const dataHash = getSha256(this.#dataFromServer);
+        return getSha256(`${metadataHash}${dataHash}`);
+    }
+    #computeHashOfVersion2() {
+        const input = [
+            hashVersion2Prefix,
+            this.specversion,
+            this.id,
+            this.predecessorhash,
+            this.#timeFromServer,
+            this.source,
+            this.subject,
+            this.type,
+            this.datacontenttype,
+            this.traceparent ?? missingField,
+            this.tracestate ?? missingField,
+            this.#dataFromServer,
+        ].join('\n');
+        return `${hashVersion2Prefix}${getSha256(input)}`;
+    }
+    // An event keeps the version of the hash it was written with, so the hash
+    // is computed in the version it names.
+    #computeHash() {
+        const version = hashVersionRegex.exec(this.hash)?.groups?.version;
+        if (version === undefined) {
+            return this.#computeHashOfVersion1();
+        }
+        if (`esdb:hash:${version}:` === hashVersion2Prefix) {
+            return this.#computeHashOfVersion2();
+        }
+        throw new UnsupportedHashVersionError(version);
+    }
+    verifyHash() {
+        if (this.#computeHash() !== this.hash) {
+            throw new HashVerificationFailedError();
+        }
+        // The hash covers the data as the server sent it, so data that has been
+        // changed since would go unnoticed without comparing the two.
+        if (!isDeepStrictEqual(this.data, JSON.parse(this.#dataFromServer))) {
+            throw new HashVerificationFailedError();
         }
     }
     verifySignature(verificationKey) {
@@ -56,7 +103,7 @@ class Event {
         const hashBytes = Buffer.from(this.hash, 'utf8');
         const isSignatureValid = crypto.verify(null, hashBytes, verificationKey, signatureBytes);
         if (!isSignatureValid) {
-            throw new Error('Signature verification failed.');
+            throw new SignatureVerificationFailedError();
         }
     }
 }

package/dist/EventType.d.ts

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

package/dist/HashVerificationFailedError.d.ts

@@ -0,0 +1,4 @@
+declare class HashVerificationFailedError extends Error {
+    constructor();
+}
+export { HashVerificationFailedError };

package/dist/HashVerificationFailedError.js

@@ -0,0 +1,7 @@
+class HashVerificationFailedError extends Error {
+    constructor() {
+        super('Failed to verify hash.');
+        this.name = 'HashVerificationFailedError';
+    }
+}
+export { HashVerificationFailedError };

package/dist/OutcomeUnknownError.d.ts

@@ -0,0 +1,6 @@
+declare class OutcomeUnknownError extends Error {
+    constructor({ cause }: {
+        cause: unknown;
+    });
+}
+export { OutcomeUnknownError };

package/dist/OutcomeUnknownError.js

@@ -0,0 +1,9 @@
+// A write that failed once it may have reached the server, so it may have been
+// stored nonetheless. Its cause tells what went wrong.
+class OutcomeUnknownError extends Error {
+    constructor({ cause }) {
+        super('The write may or may not have been stored.', { cause });
+        this.name = 'OutcomeUnknownError';
+    }
+}
+export { OutcomeUnknownError };

package/dist/ReadSubjectsOptions.d.ts

@@ -0,0 +1,4 @@
+interface ReadSubjectsOptions {
+    recursive: boolean;
+}
+export type { ReadSubjectsOptions };

package/dist/SignatureVerificationFailedError.d.ts

@@ -0,0 +1,4 @@
+declare class SignatureVerificationFailedError extends Error {
+    constructor();
+}
+export { SignatureVerificationFailedError };

package/dist/SignatureVerificationFailedError.js

@@ -0,0 +1,7 @@
+class SignatureVerificationFailedError extends Error {
+    constructor() {
+        super('Signature verification failed.');
+        this.name = 'SignatureVerificationFailedError';
+    }
+}
+export { SignatureVerificationFailedError };

package/dist/Transport.d.ts

@@ -0,0 +1,25 @@
+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';
+import type { ReadSubjectsOptions } from './ReadSubjectsOptions.js';
+interface Transport {
+    ping: (signal?: AbortSignal) => Promise<void>;
+    verifyApiToken: (signal?: AbortSignal) => Promise<void>;
+    writeEvents: (events: EventCandidate[], preconditions: Precondition[], signal?: AbortSignal) => 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>, signal?: AbortSignal) => Promise<void>;
+    readSubjects: (subject: string, options: ReadSubjectsOptions, signal?: AbortSignal) => AsyncGenerator<string, void, void>;
+    readEventType: (eventType: string, signal?: AbortSignal) => Promise<EventType>;
+    readEventTypes: (signal?: AbortSignal) => AsyncGenerator<EventType, void, void>;
+}
+interface TransportOptions {
+    url: URL;
+    apiToken: string;
+    stallTimeout: number;
+}
+export type { Transport, TransportOptions };

package/dist/UnsupportedHashVersionError.d.ts

@@ -0,0 +1,4 @@
+declare class UnsupportedHashVersionError extends Error {
+    constructor(version: string);
+}
+export { UnsupportedHashVersionError };

package/dist/UnsupportedHashVersionError.js

@@ -0,0 +1,7 @@
+class UnsupportedHashVersionError extends Error {
+    constructor(version) {
+        super(`Hash version '${version}' is not supported.`);
+        this.name = 'UnsupportedHashVersionError';
+    }
+}
+export { UnsupportedHashVersionError };

package/dist/convertCloudEventToEvent.d.ts

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

package/dist/convertCloudEventToEvent.js

@@ -1,5 +1,8 @@
 import { Event } from './Event.js';
-const convertCloudEventToEvent = (cloudEvent) => new Event({
+import { getRawJsonMember } from './json/getRawJsonMember.js';
+// The hash of an event covers its data exactly as the server sent it, so the
+// event keeps the data from the text of the cloud event, byte for byte.
+const convertCloudEventToEvent = (cloudEvent, cloudEventText) => new Event({
     specversion: cloudEvent.specversion,
     id: cloudEvent.id,
     time: new Date(cloudEvent.time),
@@ -9,6 +12,8 @@ const convertCloudEventToEvent = (cloudEvent) => new Event({
     type: cloudEvent.type,
     datacontenttype: cloudEvent.datacontenttype,
     data: cloudEvent.data,
+    dataFromServer: (cloudEventText === undefined ? undefined : getRawJsonMember(cloudEventText, 'data')) ??
+        JSON.stringify(cloudEvent.data),
     hash: cloudEvent.hash,
     predecessorhash: cloudEvent.predecessorhash,
     traceparent: cloudEvent.traceparent,

package/dist/detectApiVersion.d.ts

@@ -0,0 +1,7 @@
+type ApiVersion = 'v1' | 'v2';
+declare const detectApiVersion: ({ url, stallTimeout, }: {
+    url: URL;
+    stallTimeout: number;
+}) => Promise<ApiVersion>;
+export type { ApiVersion };
+export { detectApiVersion };

package/dist/detectApiVersion.js

@@ -0,0 +1,47 @@
+import { assertEventSourcingDb } from './http/assertEventSourcingDb.js';
+import { createDbApiErrorFromResponse } from './http/createDbApiErrorFromResponse.js';
+import { readResponseText } from './stall/readResponseText.js';
+import { runWithStallGuard } from './stall/runWithStallGuard.js';
+import { hasShapeOf } from './types/hasShapeOf.js';
+import { isString } from './types/isString.js';
+// An answer that is not JSON is not a ping, so it parses as null.
+const parseJson = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+};
+const statusNotFound = 404;
+const statusMethodNotAllowed = 405;
+// Finds out whether the server offers the v2 API, by pinging it there. A
+// server that offers only the v1 API, as EventSourcingDB 1.2.0 does, answers
+// a path of the v2 API with the status 404 or 405. Every other answer than
+// these and a ping of the v2 API fails, so that the next request asks again.
+const detectApiVersion = async ({ url, stallTimeout, }) => await runWithStallGuard({ stallTimeout }, async (stallGuard) => {
+    const response = await stallGuard.send(new URL('/api/v2/system/ping', url).toString(), {
+        method: 'GET',
+    });
+    if (response.status === statusNotFound || response.status === statusMethodNotAllowed) {
+        await readResponseText(response, stallGuard);
+        return 'v1';
+    }
+    assertEventSourcingDb(response);
+    if (response.status !== 200) {
+        throw await createDbApiErrorFromResponse(response, stallGuard);
+    }
+    const responseBody = parseJson(await readResponseText(response, stallGuard));
+    if (!hasShapeOf(responseBody, {
+        type: isString,
+        data: {
+            type: isString,
+        },
+    }) ||
+        responseBody.type !== 'event' ||
+        responseBody.data.type !== 'io.eventsourcingdb.api.ping-received') {
+        throw new Error('Failed to find out which API the server offers.');
+    }
+    return 'v2';
+});
+export { detectApiVersion };

package/dist/getImageTag.d.ts

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

package/dist/getImageTag.js

@@ -0,0 +1,13 @@
+import process from 'node:process';
+import { getImageVersionFromDockerfile } from './getImageVersionFromDockerfile.js';
+// The tests run against the image tag that EVENTSOURCINGDB_IMAGE_TAG names, so
+// that the pipeline can run them against several tags. Without the variable,
+// they run against the tag that the Dockerfile names.
+const getImageTag = () => {
+    const imageTag = process.env.EVENTSOURCINGDB_IMAGE_TAG;
+    if (imageTag !== undefined && imageTag !== '') {
+        return imageTag;
+    }
+    return getImageVersionFromDockerfile();
+};
+export { getImageTag };

package/dist/http/assertEventSourcingDb.d.ts

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

package/dist/http/assertEventSourcingDb.js

@@ -0,0 +1,14 @@
+import { isValidServerHeader } from '../isValidServerHeader.js';
+// Fails unless the response comes from EventSourcingDB, which names itself in
+// the Server header.
+const assertEventSourcingDb = (response) => {
+    if (isValidServerHeader(response)) {
+        return;
+    }
+    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}'.`);
+};
+export { assertEventSourcingDb };

package/dist/http/createDbApiErrorFromResponse.d.ts

@@ -0,0 +1,4 @@
+import { DbApiError } from '../DbApiError.js';
+import type { StallGuard } from '../stall/StallGuard.js';
+declare const createDbApiErrorFromResponse: (response: Response, stallGuard: StallGuard, getCode?: (status: number, description: string) => string | undefined) => Promise<DbApiError>;
+export { createDbApiErrorFromResponse };

package/dist/http/createDbApiErrorFromResponse.js

@@ -0,0 +1,20 @@
+import { DbApiError } from '../DbApiError.js';
+import { readResponseText } from '../stall/readResponseText.js';
+import { parseRetryAfter } from './parseRetryAfter.js';
+const statusTooManyRequests = 429;
+// Creates the error for a response with a status other than 200, whose body
+// is a text that describes the error. The text ends with a line break, which
+// is not part of the description.
+const createDbApiErrorFromResponse = async (response, stallGuard, getCode) => {
+    const { status } = response;
+    const description = (await readResponseText(response, stallGuard)).trim();
+    return new DbApiError({
+        status,
+        description,
+        code: getCode?.(status, description),
+        retryAfter: status === statusTooManyRequests
+            ? parseRetryAfter(response.headers.get('Retry-After'))
+            : undefined,
+    });
+};
+export { createDbApiErrorFromResponse };

package/dist/http/createStreamEndedError.d.ts

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

package/dist/http/createStreamEndedError.js

@@ -0,0 +1,6 @@
+// Creates the error for a stream that the server closed before it was done: a
+// finite stream that ends before its end item, or a stream of observed events,
+// which never ends on its own. Either broke off because of a failure that the
+// server did not report.
+const createStreamEndedError = (action) => new Error(`Failed to ${action}, since the stream ended unexpectedly.`);
+export { createStreamEndedError };

package/dist/http/isAbortError.d.ts

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

package/dist/http/isAbortError.js

@@ -0,0 +1,2 @@
+const isAbortError = (error) => error instanceof DOMException && error.name === 'AbortError';
+export { isAbortError };

package/dist/http/parseRetryAfter.d.ts

@@ -0,0 +1,2 @@
+declare const parseRetryAfter: (header: string | null) => number | undefined;
+export { parseRetryAfter };

package/dist/http/parseRetryAfter.js

@@ -0,0 +1,14 @@
+const secondsRegex = /^\d+$/u;
+// Returns the seconds that a Retry-After header names, or undefined if there
+// is no such header or it does not name seconds.
+const parseRetryAfter = (header) => {
+    if (header === null) {
+        return;
+    }
+    const value = header.trim();
+    if (!secondsRegex.test(value)) {
+        return;
+    }
+    return Number(value);
+};
+export { parseRetryAfter };

package/dist/http/runWrite.d.ts

@@ -0,0 +1,6 @@
+import { DbApiError } from '../DbApiError.js';
+declare const runWrite: <TResult>({ signal, isRefusal }: {
+    signal?: AbortSignal;
+    isRefusal: (error: DbApiError) => boolean;
+}, write: () => Promise<TResult>) => Promise<TResult>;
+export { runWrite };

package/dist/http/runWrite.js

@@ -0,0 +1,25 @@
+import { DbApiError } from '../DbApiError.js';
+import { OutcomeUnknownError } from '../OutcomeUnknownError.js';
+import { trackSending } from './trackSending.js';
+// Runs a write that has not been sent yet. A write certainly was not stored if
+// it failed before its request went out, whether the caller aborted it, it
+// stalled, or it could not establish a connection, or if the server refused
+// it, which isRefusal tells for an error that the server reports. Every other
+// failure may come after the server stored the write, so it fails with an
+// OutcomeUnknownError that wraps it.
+const runWrite = async ({ signal, isRefusal }, write) => {
+    signal?.throwIfAborted();
+    const outcome = await trackSending(write);
+    if ('result' in outcome) {
+        return outcome.result;
+    }
+    const { error, hasBeenSent } = outcome;
+    if (!hasBeenSent) {
+        throw error;
+    }
+    if (error instanceof DbApiError && isRefusal(error)) {
+        throw error;
+    }
+    throw new OutcomeUnknownError({ cause: error });
+};
+export { runWrite };

package/dist/http/trackSending.d.ts

@@ -0,0 +1,7 @@
+declare const trackSending: <TResult>(write: () => Promise<TResult>) => Promise<{
+    result: TResult;
+} | {
+    error: unknown;
+    hasBeenSent: boolean;
+}>;
+export { trackSending };