@cratis/chronicle 0.1.0 → 0.2.0

package/connection/ChronicleConnectionString.ts

@@ -1,4 +1,330 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-export { ChronicleConnectionString } from '@cratis/chronicle.contracts';
+import * as grpc from '@grpc/grpc-js';
+
+/**
+ * Authentication mode for Chronicle connection.
+ */
+export enum AuthenticationMode {
+    ClientCredentials = 'ClientCredentials',
+    ApiKey = 'ApiKey'
+}
+
+/**
+ * Represents a server address with host and port.
+ */
+export interface ChronicleServerAddress {
+    host: string;
+    port: number;
+}
+
+/**
+ * Builder for constructing Chronicle connection strings.
+ */
+export class ChronicleConnectionStringBuilder {
+    private static readonly _defaultPort = 35000;
+    private static readonly _hostKey = 'Host';
+    private static readonly _portKey = 'Port';
+    private static readonly _usernameKey = 'Username';
+    private static readonly _passwordKey = 'Password';
+    private static readonly _schemeKey = 'Scheme';
+    private static readonly _apiKeyKey = 'apiKey';
+    private static readonly _disableTlsKey = 'disableTls';
+    private static readonly _certificatePathKey = 'certificatePath';
+    private static readonly _certificatePasswordKey = 'certificatePassword';
+
+    private readonly _properties = new Map<string, string>();
+
+    constructor(connectionString?: string) {
+        if (connectionString) {
+            this.parseConnectionString(connectionString);
+        }
+    }
+
+    get host(): string {
+        return this._properties.get(ChronicleConnectionStringBuilder._hostKey) || 'localhost';
+    }
+
+    set host(value: string) {
+        this._properties.set(ChronicleConnectionStringBuilder._hostKey, value);
+    }
+
+    get port(): number {
+        const port = this._properties.get(ChronicleConnectionStringBuilder._portKey);
+        return port ? parseInt(port, 10) : ChronicleConnectionStringBuilder._defaultPort;
+    }
+
+    set port(value: number) {
+        this._properties.set(ChronicleConnectionStringBuilder._portKey, value.toString());
+    }
+
+    get username(): string | undefined {
+        return this._properties.get(ChronicleConnectionStringBuilder._usernameKey);
+    }
+
+    set username(value: string | undefined) {
+        if (value) {
+            this._properties.set(ChronicleConnectionStringBuilder._usernameKey, value);
+            return;
+        }
+
+        this._properties.delete(ChronicleConnectionStringBuilder._usernameKey);
+    }
+
+    get password(): string | undefined {
+        return this._properties.get(ChronicleConnectionStringBuilder._passwordKey);
+    }
+
+    set password(value: string | undefined) {
+        if (value) {
+            this._properties.set(ChronicleConnectionStringBuilder._passwordKey, value);
+            return;
+        }
+
+        this._properties.delete(ChronicleConnectionStringBuilder._passwordKey);
+    }
+
+    get scheme(): string {
+        return this._properties.get(ChronicleConnectionStringBuilder._schemeKey) || 'chronicle';
+    }
+
+    set scheme(value: string) {
+        this._properties.set(ChronicleConnectionStringBuilder._schemeKey, value);
+    }
+
+    get authenticationMode(): AuthenticationMode {
+        const hasClientCredentials = !!this.username && !!this.password;
+        const hasApiKey = !!this.apiKey;
+
+        if (hasClientCredentials && hasApiKey) {
+            throw new Error('Cannot specify both username/password and apiKey in the connection string');
+        }
+
+        if (hasClientCredentials) {
+            return AuthenticationMode.ClientCredentials;
+        }
+
+        if (hasApiKey) {
+            return AuthenticationMode.ApiKey;
+        }
+
+        throw new Error('No authentication method specified. Provide either username/password or apiKey in the connection string');
+    }
+
+    get apiKey(): string | undefined {
+        return this._properties.get(ChronicleConnectionStringBuilder._apiKeyKey);
+    }
+
+    set apiKey(value: string | undefined) {
+        if (value) {
+            this._properties.set(ChronicleConnectionStringBuilder._apiKeyKey, value);
+            return;
+        }
+
+        this._properties.delete(ChronicleConnectionStringBuilder._apiKeyKey);
+    }
+
+    get disableTls(): boolean {
+        return this._properties.get(ChronicleConnectionStringBuilder._disableTlsKey) === 'true';
+    }
+
+    set disableTls(value: boolean) {
+        this._properties.set(ChronicleConnectionStringBuilder._disableTlsKey, value.toString());
+    }
+
+    get certificatePath(): string | undefined {
+        return this._properties.get(ChronicleConnectionStringBuilder._certificatePathKey);
+    }
+
+    set certificatePath(value: string | undefined) {
+        if (value) {
+            this._properties.set(ChronicleConnectionStringBuilder._certificatePathKey, value);
+            return;
+        }
+
+        this._properties.delete(ChronicleConnectionStringBuilder._certificatePathKey);
+    }
+
+    get certificatePassword(): string | undefined {
+        return this._properties.get(ChronicleConnectionStringBuilder._certificatePasswordKey);
+    }
+
+    set certificatePassword(value: string | undefined) {
+        if (value) {
+            this._properties.set(ChronicleConnectionStringBuilder._certificatePasswordKey, value);
+            return;
+        }
+
+        this._properties.delete(ChronicleConnectionStringBuilder._certificatePasswordKey);
+    }
+
+    build(): string {
+        let result = `${this.scheme}://`;
+
+        if (this.username) {
+            result += this.username;
+            if (this.password) {
+                result += `:${this.password}`;
+            }
+            result += '@';
+        }
+
+        result += this.host;
+        result += `:${this.port}`;
+
+        const queryParameters: string[] = [];
+
+        if (this.apiKey) {
+            queryParameters.push(`apiKey=${encodeURIComponent(this.apiKey)}`);
+        }
+
+        if (this.disableTls) {
+            queryParameters.push('disableTls=true');
+        }
+
+        if (this.certificatePath) {
+            queryParameters.push(`certificatePath=${encodeURIComponent(this.certificatePath)}`);
+        }
+
+        if (this.certificatePassword) {
+            queryParameters.push(`certificatePassword=${encodeURIComponent(this.certificatePassword)}`);
+        }
+
+        for (const [key, value] of this._properties) {
+            if (
+                key !== ChronicleConnectionStringBuilder._hostKey &&
+                key !== ChronicleConnectionStringBuilder._portKey &&
+                key !== ChronicleConnectionStringBuilder._usernameKey &&
+                key !== ChronicleConnectionStringBuilder._passwordKey &&
+                key !== ChronicleConnectionStringBuilder._schemeKey &&
+                key !== ChronicleConnectionStringBuilder._apiKeyKey &&
+                key !== ChronicleConnectionStringBuilder._disableTlsKey &&
+                key !== ChronicleConnectionStringBuilder._certificatePathKey &&
+                key !== ChronicleConnectionStringBuilder._certificatePasswordKey
+            ) {
+                queryParameters.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+            }
+        }
+
+        if (queryParameters.length > 0) {
+            result += `?${queryParameters.join('&')}`;
+        }
+
+        return result;
+    }
+
+    private parseConnectionString(connectionString: string): void {
+        if (
+            connectionString.startsWith('chronicle://') ||
+            connectionString.startsWith('chronicle+srv://')
+        ) {
+            this.parseUrl(connectionString);
+        }
+    }
+
+    private parseUrl(value: string): void {
+        try {
+            const parsed = new URL(value);
+            this.scheme = parsed.protocol.replace(':', '');
+            this.host = parsed.hostname;
+
+            if (parsed.port) {
+                this.port = parseInt(parsed.port, 10);
+            }
+
+            if (parsed.username) {
+                this.username = decodeURIComponent(parsed.username);
+                if (parsed.password) {
+                    this.password = decodeURIComponent(parsed.password);
+                }
+            }
+
+            for (const [key, queryValue] of new URLSearchParams(parsed.search)) {
+                this._properties.set(key, decodeURIComponent(queryValue));
+            }
+        } catch (error) {
+            throw new Error(`Invalid Chronicle connection string: ${error}`);
+        }
+    }
+}
+
+/**
+ * Represents a Chronicle connection string.
+ */
+export class ChronicleConnectionString {
+    static readonly DEVELOPMENT_CLIENT = 'chronicle-dev-client';
+    static readonly DEVELOPMENT_CLIENT_SECRET = 'chronicle-dev-secret';
+    static readonly Default = new ChronicleConnectionString('chronicle://localhost:35000');
+    static readonly Development = new ChronicleConnectionString(
+        `chronicle://${ChronicleConnectionString.DEVELOPMENT_CLIENT}:${ChronicleConnectionString.DEVELOPMENT_CLIENT_SECRET}@localhost:35000`
+    );
+
+    private readonly _builder: ChronicleConnectionStringBuilder;
+    private readonly _serverAddress: ChronicleServerAddress;
+
+    constructor(connectionString: string) {
+        this._builder = new ChronicleConnectionStringBuilder(connectionString);
+        this._serverAddress = {
+            host: this._builder.host,
+            port: this._builder.port
+        };
+    }
+
+    get serverAddress(): ChronicleServerAddress {
+        return this._serverAddress;
+    }
+
+    get username(): string | undefined {
+        return this._builder.username;
+    }
+
+    get password(): string | undefined {
+        return this._builder.password;
+    }
+
+    get authenticationMode(): AuthenticationMode {
+        return this._builder.authenticationMode;
+    }
+
+    get apiKey(): string | undefined {
+        return this._builder.apiKey;
+    }
+
+    get disableTls(): boolean {
+        return this._builder.disableTls;
+    }
+
+    get certificatePath(): string | undefined {
+        return this._builder.certificatePath;
+    }
+
+    get certificatePassword(): string | undefined {
+        return this._builder.certificatePassword;
+    }
+
+    withCredentials(username: string, password: string): ChronicleConnectionString {
+        const builder = new ChronicleConnectionStringBuilder(this.toString());
+        builder.username = username;
+        builder.password = password;
+        return new ChronicleConnectionString(builder.build());
+    }
+
+    withApiKey(apiKey: string): ChronicleConnectionString {
+        const builder = new ChronicleConnectionStringBuilder(this.toString());
+        builder.apiKey = apiKey;
+        return new ChronicleConnectionString(builder.build());
+    }
+
+    createCredentials(): grpc.ChannelCredentials {
+        if (this.disableTls) {
+            return grpc.credentials.createInsecure();
+        }
+
+        return grpc.credentials.createSsl();
+    }
+
+    toString(): string {
+        return this._builder.build();
+    }
+}

