@tui-sandbox/library 11.11.2 → 12.0.0

package/src/scripts/commands/commandRun.ts

@@ -1,68 +0,0 @@
-import assert from "assert"
-import type { CloseEvent } from "concurrently"
-import concurrently from "concurrently"
-import type { PartialDeep } from "type-fest"
-import { debuglog } from "util"
-import * as z from "zod"
-import type { AllKeys } from "../../server/types.js"
-
-const log = debuglog("tui-sandbox.commandRun")
-
-export type TestResultExitCode = string | number
-
-const cypressName = "cypress"
-export async function commandRun(): Promise<TestResultExitCode> {
-  const job = concurrently(
-    [
-      {
-        name: "server",
-        command: "tui start",
-        prefixColor: "blue",
-      },
-      {
-        name: cypressName,
-        command: `'wait-on --timeout 60000 http-get://127.0.0.1:3000/ping && cypress run --config baseUrl=http://127.0.0.1:3000 --quiet'`,
-        prefixColor: "yellow",
-      },
-    ],
-    {
-      killOthersOn: ["failure", "success"],
-      padPrefix: true, // makes all the prefixes the same length
-      successCondition: "command-cypress", // the test run that determines success/failure
-    }
-  )
-
-  await job.result.then(
-    _ => {
-      log("All commands completed successfully")
-    },
-    (err: unknown) => {
-      log("One or more commands failed. Debug info follows.", err)
-    }
-  )
-
-  try {
-    const result = await job.result
-    const cypressCommand = result.find(cmd => cmd.command.name === "cypress")
-    assert(cypressCommand, "Cypress command not found in the result")
-    return cypressCommand.exitCode
-  } catch (e) {
-    // an array of [`CloseEvent`](#CloseEvent), in the order that the commands terminated.
-    // https://github.com/open-cli-tools/concurrently/blob/37212b7d925d8ece22d3afa68a77eef36bb833cc/README.md?plain=1#L125
-    const infos = z
-      .array(
-        z.object({
-          command: z.object({
-            name: z.string(),
-          } satisfies PartialDeep<AllKeys<CloseEvent["command"]>>),
-          exitCode: z.number().or(z.string()),
-        } satisfies PartialDeep<AllKeys<CloseEvent>>)
-      )
-      .parse(e)
-
-    const cypressCommand = infos.find(cmd => cmd.command.name === cypressName)
-    assert(cypressCommand, "Cypress command not found in the result")
-
-    return cypressCommand.exitCode
-  }
-}

package/src/scripts/commands/commandTuiNeovimExec.ts

@@ -1,36 +0,0 @@
-import { NeovimApplication, type StdoutOrStderrMessage } from "../../server/applications/neovim/NeovimApplication.js"
-import { prepareNewTestDirectory } from "../../server/applications/neovim/prepareNewTestDirectory.js"
-import type { TestServerConfigMetadata } from "../../server/updateTestdirectorySchemaFile.js"
-import type { NeovimExec } from "../parseArguments.js"
-
-export async function commandTuiNeovimExec(command: NeovimExec, config: TestServerConfigMetadata): Promise<void> {
-  // automatically dispose of the neovim instance when done
-  await using app = new NeovimApplication(config.config.directories.testEnvironmentPath)
-  app.events.on("stdout" satisfies StdoutOrStderrMessage, data => {
-    console.log(`  neovim output: ${data}`)
-  })
-  const testDirectory = await prepareNewTestDirectory(config.config)
-  const NVIM_APPNAME = process.env["NVIM_APPNAME"]
-
-  if (NVIM_APPNAME && !config.config.integrations.neovim.NVIM_APPNAMEs.find(n => n === NVIM_APPNAME)) {
-    process.exitCode = 1
-    const message = `The NVIM_APPNAME environment variable is set to "${NVIM_APPNAME}", but only the following neovim configurations are known in the configuration file: ${JSON.stringify(
-      config.config.integrations.neovim.NVIM_APPNAMEs
-    )}. Please set NVIM_APPNAME to one of the configured names or unset it to use the default ("nvim"). Config file path: ${config.configFilePath}`
-
-    console.error(message)
-
-    return
-  }
-
-  await app.startNextAndKillCurrent(
-    testDirectory,
-    {
-      filename: "empty.txt",
-      headlessCmd: command.command,
-      NVIM_APPNAME,
-    },
-    { cols: 80, rows: 24 }
-  )
-  await app.application.untilExit()
-}

