@teardown/cli 1.2.15 → 1.2.22

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-hmr.server.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketHMRServer = void 0;
+const node_url_1 = require("node:url");
+const web_socket_server_1 = require("../web-socket-server");
+// @ts-ignore
+const HmrServer_1 = __importDefault(require("metro/src/HmrServer"));
+/**
+ * Class for creating a WebSocket server for Hot Module Replacement.
+ *
+ * @category Development server
+ */
+class WebSocketHMRServer extends web_socket_server_1.WebSocketServer {
+    options;
+    clients = new Map();
+    nextClientId = 0;
+    hmrServer;
+    /**
+     * Create new instance of WebSocketHMRServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     * @param delegate HMR delegate instance.
+     */
+    constructor(fastify, options) {
+        super(fastify, "/hot");
+        this.options = options;
+        this.hmrServer = new HmrServer_1.default(this.options.metroServer.getBundler(), this.options.metroServer.getCreateModuleId(), this.options.metroConfig);
+    }
+    /**
+     * Send action to all connected HMR clients.
+     *
+     * @param event Event to send to the clients.
+     * @param platform Platform of clients to send the event to.
+     * @param clientIds Ids of clients who should receive the event.
+     */
+    send(event, platform, clientIds) {
+        const data = typeof event === "string" ? event : JSON.stringify(event);
+        for (const [key, socket] of this.clients) {
+            if (key.platform !== platform ||
+                !(clientIds ?? [key.clientId]).includes(key.clientId)) {
+                continue;
+            }
+            try {
+                socket.send(data);
+            }
+            catch (error) {
+                this.fastify.log.error({
+                    msg: "Cannot send action to client",
+                    event,
+                    error,
+                    ...key,
+                });
+            }
+        }
+    }
+    /**
+     * Process new WebSocket connection from HMR client.
+     *
+     * @param socket Incoming HMR client's WebSocket connection.
+     */
+    async onConnection(socket, request) {
+        const requestUrl = request.url || "";
+        const { searchParams } = new node_url_1.URL(requestUrl, "http://localhost");
+        const platform = searchParams.get("platform") ?? "unknown";
+        if (!platform) {
+            this.fastify.log.debug({
+                msg: "HMR connection disconnected - missing platform",
+            });
+            socket.close();
+            return;
+        }
+        const clientId = `client#${this.nextClientId++}`;
+        const client = {
+            clientId,
+            platform,
+        };
+        this.clients.set(client, socket);
+        this.fastify.log.debug({ msg: "HMR client connected", ...client });
+        const onClose = () => {
+            this.fastify.log.debug({
+                msg: "HMR client disconnected",
+                ...client,
+            });
+            this.clients.delete(client);
+        };
+        socket.addEventListener("error", onClose);
+        socket.addEventListener("close", onClose);
+        await this.registerHMRClient(socket, requestUrl);
+        this.options.onClientConnected(platform, clientId);
+    }
+    async registerHMRClient(socket, requestUrl) {
+        console.log("HMR server registerHMRClient", requestUrl);
+        const sendFn = (data) => {
+            socket.send(data);
+        };
+        const hmrClient = await this.hmrServer.onClientConnect(requestUrl, sendFn);
+        socket.on("error", (error) => {
+            this.hmrServer.onClientError(hmrClient, error);
+        });
+        socket.on("close", () => {
+            this.hmrServer.onClientDisconnect(hmrClient);
+        });
+        socket.on("message", (data) => {
+            this.hmrServer.onClientMessage(hmrClient, data, sendFn);
+        });
+    }
+}
+exports.WebSocketHMRServer = WebSocketHMRServer;

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-message.server.d.ts

