@monolayer/sdk 1.2.0-canary.4

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

@@ -0,0 +1,72 @@
+/**
+ * @module types
+ * Defines TypeScript interfaces for the AWS AppSync Events WebSocket protocol messages.
+ */
+/**
+ * Base interface for all AppSync WebSocket messages.
+ */
+export interface AppSyncMessage {
+    type: string;
+}
+/**
+ * Interface for the 'connection_ack' message.
+ */
+export interface ConnectionAckMessage extends AppSyncMessage {
+    type: "connection_ack";
+    connectionTimeoutMs: number;
+}
+/**
+ * Interface for the 'ka' (keep-alive) message.
+ */
+export interface KaMessage extends AppSyncMessage {
+    type: "ka";
+}
+/**
+ * Interface for 'subscribe_success' message.
+ */
+export interface SubscribeSuccessMessage extends AppSyncMessage {
+    type: "subscribe_success";
+    id: string;
+}
+/**
+ * Interface for 'subscribe_error' message.
+ */
+export interface SubscribeErrorMessage extends AppSyncMessage {
+    type: "subscribe_error";
+    id: string;
+    errors: any[];
+}
+/**
+ * Interface for 'data' message.
+ */
+export interface DataMessage extends AppSyncMessage {
+    type: "data";
+    id: string;
+    event: string;
+}
+/**
+ * Interface for 'broadcast_error' message.
+ */
+export interface BroadcastErrorMessage extends AppSyncMessage {
+    type: "broadcast_error";
+    id: string;
+    errors: any[];
+}
+/**
+ * Interface for 'publish_success' message.
+ */
+export interface PublishSuccessMessage extends AppSyncMessage {
+    type: "publish_success";
+    id: string;
+    successful: any[];
+    failed: any[];
+}
+/**
+ * Interface for 'publish_error' message.
+ */
+export interface PublishErrorMessage extends AppSyncMessage {
+    type: "publish_error";
+    id: string;
+    errors: any[];
+}
+export type AppSyncWebSocketMessage = ConnectionAckMessage | KaMessage | SubscribeSuccessMessage | SubscribeErrorMessage | DataMessage | BroadcastErrorMessage | PublishSuccessMessage | PublishErrorMessage;

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

@@ -0,0 +1,5 @@
+/**
+ * @module types
+ * Defines TypeScript interfaces for the AWS AppSync Events WebSocket protocol messages.
+ */
+export {};

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

@@ -0,0 +1,13 @@
+type RouteParams = {
+    [key: string]: string;
+};
+export declare class RouteMatcher {
+    private routes;
+    constructor(routes: string[]);
+    private buildRegex;
+    match(url: string): {
+        route: string;
+        params: RouteParams;
+    } | null;
+}
+export {};

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

@@ -0,0 +1,43 @@
+export class RouteMatcher {
+    routes;
+    constructor(routes) {
+        this.routes = routes;
+    }
+    buildRegex(route) {
+        // Escape static segments and convert dynamic segments (e.g., [id]) into capture groups
+        const pattern = route
+            .split("/")
+            .map((segment) => {
+            if (segment.startsWith("[") && segment.endsWith("]")) {
+                // Capture dynamic segment as a parameter
+                return "([^/]+)";
+            }
+            // Escape static segments
+            return segment.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+        })
+            .join("/");
+        return new RegExp(`^${pattern}$`);
+    }
+    match(url) {
+        for (const route of this.routes) {
+            const regex = this.buildRegex(route);
+            const match = url.match(regex);
+            if (match) {
+                // Extract dynamic parameters from the match
+                const params = {};
+                const segments = route
+                    .split("/")
+                    .filter((segment) => segment.startsWith("[") && segment.endsWith("]"));
+                const values = match.slice(1);
+                segments.forEach((segment, index) => {
+                    const paramName = segment.slice(1, -1); // Remove the square brackets
+                    if (values[index]) {
+                        params[paramName] = values[index];
+                    }
+                });
+                return { route, params };
+            }
+        }
+        return null; // No match found
+    }
+}

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