package/src/scripts/commands/commandTuiNeovimPrepare.ts

@@ -1,12 +0,0 @@
-import { installDependencies } from "../../server/applications/neovim/api.js"
-import type { TestServerConfigMetadata } from "../../server/updateTestdirectorySchemaFile.js"
-
-export async function commandTuiNeovimPrepare(config: TestServerConfigMetadata): Promise<void> {
-  const NVIM_APPNAME = process.env["NVIM_APPNAME"]
-  console.log(`🚀 Installing neovim dependencies${NVIM_APPNAME ? ` for NVIM_APPNAME=${NVIM_APPNAME}` : ""}...`)
-  await installDependencies(process.env["NVIM_APPNAME"], config.config).catch((err: unknown) => {
-    console.error("Error installing neovim dependencies", err)
-    process.exit(1)
-  })
-  process.exit(0)
-}

package/src/scripts/commands/commandTuiStart.ts

@@ -1,36 +0,0 @@
-import path from "path"
-import { createCypressSupportFile } from "../../server/cypress-support/createCypressSupportFile.js"
-import { startTestServer } from "../../server/server.js"
-import type { TestServerConfig, TestServerConfigMetadata } from "../../server/updateTestdirectorySchemaFile.js"
-import { updateTestdirectorySchemaFile } from "../../server/updateTestdirectorySchemaFile.js"
-import { cwd } from "../tui.js"
-
-export async function commandTuiStart(config: TestServerConfigMetadata): Promise<void> {
-  await Promise.allSettled([updateSchemaFile(config.config), createSupportFile()])
-
-  try {
-    console.log(`🚀 Starting test server in ${cwd} - this should be the root of your integration-tests directory 🤞🏻`)
-    await startTestServer(config.config)
-  } catch (e) {
-    console.error("Failed to startTestServer", e)
-  }
-}
-
-async function updateSchemaFile(config: TestServerConfig): Promise<void> {
-  try {
-    await updateTestdirectorySchemaFile(config)
-  } catch (e) {
-    console.error("Failed to updateTestdirectorySchemaFile", e)
-  }
-}
-
-async function createSupportFile(): Promise<void> {
-  try {
-    await createCypressSupportFile({
-      cypressSupportDirectoryPath: path.join(cwd, "cypress", "support"),
-      supportFileName: "tui-sandbox.ts",
-    })
-  } catch (e) {
-    console.error("Failed to createCypressSupportFile", e)
-  }
-}

package/src/scripts/parseArguments.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { parseArguments } from "./parseArguments.js"
-
-it(`can parse "neovim prepare"`, async () => {
-  expect(await parseArguments(["neovim", "prepare"])).toEqual({ action: "neovim prepare" })
-  expect(await parseArguments(["neovim", "prepare", "foo"])).toBeUndefined()
-})
-
-describe("neovim exec", () => {
-  it(`can parse "neovim exec <command>"`, async () => {
-    expect(await parseArguments(["neovim", "exec", "foo"])).toEqual({ action: "neovim exec", command: "foo" })
-  })
-
-  it(`only allows one argument`, async () => {
-    expect(await parseArguments(["neovim", "exec"])).toBeUndefined()
-    expect(await parseArguments(["neovim", "exec", "foo", "bar"])).toBeUndefined()
-  })
-})
-
-it(`can parse "start"`, async () => {
-  expect(await parseArguments(["start"])).toEqual({ action: "start" })
-  expect(await parseArguments(["start", "foo"])).toBeUndefined()
-})
-
-it(`can parse "run"`, async () => {
-  expect(await parseArguments(["run"])).toEqual({ action: "run" })
-  expect(await parseArguments(["run", "foo"])).toBeUndefined()
-})

