@cratis/chronicle 3.0.0 → 3.1.0

package/eventSequences/IEventSequence.ts

@@ -1,7 +1,11 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+import type { Constructor } from '@cratis/fundamentals';
+import type { AppendedEvent } from '../events/AppendedEvent';
+import { AppendedEventWithResult } from './AppendedEventWithResult';
 import { AppendOptions } from './AppendOptions';
+import { CompleteStreamResult } from './CompleteStreamResult';
 import { EventForEventSourceId } from './EventForEventSourceId';
 import { AppendResult } from './AppendResult';
 import { EventSequenceId } from './EventSequenceId';
@@ -18,6 +22,18 @@ export interface IEventSequence {
     /** Transactional append operations for this event sequence. */
     readonly transactional: ITransactionalEventSequence;
 
+    /**
+     * A hot, multicast async iterable that yields the events appended through this specific
+     * {@link IEventSequence} instance, together with their result, after each {@link append} or
+     * {@link appendMany} call completes (whether it succeeded or failed). A single-event append
+     * yields an array of one element; a batch append yields the full batch.
+     * @remarks
+     * This does not fire for transactional appends through `transactional`. Values are only
+     * published while at least one consumer is iterating — there is no replay buffer, so a
+     * consumer that starts iterating after an append misses it.
+     */
+    readonly appendOperations: AsyncIterable<AppendedEventWithResult[]>;
+
     /**
      * Appends a single event to the event sequence.
      * @param eventSourceId - The identifier of the event source.
@@ -44,12 +60,36 @@ export interface IEventSequence {
      */
     appendMany(events: EventForEventSourceId[], options?: AppendOptions): Promise<AppendResult[]>;
 
+    /**
+     * Gets the next sequence number that will be assigned to the next appended event.
+     * @returns The next sequence number.
+     */
+    getNextSequenceNumber(): Promise<EventSequenceNumber>;
+
     /**
      * Gets the tail sequence number (the number of the most recently appended event).
      * @param eventSourceId - Optional event source identifier to filter by.
+     * @param eventSourceType - Optional event source type to filter by.
+     * @param eventStreamType - Optional event stream type to filter by.
+     * @param eventStreamId - Optional event stream identifier to filter by.
+     * @param filterEventTypes - Optional collection of event type constructors to filter by.
      * @returns The tail sequence number.
      */
-    getTailSequenceNumber(eventSourceId?: string): Promise<EventSequenceNumber>;
+    getTailSequenceNumber(
+        eventSourceId?: string,
+        eventSourceType?: string,
+        eventStreamType?: string,
+        eventStreamId?: string,
+        filterEventTypes?: Constructor[]
+    ): Promise<EventSequenceNumber>;
+
+    /**
+     * Gets the tail sequence number for a specific observer (reactor/reducer) type, based on the
+     * tail of the event types the observer handles.
+     * @param observerType - The observer (reactor/reducer) type to get the tail sequence number for.
+     * @returns The tail sequence number.
+     */
+    getTailSequenceNumberForObserver(observerType: Constructor): Promise<EventSequenceNumber>;
 
     /**
      * Determines whether there are events for a given event source identifier.
@@ -57,4 +97,72 @@ export interface IEventSequence {
      * @returns True if there are events for the given event source.
      */
     hasEventsFor(eventSourceId: string): Promise<boolean>;
+
+    /**
+     * Gets all events for a specific event source, optionally filtered to specific event types.
+     * @param eventSourceId - The event source identifier to get events for.
+     * @param eventTypes - Collection of event type constructors to filter by.
+     * @param eventStreamType - Optional event stream type. Defaults to the default stream type.
+     * @param eventStreamId - Optional event stream identifier. Defaults to the default stream.
+     * @param eventSourceType - Optional event source type. Defaults to the default source type.
+     * @returns A collection of appended events.
+     */
+    getForEventSourceIdAndEventTypes(
+        eventSourceId: string,
+        eventTypes: Constructor[],
+        eventStreamType?: string,
+        eventStreamId?: string,
+        eventSourceType?: string
+    ): Promise<AppendedEvent[]>;
+
+    /**
+     * Gets all events after and including a given sequence number, optionally filtered by event
+     * source identifier and event types.
+     * @param sequenceNumber - The sequence number of the first event to get from.
+     * @param eventSourceId - Optional event source identifier to filter by.
+     * @param filterEventTypes - Optional collection of event type constructors to filter by.
+     * @returns A collection of appended events.
+     */
+    getFromSequenceNumber(
+        sequenceNumber: EventSequenceNumber,
+        eventSourceId?: string,
+        filterEventTypes?: Constructor[]
+    ): Promise<AppendedEvent[]>;
+
+    /**
+     * Redacts a single event at a specific sequence number.
+     * @param sequenceNumber - The sequence number of the event to redact.
+     * @param reason - The reason for redacting the event.
+     * @returns A promise that resolves when the redaction has completed.
+     * @remarks
+     * This is a permanent, destructive rewrite of the event's content — typically used to satisfy GDPR
+     * or other compliance erasure requirements. It is not a field-level mask.
+     */
+    redact(sequenceNumber: EventSequenceNumber, reason: string): Promise<void>;
+
+    /**
+     * Redacts all events for a specific event source, optionally filtered to specific event types.
+     * @param eventSourceId - The event source identifier to redact events for.
+     * @param reason - The reason for redacting the events.
+     * @param eventTypes - Optional collection of event type constructors to limit the redaction to.
+     * @returns A promise that resolves when the redaction has completed.
+     * @remarks
+     * This is a permanent, destructive rewrite of the events' content — typically used to satisfy GDPR
+     * or other compliance erasure requirements. It is not a field-level mask.
+     */
+    redactForEventSource(eventSourceId: string, reason: string, eventTypes?: Constructor[]): Promise<void>;
+
+    /**
+     * Completes a stream so that no further events can be appended to it.
+     * @param eventStreamType - The event stream type identifying the stream's type.
+     * @param eventStreamId - The event stream identifier identifying the stream within the type.
+     * @returns The tail sequence number at the moment of completion on success, or a typed error
+     * describing why the operation was rejected.
+     * @remarks
+     * The default stream can never be completed and will return `DefaultStreamCannotBeCompleted`.
+     * Completing an already-completed stream returns `AlreadyCompleted` and leaves the stream in its
+     * completed state. After a successful completion any subsequent append targeting the same stream
+     * results in a constraint violation of type `StreamClosed`.
+     */
+    completeStream(eventStreamType: string, eventStreamId: string): Promise<CompleteStreamResult>;
 }

