@monolayer/sdk 1.2.0-canary.4

package/dist/esm/workloads/stateless/broadcast/client/broadcast-provider.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, use, useEffect, useMemo, useState, } from "react";
+import { BroadcastClient } from "./app-sync-client.js";
+export const BroadcastProvider = createContext(null);
+export function BroadcastContextProvider({ urlAndHost, children, }) {
+    const [ws] = useState(useMemo(() => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new BroadcastClient(urlAndHost);
+    }, [urlAndHost]));
+    const [connected, setConnected] = useState(false);
+    useEffect(() => {
+        async function connect() {
+            await ws.connect();
+            ws.connected = true;
+            setConnected(true);
+        }
+        connect().catch(console.error);
+        return () => ws.disconnect();
+    }, [ws]);
+    return (_jsx(BroadcastProvider.Provider, { value: { ws, connected }, children: children }));
+}
+export function useWebSocket() {
+    const context = use(BroadcastProvider);
+    if (!context) {
+        throw new Error("useWebSockets must be used within a <BroadcastProvider />");
+    }
+    return context.ws;
+}

package/dist/esm/workloads/stateless/broadcast/client/client.d.ts

@@ -0,0 +1,8 @@
+import type { ChannelData } from "../../../../workloads/stateless/broadcast/channel-data.js";
+import type { RouteParams } from "../../../../workloads/stateless/broadcast/types.js";
+export declare function broadcastClient<C extends Record<string, ChannelData<any>>>(): {
+    useSubscription: <D extends keyof C & string>(channel: D, params: RouteParams<D>) => {
+        last: (D extends string ? C[D] extends ChannelData<infer P> ? P : never : never) | null;
+        all: (D extends string ? C[D] extends ChannelData<infer P> ? P : never : never)[];
+    };
+};

package/dist/esm/workloads/stateless/broadcast/client/client.js

@@ -0,0 +1,25 @@
+"use client";
+import { useEffect, useReducer, useState } from "react";
+import { useWebSocket } from "../../../../workloads/stateless/broadcast/client/broadcast-provider.js";
+export function broadcastClient() {
+    const useSubscription = (channel, params) => {
+        const [last, setLast] = useState(null);
+        const [all, setAll] = useReducer((prevItems, newItem) => {
+            return prevItems.concat(newItem);
+        }, []);
+        const [subscribe, setSubscribed] = useState(false);
+        const client = useWebSocket();
+        useEffect(() => {
+            if (client.connected && !subscribe) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                client.subscribeTo(channel, params, (payload) => {
+                    setLast(payload);
+                    setAll(payload);
+                });
+                setSubscribed(true);
+            }
+        }, [client, channel, params, subscribe]);
+        return { last, all };
+    };
+    return { useSubscription };
+}

package/dist/esm/workloads/stateless/broadcast/client/connectionManager.d.ts

@@ -0,0 +1,62 @@
+import type { AppSyncWebSocketMessage } from "./types.js";
+/**
+ * @module ConnectionManager
+ * Manages the WebSocket connection lifecycle with the AWS AppSync Events API.
+ */
+type MessageHandler = (message: AppSyncWebSocketMessage) => void;
+type CloseHandler = (event: CloseEvent) => void;
+/**
+ * Manages the WebSocket connection to the AWS AppSync Events API.
+ * Handles connection establishment, sending initial messages, and receiving acknowledgments.
+ */
+export declare class ConnectionManager {
+    ws: WebSocket | null;
+    private readonly url;
+    private connectionTimeoutMs;
+    private keepAliveTimer;
+    private connectPromiseResolve;
+    private connectPromiseReject;
+    private messageHandler;
+    private closeHandler;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private maxReconnectDelay;
+    private _clientId?;
+    /**
+     * Creates an instance of ConnectionManager.
+     * @param url The WebSocket URL for the AWS AppSync Events API.
+     */
+    constructor(url: string);
+    clientId(): string | undefined;
+    /**
+     * Establishes a WebSocket connection to the AWS AppSync Events API.
+     * @returns A Promise that resolves when the connection is successfully established and acknowledged.
+     */
+    connect(): Promise<void>;
+    /**
+     * Registers a handler for incoming WebSocket messages.
+     * @param handler The function to call when a new message is received.
+     */
+    onMessage(handler: MessageHandler): void;
+    /**
+     * Registers a handler for WebSocket close events.
+     * @param handler The function to call when the WebSocket connection is closed.
+     */
+    onClose(handler: CloseHandler): void;
+    /**
+     * Sends a message over the WebSocket connection.
+     * @param message The message string to send.
+     */
+    send(message: string): void;
+    /**
+     * Closes the WebSocket connection gracefully.
+     * This method clears any active keep-alive timers and closes the underlying WebSocket.
+     */
+    disconnect(): void;
+    private reconnect;
+    private startKeepAliveTimer;
+    private resetKeepAliveTimer;
+    private clearKeepAliveTimer;
+}
+export {};