package/src/scripts/parseArguments.ts

@@ -1,66 +0,0 @@
-import assert from "assert"
-import * as z from "zod"
-
-export const parseArguments = async (args: string[]): Promise<ParseArgumentsResult | undefined> => {
-  {
-    const schema = z.tuple([z.literal("neovim"), z.literal("prepare")])
-    const prepareArguments = schema.safeParse(args)
-    if (prepareArguments.success) {
-      return {
-        action: "neovim prepare",
-      }
-    }
-  }
-
-  {
-    const schema = z.tuple([z.literal("neovim"), z.literal("exec"), z.string()])
-    const execArguments = schema.safeParse(args)
-    if (execArguments.success) {
-      const command = execArguments.data.at(2)
-      assert(command, "No command provided for neovim exec")
-      return {
-        action: "neovim exec",
-        command,
-      }
-    }
-  }
-
-  {
-    const schema = z.tuple([z.literal("start")])
-    const result = schema.safeParse(args)
-    if (result.success) {
-      return {
-        action: "start",
-      }
-    }
-  }
-
-  {
-    const schema = z.tuple([z.literal("run")])
-    const result = schema.safeParse(args)
-    if (result.success) {
-      return {
-        action: "run",
-      }
-    }
-  }
-}
-
-export type ParseArgumentsResult = NeovimPrepare | NeovimExec | TuiStart | TuiRunOnce
-
-export type NeovimExec = {
-  action: "neovim exec"
-  command: string
-}
-
-export type NeovimPrepare = {
-  action: "neovim prepare"
-}
-
-export type TuiStart = {
-  action: "start"
-}
-
-export type TuiRunOnce = {
-  action: "run"
-}

package/src/scripts/resolveConfig.test.ts

@@ -1,78 +0,0 @@
-import assert from "assert"
-import { writeFile } from "fs/promises"
-import { expect } from "vitest"
-import { TempDirectory } from "../server/applications/neovim/environment/TempDirectory.js"
-import type { TestServerConfig } from "../server/updateTestdirectorySchemaFile.js"
-import { testServerConfigSchema } from "../server/updateTestdirectorySchemaFile.js"
-import type { ResolveTuiConfigResult, ResolveTuiConfigResultSuccess } from "./resolveTuiConfig.js"
-import { resolveTuiConfig } from "./resolveTuiConfig.js"
-
-it("defaults to the default configuration if no config file is found", async () => {
-  const config = await resolveTuiConfig(__dirname)
-  assert(!config.error)
-  expect(config.id).toBe("no-config-found" satisfies ResolveTuiConfigResultSuccess["id"])
-  expect(testServerConfigSchema.safeParse(config.result.config).success).toBe(true)
-})
-
-it("loads a custom configuration file if it exists", async () => {
-  using dir = TempDirectory.create()
-
-  const filename = `${dir.path}/tui-sandbox.config.ts`
-  const customConfig: TestServerConfig = {
-    directories: {
-      testEnvironmentPath: "./test-environment2/",
-      outputFilePath: "./output.ts",
-      latestSymlinkName: "latest",
-    },
-    integrations: { neovim: { NVIM_APPNAMEs: ["nvim", "nvim_2"] } },
-    port: 12345,
-  }
-  {
-    const contents = `export const config = ${JSON.stringify(customConfig)}`
-    await writeFile(filename, contents)
-  }
-
-  const config = await resolveTuiConfig(dir.path)
-  expect(config).toStrictEqual({
-    id: "custom-config",
-    result: {
-      config: customConfig,
-      configFilePath: filename,
-    },
-  } satisfies ResolveTuiConfigResult)
-})
-
-it("uses the default configuration file if the config has invalid contents", async () => {
-  using dir = TempDirectory.create()
-
-  {
-    const customConfig: TestServerConfig = {
-      // @ts-expect-error testing an invalid config on purpose
-      directories: undefined,
-      port: 12345,
-    }
-    const filename = `${dir.path}/tui-sandbox.config.ts`
-    const contents = `export const config = ${JSON.stringify(customConfig)}`
-    await writeFile(filename, contents)
-  }
-
-  const result = await resolveTuiConfig(dir.path)
-  assert(result.error)
-  expect(result.configFilePath).contains(dir.path)
-  expect(result.message).match(/Issues found in the config file/)
-})
-
-it("fails if the config has not been exported from the config file", async () => {
-  using dir = TempDirectory.create()
-
-  {
-    const filename = `${dir.path}/tui-sandbox.config.ts`
-    const contents = ``
-    await writeFile(filename, contents)
-  }
-
-  const result = await resolveTuiConfig(dir.path)
-  assert(result.error)
-  expect(result.configFilePath).contains(dir.path)
-  expect(result.message).match(/Issues found in the config file/)
-})