package/connection/ChronicleServices.ts

@@ -1,4 +1,45 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-export { ChronicleServices } from '@cratis/chronicle.contracts';
+import type {
+    ConstraintsClient,
+    EventSeedingClient,
+    EventSequencesClient,
+    EventStoresClient,
+    EventTypesClient,
+    FailedPartitionsClient,
+    IdentitiesClient,
+    JobsClient,
+    NamespacesClient,
+    ObserversClient,
+    ProjectionsClient,
+    ReactorsClient,
+    ReadModelsClient,
+    RecommendationsClient,
+    ReducersClient,
+    ServerClient,
+    WebhooksClient
+} from '@cratis/chronicle.contracts';
+
+/**
+ * Represents all Chronicle gRPC services.
+ */
+export interface ChronicleServices {
+    eventStores: EventStoresClient;
+    namespaces: NamespacesClient;
+    recommendations: RecommendationsClient;
+    identities: IdentitiesClient;
+    eventSequences: EventSequencesClient;
+    eventTypes: EventTypesClient;
+    constraints: ConstraintsClient;
+    observers: ObserversClient;
+    failedPartitions: FailedPartitionsClient;
+    reactors: ReactorsClient;
+    reducers: ReducersClient;
+    projections: ProjectionsClient;
+    readModels: ReadModelsClient;
+    jobs: JobsClient;
+    webhooks: WebhooksClient;
+    eventSeeding: EventSeedingClient;
+    server: ServerClient;
+}