package/dist/esm/workloads/stateless/broadcast/client/connectionManager.js

@@ -0,0 +1,164 @@
+/// <reference lib="dom" />
+import { v4 as uuidv4 } from "uuid";
+import { getAuthProtocol } from "./authenticator.js";
+import { parseMessage } from "./parser.js";
+/**
+ * Manages the WebSocket connection to the AWS AppSync Events API.
+ * Handles connection establishment, sending initial messages, and receiving acknowledgments.
+ */
+export class ConnectionManager {
+    ws = null;
+    url;
+    connectionTimeoutMs = 0;
+    keepAliveTimer = null;
+    connectPromiseResolve = null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    connectPromiseReject = null;
+    messageHandler = null;
+    closeHandler = null;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 10;
+    reconnectDelay = 1000; // 1 second
+    maxReconnectDelay = 30000; // 30 seconds
+    _clientId;
+    /**
+     * Creates an instance of ConnectionManager.
+     * @param url The WebSocket URL for the AWS AppSync Events API.
+     */
+    constructor(url) {
+        this.url = url;
+    }
+    clientId() {
+        return this._clientId;
+    }
+    /**
+     * Establishes a WebSocket connection to the AWS AppSync Events API.
+     * @returns A Promise that resolves when the connection is successfully established and acknowledged.
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            this.connectPromiseResolve = resolve;
+            this.connectPromiseReject = reject;
+            this._clientId = uuidv4();
+            this.ws = new WebSocket(this.url, [
+                "aws-appsync-event-ws",
+                getAuthProtocol({
+                    clientId: this._clientId,
+                    host: "",
+                    Authorization: "",
+                }),
+            ]);
+            this.ws.onopen = () => {
+                this.reconnectAttempts = 0;
+                this.ws?.send(JSON.stringify({ type: "connection_init" }));
+            };
+            this.ws.onmessage = (event) => {
+                const message = parseMessage(event.data);
+                switch (message.type) {
+                    case "connection_ack":
+                        this.connectionTimeoutMs = message.connectionTimeoutMs;
+                        this.startKeepAliveTimer();
+                        this.connectPromiseResolve?.();
+                        break;
+                    case "ka":
+                        this.resetKeepAliveTimer();
+                        break;
+                    default:
+                        // Pass other messages to the registered handler
+                        if (this.messageHandler) {
+                            this.messageHandler(message);
+                        }
+                        break;
+                }
+            };
+            this.ws.onerror = (error) => {
+                this.clearKeepAliveTimer();
+                this.connectPromiseReject?.(error);
+            };
+            this.ws.onclose = (event) => {
+                this.clearKeepAliveTimer();
+                if (!event.wasClean) {
+                    // Attempt to reconnect if the closure was not clean
+                    this.reconnect();
+                }
+                else {
+                    this.connectPromiseReject?.(new Error(`WebSocket closed unexpectedly: ${event.code} - ${event.reason}`));
+                }
+                // Call the registered close handler
+                if (this.closeHandler) {
+                    this.closeHandler(event);
+                }
+            };
+        });
+    }
+    /**
+     * Registers a handler for incoming WebSocket messages.
+     * @param handler The function to call when a new message is received.
+     */
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    /**
+     * Registers a handler for WebSocket close events.
+     * @param handler The function to call when the WebSocket connection is closed.
+     */
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
+    /**
+     * Sends a message over the WebSocket connection.
+     * @param message The message string to send.
+     */
+    send(message) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(message);
+        }
+        else {
+            console.warn("WebSocket is not open. Message not sent.", message);
+        }
+    }
+    /**
+     * Closes the WebSocket connection gracefully.
+     * This method clears any active keep-alive timers and closes the underlying WebSocket.
+     */
+    disconnect() {
+        this.clearKeepAliveTimer();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+            this._clientId = "";
+        }
+    }
+    reconnect() {
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnectAttempts++;
+            const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+            console.log(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})...`);
+            setTimeout(() => {
+                // Re-call connect to attempt reconnection
+                this.connect();
+            }, delay);
+        }
+        else {
+            console.error("Max reconnect attempts reached. Connection permanently lost.");
+            this.connectPromiseReject?.(new Error("Max reconnect attempts reached"));
+        }
+    }
+    startKeepAliveTimer() {
+        this.clearKeepAliveTimer();
+        this.keepAliveTimer = setTimeout(() => {
+            // If timer expires, no keep-alive message received
+            this.ws?.close();
+            this.connectPromiseReject?.(new Error("WebSocket closed due to keep-alive timeout"));
+        }, this.connectionTimeoutMs);
+    }
+    resetKeepAliveTimer() {
+        this.startKeepAliveTimer(); // Simply restart the timer
+    }
+    clearKeepAliveTimer() {
+        if (this.keepAliveTimer) {
+            clearTimeout(this.keepAliveTimer);
+            this.keepAliveTimer = null;
+        }
+    }
+}

package/dist/esm/workloads/stateless/broadcast/client/eventEmitter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module EventEmitter
+ * Implements a simple event emitter pattern for handling custom events.
+ */
+type Listener = (...args: any[]) => void;
+/**
+ * A simple event emitter class that allows for subscribing to, unsubscribing from,
+ * and emitting custom events.
+ */
+export declare class EventEmitter {
+    private listeners;
+    constructor();
+    /**
+     * Registers a new listener for a specified event.
+     * @param eventName The name of the event to listen for.
+     * @param listener The callback function to be invoked when the event is emitted.
+     */
+    on(eventName: string, listener: Listener): void;
+    /**
+     * Removes a registered listener for a specified event.
+     * @param eventName The name of the event to remove the listener from.
+     * @param listener The callback function to be removed.
+     */
+    off(eventName: string, listener: Listener): void;
+    /**
+     * Emits an event, invoking all registered listeners for that event.
+     * @param eventName The name of the event to emit.
+     * @param args Any arguments to pass to the listeners.
+     */
+    emit(eventName: string, ...args: any[]): void;
+}
+export {};

package/dist/esm/workloads/stateless/broadcast/client/eventEmitter.js

@@ -0,0 +1,50 @@
+/**
+ * @module EventEmitter
+ * Implements a simple event emitter pattern for handling custom events.
+ */
+/**
+ * A simple event emitter class that allows for subscribing to, unsubscribing from,
+ * and emitting custom events.
+ */
+export class EventEmitter {
+    listeners;
+    constructor() {
+        this.listeners = new Map();
+    }
+    /**
+     * Registers a new listener for a specified event.
+     * @param eventName The name of the event to listen for.
+     * @param listener The callback function to be invoked when the event is emitted.
+     */
+    on(eventName, listener) {
+        if (!this.listeners.has(eventName)) {
+            this.listeners.set(eventName, new Set());
+        }
+        this.listeners.get(eventName)?.add(listener);
+    }
+    /**
+     * Removes a registered listener for a specified event.
+     * @param eventName The name of the event to remove the listener from.
+     * @param listener The callback function to be removed.
+     */
+    off(eventName, listener) {
+        if (this.listeners.has(eventName)) {
+            this.listeners.get(eventName)?.delete(listener);
+        }
+    }
+    /**
+     * Emits an event, invoking all registered listeners for that event.
+     * @param eventName The name of the event to emit.
+     * @param args Any arguments to pass to the listeners.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    emit(eventName, ...args) {
+        if (this.listeners.has(eventName)) {
+            // Create a shallow copy to prevent issues if listeners modify the set during iteration
+            const listenersToCall = Array.from(this.listeners.get(eventName));
+            for (const listener of listenersToCall) {
+                listener(...args);
+            }
+        }
+    }
+}

package/dist/esm/workloads/stateless/broadcast/client/messageBuilder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @module messageBuilder
+ * Provides utility functions for constructing WebSocket messages
+ * according to the AWS AppSync Events API protocol.
+ */
+/**
+ * Builds a 'subscribe' message for the AWS AppSync Events API.
+ *
+ * @param id A unique identifier for the subscription.
+ * @param channel The channel path to subscribe to (e.g., '/my/channel').
+ * @param authorization An object containing the authorization details for the subscription.
+ * @returns A JSON object representing the 'subscribe' message.
+ */
+export declare function buildSubscribeMessage(id: string, channel: string, authorization: object): object;
+/**
+ * Builds a 'publish' message for the AWS AppSync Events API.
+ *
+ * @param id A unique identifier for the publish operation.
+ * @param channel The channel path to publish to.
+ * @param events An array of stringified JSON events to be published.
+ * @param authorization An object containing the authorization details for the publish operation.
+ * @returns A JSON object representing the 'publish' message.
+ */
+export declare function buildPublishMessage(id: string, channel: string, events: string[], authorization: object): object;

package/dist/esm/workloads/stateless/broadcast/client/messageBuilder.js

@@ -0,0 +1,39 @@
+/**
+ * @module messageBuilder
+ * Provides utility functions for constructing WebSocket messages
+ * according to the AWS AppSync Events API protocol.
+ */
+/**
+ * Builds a 'subscribe' message for the AWS AppSync Events API.
+ *
+ * @param id A unique identifier for the subscription.
+ * @param channel The channel path to subscribe to (e.g., '/my/channel').
+ * @param authorization An object containing the authorization details for the subscription.
+ * @returns A JSON object representing the 'subscribe' message.
+ */
+export function buildSubscribeMessage(id, channel, authorization) {
+    return {
+        type: "subscribe",
+        id,
+        channel,
+        authorization,
+    };
+}
+/**
+ * Builds a 'publish' message for the AWS AppSync Events API.
+ *
+ * @param id A unique identifier for the publish operation.
+ * @param channel The channel path to publish to.
+ * @param events An array of stringified JSON events to be published.
+ * @param authorization An object containing the authorization details for the publish operation.
+ * @returns A JSON object representing the 'publish' message.
+ */
+export function buildPublishMessage(id, channel, events, authorization) {
+    return {
+        type: "publish",
+        id,
+        channel,
+        events,
+        authorization,
+    };
+}

package/dist/esm/workloads/stateless/broadcast/client/parser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module parser
+ * Provides utility functions for parsing incoming WebSocket messages
+ * from the AWS AppSync Events API.
+ */
+/**
+ * Parses a raw WebSocket message string into a structured JavaScript object.
+ * @param message The raw message string received from the WebSocket.
+ * @returns The parsed message object.
+ * @throws {Error} If the message is not valid JSON.
+ */
+export declare function parseMessage(message: string): object;

package/dist/esm/workloads/stateless/broadcast/client/parser.js

@@ -0,0 +1,19 @@
+/**
+ * @module parser
+ * Provides utility functions for parsing incoming WebSocket messages
+ * from the AWS AppSync Events API.
+ */
+/**
+ * Parses a raw WebSocket message string into a structured JavaScript object.
+ * @param message The raw message string received from the WebSocket.
+ * @returns The parsed message object.
+ * @throws {Error} If the message is not valid JSON.
+ */
+export function parseMessage(message) {
+    try {
+        return JSON.parse(message);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse message: ${message}. Error: ${error}`);
+    }
+}

