Merge pull request #3 from appwrite/chore-update

chore: make synapse.send public and update tests

Author: eldadfux

.github/workflows/publish.yml

@@ -8,7 +8,6 @@ on:
 jobs:
   publish:
     runs-on: ubuntu-latest
-
     steps:
       - uses: actions/checkout@v4
 

README.md

@@ -77,7 +77,7 @@ synapse.disconnect();
 
 ```typescript
 // File operations through Synapse's filesystem service
-import { Synapse, Filesystem } from "synapse";
+import { Synapse, Filesystem } from "@appwrite.io/synapse";
 
 const synapse = new Synapse();
 const filesystem = new Filesystem(synapse);
@@ -92,7 +92,7 @@ const { success, data } = await filesystem.getFolder("/path/to/dir");
 
 ```typescript
 // Get system usage statistics through Synapse's system service
-import { System } from "synapse";
+import { System } from "@appwrite.io/synapse";
 
 const system = new System(synapse);
 const { success, data } = await system.getUsage();
@@ -105,7 +105,7 @@ console.log("Load Average (1m):", data.loadAverage1m);
 
 ```typescript
 // Perform Git operations through Synapse's git service
-import { Synapse, Git } from "synapse";
+import { Synapse, Git } from "@appwrite.io/synapse";
 
 const synapse = new Synapse();
 const git = new Git(synapse);

src/synapse.ts

@@ -9,6 +9,7 @@ export type MessagePayload = {
 export type MessageHandler = (message: MessagePayload) => void;
 export type ConnectionCallback = () => void;
 export type ErrorCallback = (error: Error) => void;
+export type Logger = (message: string) => void;
 
 class Synapse {
   private ws: WebSocket | null = null;
@@ -18,27 +19,7 @@ class Synapse {
     onClose: (() => {}) as ConnectionCallback,
     onError: (() => {}) as ErrorCallback,
   };
-  logger: (message: string) => void = console.log;
-
-  private send(
-    type: string,
-    payload: Record<string, unknown> = {},
-  ): Promise<MessagePayload> {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error("WebSocket is not connected");
-    }
-
-    const message: MessagePayload = {
-      type,
-      requestId: Date.now().toString(),
-      ...payload,
-    };
-
-    return new Promise((resolve) => {
-      this.ws!.send(JSON.stringify(message));
-      resolve(message);
-    });
-  }
+  logger: Logger = console.log;
 
   private handleMessage(event: WebSocket.MessageEvent): void {
     try {
@@ -52,14 +33,6 @@ class Synapse {
     }
   }
 
-  /**
-   * Sets the logger function for the Synapse instance
-   * @param logger - The logger function to use
-   */
-  setLogger(logger: (message: string) => void): void {
-    this.logger = logger;
-  }
-
   /**
    * Establishes a WebSocket connection to the specified URL and initializes the terminal
    * @param url - The WebSocket server URL to connect to
@@ -89,6 +62,41 @@ class Synapse {
     });
   }
 
+  /**
+   * Sets the logger function for the Synapse instance
+   * @param logger - The logger function to use
+   */
+  setLogger(logger: Logger): void {
+    this.logger = logger;
+  }
+
+  /**
+   * Sends a message to the WebSocket server
+   * @param type - The type of message to send
+   * @param payload - The payload of the message
+   * @returns A promise that resolves with the message payload
+   * @throws Error if WebSocket is not connected
+   */
+  send(
+    type: string,
+    payload: Record<string, unknown> = {},
+  ): Promise<MessagePayload> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+
+    const message: MessagePayload = {
+      type,
+      requestId: Date.now().toString(),
+      ...payload,
+    };
+
+    return new Promise((resolve) => {
+      this.ws!.send(JSON.stringify(message));
+      resolve(message);
+    });
+  }
+
   /**
    * Sends a command to the terminal for execution
    * @param command - The command string to execute

tests/synapse.test.ts

@@ -141,4 +141,64 @@ describe("Synapse", () => {
       expect(handler).not.toHaveBeenCalled();
     });
   });
+
+  describe("send", () => {
+    it("should send messages with correct format and return promise with message payload", async () => {
+      const mockWs = {
+        onopen: null as unknown as (event: WebSocket.Event) => void,
+        onmessage: null as unknown as (event: WebSocket.MessageEvent) => void,
+        onerror: null as unknown as (event: WebSocket.ErrorEvent) => void,
+        onclose: null as unknown as (event: WebSocket.CloseEvent) => void,
+        readyState: WebSocket.OPEN,
+        send: jest.fn(),
+      };
+
+      (WebSocket as unknown as jest.Mock).mockImplementation(() => mockWs);
+      const connectPromise = synapse.connect("ws://localhost:8080");
+      mockWs.onopen!({} as WebSocket.Event);
+      await connectPromise;
+
+      const payload = { data: "test-data" };
+      const result = await synapse.send("test-type", payload);
+
+      expect(mockWs.send).toHaveBeenCalledTimes(1);
+      const sentMessage = JSON.parse(mockWs.send.mock.calls[0][0]);
+      expect(sentMessage).toEqual({
+        type: "test-type",
+        requestId: expect.any(String),
+        data: "test-data",
+      });
+      expect(result).toEqual({
+        type: "test-type",
+        requestId: expect.any(String),
+        data: "test-data",
+      });
+    });
+
+    it("should throw error when WebSocket is not connected", () => {
+      expect(() => synapse.send("test-type")).toThrow(
+        "WebSocket is not connected",
+      );
+    });
+
+    it("should throw error when WebSocket is not in OPEN state", async () => {
+      const mockWs = {
+        onopen: null as unknown as (event: WebSocket.Event) => void,
+        onmessage: null as unknown as (event: WebSocket.MessageEvent) => void,
+        onerror: null as unknown as (event: WebSocket.ErrorEvent) => void,
+        onclose: null as unknown as (event: WebSocket.CloseEvent) => void,
+        readyState: WebSocket.CLOSED,
+        send: jest.fn(),
+      };
+
+      (WebSocket as unknown as jest.Mock).mockImplementation(() => mockWs);
+      const connectPromise = synapse.connect("ws://localhost:8080");
+      mockWs.onopen!({} as WebSocket.Event);
+      await connectPromise;
+
+      expect(() => synapse.send("test-type")).toThrow(
+        "WebSocket is not connected",
+      );
+    });
+  });
 });