@cratis/chronicle.contracts 0.0.0

package/README.md

@@ -0,0 +1,221 @@
+# @cratis/chronicle.contracts
+
+TypeScript gRPC contracts for Chronicle with full type safety and IDE support.
+
+## Installation
+
+```bash
+npm install @cratis/chronicle.contracts
+# or
+yarn add @cratis/chronicle.contracts
+```
+
+## Usage
+
+This package provides strongly-typed Chronicle gRPC service clients generated from proto definitions using ts-proto.
+
+### Quick Start
+
+```typescript
+import { ChronicleConnection, ChronicleConnectionString } from '@cratis/chronicle.contracts';
+
+// Create a connection using a connection string
+const connection = new ChronicleConnection({
+    connectionString: 'chronicle://localhost:35000'
+});
+
+// Connect to Chronicle
+await connection.connect();
+
+// Use the services with full type safety and IDE completion
+const eventStores = await connection.eventStores.GetEventStores({});
+console.log('Event stores:', eventStores.items);
+
+// Clean up
+connection.dispose();
+```
+
+### Connection Strings
+
+Chronicle supports connection strings similar to database connection strings, providing a consistent way to configure connections:
+
+```typescript
+// Basic connection
+const connection = new ChronicleConnection({
+    connectionString: 'chronicle://localhost:35000'
+});
+
+// With client credentials (username:password)
+const connection = new ChronicleConnection({
+    connectionString: 'chronicle://myuser:mypassword@localhost:35000'
+});
+
+// With API key authentication
+const connection = new ChronicleConnection({
+    connectionString: 'chronicle://localhost:35000?apiKey=your-api-key-here'
+});
+
+// With TLS disabled (for development)
+const connection = new ChronicleConnection({
+    connectionString: 'chronicle://localhost:35000?disableTls=true'
+});
+```
+
+### Development Connection
+
+For local development, use the built-in development connection with default credentials:
+
+```typescript
+import { ChronicleConnectionString } from '@cratis/chronicle.contracts';
+
+const connection = new ChronicleConnection({
+    connectionString: ChronicleConnectionString.Development
+});
+```
+
+The development connection string uses:
+- **Client ID**: `chronicle-dev-client`
+- **Client Secret**: `chronicle-dev-secret`
+- **Host**: `localhost:35000`
+
+These are the default development credentials that Chronicle Kernel accepts when running in development mode.
+
+### Working with Connection Strings
+
+```typescript
+import { ChronicleConnectionString } from '@cratis/chronicle.contracts';
+
+// Parse a connection string
+const connStr = new ChronicleConnectionString('chronicle://localhost:35000');
+
+// Access connection details
+console.log(connStr.serverAddress.host); // 'localhost'
+console.log(connStr.serverAddress.port); // 35000
+
+// Create new connection strings with modifications
+const withCreds = connStr.withCredentials('myuser', 'mypassword');
+const withApiKey = connStr.withApiKey('my-api-key');
+
+// Convert to string
+console.log(withCreds.toString()); // chronicle://myuser:mypassword@localhost:35000
+```
+
+### Authentication
+
+Chronicle supports two authentication modes. When using Client Credentials, the TypeScript client automatically obtains a bearer token from the authentication authority using OAuth 2.0 client_credentials flow.
+
+#### Client Credentials (OAuth2 client_credentials flow)
+
+The client automatically obtains and refreshes bearer tokens from the Chronicle server (or a custom authority):
+
+```typescript
+const connection = new ChronicleConnection({
+    connectionString: 'chronicle://client-id:client-secret@localhost:35000'
+});
+
+// With custom authority
+const connection = new ChronicleConnection({
+    connectionString: 'chronicle://client-id:client-secret@localhost:35000',
+    authority: 'https://my-auth-server.com',
+    managementPort: 8080 // Optional, defaults to 8080
+});
+```
+
+The token is automatically included as a Bearer token in the authorization header for all gRPC calls.
+
+#### API Key
+
+```typescript
+const connection = new ChronicleConnection({
+    connectionString: 'chronicle://localhost:35000?apiKey=your-api-key'
+});
+```
+
+### Using Individual Services
+
+You can also import and use services directly:
+
+```typescript
+import { EventStoresClient } from '@cratis/chronicle.contracts';
+import * as grpc from '@grpc/grpc-js';
+
+const client = new EventStoresClient(
+    'localhost:35000',
+    grpc.credentials.createInsecure()
+);
+
+const response = await client.GetEventStores({});
+console.log('Event stores:', response.items);
+```
+
+### Configuration Options
+
+```typescript
+const connection = new ChronicleConnection({
+    connectionString: 'chronicle://localhost:35000',
+    
+    // Optional: Override credentials from connection string
+    credentials: grpc.credentials.createSsl(),
+    
+    // Optional: connection timeout in ms
+    connectTimeout: 10000,
+    
+    // Optional: message size limits
+    maxReceiveMessageSize: 1024 * 1024 * 10, // 10MB
+    maxSendMessageSize: 1024 * 1024 * 10, // 10MB
+    
+    // Optional: for request tracking
+    correlationId: 'my-correlation-id',
+    
+    // Optional: Custom authentication authority URL
+    // If not set, uses Chronicle server as the authority
+    authority: 'https://my-auth-server.com',
+    
+    // Optional: Management port for authentication endpoint (defaults to 8080)
+    managementPort: 8080
+});
+```
+
+### Legacy Server Address
+
+For backward compatibility, you can still use `serverAddress`:
+
+```typescript
+const connection = new ChronicleConnection({
+    serverAddress: 'localhost:35000'
+});
+```
+
+### Available Services
+
+The `ChronicleConnection` provides access to all Chronicle services:
+
+- `eventStores` - Event store management
+- `namespaces` - Namespace management
+- `recommendations` - Recommendations
+- `identities` - Identity management
+- `eventSequences` - Event sequence operations
+- `eventTypes` - Event type management
+- `constraints` - Event constraints
+- `observers` - Observer management
+- `failedPartitions` - Failed partition handling
+- `reactors` - Reactor management
+- `reducers` - Reducer management
+- `projections` - Projection management
+- `readModels` - Read model operations
+- `jobs` - Job management
+- `eventSeeding` - Event seeding
+- `server` - Server information
+
+### Type Safety
+
+All services are fully typed with TypeScript interfaces generated from proto definitions, providing:
+
+- **IntelliSense** in your IDE
+- **Compile-time type checking**
+- **Auto-completion** for all methods and parameters
+- **Type inference** for request and response objects
+
+## License
+
+MIT