package/eventSequences/WaitForCompletionResult.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { FailedPartition } from '../observation/FailedPartition';
+
+/**
+ * Represents the result of waiting for the observers affected by an append operation to catch up.
+ */
+export interface WaitForCompletionResult {
+    /** Whether all affected observers completed successfully. */
+    readonly isSuccess: boolean;
+
+    /** The failed partitions discovered while waiting, across all affected observers. */
+    readonly failedPartitions: ReadonlyArray<FailedPartition>;
+}

package/eventSequences/index.ts

@@ -4,11 +4,16 @@
 export { EventSequenceId } from './EventSequenceId';
 export { EventSequenceNumber } from './EventSequenceNumber';
 export type { AppendError } from './AppendError';
+export type { ConcurrencyViolation } from './ConcurrencyViolation';
 export type { ConstraintViolation } from './ConstraintViolation';
 export type { AppendResult } from './AppendResult';
+export type { AppendedEventWithResult } from './AppendedEventWithResult';
 export type { AppendOptions } from './AppendOptions';
+export { CompleteStreamError } from './CompleteStreamError';
+export type { CompleteStreamResult } from './CompleteStreamResult';
 export type { ConcurrencyScope } from './ConcurrencyScope';
 export type { EventForEventSourceId } from './EventForEventSourceId';
+export type { WaitForCompletionResult } from './WaitForCompletionResult';
 export type { IEventSequence } from './IEventSequence';
 export type { IEventLog } from './IEventLog';
 export type { ITransactionalEventSequence } from './ITransactionalEventSequence';

package/eventStoreSubscriptions/EventStoreSubscriptions.spec.ts

