@hasna/logs 0.3.26 → 0.3.28

package/src/lib/page-auth.ts

@@ -1,48 +0,0 @@
-import type { Database } from "bun:sqlite"
-import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto"
-
-const SECRET_KEY = Buffer.from((process.env.LOGS_SECRET_KEY ?? "open-logs-default-key-32bytesXXX").padEnd(32).slice(0, 32))
-
-export interface PageAuth {
-  id: string
-  page_id: string
-  type: "cookie" | "bearer" | "basic"
-  credentials: string
-  created_at: string
-}
-
-function encrypt(text: string): string {
-  const iv = randomBytes(16)
-  const cipher = createCipheriv("aes-256-cbc", SECRET_KEY, iv)
-  const encrypted = Buffer.concat([cipher.update(text, "utf8"), cipher.final()])
-  return iv.toString("hex") + ":" + encrypted.toString("hex")
-}
-
-function decrypt(text: string): string {
-  const [ivHex, encHex] = text.split(":")
-  if (!ivHex || !encHex) return text
-  const iv = Buffer.from(ivHex, "hex")
-  const enc = Buffer.from(encHex, "hex")
-  const decipher = createDecipheriv("aes-256-cbc", SECRET_KEY, iv)
-  return Buffer.concat([decipher.update(enc), decipher.final()]).toString("utf8")
-}
-
-export function setPageAuth(db: Database, pageId: string, type: PageAuth["type"], credentials: string): PageAuth {
-  const encrypted = encrypt(credentials)
-  return db.prepare(`
-    INSERT INTO page_auth (page_id, type, credentials)
-    VALUES ($page_id, $type, $credentials)
-    ON CONFLICT(page_id) DO UPDATE SET type = excluded.type, credentials = excluded.credentials
-    RETURNING *
-  `).get({ $page_id: pageId, $type: type, $credentials: encrypted }) as PageAuth
-}
-
-export function getPageAuth(db: Database, pageId: string): { type: PageAuth["type"]; credentials: string } | null {
-  const row = db.prepare("SELECT * FROM page_auth WHERE page_id = $id").get({ $id: pageId }) as PageAuth | null
-  if (!row) return null
-  return { type: row.type, credentials: decrypt(row.credentials) }
-}
-
-export function deletePageAuth(db: Database, pageId: string): void {
-  db.run("DELETE FROM page_auth WHERE page_id = $id", { $id: pageId })
-}

package/src/lib/parse-time.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { parseTime } from "./parse-time.ts"
-
-describe("parseTime", () => {
-  it("returns undefined for undefined input", () => expect(parseTime(undefined)).toBeUndefined())
-  it("returns ISO string unchanged", () => {
-    const iso = "2026-01-01T00:00:00.000Z"
-    expect(parseTime(iso)).toBe(iso)
-  })
-  it("parses 30m", () => {
-    const result = parseTime("30m")!
-    const diff = Date.now() - new Date(result).getTime()
-    expect(diff).toBeGreaterThan(29 * 60 * 1000)
-    expect(diff).toBeLessThan(31 * 60 * 1000)
-  })
-  it("parses 1h", () => {
-    const result = parseTime("1h")!
-    const diff = Date.now() - new Date(result).getTime()
-    expect(diff).toBeGreaterThan(59 * 60 * 1000)
-    expect(diff).toBeLessThan(61 * 60 * 1000)
-  })
-  it("parses 7d", () => {
-    const result = parseTime("7d")!
-    const diff = Date.now() - new Date(result).getTime()
-    expect(diff).toBeGreaterThan(6.9 * 86400 * 1000)
-    expect(diff).toBeLessThan(7.1 * 86400 * 1000)
-  })
-  it("parses 1w", () => {
-    const result = parseTime("1w")!
-    const diff = Date.now() - new Date(result).getTime()
-    expect(diff).toBeGreaterThan(6.9 * 86400 * 1000)
-  })
-  it("returns unknown strings unchanged", () => {
-    expect(parseTime("yesterday")).toBe("yesterday")
-    expect(parseTime("now")).toBe("now")
-  })
-})

package/src/lib/parse-time.ts

