feat(vscode): allow daemon to send requests (#930)

Author: alestiago

extensions/vscode/src/daemon/dart-frog-daemon.ts

@@ -15,6 +15,26 @@ import {
   IdentifierGenerator,
 } from "../utils";
 
+/**
+ * An error that is thrown when the Dart Frog Daemon has not yet been invoked
+ * but a request is made to it.
+ */
+export class DartFrogDaemonNotInvokedError extends Error {
+  constructor() {
+    super("The Dart Frog Daemon is yet to be invoked.");
+  }
+}
+
+/**
+ * An error that is thrown when the Dart Frog Daemon is invoked but is not yet
+ * ready to accept requests.
+ */
+export class DartFrogDaemonReadyError extends Error {
+  constructor() {
+    super("The Dart Frog Daemon is not yet ready to accept requests.");
+  }
+}
+
 /**
  * The types of events that are emitted by the {@link DartFrogDaemon}.
  *
@@ -102,8 +122,8 @@ export class DartFrogDaemon {
       const readyEventListener = (message: DaemonEvent) => {
         if (!this._isReady && isReadyDaemonEvent(message)) {
           this._isReady = true;
-          resolve();
           this.off(DartFrogDaemonEventEmitterTypes.event, readyEventListener);
+          resolve();
         }
       };
       this.on(
@@ -182,4 +202,47 @@ export class DartFrogDaemon {
     this.daemonMessagesEventEmitter.off(type, listener);
     return this;
   }
+
+  /**
+   * Sends a request to the Dart Frog daemon.
+   *
+   * @param request The request to send to the Dart Frog daemon.
+   * @throws {DartFrogDaemonNotInvokedError} If the Dart Frog daemon has not yet
+   * been {@link invoke}d.
+   * @throws {DartFrogDaemonReadyError} If the Dart Frog daemon is not yet
+   * ready to accept requests.
+   * @returns A promise that resolves to the response from the Dart Frog
+   * daemon to the request.
+   * @see {@link isReady} to check if the Dart Frog daemon is ready to accept
+   * requests.
+   */
+  public send(request: DaemonRequest): Promise<DaemonResponse> {
+    if (!this.process) {
+      throw new DartFrogDaemonNotInvokedError();
+    } else if (!this.isReady) {
+      throw new DartFrogDaemonReadyError();
+    }
+
+    const responsePromise = new Promise<DaemonResponse>((resolve) => {
+      const responseListener = (message: DaemonResponse) => {
+        if (message.id === request.id && message.result) {
+          this.off(DartFrogDaemonEventEmitterTypes.response, responseListener);
+          resolve(message);
+        }
+      };
+      this.on(
+        DartFrogDaemonEventEmitterTypes.response,
+        responseListener.bind(this)
+      );
+    });
+
+    const encodedRequest = `${JSON.stringify([request])}\n`;
+    this.process!.stdin.write(encodedRequest);
+    this.daemonMessagesEventEmitter.emit(
+      DartFrogDaemonEventEmitterTypes.request,
+      request
+    );
+
+    return responsePromise;
+  }
 }

extensions/vscode/src/daemon/protocol/domains/daemon.ts

@@ -10,6 +10,7 @@ import {
   DaemonEvent,
   isDaemonEvent,
   isDaemonRequest,
+  DaemonResponse,
 } from "../protocol";
 
 const domainName = "daemon";

extensions/vscode/src/test/suite/daemon/dart-frog-daemon.test.ts

@@ -4,6 +4,7 @@ import { EventEmitter } from "events";
 
 import { afterEach, beforeEach } from "mocha";
 import assert = require("assert");
+import { RequestVersionDaemonRequest } from "../../../daemon";
 
 suite("DartFrogDaemon", () => {
   let childProcessStub: any;
@@ -292,4 +293,124 @@ suite("DartFrogDaemon", () => {
       sinon.assert.notCalled(callback);
     });
   });
+
+  suite("send", () => {
+    test("throws a DartFrogDaemonNotInvokedError when not invoked", async () => {
+      const daemon = new dartFrogDaemon.DartFrogDaemon();
+
+      const request = new RequestVersionDaemonRequest("1");
+
+      assert.throws(
+        () => daemon.send(request),
+        new dartFrogDaemon.DartFrogDaemonNotInvokedError()
+      );
+    });
+
+    test("throws a DartFrogDaemonReadyError when invoked but not ready", async () => {
+      const daemon = new dartFrogDaemon.DartFrogDaemon();
+
+      const daemonProcess = sinon.stub();
+      const daemonStdoutEventEmitter = new EventEmitter();
+
+      daemonProcess.stdout = daemonStdoutEventEmitter;
+      const workingDirectory = "workingDirectory";
+
+      childProcessStub.spawn
+        .withArgs("dart_frog", ["daemon"], {
+          cwd: workingDirectory,
+        })
+        .returns(daemonProcess);
+
+      daemon.invoke(workingDirectory);
+
+      const request = new RequestVersionDaemonRequest("1");
+
+      assert.throws(
+        () => daemon.send(request),
+        new dartFrogDaemon.DartFrogDaemonReadyError()
+      );
+    });
+
+    suite("when ready", () => {
+      let daemon: any;
+      let stdout: any;
+      let stdin: any;
+
+      beforeEach(() => {
+        const workingDirectory = "workingDirectory";
+
+        const daemonProcess = sinon.stub();
+
+        const daemonStdoutEventEmitter = new EventEmitter();
+        daemonProcess.stdout = stdout = daemonStdoutEventEmitter;
+
+        daemonProcess.stdin = stdin = {
+          write: sinon.stub(),
+        };
+
+        childProcessStub.spawn
+          .withArgs("dart_frog", ["daemon"], {
+            cwd: workingDirectory,
+          })
+          .returns(daemonProcess);
+
+        daemon = new dartFrogDaemon.DartFrogDaemon();
+
+        const invokePromise = daemon.invoke(workingDirectory);
+
+        const readyMessage = `[{"event":"daemon.ready","params":{"version":"0.0.1","processId":94799}}]`;
+        daemonStdoutEventEmitter.emit("data", readyMessage);
+
+        return invokePromise;
+      });
+
+      test("writes request in stdin", async () => {
+        const request = new RequestVersionDaemonRequest("1");
+
+        daemon.send(request);
+
+        sinon.assert.calledOnceWithExactly(
+          stdin.write,
+          `${JSON.stringify([request])}\n`
+        );
+      });
+
+      test("emits request event", async () => {
+        const request = new RequestVersionDaemonRequest("1");
+
+        const callback = sinon.stub();
+        daemon.on(
+          dartFrogDaemon.DartFrogDaemonEventEmitterTypes.request,
+          callback
+        );
+
+        daemon.send(request);
+
+        sinon.assert.calledOnceWithExactly(callback, request);
+      });
+
+      test("resolves correct response", async () => {
+        const request = new RequestVersionDaemonRequest("1");
+
+        const responsePromise = daemon.send(request);
+
+        const anotherResponse = `[{"id":"2","result":{"version":"0.0.1"}}]`;
+        stdout.emit("data", anotherResponse);
+
+        const response = `[{"id":"1","result":{"version":"0.0.1"}}]`;
+        stdout.emit("data", response);
+
+        const actualResponse = await responsePromise;
+
+        const expectedResponse = {
+          id: "1",
+          result: {
+            version: "0.0.1",
+          },
+        };
+
+        assert.deepEqual(actualResponse, expectedResponse);
+      });
+    });
+  });
 });