@hasna/logs 0.3.26 → 0.3.27

package/src/server/routes/logs.ts

@@ -1,113 +0,0 @@
-import { Hono } from "hono"
-import type { Database } from "bun:sqlite"
-import { ingestBatch, ingestLog } from "../../lib/ingest.ts"
-import { getLogContext, searchLogs, tailLogs } from "../../lib/query.ts"
-import { summarizeLogs } from "../../lib/summarize.ts"
-import { exportToCsv, exportToJson } from "../../lib/export.ts"
-import { countLogs } from "../../lib/count.ts"
-import { parseTime } from "../../lib/parse-time.ts"
-import { resolveProjectId } from "../../lib/projects.ts"
-import type { LogEntry, LogLevel } from "../../types/index.ts"
-
-export function logsRoutes(db: Database) {
-  const app = new Hono()
-
-  // POST /api/logs — ingest single or batch
-  app.post("/", async (c) => {
-    const body = await c.req.json()
-    if (Array.isArray(body)) {
-      const rows = ingestBatch(db, body as LogEntry[])
-      return c.json({ inserted: rows.length }, 201)
-    }
-    const row = ingestLog(db, body as LogEntry)
-    return c.json(row, 201)
-  })
-
-  // GET /api/logs
-  app.get("/", (c) => {
-    const { project_id, page_id, level, service, since, until, text, trace_id, limit, offset, fields } = c.req.query()
-    const rows = searchLogs(db, {
-      project_id: project_id || undefined,
-      page_id: page_id || undefined,
-      level: level ? (level.split(",") as LogLevel[]) : undefined,
-      service: service || undefined,
-      since: since || undefined,
-      until: until || undefined,
-      text: text || undefined,
-      trace_id: trace_id || undefined,
-      limit: limit ? Number(limit) : 100,
-      offset: offset ? Number(offset) : 0,
-    })
-    if (fields) {
-      const keys = fields.split(",")
-      return c.json(rows.map(r => Object.fromEntries(keys.map(k => [k, (r as Record<string, unknown>)[k]]))))
-    }
-    return c.json(rows)
-  })
-
-  // GET /api/logs/tail
-  app.get("/tail", (c) => {
-    const { project_id, n } = c.req.query()
-    const rows = tailLogs(db, project_id || undefined, n ? Number(n) : 50)
-    return c.json(rows)
-  })
-
-  // GET /api/logs/summary
-  app.get("/summary", (c) => {
-    const { project_id, since } = c.req.query()
-    const summary = summarizeLogs(db, resolveProjectId(db, project_id) || undefined, parseTime(since) || since || undefined)
-    return c.json(summary)
-  })
-
-  // GET /api/logs/count
-  app.get("/count", (c) => {
-    const { project_id, service, level, since, until } = c.req.query()
-    return c.json(countLogs(db, {
-      project_id: resolveProjectId(db, project_id) || undefined,
-      service: service || undefined,
-      level: level || undefined,
-      since: since || undefined,
-      until: until || undefined,
-    }))
-  })
-
-  // GET /api/logs/recent-errors
-  app.get("/recent-errors", (c) => {
-    const { project_id, since, limit } = c.req.query()
-    const rows = searchLogs(db, {
-      project_id: resolveProjectId(db, project_id) || undefined,
-      level: ["error", "fatal"],
-      since: parseTime(since || "1h"),
-      limit: limit ? Number(limit) : 20,
-    })
-    return c.json(rows.map(r => ({ id: r.id, timestamp: r.timestamp, level: r.level, message: r.message, service: r.service, age_seconds: Math.floor((Date.now() - new Date(r.timestamp).getTime()) / 1000) })))
-  })
-
-  // GET /api/logs/:trace_id/context
-  app.get("/:trace_id/context", (c) => {
-    const rows = getLogContext(db, c.req.param("trace_id"))
-    return c.json(rows)
-  })
-
-  // GET /api/logs/export?format=json|csv&project_id=&since=&level=
-  app.get("/export", (c) => {
-    const { project_id, since, until, level, service, format, limit } = c.req.query()
-    const opts = { project_id: project_id || undefined, since: since || undefined, until: until || undefined, level: level || undefined, service: service || undefined, limit: limit ? Number(limit) : undefined }
-
-    if (format === "csv") {
-      c.header("Content-Type", "text/csv")
-      c.header("Content-Disposition", "attachment; filename=logs.csv")
-      const chunks: string[] = []
-      exportToCsv(db, opts, s => chunks.push(s))
-      return c.text(chunks.join(""))
-    }
-
-    c.header("Content-Type", "application/json")
-    c.header("Content-Disposition", "attachment; filename=logs.json")
-    const chunks: string[] = []
-    exportToJson(db, opts, s => chunks.push(s))
-    return c.text(chunks.join("\n"))
-  })
-
-  return app
-}