@@ -1,14 +0,0 @@
-/**
- * Parses a relative time string or ISO timestamp into an ISO timestamp.
- * Accepts: "30m", "1h", "2h", "24h", "7d", "1w" or any ISO string.
- * Returns the input unchanged if it doesn't match a relative format.
- */
-export function parseTime(val: string | undefined): string | undefined {
-  if (!val) return undefined
-  const m = val.match(/^(\d+(?:\.\d+)?)(m|h|d|w)$/)
-  if (!m) return val
-  const n = parseFloat(m[1]!)
-  const unit = m[2]!
-  const ms = n * ({ m: 60, h: 3600, d: 86400, w: 604800 }[unit]!) * 1000
-  return new Date(Date.now() - ms).toISOString()
-}

package/src/lib/perf.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { getLatestSnapshot, getPerfTrend, saveSnapshot, scoreLabel } from "./perf.ts"
-
-function seedProject(db: ReturnType<typeof createTestDb>) {
-  return db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
-}
-
-describe("perf", () => {
-  it("saves and retrieves a snapshot", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const snap = saveSnapshot(db, { project_id: p.id, url: "https://app.com", lcp: 1200, fcp: 800, cls: 0.05, tti: 2000, ttfb: 100, score: 91, raw_audit: null, page_id: null })
-    expect(snap.id).toBeTruthy()
-    expect(snap.score).toBe(91)
-    const latest = getLatestSnapshot(db, p.id)
-    expect(latest?.id).toBe(snap.id)
-  })
-
-  it("returns null when no snapshot exists", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    expect(getLatestSnapshot(db, p.id)).toBeNull()
-  })
-
-  it("returns trend in desc order", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    saveSnapshot(db, { project_id: p.id, url: "https://app.com", lcp: 1000, fcp: 700, cls: 0.03, tti: 1800, ttfb: 90, score: 95, raw_audit: null, page_id: null })
-    saveSnapshot(db, { project_id: p.id, url: "https://app.com", lcp: 2000, fcp: 1200, cls: 0.1, tti: 3000, ttfb: 200, score: 70, raw_audit: null, page_id: null })
-    const trend = getPerfTrend(db, p.id)
-    expect(trend).toHaveLength(2)
-    expect(trend[0]!.timestamp >= trend[1]!.timestamp).toBe(true)
-  })
-})
-
-describe("scoreLabel", () => {
-  it("returns green for >= 90", () => expect(scoreLabel(90)).toBe("green"))
-  it("returns green for 100", () => expect(scoreLabel(100)).toBe("green"))
-  it("returns yellow for 50-89", () => expect(scoreLabel(75)).toBe("yellow"))
-  it("returns yellow for 50", () => expect(scoreLabel(50)).toBe("yellow"))
-  it("returns red for < 50", () => expect(scoreLabel(49)).toBe("red"))
-  it("returns red for 0", () => expect(scoreLabel(0)).toBe("red"))
-  it("returns unknown for null", () => expect(scoreLabel(null)).toBe("unknown"))
-})

package/src/lib/perf.ts

@@ -1,46 +0,0 @@
-import type { Database } from "bun:sqlite"
-import type { PerformanceSnapshot } from "../types/index.ts"
-
-export function saveSnapshot(db: Database, data: Omit<PerformanceSnapshot, "id" | "timestamp">): PerformanceSnapshot {
-  return db.prepare(`
-    INSERT INTO performance_snapshots (project_id, page_id, url, lcp, fcp, cls, tti, ttfb, score, raw_audit)
-    VALUES ($project_id, $page_id, $url, $lcp, $fcp, $cls, $tti, $ttfb, $score, $raw_audit)
-    RETURNING *
-  `).get({
-    $project_id: data.project_id,
-    $page_id: data.page_id ?? null,
-    $url: data.url,
-    $lcp: data.lcp ?? null,
-    $fcp: data.fcp ?? null,
-    $cls: data.cls ?? null,
-    $tti: data.tti ?? null,
-    $ttfb: data.ttfb ?? null,
-    $score: data.score ?? null,
-    $raw_audit: data.raw_audit ?? null,
-  }) as PerformanceSnapshot
-}
-
-export function getLatestSnapshot(db: Database, projectId: string, pageId?: string): PerformanceSnapshot | null {
-  if (pageId) {
-    return db.prepare("SELECT * FROM performance_snapshots WHERE project_id = $p AND page_id = $pg ORDER BY timestamp DESC LIMIT 1")
-      .get({ $p: projectId, $pg: pageId }) as PerformanceSnapshot | null
-  }
-  return db.prepare("SELECT * FROM performance_snapshots WHERE project_id = $p ORDER BY timestamp DESC LIMIT 1")
-    .get({ $p: projectId }) as PerformanceSnapshot | null
-}
-
-export function getPerfTrend(db: Database, projectId: string, pageId?: string, since?: string, limit = 50): PerformanceSnapshot[] {
-  const conditions = ["project_id = $p"]
-  const params: Record<string, unknown> = { $p: projectId, $limit: limit }
-  if (pageId) { conditions.push("page_id = $pg"); params.$pg = pageId }
-  if (since) { conditions.push("timestamp >= $since"); params.$since = since }
-  return db.prepare(`SELECT * FROM performance_snapshots WHERE ${conditions.join(" AND ")} ORDER BY timestamp DESC LIMIT $limit`)
-    .all(params) as PerformanceSnapshot[]
-}
-
-export function scoreLabel(score: number | null): "green" | "yellow" | "red" | "unknown" {
-  if (score === null) return "unknown"
-  if (score >= 90) return "green"
-  if (score >= 50) return "yellow"
-  return "red"
-}