@@ -0,0 +1,52 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { describe, expect, it, vi } from 'vitest';
+import type { ChronicleConnection } from '../connection';
+import type { IEventTypes } from '../events';
+import { EventStoreSubscriptions } from './EventStoreSubscriptions';
+
+function createEventStoreSubscriptions(getSubscriptionsResult?: unknown) {
+    const getSubscriptions = vi.fn().mockResolvedValue(getSubscriptionsResult ?? { items: [] });
+    const connection = { eventStoreSubscriptions: { getSubscriptions } } as unknown as ChronicleConnection;
+    const eventTypes = {} as IEventTypes;
+    const subscriptions = new EventStoreSubscriptions(eventTypes, 'my-event-store', connection);
+    return { subscriptions, getSubscriptions };
+}
+
+describe('EventStoreSubscriptions', () => {
+    describe('when getting all subscriptions', () => {
+        const { subscriptions, getSubscriptions } = createEventStoreSubscriptions({
+            items: [{
+                Identifier: 'my-subscription',
+                SourceEventStore: 'source-event-store',
+                EventTypes: [{ Id: 'a3f6a2f0-6f2f-4a3c-9d3f-6f2f4a3c9d3f', Generation: 1, Tombstone: false }]
+            }]
+        });
+
+        it('should call the RPC with the target event store and map the response', async () => {
+            const result = await subscriptions.getAll();
+
+            expect(getSubscriptions).toHaveBeenCalledTimes(1);
+            const request = getSubscriptions.mock.calls[0][0];
+            expect(request.TargetEventStore).toEqual('my-event-store');
+
+            expect(result).toHaveLength(1);
+            expect(result[0].id.value).toEqual('my-subscription');
+            expect(result[0].sourceEventStore).toEqual('source-event-store');
+            expect(result[0].eventTypes).toHaveLength(1);
+            expect(result[0].eventTypes[0].id.value).toEqual('a3f6a2f0-6f2f-4a3c-9d3f-6f2f4a3c9d3f');
+            expect(result[0].eventTypes[0].generation.value).toEqual(1);
+        });
+    });
+
+    describe('when there are no subscriptions', () => {
+        const { subscriptions } = createEventStoreSubscriptions({ items: [] });
+
+        it('should return an empty array', async () => {
+            const result = await subscriptions.getAll();
+
+            expect(result).toEqual([]);
+        });
+    });
+});

package/eventStoreSubscriptions/EventStoreSubscriptions.ts

@@ -4,8 +4,9 @@
 import { diag } from '@opentelemetry/api';
 import { ChronicleConnection } from '../connection';
 import { EventStoreName } from '../EventStoreName';
-import { IEventTypes } from '../events';
+import { EventType, EventTypeGeneration, EventTypeId, IEventTypes } from '../events';
 import { EventStoreSubscriptionBuilder } from './EventStoreSubscriptionBuilder';
+import { EventStoreSubscriptionDefinition } from './EventStoreSubscriptionDefinition';
 import { EventStoreSubscriptionId } from './EventStoreSubscriptionId';
 import { IEventStoreSubscriptionBuilder } from './IEventStoreSubscriptionBuilder';
 import { IEventStoreSubscriptions } from './IEventStoreSubscriptions';
@@ -71,4 +72,21 @@ export class EventStoreSubscriptions implements IEventStoreSubscriptions {
             SubscriptionIds: [id]
         });
     }
+
+    /** @inheritdoc */
+    async getAll(): Promise<EventStoreSubscriptionDefinition[]> {
+        const response = await this._connection.eventStoreSubscriptions.getSubscriptions({
+            TargetEventStore: this._targetEventStore
+        });
+
+        return (response.items ?? []).map(definition => new EventStoreSubscriptionDefinition(
+            new EventStoreSubscriptionId(definition.Identifier),
+            definition.SourceEventStore,
+            (definition.EventTypes ?? []).map(eventType => new EventType(
+                new EventTypeId(eventType.Id),
+                new EventTypeGeneration(eventType.Generation),
+                eventType.Tombstone
+            ))
+        ));
+    }
 }

