@delta-base/core 1.4.0 → 1.5.1

package/dist/index.d.ts

@@ -81,6 +81,22 @@ declare namespace EventBusAPI {
             earliest: "earliest";
         }>>>;
     }, z.core.$strip>;
+    const ReplayRequestSchema: z.ZodObject<{
+        fromGlobalPosition: z.ZodOptional<z.ZodNumber>;
+        fromCreatedAt: z.ZodOptional<z.ZodString>;
+        toGlobalPosition: z.ZodOptional<z.ZodNumber>;
+        toCreatedAt: z.ZodOptional<z.ZodString>;
+        eventTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    const ReplayStatusResponseSchema: z.ZodObject<{
+        inProgress: z.ZodBoolean;
+        startPosition: z.ZodNullable<z.ZodNumber>;
+        targetPosition: z.ZodNullable<z.ZodNumber>;
+        currentPosition: z.ZodNumber;
+        processedCount: z.ZodNumber;
+        estimatedEvents: z.ZodNumber;
+        startedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
     const UpdateSubscriptionRequestSchema: z.ZodObject<{
         eventFilter: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodString, z.ZodString]>, z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodString, z.ZodString]>>]>>;
         subscriberConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -1008,6 +1024,222 @@ declare namespace EventBusAPI {
                 status: 409;
             };
         };
+    } & {
+        "/event-stores/:eventStoreName/subscriptions/:subscriberId/replay": {
+            $post: {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        fromGlobalPosition?: number | undefined;
+                        fromCreatedAt?: string | undefined;
+                        toGlobalPosition?: number | undefined;
+                        toCreatedAt?: string | undefined;
+                        eventTypes?: string[] | undefined;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 400;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        fromGlobalPosition?: number | undefined;
+                        fromCreatedAt?: string | undefined;
+                        toGlobalPosition?: number | undefined;
+                        toCreatedAt?: string | undefined;
+                        eventTypes?: string[] | undefined;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 401;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        fromGlobalPosition?: number | undefined;
+                        fromCreatedAt?: string | undefined;
+                        toGlobalPosition?: number | undefined;
+                        toCreatedAt?: string | undefined;
+                        eventTypes?: string[] | undefined;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 404;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        fromGlobalPosition?: number | undefined;
+                        fromCreatedAt?: string | undefined;
+                        toGlobalPosition?: number | undefined;
+                        toCreatedAt?: string | undefined;
+                        eventTypes?: string[] | undefined;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 500;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        fromGlobalPosition?: number | undefined;
+                        fromCreatedAt?: string | undefined;
+                        toGlobalPosition?: number | undefined;
+                        toCreatedAt?: string | undefined;
+                        eventTypes?: string[] | undefined;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 409;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        fromGlobalPosition?: number | undefined;
+                        fromCreatedAt?: string | undefined;
+                        toGlobalPosition?: number | undefined;
+                        toCreatedAt?: string | undefined;
+                        eventTypes?: string[] | undefined;
+                    };
+                };
+                output: {
+                    message: string;
+                    fromPosition: number;
+                    estimatedEvents: number;
+                };
+                outputFormat: "json";
+                status: 202;
+            };
+        };
+    } & {
+        "/event-stores/:eventStoreName/subscriptions/:subscriberId/replay": {
+            $get: {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 401;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 404;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 500;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                };
+                output: {
+                    inProgress: boolean;
+                    startPosition: number | null;
+                    targetPosition: number | null;
+                    currentPosition: number;
+                    processedCount: number;
+                    estimatedEvents: number;
+                    startedAt: string | null;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        };
     }, "/">;
 }
 
@@ -2997,6 +3229,14 @@ declare class EventBusDurableObject extends DurableObject<Env> {
         transaction_id: string;
         created: string;
     }[]): Promise<void>;
+    /**
+     * Coordinates fetching events for replay from EventStoreDO
+     * @param fromGlobalPosition - The global position to start fetching from
+     * @param limit - Maximum number of events to fetch
+     * @param eventFilter - Optional event type filter (supports wildcards)
+     * @returns Array of events for replay
+     */
+    getEventsForReplay(fromGlobalPosition: number, limit: number, eventFilter?: string): Promise<EventMessage[]>;
     private getMatchingSubscriptions;
     private requestDelivery;
     private processOutboxBatch;
