datool 0.0.1

package/src/client/lib/datool-icons.ts

@@ -0,0 +1,37 @@
+import {
+  Ban,
+  Check,
+  CircleAlert,
+  Copy,
+  Download,
+  ExternalLink,
+  Filter,
+  Info,
+  Play,
+  RefreshCcw,
+  Search,
+  Trash2,
+  X,
+} from "lucide-react"
+import type { ComponentType } from "react"
+
+import type { DatoolIconName } from "../../shared/types"
+
+export const LOG_VIEWER_ICONS: Record<
+  DatoolIconName,
+  ComponentType<{ className?: string }>
+> = {
+  Ban,
+  Check,
+  CircleAlert,
+  Copy,
+  Download,
+  ExternalLink,
+  Filter,
+  Info,
+  Play,
+  RefreshCcw,
+  Search,
+  Trash: Trash2,
+  X,
+}

package/src/client/lib/datool-url-state.ts

@@ -0,0 +1,159 @@
+import type { VisibilityState } from "@tanstack/react-table"
+
+type PersistedTableState = {
+  columnFilters?: unknown[]
+  columnSizing?: Record<string, number>
+  columnVisibility?: VisibilityState
+  globalFilter?: string
+  highlightedColumns?: Record<string, boolean>
+  sorting?: unknown[]
+}
+
+const STREAM_PARAM = "stream"
+const DATA_TABLE_URL_PARAM_PREFIX = "datatable-"
+const LOG_VIEWER_TABLE_ID_PREFIX = "datool"
+
+function getSearchUrlParam(tableId: string) {
+  return `${tableId}-search`
+}
+
+function getTableUrlParam(tableId: string) {
+  return `${DATA_TABLE_URL_PARAM_PREFIX}${tableId}`
+}
+
+function isDatoolUrlParam(key: string) {
+  return (
+    key.startsWith(`${DATA_TABLE_URL_PARAM_PREFIX}${LOG_VIEWER_TABLE_ID_PREFIX}`) ||
+    (key.startsWith(`${LOG_VIEWER_TABLE_ID_PREFIX}-`) && key.endsWith("-search"))
+  )
+}
+
+function readPersistedTableState(tableId: string) {
+  if (typeof window === "undefined") {
+    return null
+  }
+
+  try {
+    const rawValue = new URL(window.location.href).searchParams.get(
+      getTableUrlParam(tableId)
+    )
+
+    return rawValue ? (JSON.parse(rawValue) as PersistedTableState) : null
+  } catch {
+    return null
+  }
+}
+
+function sanitizeColumnVisibility(
+  columnVisibility: VisibilityState | undefined,
+  columnIds: string[]
+) {
+  const validIds = new Set(columnIds)
+
+  return Object.fromEntries(
+    Object.entries(columnVisibility ?? {}).filter(([columnId]) =>
+      validIds.has(columnId)
+    )
+  )
+}
+
+function cleanUpDatoolParams(url: URL, tableId: string) {
+  const activeSearchParam = getSearchUrlParam(tableId)
+  const activeTableParam = getTableUrlParam(tableId)
+
+  for (const key of Array.from(url.searchParams.keys())) {
+    if (
+      key === STREAM_PARAM ||
+      key === activeSearchParam ||
+      key === activeTableParam
+    ) {
+      continue
+    }
+
+    if (isDatoolUrlParam(key)) {
+      url.searchParams.delete(key)
+    }
+  }
+}
+
+export function readSelectedStreamId() {
+  if (typeof window === "undefined") {
+    return null
+  }
+
+  return new URL(window.location.href).searchParams.get(STREAM_PARAM)
+}
+
+export function readDatoolSearch(tableId: string) {
+  if (typeof window === "undefined") {
+    return ""
+  }
+
+  return new URL(window.location.href).searchParams.get(getSearchUrlParam(tableId)) ?? ""
+}
+
+export function readDatoolColumnVisibility(
+  tableId: string,
+  columnIds: string[]
+) {
+  return sanitizeColumnVisibility(
+    readPersistedTableState(tableId)?.columnVisibility,
+    columnIds
+  )
+}
+
+export function writeDatoolUrlState({
+  columnIds,
+  columnVisibility,
+  search,
+  selectedStreamId,
+  tableId,
+}: {
+  columnIds: string[]
+  columnVisibility: VisibilityState
+  search: string
+  selectedStreamId: string | null
+  tableId: string
+}) {
+  if (typeof window === "undefined") {
+    return
+  }
+
+  const url = new URL(window.location.href)
+  const searchValue = search.trim()
+  const nextColumnVisibility = sanitizeColumnVisibility(
+    columnVisibility,
+    columnIds
+  )
+  const nextTableState = {
+    ...readPersistedTableState(tableId),
+  } satisfies PersistedTableState
+
+  cleanUpDatoolParams(url, tableId)
+
+  if (selectedStreamId) {
+    url.searchParams.set(STREAM_PARAM, selectedStreamId)
+  } else {
+    url.searchParams.delete(STREAM_PARAM)
+  }
+
+  if (searchValue) {
+    url.searchParams.set(getSearchUrlParam(tableId), search)
+  } else {
+    url.searchParams.delete(getSearchUrlParam(tableId))
+  }
+
+  if (Object.keys(nextColumnVisibility).length > 0) {
+    nextTableState.columnVisibility = nextColumnVisibility
+  } else {
+    delete nextTableState.columnVisibility
+  }
+
+  if (Object.keys(nextTableState).length > 0) {
+    url.searchParams.set(getTableUrlParam(tableId), JSON.stringify(nextTableState))
+  } else {
+    url.searchParams.delete(getTableUrlParam(tableId))
+  }
+
+  window.history.replaceState(window.history.state, "", url)
+}