package/src/lib/projects.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { createPage, createProject, getPage, getProject, listPages, listProjects, touchPage, updateProject } from "./projects.ts"
-
-describe("projects", () => {
-  it("creates a project", () => {
-    const db = createTestDb()
-    const p = createProject(db, { name: "my-app", github_repo: "https://github.com/foo/bar", base_url: "https://myapp.com" })
-    expect(p.id).toBeTruthy()
-    expect(p.name).toBe("my-app")
-    expect(p.github_repo).toBe("https://github.com/foo/bar")
-  })
-
-  it("lists projects", () => {
-    const db = createTestDb()
-    createProject(db, { name: "app1" })
-    createProject(db, { name: "app2" })
-    expect(listProjects(db)).toHaveLength(2)
-  })
-
-  it("gets a project by id", () => {
-    const db = createTestDb()
-    const p = createProject(db, { name: "test" })
-    expect(getProject(db, p.id)?.name).toBe("test")
-  })
-
-  it("returns null for unknown id", () => {
-    expect(getProject(createTestDb(), "nope")).toBeNull()
-  })
-
-  it("updates project fields", () => {
-    const db = createTestDb()
-    const p = createProject(db, { name: "x" })
-    const updated = updateProject(db, p.id, { github_sha: "abc123" })
-    expect(updated?.github_sha).toBe("abc123")
-  })
-})
-
-describe("pages", () => {
-  it("creates a page", () => {
-    const db = createTestDb()
-    const p = createProject(db, { name: "app" })
-    const page = createPage(db, { project_id: p.id, url: "https://app.com/dashboard", name: "Dashboard" })
-    expect(page.id).toBeTruthy()
-    expect(page.url).toBe("https://app.com/dashboard")
-    expect(page.name).toBe("Dashboard")
-  })
-
-  it("upserts on duplicate url", () => {
-    const db = createTestDb()
-    const p = createProject(db, { name: "app" })
-    createPage(db, { project_id: p.id, url: "https://app.com/", name: "Home" })
-    createPage(db, { project_id: p.id, url: "https://app.com/", name: "Home v2" })
-    expect(listPages(db, p.id)).toHaveLength(1)
-  })
-
-  it("lists pages for a project", () => {
-    const db = createTestDb()
-    const p = createProject(db, { name: "app" })
-    createPage(db, { project_id: p.id, url: "https://app.com/a" })
-    createPage(db, { project_id: p.id, url: "https://app.com/b" })
-    expect(listPages(db, p.id)).toHaveLength(2)
-  })
-
-  it("touches last_scanned_at", () => {
-    const db = createTestDb()
-    const p = createProject(db, { name: "app" })
-    const page = createPage(db, { project_id: p.id, url: "https://app.com/" })
-    expect(page.last_scanned_at).toBeNull()
-    touchPage(db, page.id)
-    expect(getPage(db, page.id)?.last_scanned_at).toBeTruthy()
-  })
-})

package/src/lib/projects.ts