package/src/scripts/resolveTuiConfig.ts

@@ -1,65 +0,0 @@
-import assert from "assert"
-import { resolve } from "path/posix"
-import { pathToFileURL } from "url"
-import { debuglog } from "util"
-import * as z from "zod"
-import { createDefaultConfig } from "../server/config.js"
-import { testServerConfigSchema, type TestServerConfigMetadata } from "../server/updateTestdirectorySchemaFile.js"
-
-const log = debuglog("tui-sandbox.resolveConfig")
-
-export type ResolveTuiConfigResultSuccess = {
-  id: "default-config" | "custom-config" | "no-config-found"
-  result: TestServerConfigMetadata
-  error?: never
-}
-export type ResolveTuiConfigResultError = {
-  error: object
-  configFilePath: string
-  message: string
-}
-
-export type ResolveTuiConfigResult = ResolveTuiConfigResultSuccess | ResolveTuiConfigResultError
-
-export const resolveTuiConfig = async (cwd: string): Promise<ResolveTuiConfigResult> => {
-  const defaultConfig = createDefaultConfig(cwd, process.env)
-
-  const url = pathToFileURL(resolve(cwd, "tui-sandbox.config.ts"))
-
-  let file: unknown
-  try {
-    // loading typescript files works when using https://tsx.is/
-    file = await import(url.href)
-    log(`Found configuration file in ${url.pathname}:`, JSON.stringify(file, null, 2))
-  } catch (e) {
-    console.log("Using the default configuration.")
-    log("Config load error:", e)
-
-    return {
-      id: "no-config-found",
-      result: {
-        config: defaultConfig,
-        configFilePath: url.pathname,
-      },
-    }
-  }
-
-  assert(file)
-  const customConfigSchema = z.strictObject({ config: testServerConfigSchema })
-  const customConfig = customConfigSchema.safeParse(file)
-  if (customConfig.success) {
-    return {
-      id: "custom-config",
-      result: {
-        config: customConfig.data.config,
-        configFilePath: url.pathname,
-      },
-    }
-  } else {
-    return {
-      error: z.treeifyError(customConfig.error),
-      configFilePath: url.pathname,
-      message: `Issues found in the config file`,
-    }
-  }
-}

package/src/scripts/tui.ts