package/dist/esm/workloads/stateless/broadcast/client/provider.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from "react";
+export declare function Broadcast({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/esm/workloads/stateless/broadcast/client/provider.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BroadcastContextProvider } from "./broadcast-provider.js";
+export function Broadcast({ children }) {
+    return (_jsx(BroadcastContextProvider, { urlAndHost: {
+            url: process.env.ML_BROADCAST_URL ?? "ws://localhost:9311",
+            host: process.env.ML_BROADCAST_HOST ?? "localhost",
+        }, children: children }));
+}

package/dist/esm/workloads/stateless/broadcast/client/subscriptionManager.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @module SubscriptionManager
+ * Manages subscriptions to channels in the AWS AppSync Events API.
+ */
+import type { EventEmitter } from "./eventEmitter.js";
+type SubscriberCallback = (data: object) => void;
+/**
+ * Represents a manager for handling subscriptions to various channels.
+ * It interacts with a connection manager to send subscription messages.
+ */
+export declare class SubscriptionManager {
+    private connectionManager;
+    private subscribers;
+    private subscriptionPromises;
+    /**
+     * Creates an instance of SubscriptionManager.
+     * @param connectionManager The connection manager responsible for sending messages.
+     */
+    constructor(connectionManager: any, eventEmitter: EventEmitter);
+    /**
+     * Subscribes to a specified channel.
+     * @param channel The channel path to subscribe to.
+     * @param authorization The authorization object for the subscription.
+     * @param callback The callback function to invoke when data is received for this subscription.
+     * @returns The ID of the created subscription.
+     */
+    subscribe(channel: string, authorization: object, callback: SubscriberCallback): string;
+    /**
+     * Unsubscribes from a previously subscribed channel.
+     * @param subscriptionId The ID of the subscription to unsubscribe from.
+     */
+    unsubscribe(subscriptionId: string): void;
+}
+export {};

package/dist/esm/workloads/stateless/broadcast/client/subscriptionManager.js

@@ -0,0 +1,91 @@
+/**
+ * @module SubscriptionManager
+ * Manages subscriptions to channels in the AWS AppSync Events API.
+ */
+import { v4 as uuidv4 } from "uuid";
+import { buildSubscribeMessage } from "./messageBuilder.js";
+/**
+ * Represents a manager for handling subscriptions to various channels.
+ * It interacts with a connection manager to send subscription messages.
+ */
+export class SubscriptionManager {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    connectionManager; // Will be typed more strictly later
+    subscribers;
+    subscriptionPromises;
+    /**
+     * Creates an instance of SubscriptionManager.
+     * @param connectionManager The connection manager responsible for sending messages.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(connectionManager, eventEmitter) {
+        this.connectionManager = connectionManager;
+        this.subscribers = new Map();
+        this.subscriptionPromises = new Map();
+        // Register a handler for incoming messages from the ConnectionManager
+        eventEmitter.on("message", (message) => {
+            switch (message.type) {
+                case "data":
+                    console.log("data", message);
+                    if (this.subscribers.get(message.id)) {
+                        // Event content is a stringified JSON, so parse it
+                        this.subscribers.get(message.id)(JSON.parse(message.event));
+                    }
+                    break;
+                case "subscribe_success":
+                    if (this.subscriptionPromises.get(message.id)) {
+                        this.subscriptionPromises.get(message.id).resolve();
+                        this.subscriptionPromises.delete(message.id);
+                    }
+                    break;
+                case "subscribe_error":
+                    if (this.subscriptionPromises.get(message.id)) {
+                        this.subscriptionPromises
+                            .get(message.id)
+                            .reject(new Error(message.errors[0]?.message || "Subscription error"));
+                        this.subscriptionPromises.delete(message.id);
+                    }
+                    break;
+            }
+        });
+    }
+    /**
+     * Subscribes to a specified channel.
+     * @param channel The channel path to subscribe to.
+     * @param authorization The authorization object for the subscription.
+     * @param callback The callback function to invoke when data is received for this subscription.
+     * @returns The ID of the created subscription.
+     */
+    subscribe(channel, authorization, callback) {
+        // Changed return type to string
+        const id = uuidv4();
+        const subscribeMessage = buildSubscribeMessage(id, channel, authorization);
+        this.connectionManager.send(JSON.stringify(subscribeMessage));
+        this.subscribers.set(id, callback);
+        // Store the resolve/reject functions for this subscription ID
+        let resolvePromise;
+        let rejectPromise;
+        const promise = new Promise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        this.subscriptionPromises.set(id, {
+            resolve: resolvePromise,
+            reject: rejectPromise,
+            promise,
+        });
+        return id; // Return the id immediately
+    }
+    /**
+     * Unsubscribes from a previously subscribed channel.
+     * @param subscriptionId The ID of the subscription to unsubscribe from.
+     */
+    unsubscribe(subscriptionId) {
+        const unsubscribeMessage = {
+            type: "unsubscribe",
+            id: subscriptionId,
+        };
+        this.connectionManager.send(JSON.stringify(unsubscribeMessage));
+        this.subscribers.delete(subscriptionId);
+    }
+}