🧪 Add first failing test

Author: cowboyd

cancellation-token.ts

@@ -0,0 +1,18 @@
+import { type Operation, useAbortSignal } from "effection";
+import type { CancellationToken } from "vscode-jsonrpc";
+
+export function* useCancellationToken(): Operation<CancellationToken> {
+  let signal = yield* useAbortSignal();
+
+  return {
+    get isCancellationRequested() {
+      return signal.aborted;
+    },
+    onCancellationRequested(listener) {
+      signal.addEventListener("abort", listener);
+      return {
+        dispose: () => signal.removeEventListener("abort", listener),
+      };
+    },
+  };
+}

deno.json

@@ -7,10 +7,12 @@
   },
   "imports": {
     "@effection-contrib/test-adapter": "jsr:@effection-contrib/test-adapter@^0.1.0",
+    "@std/expect": "jsr:@std/expect@^1.0.13",
     "@std/testing": "jsr:@std/testing@^1.0.9",
     "effection": "jsr:@effection/effection@^4.0.0-alpha.7",
     "@std/assert": "jsr:@std/assert@1",
     "vscode-jsonrpc": "npm:vscode-jsonrpc@^8.2.1",
+    "vscode-languageserver-protocol": "npm:vscode-languageserver-protocol@^3.17.5",
     "zod": "npm:zod@^3.24.2",
     "zod-opts": "npm:zod-opts@^0.1.8"
   },

deno.lock

@@ -3,6 +3,7 @@ import { readline } from "./readline.ts";
 import process from "node:process";
 import completions from "./completions.json" with { type: "json" };
 import { each, spawn } from "effection";