@@ -0,0 +1,103 @@
+import { Workload } from "../../../workloads/workload.js";
+import type { RouteParams } from "./types.js";
+export type IsValidSegment<S extends string> = S extends `${infer _Start}[${infer Param}]${infer After}` ? After extends `/${string}` | "" ? IsValidSegment<After> : false : true;
+export type ValidateRouteFormat<T extends string> = IsValidSegment<T> extends true ? T : never;
+export type ExtractRouteParamsTuple<T extends string, Acc extends string[] = []> = T extends `${string}[${infer Param}]${infer Rest}` ? ExtractRouteParamsTuple<Rest, [...Acc, Param]> : Acc;
+export type HasDuplicates<T extends readonly any[]> = T extends [
+    infer F,
+    ...infer R
+] ? F extends R[number] ? true : HasDuplicates<R> : false;
+export type ValidateUniqueParams<T extends string> = HasDuplicates<ExtractRouteParamsTuple<T>> extends true ? never : T;
+export type ValidateRoute<T extends string> = ValidateRouteFormat<T> extends never ? never : ValidateUniqueParams<T> extends never ? never : T;
+export type ValidateRoutes<T extends Record<string, any>> = {
+    [K in keyof T]: ValidateRoute<K & string> extends never ? never : T[K];
+};
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export type Simplify<T> = DrainOuterGeneric<{
+    [K in keyof T]: T[K];
+} & {}>;
+/**
+ * Creates a Broadcast workloads
+ *
+ * The constructore takes a session handler and a configuration object for channels. Each channel
+ * is mapped to a path and an optional authorization handler. The channel paths can
+ * include dynamic segments, like `/users/[id]`, which are parsed and passed to the
+ * authorization logic.
+ *
+ * @template T - A record mapping channel strings to their channel data types.
+ * @template S - The type of the session object, returned by the `session` function.
+ *
+ * @param session A function that resolves to a session object. This object is available
+ *   within the authorization handlers. It receives an object with `cookies` as an argument.
+ * @param channels An object where keys are route strings and values are objects defining
+ *   the channel and its authorization logic.
+ *   - `auth`: An optional function to authorize "PUBLISH" or "SUBSCRIBE" operations.
+ *     It receives the operation type, route parameters, and the session object.
+ *   - `channel`: The channel instance for the route.
+ *
+ * @returns An object containing the configured channels, an internal authorization function (`authFn`),
+ *   and the session handler.
+ *
+ * @example
+ * ```ts
+ * import { channel, Broadcast } from "@monolayer/sdk";
+ *
+ * const broadcast = new Broadcast(
+ *   async () => ({ userId: 1 }),
+ *   {
+ *     "/todos": {
+ *       channel: channel<{ message: string }>(),
+ *       auth: async (ctx) => {
+ *         console.log("User trying to access todos:", ctx.session.userId);
+ *         return true; // Allow access
+ *       },
+ *     },
+ *     "/users/[id]": {
+ *       channel: channel<{ salute: string }>(),
+ *       auth: async (ctx) => {
+ *         // Only allow users to access their own channel
+ *         return ctx.session.userId === Number(ctx.params.id);
+ *       },
+ *     },
+ *   }
+ * );
+ *
+ * export default broadcast;
+ * ```
+ */
+export declare class Broadcast<T extends Record<string, any>, S> extends Workload {
+    session: (opts: {
+        cookies: Record<string, string>;
+    }) => Promise<S>;
+    channels: {
+        [channel in keyof T]: ValidateRoute<channel & string> extends never ? never : {
+            auth?: (ctx: {
+                operation: "PUBLISH" | "SUBSCRIBE";
+                params: channel extends string ? Simplify<RouteParams<channel>> : never;
+                session: S;
+            }) => Promise<boolean>;
+            data: T[channel];
+        };
+    };
+    _channelDataType: {
+        [K in keyof T]: T[K];
+    };
+    constructor(initOpts: {
+        session?: (opts: {
+            cookies: Record<string, string>;
+        }) => Promise<S>;
+        channels: {
+            [channel in keyof T]: ValidateRoute<channel & string> extends never ? never : {
+                auth?: (ctx: {
+                    operation: "PUBLISH" | "SUBSCRIBE";
+                    params: channel extends string ? Simplify<RouteParams<channel>> : never;
+                    session: S;
+                }) => Promise<boolean>;
+                data: T[channel];
+            };
+        };
+    });
+    authFn(route: string, operation: "PUBLISH" | "SUBSCRIBE", session: S): Promise<boolean>;
+    get connectionStringEnvVar(): "ML_BROADCAST_URL";
+}
+export type AnyBroadcast = Broadcast<any, any>;

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

