velocious 1.0.299 → 1.0.301

package/build/src/http-server/websocket-channel.js

@@ -5,13 +5,17 @@ export default class VelociousHttpServerWebsocketChannel {
      * @param {import("../configuration.js").default} args.configuration - Configuration instance.
      * @param {import("./client/request.js").default | import("./client/websocket-request.js").default | undefined} args.request - Request instance.
      * @param {import("./client/index.js").default} args.client - Client instance.
+     * @param {string} [args.lastEventId] - Last received event id.
+     * @param {string} [args.subscriptionChannel] - Client-facing subscription channel.
      * @param {import("./client/websocket-session.js").default} args.websocketSession - Websocket session.
      * @param {Record<string, unknown>} [args.subscriptionParams] - Params from subscribe message.
      */
-    constructor({ configuration, request, client, websocketSession, subscriptionParams }) {
+    constructor({ configuration, request, client, lastEventId, subscriptionChannel, websocketSession, subscriptionParams }) {
         this.configuration = configuration;
         this.request = request;
         this.client = client;
+        this.lastEventId = lastEventId;
+        this.subscriptionChannel = subscriptionChannel;
         this.websocketSession = websocketSession;
         this.subscriptionParams = subscriptionParams;
         this._params = this._buildParams();
@@ -33,24 +37,32 @@ export default class VelociousHttpServerWebsocketChannel {
     /**
      * Subscribe this connection to a broadcast channel.
      * @param {string} channel - Channel name.
-     * @param {{acknowledge?: boolean}} [options] - Subscription options.
+     * @param {{acknowledge?: boolean, lastEventId?: string}} [options] - Subscription options.
      * @returns {Promise<boolean>} - Whether the subscription succeeded.
      */
     async streamFrom(channel, options = {}) {
+        const lastEventId = options.lastEventId ?? this.lastEventId;
         return await this.websocketSession.subscribeToChannel(channel, {
             acknowledge: options.acknowledge ?? true,
-            channelHandler: this
+            channelHandler: this,
+            lastEventId,
+            params: this.subscriptionParams,
+            subscriptionChannel: this.subscriptionChannel
         });
     }
     /**
      * Called when a broadcast event is delivered for one of this channel instance's subscriptions.
      * @param {object} args - Event args.
      * @param {string} args.channel - Broadcast channel name.
+     * @param {string} [args.createdAt] - Event creation timestamp.
+     * @param {string} [args.eventId] - Event id.
      * @param {any} args.payload - Broadcast payload.
+     * @param {boolean} [args.replayed] - Whether this event was replayed.
+     * @param {number} [args.sequence] - Event sequence.
      * @returns {Promise<void>} - Resolves when complete.
      */
-    async receivedBroadcast({ channel, payload }) {
-        this.websocketSession.sendJson({ channel, payload, type: "event" });
+    async receivedBroadcast({ channel, createdAt, eventId, payload, replayed, sequence }) {
+        this.websocketSession.sendJson({ channel, createdAt, eventId, payload, replayed, sequence, type: "event" });
     }
     /**
      * @returns {Record<string, unknown>} - Parsed params.
@@ -80,4 +92,4 @@ export default class VelociousHttpServerWebsocketChannel {
         return params;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-channel.js","sourceRoot":"","sources":["../../../src/http-server/websocket-channel.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,MAAM,CAAC,OAAO,OAAO,mCAAmC;IACtD;;;;;;;;;OASG;IACH,YAAY,EAAC,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,kBAAkB,EAAC;QAClH,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;QAC9B,IAAI,CAAC,mBAAmB,GAAG,mBAAmB,CAAA;QAC9C,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAA;QACxC,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAA;QAC5C,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,YAAY,EAAE,CAAA;IACpC,CAAC;IAED;;OAEG;IACH,MAAM,KAAK,OAAO,IAAI,CAAC,OAAO,CAAA,CAAC,CAAC;IAEhC;;;OAGG;IACH,KAAK,CAAC,UAAU,KAAI,CAAC;IAErB;;;OAGG;IACH,KAAK,CAAC,YAAY,KAAI,CAAC;IAEvB;;;;;OAKG;IACH,KAAK,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,EAAE;QACpC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,CAAA;QAE3D,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,OAAO,EAAE;YAC7D,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,IAAI;YACxC,cAAc,EAAE,IAAI;YACpB,WAAW;YACX,MAAM,EAAE,IAAI,CAAC,kBAAkB;YAC/B,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;SAC9C,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,iBAAiB,CAAC,EAAC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAC;QAChF,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAC,CAAC,CAAA;IAC3G,CAAC;IAED;;OAEG;IACH,YAAY;QACV,sCAAsC;QACtC,MAAM,MAAM,GAAG,EAAE,CAAA;QAEjB,IAAI,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;YACzB,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAA;YAE3C,IAAI,aAAa,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;gBACvD,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;YACtC,CAAC;QACH,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,CAAA;QACxC,MAAM,KAAK,GAAG,SAAS,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;QAEtC,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,YAAY,GAAG,IAAI,eAAe,CAAC,KAAK,CAAC,CAAA;YAE/C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC;gBAClD,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;oBAC9B,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;gBACrB,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,IAAI,CAAC,kBAAkB,IAAI,OAAO,IAAI,CAAC,kBAAkB,KAAK,QAAQ,EAAE,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAA;QAChD,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;CACF","sourcesContent":["// @ts-check\n\nexport default class VelociousHttpServerWebsocketChannel {\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"./client/request.js\").default | import(\"./client/websocket-request.js\").default | undefined} args.request - Request instance.\n   * @param {import(\"./client/index.js\").default} args.client - Client instance.\n   * @param {string} [args.lastEventId] - Last received event id.\n   * @param {string} [args.subscriptionChannel] - Client-facing subscription channel.\n   * @param {import(\"./client/websocket-session.js\").default} args.websocketSession - Websocket session.\n   * @param {Record<string, unknown>} [args.subscriptionParams] - Params from subscribe message.\n   */\n  constructor({configuration, request, client, lastEventId, subscriptionChannel, websocketSession, subscriptionParams}) {\n    this.configuration = configuration\n    this.request = request\n    this.client = client\n    this.lastEventId = lastEventId\n    this.subscriptionChannel = subscriptionChannel\n    this.websocketSession = websocketSession\n    this.subscriptionParams = subscriptionParams\n    this._params = this._buildParams()\n  }\n\n  /**\n   * @returns {Record<string, unknown>} - Params for the websocket connection.\n   */\n  params() { return this._params }\n\n  /**\n   * Called when the channel is created for a websocket connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async subscribed() {}\n\n  /**\n   * Called when the websocket disconnects.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async unsubscribed() {}\n\n  /**\n   * Subscribe this connection to a broadcast channel.\n   * @param {string} channel - Channel name.\n   * @param {{acknowledge?: boolean, lastEventId?: string}} [options] - Subscription options.\n   * @returns {Promise<boolean>} - Whether the subscription succeeded.\n   */\n  async streamFrom(channel, options = {}) {\n    const lastEventId = options.lastEventId ?? this.lastEventId\n\n    return await this.websocketSession.subscribeToChannel(channel, {\n      acknowledge: options.acknowledge ?? true,\n      channelHandler: this,\n      lastEventId,\n      params: this.subscriptionParams,\n      subscriptionChannel: this.subscriptionChannel\n    })\n  }\n\n  /**\n   * Called when a broadcast event is delivered for one of this channel instance's subscriptions.\n   * @param {object} args - Event args.\n   * @param {string} args.channel - Broadcast channel name.\n   * @param {string} [args.createdAt] - Event creation timestamp.\n   * @param {string} [args.eventId] - Event id.\n   * @param {any} args.payload - Broadcast payload.\n   * @param {boolean} [args.replayed] - Whether this event was replayed.\n   * @param {number} [args.sequence] - Event sequence.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async receivedBroadcast({channel, createdAt, eventId, payload, replayed, sequence}) {\n    this.websocketSession.sendJson({channel, createdAt, eventId, payload, replayed, sequence, type: \"event\"})\n  }\n\n  /**\n   * @returns {Record<string, unknown>} - Parsed params.\n   */\n  _buildParams() {\n    /** @type {Record<string, unknown>} */\n    const params = {}\n\n    if (this.request?.params) {\n      const requestParams = this.request.params()\n\n      if (requestParams && typeof requestParams === \"object\") {\n        Object.assign(params, requestParams)\n      }\n    }\n\n    const pathValue = this.request?.path?.()\n    const query = pathValue?.split(\"?\")[1]\n\n    if (query) {\n      const searchParams = new URLSearchParams(query)\n\n      for (const [key, value] of searchParams.entries()) {\n        if (params[key] === undefined) {\n          params[key] = value\n        }\n      }\n    }\n\n    if (this.subscriptionParams && typeof this.subscriptionParams === \"object\") {\n      Object.assign(params, this.subscriptionParams)\n    }\n\n    return params\n  }\n}\n"]}

package/build/src/http-server/websocket-event-log-store.d.ts

@@ -0,0 +1,198 @@
+/**
+ * @typedef {object} WebsocketEventRow
+ * @property {string} channel - Channel name.
+ * @property {Date | string} created_at - Creation time.
+ * @property {string} id - Event id.
+ * @property {string} payload_json - Serialized payload.
+ * @property {number | string} sequence - Sequence number.
+ */
+/**
+ * @typedef {object} WebsocketReplayChannelRow
+ * @property {string} channel - Channel name.
+ */
+/**
+ * @param {import("../configuration.js").default} configuration - Configuration.
+ * @returns {VelociousHttpServerWebsocketEventLogStore} - Shared store instance.
+ */
+export function websocketEventLogStoreForConfiguration(configuration: import("../configuration.js").default): VelociousHttpServerWebsocketEventLogStore;
+export default class VelociousHttpServerWebsocketEventLogStore {
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration.
+     * @param {string} [args.databaseIdentifier] - Database identifier.
+     * @param {number} [args.retentionMs] - Event retention in milliseconds.
+     */
+    constructor({ configuration, databaseIdentifier, retentionMs }: {
+        configuration: import("../configuration.js").default;
+        databaseIdentifier?: string | undefined;
+        retentionMs?: number | undefined;
+    });
+    configuration: import("../configuration.js").default;
+    databaseIdentifier: string;
+    retentionMs: number;
+    logger: Logger;
+    _isReady: boolean;
+    _readyPromise: Promise<void> | null;
+    /**
+     * @returns {Promise<void>} - Resolves when ready.
+     */
+    ensureReady(): Promise<void>;
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {unknown} args.payload - Event payload.
+     * @returns {Promise<{channel: string, createdAt: string, id: string, payload: unknown}>} - Persisted event row.
+     */
+    appendEvent({ channel, payload }: {
+        channel: string;
+        payload: unknown;
+    }): Promise<{
+        channel: string;
+        createdAt: string;
+        id: string;
+        payload: unknown;
+    }>;
+    /**
+     * @param {string} channel - Channel name.
+     * @returns {Promise<void>} - Resolves when the channel interest was persisted.
+     */
+    markChannelInterested(channel: string): Promise<void>;
+    /**
+     * @param {string} channel - Channel name.
+     * @returns {Promise<boolean>} - Whether the channel should be persisted for replay.
+     */
+    shouldPersistChannel(channel: string): Promise<boolean>;
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {string} args.id - Event id.
+     * @returns {Promise<{channel: string, createdAt: string, id: string, payload: unknown, sequence: number} | null>} - Event row or null.
+     */
+    getEventById({ channel, id }: {
+        channel: string;
+        id: string;
+    }): Promise<{
+        channel: string;
+        createdAt: string;
+        id: string;
+        payload: unknown;
+        sequence: number;
+    } | null>;
+    /**
+     * @param {string} channel - Channel name.
+     * @returns {Promise<number | null>} - Latest channel sequence.
+     */
+    latestSequence(channel: string): Promise<number | null>;
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {number} args.sequence - Lower bound sequence.
+     * @param {number | null | undefined} [args.upToSequence] - Inclusive ceiling sequence.
+     * @returns {Promise<Array<{channel: string, createdAt: string, id: string, payload: unknown, sequence: number}>>} - Ordered events.
+     */
+    getEventsAfter({ channel, sequence, upToSequence }: {
+        channel: string;
+        sequence: number;
+        upToSequence?: number | null | undefined;
+    }): Promise<Array<{
+        channel: string;
+        createdAt: string;
+        id: string;
+        payload: unknown;
+        sequence: number;
+    }>>;
+    /**
+     * @param {object} [args] - Options.
+     * @param {Date} [args.now] - Cleanup reference time.
+     * @returns {Promise<void>} - Resolves when cleanup completes.
+     */
+    cleanupExpired({ now }?: {
+        now?: Date | undefined;
+    }): Promise<void>;
+    _ensureSchema(): Promise<void>;
+    /**
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    _ensureEventsTable(db: import("../database/drivers/base.js").default): Promise<void>;
+    /**
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    _ensureReplayChannelsTable(db: import("../database/drivers/base.js").default): Promise<void>;
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {import("../database/drivers/base.js").default} args.db - Database connection.
+     * @param {string} args.id - Event id.
+     * @returns {Promise<{channel: string, createdAt: string, id: string, payload: unknown, sequence: number} | null>} - Event row or null.
+     */
+    _getEventById({ channel, db, id }: {
+        channel: string;
+        db: import("../database/drivers/base.js").default;
+        id: string;
+    }): Promise<{
+        channel: string;
+        createdAt: string;
+        id: string;
+        payload: unknown;
+        sequence: number;
+    } | null>;
+    /**
+     * @param {WebsocketEventRow} row - Raw row.
+     * @returns {{channel: string, createdAt: string, id: string, payload: unknown, sequence: number}} - Normalized row.
+     */
+    _normalizeEventRow(row: WebsocketEventRow): {
+        channel: string;
+        createdAt: string;
+        id: string;
+        payload: unknown;
+        sequence: number;
+    };
+    /**
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {Date} args.interestedUntil - Retention deadline.
+     * @returns {Promise<void>} - Resolves when the replay-channel row was upserted.
+     */
+    _upsertReplayChannelInterest(db: import("../database/drivers/base.js").default, { channel, interestedUntil }: {
+        channel: string;
+        interestedUntil: Date;
+    }): Promise<void>;
+    /**
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<any>} callback - Callback.
+     * @returns {Promise<any>} - Callback result.
+     */
+    _withDb(callback: (db: import("../database/drivers/base.js").default) => Promise<any>): Promise<any>;
+}
+export type WebsocketEventRow = {
+    /**
+     * - Channel name.
+     */
+    channel: string;
+    /**
+     * - Creation time.
+     */
+    created_at: Date | string;
+    /**
+     * - Event id.
+     */
+    id: string;
+    /**
+     * - Serialized payload.
+     */
+    payload_json: string;
+    /**
+     * - Sequence number.
+     */
+    sequence: number | string;
+};
+export type WebsocketReplayChannelRow = {
+    /**
+     * - Channel name.
+     */
+    channel: string;
+};
+import Logger from "../logger.js";
+//# sourceMappingURL=websocket-event-log-store.d.ts.map

package/build/src/http-server/websocket-event-log-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-event-log-store.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-event-log-store.js"],"names":[],"mappings":"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"}

package/build/src/http-server/websocket-event-log-store.js

@@ -0,0 +1,308 @@
+// @ts-check
+import { randomUUID } from "crypto";
+import TableData from "../database/table-data/index.js";
+import Logger from "../logger.js";
+const EVENTS_TABLE = "websocket_channel_events";
+const REPLAY_CHANNELS_TABLE = "websocket_replay_channels";
+const DEFAULT_RETENTION_MS = 10 * 60 * 1000;
+const stores = new WeakMap();
+/**
+ * @typedef {object} WebsocketEventRow
+ * @property {string} channel - Channel name.
+ * @property {Date | string} created_at - Creation time.
+ * @property {string} id - Event id.
+ * @property {string} payload_json - Serialized payload.
+ * @property {number | string} sequence - Sequence number.
+ */
+/**
+ * @typedef {object} WebsocketReplayChannelRow
+ * @property {string} channel - Channel name.
+ */
+/**
+ * @param {import("../configuration.js").default} configuration - Configuration.
+ * @returns {VelociousHttpServerWebsocketEventLogStore} - Shared store instance.
+ */
+export function websocketEventLogStoreForConfiguration(configuration) {
+    let store = stores.get(configuration);
+    if (!store) {
+        store = new VelociousHttpServerWebsocketEventLogStore({ configuration });
+        stores.set(configuration, store);
+    }
+    return store;
+}
+export default class VelociousHttpServerWebsocketEventLogStore {
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration.
+     * @param {string} [args.databaseIdentifier] - Database identifier.
+     * @param {number} [args.retentionMs] - Event retention in milliseconds.
+     */
+    constructor({ configuration, databaseIdentifier = "default", retentionMs = DEFAULT_RETENTION_MS }) {
+        this.configuration = configuration;
+        this.databaseIdentifier = databaseIdentifier;
+        this.retentionMs = retentionMs;
+        this.logger = new Logger(this);
+        this._isReady = false;
+        this._readyPromise = null;
+    }
+    /**
+     * @returns {Promise<void>} - Resolves when ready.
+     */
+    async ensureReady() {
+        if (this._isReady)
+            return;
+        if (this._readyPromise)
+            return await this._readyPromise;
+        this._readyPromise = (async () => {
+            this.configuration.setCurrent();
+            await this._ensureSchema();
+            this._isReady = true;
+        })();
+        try {
+            await this._readyPromise;
+        }
+        finally {
+            if (!this._isReady) {
+                this._readyPromise = null;
+            }
+        }
+    }
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {unknown} args.payload - Event payload.
+     * @returns {Promise<{channel: string, createdAt: string, id: string, payload: unknown}>} - Persisted event row.
+     */
+    async appendEvent({ channel, payload }) {
+        await this.ensureReady();
+        const id = randomUUID();
+        const createdAt = new Date();
+        return await this._withDb(async (db) => {
+            await db.insert({
+                tableName: EVENTS_TABLE,
+                data: {
+                    channel,
+                    created_at: createdAt,
+                    id,
+                    payload_json: JSON.stringify(payload)
+                }
+            });
+            return { channel, createdAt: createdAt.toISOString(), id, payload };
+        });
+    }
+    /**
+     * @param {string} channel - Channel name.
+     * @returns {Promise<void>} - Resolves when the channel interest was persisted.
+     */
+    async markChannelInterested(channel) {
+        await this.ensureReady();
+        const interestedUntil = new Date(Date.now() + this.retentionMs);
+        await this._withDb(async (db) => {
+            await this._upsertReplayChannelInterest(db, { channel, interestedUntil });
+        });
+    }
+    /**
+     * @param {string} channel - Channel name.
+     * @returns {Promise<boolean>} - Whether the channel should be persisted for replay.
+     */
+    async shouldPersistChannel(channel) {
+        await this.ensureReady();
+        return await this._withDb(async (db) => {
+            const rows = await db
+                .newQuery()
+                .from(REPLAY_CHANNELS_TABLE)
+                .where({ channel })
+                .where(`interested_until > ${db.quote(new Date())}`)
+                .limit(1)
+                .results();
+            return rows.length > 0;
+        });
+    }
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {string} args.id - Event id.
+     * @returns {Promise<{channel: string, createdAt: string, id: string, payload: unknown, sequence: number} | null>} - Event row or null.
+     */
+    async getEventById({ channel, id }) {
+        await this.ensureReady();
+        return await this._withDb(async (db) => {
+            return await this._getEventById({ channel, db, id });
+        });
+    }
+    /**
+     * @param {string} channel - Channel name.
+     * @returns {Promise<number | null>} - Latest channel sequence.
+     */
+    async latestSequence(channel) {
+        await this.ensureReady();
+        return await this._withDb(async (db) => {
+            const rows = await db
+                .newQuery()
+                .from(EVENTS_TABLE)
+                .where({ channel })
+                .order("sequence DESC")
+                .limit(1)
+                .results();
+            const row = /** @type {Record<string, any> | undefined} */ (rows[0]);
+            if (!row)
+                return null;
+            return Number(row.sequence);
+        });
+    }
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {number} args.sequence - Lower bound sequence.
+     * @param {number | null | undefined} [args.upToSequence] - Inclusive ceiling sequence.
+     * @returns {Promise<Array<{channel: string, createdAt: string, id: string, payload: unknown, sequence: number}>>} - Ordered events.
+     */
+    async getEventsAfter({ channel, sequence, upToSequence }) {
+        await this.ensureReady();
+        return await this._withDb(async (db) => {
+            const query = db
+                .newQuery()
+                .from(EVENTS_TABLE)
+                .where({ channel })
+                .where(`sequence > ${db.quote(sequence)}`)
+                .order("sequence ASC");
+            if (typeof upToSequence === "number") {
+                query.where(`sequence <= ${db.quote(upToSequence)}`);
+            }
+            const rows = /** @type {WebsocketEventRow[]} */ (await query.results());
+            return rows.map((row) => this._normalizeEventRow(row));
+        });
+    }
+    /**
+     * @param {object} [args] - Options.
+     * @param {Date} [args.now] - Cleanup reference time.
+     * @returns {Promise<void>} - Resolves when cleanup completes.
+     */
+    async cleanupExpired({ now = new Date() } = {}) {
+        await this.ensureReady();
+        const cutoff = new Date(now.getTime() - this.retentionMs);
+        await this._withDb(async (db) => {
+            const expiredEventRows = /** @type {Array<{id: string}>} */ (await db
+                .newQuery()
+                .from(EVENTS_TABLE)
+                .where(`created_at <= ${db.quote(cutoff)}`)
+                .results());
+            const expiredReplayChannelRows = /** @type {WebsocketReplayChannelRow[]} */ (await db
+                .newQuery()
+                .from(REPLAY_CHANNELS_TABLE)
+                .where(`interested_until <= ${db.quote(now)}`)
+                .results());
+            for (const expiredEventRow of expiredEventRows) {
+                await db.delete({
+                    tableName: EVENTS_TABLE,
+                    conditions: { id: expiredEventRow.id }
+                });
+            }
+            for (const expiredReplayChannelRow of expiredReplayChannelRows) {
+                await db.delete({
+                    tableName: REPLAY_CHANNELS_TABLE,
+                    conditions: { channel: expiredReplayChannelRow.channel }
+                });
+            }
+        });
+    }
+    async _ensureSchema() {
+        await this._withDb(async (db) => {
+            await this._ensureEventsTable(db);
+            await this._ensureReplayChannelsTable(db);
+        });
+    }
+    /**
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _ensureEventsTable(db) {
+        this.logger.info("Applying websocket event-log schema");
+        if (await db.tableExists(EVENTS_TABLE)) {
+            this.logger.info("Websocket event-log table already exists - skipping create");
+            return;
+        }
+        const eventTable = new TableData(EVENTS_TABLE, { ifNotExists: true });
+        eventTable.integer("sequence", { autoIncrement: true, null: false, primaryKey: true });
+        eventTable.string("id", { index: true, null: false });
+        eventTable.string("channel", { index: true, null: false });
+        eventTable.text("payload_json", { null: false });
+        eventTable.datetime("created_at", { index: true, null: false });
+        await db.createTable(eventTable);
+    }
+    /**
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _ensureReplayChannelsTable(db) {
+        if (await db.tableExists(REPLAY_CHANNELS_TABLE))
+            return;
+        const replayChannelTable = new TableData(REPLAY_CHANNELS_TABLE, { ifNotExists: true });
+        replayChannelTable.string("channel", { null: false, primaryKey: true });
+        replayChannelTable.datetime("interested_until", { index: true, null: false });
+        await db.createTable(replayChannelTable);
+    }
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {import("../database/drivers/base.js").default} args.db - Database connection.
+     * @param {string} args.id - Event id.
+     * @returns {Promise<{channel: string, createdAt: string, id: string, payload: unknown, sequence: number} | null>} - Event row or null.
+     */
+    async _getEventById({ channel, db, id }) {
+        const rows = /** @type {WebsocketEventRow[]} */ (await db
+            .newQuery()
+            .from(EVENTS_TABLE)
+            .where({ channel, id })
+            .limit(1)
+            .results());
+        if (!rows[0])
+            return null;
+        return this._normalizeEventRow(rows[0]);
+    }
+    /**
+     * @param {WebsocketEventRow} row - Raw row.
+     * @returns {{channel: string, createdAt: string, id: string, payload: unknown, sequence: number}} - Normalized row.
+     */
+    _normalizeEventRow(row) {
+        const createdAtValue = row.created_at;
+        return {
+            channel: row.channel,
+            createdAt: createdAtValue instanceof Date ? createdAtValue.toISOString() : new Date(createdAtValue).toISOString(),
+            id: row.id,
+            payload: JSON.parse(row.payload_json),
+            sequence: Number(row.sequence)
+        };
+    }
+    /**
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {Date} args.interestedUntil - Retention deadline.
+     * @returns {Promise<void>} - Resolves when the replay-channel row was upserted.
+     */
+    async _upsertReplayChannelInterest(db, { channel, interestedUntil }) {
+        await db.upsert({
+            conflictColumns: ["channel"],
+            data: {
+                channel,
+                interested_until: interestedUntil
+            },
+            tableName: REPLAY_CHANNELS_TABLE,
+            updateColumns: ["interested_until"]
+        });
+    }
+    /**
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<any>} callback - Callback.
+     * @returns {Promise<any>} - Callback result.
+     */
+    async _withDb(callback) {
+        return await this.configuration.ensureConnections(async (dbs) => {
+            const db = dbs[this.databaseIdentifier];
+            if (!db)
+                throw new Error(`No database connection available for identifier: ${this.databaseIdentifier}`);
+            return await callback(db);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-event-log-store.js","sourceRoot":"","sources":["../../../src/http-server/websocket-event-log-store.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {randomUUID} from \"crypto\"\nimport TableData from \"../database/table-data/index.js\"\nimport Logger from \"../logger.js\"\n\nconst EVENTS_TABLE = \"websocket_channel_events\"\nconst REPLAY_CHANNELS_TABLE = \"websocket_replay_channels\"\nconst DEFAULT_RETENTION_MS = 10 * 60 * 1000\nconst stores = new WeakMap()\n\n/**\n * @typedef {object} WebsocketEventRow\n * @property {string} channel - Channel name.\n * @property {Date | string} created_at - Creation time.\n * @property {string} id - Event id.\n * @property {string} payload_json - Serialized payload.\n * @property {number | string} sequence - Sequence number.\n */\n\n/**\n * @typedef {object} WebsocketReplayChannelRow\n * @property {string} channel - Channel name.\n */\n\n/**\n * @param {import(\"../configuration.js\").default} configuration - Configuration.\n * @returns {VelociousHttpServerWebsocketEventLogStore} - Shared store instance.\n */\nexport function websocketEventLogStoreForConfiguration(configuration) {\n  let store = stores.get(configuration)\n\n  if (!store) {\n    store = new VelociousHttpServerWebsocketEventLogStore({configuration})\n    stores.set(configuration, store)\n  }\n\n  return store\n}\n\nexport default class VelociousHttpServerWebsocketEventLogStore {\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {string} [args.databaseIdentifier] - Database identifier.\n   * @param {number} [args.retentionMs] - Event retention in milliseconds.\n   */\n  constructor({configuration, databaseIdentifier = \"default\", retentionMs = DEFAULT_RETENTION_MS}) {\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    this.retentionMs = retentionMs\n    this.logger = new Logger(this)\n    this._isReady = false\n    this._readyPromise = null\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async ensureReady() {\n    if (this._isReady) return\n    if (this._readyPromise) return await this._readyPromise\n\n    this._readyPromise = (async () => {\n      this.configuration.setCurrent()\n      await this._ensureSchema()\n      this._isReady = true\n    })()\n\n    try {\n      await this._readyPromise\n    } finally {\n      if (!this._isReady) {\n        this._readyPromise = null\n      }\n    }\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.channel - Channel name.\n   * @param {unknown} args.payload - Event payload.\n   * @returns {Promise<{channel: string, createdAt: string, id: string, payload: unknown}>} - Persisted event row.\n   */\n  async appendEvent({channel, payload}) {\n    await this.ensureReady()\n\n    const id = randomUUID()\n    const createdAt = new Date()\n\n    return await this._withDb(async (db) => {\n      await db.insert({\n        tableName: EVENTS_TABLE,\n        data: {\n          channel,\n          created_at: createdAt,\n          id,\n          payload_json: JSON.stringify(payload)\n        }\n      })\n      return {channel, createdAt: createdAt.toISOString(), id, payload}\n    })\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {Promise<void>} - Resolves when the channel interest was persisted.\n   */\n  async markChannelInterested(channel) {\n    await this.ensureReady()\n\n    const interestedUntil = new Date(Date.now() + this.retentionMs)\n\n    await this._withDb(async (db) => {\n      await this._upsertReplayChannelInterest(db, {channel, interestedUntil})\n    })\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {Promise<boolean>} - Whether the channel should be persisted for replay.\n   */\n  async shouldPersistChannel(channel) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const rows = await db\n        .newQuery()\n        .from(REPLAY_CHANNELS_TABLE)\n        .where({channel})\n        .where(`interested_until > ${db.quote(new Date())}`)\n        .limit(1)\n        .results()\n\n      return rows.length > 0\n    })\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.channel - Channel name.\n   * @param {string} args.id - Event id.\n   * @returns {Promise<{channel: string, createdAt: string, id: string, payload: unknown, sequence: number} | null>} - Event row or null.\n   */\n  async getEventById({channel, id}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      return await this._getEventById({channel, db, id})\n    })\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {Promise<number | null>} - Latest channel sequence.\n   */\n  async latestSequence(channel) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const rows = await db\n        .newQuery()\n        .from(EVENTS_TABLE)\n        .where({channel})\n        .order(\"sequence DESC\")\n        .limit(1)\n        .results()\n      const row = /** @type {Record<string, any> | undefined} */ (rows[0])\n\n      if (!row) return null\n\n      return Number(row.sequence)\n    })\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.channel - Channel name.\n   * @param {number} args.sequence - Lower bound sequence.\n   * @param {number | null | undefined} [args.upToSequence] - Inclusive ceiling sequence.\n   * @returns {Promise<Array<{channel: string, createdAt: string, id: string, payload: unknown, sequence: number}>>} - Ordered events.\n   */\n  async getEventsAfter({channel, sequence, upToSequence}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const query = db\n        .newQuery()\n        .from(EVENTS_TABLE)\n        .where({channel})\n        .where(`sequence > ${db.quote(sequence)}`)\n        .order(\"sequence ASC\")\n\n      if (typeof upToSequence === \"number\") {\n        query.where(`sequence <= ${db.quote(upToSequence)}`)\n      }\n\n      const rows = /** @type {WebsocketEventRow[]} */ (await query.results())\n\n      return rows.map((row) => this._normalizeEventRow(row))\n    })\n  }\n\n  /**\n   * @param {object} [args] - Options.\n   * @param {Date} [args.now] - Cleanup reference time.\n   * @returns {Promise<void>} - Resolves when cleanup completes.\n   */\n  async cleanupExpired({now = new Date()} = {}) {\n    await this.ensureReady()\n\n    const cutoff = new Date(now.getTime() - this.retentionMs)\n\n    await this._withDb(async (db) => {\n      const expiredEventRows = /** @type {Array<{id: string}>} */ (await db\n        .newQuery()\n        .from(EVENTS_TABLE)\n        .where(`created_at <= ${db.quote(cutoff)}`)\n        .results())\n      const expiredReplayChannelRows = /** @type {WebsocketReplayChannelRow[]} */ (await db\n        .newQuery()\n        .from(REPLAY_CHANNELS_TABLE)\n        .where(`interested_until <= ${db.quote(now)}`)\n        .results())\n\n      for (const expiredEventRow of expiredEventRows) {\n        await db.delete({\n          tableName: EVENTS_TABLE,\n          conditions: {id: expiredEventRow.id}\n        })\n      }\n\n      for (const expiredReplayChannelRow of expiredReplayChannelRows) {\n        await db.delete({\n          tableName: REPLAY_CHANNELS_TABLE,\n          conditions: {channel: expiredReplayChannelRow.channel}\n        })\n      }\n    })\n  }\n\n  async _ensureSchema() {\n    await this._withDb(async (db) => {\n      await this._ensureEventsTable(db)\n      await this._ensureReplayChannelsTable(db)\n    })\n  }\n\n  /**\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _ensureEventsTable(db) {\n    this.logger.info(\"Applying websocket event-log schema\")\n\n    if (await db.tableExists(EVENTS_TABLE)) {\n      this.logger.info(\"Websocket event-log table already exists - skipping create\")\n      return\n    }\n\n    const eventTable = new TableData(EVENTS_TABLE, {ifNotExists: true})\n\n    eventTable.integer(\"sequence\", {autoIncrement: true, null: false, primaryKey: true})\n    eventTable.string(\"id\", {index: true, null: false})\n    eventTable.string(\"channel\", {index: true, null: false})\n    eventTable.text(\"payload_json\", {null: false})\n    eventTable.datetime(\"created_at\", {index: true, null: false})\n\n    await db.createTable(eventTable)\n  }\n\n  /**\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _ensureReplayChannelsTable(db) {\n    if (await db.tableExists(REPLAY_CHANNELS_TABLE)) return\n\n    const replayChannelTable = new TableData(REPLAY_CHANNELS_TABLE, {ifNotExists: true})\n\n    replayChannelTable.string(\"channel\", {null: false, primaryKey: true})\n    replayChannelTable.datetime(\"interested_until\", {index: true, null: false})\n\n    await db.createTable(replayChannelTable)\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.channel - Channel name.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Database connection.\n   * @param {string} args.id - Event id.\n   * @returns {Promise<{channel: string, createdAt: string, id: string, payload: unknown, sequence: number} | null>} - Event row or null.\n   */\n  async _getEventById({channel, db, id}) {\n    const rows = /** @type {WebsocketEventRow[]} */ (await db\n      .newQuery()\n      .from(EVENTS_TABLE)\n      .where({channel, id})\n      .limit(1)\n      .results())\n\n    if (!rows[0]) return null\n\n    return this._normalizeEventRow(rows[0])\n  }\n\n  /**\n   * @param {WebsocketEventRow} row - Raw row.\n   * @returns {{channel: string, createdAt: string, id: string, payload: unknown, sequence: number}} - Normalized row.\n   */\n  _normalizeEventRow(row) {\n    const createdAtValue = row.created_at\n\n    return {\n      channel: row.channel,\n      createdAt: createdAtValue instanceof Date ? createdAtValue.toISOString() : new Date(createdAtValue).toISOString(),\n      id: row.id,\n      payload: JSON.parse(row.payload_json),\n      sequence: Number(row.sequence)\n    }\n  }\n\n  /**\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} args - Options.\n   * @param {string} args.channel - Channel name.\n   * @param {Date} args.interestedUntil - Retention deadline.\n   * @returns {Promise<void>} - Resolves when the replay-channel row was upserted.\n   */\n  async _upsertReplayChannelInterest(db, {channel, interestedUntil}) {\n    await db.upsert({\n      conflictColumns: [\"channel\"],\n      data: {\n        channel,\n        interested_until: interestedUntil\n      },\n      tableName: REPLAY_CHANNELS_TABLE,\n      updateColumns: [\"interested_until\"]\n    })\n  }\n\n  /**\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<any>} callback - Callback.\n   * @returns {Promise<any>} - Callback result.\n   */\n  async _withDb(callback) {\n    return await this.configuration.ensureConnections(async (dbs) => {\n      const db = dbs[this.databaseIdentifier]\n\n      if (!db) throw new Error(`No database connection available for identifier: ${this.databaseIdentifier}`)\n\n      return await callback(db)\n    })\n  }\n}\n"]}