@@ -1,77 +0,0 @@
-import assert from "node:assert"
-import type { TestServerConfigMetadata } from "../server/updateTestdirectorySchemaFile.js"
-import type { TestResultExitCode } from "./commands/commandRun.js"
-import { commandRun } from "./commands/commandRun.js"
-import { commandTuiNeovimExec } from "./commands/commandTuiNeovimExec.js"
-import { commandTuiNeovimPrepare } from "./commands/commandTuiNeovimPrepare.js"
-import { commandTuiStart } from "./commands/commandTuiStart.js"
-import { parseArguments } from "./parseArguments.js"
-import { resolveTuiConfig } from "./resolveTuiConfig.js"
-
-//
-// This is the main entrypoint to tui-sandbox
-//
-
-const [major] = process.versions.node.split(".").map(Number)
-assert(major)
-assert(!isNaN(major))
-
-if (major < 24) {
-  console.error(`tui-sandbox error: Node.js >= 24.0.0 is required. You are using ${process.version}.`)
-  process.exit(1)
-}
-
-/** The cwd in the user's directory when they are running this script. Not the
- * cwd of the script itself. */
-export const cwd = process.cwd()
-const configResult = await resolveTuiConfig(cwd)
-if (configResult.error) {
-  console.error(configResult.message, configResult.error)
-  process.exit(1)
-}
-
-// the arguments passed to this script start at index 2
-const args = process.argv.slice(2)
-const config: TestServerConfigMetadata = configResult.result
-const command = await parseArguments(args)
-
-switch (command?.action) {
-  case "neovim prepare": {
-    await commandTuiNeovimPrepare(config)
-    break
-  }
-  case "neovim exec": {
-    await commandTuiNeovimExec(command, config)
-    break
-  }
-  case "start": {
-    await commandTuiStart(config)
-    break
-  }
-  case "run": {
-    const result: TestResultExitCode = await commandRun()
-    // important:
-    //
-    // This is what determines if the test run was successful or not.
-    process.exitCode = typeof result === "number" ? result : 1
-    break
-  }
-  case undefined: {
-    command satisfies undefined
-    showUsageAndExit()
-  }
-}
-
-function showUsageAndExit() {
-  console.log(
-    [
-      //
-      `Usage (pick one):`,
-      `    tui start`,
-      `    tui neovim exec '<ex-command>'`,
-      `    tui neovim prepare`,
-    ].join("\n")
-  )
-
-  process.exit(1)
-}

package/src/server/TestServer.ts

@@ -1,73 +0,0 @@
-import type { AnyTRPCRouter } from "@trpc/server"
-import * as trpcExpress from "@trpc/server/adapters/express"
-import cors from "cors"
-import { once } from "events"
-import express from "express"
-import { accessSync } from "fs"
-import path from "path"
-import { fileURLToPath } from "url"
-import { debuglog } from "util"
-
-export type TestServerSettings = {
-  port: number
-}
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const log = debuglog("tui-sandbox.TestServer")
-
-export class TestServer {
-  public constructor(private readonly settings: TestServerSettings) {}
-
-  public async startAndRun(appRouter: AnyTRPCRouter): Promise<void> {
-    log("🚀 Server starting")
-
-    const app = express()
-    app.use(
-      "/trpc",
-      trpcExpress.createExpressMiddleware({
-        router: appRouter,
-        createContext: () => ({}),
-        middleware: cors({
-          origin: "*",
-        }),
-      })
-    )
-
-    {
-      const publicPath = path.resolve(__dirname, "..", "..", "browser")
-      try {
-        accessSync(publicPath)
-      } catch {
-        // This is normal when developing the tui-sandbox library locally. It
-        // should always exist when using it as an npm package, however.
-        console.warn(
-          `⚠️ Warning: Looks like the tui-sandbox root contents directory is not accessible at: ${publicPath}`
-        )
-      }
-
-      // eslint-disable-next-line import-x/no-named-as-default-member
-      app.use(express.static(publicPath))
-    }
-
-    app.use("/ping", (_, res) => {
-      // used by the command-line test runner to see when the server is ready
-      res.send("pong")
-    })
-
-    const server = app.listen(this.settings.port, "0.0.0.0")
-
-    console.info(`✅ Server listening on port ${this.settings.port}`)
-
-    await Promise.race([once(process, "SIGTERM"), once(process, "SIGINT")])
-    log("😴 Shutting down...")
-    server.close(error => {
-      if (error) {
-        console.error("Error closing server", error)
-        process.exit(1)
-      }
-      log("Server closed")
-      process.exit(0)
-    })
-  }
-}