datool 0.0.1

package/src/node/server.ts

@@ -0,0 +1,403 @@
+import fs from "fs"
+import fsPromises from "fs/promises"
+import path from "path"
+
+import { getStreamFromConfig, loadDatoolConfig, toClientConfig } from "./config"
+import { openStreamRuntime } from "./runtime"
+import type {
+  DatoolActionRequest,
+  DatoolActionRowChange,
+  DatoolActionResolveResult,
+  DatoolActionResponse,
+  DatoolConfig,
+  DatoolSseErrorEvent,
+} from "../shared/types"
+
+type StartServerOptions = {
+  configPath?: string
+  cwd?: string
+  host?: string
+  port?: number
+}
+
+export type DatoolServerHandle = {
+  config: DatoolConfig
+  configPath: string
+  host: string
+  port: number
+  stop: () => void
+  url: string
+}
+
+const SSE_HEADERS = {
+  "Cache-Control": "no-cache, no-transform",
+  Connection: "keep-alive",
+  "Content-Type": "text/event-stream; charset=utf-8",
+} as const
+
+function packageRootFromImportMeta() {
+  return path.resolve(import.meta.dir, "..", "..")
+}
+
+async function loadClientIndexHtml(packageRoot: string) {
+  const indexPath = path.join(packageRoot, "client-dist", "index.html")
+
+  return fsPromises.readFile(indexPath, "utf8")
+}
+
+function getClientAssetPath(packageRoot: string, pathname: string) {
+  const clientRoot = path.join(packageRoot, "client-dist")
+  const absolutePath = path.resolve(clientRoot, pathname.replace(/^\/+/, ""))
+
+  if (!absolutePath.startsWith(clientRoot)) {
+    return null
+  }
+
+  return absolutePath
+}
+
+function jsonResponse(body: unknown, status = 200) {
+  return Response.json(body, {
+    status,
+  })
+}
+
+function toErrorPayload(error: unknown): DatoolSseErrorEvent {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+    }
+  }
+
+  return {
+    message: String(error),
+  }
+}
+
+function encodeSseEvent(event: string, data: unknown) {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object"
+}
+
+function toActionResponsePayload(
+  result: DatoolActionResolveResult<Record<string, unknown>>,
+  rowCount: number
+): DatoolActionResponse {
+  if (result === undefined || result === true) {
+    return {}
+  }
+
+  if (result === null || result === false) {
+    return {
+      rowChanges: Array<boolean>(rowCount).fill(false),
+    }
+  }
+
+  if (Array.isArray(result)) {
+    if (result.length === 0) {
+      return {}
+    }
+
+    if (result.length !== rowCount) {
+      throw new Error(
+        `Action results must return either an empty array or exactly ${rowCount} item${rowCount === 1 ? "" : "s"}.`
+      )
+    }
+
+    return {
+      rowChanges: result.map<boolean | Record<string, unknown>>((change, index) =>
+        normalizeActionRowChange(change, index)
+      ),
+    }
+  }
+
+  throw new Error(
+    "Action results must return true, false, null, undefined, or an array of row changes."
+  )
+}
+
+function normalizeActionRowChange(
+  change: DatoolActionRowChange<Record<string, unknown>>,
+  index: number
+) {
+  if (change === undefined || change === true) {
+    return true
+  }
+
+  if (change === null || change === false) {
+    return false
+  }
+
+  if (isRecord(change)) {
+    return change
+  }
+
+  throw new Error(
+    `Action result at index ${index} must be a row object, true, false, null, or undefined.`
+  )
+}
+
+async function resolveActionResponsePayload(
+  result: DatoolActionResolveResult<Record<string, unknown>>,
+  rowCount: number
+) {
+  try {
+    return toActionResponsePayload(result, rowCount)
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}
+
+async function createActionResponse(
+  config: DatoolConfig,
+  streamId: string,
+  actionId: string,
+  query: URLSearchParams,
+  request: Request
+) {
+  const stream = getStreamFromConfig(config, streamId)
+
+  if (!stream) {
+    return jsonResponse(
+      {
+        error: `Unknown stream "${streamId}".`,
+      },
+      404
+    )
+  }
+
+  const action = stream.actions?.[actionId]
+
+  if (!action) {
+    return jsonResponse(
+      {
+        error: `Unknown action "${actionId}" for stream "${streamId}".`,
+      },
+      404
+    )
+  }
+
+  let body: DatoolActionRequest
+
+  try {
+    body = (await request.json()) as DatoolActionRequest
+  } catch {
+    return jsonResponse(
+      {
+        error: "Invalid JSON body.",
+      },
+      400
+    )
+  }
+
+  if (!Array.isArray(body.rows) || body.rows.length === 0) {
+    return jsonResponse(
+      {
+        error: "Action requests must include a non-empty rows array.",
+      },
+      400
+    )
+  }
+
+  try {
+    const result = await action.resolve({
+      actionId,
+      query,
+      rows: body.rows,
+      streamId,
+    })
+
+    const payload = await resolveActionResponsePayload(result, body.rows.length)
+
+    if ("error" in payload) {
+      return jsonResponse(
+        {
+          error: payload.error,
+        },
+        500
+      )
+    }
+
+    return jsonResponse(payload)
+  } catch (error) {
+    return jsonResponse(
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+      500
+    )
+  }
+}
+
+function createSseResponse(
+  config: DatoolConfig,
+  streamId: string,
+  query: URLSearchParams,
+  requestSignal: AbortSignal
+) {
+  const stream = getStreamFromConfig(config, streamId)
+
+  if (!stream) {
+    return jsonResponse(
+      {
+        error: `Unknown stream "${streamId}".`,
+      },
+      404
+    )
+  }
+
+  const responseStream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      const encoder = new TextEncoder()
+      const abortController = new AbortController()
+
+      const forwardAbort = () => abortController.abort()
+
+      requestSignal.addEventListener("abort", forwardAbort, {
+        once: true,
+      })
+
+      const send = (event: string, payload: unknown) => {
+        controller.enqueue(encoder.encode(encodeSseEvent(event, payload)))
+      }
+
+      const heartbeat = setInterval(() => {
+        if (!abortController.signal.aborted) {
+          send("heartbeat", { ok: true })
+        }
+      }, 15_000)
+
+      void openStreamRuntime(
+        streamId,
+        stream,
+        query,
+        abortController.signal,
+        {
+          async onError(error) {
+            send("error", toErrorPayload(error))
+          },
+          async onRow(payload) {
+            send("row", payload)
+          },
+        }
+      )
+        .catch((error) => {
+          send("error", toErrorPayload(error))
+        })
+        .finally(() => {
+          clearInterval(heartbeat)
+          requestSignal.removeEventListener("abort", forwardAbort)
+          try {
+            controller.close()
+          } catch {
+            // The client may have already closed the SSE stream.
+          }
+        })
+    },
+    cancel() {
+      // The request signal already drives stream shutdown.
+    },
+  })
+
+  return new Response(responseStream, {
+    headers: SSE_HEADERS,
+  })
+}
+
+export async function startDatoolServer(
+  options: StartServerOptions = {}
+): Promise<DatoolServerHandle> {
+  const cwd = options.cwd ?? process.cwd()
+  const packageRoot = packageRootFromImportMeta()
+  const { config, configPath } = await loadDatoolConfig({
+    configPath: options.configPath,
+    cwd,
+  })
+  const host = options.host ?? config.server?.host ?? "127.0.0.1"
+  const port = options.port ?? config.server?.port ?? 3210
+  const indexHtml = await loadClientIndexHtml(packageRoot)
+  const server = Bun.serve({
+    async fetch(request) {
+      const url = new URL(request.url)
+
+      if (url.pathname === "/api/config") {
+        return jsonResponse(toClientConfig(config))
+      }
+
+      if (
+        url.pathname.startsWith("/api/streams/") &&
+        url.pathname.endsWith("/events")
+      ) {
+        const streamId = decodeURIComponent(
+          url.pathname
+            .slice("/api/streams/".length, -"/events".length)
+            .replace(/\/+$/, "")
+        )
+        const query = new URLSearchParams(url.searchParams)
+
+        query.delete("stream")
+
+        return createSseResponse(config, streamId, query, request.signal)
+      }
+
+      if (
+        request.method === "POST" &&
+        url.pathname.startsWith("/api/streams/") &&
+        url.pathname.includes("/actions/")
+      ) {
+        const pathMatch = url.pathname.match(
+          /^\/api\/streams\/(.+?)\/actions\/(.+?)\/?$/
+        )
+
+        if (!pathMatch) {
+          return new Response("Not found", {
+            status: 404,
+          })
+        }
+
+        const streamId = decodeURIComponent(pathMatch[1] ?? "")
+        const actionId = decodeURIComponent(pathMatch[2] ?? "")
+        const query = new URLSearchParams(url.searchParams)
+
+        query.delete("stream")
+
+        return createActionResponse(config, streamId, actionId, query, request)
+      }
+
+      if (url.pathname === "/" || url.pathname === "/index.html") {
+        return new Response(indexHtml, {
+          headers: {
+            "Content-Type": "text/html; charset=utf-8",
+          },
+        })
+      }
+
+      const assetPath = getClientAssetPath(packageRoot, url.pathname)
+
+      if (assetPath && fs.existsSync(assetPath)) {
+        return new Response(Bun.file(assetPath))
+      }
+
+      return new Response("Not found", {
+        status: 404,
+      })
+    },
+    hostname: host,
+    port,
+  })
+  const resolvedPort = server.port ?? port
+
+  return {
+    config,
+    configPath,
+    host,
+    port: resolvedPort,
+    stop: () => server.stop(true),
+    url: `http://${host}:${resolvedPort}`,
+  }
+}

