eventsourcingdb 1.10.0 → 2.0.1

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/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/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/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/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/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 };

package/dist/http/trackSending.js

@@ -0,0 +1,46 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import diagnosticsChannel from 'node:diagnostics_channel';
+const currentSending = new AsyncLocalStorage();
+const sendingByRequest = new WeakMap();
+const getRequest = (message) => {
+    if (typeof message !== 'object' || message === null || !('request' in message)) {
+        return;
+    }
+    const { request } = message;
+    if (typeof request !== 'object' || request === null) {
+        return;
+    }
+    return request;
+};
+// The fetch built into Node.js creates its request within the call of fetch,
+// so the request belongs to the write that runs there.
+diagnosticsChannel.subscribe('undici:request:create', (message) => {
+    const sending = currentSending.getStore();
+    const request = getRequest(message);
+    if (sending === undefined || request === undefined || sending.state !== 'unknown') {
+        return;
+    }
+    sending.state = 'created';
+    sendingByRequest.set(request, sending);
+});
+diagnosticsChannel.subscribe('undici:client:sendHeaders', (message) => {
+    const request = getRequest(message);
+    const sending = request === undefined ? undefined : sendingByRequest.get(request);
+    if (sending !== undefined) {
+        sending.state = 'sent';
+    }
+});
+// Runs a write and tells, if it fails, whether its request certainly did not
+// reach the server, since it was created but its headers never went out. If
+// the client cannot tell, for example since fetch is not the one built into
+// Node.js, the request counts as sent.
+const trackSending = async (write) => {
+    const sending = { state: 'unknown' };
+    try {
+        return { result: await currentSending.run(sending, write) };
+    }
+    catch (error) {
+        return { error, hasBeenSent: sending.state !== 'created' };
+    }
+};
+export { trackSending };

package/dist/http/waitUnlessAborted.d.ts

@@ -0,0 +1,2 @@
+declare const waitUnlessAborted: <TResult>(promise: Promise<TResult>, signal?: AbortSignal) => Promise<TResult>;
+export { waitUnlessAborted };

package/dist/http/waitUnlessAborted.js