package/src/server/routes/perf.ts

@@ -1,23 +0,0 @@
-import { Hono } from "hono"
-import type { Database } from "bun:sqlite"
-import { getLatestSnapshot, getPerfTrend } from "../../lib/perf.ts"
-
-export function perfRoutes(db: Database) {
-  const app = new Hono()
-
-  app.get("/", (c) => {
-    const { project_id, page_id, since } = c.req.query()
-    if (!project_id) return c.json({ error: "project_id is required" }, 422)
-    const snap = getLatestSnapshot(db, project_id, page_id || undefined)
-    return c.json(snap)
-  })
-
-  app.get("/trend", (c) => {
-    const { project_id, page_id, since, limit } = c.req.query()
-    if (!project_id) return c.json({ error: "project_id is required" }, 422)
-    const trend = getPerfTrend(db, project_id, page_id || undefined, since || undefined, limit ? Number(limit) : 50)
-    return c.json(trend)
-  })
-
-  return app
-}

package/src/server/routes/projects.ts

@@ -1,67 +0,0 @@
-import { Hono } from "hono"
-import type { Database } from "bun:sqlite"
-import { createPage, createProject, getProject, listPages, listProjects } from "../../lib/projects.ts"
-import { syncGithubRepo } from "../../lib/github.ts"
-import { runRetentionForProject, setRetentionPolicy } from "../../lib/retention.ts"
-import { deletePageAuth, setPageAuth } from "../../lib/page-auth.ts"
-
-export function projectsRoutes(db: Database) {
-  const app = new Hono()
-
-  app.post("/", async (c) => {
-    const body = await c.req.json()
-    if (!body.name) return c.json({ error: "name is required" }, 422)
-    const project = createProject(db, body)
-    return c.json(project, 201)
-  })
-
-  app.get("/", (c) => c.json(listProjects(db)))
-
-  app.get("/:id", (c) => {
-    const project = getProject(db, c.req.param("id"))
-    if (!project) return c.json({ error: "not found" }, 404)
-    return c.json(project)
-  })
-
-  app.post("/:id/pages", async (c) => {
-    const body = await c.req.json()
-    if (!body.url) return c.json({ error: "url is required" }, 422)
-    const page = createPage(db, { ...body, project_id: c.req.param("id") })
-    return c.json(page, 201)
-  })
-
-  app.get("/:id/pages", (c) => c.json(listPages(db, c.req.param("id"))))
-
-  app.put("/:id/retention", async (c) => {
-    const body = await c.req.json()
-    setRetentionPolicy(db, c.req.param("id"), body)
-    return c.json({ updated: true })
-  })
-
-  app.post("/:id/retention/run", (c) => {
-    const result = runRetentionForProject(db, c.req.param("id"))
-    return c.json(result)
-  })
-
-  app.post("/:id/pages/:page_id/auth", async (c) => {
-    const { type, credentials } = await c.req.json()
-    if (!type || !credentials) return c.json({ error: "type and credentials required" }, 422)
-    const result = setPageAuth(db, c.req.param("page_id"), type, credentials)
-    return c.json({ id: result.id, type: result.type, created_at: result.created_at }, 201)
-  })
-
-  app.delete("/:id/pages/:page_id/auth", (c) => {
-    deletePageAuth(db, c.req.param("page_id"))
-    return c.json({ deleted: true })
-  })
-
-  app.post("/:id/sync-repo", async (c) => {
-    const project = getProject(db, c.req.param("id"))
-    if (!project) return c.json({ error: "not found" }, 404)
-    if (!project.github_repo) return c.json({ error: "no github_repo set" }, 422)
-    const updated = await syncGithubRepo(db, project)
-    return c.json(updated)
-  })
-
-  return app
-}