@@ -1,69 +0,0 @@
-import type { Database } from "bun:sqlite"
-import type { Page, Project } from "../types/index.ts"
-
-// Projects
-export function createProject(db: Database, data: { name: string; github_repo?: string; base_url?: string; description?: string }): Project {
-  return db.prepare(`
-    INSERT INTO projects (name, github_repo, base_url, description)
-    VALUES ($name, $github_repo, $base_url, $description)
-    RETURNING *
-  `).get({
-    $name: data.name,
-    $github_repo: data.github_repo ?? null,
-    $base_url: data.base_url ?? null,
-    $description: data.description ?? null,
-  }) as Project
-}
-
-export function listProjects(db: Database): Project[] {
-  return db.prepare("SELECT * FROM projects ORDER BY created_at DESC").all() as Project[]
-}
-
-export function getProject(db: Database, id: string): Project | null {
-  return db.prepare("SELECT * FROM projects WHERE id = $id").get({ $id: id }) as Project | null
-}
-
-export function updateProject(db: Database, id: string, data: Partial<Pick<Project, "name" | "github_repo" | "base_url" | "description" | "github_description" | "github_branch" | "github_sha" | "last_synced_at">>): Project | null {
-  const fields = Object.keys(data).map(k => `${k} = $${k}`).join(", ")
-  if (!fields) return getProject(db, id)
-  const params = Object.fromEntries(Object.entries(data).map(([k, v]) => [`$${k}`, v]))
-  params.$id = id
-  return db.prepare(`UPDATE projects SET ${fields} WHERE id = $id RETURNING *`).get(params) as Project | null
-}
-
-// Pages
-export function createPage(db: Database, data: { project_id: string; url: string; path?: string; name?: string }): Page {
-  return db.prepare(`
-    INSERT INTO pages (project_id, url, path, name)
-    VALUES ($project_id, $url, $path, $name)
-    ON CONFLICT(project_id, url) DO UPDATE SET name = excluded.name
-    RETURNING *
-  `).get({
-    $project_id: data.project_id,
-    $url: data.url,
-    $path: data.path ?? new URL(data.url).pathname,
-    $name: data.name ?? null,
-  }) as Page
-}
-
-export function listPages(db: Database, projectId: string): Page[] {
-  return db.prepare("SELECT * FROM pages WHERE project_id = $p ORDER BY created_at ASC").all({ $p: projectId }) as Page[]
-}
-
-export function getPage(db: Database, id: string): Page | null {
-  return db.prepare("SELECT * FROM pages WHERE id = $id").get({ $id: id }) as Page | null
-}
-
-/** Resolves a project ID or name to a project ID. Returns null if not found or input is empty. */
-export function resolveProjectId(db: Database, idOrName: string | undefined | null): string | null {
-  if (!idOrName) return null
-  // Looks like a hex ID (8+ hex chars)
-  if (/^[0-9a-f]{8,}$/i.test(idOrName)) return idOrName
-  // Try name lookup (case-insensitive)
-  const p = db.prepare("SELECT id FROM projects WHERE LOWER(name) = LOWER($n)").get({ $n: idOrName }) as { id: string } | null
-  return p?.id ?? null
-}
-
-export function touchPage(db: Database, id: string): void {
-  db.run("UPDATE pages SET last_scanned_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') WHERE id = $id", { $id: id })
-}

package/src/lib/query.test.ts