@@ -3084,6 +3324,25 @@ declare class EventBusDurableObject extends DurableObject<Env> {
         legacyCount: number;
         legacyOutboxCount: number;
     }>;
+    /**
+     * Checks how many SubscriberDOs still need event_store_id backfilled.
+     * Queries each SubscriberDO's config to check if event_store_id is set.
+     */
+    getBackfillStatus(): Promise<{
+        total: number;
+        backfilled: number;
+        pending: number;
+        complete: boolean;
+    }>;
+    /**
+     * Backfills event_store_id on all SubscriberDOs for this EventBusDO.
+     * Idempotent — safe to run multiple times. Calls setEventStoreId()
+     * on each SubscriberDO that has a subscriber_do_id.
+     */
+    backfillEventStoreIds(): Promise<{
+        updated: number;
+        failed: number;
+    }>;
     /**
      * Reconstructs an EventMessage from a subscriptions_outbox row
      */
@@ -3276,6 +3535,24 @@ declare class EventStoreDurableObject extends DurableObject<Env> {
      * @returns Promise resolving to filtered events and optional count
      */
     queryEvents(params?: EventsQueryParams): Promise<QueryEventsResult>;
+    /**
+     * Gets events for replay starting from a specific global position
+     * @param fromGlobalPosition - The global position to start fetching from
+     * @param limit - Maximum number of events to fetch
+     * @param eventFilter - Optional event type filter (supports wildcards like "orders.*")
+     * @returns Array of events for replay
+     */
+    getEventsForReplay(fromGlobalPosition: number, limit: number, eventFilter?: string): Promise<EventMessage[]>;
+    /**
+     * Resolves an ISO datetime to the nearest global position at or after that time.
+     * Returns 0 if no events exist at or after the given datetime.
+     */
+    resolveCreatedAtToPosition(createdAt: string): number;
+    /**
+     * Returns the maximum global position across all non-archived events.
+     * Returns 0 if no events exist.
+     */
+    getHeadPosition(): number;
     /**
      * Queries streams based on filtering parameters
      * @param params - Query parameters for filtering streams
@@ -3634,23 +3911,80 @@ declare class EventStoreManagerDurableObject extends DurableObject<Env> {
 
 interface SubscriberInitConfig {
     subscriberId: string;
+    eventStoreId: string;
     subscriberType: SubscriberType;
     subscriberConfig: SubscriberTypeConfig['config'];
     eventFilter: string;
     retryPolicy: RetryPolicy;
 }
+interface ReplayOptions {
+    fromGlobalPosition?: number;
+    fromCreatedAt?: string;
+    toGlobalPosition?: number;
+    toCreatedAt?: string;
+    eventTypes?: string[];
+}
+interface ReplayStatus {
+    inProgress: boolean;
+    startPosition: number | null;
+    targetPosition: number | null;
+    currentPosition: number;
+    processedCount: number;
+    estimatedEvents: number;
+    startedAt: string | null;
+}
 type SubscriberStatus = 'ACTIVE' | 'PAUSED' | 'ERROR';
 declare class SubscriberDurableObject extends DurableObject<Env> {
     private readonly BATCH_SIZE;
     private readonly MAX_BATCHES_PER_ALARM;
+    private readonly REPLAY_BATCH_SIZE;
+    private readonly REPLAY_DELAY_MS;
+    private readonly REPLAY_STALE_TIMEOUT_MS;
     private isAlarmActive;
     private isSchedulingAlarm;
     sql: SqlStorage;
     constructor(state: DurableObjectState, env: Env);
     private initializeTables;
+    /**
+     * Handles schema migrations for existing SubscriberDOs.
+     * Uses PRAGMA table_info to detect missing columns and adds them.
+     * This runs in blockConcurrencyWhile so it's safe on every wake.
+     */
+    private migrateSchema;
+    private ensureConfigColumn;
+    private ensureCursorColumn;
     initialize(config: SubscriberInitConfig): void;
+    /**
+     * Returns whether this subscriber has event_store_id set in its config.
+     * Used by the backfill status check.
+     */
+    hasEventStoreId(): boolean;
+    /**
+     * Sets the event store ID for this subscriber.
+     * Used by backfill migration for existing DOs that were created
+     * before event_store_id was added to the config table.
+     */
+    setEventStoreId(eventStoreId: string): void;
     setCursor(position: number): void;
+    replay(options: ReplayOptions): Promise<void>;
+    /**
+     * Resolves an ISO datetime to the nearest global position at or after that time.
+     */
+    private resolveCreatedAtToPosition;
+    /**
+     * Fetches the current head (max) global position from EventStoreDO.
+     */
+    private fetchHeadPosition;
+    getReplayStatus(): ReplayStatus;
+    private getSubscriberId;
+    private completeReplay;
     enqueue(events: EventMessage[]): Promise<void>;
+    /**
+     * Internal enqueue that inserts events without replay guard logic.
+     * Used by both public enqueue() and processReplayBatch().
+     */
+    private enqueueInternal;
+    private isReplayInProgress;
     private requestAlarm;
     private getConfigRow;
     private getSubscriberStatus;
@@ -3666,6 +4000,14 @@ declare class SubscriberDurableObject extends DurableObject<Env> {
     private updateRetryState;
     private deliverEvent;
     alarm(): Promise<void>;
+    /**
+     * Fetches and enqueues the next batch of replay events.
+     * @returns The number of events fetched in this batch (0 means replay fetching is done).
+     */
+    private processReplayBatch;
+    private getEventStoreId;
+    private getEventFilter;
+    private scheduleReplayAlarm;
 }
 
 interface ConnectionListOptions {
@@ -5788,6 +6130,222 @@ declare const routes: hono_hono_base.HonoBase<{
             status: 409;
         };
     };
+} & {
+    "/event-stores/:eventStoreName/subscriptions/:subscriberId/replay": {
+        $post: {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    fromGlobalPosition?: number | undefined;
+                    fromCreatedAt?: string | undefined;
+                    toGlobalPosition?: number | undefined;
+                    toCreatedAt?: string | undefined;
+                    eventTypes?: string[] | undefined;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    fromGlobalPosition?: number | undefined;
+                    fromCreatedAt?: string | undefined;
+                    toGlobalPosition?: number | undefined;
+                    toCreatedAt?: string | undefined;
+                    eventTypes?: string[] | undefined;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    fromGlobalPosition?: number | undefined;
+                    fromCreatedAt?: string | undefined;
+                    toGlobalPosition?: number | undefined;
+                    toCreatedAt?: string | undefined;
+                    eventTypes?: string[] | undefined;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    fromGlobalPosition?: number | undefined;
+                    fromCreatedAt?: string | undefined;
+                    toGlobalPosition?: number | undefined;
+                    toCreatedAt?: string | undefined;
+                    eventTypes?: string[] | undefined;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 500;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    fromGlobalPosition?: number | undefined;
+                    fromCreatedAt?: string | undefined;
+                    toGlobalPosition?: number | undefined;
+                    toCreatedAt?: string | undefined;
+                    eventTypes?: string[] | undefined;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 409;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    fromGlobalPosition?: number | undefined;
+                    fromCreatedAt?: string | undefined;
+                    toGlobalPosition?: number | undefined;
+                    toCreatedAt?: string | undefined;
+                    eventTypes?: string[] | undefined;
+                };
+            };
+            output: {
+                message: string;
+                fromPosition: number;
+                estimatedEvents: number;
+            };
+            outputFormat: "json";
+            status: 202;
+        };
+    };
+} & {
+    "/event-stores/:eventStoreName/subscriptions/:subscriberId/replay": {
+        $get: {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 500;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            };
+            output: {
+                inProgress: boolean;
+                startPosition: number | null;
+                targetPosition: number | null;
+                currentPosition: number;
+                processedCount: number;
+                estimatedEvents: number;
+                startedAt: string | null;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
 }, "/api"> | hono_types.MergeSchemaPath<{
     "/event-stores/:eventStoreName/events/ws": {
         $get: {