package/src/server/routes/stream.ts

@@ -1,43 +0,0 @@
-import { Hono } from "hono"
-import { streamSSE } from "hono/streaming"
-import type { Database } from "bun:sqlite"
-import type { LogLevel, LogRow } from "../../types/index.ts"
-
-export function streamRoutes(db: Database) {
-  const app = new Hono()
-
-  // GET /api/logs/stream?project_id=&level=&service=
-  app.get("/", (c) => {
-    const { project_id, level, service } = c.req.query()
-
-    return streamSSE(c, async (stream) => {
-      let lastId: string | null = null
-
-      // Seed lastId with the most recent log so we only stream new ones
-      const latest = db.prepare("SELECT id FROM logs ORDER BY timestamp DESC LIMIT 1").get() as { id: string } | null
-      lastId = latest?.id ?? null
-
-      while (true) {
-        const conditions: string[] = []
-        const params: Record<string, unknown> = {}
-
-        if (lastId) { conditions.push("rowid > (SELECT rowid FROM logs WHERE id = $lastId)"); params.$lastId = lastId }
-        if (project_id) { conditions.push("project_id = $project_id"); params.$project_id = project_id }
-        if (level) { conditions.push("level IN (" + level.split(",").map((l, i) => `$l${i}`).join(",") + ")"); level.split(",").forEach((l, i) => { params[`$l${i}`] = l }) }
-        if (service) { conditions.push("service = $service"); params.$service = service }
-
-        const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
-        const rows = db.prepare(`SELECT * FROM logs ${where} ORDER BY timestamp ASC LIMIT 50`).all(params) as LogRow[]
-
-        for (const row of rows) {
-          await stream.writeSSE({ data: JSON.stringify(row), id: row.id, event: row.level })
-          lastId = row.id
-        }
-
-        await stream.sleep(500)
-      }
-    })
-  })
-
-  return app
-}

package/src/server/server.test.ts