package/src/client/lib/filterable-table.ts

@@ -0,0 +1,146 @@
+import type { FilterFn } from "@tanstack/react-table"
+
+import { type DataTableColumnConfig } from "@/components/data-table"
+import {
+  buildEnumOptions,
+  matchesFieldClauses,
+  type DataTableSearchField,
+  type DataTableSearchFieldKind,
+  type DataTableSearchFilterClause,
+} from "@/lib/data-table-search"
+
+type TableRow = Record<string, unknown>
+
+export type BuildTableSearchFieldsOptions = {
+  fieldOptions?: Partial<Record<string, string[]>>
+}
+
+function stringifySampleValue(value: unknown) {
+  if (value === null || value === undefined) {
+    return new Date().toISOString()
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString()
+  }
+
+  if (typeof value === "object") {
+    return JSON.stringify(value)
+  }
+
+  return String(value)
+}
+
+function getColumnValueGetter<TData extends TableRow>(
+  column: DataTableColumnConfig<TData>
+) {
+  return (row: TData) => {
+    if (column.accessorFn) {
+      return column.accessorFn(row)
+    }
+
+    if (column.accessorKey) {
+      return row[column.accessorKey]
+    }
+
+    return undefined
+  }
+}
+
+function getDefaultFieldKind<TData extends TableRow>(
+  column: DataTableColumnConfig<TData>
+): DataTableSearchFieldKind {
+  switch (column.kind) {
+    case "date":
+      return "date"
+    case "enum":
+      return "enum"
+    case "json":
+      return "json"
+    case "number":
+      return "number"
+    default:
+      return "text"
+  }
+}
+
+export function resolveTableColumnId<TData extends TableRow>(
+  column: DataTableColumnConfig<TData>,
+  index: number
+) {
+  return (
+    column.id ??
+    column.accessorKey ??
+    (column.header
+      ? column.header.toLowerCase().replace(/\s+/g, "-")
+      : `column-${index}`)
+  )
+}
+
+export function buildTableSearchFields<TData extends TableRow>(
+  columns: DataTableColumnConfig<TData>[],
+  rows: TData[],
+  options: BuildTableSearchFieldsOptions = {}
+) {
+  const latestRow = rows.at(-1)
+
+  return columns.map<DataTableSearchField<TData>>((column, index) => {
+    const columnId = resolveTableColumnId(column, index)
+    const getValue = getColumnValueGetter(column)
+    const kind = getDefaultFieldKind(column)
+
+    if (kind === "enum") {
+      return {
+        getValue,
+        id: columnId,
+        kind,
+        options:
+          options.fieldOptions?.[columnId] ?? buildEnumOptions(rows, getValue),
+      }
+    }
+
+    if (kind === "date") {
+      return {
+        getValue,
+        id: columnId,
+        kind,
+        sample: stringifySampleValue(
+          latestRow ? getValue(latestRow) : new Date().toISOString()
+        ),
+      }
+    }
+
+    return {
+      getValue,
+      id: columnId,
+      kind,
+    }
+  })
+}
+
+export function withColumnSearchFilters<TData extends TableRow>(
+  columns: DataTableColumnConfig<TData>[],
+  fields: DataTableSearchField<TData>[]
+) {
+  const fieldMap = new Map(fields.map((field) => [field.id, field]))
+
+  return columns.map((column, index) => {
+    const columnId = resolveTableColumnId(column, index)
+    const field = fieldMap.get(columnId)
+
+    if (!field || column.filterFn) {
+      return column
+    }
+
+    return {
+      ...column,
+      filterFn: ((row, _columnId, filterValue) => {
+        const clauses = Array.isArray(filterValue)
+          ? (filterValue as DataTableSearchFilterClause[])
+          : []
+
+        return matchesFieldClauses(row.original, field, clauses)
+      }) as FilterFn<TData>,
+    } satisfies DataTableColumnConfig<TData>
+  })
+}

package/src/client/lib/table-search-persistence.ts