package/connection/Guid.ts

@@ -23,10 +23,8 @@ export function toContractsGuid(guid: FundamentalGuid): ContractsGuid {
         hi |= BigInt(bytes[index + 8]) << BigInt(index * 8);
     }
 
-    // The runtime accepts strings for fixed64 values, which preserves the exact
-    // 64-bit payload instead of truncating through Number.
     return {
-        lo: lo.toString() as unknown as number,
-        hi: hi.toString() as unknown as number
+        lo,
+        hi
     };
 }

package/connection/TokenProvider.ts

@@ -1,13 +1,135 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import type { ITokenProvider } from '@cratis/chronicle.contracts';
+import * as http from 'http';
+import * as https from 'https';
 
-export {
-	NoOpTokenProvider,
-	OAuthTokenProvider
-} from '@cratis/chronicle.contracts';
+const TOKEN_EXPIRY_BUFFER_SECONDS = 60;
+const DEFAULT_TOKEN_EXPIRY_SECONDS = 3600;
 
-export type { ITokenProvider } from '@cratis/chronicle.contracts';
+/**
+ * Interface for providing authentication tokens.
+ */
+export interface ITokenProvider {
+    /**
+     * Gets the current access token.
+     * @returns Promise resolving to the access token or undefined if not available.
+     */
+    getAccessToken(): Promise<string | undefined>;
+
+    /**
+     * Refreshes the access token by clearing cached tokens and obtaining a new one.
+     * @returns Promise resolving to the new access token or undefined if not available.
+     */
+    refresh(): Promise<string | undefined>;
+}
+
+/**
+ * No-op token provider for when authentication is not required.
+ */
+export class NoOpTokenProvider implements ITokenProvider {
+    async getAccessToken(): Promise<string | undefined> {
+        return undefined;
+    }
+
+    async refresh(): Promise<string | undefined> {
+        return undefined;
+    }
+}
+
+interface OAuthTokenResponse {
+    access_token: string;
+    expires_in: number;
+}
+
+/**
+ * OAuth token provider using client credentials flow.
+ */
+export class OAuthTokenProvider implements ITokenProvider {
+    private _accessToken?: string;
+    private _tokenExpiry = new Date(0);
+    private _refreshPromise?: Promise<string | undefined>;
+
+    constructor(
+        private readonly _tokenEndpoint: string,
+        private readonly _clientId: string,
+        private readonly _clientSecret: string
+    ) {}
+
+    async getAccessToken(): Promise<string | undefined> {
+        if (this._accessToken && new Date() < this._tokenExpiry) {
+            return this._accessToken;
+        }
+
+        if (this._refreshPromise) {
+            return this._refreshPromise;
+        }
+
+        this._refreshPromise = this.fetchAccessToken();
+        try {
+            return await this._refreshPromise;
+        } finally {
+            this._refreshPromise = undefined;
+        }
+    }
+
+    async refresh(): Promise<string | undefined> {
+        this._accessToken = undefined;
+        this._tokenExpiry = new Date(0);
+        return this.getAccessToken();
+    }
+
+    private async fetchAccessToken(): Promise<string | undefined> {
+        const params = new URLSearchParams();
+        params.append('grant_type', 'client_credentials');
+        params.append('client_id', this._clientId);
+        params.append('client_secret', this._clientSecret);
+
+        const body = params.toString();
+
+        return new Promise((resolve, reject) => {
+            const url = new URL(this._tokenEndpoint);
+            const httpModule = url.protocol === 'https:' ? https : http;
+
+            const req = httpModule.request(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Content-Length': Buffer.byteLength(body)
+                }
+            }, response => {
+                let data = '';
+
+                response.on('data', chunk => {
+                    data += chunk;
+                });
+
+                response.on('end', () => {
+                    if (response.statusCode !== 200) {
+                        reject(new Error(`Token request failed with status ${response.statusCode}: ${data}`));
+                        return;
+                    }
+
+                    try {
+                        const tokenResponse = JSON.parse(data) as OAuthTokenResponse;
+                        this._accessToken = tokenResponse.access_token;
+                        const expiresInSeconds = tokenResponse.expires_in || DEFAULT_TOKEN_EXPIRY_SECONDS;
+                        this._tokenExpiry = new Date(Date.now() + (expiresInSeconds - TOKEN_EXPIRY_BUFFER_SECONDS) * 1000);
+                        resolve(this._accessToken);
+                    } catch (error) {
+                        reject(new Error(`Failed to parse token response: ${error instanceof Error ? error.message : String(error)}`));
+                    }
+                });
+            });
+
+            req.on('error', error => {
+                reject(new Error(`Token request failed: ${error.message}`));
+            });
+
+            req.write(body);
+            req.end();
+        });
+    }
+}
 
 export type TokenProvider = ITokenProvider;