@@ -1,104 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { ingestBatch } from "./ingest.ts"
-import { getLogContext, searchLogs, tailLogs } from "./query.ts"
-
-function seed(db: ReturnType<typeof createTestDb>) {
-  ingestBatch(db, [
-    { level: "error", message: "DB connection failed", service: "api", trace_id: "t1" },
-    { level: "warn", message: "Slow query detected", service: "api", trace_id: "t1" },
-    { level: "info", message: "User login", service: "auth" },
-    { level: "debug", message: "Cache miss", service: "cache" },
-    { level: "fatal", message: "Out of memory", service: "worker" },
-  ])
-}
-
-describe("searchLogs", () => {
-  it("returns all logs without filters", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = searchLogs(db, {})
-    expect(rows.length).toBe(5)
-  })
-
-  it("filters by level", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = searchLogs(db, { level: "error" })
-    expect(rows.every(r => r.level === "error")).toBe(true)
-  })
-
-  it("filters by multiple levels", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = searchLogs(db, { level: ["error", "fatal"] })
-    expect(rows).toHaveLength(2)
-  })
-
-  it("filters by service", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = searchLogs(db, { service: "api" })
-    expect(rows).toHaveLength(2)
-  })
-
-  it("full-text search on message", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = searchLogs(db, { text: "connection" })
-    expect(rows).toHaveLength(1)
-    expect(rows[0]!.message).toContain("connection")
-  })
-
-  it("filters by trace_id", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = searchLogs(db, { trace_id: "t1" })
-    expect(rows).toHaveLength(2)
-  })
-
-  it("respects limit", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = searchLogs(db, { limit: 2 })
-    expect(rows).toHaveLength(2)
-  })
-
-  it("returns results ordered by timestamp desc", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = searchLogs(db, {})
-    expect(rows[0]!.timestamp >= rows[rows.length - 1]!.timestamp).toBe(true)
-  })
-})
-
-describe("tailLogs", () => {
-  it("returns n most recent logs", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = tailLogs(db, undefined, 3)
-    expect(rows).toHaveLength(3)
-  })
-
-  it("filters by project_id", () => {
-    const db = createTestDb()
-    const rows = tailLogs(db, "nonexistent")
-    expect(rows).toHaveLength(0)
-  })
-})
-
-describe("getLogContext", () => {
-  it("returns all logs for a trace_id in asc order", () => {
-    const db = createTestDb()
-    seed(db)
-    const rows = getLogContext(db, "t1")
-    expect(rows).toHaveLength(2)
-    expect(rows[0]!.timestamp <= rows[1]!.timestamp).toBe(true)
-  })
-
-  it("returns empty for unknown trace_id", () => {
-    const db = createTestDb()
-    const rows = getLogContext(db, "unknown")
-    expect(rows).toHaveLength(0)
-  })
-})

package/src/lib/query.ts

@@ -1,84 +0,0 @@
-import type { Database } from "bun:sqlite"
-import type { LogQuery, LogRow } from "../types/index.ts"
-import { parseTime } from "./parse-time.ts"
-
-export function searchLogs(db: Database, q: LogQuery): LogRow[] {
-  const conditions: string[] = []
-  const params: Record<string, unknown> = {}
-
-  if (q.project_id) { conditions.push("l.project_id = $project_id"); params.$project_id = q.project_id }
-  if (q.page_id) { conditions.push("l.page_id = $page_id"); params.$page_id = q.page_id }
-  if (q.service) { conditions.push("l.service = $service"); params.$service = q.service }
-  if (q.trace_id) { conditions.push("l.trace_id = $trace_id"); params.$trace_id = q.trace_id }
-  if (q.since) { conditions.push("l.timestamp >= $since"); params.$since = parseTime(q.since) ?? q.since }
-  if (q.until) { conditions.push("l.timestamp <= $until"); params.$until = parseTime(q.until) ?? q.until }
-
-  if (q.level) {
-    const levels = Array.isArray(q.level) ? q.level : [q.level]
-    const placeholders = levels.map((_, i) => `$level${i}`).join(",")
-    levels.forEach((lv, i) => { params[`$level${i}`] = lv })
-    conditions.push(`l.level IN (${placeholders})`)
-  }
-
-  const limit = q.limit ?? 100
-  const offset = q.offset ?? 0
-  params.$limit = limit
-  params.$offset = offset
-
-  if (q.text) {
-    // FTS search via subquery
-    params.$text = q.text
-    const where = conditions.length ? `WHERE ${conditions.join(" AND ")} AND` : "WHERE"
-    const sql = `
-      SELECT l.* FROM logs l
-      ${where} l.rowid IN (SELECT rowid FROM logs_fts WHERE logs_fts MATCH $text)
-      ORDER BY l.timestamp DESC
-      LIMIT $limit OFFSET $offset
-    `
-    return db.prepare(sql).all(params) as LogRow[]
-  }
-
-  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
-  const sql = `SELECT * FROM logs l ${where} ORDER BY l.timestamp DESC LIMIT $limit OFFSET $offset`
-  return db.prepare(sql).all(params) as LogRow[]
-}
-
-export function tailLogs(db: Database, projectId?: string, n = 50): LogRow[] {
-  if (projectId) {
-    return db.prepare("SELECT * FROM logs WHERE project_id = $p ORDER BY timestamp DESC LIMIT $n")
-      .all({ $p: projectId, $n: n }) as LogRow[]
-  }
-  return db.prepare("SELECT * FROM logs ORDER BY timestamp DESC LIMIT $n").all({ $n: n }) as LogRow[]
-}
-
-export function getLogContext(db: Database, traceId: string): LogRow[] {
-  return db.prepare("SELECT * FROM logs WHERE trace_id = $t ORDER BY timestamp ASC")
-    .all({ $t: traceId }) as LogRow[]
-}
-
-export function getLogContextFromId(db: Database, logId: string, window = 0): LogRow[] {
-  const log = db.prepare("SELECT * FROM logs WHERE id = $id").get({ $id: logId }) as LogRow | null
-  if (!log) return []
-
-  // Get trace context (or just the log itself if no trace)
-  const trace: LogRow[] = log.trace_id ? getLogContext(db, log.trace_id) : [log]
-
-  if (window <= 0) return trace
-
-  // Fetch N rows before and after the target log's timestamp
-  const before = db.prepare(
-    `SELECT * FROM logs WHERE id != $id AND timestamp <= $ts ORDER BY timestamp DESC LIMIT $n`
-  ).all({ $id: logId, $ts: log.timestamp, $n: window }) as LogRow[]
-
-  const after = db.prepare(
-    `SELECT * FROM logs WHERE id != $id AND timestamp > $ts ORDER BY timestamp ASC LIMIT $n`
-  ).all({ $id: logId, $ts: log.timestamp, $n: window }) as LogRow[]
-
-  // Merge: before (oldest first) + trace + after, deduplicate by id
-  const seen = new Set<string>()
-  const merged: LogRow[] = []
-  for (const row of [...before.reverse(), ...trace, ...after]) {
-    if (!seen.has(row.id)) { seen.add(row.id); merged.push(row) }
-  }
-  return merged.sort((a, b) => a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0)
-}