@@ -0,0 +1,93 @@
+import path from "path";
+import { Workload } from "../../../workloads/workload.js";
+import { RouteMatcher } from "./matcher.js";
+/**
+ * Creates a Broadcast workloads
+ *
+ * The constructore takes a session handler and a configuration object for channels. Each channel
+ * is mapped to a path and an optional authorization handler. The channel paths can
+ * include dynamic segments, like `/users/[id]`, which are parsed and passed to the
+ * authorization logic.
+ *
+ * @template T - A record mapping channel strings to their channel data types.
+ * @template S - The type of the session object, returned by the `session` function.
+ *
+ * @param session A function that resolves to a session object. This object is available
+ *   within the authorization handlers. It receives an object with `cookies` as an argument.
+ * @param channels An object where keys are route strings and values are objects defining
+ *   the channel and its authorization logic.
+ *   - `auth`: An optional function to authorize "PUBLISH" or "SUBSCRIBE" operations.
+ *     It receives the operation type, route parameters, and the session object.
+ *   - `channel`: The channel instance for the route.
+ *
+ * @returns An object containing the configured channels, an internal authorization function (`authFn`),
+ *   and the session handler.
+ *
+ * @example
+ * ```ts
+ * import { channel, Broadcast } from "@monolayer/sdk";
+ *
+ * const broadcast = new Broadcast(
+ *   async () => ({ userId: 1 }),
+ *   {
+ *     "/todos": {
+ *       channel: channel<{ message: string }>(),
+ *       auth: async (ctx) => {
+ *         console.log("User trying to access todos:", ctx.session.userId);
+ *         return true; // Allow access
+ *       },
+ *     },
+ *     "/users/[id]": {
+ *       channel: channel<{ salute: string }>(),
+ *       auth: async (ctx) => {
+ *         // Only allow users to access their own channel
+ *         return ctx.session.userId === Number(ctx.params.id);
+ *       },
+ *     },
+ *   }
+ * );
+ *
+ * export default broadcast;
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class Broadcast extends Workload {
+    session;
+    channels;
+    constructor(initOpts) {
+        super("broadcast");
+        this.session =
+            initOpts.session ??
+                (async () => {
+                    return {};
+                });
+        this.channels = initOpts.channels;
+    }
+    async authFn(route, operation, session) {
+        const auth = {};
+        for (const routeName of Object.keys(this.channels)) {
+            if (this.channels[routeName]) {
+                auth[`${path.join("default", routeName)}`] =
+                    this.channels[routeName].auth;
+            }
+        }
+        const matcher = new RouteMatcher(Object.keys(this.channels).map((r) => path.join("default", r)));
+        const match = matcher.match(route);
+        if (match) {
+            const routeAuth = auth[route];
+            if (routeAuth === undefined)
+                return true;
+            return await routeAuth({
+                session: session,
+                params: match.params,
+                operation,
+            });
+        }
+        else {
+            return true;
+        }
+    }
+    get connectionStringEnvVar() {
+        return "ML_BROADCAST_URL";
+    }
+}

package/dist/esm/workloads/stateless/broadcast/server/broadcast-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/esm/workloads/stateless/broadcast/server/broadcast-server.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+/* eslint-disable max-lines */
+import { WebSocketServer } from "ws";
+const PORT = 9311;
+const PING_INTERVAL = 1000 * 60; // 60 seconds
+class AppSyncTestServer {
+    wss;
+    session;
+    clients;
+    interval = null;
+    connectionTimeoutMs;
+    channelAuth;
+    constructor(opts) {
+        this.wss = new WebSocketServer({ port: opts.port });
+        this.clients = new Set();
+        this.connectionTimeoutMs = opts.connectionTimeoutMs ?? 300000;
+        this.channelAuth = opts.channelAuth;
+        this.session = opts.session;
+        this.setupServer();
+    }
+    setupServer() {
+        this.wss.on("headers", (d) => {
+            console.log(d);
+        });
+        this.wss.on("connection", async (ws, request) => {
+            console.log(request.url);
+            const client = ws;
+            client.isAlive = true;
+            client.subscriptions = new Map();
+            console.log("Client connected");
+            const protocol = request.headers["sec-websocket-protocol"];
+            const authProtocol = protocol?.split(",")[1]?.trim();
+            const authProtocolName = protocol?.split(",")[0]?.trim();
+            if (authProtocol && authProtocolName === "aws-appsync-event-ws") {
+                try {
+                    const encodedHeader = authProtocol.substring("header-".length);
+                    const decodedHeader = Buffer.from(encodedHeader, "base64url").toString("utf8");
+                    console.log("Decoded", decodedHeader);
+                    const auth = JSON.parse(decodedHeader);
+                    console.log("Authorization header:", auth);
+                    if (auth.Authorization === undefined) {
+                        console.error("Unauthorized");
+                        client.close(3000, "Unauthorized");
+                        return;
+                    }
+                    client._authorizationToken = auth.Authorization;
+                    if (this.session) {
+                        client._session = await this.session({ cookies: {} });
+                    }
+                    this.clients.add(client);
+                }
+                catch (e) {
+                    console.error("Failed to parse authorization header:", e);
+                    client.close(1008, "Invalid authorization header");
+                    return;
+                }
+            }
+            else {
+                console.error("Mising authorization:");
+                client.close(1008, "Missing authorization");
+            }
+            client.on("pong", () => {
+                client.isAlive = true;
+            });
+            client.on("message", async (message) => {
+                console.log(`Received message: ${message}`);
+                try {
+                    const parsedMessage = JSON.parse(message);
+                    console.log(parsedMessage);
+                    await this.handleMessage(client, parsedMessage);
+                }
+                catch (e) {
+                    console.error("Failed to parse message:", e);
+                    client.send(JSON.stringify({ type: "error", message: "Invalid JSON message" }));
+                }
+            });
+            client.on("close", () => {
+                console.log("Client disconnected");
+                this.clients.delete(client);
+            });
+            client.on("error", (error) => {
+                console.error("WebSocket error:", error);
+            });
+        });
+        this.interval = setInterval(() => {
+            this.clients.forEach((client) => {
+                if (client.isAlive === false) {
+                    console.log("Client not alive, terminating connection");
+                    return client.terminate();
+                }
+                client.isAlive = false;
+                client.ping();
+            });
+        }, PING_INTERVAL);
+        this.wss.on("close", () => {
+            if (this.interval) {
+                clearInterval(this.interval);
+            }
+        });
+        console.log("AppSync Test Server started");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async handleMessage(client, message) {
+        switch (message.type) {
+            case "connection_init":
+                client.connectionTimeoutMs = this.connectionTimeoutMs;
+                client.send(JSON.stringify({
+                    type: "connection_ack",
+                    connectionTimeoutMs: client.connectionTimeoutMs,
+                }));
+                break;
+            case "subscribe":
+                if (!message.id || !message.channel) {
+                    client.send(JSON.stringify({
+                        type: "subscribe_error",
+                        id: message.id,
+                        errors: [
+                            {
+                                errorType: "ValidationError",
+                                message: "Missing id or channel",
+                            },
+                        ],
+                    }));
+                    return;
+                }
+                if (client.subscriptions.has(message.id)) {
+                    client.send(JSON.stringify({
+                        type: "subscribe_error",
+                        id: message.id,
+                        errors: [
+                            {
+                                errorType: "DuplicateSubscriptionError",
+                                message: "Subscription ID already exists",
+                            },
+                        ],
+                    }));
+                    return;
+                }
+                if (this.channelAuth) {
+                    try {
+                        const isAuthorized = await this.channelAuth(message.channel, "SUBSCRIBE", client._session);
+                        if (!isAuthorized) {
+                            console.error("Unauthorized");
+                            client.send(JSON.stringify({
+                                type: "subscribe_error",
+                                id: message.id,
+                                errors: [
+                                    {
+                                        errorType: "Unauthorized",
+                                        message: "Unauthorized to subscribe",
+                                    },
+                                ],
+                            }));
+                            return;
+                        }
+                    }
+                    catch {
+                        console.error("Internal Error");
+                        client.send(JSON.stringify({
+                            type: "internal_error",
+                            id: message.id,
+                            errors: [
+                                {
+                                    errorType: "Internal Error",
+                                },
+                            ],
+                        }));
+                        return;
+                    }
+                }
+                client.subscriptions.set(message.id, message.channel);
+                client.send(JSON.stringify({ type: "subscribe_success", id: message.id }));
+                console.log(`Client subscribed to channel: ${message.channel} with id: ${message.id}`);
+                break;
+            case "unsubscribe":
+                if (!message.id) {
+                    client.send(JSON.stringify({
+                        type: "unsubscribe_error",
+                        id: message.id,
+                        errors: [{ errorType: "ValidationError", message: "Missing id" }],
+                    }));
+                    return;
+                }
+                if (client.subscriptions.delete(message.id)) {
+                    client.send(JSON.stringify({ type: "unsubscribe_success", id: message.id }));
+                    console.log(`Client unsubscribed from id: ${message.id}`);
+                }
+                else {
+                    client.send(JSON.stringify({
+                        type: "unsubscribe_error",
+                        id: message.id,
+                        errors: [
+                            {
+                                errorType: "UnknownOperationError",
+                                message: `Unknown subscription id ${message.id}`,
+                            },
+                        ],
+                    }));
+                }
+                break;
+            case "publish":
+                if (!message.id || !message.channel || !message.events) {
+                    client.send(JSON.stringify({
+                        type: "publish_error",
+                        id: message.id,
+                        errors: [
+                            {
+                                errorType: "ValidationError",
+                                message: "Missing id, channel, or events",
+                            },
+                        ],
+                    }));
+                    return;
+                }
+                console.log(`Client publishing to channel: ${message.channel} with events:`, message.events);
+                if (this.channelAuth) {
+                    try {
+                        const isAuthorized = await this.channelAuth(message.channel, "PUBLISH", {});
+                        if (!isAuthorized) {
+                            console.error("Unauthorized");
+                            client.send(JSON.stringify({
+                                type: "subscribe_error",
+                                id: message.id,
+                                errors: [
+                                    {
+                                        errorType: "Unauthorized",
+                                        message: "Unauthorized to subscribe",
+                                    },
+                                ],
+                            }));
+                            return;
+                        }
+                    }
+                    catch {
+                        console.error("Internal Error");
+                        client.send(JSON.stringify({
+                            type: "internal_error",
+                            id: message.id,
+                            errors: [
+                                {
+                                    errorType: "Internal Error",
+                                },
+                            ],
+                        }));
+                        return;
+                    }
+                }
+                this.broadcast(message.channel, message.events, message.id);
+                console.log("message", message);
+                client.send(JSON.stringify({
+                    type: "publish_success",
+                    id: message.id,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    successful: message.events.map((_, index) => ({
+                        identifier: `event-${index}`,
+                        index,
+                    })),
+                    failed: [],
+                }));
+                break;
+            default:
+                client.send(JSON.stringify({ type: "error", message: "Unknown message type" }));
+                break;
+        }
+    }
+    broadcast(channel, events, publishId) {
+        this.clients.forEach((client) => {
+            client.subscriptions.forEach((subscribedChannel, subscriptionId) => {
+                if (subscribedChannel === channel) {
+                    events.forEach((event) => {
+                        client.send(JSON.stringify({
+                            type: "data",
+                            id: subscriptionId,
+                            event: [event],
+                            publishId: publishId, // Include publishId for correlation if needed
+                        }));
+                    });
+                }
+            });
+        });
+    }
+    close() {
+        this.wss.close();
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
+        console.log("AppSync Test Server closed");
+    }
+    stopKeepAlive() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    sendKeepAlive(client) {
+        client.send(JSON.stringify({ type: "ka" }));
+    }
+}
+async function main() {
+    const routesPath = "/app/workloads/broadcast.js";
+    const ru = await import(routesPath);
+    const server = new AppSyncTestServer({
+        port: PORT,
+        channelAuth: ru.authFn,
+        session: ru.session,
+    });
+    process.on("SIGINT", () => {
+        server.close();
+        process.exit();
+    });
+    process.on("SIGTERM", () => {
+        server.close();
+        process.exit();
+    });
+}
+main().catch(console.error);

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

@@ -0,0 +1,17 @@
+export type Channel<T> = {
+    _data: T;
+    subscribed?: (ctx: any) => void;
+    unsubscribed?: (ctx: any) => void;
+};
+export type ChannelData<T extends Channel<any>> = T extends Channel<infer D> ? D : never;
+export type Channels = Record<string, Channel<any>>;
+export type ExtractRouteParamsTuple<T extends string, Acc extends string[] = []> = T extends `${string}[${infer Param}]${infer Rest}` ? ExtractRouteParamsTuple<Rest, [...Acc, Param]> : Acc;
+export type HasDuplicates<T extends readonly any[]> = T extends [
+    infer F,
+    ...infer R
+] ? F extends R[number] ? true : HasDuplicates<R> : false;
+export type ValidateUniqueParams<T extends string> = HasDuplicates<ExtractRouteParamsTuple<T>> extends true ? ["❌ Duplicate route params not allowed in", T] : T;
+export type TupleToParamObject<T extends readonly string[]> = {
+    [K in T[number]]: string;
+};
+export type RouteParams<T extends string> = TupleToParamObject<ExtractRouteParamsTuple<T>>;

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

@@ -0,0 +1 @@
+export {};