@@ -0,0 +1,21 @@
+// Waits for a promise that other callers may share, unless the signal of this
+// caller aborts first, which then rejects with its reason, while the promise
+// goes on for the others.
+const waitUnlessAborted = async (promise, signal) => {
+    if (signal === undefined) {
+        return await promise;
+    }
+    signal.throwIfAborted();
+    const aborted = Promise.withResolvers();
+    const onAbort = () => {
+        aborted.reject(signal.reason);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    try {
+        return await Promise.race([promise, aborted.promise]);
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+    }
+};
+export { waitUnlessAborted };

package/dist/index.d.ts

@@ -2,19 +2,23 @@ import { Client } from './Client.js';
 import type { ClientOptions } from './ClientOptions.js';
 import { ConnectionStalledError } from './ConnectionStalledError.js';
 import { Container } from './Container.js';
+import type { DbApiErrorOptions } from './DbApiError.js';
+import { DbApiError } from './DbApiError.js';
+import { ErrorCode } from './ErrorCode.js';
 import type { Event } from './Event.js';
 import type { EventCandidate } from './EventCandidate.js';
 import type { EventType } from './EventType.js';
 import { HashVerificationFailedError } from './HashVerificationFailedError.js';
-import { HeartbeatTimeoutError } from './HeartbeatTimeoutError.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 { OutcomeUnknownError } from './OutcomeUnknownError.js';
 import type { Precondition } from './Precondition.js';
 import type { ReadEventsOptions } from './ReadEventsOptions.js';
+import type { ReadSubjectsOptions } from './ReadSubjectsOptions.js';
 import { SignatureVerificationFailedError } from './SignatureVerificationFailedError.js';
 import { UnsupportedHashVersionError } from './UnsupportedHashVersionError.js';
-export type { ClientOptions, Event, EventCandidate, EventType, ObserveEventsOptions, Precondition, ReadEventsOptions, };
-export { Client, ConnectionStalledError, Container, HashVerificationFailedError, HeartbeatTimeoutError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, SignatureVerificationFailedError, UnsupportedHashVersionError, };
+export type { ClientOptions, DbApiErrorOptions, Event, EventCandidate, EventType, ObserveEventsOptions, Precondition, ReadEventsOptions, ReadSubjectsOptions, };
+export { Client, ConnectionStalledError, Container, DbApiError, ErrorCode, HashVerificationFailedError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, OutcomeUnknownError, SignatureVerificationFailedError, UnsupportedHashVersionError, };

package/dist/index.js

@@ -1,12 +1,14 @@
 import { Client } from './Client.js';
 import { ConnectionStalledError } from './ConnectionStalledError.js';
 import { Container } from './Container.js';
+import { DbApiError } from './DbApiError.js';
+import { ErrorCode } from './ErrorCode.js';
 import { HashVerificationFailedError } from './HashVerificationFailedError.js';
-import { HeartbeatTimeoutError } from './HeartbeatTimeoutError.js';
 import { isEventQlQueryTrue } from './isEventQlQueryTrue.js';
 import { isSubjectOnEventId } from './isSubjectOnEventId.js';
 import { isSubjectPopulated } from './isSubjectPopulated.js';
 import { isSubjectPristine } from './isSubjectPristine.js';
+import { OutcomeUnknownError } from './OutcomeUnknownError.js';
 import { SignatureVerificationFailedError } from './SignatureVerificationFailedError.js';
 import { UnsupportedHashVersionError } from './UnsupportedHashVersionError.js';
-export { Client, ConnectionStalledError, Container, HashVerificationFailedError, HeartbeatTimeoutError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, SignatureVerificationFailedError, UnsupportedHashVersionError, };
+export { Client, ConnectionStalledError, Container, DbApiError, ErrorCode, HashVerificationFailedError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, OutcomeUnknownError, SignatureVerificationFailedError, UnsupportedHashVersionError, };

package/dist/stall/StallGuard.d.ts

@@ -3,7 +3,6 @@ declare class StallGuard {
     constructor(stallTimeout: number, callerSignal?: AbortSignal);
     get signal(): AbortSignal;
     send(url: string, init: RequestInit): Promise<Response>;
-    onStall(createStallError: () => Error): void;
     restart(): void;
     pause(): void;
     throwIfStalled(): void;

package/dist/stall/StallGuard.js

@@ -9,7 +9,6 @@ class StallGuard {
     #stallTimeout;
     #controller = new AbortController();
     #callerSignal;
-    #createStallError;
     #phase = 'headers';
     #stallError;
     #timer;
@@ -19,9 +18,6 @@ class StallGuard {
     constructor(stallTimeout, callerSignal) {
         this.#stallTimeout = stallTimeout;
         this.#callerSignal = callerSignal;
-        this.#createStallError = () => new ConnectionStalledError(stallTimeout, {
-            cause: createFetchTimeoutError(this.#phase),
-        });
         if (callerSignal?.aborted) {
             this.#onCallerAbort();
         }
@@ -42,10 +38,6 @@ class StallGuard {
         this.restart();
         return response;
     }
-    // From now on, a stall ends the request with the error that this creates.
-    onStall(createStallError) {
-        this.#createStallError = createStallError;
-    }
     // Starts the clock, or starts it anew, since something arrived.
     restart() {
         if (this.#controller.signal.aborted) {
@@ -56,7 +48,9 @@ class StallGuard {
         this.pause();
         this.#timer = setTimeout(() => {
             this.#timer = undefined;
-            this.#stallError = this.#createStallError();
+            this.#stallError = new ConnectionStalledError(this.#stallTimeout, {
+                cause: createFetchTimeoutError(this.#phase),
+            });
             this.#controller.abort(this.#stallError);
         }, this.#stallTimeout);
     }

package/dist/stall/streamWithStallGuard.d.ts

@@ -0,0 +1,6 @@
+import { StallGuard } from './StallGuard.js';
+declare const streamWithStallGuard: <TItem>({ stallTimeout, signal }: {
+    stallTimeout: number;
+    signal?: AbortSignal;
+}, stream: (stallGuard: StallGuard) => AsyncGenerator<TItem, void, void>) => AsyncGenerator<TItem, void, void>;
+export { streamWithStallGuard };

package/dist/stall/streamWithStallGuard.js

@@ -0,0 +1,25 @@
+import { isAbortError } from '../http/isAbortError.js';
+import { StallGuard } from './StallGuard.js';
+// Runs a request that is a stream under a stall guard. If the request stalls,
+// the stream fails with the error of the stall, whatever fetch throws then. If
+// the caller aborts, the stream ends without an error. Ending the stream early
+// closes the connection of the request.
+const streamWithStallGuard = async function* ({ stallTimeout, signal }, stream) {
+    const stallGuard = new StallGuard(stallTimeout, signal);
+    try {
+        stallGuard.restart();
+        yield* stream(stallGuard);
+        stallGuard.throwIfStalled();
+    }
+    catch (error) {
+        stallGuard.throwIfStalled();
+        if (isAbortError(error)) {
+            return;
+        }
+        throw error;
+    }
+    finally {
+        stallGuard.dispose({ abortRequest: true });
+    }
+};
+export { streamWithStallGuard };

package/dist/v1/V1Transport.d.ts

@@ -0,0 +1,23 @@
+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';
+import type { Transport, TransportOptions } from '../Transport.js';
+declare class V1Transport implements Transport {
+    #private;
+    constructor({ url, apiToken, stallTimeout }: TransportOptions);
+    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, { recursive }: ReadSubjectsOptions, signal?: AbortSignal): AsyncGenerator<string, void, void>;
+    readEventType(eventType: string, signal?: AbortSignal): Promise<EventType>;
+    readEventTypes(signal?: AbortSignal): AsyncGenerator<EventType, void, void>;
+}
+export { V1Transport };