package/eventStoreSubscriptions/IEventStoreSubscriptions.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { EventStoreName } from '../EventStoreName';
+import { EventStoreSubscriptionDefinition } from './EventStoreSubscriptionDefinition';
 import { EventStoreSubscriptionId } from './EventStoreSubscriptionId';
 import { IEventStoreSubscriptionBuilder } from './IEventStoreSubscriptionBuilder';
 
@@ -26,4 +27,10 @@ export interface IEventStoreSubscriptions {
      * @param subscriptionId - The subscription identifier to remove.
      */
     unsubscribe(subscriptionId: EventStoreSubscriptionId | string): Promise<void>;
+
+    /**
+     * Gets all subscriptions registered for this event store.
+     * @returns A collection of {@link EventStoreSubscriptionDefinition}.
+     */
+    getAll(): Promise<EventStoreSubscriptionDefinition[]>;
 }

package/eventStoreSubscriptions/contracts.ts

@@ -28,6 +28,14 @@ export interface RemoveEventStoreSubscriptions {
     SubscriptionIds: string[];
 }
 
+export interface GetEventStoreSubscriptions {
+    TargetEventStore: string;
+}
+
+export interface IEnumerableEventStoreSubscriptionDefinitionContract {
+    items: EventStoreSubscriptionDefinitionContract[];
+}
+
 function createBaseEmpty(): Empty {
     return {};
 }
@@ -48,6 +56,14 @@ function createBaseRemoveEventStoreSubscriptions(): RemoveEventStoreSubscription
     return { TargetEventStore: '', SubscriptionIds: [] };
 }
 
+function createBaseGetEventStoreSubscriptions(): GetEventStoreSubscriptions {
+    return { TargetEventStore: '' };
+}
+
+function createBaseIEnumerableEventStoreSubscriptionDefinition(): IEnumerableEventStoreSubscriptionDefinitionContract {
+    return { items: [] };
+}
+
 export const EmptyMessage: MessageFns<Empty> = {
     encode(_: Empty, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
         return writer;
@@ -322,6 +338,100 @@ export const RemoveEventStoreSubscriptionsMessage: MessageFns<RemoveEventStoreSu
     }
 };
 
