Merge pull request #6 from thefrontside/middleware

✨Middleware

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,5 +1,11 @@
 import { all, type Operation } from "effection";
-import type { LSPAgent, NotificationParams, RequestParams } from "./types.ts";
+import type {
+  LSPAgent,
+  LSPXMiddleware,
+  RequestParams,
+  XClientNotification,
+  XClientRequest,
+} from "./types.ts";
 import deepmerge from "deepmerge";
 import { get, optic } from "optics-ts";
 import { method2capability } from "./capabilities.ts";
@@ -8,21 +14,23 @@ import {
   type CompletionParams,
   ErrorCodes,
 } from "vscode-languageserver-protocol";
+import { createLSPXMiddleware } from "./middleware.ts";
 
-/**
- * An incomping request that should be delegated to some group of server
- */
-export interface RequestOptions {
-  agents: LSPAgent[];
-  params: RequestParams;
+export function defaultHandler(): LSPXMiddleware {
+  return createLSPXMiddleware({
+    client2server: {
+      request: defaultRequest,
+      notify: defaultNotify,
+    },
+  });
 }
 
 /**
  * Dispatch an incoming request from the client to a set of matching
  * agents, and then merge the responses from each one into a single
  * response
  */
-export function* request(options: RequestOptions): Operation<unknown> {
+export function* defaultRequest(options: XClientRequest): Operation<unknown> {
   let { agents, params } = options;
   let handler = match(agents, params);
 
@@ -42,18 +50,24 @@ export function* request(options: RequestOptions): Operation<unknown> {
   return merge(responses);
 }
 
-export interface NotificationOptions {
-  agents: LSPAgent[];
-  params: NotificationParams;
-}
-
 /**
  * Dispatch an incoming notification from the client to a set of
  * matching agents.
  */
-export function* notification(options: NotificationOptions): Operation<void> {
+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)),
@@ -75,7 +89,7 @@ export function match(agents: LSPAgent[], params: RequestParams): Match {
  * If the completion trigger is not specified as one of the triggers
  * that an agent is providing, then it will not be sent the request.
  */
-function completion(options: RequestOptions): Match {
+function completion(options: XClientRequest): Match {
   let { context } = options.params[1] as CompletionParams;
   let agents = options.agents.filter((agent) => {
     let capability = agent.capabilities.completionProvider;

lib/dispatch.ts

@@ -13,8 +13,8 @@ import {
 } from "effection";
 import * as rpc from "vscode-jsonrpc/node.js";
 import type {
+  LSPServerNotification,
   LSPServerRequest,
-  NotificationParams,
   RPCEndpoint,
 } from "./types.ts";
 import { disposable, disposableScope } from "./disposable.ts";
@@ -50,11 +50,13 @@ export function useConnection(
       rpc.createMessageConnection(readable, writable),
     );
 
-    let notifications = createSignal<NotificationParams>();
+    let notifications = createSignal<LSPServerNotification>();
     let requests = createSignal<LSPServerRequest>();
 
     yield* disposable(
-      connection.onNotification((...params) => notifications.send(params)),
+      connection.onNotification((...params) => {
+        notifications.send((execute) => execute(params));
+      }),
     );
 
     yield* disposable(connection.onRequest((...params) => {