package/src/lib/retention.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { ingestBatch } from "./ingest.ts"
-import { runRetentionForProject, setRetentionPolicy } from "./retention.ts"
-
-function seedProject(db: ReturnType<typeof createTestDb>, name = "app") {
-  return db.prepare("INSERT INTO projects (name) VALUES (?) RETURNING id").get(name) as { id: string }
-}
-
-describe("retention", () => {
-  it("does nothing when under max_rows", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    ingestBatch(db, Array.from({ length: 5 }, () => ({ level: "info" as const, message: "x", project_id: p.id })))
-    const result = runRetentionForProject(db, p.id)
-    expect(result.deleted).toBe(0)
-  })
-
-  it("enforces max_rows", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    setRetentionPolicy(db, p.id, { max_rows: 3 })
-    ingestBatch(db, Array.from({ length: 10 }, () => ({ level: "info" as const, message: "x", project_id: p.id })))
-    runRetentionForProject(db, p.id)
-    const count = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = ?").get(p.id) as { c: number }).c
-    expect(count).toBeLessThanOrEqual(3)
-  })
-
-  it("returns 0 for unknown project", () => {
-    const db = createTestDb()
-    expect(runRetentionForProject(db, "nope").deleted).toBe(0)
-  })
-
-  it("setRetentionPolicy updates project config", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    setRetentionPolicy(db, p.id, { max_rows: 500, debug_ttl_hours: 1 })
-    const proj = db.prepare("SELECT max_rows, debug_ttl_hours FROM projects WHERE id = ?").get(p.id) as { max_rows: number; debug_ttl_hours: number }
-    expect(proj.max_rows).toBe(500)
-    expect(proj.debug_ttl_hours).toBe(1)
-  })
-})

package/src/lib/retention.ts