@@ -0,0 +1,139 @@
+import type { IncomingMessage } from "node:http";
+import type { FastifyInstance } from "fastify";
+import type WebSocket from "ws";
+import { WebSocketServer } from "../web-socket-server";
+/**
+ * Holds {@link ReactNativeMessage} `id` data.
+ */
+export interface ReactNativeIdObject {
+    requestId: string;
+    clientId: string;
+}
+/**
+ * Message representation used by {@link WebSocketMessageServer}.
+ */
+export interface ReactNativeMessage {
+    version?: string;
+    id?: ReactNativeIdObject;
+    method?: string;
+    target: string;
+    result?: any;
+    error?: Error;
+    params?: Record<string, any>;
+}
+type WebSocketWithUpgradeReq = WebSocket & {
+    upgradeReq?: IncomingMessage;
+};
+/**
+ * Class for creating a WebSocket server and sending messages between development server
+ * and the React Native applications.
+ *
+ * Based on: https://github.com/react-native-community/cli/blob/v4.14.0/packages/cli-server-api/src/websocket/messageSocketServer.ts
+ *
+ * @category Development server
+ */
+export declare class WebSocketMessageServer extends WebSocketServer {
+    static readonly PROTOCOL_VERSION = 2;
+    /**
+     * Check if message is a broadcast request.
+     *
+     * @param message Message to check.
+     * @returns True if message is a broadcast request and should be broadcasted
+     * with {@link sendBroadcast}.
+     */
+    static isBroadcast(message: Partial<ReactNativeMessage>): boolean;
+    /**
+     * Check if message is a method request.
+     *
+     * @param message Message to check.
+     * @returns True if message is a request.
+     */
+    static isRequest(message: Partial<ReactNativeMessage>): boolean;
+    /**
+     * Check if message is a response with results of performing some request.
+     *
+     * @param message Message to check.
+     * @returns True if message is a response.
+     */
+    static isResponse(message: Partial<ReactNativeMessage>): boolean;
+    private clients;
+    private nextClientId;
+    /**
+     * Create new instance of WebSocketMessageServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     */
+    constructor(fastify: FastifyInstance);
+    /**
+     * Parse stringified message into a {@link ReactNativeMessage}.
+     *
+     * @param data Stringified message.
+     * @param binary Additional binary data if any.
+     * @returns Parsed message or `undefined` if parsing failed.
+     */
+    parseMessage(data: string, binary: any): Partial<ReactNativeMessage> | undefined;
+    /**
+     * Get client's WebSocket connection for given `clientId`.
+     * Throws if no such client is connected.
+     *
+     * @param clientId Id of the client.
+     * @returns WebSocket connection.
+     */
+    getClientSocket(clientId: string): WebSocketWithUpgradeReq;
+    /**
+     * Process error by sending an error message to the client whose message caused the error
+     * to occur.
+     *
+     * @param clientId Id of the client whose message caused an error.
+     * @param message Original message which caused the error.
+     * @param error Concrete instance of an error that occurred.
+     */
+    handleError(clientId: string, message: Partial<ReactNativeMessage>, error: Error): void;
+    /**
+     * Send given request `message` to it's designated client's socket based on `message.target`.
+     * The target client must be connected, otherwise it will throw an error.
+     *
+     * @param clientId Id of the client that requested the forward.
+     * @param message Message to forward.
+     */
+    forwardRequest(clientId: string, message: Partial<ReactNativeMessage>): void;
+    /**
+     * Send given response `message` to it's designated client's socket based
+     * on `message.id.clientId`.
+     * The target client must be connected, otherwise it will throw an error.
+     *
+     * @param message Message to forward.
+     */
+    forwardResponse(message: Partial<ReactNativeMessage>): void;
+    /**
+     * Process request message targeted towards this {@link WebSocketMessageServer}
+     * and send back the results.
+     *
+     * @param clientId Id of the client who send the message.
+     * @param message The message to process by the server.
+     */
+    processServerRequest(clientId: string, message: Partial<ReactNativeMessage>): void;
+    /**
+     * Broadcast given message to all connected clients.
+     *
+     * @param broadcasterId Id of the client who is broadcasting.
+     * @param message Message to broadcast.
+     */
+    sendBroadcast(broadcasterId: string | undefined, message: Partial<ReactNativeMessage>): void;
+    /**
+     * Send method broadcast to all connected clients.
+     *
+     * @param method Method name to broadcast.
+     * @param params Method parameters.
+     */
+    broadcast(method: string, params?: Record<string, any>): void;
+    /**
+     * Process new client's WebSocket connection.
+     *
+     * @param socket Incoming WebSocket connection.
+     * @param request Upgrade request for the connection.
+     */
+    onConnection(socket: WebSocket, request: IncomingMessage): void;
+}
+export {};

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-message.server.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketMessageServer = void 0;
+const node_url_1 = require("node:url");
+const web_socket_server_1 = require("../web-socket-server");
+/**
+ * Class for creating a WebSocket server and sending messages between development server
+ * and the React Native applications.
+ *
+ * Based on: https://github.com/react-native-community/cli/blob/v4.14.0/packages/cli-server-api/src/websocket/messageSocketServer.ts
+ *
+ * @category Development server
+ */
+class WebSocketMessageServer extends web_socket_server_1.WebSocketServer {
+    static PROTOCOL_VERSION = 2;
+    /**
+     * Check if message is a broadcast request.
+     *
+     * @param message Message to check.
+     * @returns True if message is a broadcast request and should be broadcasted
+     * with {@link sendBroadcast}.
+     */
+    static isBroadcast(message) {
+        return (typeof message.method === "string" &&
+            message.id === undefined &&
+            message.target === undefined);
+    }
+    /**
+     * Check if message is a method request.
+     *
+     * @param message Message to check.
+     * @returns True if message is a request.
+     */
+    static isRequest(message) {
+        return (typeof message.method === "string" && typeof message.target === "string");
+    }
+    /**
+     * Check if message is a response with results of performing some request.
+     *
+     * @param message Message to check.
+     * @returns True if message is a response.
+     */
+    static isResponse(message) {
+        return (typeof message.id === "object" &&
+            typeof message.id.requestId !== "undefined" &&
+            typeof message.id.clientId === "string" &&
+            (message.result !== undefined || message.error !== undefined));
+    }
+    clients = new Map();
+    nextClientId = 0;
+    /**
+     * Create new instance of WebSocketMessageServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     */
+    constructor(fastify) {
+        super(fastify, "/message");
+    }
+    /**
+     * Parse stringified message into a {@link ReactNativeMessage}.
+     *
+     * @param data Stringified message.
+     * @param binary Additional binary data if any.
+     * @returns Parsed message or `undefined` if parsing failed.
+     */
+    parseMessage(data, binary) {
+        if (binary) {
+            this.fastify.log.error({
+                msg: "Failed to parse message - expected text message, got binary",
+            });
+            return undefined;
+        }
+        try {
+            const message = JSON.parse(data);
+            if (message.version === WebSocketMessageServer.PROTOCOL_VERSION.toString()) {
+                return message;
+            }
+            this.fastify.log.error({
+                msg: "Received message had wrong protocol version",
+                message,
+            });
+        }
+        catch {
+            this.fastify.log.error({
+                msg: "Failed to parse the message as JSON",
+                data,
+            });
+        }
+        return undefined;
+    }
+    /**
+     * Get client's WebSocket connection for given `clientId`.
+     * Throws if no such client is connected.
+     *
+     * @param clientId Id of the client.
+     * @returns WebSocket connection.
+     */
+    getClientSocket(clientId) {
+        const socket = this.clients.get(clientId);
+        if (socket === undefined) {
+            throw new Error(`Could not find client with id "${clientId}"`);
+        }
+        return socket;
+    }
+    /**
+     * Process error by sending an error message to the client whose message caused the error
+     * to occur.
+     *
+     * @param clientId Id of the client whose message caused an error.
+     * @param message Original message which caused the error.
+     * @param error Concrete instance of an error that occurred.
+     */
+    handleError(clientId, message, error) {
+        const errorMessage = {
+            id: message.id,
+            method: message.method,
+            target: message.target,
+            error: message.error === undefined ? "undefined" : "defined",
+            params: message.params === undefined ? "undefined" : "defined",
+            result: message.result === undefined ? "undefined" : "defined",
+        };
+        if (message.id === undefined) {
+            this.fastify.log.error({
+                msg: "Handling message failed",
+                clientId,
+                error,
+                errorMessage,
+            });
+        }
+        else {
+            try {
+                const socket = this.getClientSocket(clientId);
+                socket.send(JSON.stringify({
+                    version: WebSocketMessageServer.PROTOCOL_VERSION,
+                    error,
+                    id: message.id,
+                }));
+            }
+            catch (error) {
+                this.fastify.log.error("Failed to reply", {
+                    clientId,
+                    error,
+                    errorMessage,
+                });
+            }
+        }
+    }
+    /**
+     * Send given request `message` to it's designated client's socket based on `message.target`.
+     * The target client must be connected, otherwise it will throw an error.
+     *
+     * @param clientId Id of the client that requested the forward.
+     * @param message Message to forward.
+     */
+    forwardRequest(clientId, message) {
+        if (!message.target) {
+            this.fastify.log.error({
+                msg: "Failed to forward request - message.target is missing",
+                clientId,
+                message,
+            });
+            return;
+        }
+        const socket = this.getClientSocket(message.target);
+        socket.send(JSON.stringify({
+            version: WebSocketMessageServer.PROTOCOL_VERSION,
+            method: message.method,
+            params: message.params,
+            id: message.id === undefined
+                ? undefined
+                : { requestId: message.id, clientId },
+        }));
+    }
+    /**
+     * Send given response `message` to it's designated client's socket based
+     * on `message.id.clientId`.
+     * The target client must be connected, otherwise it will throw an error.
+     *
+     * @param message Message to forward.
+     */
+    forwardResponse(message) {
+        console.log("forwardResponse", message);
+        if (!message.id) {
+            return;
+        }
+        const socket = this.getClientSocket(message.id.clientId);
+        socket.send(JSON.stringify({
+            version: WebSocketMessageServer.PROTOCOL_VERSION,
+            result: message.result,
+            error: message.error,
+            id: message.id.requestId,
+        }));
+    }
+    /**
+     * Process request message targeted towards this {@link WebSocketMessageServer}
+     * and send back the results.
+     *
+     * @param clientId Id of the client who send the message.
+     * @param message The message to process by the server.
+     */
+    processServerRequest(clientId, message) {
+        let result;
+        switch (message.method) {
+            case "getid":
+                result = clientId;
+                break;
+            case "getpeers": {
+                const output = {};
+                this.clients.forEach((peerSocket, peerId) => {
+                    if (clientId !== peerId) {
+                        const { searchParams } = new node_url_1.URL(peerSocket.upgradeReq?.url || "");
+                        output[peerId] = [...searchParams.entries()].reduce((acc, [key, value]) => {
+                            acc[key] = value;
+                            return acc;
+                        }, {});
+                    }
+                });
+                result = output;
+                break;
+            }
+            default:
+                throw new Error(`Cannot process server request - unknown method ${JSON.stringify({
+                    clientId,
+                    message,
+                })}`);
+        }
+        const socket = this.getClientSocket(clientId);
+        socket.send(JSON.stringify({
+            version: WebSocketMessageServer.PROTOCOL_VERSION,
+            result,
+            id: message.id,
+        }));
+    }
+    /**
+     * Broadcast given message to all connected clients.
+     *
+     * @param broadcasterId Id of the client who is broadcasting.
+     * @param message Message to broadcast.
+     */
+    sendBroadcast(broadcasterId, message) {
+        const forwarded = {
+            version: WebSocketMessageServer.PROTOCOL_VERSION,
+            method: message.method,
+            params: message.params,
+        };
+        if (this.clients.size === 0) {
+            this.fastify.log.warn({
+                msg: 
+                // biome-ignore lint/style/useTemplate: <explanation>
+                "No apps connected. " +
+                    `Sending "${message.method}" to all React Native apps failed. ` +
+                    "Make sure your app is running in the simulator or on a phone connected via USB.",
+            });
+        }
+        for (const [clientId, socket] of this.clients) {
+            if (clientId !== broadcasterId) {
+                try {
+                    socket.send(JSON.stringify(forwarded));
+                }
+                catch (error) {
+                    this.fastify.log.error({
+                        msg: "Failed to send broadcast",
+                        clientId,
+                        error,
+                        forwarded,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Send method broadcast to all connected clients.
+     *
+     * @param method Method name to broadcast.
+     * @param params Method parameters.
+     */
+    broadcast(method, params) {
+        this.sendBroadcast(undefined, { method, params });
+    }
+    /**
+     * Process new client's WebSocket connection.
+     *
+     * @param socket Incoming WebSocket connection.
+     * @param request Upgrade request for the connection.
+     */
+    onConnection(socket, request) {
+        const clientId = `client#${this.nextClientId++}`;
+        const client = socket;
+        client.upgradeReq = request;
+        this.clients.set(clientId, client);
+        this.fastify.log.debug({ msg: "Message client connected", clientId });
+        const cleanup = () => {
+            this.fastify.log.debug({ msg: "Cleaning up message client", clientId });
+            socket.removeAllListeners();
+            this.clients.delete(clientId);
+        };
+        const onClose = (close) => {
+            this.fastify.log.debug({
+                msg: ["Message client closed"],
+                clientId,
+                close,
+            });
+            cleanup();
+        };
+        const onError = (error) => {
+            this.fastify.log.error({ msg: "Message client error", clientId, error });
+            cleanup();
+        };
+        socket.addEventListener("error", onError);
+        socket.addEventListener("close", onClose);
+        socket.addEventListener("message", (event) => {
+            const message = this.parseMessage(event.data.toString(), 
+            // @ts-ignore
+            event.binary);
+            if (!message) {
+                this.fastify.log.error({
+                    msg: "Received message not matching protocol",
+                    clientId,
+                    message,
+                });
+                return;
+            }
+            try {
+                if (WebSocketMessageServer.isBroadcast(message)) {
+                    this.sendBroadcast(clientId, message);
+                }
+                else if (WebSocketMessageServer.isRequest(message)) {
+                    if (message.target === "server") {
+                        this.processServerRequest(clientId, message);
+                    }
+                    else {
+                        this.forwardRequest(clientId, message);
+                    }
+                }
+                else if (WebSocketMessageServer.isResponse(message)) {
+                    this.forwardResponse(message);
+                }
+                else {
+                    throw new Error(`Invalid message, did not match the protocol ${JSON.stringify({
+                        clientId,
+                        message,
+                    })}`);
+                }
+            }
+            catch (error) {
+                this.handleError(clientId, message, error);
+            }
+        });
+    }
+}
+exports.WebSocketMessageServer = WebSocketMessageServer;

package/dist/modules/dev/dev-server/plugins/wss/types.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage } from 'node:http';
+import type { Socket } from 'node:net';
+export interface WebSocketServerInterface {
+    shouldUpgrade(pathname: string): boolean;
+    upgrade(request: IncomingMessage, socket: Socket, head: Buffer): void;
+}

package/dist/modules/dev/dev-server/plugins/wss/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/dev/dev-server/plugins/wss/web-socket-router.d.ts

@@ -0,0 +1,32 @@
+import type { FastifyInstance } from "fastify";
+import type { WebSocketServerInterface } from "./types";
+/**
+ * Class for creating a WebSocket router to forward connections to the
+ * respective {@link WebSocketServer} as long as the connection is accepted for the upgrade by the
+ * server.
+ *
+ * If the connection is not accepted by any `WebSocketServer`, it will be destroyed to avoid
+ * creating handling connections and potentially throwing `ECONNRESET` errors.
+ *
+ * @category Development server
+ */
+export declare class WebSocketRouter {
+    private fastify;
+    /** The list of all register WebSocket servers. */
+    protected servers: WebSocketServerInterface[];
+    /**
+     * Create new instance of `WebSocketRouter` and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket router to.
+     */
+    constructor(fastify: FastifyInstance);
+    /**
+     * Register a new {@link WebSocketServer}. New connection will now
+     * check if the given server will accept them and forward them.
+     *
+     * @param server WebSocket server to register.
+     * @returns The same instance of the WebSocket server after it's been registered.
+     */
+    registerServer<T extends WebSocketServerInterface>(server: T): T;
+}