+import { useCancellationToken } from "./cancellation-token.ts";
 
 export function* repl(server: LSPXServer) {
   yield* spawn(function* () {
@@ -29,13 +30,17 @@ export function* repl(server: LSPXServer) {
     let match = pattern.exec(line);
     if (match) {
       try {
-        const method = match[1];
-        let params = JSON.parse(`[${match[2]}]`);
+        let method = match[1];
+        let args = JSON.parse(`[${match[2]}]`) as unknown[];
         console.log(
-          `Sending request ${method} with params ${JSON.stringify(params)}...`,
+          `Sending request ${method} with params ${JSON.stringify(args)}...`,
         );
 
-        let response = yield* server.request(method, ...params);
+        let params = args.length === 1 ? args[0] : args;
+
+        let token = yield* useCancellationToken();
+
+        let response = yield* server.request(method, params as object, token);
 
         console.log(JSON.stringify(response, null, 2));
       } catch (e) {

repl.ts

@@ -1,24 +1,43 @@
-import { call, createSignal, type Operation, resource } from "effection";
-import type { Disposable, LSPXServer, Notification } from "./types.ts";
+import {
+  call,
+  createSignal,
+  type Operation,
+  resource,
+  useScope,
+} from "effection";
+import type {
+  Disposable,
+  LSPXServer,
+  Notification,
+  RequestParams,
+} from "./types.ts";
 
-import { useCommand } from "./use-command.ts";
+import { useCommand, useDaemon } from "./use-command.ts";
 import { useConnection } from "./json-rpc-connection.ts";
-import type { MessageConnection } from "vscode-jsonrpc";
+import {
+  ErrorCodes,
+  type MessageConnection,
+  ResponseError,
+  type StarRequestHandler,
+} from "vscode-jsonrpc";
 
-export interface Options {
-  interactive: boolean;
+export interface LSPXOptions {
+  interactive?: boolean;
+  input?: ReadableStream<Uint8Array>;
+  output?: WritableStream<Uint8Array>;
   commands: string[];
 }
 
-export function start(opts: Options): Operation<LSPXServer> {
+export function start(opts: LSPXOptions): Operation<LSPXServer> {
   return resource(function* (provide) {
     let notifications = createSignal<Notification, never>();
     let connections: MessageConnection[] = [];
     let disposables: Disposable[] = [];
+
     try {
       for (let command of opts.commands) {
         let [exe, ...args] = command.split(/\s/g);
-        let process = yield* useCommand(exe, {
+        let process = yield* useDaemon(exe, {
           args,
           stdin: "piped",
           stdout: "piped",
@@ -36,14 +55,28 @@ export function start(opts: Options): Operation<LSPXServer> {
           ),
         );
       }
+
+      let client = yield* useConnection({
+        read: opts.input ?? ReadableStream.from([]),
+        write: opts.output ?? new WritableStream(),
+      });
+
+      let scope = yield* useScope();
+      let dispatch = createDispatch(connections);
+
+      let handler: StarRequestHandler = (...params) =>
+        scope.run(() => dispatch(...params));
+
+      disposables.push(client.onRequest(handler));
+
       yield* provide({
         notifications,
-        *request<T>(method: string, ...params: unknown[]) {
-          for (let connection of connections) {
-            return (yield* call(() =>
-              connection.sendRequest(method, ...params)
-            )) as T;
+        *request<T>(...params: RequestParams): Operation<T> {
+          const result = yield* dispatch<T, unknown>(...params);
+          if (result instanceof ResponseError) {
+            throw result;
           }
+          return result;
         },
       });
     } finally {
@@ -53,3 +86,17 @@ export function start(opts: Options): Operation<LSPXServer> {
     }
   });
 }
+
+function createDispatch(
+  connections: MessageConnection[],
+): <T, E>(...params: RequestParams) => Operation<T | ResponseError<E>> {
+  return function* dispatch(...params) {
+    for (let connection of connections) {
+      return (yield* call(() => connection.sendRequest(...params)));
+    }
+    return new ResponseError(
+      ErrorCodes.ServerNotInitialized,
+      `no active server connections`,
+    );
+  };
+}

server.ts

@@ -34,8 +34,91 @@ export function beforeEach(...args: BeforeEachArgs): void {
 
 export type ItBody = Parameters<TestAdapter["runTest"]>[0];
 
-export function it(name: string, body: ItBody): void {
-  bdd.it<EffectionTestContext>(name, function () {
+export function it(name: string, body?: ItBody): void {
+  if (body) {
+    bdd.it<EffectionTestContext>(name, function () {
+      return this["@effectionx/test-adapter"].runTest(body);
+    });
+  } else {
+    bdd.it.skip(name, () => {});
+  }
+}
+
+it.only = (name: string, body: ItBody) => {
+  bdd.it.only<EffectionTestContext>(name, function () {
     return this["@effectionx/test-adapter"].runTest(body);
   });
+};
+
+import { type Async, expect as $expect, type Expected } from "@std/expect";
+import type { Result } from "effection";
+
+interface ExtendedExpected<IsAsync = false> extends Expected<IsAsync> {
+  toBeErr: (expected?: unknown) => unknown;
+  toBeOk: (expected?: unknown) => unknown;
+
+  // NOTE: You also need to overrides the following typings to allow modifiers to correctly infer typing
+  not: IsAsync extends true ? Async<ExtendedExpected<true>>
+    : ExtendedExpected<false>;
+  resolves: Async<ExtendedExpected<true>>;
+  rejects: Async<ExtendedExpected<true>>;
+}
+
+export const expect = $expect<ExtendedExpected>;
+
+$expect.extend({
+  toBeOk(context, options?: unknown) {
+    let { value } = context;
+    let pass = isOk(value) &&
+      (typeof options === "undefined" || options === value.value);
+
+    if (context.isNot) {
+      return {
+        pass,
+        message: () => `Expected NOT to be ok, but was Ok(${value})`,
+      };
+    } else {
+      let actually = isErr(value)
+        ? `was Err(${value.error})`
+        : `${value} is not a Result`;
+      return {
+        pass,
+        message: () => `Expected to be Ok(${options ?? ""}) but ${actually}`,
+      };
+    }
+  },
+  toBeErr(context, options?: string) {
+    let { value } = context;
+    let pass = isErr(value) &&
+      (typeof options === "undefined" || options === value.error.message);
+    if (context.isNot) {
+      return {
+        pass,
+        message: () =>
+          `Expected NOT to be an error, but was Err(${
+            (value as { error: Error }).error
+          })`,
+      };
+    } else {
+      let actually = isOk(value)
+        ? `was Ok(${value.value})`
+        : isErr(value)
+        ? `but was Err(${value.error})`
+        : `${value} is not a Result`;
+      return {
+        pass,
+        message: () => `Expected to be Err(${options}), but ${actually}`,
+      };
+    }
+  },
+});
+
+function isOk<T>(value: unknown): value is Result<T> & { ok: true } {
+  let result = value as Result<T>;
+  return result.ok;
+}
+
+function isErr<T>(value: unknown): value is { error: Error } {
+  let result = value as Result<T>;
+  return !result.ok && typeof result.error !== "undefined";
 }