feat(vscode): define "deamon" domain messages (#918)

Author: alestiago

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

@@ -2,7 +2,7 @@
  * The Dart Frog daemon is a long-running process that is responsible for
  * managing a single or multiple Dart Frog projects simultaneously.
  *
- * @see {@link https://dartfrog.vgv.dev/docs/advanced/daemon Dart Frog deamon documentation }
+ * @see {@link https://dartfrog.vgv.dev/docs/advanced/daemon Dart Frog daemon documentation }
  */
 export class DartFrogDaemon {
   private static _instance: DartFrogDaemon;

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

@@ -0,0 +1,70 @@
+/**
+ * Defines the protocol used by the Dart Frog daemon "daemon" domain and custom
+ * type guards to check if an object is a valid message.
+ *
+ * @see {@link https://dartfrog.vgv.dev/docs/advanced/daemon#daemon-domain Dart Frog daemon domain}
+ */
+
+import {
+  DaemonRequest,
+  DaemonEvent,
+  isDaemonEvent,
+  isDaemonRequest,
+} from "../protocol";
+
+const domainName = "daemon";
+
+const requestVersionMethodName = `${domainName}.requestVersion`;
+
+export class RequestVersionDaemonRequest extends DaemonRequest {
+  constructor(id: string) {
+    super();
+    this.id = id;
+  }
+
+  public readonly id: string;
+  public readonly method: string = requestVersionMethodName;
+  public readonly params: undefined;
+}
+
+export function isRequestVersionDaemonRequest(
+  object: any
+): object is RequestVersionDaemonRequest {
+  return isDaemonRequest(object) && object.method === requestVersionMethodName;
+}
+
+const killMethodName = `${domainName}.kill`;
+
+export class KillDaemonRequest extends DaemonRequest {
+  constructor(id: string) {
+    super();
+    this.id = id;
+  }
+
+  public readonly id: string;
+  public readonly method: string = killMethodName;
+  public readonly params: undefined;
+}
+
+export function isKillDaemonRequest(object: any): object is KillDaemonRequest {
+  return isDaemonRequest(object) && object.method === killMethodName;
+}
+
+const readyEventName = `${domainName}.ready`;
+
+export interface ReadyDaemonEvent extends DaemonEvent {
+  event: string;
+  params: {
+    version: string;
+    processId: number;
+  };
+}
+
+export function isReadyDaemonEvent(object: any): object is ReadyDaemonEvent {
+  return (
+    isDaemonEvent(object) &&
+    object.event === readyEventName &&
+    typeof object.params.version === "string" &&
+    typeof object.params.processId === "number"
+  );
+}

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

@@ -0,0 +1 @@
+export * from "./daemon";

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

@@ -0,0 +1,2 @@
+export * from "./protocol";
+export * from "./domains";

extensions/vscode/src/daemon/protocol.ts renamed to extensions/vscode/src/daemon/protocol/protocol.ts

@@ -0,0 +1,89 @@
+import * as assert from "assert";
+import {
+  DaemonMessage,
+  KillDaemonRequest,
+  RequestVersionDaemonRequest,
+  isKillDaemonRequest,
+  isReadyDaemonEvent,
+  isRequestVersionDaemonRequest,
+} from "../../../../../daemon";
+
+suite("RequestVersionDaemonRequest", () => {
+  test("is a valid requestVersion request", () => {
+    const request = new RequestVersionDaemonRequest("1");
+
+    assert.equal(request.id, "1");
+    assert.equal(request.method, "daemon.requestVersion");
+    assert.equal(request.params, undefined);
+  });
+});
+
+suite("isRequestVersionDaemonRequest", () => {
+  test("returns true when it is a RequestVersionDaemonRequest", () => {
+    const request = Buffer.from(
+      `[{"method": "daemon.requestVersion", "id": "1"}]\n`,
+      "utf8"
+    );
+    const requestObject = DaemonMessage.decode(request)[0];
+    assert.equal(isRequestVersionDaemonRequest(requestObject), true);
+  });
+
+  test("returns false when it is not a RequestVersionDaemonRequest", () => {
+    const request = Buffer.from(
+      `[{"method": "daemon.notARequestVersion", "id": "1"}]\n`,
+      "utf8"
+    );
+    const requestObject = DaemonMessage.decode(request)[0];
+    assert.equal(isRequestVersionDaemonRequest(requestObject), false);
+  });
+});
+
+suite("KillDaemonRequest", () => {
+  test("is a valid kill request", () => {
+    const request = new KillDaemonRequest("1");
+
+    assert.equal(request.id, "1");
+    assert.equal(request.method, "daemon.kill");
+    assert.equal(request.params, undefined);
+  });
+});
+
+suite("isKillDaemonRequest", () => {
+  test("returns true when it is a KillDaemonRequest", () => {
+    const request = Buffer.from(
+      `[{"method": "daemon.kill", "id": "1"}]\n`,
+      "utf8"
+    );
+    const requestObject = DaemonMessage.decode(request)[0];
+    assert.equal(isKillDaemonRequest(requestObject), true);
+  });
+
+  test("returns false when it is not a KillDaemonRequest", () => {
+    const request = Buffer.from(
+      `[{"method": "daemon.notAKill", "id": "1"}]\n`,
+      "utf8"
+    );
+    const requestObject = DaemonMessage.decode(request)[0];
+    assert.equal(isKillDaemonRequest(requestObject), false);
+  });
+});
+
+suite("isReadyDaemonEvent", () => {
+  test("returns true when it is a KillDaemonRequest", () => {
+    const event = Buffer.from(
+      `[{"event":"daemon.ready","params":{"version":"0.0.1","processId":8623}}]\n`,
+      "utf8"
+    );
+    const eventObject = DaemonMessage.decode(event)[0];
+    assert.equal(isReadyDaemonEvent(eventObject), true);
+  });
+
+  test("returns false when it is not a KillDaemonRequest", () => {
+    const event = Buffer.from(
+      `[{"event":"daemon.notAReady","params":{"version":"0.0.1","processId":8623}}]\n`,
+      "utf8"
+    );
+    const eventObject = DaemonMessage.decode(event)[0];
+    assert.equal(isReadyDaemonEvent(eventObject), false);
+  });
+});

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

@@ -4,7 +4,7 @@ import {
   isDaemonEvent,
   isDaemonRequest,
   isDaemonResponse,
-} from "../../../daemon";
+} from "../../../../daemon";
 
 suite("DaemonMessage", () => {
   suite("decode", () => {