+export const GetEventStoreSubscriptionsMessage: MessageFns<GetEventStoreSubscriptions> = {
+    encode(message: GetEventStoreSubscriptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+        if (message.TargetEventStore !== '') {
+            writer.uint32(10).string(message.TargetEventStore);
+        }
+        return writer;
+    },
+    decode(input: BinaryReader | Uint8Array, length?: number): GetEventStoreSubscriptions {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGetEventStoreSubscriptions();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.TargetEventStore = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object: unknown): GetEventStoreSubscriptions {
+        const value = object as { TargetEventStore?: unknown };
+        return {
+            TargetEventStore: typeof value.TargetEventStore === 'string' ? value.TargetEventStore : ''
+        };
+    },
+    toJSON(message: GetEventStoreSubscriptions): unknown {
+        return {
+            TargetEventStore: message.TargetEventStore
+        };
+    },
+    create(base?: DeepPartial<GetEventStoreSubscriptions>): GetEventStoreSubscriptions {
+        return GetEventStoreSubscriptionsMessage.fromPartial(base ?? {});
+    },
+    fromPartial(object: DeepPartial<GetEventStoreSubscriptions>): GetEventStoreSubscriptions {
+        return {
+            TargetEventStore: object.TargetEventStore ?? ''
+        };
+    }
+};
+
+export const IEnumerableEventStoreSubscriptionDefinitionMessage: MessageFns<IEnumerableEventStoreSubscriptionDefinitionContract> = {
+    encode(message: IEnumerableEventStoreSubscriptionDefinitionContract, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+        for (const item of message.items) {
+            EventStoreSubscriptionDefinitionMessage.encode(item, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input: BinaryReader | Uint8Array, length?: number): IEnumerableEventStoreSubscriptionDefinitionContract {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseIEnumerableEventStoreSubscriptionDefinition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.items.push(EventStoreSubscriptionDefinitionMessage.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object: unknown): IEnumerableEventStoreSubscriptionDefinitionContract {
+        const value = object as { items?: unknown[] };
+        return {
+            items: Array.isArray(value.items)
+                ? value.items.map(_ => EventStoreSubscriptionDefinitionMessage.fromJSON(_))
+                : []
+        };
+    },
+    toJSON(message: IEnumerableEventStoreSubscriptionDefinitionContract): unknown {
+        return {
+            items: message.items.map(_ => EventStoreSubscriptionDefinitionMessage.toJSON(_))
+        };
+    },
+    create(base?: DeepPartial<IEnumerableEventStoreSubscriptionDefinitionContract>): IEnumerableEventStoreSubscriptionDefinitionContract {
+        return IEnumerableEventStoreSubscriptionDefinitionMessage.fromPartial(base ?? {});
+    },
+    fromPartial(object: DeepPartial<IEnumerableEventStoreSubscriptionDefinitionContract>): IEnumerableEventStoreSubscriptionDefinitionContract {
+        return {
+            items: object.items?.map(_ => EventStoreSubscriptionDefinitionMessage.fromPartial(_)) ?? []
+        };
+    }
+};
+
 export const EventStoreSubscriptionsDefinition = {
     name: 'EventStoreSubscriptions',
     fullName: 'Cratis.Chronicle.Contracts.Observation.EventStoreSubscriptions.EventStoreSubscriptions',
@@ -334,6 +444,14 @@ export const EventStoreSubscriptionsDefinition = {
             responseStream: false,
             options: {}
         },
+        getSubscriptions: {
+            name: 'GetSubscriptions',
+            requestType: GetEventStoreSubscriptionsMessage,
+            requestStream: false,
+            responseType: IEnumerableEventStoreSubscriptionDefinitionMessage,
+            responseStream: false,
+            options: {}
+        },
         remove: {
             name: 'Remove',
             requestType: RemoveEventStoreSubscriptionsMessage,
@@ -347,11 +465,19 @@ export const EventStoreSubscriptionsDefinition = {
 
 export interface EventStoreSubscriptionsClient<CallOptionsExt = {}> {
     add(request: DeepPartial<AddEventStoreSubscriptions>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+    getSubscriptions(
+        request: DeepPartial<GetEventStoreSubscriptions>,
+        options?: CallOptions & CallOptionsExt
+    ): Promise<IEnumerableEventStoreSubscriptionDefinitionContract>;
     remove(request: DeepPartial<RemoveEventStoreSubscriptions>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
 }
 
 export interface EventStoreSubscriptionsServiceImplementation<CallContextExt = {}> {
     add(request: AddEventStoreSubscriptions, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
+    getSubscriptions(
+        request: GetEventStoreSubscriptions,
+        context: CallContext & CallContextExt
+    ): Promise<DeepPartial<IEnumerableEventStoreSubscriptionDefinitionContract>>;
     remove(request: RemoveEventStoreSubscriptions, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
 }
 

package/events/constraints/Constraints.ts

@@ -84,7 +84,7 @@ export class Constraints implements IConstraints {
                     Definition: {
                         Value0: undefined,
                         Value1: {
-                            EventTypeId: uet.eventTypeId
+                            EventTypeIds: [uet.eventTypeId]
                         }
                     },
                     Scope: scope

package/externalServices/ExternalServiceBuilder.ts

@@ -0,0 +1,128 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import {
+    ExternalServiceDefinition,
+    ExternalServiceEndpoint,
+    ExternalServiceEndpointType,
+    OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization
+} from './ExternalServicesContracts';
+import { IExternalServiceBuilder } from './IExternalServiceBuilder';
+
+/**
+ * Implements {@link IExternalServiceBuilder}.
+ */
+export class ExternalServiceBuilder implements IExternalServiceBuilder {
+    private readonly _headers = new Map<string, string>();
+    private readonly _options = new Map<string, string>();
+    private _type = ExternalServiceEndpointType.Http;
+    private _url = '';
+    private _authorization: OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization | undefined;
+    private _host = '';
+    private _port = 0;
+    private _database = '';
+    private _username = '';
+    private _password = '';
+
+    /** @inheritdoc */
+    http(url: string): IExternalServiceBuilder {
+        this._type = ExternalServiceEndpointType.Http;
+        this._url = url;
+        return this;
+    }
+
+    /** @inheritdoc */
+    withBasicAuth(username: string, password: string): IExternalServiceBuilder {
+        this._authorization = {
+            Value0: { Username: username, Password: password },
+            Value1: undefined,
+            Value2: undefined
+        };
+        return this;
+    }
+
+    /** @inheritdoc */
+    withBearerToken(token: string): IExternalServiceBuilder {
+        this._authorization = {
+            Value0: undefined,
+            Value1: { Token: token },
+            Value2: undefined
+        };
+        return this;
+    }
+
+    /** @inheritdoc */
+    withOAuth(authority: string, clientId: string, clientSecret: string): IExternalServiceBuilder {
+        this._authorization = {
+            Value0: undefined,
+            Value1: undefined,
+            Value2: { Authority: authority, ClientId: clientId, ClientSecret: clientSecret }
+        };
+        return this;
+    }
+
+    /** @inheritdoc */
+    withHeader(key: string, value: string): IExternalServiceBuilder {
+        this._headers.set(key, value);
+        return this;
+    }
+
+    /** @inheritdoc */
+    msSql(host: string, database: string, username: string, password: string, port = 0): IExternalServiceBuilder {
+        return this.configureDatabase(ExternalServiceEndpointType.MsSql, host, database, username, password, port);
+    }
+
+    /** @inheritdoc */
+    postgreSql(host: string, database: string, username: string, password: string, port = 0): IExternalServiceBuilder {
+        return this.configureDatabase(ExternalServiceEndpointType.PostgreSql, host, database, username, password, port);
+    }
+
+    /** @inheritdoc */
+    withOption(key: string, value: string): IExternalServiceBuilder {
+        this._options.set(key, value);
+        return this;
+    }
+
+    /**
+     * Builds the external service definition.
+     * @param id - The identifier of the external service.
+     * @param name - The human-readable name of the external service.
+     * @returns The built external service definition.
+     */
+    build(id: string, name: string): ExternalServiceDefinition {
+        const endpoint: ExternalServiceEndpoint = { Type: this._type, Http: undefined, Database: undefined };
+
+        if (this._type === ExternalServiceEndpointType.Http) {
+            endpoint.Http = {
+                Url: this._url,
+                Authorization: this._authorization,
+                Headers: Object.fromEntries(this._headers)
+            };
+        } else {
+            endpoint.Database = {
+                Host: this._host,
+                Port: this._port,
+                Database: this._database,
+                Username: this._username,
+                Password: this._password,
+                Options: Object.fromEntries(this._options)
+            };
+        }
+
+        return {
+            Id: id,
+            Name: name,
+            Endpoint: endpoint
+        };
+    }
+
+    private configureDatabase(type: ExternalServiceEndpointType, host: string, database: string, username: string, password: string, port: number): IExternalServiceBuilder {
+        this._type = type;
+        this._host = host;
+        this._database = database;
+        this._username = username;
+        this._password = password;
+        this._port = port;
+        return this;
+    }
+}

package/externalServices/ExternalServices.ts

@@ -0,0 +1,34 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ChronicleConnection } from '../connection';
+import { ExternalServiceBuilder } from './ExternalServiceBuilder';
+import { IExternalServiceBuilder } from './IExternalServiceBuilder';
+import { IExternalServices } from './IExternalServices';
+
+/**
+ * Implements {@link IExternalServices}.
+ */
+export class ExternalServices implements IExternalServices {
+    /**
+     * Creates a new {@link ExternalServices} instance.
+     * @param _eventStore - Event store name.
+     * @param _connection - Chronicle connection.
+     */
+    constructor(
+        private readonly _eventStore: string,
+        private readonly _connection: ChronicleConnection
+    ) {}
+
+    /** @inheritdoc */
+    async register(name: string, configure: (builder: IExternalServiceBuilder) => void): Promise<void> {
+        const builder = new ExternalServiceBuilder();
+        configure(builder);
+        const definition = builder.build(name, name);
+
+        await this._connection.externalServices.add({
+            EventStore: this._eventStore,
+            ExternalServices: [definition]
+        });
+    }
+}