package/src/node/sources/command.ts

@@ -0,0 +1,82 @@
+import { readLinesFromStream } from "../lines"
+import type { DatoolSource } from "../../shared/types"
+
+type Resolver<T> = T | ((context: { query: URLSearchParams }) => T)
+
+export type CommandSourceOptions = {
+  args?: Resolver<string[]>
+  command: Resolver<string>
+  cwd?: Resolver<string>
+  env?: Resolver<Record<string, string | undefined>>
+}
+
+function resolveValue<T>(value: Resolver<T>, query: URLSearchParams) {
+  if (typeof value === "function") {
+    return (value as (context: { query: URLSearchParams }) => T)({
+      query,
+    })
+  }
+
+  return value
+}
+
+function toSpawnArgs(options: CommandSourceOptions, query: URLSearchParams) {
+  const command = resolveValue(options.command, query)
+  const args = options.args ? resolveValue(options.args, query) : undefined
+
+  if (args && args.length > 0) {
+    return [command, ...args]
+  }
+
+  return ["/bin/sh", "-lc", command]
+}
+
+export function commandSource(options: CommandSourceOptions): DatoolSource {
+  return {
+    async open(context) {
+      const cmd = toSpawnArgs(options, context.query)
+      const env = options.env ? resolveValue(options.env, context.query) : undefined
+      const cwd = options.cwd ? resolveValue(options.cwd, context.query) : undefined
+      const child = Bun.spawn(cmd, {
+        cwd,
+        env,
+        stderr: "pipe",
+        stdout: "pipe",
+      })
+
+      const abortChild = () => {
+        try {
+          child.kill()
+        } catch {
+          // Ignore process termination races during shutdown.
+        }
+      }
+
+      context.signal.addEventListener("abort", abortChild, {
+        once: true,
+      })
+
+      try {
+        await Promise.all([
+          readLinesFromStream(child.stdout, {
+            onLine: context.emit,
+            signal: context.signal,
+          }),
+          child.exited,
+        ])
+
+        const exitCode = await child.exited
+
+        if (exitCode !== 0 && !context.signal.aborted) {
+          const stderrText = await new Response(child.stderr).text()
+
+          throw new Error(
+            stderrText.trim() || `Command exited with code ${exitCode}.`
+          )
+        }
+      } finally {
+        context.signal.removeEventListener("abort", abortChild)
+      }
+    },
+  }
+}