package/TokenProvider.ts

@@ -0,0 +1,167 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import * as https from 'https';
+import * as http from 'http';
+
+/**
+ * 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;
+    }
+}
+
+/**
+ * OAuth token response from the token endpoint
+ */
+interface OAuthTokenResponse {
+    access_token: string;
+    expires_in: number;
+    token_type: string;
+}
+
+/**
+ * OAuth token provider using client credentials flow
+ */
+export class OAuthTokenProvider implements ITokenProvider {
+    private accessToken?: string;
+    private tokenExpiry: Date = new Date(0);
+    private refreshPromise?: Promise<string | undefined>;
+
+    /**
+     * Creates a new OAuth token provider
+     * @param tokenEndpoint The token endpoint URL
+     * @param clientId The OAuth client ID
+     * @param clientSecret The OAuth client secret
+     */
+    constructor(
+        private readonly tokenEndpoint: string,
+        private readonly clientId: string,
+        private readonly clientSecret: string
+    ) {}
+
+    /**
+     * Gets the current access token, fetching a new one if needed
+     */
+    async getAccessToken(): Promise<string | undefined> {
+        if (this.accessToken && new Date() < this.tokenExpiry) {
+            return this.accessToken;
+        }
+
+        // If we're already refreshing, wait for that promise
+        if (this.refreshPromise) {
+            return this.refreshPromise;
+        }
+
+        this.refreshPromise = this.fetchAccessToken();
+        try {
+            return await this.refreshPromise;
+        } finally {
+            this.refreshPromise = undefined;
+        }
+    }
+
+    /**
+     * Refreshes the access token by clearing the cache and fetching a new one
+     */
+    async refresh(): Promise<string | undefined> {
+        this.accessToken = undefined;
+        this.tokenExpiry = new Date(0);
+        return this.getAccessToken();
+    }
+
+    /**
+     * Fetches a new access token from the token endpoint
+     */
+    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 isHttps = url.protocol === 'https:';
+            const httpModule = isHttps ? https : http;
+
+            const options = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+                // Accept self-signed certificates in development
+                rejectUnauthorized: false,
+            };
+
+            const req = httpModule.request(url, options, (res) => {
+                let data = '';
+
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+
+                res.on('end', () => {
+                    if (res.statusCode === 200) {
+                        try {
+                            const tokenResponse: OAuthTokenResponse = JSON.parse(data);
+                            this.accessToken = tokenResponse.access_token;
+
+                            // Set expiry with 60 second buffer
+                            const expiresInSeconds = tokenResponse.expires_in || 3600;
+                            this.tokenExpiry = new Date(
+                                Date.now() + (expiresInSeconds - 60) * 1000
+                            );
+
+                            resolve(this.accessToken);
+                        } catch (error) {
+                            reject(
+                                new Error(
+                                    `Failed to parse token response: ${error instanceof Error ? error.message : String(error)}`
+                                )
+                            );
+                        }
+                    } else {
+                        reject(
+                            new Error(
+                                `Token request failed with status ${res.statusCode}: ${data}`
+                            )
+                        );
+                    }
+                });
+            });
+
+            req.on('error', (error) => {
+                reject(new Error(`Token request failed: ${error.message}`));
+            });
+
+            req.write(body);
+            req.end();
+        });
+    }
+}

