@tui-sandbox/library 2.1.0 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.3.0](https://github.com/mikavilpas/tui-sandbox/compare/library-v2.2.0...library-v2.3.0) (2024-11-03)
+
+
+### Features
+
+* **wip:** allow access to neovim via a type safe socket connection ([#109](https://github.com/mikavilpas/tui-sandbox/issues/109)) ([1c4d919](https://github.com/mikavilpas/tui-sandbox/commit/1c4d9194ec8961bde0e8f84d500c27363c66a61b))
+
+## [2.2.0](https://github.com/mikavilpas/tui-sandbox/compare/library-v2.1.0...library-v2.2.0) (2024-11-03)
+
+
+### Features
+
+* check that neovim is available before starting the server ([#107](https://github.com/mikavilpas/tui-sandbox/issues/107)) ([bcc817f](https://github.com/mikavilpas/tui-sandbox/commit/bcc817fe25a9811cdd7b1832f6811fa4f92974bd))
+
 ## [2.1.0](https://github.com/mikavilpas/tui-sandbox/compare/library-v2.0.2...library-v2.1.0) (2024-11-02)
 
 

package/dist/src/server/neovim/NeovimApplication.d.ts

@@ -15,7 +15,7 @@ export type StartNeovimGenericArguments = {
 export declare class NeovimApplication {
     private readonly testEnvironmentPath;
     readonly application: DisposableSingleApplication;
-    private testDirectory;
+    private state;
     readonly events: EventEmitter;
     constructor(testEnvironmentPath: string, application?: DisposableSingleApplication);
     /**

package/dist/src/server/neovim/NeovimApplication.js

@@ -1,14 +1,16 @@
 import assert from "assert";
 import { exec } from "child_process";
 import EventEmitter from "events";
-import { existsSync } from "fs";
+import { access } from "fs/promises";
+import { tmpdir } from "os";
 import path from "path";
 import { DisposableSingleApplication } from "../utilities/DisposableSingleApplication";
 import { TerminalApplication } from "../utilities/TerminalApplication";
+import { connectNeovimApi } from "./NeovimJavascriptApiClient";
 export class NeovimApplication {
     testEnvironmentPath;
     application;
-    testDirectory;
+    state;
     events;
     constructor(testEnvironmentPath, application = new DisposableSingleApplication()) {
         this.testEnvironmentPath = testEnvironmentPath;
@@ -20,13 +22,16 @@ export class NeovimApplication {
      */
     async startNextAndKillCurrent(testDirectory, startArgs) {
         await this[Symbol.asyncDispose]();
-        this.testDirectory = testDirectory;
+        assert(this.state === undefined, "NeovimApplication state should be undefined after disposing so that no previous state is reused.");
         const neovimArguments = ["-u", "test-setup.lua"];
         if (startArgs.startupScriptModifications) {
             for (const modification of startArgs.startupScriptModifications) {
                 const file = path.join(testDirectory.rootPathAbsolute, "config-modifications", modification);
-                if (!existsSync(file)) {
-                    throw new Error(`startupScriptModifications file does not exist: ${file}`);
+                try {
+                    await access(file);
+                }
+                catch (e) {
+                    throw new Error(`startupScriptModifications file does not exist: ${file}. Error: ${String(e)}`);
                 }
                 neovimArguments.push("-c", `lua dofile('${file}')`);
             }
@@ -43,6 +48,9 @@ export class NeovimApplication {
                 neovimArguments.push(filePath);
             }
         }
+        const id = Math.random().toString().slice(2, 8);
+        const socketPath = `${tmpdir()}/tui-sandbox-nvim-socket-${id}`;
+        neovimArguments.push("--listen", socketPath);
         const stdout = this.events;
         await this.application.startNextAndKillCurrent(async () => {
             return TerminalApplication.start({
@@ -59,12 +67,25 @@ export class NeovimApplication {
         });
         const processId = this.application.processId();
         assert(processId !== undefined, "Neovim was started without a process ID. This is a bug - please open an issue.");
+        this.state = {
+            testDirectory,
+            socketPath,
+            client: connectNeovimApi(socketPath),
+        };
         console.log(`🚀 Started Neovim instance ${processId}`);
     }
     async [Symbol.asyncDispose]() {
         await this.application[Symbol.asyncDispose]();
-        if (this.testDirectory) {
-            exec(`rm -rf ${this.testDirectory.rootPathAbsolute}`);
+        if (!this.state)
+            return;
+        exec(`rm -rf ${this.state.testDirectory.rootPathAbsolute}`);
+        try {
+            await access(this.state.socketPath);
+            throw new Error(`Socket file ${this.state.socketPath} should have been removed by neovim when it exited.`);
+        }
+        catch (e) {
+            // all good
         }
+        this.state = undefined;
     }
 }

package/dist/src/server/neovim/NeovimJavascriptApiClient.d.ts

@@ -0,0 +1,5 @@
+import type { NeovimClient as NeovimApiClient } from "neovim";
+import { Lazy } from "../utilities/Lazy";
+export type NeovimJavascriptApiClient = NeovimApiClient;
+export type PollingInterval = 100;
+export declare function connectNeovimApi(socketPath: string): Lazy<Promise<NeovimJavascriptApiClient>>;

package/dist/src/server/neovim/NeovimJavascriptApiClient.js

@@ -0,0 +1,21 @@
+import { access } from "fs/promises";
+import { attach } from "neovim";
+import { Lazy } from "../utilities/Lazy";
+export function connectNeovimApi(socketPath) {
+    // it takes about 100ms for the socket file to be created - best make this
+    // Lazy so that we don't wait for it unnecessarily.
+    return new Lazy(async () => {
+        for (let i = 0; i < 100; i++) {
+            try {
+                await access(socketPath);
+                console.log(`socket file ${socketPath} created after at attempt ${i + 1}`);
+                break;
+            }
+            catch (e) {
+                console.log(`polling for socket file ${socketPath} to be created (attempt ${i + 1})`);
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+        }
+        return attach({ socket: socketPath });
+    });
+}

package/dist/src/server/neovim/NeovimJavascriptApiClient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/server/neovim/NeovimJavascriptApiClient.test.js

@@ -0,0 +1,33 @@
+import { access } from "fs/promises";
+import { attach } from "neovim";
+import { connectNeovimApi } from "./NeovimJavascriptApiClient";
+vi.mock("neovim");
+vi.mock("fs/promises");
+const mocked = {
+    attach: vi.mocked(attach),
+    access: vi.mocked(access),
+    log: vi.spyOn(console, "log").mockImplementation(() => {
+        //
+    }),
+};
+const pollingInterval = 100;
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+it("is lazy - does not connect right away", async () => {
+    mocked.access.mockRejectedValue(new Error("no such file or directory"));
+    connectNeovimApi("foosocket");
+    vi.advanceTimersByTime(pollingInterval);
+    expect(mocked.attach).not.toHaveBeenCalled();
+});
+it("connects right away if the socket file is already there", async () => {
+    mocked.access.mockResolvedValue(undefined);
+    const lazyClient = connectNeovimApi("foosocket");
+    await lazyClient.get();
+    vi.advanceTimersByTime(pollingInterval);
+    expect(mocked.attach).toHaveBeenCalledWith({ socket: "foosocket" });
+    expect(mocked.attach).toHaveBeenCalledTimes(1);
+});

package/dist/src/server/server.d.ts

@@ -5,7 +5,8 @@ import type { TestServerConfig } from "./updateTestdirectorySchemaFile";
  * shuts down */
 declare const autocleanup: AsyncDisposableStack;
 export { autocleanup };
-declare function createAppRouter(config: TestServerConfig): import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
+/** @private */
+export declare function createAppRouter(config: TestServerConfig): Promise<import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
     ctx: object;
     meta: object;
     errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
@@ -53,7 +54,7 @@ declare function createAppRouter(config: TestServerConfig): import("@trpc/server
             output: void;
         }>;
     }>;
-}>>;
-export type AppRouter = ReturnType<typeof createAppRouter>;
+}>>>;
+export type AppRouter = Awaited<ReturnType<typeof createAppRouter>>;
 export type RouterInput = inferRouterInputs<AppRouter>;
 export declare function startTestServer(config: TestServerConfig): Promise<TestServer>;

package/dist/src/server/server.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { trpc } from "./connection/trpc";
 import * as neovim from "./neovim";
 import { TestServer } from "./TestServer";
+import { applicationAvailable } from "./utilities/applicationAvailable";
 import { tabIdSchema } from "./utilities/tabId";
 /** Stack for managing resources that need to be disposed of when the server
  * shuts down */
@@ -10,7 +11,12 @@ autocleanup.defer(() => {
     console.log("Closing any open test applications");
 });
 export { autocleanup };
-function createAppRouter(config) {
+/** @private */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export async function createAppRouter(config) {
+    if (!(await applicationAvailable("nvim"))) {
+        throw new Error("Neovim is not installed. Please install Neovim (nvim).");
+    }
     const appRouter = trpc.router({
         neovim: trpc.router({
             start: trpc.procedure
@@ -45,7 +51,7 @@ function createAppRouter(config) {
 }
 export async function startTestServer(config) {
     const testServer = new TestServer(3000);
-    const appRouter = createAppRouter(config);
+    const appRouter = await createAppRouter(config);
     await testServer.startAndRun(appRouter, config);
     return testServer;
 }

package/dist/src/server/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/server/server.test.js

@@ -0,0 +1,23 @@
+import { createAppRouter } from "./server";
+import { applicationAvailable } from "./utilities/applicationAvailable";
+vi.mock("./utilities/applicationAvailable");
+const mocked = {
+    applicationAvailable: vi.mocked(applicationAvailable),
+};
+describe("Neovim server", () => {
+    it("complains when neovim is not installed", async () => {
+        await expect(createAppRouter({
+            outputFilePath: "outputFilePath",
+            testEnvironmentPath: "testEnvironmentPath",
+        })).rejects.toThrow("Neovim is not installed. Please install Neovim (nvim).");
+        expect(mocked.applicationAvailable).toHaveBeenCalledWith("nvim");
+    });
+    it("creates a router when neovim is installed", async () => {
+        mocked.applicationAvailable.mockResolvedValue("nvim");
+        await expect(createAppRouter({
+            outputFilePath: "outputFilePath",
+            testEnvironmentPath: "testEnvironmentPath",
+        })).resolves.toBeDefined();
+        expect(mocked.applicationAvailable).toHaveBeenCalledWith("nvim");
+    });
+});

package/dist/src/server/utilities/applicationAvailable.d.ts

@@ -0,0 +1 @@
+export declare function applicationAvailable(command: string): Promise<string | null>;

package/dist/src/server/utilities/applicationAvailable.js

@@ -0,0 +1,4 @@
+import commandExists from "command-exists";
+export async function applicationAvailable(command) {
+    return commandExists(command);
+}

package/dist/src/server/utilities/applicationAvailable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/server/utilities/applicationAvailable.test.js

@@ -0,0 +1,12 @@
+import { applicationAvailable } from "./applicationAvailable";
+describe("sanity checks for mocking", () => {
+    // because it makes no sense to mock the actual implementation if we don't
+    // know what it does in the current version, we better check what it's
+    // expected to do
+    it("can find neovim using the actual implementation", async () => {
+        await expect(applicationAvailable("nvim")).resolves.toBe("nvim");
+    });
+    it("complains when a nonexistent command is checked", async () => {
+        await expect(applicationAvailable("thisCommandDoesNotExist")).rejects.toBe(null);
+    });
+});