package/src/node/sources/file.ts

@@ -0,0 +1,116 @@
+import fs from "fs/promises"
+
+import { waitForDelay } from "../lines"
+import type { DatoolSource } from "../../shared/types"
+
+type Resolver<T> = T | ((context: { query: URLSearchParams }) => T)
+
+export type FileSourceOptions = {
+  historyParam?: string
+  path: Resolver<string>
+  pollIntervalMs?: number
+}
+
+function resolveValue<T>(value: Resolver<T>, query: URLSearchParams) {
+  if (typeof value === "function") {
+    return (value as (context: { query: URLSearchParams }) => T)({
+      query,
+    })
+  }
+
+  return value
+}
+
+function toHistoryLineCount(query: URLSearchParams, historyParam: string) {
+  const rawValue = query.get(historyParam)
+
+  if (!rawValue) {
+    return 0
+  }
+
+  const parsedValue = Number.parseInt(rawValue, 10)
+
+  if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
+    return 0
+  }
+
+  return parsedValue
+}
+
+function normalizeLines(content: string) {
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n")
+}
+
+async function emitHistoryLines(
+  filePath: string,
+  lineCount: number,
+  emit: (line: string) => void
+) {
+  if (lineCount <= 0) {
+    return
+  }
+
+  const content = await fs.readFile(filePath, "utf8")
+  const lines = normalizeLines(content).filter(Boolean)
+
+  for (const line of lines.slice(-lineCount)) {
+    emit(line)
+  }
+}
+
+async function readAppendedText(filePath: string, start: number, end: number) {
+  const fileHandle = await fs.open(filePath, "r")
+
+  try {
+    const length = end - start
+    const buffer = Buffer.alloc(length)
+
+    await fileHandle.read(buffer, 0, length, start)
+
+    return buffer.toString("utf8")
+  } finally {
+    await fileHandle.close()
+  }
+}
+
+export function fileSource(options: FileSourceOptions): DatoolSource {
+  return {
+    async open(context) {
+      const historyParam = options.historyParam ?? "history"
+      const pollIntervalMs = options.pollIntervalMs ?? 250
+      const filePath = resolveValue(options.path, context.query)
+      const historyLineCount = toHistoryLineCount(context.query, historyParam)
+      let stat = await fs.stat(filePath)
+      let position = stat.size
+      let remainder = ""
+
+      await emitHistoryLines(filePath, historyLineCount, context.emit)
+
+      while (!context.signal.aborted) {
+        stat = await fs.stat(filePath)
+
+        if (stat.size < position) {
+          position = 0
+          remainder = ""
+        }
+
+        if (stat.size > position) {
+          const appendedText = await readAppendedText(filePath, position, stat.size)
+          const normalized = (remainder + appendedText).replace(/\r\n/g, "\n").replace(/\r/g, "\n")
+          const parts = normalized.split("\n")
+
+          remainder = parts.pop() ?? ""
+          position = stat.size
+
+          for (const line of parts) {
+            if (line.length > 0) {
+              context.emit(line)
+            }
+          }
+        }
+
+        await waitForDelay(pollIntervalMs, context.signal)
+      }
+    },
+  }
+}

