@delta-base/core 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,412 @@
+import * as hono_hono_base from 'hono/hono-base';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import * as hono_types from 'hono/types';
+import * as hono from 'hono';
+import { DurableObject } from 'cloudflare:workers';
+import { OpenAPIHono } from '@hono/zod-openapi';
+
+type Flavour<K, T> = K & {
+    readonly __brand?: T;
+};
+type DefaultRecord = Record<string, unknown>;
+type Event<EventType extends string = string, EventData extends DefaultRecord = DefaultRecord, EventMetaData extends DefaultRecord = DefaultRecord> = Flavour<Readonly<{
+    type: EventType;
+    data: EventData;
+    metadata?: EventMetaData;
+}>, 'Event'>;
+type EventTypeOf<T extends Event> = T['type'];
+type EventDataOf<T extends Event> = T['data'];
+type EventMetaDataOf<T extends Event> = T['metadata'];
+type CreateEventType<EventType extends string, EventData extends DefaultRecord, EventMetaData extends DefaultRecord | undefined> = Readonly<{
+    type: EventType;
+    data: EventData;
+    metadata?: EventMetaData;
+}>;
+type ReadEvent<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = CreateEventType<EventTypeOf<EventType>, EventDataOf<EventType>, EventMetaDataType> & EventType & {
+    metadata: EventMetaDataType;
+};
+type ReadEventMetadata = Readonly<{
+    eventId: string;
+    streamPosition: number;
+    streamName: string;
+}>;
+type ReadEventMetadataWithGlobalPosition = ReadEventMetadata & {
+    globalPosition: number;
+};
+type ExpectedStreamVersion<VersionType = DefaultStreamVersionType> = ExpectedStreamVersionWithValue<VersionType> | ExpectedStreamVersionGeneral;
+type ExpectedStreamVersionWithValue<VersionType = DefaultStreamVersionType> = Flavour<VersionType, 'StreamVersion'>;
+type ExpectedStreamVersionGeneral = Flavour<'STREAM_EXISTS' | 'STREAM_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK', 'StreamVersion'>;
+interface EventStore<StreamVersion = DefaultStreamVersionType, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> {
+    aggregateStream<State, EventType extends Event>(streamName: string, options: AggregateStreamOptions<State, EventType, StreamVersion, ReadEventMetadataType>): Promise<AggregateStreamResult<State, StreamVersion> | null>;
+    readStream<EventType extends Event>(streamName: string, options?: ReadStreamOptions<StreamVersion>): Promise<ReadStreamResult<EventType, StreamVersion, ReadEventMetadataType>>;
+    appendToStream<EventType extends Event>(streamName: string, events: EventType[], options?: AppendToStreamOptions<StreamVersion>): Promise<AppendToStreamResult<StreamVersion>>;
+}
+type DefaultStreamVersionType = number;
+type ReadStreamOptions<StreamVersion = DefaultStreamVersionType> = ({
+    from: StreamVersion;
+} | {
+    to: StreamVersion;
+} | {
+    from: StreamVersion;
+    maxCount?: DefaultStreamVersionType;
+} | {
+    expectedStreamVersion: ExpectedStreamVersion<StreamVersion>;
+}) & {
+    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
+};
+type ReadStreamResult<EventType extends Event, StreamVersion = DefaultStreamVersionType, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = {
+    currentStreamVersion: StreamVersion;
+    events: ReadEvent<EventType, ReadEventMetadataType>[];
+} | null;
+type Evolve<State, EventType extends Event, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = ((currentState: State, event: EventType) => State) | ((currentState: State, event: ReadEvent<EventType, ReadEventMetadataType>) => State) | ((currentState: State, event: ReadEvent<EventType>) => State);
+type AggregateStreamOptions<State, EventType extends Event, StreamVersion = DefaultStreamVersionType, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = {
+    evolve: Evolve<State, EventType, ReadEventMetadataType>;
+    initialState: () => State;
+    read?: ReadStreamOptions<StreamVersion>;
+};
+type AggregateStreamResult<State, StreamVersion = DefaultStreamVersionType> = {
+    currentStreamVersion: StreamVersion;
+    state: State;
+};
+type AppendToStreamOptions<StreamVersion = DefaultStreamVersionType> = {
+    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
+};
+type AppendToStreamResult<StreamVersion = DefaultStreamVersionType> = {
+    nextExpectedStreamVersion: StreamVersion;
+};
+
+type EventStoreOutboxEvent = {
+    stream_position: number;
+    global_position: number;
+    event_id: string;
+    event_type: string;
+    event_data: string;
+    event_metadata: string;
+    event_schema_version: string;
+    transaction_id: string;
+    stream_id: string;
+    phase: number;
+    created: string;
+    processing_started_at: string;
+    processed_at: string;
+};
+declare class EventStoreDurableObject extends DurableObject<Env> {
+    sql: SqlStorage;
+    constructor(ctx: DurableObjectState, env: Env);
+    private initializeTables;
+    initialize(eventStoreId: string): void;
+    getEventStoreId(): string;
+    appendToStream(streamId: string, events: Event[], options?: AppendToStreamOptions<number>): Promise<AppendToStreamResult<number>>;
+    private getStreamVersion;
+    private getGlobalPosition;
+    private scheduleAsyncWork;
+    private storeEventsToStream;
+    alarm(_alarmInfo: AlarmInvocationInfo): Promise<void>;
+    queryEvents(options: {
+        afterPosition?: number;
+        limit?: number;
+        streamId?: string;
+        eventType?: string;
+    }): Promise<{
+        events: EventStoreOutboxEvent[];
+        hasMore: boolean;
+        nextPosition: number;
+    }>;
+    getDatabaseSize(): number;
+    readStream<EventType extends Event>(streamId: string, options?: ReadStreamOptions & {
+        consistencyLevel?: 'eventual' | 'strong';
+    }): Promise<ReadStreamResult<EventType, DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition> & {
+        consistency: 'eventual' | 'strong';
+    }>;
+    private waitForStreamVersion;
+    private mergeAndDeduplicateEvents;
+}
+
+type WildcardPattern = '*' | `${string}.*` | `*.${string}` | `${string}.*${string}`;
+type EventType = string;
+type EventFilter = EventType | EventType[] | WildcardPattern;
+interface BaseSubscriberConfig {
+    retryPolicy?: {
+        maxAttempts: number;
+        backoffMinutes: number;
+    };
+}
+interface DurableObjectConfig extends BaseSubscriberConfig {
+    namespace: string;
+    id: string;
+}
+interface CloudflareWorkflowConfig extends BaseSubscriberConfig {
+    bindingName: string;
+}
+interface WebhookConfig extends BaseSubscriberConfig {
+    url: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+}
+interface QueueConfig extends BaseSubscriberConfig {
+    queueName: string;
+    region?: string;
+    batchSize?: number;
+}
+interface WebSocketConfig extends BaseSubscriberConfig {
+    managerId: string;
+}
+declare enum SubscriberType {
+    DurableObject = "durable_object",
+    Webhook = "webhook",
+    Queue = "queue",
+    CloudflareWorkflow = "cloudflare_workflow",
+    WebSocket = "websocket"
+}
+type SubscriberTypeConfig = {
+    type: SubscriberType.DurableObject;
+    config: DurableObjectConfig;
+} | {
+    type: SubscriberType.Webhook;
+    config: WebhookConfig;
+} | {
+    type: SubscriberType.Queue;
+    config: QueueConfig;
+} | {
+    type: SubscriberType.CloudflareWorkflow;
+    config: CloudflareWorkflowConfig;
+} | {
+    type: SubscriberType.WebSocket;
+    config: WebSocketConfig;
+};
+interface Env$1 {
+    [key: string]: DurableObjectNamespace | Workflow;
+}
+interface EventMessage {
+    event_id: string;
+    event_type: string;
+    event_data: Record<string, unknown>;
+    event_metadata: Record<string, unknown>;
+    stream_id: string;
+    stream_position: number;
+    global_position: number;
+    event_schema_version: string;
+    transaction_id: string;
+    created: string;
+}
+declare class EventBusDurableObject extends DurableObject<Env$1> {
+    private readonly BATCH_SIZE;
+    private readonly RETRY_DELAY_HOURS;
+    sql: SqlStorage;
+    constructor(state: DurableObjectState, env: Env$1);
+    private initializeTables;
+    subscribe(eventFilter: EventFilter, subscriberId: string, subscription: SubscriberTypeConfig): Promise<void>;
+    unsubscribe(eventFilter: EventFilter, subscriberId: string): Promise<void>;
+    getSubscriptions(): Promise<{
+        id: string;
+        eventFilter: string;
+        subscriberId: string;
+        subscriberType: SubscriberType;
+        subscriberConfig: string;
+        lastProcessedEventGlobalPosition: number;
+        createdAt: string;
+    }[]>;
+    publish(events: EventStoreOutboxEvent[]): Promise<void>;
+    private getMatchingSubscriptions;
+    private scheduleDelivery;
+    private processOutboxBatch;
+    private getPendingMessages;
+    private reconstructEvent;
+    private parseSubscription;
+    private markMessageAsProcessed;
+    private markMessageAsFailed;
+    private deliverEvent;
+    private logProcessingMetrics;
+    alarm(alarmInfo: AlarmInvocationInfo): Promise<void>;
+    getDatabaseSize(): number;
+    private validateEventFilter;
+}
+
+declare class WebSocketManagerDurableObject extends DurableObject<Env> {
+    fetch(request: Request): Promise<Response>;
+    private findWebSocketsByClientId;
+    deliverEventToClient(clientId: string, event: EventMessage): Promise<void>;
+    broadcastEvent(event: EventMessage): Promise<void>;
+    closeConnection(clientId: string): Promise<void>;
+    webSocketClose(ws: WebSocket, _code: number, reason: string, _wasClean: boolean): Promise<void>;
+}
+
+declare class EventStreamDurableObject extends DurableObject<Env> {
+    sql: SqlStorage;
+    private isProcessing;
+    private static ALARM_DELAY;
+    constructor(ctx: DurableObjectState, env: Env);
+    private initializeTables;
+    initializeStream(streamId: string, eventStoreId: string): void;
+    private getStreamId;
+    private getEventStoreId;
+    appendToStream(events: EventStoreOutboxEvent[]): Promise<void>;
+    getStreamEvents<EventType extends Event>(streamId: string, options?: ReadStreamOptions<number>): ReadStreamResult<EventType, number, ReadEventMetadataWithGlobalPosition>;
+    getEventsByEventIds(eventIds: string[]): Promise<ReadEvent[]>;
+    private checkUnprocessedEvents;
+    private scheduleAsyncWork;
+    private publishEventsToEventBus;
+    private storeEventsToGlobalIndex;
+    alarm(_alarmInfo: AlarmInvocationInfo): Promise<void>;
+}
+
+declare class EventGlobalIndexDurableObject extends DurableObject<Env> {
+    sql: SqlStorage;
+    constructor(ctx: DurableObjectState, env: Env);
+    private initializeTables;
+    appendToIndex(events: EventStoreOutboxEvent[]): Promise<void>;
+    getEventsByType(eventType: string, options?: {
+        fromPosition?: number;
+        limit?: number;
+        streamId?: string;
+    }): Promise<Record<string, SqlStorageValue>[]>;
+    getEventsPaginated(options: {
+        afterPosition?: number;
+        limit?: number;
+        streamId?: string;
+        eventType?: string;
+    }): Promise<{
+        events: Record<string, SqlStorageValue>[];
+        hasMore: boolean;
+        nextPosition: SqlStorageValue | undefined;
+    }>;
+    getEventsByTransactionId(transactionId: string): Promise<Record<string, SqlStorageValue>[]>;
+    getEventCounts(): Promise<Record<string, SqlStorageValue>[]>;
+    getEventTypeDistribution(streamId?: string): Promise<Record<string, SqlStorageValue>[]>;
+    getEventsInTimeAndPositionRange(options: {
+        startTime?: Date;
+        endTime?: Date;
+        minPosition?: number;
+        maxPosition?: number;
+        streamId?: string;
+        limit?: number;
+    }): Promise<Record<string, SqlStorageValue>[]>;
+    getEventStatistics(windowStart: Date, windowEnd: Date): Promise<Record<string, SqlStorageValue>>;
+    getEventsAfterPosition(position: number, limit?: number): Promise<Record<string, SqlStorageValue>[]>;
+    getStreamEvents(streamId: string, options?: {
+        fromPosition?: number;
+        toPosition?: number;
+        limit?: number;
+    }): Promise<Record<string, SqlStorageValue>[]>;
+    getEventsByTimeRange(startTime: Date, endTime: Date, limit?: number): Promise<Record<string, SqlStorageValue>[]>;
+    getLatestEvents(limit?: number): Promise<Record<string, SqlStorageValue>[]>;
+    getStreamPositionRange(streamId: string): Promise<Record<string, SqlStorageValue>>;
+    getDatabaseSize(): number;
+}
+
+declare class EventStoreManagerDurableObject extends DurableObject<Env> {
+    sql: SqlStorage;
+    constructor(ctx: DurableObjectState, env: Env);
+    private initializeTables;
+    createEventStore(eventStoreName: string): Promise<{
+        eventStoreID: string;
+        eventStoreName: string;
+        eventStoreDurableObjectID: string;
+        eventBusDurableObjectID: string;
+        eventGlobalIndexDurableObjectID: string;
+    }>;
+    getEventStoreInfo(eventStoreName: string): {
+        eventStoreID: string;
+        eventStoreName: string;
+        eventStoreDurableObjectID: string;
+        eventBusDurableObjectID: string;
+        eventGlobalIndexDurableObjectID: string;
+    };
+    getEventStoreDatabaseSizes(eventStoreName: string): Promise<{
+        eventStoreDatabaseSize: number;
+        eventBusDatabaseSize: number;
+        eventGlobalIndexDatabaseSize: number;
+    }>;
+}
+
+// Generated by Wrangler by running `wrangler types`
+
+interface Env {
+  EVENT_STORE_MANAGER_DO: DurableObjectNamespace<
+    EventStoreManagerDurableObject
+  >;
+  EVENT_STORE_DO: DurableObjectNamespace<
+    EventStoreDurableObject
+  >;
+  EVENT_BUS_DO: DurableObjectNamespace<
+    EventBusDurableObject
+  >;
+  EVENT_GLOBAL_INDEX_DO: DurableObjectNamespace<
+    EventGlobalIndexDurableObject
+  >;
+  EVENT_STREAM_DO: DurableObjectNamespace<
+    EventStreamDurableObject
+  >;
+  WS_MANAGER_DO: DurableObjectNamespace<
+    WebSocketManagerDurableObject
+  >;
+}
+
+declare const getDOEventStoreManagement: (environmentName: string, env: Env) => {
+    createEventStore: (eventStoreName: string) => Promise<{
+        eventStoreID: string;
+        eventStoreName: string;
+        eventStoreDurableObjectID: string;
+        eventBusDurableObjectID: string;
+        eventGlobalIndexDurableObjectID: string;
+    } & Disposable>;
+    getEventStoreInfo: (eventStoreName: string) => Promise<{
+        eventStoreID: string;
+        eventStoreName: string;
+        eventStoreDurableObjectID: string;
+        eventBusDurableObjectID: string;
+        eventGlobalIndexDurableObjectID: string;
+    } & Disposable>;
+    getEventStoreDatabaseSizes: (eventStoreName: string) => Promise<{
+        eventStoreDatabaseSize: number;
+        eventBusDatabaseSize: number;
+        eventGlobalIndexDatabaseSize: number;
+    } & Disposable>;
+};
+
+declare const getDOEventStore: (eventStoreId: string, env: Env) => EventStore;
+
+declare const getDOEventBus: (eventBusId: string, env: Env) => {
+    subscribe: (eventFilter: EventFilter, subscriberId: string, subscription: SubscriberTypeConfig) => Promise<void>;
+    unsubscribe: (eventFilter: EventFilter, subscriberId: string) => Promise<void>;
+};
+
+interface EventStoreWebSocketRouteConfig {
+    managerId: string;
+    path?: string;
+}
+declare function createEventStoreWebSocketRoute(config: EventStoreWebSocketRouteConfig): {
+    app: OpenAPIHono<{
+        Bindings: Env;
+    }, {}, "/">;
+    getManagerId: () => string;
+};
+
+declare const routes: hono_hono_base.HonoBase<hono.Env, hono_types.MergeSchemaPath<{}, "/api"> & {
+    docs: {
+        $get: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+} & {
+    "/api/reference": {
+        $get: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        } | {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+}, "/api">;
+
+type AppType = typeof routes;
+
+export { type AppType, type BaseSubscriberConfig, type CloudflareWorkflowConfig, type DurableObjectConfig, EventBusDurableObject, type EventFilter, EventGlobalIndexDurableObject, EventStoreDurableObject, type Env as EventStoreEnv, EventStoreManagerDurableObject, EventStreamDurableObject, type EventType, type QueueConfig, SubscriberType, WebSocketManagerDurableObject, type WebhookConfig, type WildcardPattern, createEventStoreWebSocketRoute, routes as default, getDOEventBus, getDOEventStore, getDOEventStoreManagement };