package/dist/ChronicleConnection.d.ts

@@ -0,0 +1,63 @@
+import * as grpc from '@grpc/grpc-js';
+import { EventStoresClient } from './generated/cratis_chronicle_contracts';
+import { NamespacesClient } from './generated/cratis_chronicle_contracts';
+import { RecommendationsClient } from './generated/recommendations';
+import { IdentitiesClient } from './generated/identities';
+import { EventSequencesClient } from './generated/eventsequences';
+import { EventTypesClient } from './generated/events';
+import { ConstraintsClient } from './generated/events_constraints';
+import { ObserversClient } from './generated/observation';
+import { FailedPartitionsClient } from './generated/observation';
+import { ReactorsClient } from './generated/observation_reactors';
+import { ReducersClient } from './generated/observation_reducers';
+import { ProjectionsClient } from './generated/projections';
+import { ReadModelsClient } from './generated/readmodels';
+import { JobsClient } from './generated/jobs';
+import { EventSeedingClient } from './generated/seeding';
+import { ServerClient } from './generated/host';
+import type { ChronicleServices } from './ChronicleServices';
+import { ChronicleConnectionString } from './ChronicleConnectionString';
+export interface ChronicleConnectionOptions {
+    connectionString?: string | ChronicleConnectionString;
+    serverAddress?: string;
+    credentials?: grpc.ChannelCredentials;
+    connectTimeout?: number;
+    maxReceiveMessageSize?: number;
+    maxSendMessageSize?: number;
+    correlationId?: string;
+    authority?: string;
+    managementPort?: number;
+}
+export declare class ChronicleConnection implements ChronicleServices {
+    private readonly channel;
+    private readonly services;
+    private readonly _connectionString;
+    private readonly tokenProvider;
+    private _isConnected;
+    get eventStores(): EventStoresClient;
+    get namespaces(): NamespacesClient;
+    get recommendations(): RecommendationsClient;
+    get identities(): IdentitiesClient;
+    get eventSequences(): EventSequencesClient;
+    get eventTypes(): EventTypesClient;
+    get constraints(): ConstraintsClient;
+    get observers(): ObserversClient;
+    get failedPartitions(): FailedPartitionsClient;
+    get reactors(): ReactorsClient;
+    get reducers(): ReducersClient;
+    get projections(): ProjectionsClient;
+    get readModels(): ReadModelsClient;
+    get jobs(): JobsClient;
+    get eventSeeding(): EventSeedingClient;
+    get server(): ServerClient;
+    private connectionService;
+    get connectionString(): ChronicleConnectionString;
+    constructor(options: ChronicleConnectionOptions);
+    private createTokenProvider;
+    private createAuthCallCredentials;
+    get isConnected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=ChronicleConnection.d.ts.map

package/dist/ChronicleConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChronicleConnection.d.ts","sourceRoot":"","sources":["../ChronicleConnection.ts"],"names":[],"mappings":"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"}

package/dist/ChronicleConnection.js

@@ -0,0 +1,223 @@
+import * as grpc from '@grpc/grpc-js';
+import { EventStoresClient } from './generated/cratis_chronicle_contracts';
+import { NamespacesClient } from './generated/cratis_chronicle_contracts';
+import { RecommendationsClient } from './generated/recommendations';
+import { IdentitiesClient } from './generated/identities';
+import { EventSequencesClient } from './generated/eventsequences';
+import { EventTypesClient } from './generated/events';
+import { ConstraintsClient } from './generated/events_constraints';
+import { ObserversClient } from './generated/observation';
+import { FailedPartitionsClient } from './generated/observation';
+import { ReactorsClient } from './generated/observation_reactors';
+import { ReducersClient } from './generated/observation_reducers';
+import { ProjectionsClient } from './generated/projections';
+import { ReadModelsClient } from './generated/readmodels';
+import { JobsClient } from './generated/jobs';
+import { EventSeedingClient } from './generated/seeding';
+import { ServerClient } from './generated/host';
+import { ConnectionServiceClient } from './generated/clients';
+import { ChronicleConnectionString, AuthenticationMode } from './ChronicleConnectionString';
+import { OAuthTokenProvider, NoOpTokenProvider } from './TokenProvider';
+export class ChronicleConnection {
+    channel;
+    services;
+    _connectionString;
+    tokenProvider;
+    _isConnected = false;
+    get eventStores() {
+        return this.services.eventStores;
+    }
+    get namespaces() {
+        return this.services.namespaces;
+    }
+    get recommendations() {
+        return this.services.recommendations;
+    }
+    get identities() {
+        return this.services.identities;
+    }
+    get eventSequences() {
+        return this.services.eventSequences;
+    }
+    get eventTypes() {
+        return this.services.eventTypes;
+    }
+    get constraints() {
+        return this.services.constraints;
+    }
+    get observers() {
+        return this.services.observers;
+    }
+    get failedPartitions() {
+        return this.services.failedPartitions;
+    }
+    get reactors() {
+        return this.services.reactors;
+    }
+    get reducers() {
+        return this.services.reducers;
+    }
+    get projections() {
+        return this.services.projections;
+    }
+    get readModels() {
+        return this.services.readModels;
+    }
+    get jobs() {
+        return this.services.jobs;
+    }
+    get eventSeeding() {
+        return this.services.eventSeeding;
+    }
+    get server() {
+        return this.services.server;
+    }
+    connectionService;
+    get connectionString() {
+        return this._connectionString;
+    }
+    constructor(options) {
+        if (options.connectionString) {
+            this._connectionString =
+                typeof options.connectionString === 'string'
+                    ? new ChronicleConnectionString(options.connectionString)
+                    : options.connectionString;
+        }
+        else if (options.serverAddress) {
+            this._connectionString = new ChronicleConnectionString(`chronicle://${options.serverAddress}`);
+        }
+        else {
+            this._connectionString = ChronicleConnectionString.Default;
+        }
+        const serverAddress = `${this._connectionString.serverAddress.host}:${this._connectionString.serverAddress.port}`;
+        this.tokenProvider = this.createTokenProvider(options);
+        let channelCredentials = options.credentials;
+        if (!channelCredentials) {
+            channelCredentials = this._connectionString.createCredentials();
+            const callCredentials = this.createAuthCallCredentials();
+            if (callCredentials) {
+                channelCredentials = grpc.credentials.combineChannelCredentials(channelCredentials, callCredentials);
+            }
+        }
+        const channelOptions = {};
+        if (options.maxReceiveMessageSize) {
+            channelOptions['grpc.max_receive_message_length'] = options.maxReceiveMessageSize;
+        }
+        if (options.maxSendMessageSize) {
+            channelOptions['grpc.max_send_message_length'] = options.maxSendMessageSize;
+        }
+        this.channel = new grpc.Channel(serverAddress, channelCredentials, channelOptions);
+        this.connectionService = new ConnectionServiceClient(serverAddress, channelCredentials);
+        this.services = {
+            eventStores: new EventStoresClient(serverAddress, channelCredentials),
+            namespaces: new NamespacesClient(serverAddress, channelCredentials),
+            recommendations: new RecommendationsClient(serverAddress, channelCredentials),
+            identities: new IdentitiesClient(serverAddress, channelCredentials),
+            eventSequences: new EventSequencesClient(serverAddress, channelCredentials),
+            eventTypes: new EventTypesClient(serverAddress, channelCredentials),
+            constraints: new ConstraintsClient(serverAddress, channelCredentials),
+            observers: new ObserversClient(serverAddress, channelCredentials),
+            failedPartitions: new FailedPartitionsClient(serverAddress, channelCredentials),
+            reactors: new ReactorsClient(serverAddress, channelCredentials),
+            reducers: new ReducersClient(serverAddress, channelCredentials),
+            projections: new ProjectionsClient(serverAddress, channelCredentials),
+            readModels: new ReadModelsClient(serverAddress, channelCredentials),
+            jobs: new JobsClient(serverAddress, channelCredentials),
+            eventSeeding: new EventSeedingClient(serverAddress, channelCredentials),
+            server: new ServerClient(serverAddress, channelCredentials),
+        };
+    }
+    createTokenProvider(options) {
+        try {
+            const authMode = this._connectionString.authenticationMode;
+            if (authMode === AuthenticationMode.ClientCredentials) {
+                const username = this._connectionString.username;
+                const password = this._connectionString.password;
+                if (!username || !password) {
+                    return new NoOpTokenProvider();
+                }
+                const managementPort = options.managementPort || 8080;
+                let authorityHost;
+                let authorityPort;
+                if (options.authority) {
+                    const authorityUrl = new URL(options.authority);
+                    authorityHost = authorityUrl.hostname;
+                    authorityPort = authorityUrl.port ? parseInt(authorityUrl.port, 10) : managementPort;
+                }
+                else {
+                    authorityHost = this._connectionString.serverAddress.host;
+                    authorityPort = managementPort;
+                }
+                const scheme = this._connectionString.disableTls ? 'http' : 'https';
+                const tokenEndpoint = `${scheme}://${authorityHost}:${authorityPort}/connect/token`;
+                return new OAuthTokenProvider(tokenEndpoint, username, password);
+            }
+            return new NoOpTokenProvider();
+        }
+        catch {
+            return new NoOpTokenProvider();
+        }
+    }
+    createAuthCallCredentials() {
+        return grpc.credentials.createFromMetadataGenerator(async (params, callback) => {
+            try {
+                const token = await this.tokenProvider.getAccessToken();
+                const metadata = new grpc.Metadata();
+                if (token) {
+                    metadata.add('authorization', `Bearer ${token}`);
+                }
+                else {
+                    try {
+                        const authMode = this._connectionString.authenticationMode;
+                        if (authMode === AuthenticationMode.ApiKey && this._connectionString.apiKey) {
+                            metadata.add('api-key', this._connectionString.apiKey);
+                        }
+                    }
+                    catch {
+                    }
+                }
+                callback(null, metadata);
+            }
+            catch (error) {
+                callback(error, new grpc.Metadata());
+            }
+        });
+    }
+    get isConnected() {
+        return this._isConnected;
+    }
+    async connect() {
+        if (this._isConnected) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const deadline = new Date();
+            deadline.setSeconds(deadline.getSeconds() + 10);
+            this.channel.watchConnectivityState(this.channel.getConnectivityState(true), deadline, (error) => {
+                if (error) {
+                    this._isConnected = false;
+                    reject(error);
+                }
+                else {
+                    const state = this.channel.getConnectivityState(false);
+                    if (state === grpc.connectivityState.READY) {
+                        this._isConnected = true;
+                        resolve();
+                    }
+                    else {
+                        this._isConnected = false;
+                        reject(new Error(`Connection failed with state: ${state}`));
+                    }
+                }
+            });
+        });
+    }
+    disconnect() {
+        this._isConnected = false;
+        this.channel.close();
+    }
+    dispose() {
+        this.disconnect();
+    }
+}
+//# sourceMappingURL=ChronicleConnection.js.map