package/src/node/sources/ssh.ts

@@ -0,0 +1,59 @@
+import { commandSource } from "./command"
+import type { DatoolSource } from "../../shared/types"
+
+type Resolver<T> = T | ((context: { query: URLSearchParams }) => T)
+
+export type SshSourceOptions = {
+  command: Resolver<string>
+  host: string
+  identityFile?: string
+  options?: Record<string, string>
+  port?: number
+  user?: string
+}
+
+function resolveValue<T>(value: Resolver<T>, query: URLSearchParams) {
+  if (typeof value === "function") {
+    return (value as (context: { query: URLSearchParams }) => T)({
+      query,
+    })
+  }
+
+  return value
+}
+
+export function buildSshArgs(
+  options: SshSourceOptions,
+  query: URLSearchParams
+) {
+  const sshArgs: string[] = []
+
+  if (options.port) {
+    sshArgs.push("-p", String(options.port))
+  }
+
+  if (options.identityFile) {
+    sshArgs.push("-i", options.identityFile)
+  }
+
+  for (const [key, value] of Object.entries(options.options ?? {})) {
+    sshArgs.push("-o", `${key}=${value}`)
+  }
+
+  const target = options.user ? `${options.user}@${options.host}` : options.host
+
+  sshArgs.push(target, resolveValue(options.command, query))
+
+  return sshArgs
+}
+
+export function sshSource(options: SshSourceOptions): DatoolSource {
+  return {
+    open(context) {
+      return commandSource({
+        args: buildSshArgs(options, context.query),
+        command: "ssh",
+      }).open(context)
+    },
+  }
+}

package/src/shared/columns.ts

@@ -0,0 +1,41 @@
+import type { DatoolColumn } from "./types"
+
+export function resolveDatoolColumnId(
+  column: DatoolColumn,
+  index: number
+) {
+  return (
+    column.id ??
+    column.accessorKey ??
+    (column.header
+      ? column.header.toLowerCase().replace(/\s+/g, "-")
+      : `column-${index}`)
+  )
+}
+
+export function getValueAtPath(
+  value: Record<string, unknown>,
+  accessorKey: string
+): unknown {
+  if (!accessorKey.includes(".")) {
+    return value[accessorKey]
+  }
+
+  return accessorKey
+    .split(".")
+    .reduce<unknown>((currentValue, segment) => {
+      if (
+        currentValue === null ||
+        currentValue === undefined ||
+        typeof currentValue !== "object"
+      ) {
+        return undefined
+      }
+
+      return (currentValue as Record<string, unknown>)[segment]
+    }, value)
+}
+
+export function isNestedAccessorKey(accessorKey: string) {
+  return accessorKey.includes(".")
+}