Remove lifecycle state from context and make it explicit

Also: add logging of stderr

Author: cowboyd

deno.json

@@ -10,6 +10,7 @@
   "imports": {
     "@effection-contrib/test-adapter": "jsr:@effection-contrib/test-adapter@^0.1.0",
     "@std/expect": "jsr:@std/expect@^1.0.13",
+    "@std/streams": "jsr:@std/streams@^1.0.9",
     "@std/testing": "jsr:@std/testing@^1.0.9",
     "deepmerge": "npm:deepmerge@^4.3.1",
     "effection": "jsr:@effection/effection@^4.0.0-alpha.7",

deno.lock

@@ -0,0 +1,72 @@
+import type { LSPXMiddleware } from "./types.ts";
+import { createLSPXMiddleware } from "./middleware.ts";
+
+/**
+ * This debug middleware prints handy diagnostics to stderr with
+ * every request/notification in both directions
+ */
+export function debug(): LSPXMiddleware {
+  return createLSPXMiddleware({
+    client2server: {
+      *request(req, next) {
+        let [method, ...params] = req.params;
+        console.error(
+          `--> [client2server.request]`,
+          req.agents.map((a) => a.name),
+          method,
+          params,
+        );
+        let result = yield* next(req);
+        console.error(
+          `<-- [client2server.request]`,
+          req.agents.map((a) => a.name),
+          method,
+          result,
+        );
+        return result;
+      },
+      *notify(req, next) {
+        let [method, ...params] = req.params;
+        console.error(
+          `--> [client2server.notify]`,
+          req.agents.map((a) => a.name),
+          method,
+          params,
+        );
+        let result = yield* next(req);
+        return result;
+      },
+    },
+    server2client: {
+      *request(req, next) {
+        let [method, ...params] = req.params;
+        console.error(
+          `--> [server2client.request]`,
+          req.agent.name,
+          method,
+          params,
+        );
+        let result = yield* next(req);
+        console.error(
+          `<-- [server2client.request]`,
+          req.agent.name,
+          method,
+          result,
+        );
+        return result;
+      },
+
+      *notify(req, next) {
+        let [method, ...params] = req.params;
+        console.error(
+          `--> [server2client.notify]`,
+          req.agent.name,
+          method,
+          params,
+        );
+        let result = yield* next(req);
+        return result;
+      },
+    },
+  });
+}

lib/debug.ts

@@ -1,6 +1,7 @@
 import { all, type Operation } from "effection";
 import type {
   LSPAgent,
+  LSPXMiddleware,
   RequestParams,
   XClientNotification,
   XClientRequest,
@@ -13,6 +14,16 @@ import {
   type CompletionParams,
   ErrorCodes,
 } from "vscode-languageserver-protocol";
+import { createLSPXMiddleware } from "./middleware.ts";
+
+export function defaultHandler(): LSPXMiddleware {
+  return createLSPXMiddleware({
+    client2server: {
+      request: defaultRequest,
+      notify: defaultNotify,
+    },
+  });
+}
 
 /**
  * Dispatch an incoming request from the client to a set of matching
@@ -46,6 +57,17 @@ export function* defaultRequest(options: XClientRequest): Operation<unknown> {
 export function* defaultNotify(options: XClientNotification): Operation<void> {
   let [method] = options.params;
   let handler = defaultMatch(options.agents, method);
+  if (handler.agents.length === 0) {
+    console.error(
+      `no matching agents found for notification '${
+        options.params[0]
+      }. candidates are`,
+      options.agents.map((a) => ({
+        name: a.name,
+        capabilities: a.capabilities,
+      })),
+    );
+  }
 
   yield* all(
     handler.agents.map((agent) => agent.notify(options.params)),

lib/dispatch.ts

@@ -1,40 +1,43 @@
-import { all, call, createContext } from "effection";
+import { all, call } from "effection";
 import type { LSPAgent, LSPXMiddleware } from "./types.ts";
 import { ErrorCodes } from "vscode-jsonrpc";
 import type { InitializeResult } from "vscode-languageserver-protocol";
 import { responseError } from "./json-rpc-connection.ts";
 import * as merge from "./merge.ts";
 import { createLSPXMiddleware } from "./middleware.ts";
 
-const State = createContext<LSPXMiddleware>("lspx.state", uninitialized());
-
 export function lifecycle(): LSPXMiddleware {
+  let transition = (state: State) => {
+    currentState = state;
+  };
+  let currentState = uninitialized(transition);
+
   return createLSPXMiddleware({
     client2server: {
       *request(params, next) {
-        let state = yield* State.expect();
-        return yield* state.client2Server.request(params, next);
+        let { middleware: { client2Server } } = currentState;
+        return yield* client2Server.request(params, next);
       },
       *notify(params, next) {
-        let state = yield* State.expect();
-        return yield* state.client2Server.notify(params, next);
+        let { middleware: { client2Server } } = currentState;
+        return yield* client2Server.notify(params, next);
       },
     },
     server2client: {
       *request(params, next) {
-        let state = yield* State.expect();
-        return yield* state.server2Client.request(params, next);
+        let { middleware: { server2Client } } = currentState;
+        return yield* server2Client.request(params, next);
       },
       *notify(params, next) {
-        let state = yield* State.expect();
-        return yield* state.server2Client.notify(params, next);
+        let { middleware: { server2Client } } = currentState;
+        return yield* server2Client.notify(params, next);
       },
     },
   });
 }
 
-function uninitialized(): LSPXMiddleware {
-  return createLSPXMiddleware({
+function uninitialized(transition: (state: State) => void): State {
+  let middleware = createLSPXMiddleware({
     client2server: {
       *request(options) {
         let [method] = options.params;
@@ -60,20 +63,19 @@ function uninitialized(): LSPXMiddleware {
           ),
         );
 
-        yield* State.set(initialized(agents));
+        transition(initialized(agents, transition));
 
         return cast(merge.capabilities(agents));
       },
     },
   });
+  return { name: "UNINITIALIZED", middleware };
 }
 
-function initialized(agents: LSPAgent[]): LSPXMiddleware {
-  return createLSPXMiddleware({
+function initialized(agents: LSPAgent[], transition: SetState): State {
+  let middleware = createLSPXMiddleware({
     client2server: {
-      notify(options, next) {
-        return next({ ...options, agents });
-      },
+      notify: (options, next) => next({ ...options, agents }),
       *request(options, next) {
         let [method] = options.params;
         if (method === "initialize") {
@@ -82,7 +84,7 @@ function initialized(agents: LSPAgent[]): LSPXMiddleware {
             `initialize invoked twice`,
           );
         } else if (method === "shutdown") {
-          yield* State.set(shutdown());
+          transition(shutdown());
           yield* all(agents.map((agent) => agent.request(options.params)));
           return null;
         } else {
@@ -91,10 +93,12 @@ function initialized(agents: LSPAgent[]): LSPXMiddleware {
       },
     },
   });
+
+  return { name: "INITIALIZED", middleware };
 }
 
-function shutdown(): LSPXMiddleware {
-  return createLSPXMiddleware({
+function shutdown(): State {
+  let middleware = createLSPXMiddleware({
     client2server: {
       *request() {
         return yield* responseError(
@@ -104,6 +108,16 @@ function shutdown(): LSPXMiddleware {
       },
     },
   });
+  return { name: "SHUTDOWN", middleware };
 }
 
 const cast = <T>(value: unknown) => value as T;
+
+interface State {
+  name: string;
+  middleware: LSPXMiddleware;
+}
+
+interface SetState {
+  (state: State): void;
+}

lib/lifecycle.ts

@@ -10,7 +10,9 @@ import type {
 } from "./types.ts";
 import { lifecycle } from "./lifecycle.ts";
 import { combineLSPXMiddlewares } from "./middleware.ts";
-import { defaultNotify, defaultRequest } from "./dispatch.ts";
+import { defaultHandler } from "./dispatch.ts";
+import { responseError } from "./json-rpc-connection.ts";
+import { ErrorCodes } from "vscode-languageserver-protocol";
 
 export interface MultiplexerOptions {
   agents: LSPAgent[];
@@ -24,6 +26,7 @@ export function useMultiplexer(
     let { client2Server, server2Client } = combineLSPXMiddlewares([
       lifecycle(),
       ...options.middlewares,
+      defaultHandler(),
     ]);
 
     let { agents } = options;
@@ -62,9 +65,18 @@ export function useMultiplexer(
       notifications,
       requests,
       notify: (params) =>
-        client2Server.notify({ agents, params }, defaultNotify),
+        client2Server.notify({ agents, params }, function* ({ params }) {
+          let [method, ...rest] = params;
+          console.error(`no handler found for notification '${method}'`, rest);
+        }),
       request: <T>(params: RequestParams) =>
-        client2Server.request({ agents, params }, defaultRequest) as Operation<
+        client2Server.request({ agents, params }, function* ({ params }) {
+          let [method] = params;
+          return yield* responseError(
+            ErrorCodes.MethodNotFound,
+            `no handler found for '${method}'`,
+          );
+        }) as Operation<
           T
         >,
     };