@@ -1,194 +0,0 @@
-import { describe, expect, it, beforeEach } from "bun:test"
-import { Hono } from "hono"
-import { cors } from "hono/cors"
-import { createTestDb } from "../db/index.ts"
-import { logsRoutes } from "./routes/logs.ts"
-import { projectsRoutes } from "./routes/projects.ts"
-import { jobsRoutes } from "./routes/jobs.ts"
-import { perfRoutes } from "./routes/perf.ts"
-
-function buildApp() {
-  const db = createTestDb()
-  const app = new Hono()
-  app.use("*", cors())
-  app.route("/api/logs", logsRoutes(db))
-  app.route("/api/projects", projectsRoutes(db))
-  app.route("/api/jobs", jobsRoutes(db))
-  app.route("/api/perf", perfRoutes(db))
-  return { app, db }
-}
-
-describe("POST /api/logs", () => {
-  it("ingests a single log", async () => {
-    const { app } = buildApp()
-    const res = await app.request("/api/logs", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ level: "error", message: "boom" }) })
-    expect(res.status).toBe(201)
-    const body = await res.json() as { level: string; message: string }
-    expect(body.level).toBe("error")
-    expect(body.message).toBe("boom")
-  })
-
-  it("ingests a batch", async () => {
-    const { app } = buildApp()
-    const res = await app.request("/api/logs", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify([{ level: "info", message: "a" }, { level: "warn", message: "b" }]) })
-    expect(res.status).toBe(201)
-    const body = await res.json() as { inserted: number }
-    expect(body.inserted).toBe(2)
-  })
-})
-
-describe("GET /api/logs", () => {
-  it("lists logs", async () => {
-    const { app, db } = buildApp()
-    const { ingestBatch } = await import("../lib/ingest.ts")
-    ingestBatch(db, [{ level: "error", message: "e1" }, { level: "info", message: "i1" }])
-    const res = await app.request("/api/logs")
-    expect(res.status).toBe(200)
-    const body = await res.json() as unknown[]
-    expect(body.length).toBeGreaterThanOrEqual(2)
-  })
-
-  it("filters by level", async () => {
-    const { app, db } = buildApp()
-    const { ingestBatch } = await import("../lib/ingest.ts")
-    ingestBatch(db, [{ level: "error", message: "e1" }, { level: "info", message: "i1" }])
-    const res = await app.request("/api/logs?level=error")
-    const body = await res.json() as { level: string }[]
-    expect(body.every(r => r.level === "error")).toBe(true)
-  })
-
-  it("supports ?fields= projection", async () => {
-    const { app, db } = buildApp()
-    const { ingestLog } = await import("../lib/ingest.ts")
-    ingestLog(db, { level: "info", message: "hello" })
-    const res = await app.request("/api/logs?fields=level,message")
-    const body = await res.json() as Record<string, unknown>[]
-    expect(Object.keys(body[0]!).sort()).toEqual(["level", "message"].sort())
-  })
-})
-
-describe("GET /api/logs/tail", () => {
-  it("returns recent logs", async () => {
-    const { app, db } = buildApp()
-    const { ingestBatch } = await import("../lib/ingest.ts")
-    ingestBatch(db, Array.from({ length: 10 }, (_, i) => ({ level: "info" as const, message: `m${i}` })))
-    const res = await app.request("/api/logs/tail?n=5")
-    const body = await res.json() as unknown[]
-    expect(body).toHaveLength(5)
-  })
-})
-
-describe("GET /api/logs/summary", () => {
-  it("returns summary of errors/warns", async () => {
-    const { app, db } = buildApp()
-    const { ingestBatch } = await import("../lib/ingest.ts")
-    ingestBatch(db, [{ level: "error", message: "x", service: "api" }, { level: "warn", message: "y", service: "db" }])
-    const res = await app.request("/api/logs/summary")
-    const body = await res.json() as unknown[]
-    expect(body.length).toBeGreaterThan(0)
-  })
-})
-
-describe("GET /api/logs/:trace_id/context", () => {
-  it("returns logs for trace", async () => {
-    const { app, db } = buildApp()
-    const { ingestBatch } = await import("../lib/ingest.ts")
-    ingestBatch(db, [{ level: "info", message: "a", trace_id: "t99" }, { level: "error", message: "b", trace_id: "t99" }])
-    const res = await app.request("/api/logs/t99/context")
-    const body = await res.json() as unknown[]
-    expect(body).toHaveLength(2)
-  })
-})
-
-describe("POST /api/projects", () => {
-  it("creates a project", async () => {
-    const { app } = buildApp()
-    const res = await app.request("/api/projects", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name: "myapp" }) })
-    expect(res.status).toBe(201)
-    const body = await res.json() as { name: string }
-    expect(body.name).toBe("myapp")
-  })
-
-  it("returns 422 without name", async () => {
-    const { app } = buildApp()
-    const res = await app.request("/api/projects", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({}) })
-    expect(res.status).toBe(422)
-  })
-})
-
-describe("GET /api/projects", () => {
-  it("lists projects", async () => {
-    const { app } = buildApp()
-    await app.request("/api/projects", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name: "p1" }) })
-    const res = await app.request("/api/projects")
-    const body = await res.json() as unknown[]
-    expect(body.length).toBeGreaterThanOrEqual(1)
-  })
-})
-
-describe("POST /api/projects/:id/pages", () => {
-  it("registers a page", async () => {
-    const { app } = buildApp()
-    const pRes = await app.request("/api/projects", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name: "app" }) })
-    const project = await pRes.json() as { id: string }
-    const res = await app.request(`/api/projects/${project.id}/pages`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ url: "https://app.com/home" }) })
-    expect(res.status).toBe(201)
-    const page = await res.json() as { url: string }
-    expect(page.url).toBe("https://app.com/home")
-  })
-
-  it("returns 422 without url", async () => {
-    const { app } = buildApp()
-    const pRes = await app.request("/api/projects", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name: "app2" }) })
-    const project = await pRes.json() as { id: string }
-    const res = await app.request(`/api/projects/${project.id}/pages`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({}) })
-    expect(res.status).toBe(422)
-  })
-})
-
-describe("jobs routes", () => {
-  it("creates and lists jobs", async () => {
-    const { app } = buildApp()
-    const pRes = await app.request("/api/projects", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name: "appj" }) })
-    const { id } = await pRes.json() as { id: string }
-    const jRes = await app.request("/api/jobs", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ project_id: id, schedule: "*/5 * * * *" }) })
-    expect(jRes.status).toBe(201)
-    const listRes = await app.request(`/api/jobs?project_id=${id}`)
-    const jobs = await listRes.json() as unknown[]
-    expect(jobs).toHaveLength(1)
-  })
-
-  it("returns 422 without required fields", async () => {
-    const { app } = buildApp()
-    const res = await app.request("/api/jobs", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({}) })
-    expect(res.status).toBe(422)
-  })
-
-  it("deletes a job", async () => {
-    const { app } = buildApp()
-    const pRes = await app.request("/api/projects", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name: "appd" }) })
-    const { id } = await pRes.json() as { id: string }
-    const jRes = await app.request("/api/jobs", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ project_id: id, schedule: "*/5 * * * *" }) })
-    const job = await jRes.json() as { id: string }
-    const del = await app.request(`/api/jobs/${job.id}`, { method: "DELETE" })
-    expect(del.status).toBe(200)
-  })
-})
-
-describe("perf routes", () => {
-  it("returns 422 without project_id", async () => {
-    const { app } = buildApp()
-    const res = await app.request("/api/perf")
-    expect(res.status).toBe(422)
-  })
-
-  it("returns null when no snapshot exists", async () => {
-    const { app } = buildApp()
-    const pRes = await app.request("/api/projects", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name: "perf-app" }) })
-    const { id } = await pRes.json() as { id: string }
-    const res = await app.request(`/api/perf?project_id=${id}`)
-    expect(res.status).toBe(200)
-    const body = await res.json()
-    expect(body).toBeNull()
-  })
-})