@@ -0,0 +1,94 @@
+export type SearchStatePersistence = "localStorage" | "url"
+
+function getSearchLocalStorageKey(tableId: string) {
+  return `${tableId}:search`
+}
+
+function getSearchUrlParam(tableId: string) {
+  return `${tableId}-search`
+}
+
+function getTableUrlParam(tableId: string) {
+  return `datatable-${tableId}`
+}
+
+export function hasSearchUrlPersistence(tableId: string) {
+  if (typeof window === "undefined") {
+    return false
+  }
+
+  const params = new URL(window.location.href).searchParams
+
+  return (
+    params.has(getSearchUrlParam(tableId)) ||
+    params.has(getTableUrlParam(tableId))
+  )
+}
+
+export function getInitialSearchPersistence(
+  tableId: string
+): SearchStatePersistence {
+  return hasSearchUrlPersistence(tableId) ? "url" : "localStorage"
+}
+
+export function readPersistedSearch(
+  tableId: string,
+  statePersistence: SearchStatePersistence
+) {
+  if (typeof window === "undefined") {
+    return ""
+  }
+
+  if (statePersistence === "url") {
+    return (
+      new URL(window.location.href).searchParams.get(
+        getSearchUrlParam(tableId)
+      ) ?? ""
+    )
+  }
+
+  return window.localStorage.getItem(getSearchLocalStorageKey(tableId)) ?? ""
+}
+
+export function writePersistedSearch(
+  tableId: string,
+  statePersistence: SearchStatePersistence,
+  value: string
+) {
+  if (typeof window === "undefined") {
+    return
+  }
+
+  if (statePersistence === "url") {
+    const url = new URL(window.location.href)
+
+    if (value.trim()) {
+      url.searchParams.set(getSearchUrlParam(tableId), value)
+    } else {
+      url.searchParams.delete(getSearchUrlParam(tableId))
+    }
+
+    window.history.replaceState(window.history.state, "", url)
+    return
+  }
+
+  if (value) {
+    window.localStorage.setItem(getSearchLocalStorageKey(tableId), value)
+    return
+  }
+
+  window.localStorage.removeItem(getSearchLocalStorageKey(tableId))
+}
+
+export function clearUrlSearchPersistence(tableId: string) {
+  if (typeof window === "undefined") {
+    return
+  }
+
+  const url = new URL(window.location.href)
+
+  url.searchParams.delete(getSearchUrlParam(tableId))
+  url.searchParams.delete(getTableUrlParam(tableId))
+
+  window.history.replaceState(window.history.state, "", url)
+}

package/src/client/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/src/client/main.tsx

@@ -0,0 +1,14 @@
+import { StrictMode } from "react"
+import { createRoot } from "react-dom/client"
+
+import "./index.css"
+import App from "./App.tsx"
+import { ThemeProvider } from "./components/theme-provider.tsx"
+
+createRoot(document.getElementById("root")!).render(
+  <StrictMode>
+    <ThemeProvider storageKey="datool-theme">
+      <App />
+    </ThemeProvider>
+  </StrictMode>
+)

package/src/index.ts

@@ -0,0 +1,19 @@
+import { commandSource } from "./node/sources/command"
+import { fileSource } from "./node/sources/file"
+import { sshSource } from "./node/sources/ssh"
+import type { DatoolConfig } from "./shared/types"
+
+export * from "./shared/types"
+export { startDatoolServer } from "./node/server"
+
+export function defineDatoolConfig<TConfig extends DatoolConfig>(
+  config: TConfig
+) {
+  return config
+}
+
+export const sources = {
+  command: commandSource,
+  file: fileSource,
+  ssh: sshSource,
+}

package/src/node/cli.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env bun
+import { startDatoolServer } from "./server"
+
+function parseCliArgs(argv: string[]) {
+  const parsedArgs: {
+    configPath?: string
+    host?: string
+    port?: number
+  } = {}
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const currentArg = argv[index]
+    const nextArg = argv[index + 1]
+
+    if (currentArg === "--host" && nextArg) {
+      parsedArgs.host = nextArg
+      index += 1
+      continue
+    }
+
+    if (currentArg === "--port" && nextArg) {
+      parsedArgs.port = Number.parseInt(nextArg, 10)
+      index += 1
+      continue
+    }
+
+    if (currentArg === "--config" && nextArg) {
+      parsedArgs.configPath = nextArg
+      index += 1
+    }
+  }
+
+  return parsedArgs
+}
+
+async function main() {
+  const args = parseCliArgs(process.argv.slice(2))
+  const server = await startDatoolServer({
+    configPath: args.configPath,
+    host: args.host,
+    port: args.port,
+  })
+
+  console.log(`datool ready`)
+  console.log(`config: ${server.configPath}`)
+  console.log(`url: ${server.url}`)
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error)
+
+  console.error(`Failed to start datool: ${message}`)
+  process.exit(1)
+})