@@ -1,62 +0,0 @@
-import type { Database } from "bun:sqlite"
-
-interface RetentionConfig {
-  max_rows: number
-  debug_ttl_hours: number
-  info_ttl_hours: number
-  warn_ttl_hours: number
-  error_ttl_hours: number
-}
-
-const TTL_BY_LEVEL: Record<string, keyof RetentionConfig> = {
-  debug: "debug_ttl_hours",
-  info: "info_ttl_hours",
-  warn: "warn_ttl_hours",
-  error: "error_ttl_hours",
-  fatal: "error_ttl_hours",
-}
-
-export function runRetentionForProject(db: Database, projectId: string): { deleted: number } {
-  const project = db.prepare("SELECT * FROM projects WHERE id = $id").get({ $id: projectId }) as (RetentionConfig & { id: string }) | null
-  if (!project) return { deleted: 0 }
-
-  let deleted = 0
-
-  // TTL enforcement per level
-  for (const [level, configKey] of Object.entries(TTL_BY_LEVEL)) {
-    const ttlHours = project[configKey] as number
-    const cutoff = new Date(Date.now() - ttlHours * 3600 * 1000).toISOString()
-    const before = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = $p AND level = $level AND timestamp < $cutoff").get({ $p: projectId, $level: level, $cutoff: cutoff }) as { c: number }).c
-    if (before > 0) {
-      db.prepare("DELETE FROM logs WHERE project_id = $p AND level = $level AND timestamp < $cutoff").run({ $p: projectId, $level: level, $cutoff: cutoff })
-      deleted += before
-    }
-  }
-
-  // max_rows enforcement
-  const total = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = $p").get({ $p: projectId }) as { c: number }).c
-  if (total > project.max_rows) {
-    const toDelete = total - project.max_rows
-    db.prepare(`DELETE FROM logs WHERE id IN (SELECT id FROM logs WHERE project_id = $p ORDER BY timestamp ASC LIMIT ${toDelete})`).run({ $p: projectId })
-    deleted += toDelete
-  }
-
-  return { deleted }
-}
-
-export function runRetentionAll(db: Database): { deleted: number; projects: number } {
-  const projects = db.prepare("SELECT id FROM projects").all() as { id: string }[]
-  let deleted = 0
-  for (const p of projects) {
-    deleted += runRetentionForProject(db, p.id).deleted
-  }
-  return { deleted, projects: projects.length }
-}
-
-export function setRetentionPolicy(db: Database, projectId: string, config: Partial<RetentionConfig>): void {
-  const fields = Object.keys(config).map(k => `${k} = $${k}`).join(", ")
-  if (!fields) return
-  const params = Object.fromEntries(Object.entries(config).map(([k, v]) => [`$${k}`, v]))
-  params.$id = projectId
-  db.prepare(`UPDATE projects SET ${fields} WHERE id = $id`).run(params)
-}

package/src/lib/rotate.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { ingestBatch } from "./ingest.ts"
-import { rotateLogs, rotateByProject } from "./rotate.ts"
-
-describe("rotateLogs", () => {
-  it("does nothing when under maxRows", () => {
-    const db = createTestDb()
-    ingestBatch(db, [{ level: "info", message: "a" }, { level: "info", message: "b" }])
-    const deleted = rotateLogs(db, 100)
-    expect(deleted).toBe(0)
-  })
-
-  it("deletes oldest when over maxRows", () => {
-    const db = createTestDb()
-    ingestBatch(db, Array.from({ length: 10 }, (_, i) => ({ level: "info" as const, message: `msg ${i}` })))
-    const deleted = rotateLogs(db, 5)
-    expect(deleted).toBe(5)
-    const remaining = (db.prepare("SELECT COUNT(*) as c FROM logs").get() as { c: number }).c
-    expect(remaining).toBe(5)
-  })
-})
-
-describe("rotateByProject", () => {
-  it("only rotates logs for the specified project", () => {
-    const db = createTestDb()
-    const p1 = db.prepare("INSERT INTO projects (name) VALUES ('p1') RETURNING id").get() as { id: string }
-    const p2 = db.prepare("INSERT INTO projects (name) VALUES ('p2') RETURNING id").get() as { id: string }
-    ingestBatch(db, Array.from({ length: 8 }, () => ({ level: "info" as const, message: "x", project_id: p1.id })))
-    ingestBatch(db, Array.from({ length: 5 }, () => ({ level: "info" as const, message: "y", project_id: p2.id })))
-    rotateByProject(db, p1.id, 3)
-    const p1count = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = ?").get(p1.id) as { c: number }).c
-    const p2count = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = ?").get(p2.id) as { c: number }).c
-    expect(p1count).toBe(3)
-    expect(p2count).toBe(5) // untouched
-  })
-})