package/src/types/index.ts

@@ -1,119 +0,0 @@
-export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal"
-export type LogSource = "sdk" | "script" | "scanner"
-
-export interface LogEntry {
-  id?: string
-  timestamp?: string
-  project_id?: string
-  page_id?: string
-  level: LogLevel
-  source?: LogSource
-  service?: string
-  message: string
-  trace_id?: string
-  session_id?: string
-  agent?: string
-  url?: string
-  stack_trace?: string
-  metadata?: Record<string, unknown>
-}
-
-export interface LogRow {
-  id: string
-  timestamp: string
-  project_id: string | null
-  page_id: string | null
-  level: LogLevel
-  source: LogSource
-  service: string | null
-  message: string
-  trace_id: string | null
-  session_id: string | null
-  agent: string | null
-  url: string | null
-  stack_trace: string | null
-  metadata: string | null
-}
-
-export interface Project {
-  id: string
-  name: string
-  github_repo: string | null
-  base_url: string | null
-  description: string | null
-  github_description: string | null
-  github_branch: string | null
-  github_sha: string | null
-  last_synced_at: string | null
-  created_at: string
-}
-
-export interface Page {
-  id: string
-  project_id: string
-  url: string
-  path: string
-  name: string | null
-  last_scanned_at: string | null
-  created_at: string
-}
-
-export interface ScanJob {
-  id: string
-  project_id: string
-  page_id: string | null
-  schedule: string
-  enabled: number
-  last_run_at: string | null
-  created_at: string
-}
-
-export interface ScanRun {
-  id: string
-  job_id: string
-  page_id: string | null
-  started_at: string
-  finished_at: string | null
-  status: "running" | "completed" | "failed"
-  logs_collected: number
-  errors_found: number
-  perf_score: number | null
-}
-
-export interface PerformanceSnapshot {
-  id: string
-  timestamp: string
-  project_id: string
-  page_id: string | null
-  url: string
-  lcp: number | null
-  fcp: number | null
-  cls: number | null
-  tti: number | null
-  ttfb: number | null
-  score: number | null
-  raw_audit: string | null
-}
-
-export interface LogQuery {
-  project_id?: string
-  page_id?: string
-  level?: LogLevel | LogLevel[]
-  service?: string
-  since?: string
-  until?: string
-  text?: string
-  trace_id?: string
-  limit?: number
-  offset?: number
-  fields?: string[]
-}
-
-export interface LogSummary {
-  project_id: string | null
-  service: string | null
-  page_id: string | null
-  level: LogLevel
-  count: number
-  latest: string
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}