package/dist/EventStore.d.ts

@@ -1,16 +1,20 @@
 import { ChronicleConnection } from './connection';
 import { ConnectionLifecycle } from './connection/ConnectionLifecycle';
-import { EventSequenceId } from './EventSequences/EventSequenceId';
-import { IEventLog } from './EventSequences/IEventLog';
-import { IEventSequence } from './EventSequences/IEventSequence';
+import { EventSequenceId } from './eventSequences/EventSequenceId';
+import { IEventLog } from './eventSequences/IEventLog';
+import { IEventSequence } from './eventSequences/IEventSequence';
 import { EventStoreName } from './EventStoreName';
 import { EventStoreNamespaceName } from './EventStoreNamespaceName';
 import { IEventStore } from './IEventStore';
-import { IEventTypes } from './Events/IEventTypes';
-import { IConstraints } from './Events/Constraints/IConstraints';
-import { IProjections } from './Projections/IProjections';
-import { IReactors } from './Reactors/IReactors';
-import { IReducers } from './Reducers/IReducers';
+import { IEventTypes } from './events/IEventTypes';
+import { IConstraints } from './events/constraints/IConstraints';
+import { IProjections } from './projections/IProjections';
+import { IReactors } from './reactors/IReactors';
+import { IReducers } from './reducers/IReducers';
+import { IEventSeeding } from './seeding/IEventSeeding';
+import { IUnitOfWorkManager } from './transactions/IUnitOfWorkManager';
+import { IJobs } from './jobs/IJobs';
+import { IWebhooks } from './webhooks/IWebhooks';
 /**
  * Implements {@link IEventStore} by communicating with the Chronicle Kernel
  * via gRPC using the provided {@link ChronicleConnection}.
@@ -26,6 +30,10 @@ export declare class EventStore implements IEventStore {
     readonly projections: IProjections;
     readonly reactors: IReactors;
     readonly reducers: IReducers;
+    readonly unitOfWorkManager: IUnitOfWorkManager;
+    readonly jobs: IJobs;
+    readonly webhooks: IWebhooks;
+    readonly seeding: IEventSeeding;
     private readonly _sequences;
     constructor(name: EventStoreName, namespace: EventStoreNamespaceName, _connection: ChronicleConnection, lifecycle: ConnectionLifecycle);
     /**

package/dist/EventStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventStore.d.ts","sourceRoot":"","sources":["../EventStore.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIjD;;;GAGG;AACH,qBAAa,UAAW,YAAW,WAAW;IAetC,QAAQ,CAAC,IAAI,EAAE,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,uBAAuB;IAC3C,OAAO,CAAC,QAAQ,CAAC,WAAW;IAhBhC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAErB;IAEH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;IACnC,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAE7B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0C;gBAGxD,IAAI,EAAE,cAAc,EACpB,SAAS,EAAE,uBAAuB,EAC1B,WAAW,EAAE,mBAAmB,EACjD,SAAS,EAAE,mBAAmB;IAalC;;;;OAIG;IACG,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiCxC,kBAAkB;IAClB,gBAAgB,CAAC,EAAE,EAAE,eAAe,GAAG,cAAc;IAWrD,kBAAkB;IACZ,aAAa,IAAI,OAAO,CAAC,uBAAuB,EAAE,CAAC;CAiB5D"}
+{"version":3,"file":"EventStore.d.ts","sourceRoot":"","sources":["../EventStore.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAEvE,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAErC,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGjD;;;GAGG;AACH,qBAAa,UAAW,YAAW,WAAW;IAmBtC,QAAQ,CAAC,IAAI,EAAE,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,uBAAuB;IAC3C,OAAO,CAAC,QAAQ,CAAC,WAAW;IApBhC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAErB;IAEH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;IACnC,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,EAAE,kBAAkB,CAAC;IAC/C,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAEhC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0C;gBAGxD,IAAI,EAAE,cAAc,EACpB,SAAS,EAAE,uBAAuB,EAC1B,WAAW,EAAE,mBAAmB,EACjD,SAAS,EAAE,mBAAmB;IAkBlC;;;;OAIG;IACG,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAsCxC,kBAAkB;IAClB,gBAAgB,CAAC,EAAE,EAAE,eAAe,GAAG,cAAc;IAWrD,kBAAkB;IACZ,aAAa,IAAI,OAAO,CAAC,uBAAuB,EAAE,CAAC;CAiB5D"}

package/dist/EventStore.js

@@ -2,17 +2,21 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 import { diag } from '@opentelemetry/api';
 import { SpanStatusCode } from '@opentelemetry/api';
-import { EventLog } from './EventSequences/EventLog';
-import { EventSequence } from './EventSequences/EventSequence';
-import { EventSequenceId } from './EventSequences/EventSequenceId';
+import { EventLog } from './eventSequences/EventLog';
+import { EventSequence } from './eventSequences/EventSequence';
+import { EventSequenceId } from './eventSequences/EventSequenceId';
 import { EventStoreNamespaceName } from './EventStoreNamespaceName';
-import { EventTypes } from './Events/EventTypes';
-import { Constraints } from './Events/Constraints/Constraints';
-import { Projections } from './Projections/Projections';
-import { Reactors } from './Reactors/Reactors';
-import { Reducers } from './Reducers/Reducers';
+import { EventTypes } from './events/EventTypes';
+import { Constraints } from './events/constraints/Constraints';
+import { Projections } from './projections/Projections';
+import { Reactors } from './reactors/Reactors';
+import { Reducers } from './reducers/Reducers';
+import { EventSeeding } from './seeding/EventSeeding';
 import { ChronicleTracer } from './Tracing';
 import { DefaultClientArtifactsProvider } from './artifacts/DefaultClientArtifactsProvider';
+import { UnitOfWorkManager } from './transactions/UnitOfWorkManager';
+import { Jobs } from './jobs/Jobs';
+import { Webhooks } from './webhooks/Webhooks';
 /**
  * Implements {@link IEventStore} by communicating with the Chronicle Kernel
  * via gRPC using the provided {@link ChronicleConnection}.
@@ -30,12 +34,17 @@ export class EventStore {
     projections;
     reactors;
     reducers;
+    unitOfWorkManager;
+    jobs;
+    webhooks;
+    seeding;
     _sequences = new Map();
     constructor(name, namespace, _connection, lifecycle) {
         this.name = name;
         this.namespace = namespace;
         this._connection = _connection;
-        this.eventLog = new EventLog(name.value, namespace.value, _connection);
+        this.unitOfWorkManager = new UnitOfWorkManager(this);
+        this.eventLog = new EventLog(name.value, namespace.value, _connection, this.unitOfWorkManager);
         this._sequences.set(EventSequenceId.eventLog.value, this.eventLog);
         const artifacts = DefaultClientArtifactsProvider.default;
         this.eventTypes = new EventTypes(name.value, _connection, artifacts);
@@ -43,6 +52,9 @@ export class EventStore {
         this.projections = new Projections(name.value, _connection, artifacts);
         this.reactors = new Reactors(artifacts, _connection, name.value, namespace.value, lifecycle);
         this.reducers = new Reducers(artifacts, _connection, name.value, namespace.value, lifecycle);
+        this.jobs = new Jobs(name.value, namespace.value, _connection);
+        this.webhooks = new Webhooks(name.value, _connection, this.eventTypes, artifacts);
+        this.seeding = new EventSeeding(name.value, _connection, artifacts);
     }
     /**
      * Registers all discovered artifacts with the Chronicle Kernel.
@@ -59,7 +71,9 @@ export class EventStore {
             this.constraints.discover(),
             this.projections.discover(),
             this.reactors.discover(),
-            this.reducers.discover()
+            this.reducers.discover(),
+            this.webhooks.discover(),
+            this.seeding.discover()
         ]);
         this._logger.debug('Registering discovered artifacts', {
             eventStore: this.name.value,
@@ -70,8 +84,10 @@ export class EventStore {
             this.constraints.register(),
             this.projections.register(),
             this.reactors.register(),
-            this.reducers.register()
+            this.reducers.register(),
+            this.webhooks.registerDiscovered()
         ]);
+        await this.seeding.register();
         this._logger.info('Artifact registration completed', {
             eventStore: this.name.value,
             namespace: this.namespace.value
@@ -83,7 +99,7 @@ export class EventStore {
         if (existing) {
             return existing;
         }
-        const sequence = new EventSequence(id, this.name.value, this.namespace.value, this._connection);
+        const sequence = new EventSequence(id, this.name.value, this.namespace.value, this._connection, this.unitOfWorkManager);
         this._sequences.set(id.value, sequence);
         return sequence;
     }