ework-web 0.2.1 → 0.3.0

package/src/views/home.ts

@@ -3,7 +3,7 @@ import { listProjectsWithCounts, createProject, canAdminProject, StoreError, typ
 import { relTime } from "../render/components";
 import { getDefaultUpstreamUrl, webUrlFromClone } from "./projectUpstreams";
 
-function projectCard(p: ProjectWithCounts, viewer: UserRow | null): string {
+async function projectCard(p: ProjectWithCounts, viewer: UserRow | null): Promise<string> {
   const issuesHref = `/${encodeURIComponent(p.owner)}/${encodeURIComponent(p.name)}/issues`;
   const settingsHref = `/${encodeURIComponent(p.owner)}/${encodeURIComponent(p.name)}/settings/upstreams`;
   const desc = p.description ? `<div class="pcard-desc">${escapeHtml(p.description)}</div>` : "";
@@ -12,7 +12,7 @@ function projectCard(p: ProjectWithCounts, viewer: UserRow | null): string {
   const upstreamIcon = upstreamWebUrl
     ? `<a class="pcard-icon" href="${escapeAttr(upstreamWebUrl)}" target="_blank" rel="noopener noreferrer" title="查看上游：${escapeAttr(upstreamWebUrl)}" aria-label="查看上游">🔗</a>`
     : "";
-  const adminIcon = canAdminProject(p.id, viewer)
+  const adminIcon = await canAdminProject(p.id, viewer)
     ? `<a class="pcard-icon" href="${escapeAttr(settingsHref)}" title="项目设置（上游 / Webhooks / 成员）" aria-label="项目设置">⚙️</a>`
     : "";
   const iconsHtml = (upstreamIcon || adminIcon)
@@ -29,13 +29,14 @@ function projectCard(p: ProjectWithCounts, viewer: UserRow | null): string {
   </div>`;
 }
 
-export function buildHome(
+export async function buildHome(
   viewer: UserRow | null,
   flash: { kind: "ok" | "err"; msg: string } | null = null
-): string {
-  const projects = listProjectsWithCounts();
+): Promise<string> {
+  const projects = await listProjectsWithCounts();
+  const cards = await Promise.all(projects.map((p) => projectCard(p, viewer)));
   const list = projects.length
-    ? projects.map((p) => projectCard(p, viewer)).join("")
+    ? cards.join("")
     : `<div class="empty">还没有项目。在下面创建一个：</div>`;
   const flashHtml = flash
     ? `<div class="flash ${flash.kind === "ok" ? "ok" : "err"}">${escapeHtml(flash.msg)}</div>`
@@ -90,15 +91,15 @@ ${tabNavHTML("projects")}
 </body></html>`;
 }
 
-export function handleCreateProject(
+export async function handleCreateProject(
   form: Record<string, string | undefined>
-): { location: string; error?: string; projectId?: number } {
+): Promise<{ location: string; error?: string; projectId?: number }> {
   const owner = (form.owner ?? "").trim();
   const name = (form.name ?? "").trim();
   const description = (form.description ?? "").trim();
   if (!owner || !name) return { location: "/projects", error: "owner 和 name 必填" };
   try {
-    const p = createProject(owner, name, description);
+    const p = await createProject(owner, name, description);
     return { location: `/${encodeURIComponent(p.owner)}/${encodeURIComponent(p.name)}/issues`, projectId: p.id };
   } catch (e) {
     return {

package/src/views/issueList.ts

@@ -13,18 +13,18 @@ function issueRow(it: IssueWithMeta, owner: string, repo: string, q: string): st
   </a>`;
 }
 
-export function buildIssueList(
+export async function buildIssueList(
   owner: string,
   repo: string,
   state: "open" | "closed" | "all",
   writesEnabled: boolean,
   q: string
-): string {
-  const project = getProject(owner, repo);
+): Promise<string> {
+  const project = await getProject(owner, repo);
   if (!project) {
     return notFoundProject(owner, repo);
   }
-  const issues = listIssues(project.id, { state, q, limit: LIST_PAGE_SIZE });
+  const issues = await listIssues(project.id, { state, q, limit: LIST_PAGE_SIZE });
   const matchesFirst = q
     ? [...issues].sort((a, b) => Number(containsCI(b.title, q)) - Number(containsCI(a.title, q)))
     : issues;

package/src/views/issueThread.ts

@@ -44,9 +44,9 @@ function toView(c: CommentRow): CommentView {
   };
 }
 
-export function viewsFromComments(rows: CommentRow[]): CommentView[] {
+export async function viewsFromComments(rows: CommentRow[]): Promise<CommentView[]> {
   const views = rows.map((r) => toView(r));
-  hydrateReactions(views);
+  await hydrateReactions(views);
   return views;
 }
 
@@ -82,23 +82,23 @@ function orderForDisplay(views: CommentView[], sort: "desc" | "asc"): CommentVie
   return sort === "asc" ? views : views.slice().reverse();
 }
 
-export function buildIssueThread(
+export async function buildIssueThread(
   cfg: Config,
   owner: string,
   repo: string,
   number: number,
   viewerLogin?: string
-): { html: string } {
-  const project = getProject(owner, repo);
+): Promise<{ html: string }> {
+  const project = await getProject(owner, repo);
   if (!project) throw new StoreError(404, `项目 ${owner}/${repo} 不存在`);
-  const issue = getIssueWithMeta(project.id, number);
+  const issue = await getIssueWithMeta(project.id, number);
   if (!issue) throw new StoreError(404, `#${number} 在 ${owner}/${repo} 不存在`);
 
-  const total = countComments(issue.id);
+  const total = await countComments(issue.id);
   const totalPages = Math.max(1, Math.ceil(total / PAGE_SIZE));
   const currentPage = totalPages;
-  const { rows } = listCommentsPage(issue.id, currentPage, PAGE_SIZE);
-  const views = viewsFromComments(rows);
+  const { rows } = await listCommentsPage(issue.id, currentPage, PAGE_SIZE);
+  const views = await viewsFromComments(rows);
   const hasOlder = currentPage > 1;
   const displayViews = orderForDisplay(views, cfg.commentSort);
   const payload = payloadFromComments(issue, displayViews, currentPage, hasOlder, cfg.commentSort);
@@ -140,33 +140,33 @@ export interface IssuePageData {
   hasOlder: boolean;
 }
 
-export function fetchIssuePage(
+export async function fetchIssuePage(
   owner: string,
   repo: string,
   number: number,
   page: number
-): IssuePageData {
-  const project = getProject(owner, repo);
+): Promise<IssuePageData> {
+  const project = await getProject(owner, repo);
   if (!project) throw new StoreError(404, `项目 ${owner}/${repo} 不存在`);
-  const issue = getIssueWithMeta(project.id, number);
+  const issue = await getIssueWithMeta(project.id, number);
   if (!issue) throw new StoreError(404, `#${number} 不存在`);
-  const { rows, page: clamped } = listCommentsPage(issue.id, page, PAGE_SIZE);
-  const views = viewsFromComments(rows);
+  const { rows, page: clamped } = await listCommentsPage(issue.id, page, PAGE_SIZE);
+  const views = await viewsFromComments(rows);
   return { issue, views, currentPage: clamped, hasOlder: clamped > 1 };
 }
 
-export function fetchIssueSince(
+export async function fetchIssueSince(
   owner: string,
   repo: string,
   number: number,
   sinceISO: string
-): CommentView[] {
-  const project = getProject(owner, repo);
+): Promise<CommentView[]> {
+  const project = await getProject(owner, repo);
   if (!project) throw new StoreError(404, `项目 ${owner}/${repo} 不存在`);
-  const issue = getIssueWithMeta(project.id, number);
+  const issue = await getIssueWithMeta(project.id, number);
   if (!issue) throw new StoreError(404, `#${number} 不存在`);
-  const rows = listCommentsSince(issue.id, sinceISO);
-  return viewsFromComments(rows);
+  const rows = await listCommentsSince(issue.id, sinceISO);
+  return await viewsFromComments(rows);
 }
 
 export function safeJsonEmbed(v: unknown): string {

package/src/views/issues.ts

@@ -14,11 +14,11 @@ function issueRow(it: IssueWithMeta, q: string): string {
   </a>`;
 }
 
-export function buildIssuesFeed(
+export async function buildIssuesFeed(
   state: "open" | "closed" | "all",
   q: string
-): string {
-  const issues = listAllIssues({ state, q, limit: FEED_PAGE_SIZE });
+): Promise<string> {
+  const issues = await listAllIssues({ state, q, limit: FEED_PAGE_SIZE });
   const matchesFirst = q
     ? [...issues].sort((a, b) => Number(containsCI(b.title, q)) - Number(containsCI(a.title, q)))
     : issues;

package/src/views/projectMembers.ts

@@ -22,25 +22,24 @@ function roleBadge(role: ProjectRole): string {
   return `<span class="badge role-${cls}">${escapeHtml(role)}</span>`;
 }
 
-export function buildProjectMembersPage(
+export async function buildProjectMembersPage(
   viewer: UserRow,
   project: ProjectRow,
   flash: Flash | null,
-): string {
-  const members = listProjectMembersWithUsers(project.id);
-  const users = listUsers();
+): Promise<string> {
+  const members = await listProjectMembersWithUsers(project.id);
+  const users = await listUsers();
   const memberLogins = new Set(members.map((m) => m.user_login));
   const candidates = users.filter((u) => u.is_active === 1 && !memberLogins.has(u.login));
 
   const flashHtml = flash ? `<div class="flash ${flash.kind}">${escapeHtml(flash.msg)}</div>` : "";
 
+  const memberRows = await Promise.all(members.map((m) => memberRowHtml(m, viewer, project)));
   const rowsHtml = members.length
     ? `<table>
 <thead><tr><th>用户</th><th>角色</th><th>加入时间</th><th>操作</th></tr></thead>
 <tbody>
-${members
-  .map((m) => memberRowHtml(m, viewer, project))
-  .join("")}
+${memberRows.join("")}
 </tbody>
 </table>`
     : `<div class="hint">该项目还没有成员记录（site-admin 已自动获得 admin 权限，可在下方添加）。</div>`;
@@ -117,9 +116,9 @@ ${addFormHtml}
 </main></body></html>`;
 }
 
-function memberRowHtml(m: ProjectMemberWithUser, viewer: UserRow, project: ProjectRow): string {
+async function memberRowHtml(m: ProjectMemberWithUser, viewer: UserRow, project: ProjectRow): Promise<string> {
   const isSelf = m.user_login === viewer.login;
-  const isAdminCountOne = m.role === "admin" && countProjectAdmins(project.id) <= 1;
+  const isAdminCountOne = m.role === "admin" && (await countProjectAdmins(project.id)) <= 1;
   const kindBadge = m.user_kind === "bot" ? `<span class="badge bot">bot</span>` : m.user_kind === "system" ? `<span class="badge">system</span>` : "";
   const inactiveBadge = m.user_is_active === 1 ? "" : `<span class="badge inactive">禁用</span>`;
   const selfNote = isSelf ? `<span class="meta">(你)</span>` : "";

package/src/views/projectUpstreams.ts

@@ -129,13 +129,13 @@ export function parseUpstreamUrlsForm(text: string): string[] {
     .filter((line) => line.length > 0);
 }
 
-export function trySetUpstreamUrls(
+export async function trySetUpstreamUrls(
   projectId: number,
   raw: string,
-): { ok: true; urls: string[] } | { ok: false; msg: string } {
+): Promise<{ ok: true; urls: string[] } | { ok: false; msg: string }> {
   try {
     const urls = parseUpstreamUrlsForm(raw);
-    const cleaned = setProjectUpstreamUrls(projectId, urls);
+    const cleaned = await setProjectUpstreamUrls(projectId, urls);
     return { ok: true, urls: cleaned };
   } catch (e) {
     const msg = e instanceof StoreError ? e.message : e instanceof Error ? e.message : "保存失败";

package/src/webhooks.ts

@@ -16,7 +16,7 @@
 //   the full retry trail rather than an opaque final status.
 
 import { createHmac, randomUUID } from "node:crypto";
-import { rawDB } from "./db";
+import { getDB } from "./db";
 import { log } from "./logger";
 import { loadConfig } from "./config";
 import {
@@ -121,16 +121,12 @@ function parseEvents(events: unknown): WebhookEventName[] {
 
 // ─── CRUD ────────────────────────────────────────────────────
 
-export function listWebhooks(projectId: number): WebhookRow[] {
-  return rawDB()
-    .query("SELECT * FROM webhooks WHERE project_id = ? ORDER BY id")
-    .all(projectId) as WebhookRow[];
+export async function listWebhooks(projectId: number): Promise<WebhookRow[]> {
+  return await getDB().all<WebhookRow>("SELECT * FROM {{webhooks}} WHERE project_id = ? ORDER BY id", [projectId]);
 }
 
-export function getWebhook(id: number): WebhookRow | null {
-  const row = rawDB().query("SELECT * FROM webhooks WHERE id = ?").get(id) as
-    | WebhookRow
-    | undefined;
+export async function getWebhook(id: number): Promise<WebhookRow | null> {
+  const row = await getDB().get<WebhookRow>("SELECT * FROM {{webhooks}} WHERE id = ?", [id]);
   return row ?? null;
 }
 
@@ -142,7 +138,7 @@ export interface CreateWebhookInput {
   active?: boolean;
 }
 
-export function createWebhook(input: CreateWebhookInput): WebhookRow {
+export async function createWebhook(input: CreateWebhookInput): Promise<WebhookRow> {
   const url = input.url.trim();
   if (!url) throw new StoreError(400, "URL 不能为空");
   if (!/^https?:\/\//i.test(url)) throw new StoreError(400, "URL 必须是 http(s)://");
@@ -150,13 +146,10 @@ export function createWebhook(input: CreateWebhookInput): WebhookRow {
   const secret = (input.secret ?? "").slice(0, 256);
   const events = input.events && input.events.length > 0 ? input.events : DEFAULT_EVENTS;
   const ts = now();
-  const db = rawDB();
-  const info = db
-    .query(
-      `INSERT INTO webhooks (project_id, url, secret, content_type, events, active, created_at, updated_at)
-       VALUES (?, ?, ?, 'application/json', ?, ?, ?, ?)`
-    )
-    .run(
+  const info = await getDB().run(
+    `INSERT INTO {{webhooks}} (project_id, url, secret, content_type, events, active, created_at, updated_at)
+     VALUES (?, ?, ?, 'application/json', ?, ?, ?, ?)`,
+    [
       input.project_id,
       url,
       secret,
@@ -164,26 +157,24 @@ export function createWebhook(input: CreateWebhookInput): WebhookRow {
       input.active === false ? 0 : 1,
       ts,
       ts
-    );
-  return getWebhook(Number(info.lastInsertRowid))!;
+    ]
+  );
+  return (await getWebhook(info.insertId))!;
 }
 
-export function deleteWebhook(id: number): void {
-  rawDB().query("DELETE FROM webhooks WHERE id = ?").run(id);
+export async function deleteWebhook(id: number): Promise<void> {
+  await getDB().run("DELETE FROM {{webhooks}} WHERE id = ?", [id]);
 }
 
-export function setWebhookActive(id: number, active: boolean): void {
-  rawDB()
-    .query("UPDATE webhooks SET active = ?, updated_at = ? WHERE id = ?")
-    .run(active ? 1 : 0, now(), id);
+export async function setWebhookActive(id: number, active: boolean): Promise<void> {
+  await getDB().run("UPDATE {{webhooks}} SET active = ?, updated_at = ? WHERE id = ?", [active ? 1 : 0, now(), id]);
 }
 
-export function listDeliveries(webhookId: number, limit = 50): WebhookDeliveryRow[] {
-  return rawDB()
-    .query(
-      "SELECT * FROM webhook_deliveries WHERE webhook_id = ? ORDER BY id DESC LIMIT ?"
-    )
-    .all(webhookId, limit) as WebhookDeliveryRow[];
+export async function listDeliveries(webhookId: number, limit = 50): Promise<WebhookDeliveryRow[]> {
+  return await getDB().all<WebhookDeliveryRow>(
+    "SELECT * FROM {{webhook_deliveries}} WHERE webhook_id = ? ORDER BY id DESC LIMIT ?",
+    [webhookId, limit]
+  );
 }
 
 // ─── Payload builders (Gitea-compatible shape) ───────────────
@@ -504,21 +495,19 @@ async function postWithTimeout(
   }
 }
 
-function recordDelivery(
+async function recordDelivery(
   webhookId: number,
   event: WebhookEventName,
   deliveryUuid: string,
   rawBody: string,
   result: DeliveryAttemptResult
-): void {
+): Promise<void> {
   try {
-    rawDB()
-      .query(
-        `INSERT INTO webhook_deliveries
-          (webhook_id, event, delivery_uuid, payload, response_status, response_body, duration_ms, error, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-      )
-      .run(
+    await getDB().run(
+      `INSERT INTO {{webhook_deliveries}}
+        (webhook_id, event, delivery_uuid, payload, response_status, response_body, duration_ms, error, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
         webhookId,
         event,
         deliveryUuid,
@@ -528,7 +517,8 @@ function recordDelivery(
         result.durationMs,
         result.error,
         now()
-      );
+      ]
+    );
   } catch (e) {
     log.error("webhook: failed to record delivery", { err: e as Error });
   }
@@ -547,7 +537,7 @@ async function deliver(
       const headers = buildHeaders(event, deliveryUuid, rawBody, webhook.secret);
       const result = await postWithTimeout(webhook.url, rawBody, headers);
       const success = result.status !== null && result.status >= 200 && result.status < 300;
-      recordDelivery(webhook.id, event, deliveryUuid, rawBody, result);
+      await recordDelivery(webhook.id, event, deliveryUuid, rawBody, result);
       if (success) return;
       // 410 Gone: receiver explicitly says "stop sending" — honor it, no retry.
       if (result.status === 410) return;
@@ -563,14 +553,15 @@ async function deliver(
   }
 }
 
-function fanOut(
+async function fanOut(
   projectId: number,
   event: WebhookEventName,
   rawBody: string
-): void {
-  const webhooks = rawDB()
-    .query("SELECT * FROM webhooks WHERE project_id = ? AND active = 1")
-    .all(projectId) as WebhookRow[];
+): Promise<void> {
+  const webhooks = await getDB().all<WebhookRow>(
+    "SELECT * FROM {{webhooks}} WHERE project_id = ? AND active = 1",
+    [projectId]
+  );
   for (const wh of webhooks) {
     if (!parseEvents(wh.events).includes(event)) continue;
     void deliver(wh, event, rawBody);
@@ -579,26 +570,26 @@ function fanOut(
 
 // ─── Public emit API ─────────────────────────────────────────
 
-export function emitIssueEvent(
+export async function emitIssueEvent(
   projectId: number,
   issueId: number,
   action: IssueAction,
   origin: string
-): void {
+): Promise<void> {
   try {
-    const project = getProjectById(projectId);
+    const project = await getProjectById(projectId);
     if (!project) return;
-    const issue = getIssueById(issueId);
+    const issue = await getIssueById(issueId);
     if (!issue) return;
-    const commentCount = countCommentsSafe(issueId);
+    const commentCount = await countCommentsSafe(issueId);
     // Resolve model: project override > global default. Empty string = no
     // override (daemon omits --model, lets opencode pick). globalDefault
     // comes from the config table via loadConfig() — cheap DB read.
-    const globalDefault = loadConfig().defaultModel;
+    const globalDefault = (await loadConfig()).defaultModel;
     const model = resolveModel(project.model, globalDefault);
     const payload = buildIssuePayload(issue, project, commentCount, action, origin, model);
     const rawBody = JSON.stringify(payload);
-    fanOut(projectId, "issues", rawBody);
+    await fanOut(projectId, "issues", rawBody);
   } catch (e) {
     log.error("webhook: emitIssueEvent failed", {
       err: e as Error,
@@ -609,25 +600,25 @@ export function emitIssueEvent(
   }
 }
 
-export function emitCommentEvent(
+export async function emitCommentEvent(
   projectId: number,
   issueId: number,
   commentId: number,
   origin: string
-): void {
+): Promise<void> {
   try {
-    const project = getProjectById(projectId);
+    const project = await getProjectById(projectId);
     if (!project) return;
-    const issue = getIssueById(issueId);
+    const issue = await getIssueById(issueId);
     if (!issue) return;
-    const comment = getCommentByIdSafe(commentId);
+    const comment = await getCommentByIdSafe(commentId);
     if (!comment) return;
-    const commentCount = countCommentsSafe(issueId);
-    const globalDefault = loadConfig().defaultModel;
+    const commentCount = await countCommentsSafe(issueId);
+    const globalDefault = (await loadConfig()).defaultModel;
     const model = resolveModel(project.model, globalDefault);
     const payload = buildCommentPayload(issue, comment, project, commentCount, origin, model);
     const rawBody = JSON.stringify(payload);
-    fanOut(projectId, "issue_comment", rawBody);
+    await fanOut(projectId, "issue_comment", rawBody);
   } catch (e) {
     log.error("webhook: emitCommentEvent failed", {
       err: e as Error,
@@ -638,11 +629,11 @@ export function emitCommentEvent(
   }
 }
 
-export function emitPingEvent(projectId: number, origin: string): void {
+export async function emitPingEvent(projectId: number, origin: string): Promise<void> {
   // Synthetic ping: send a small `ping` event (no issue context). Useful for
   // verifying webhook configuration without triggering a real write.
   try {
-    const project = getProjectById(projectId);
+    const project = await getProjectById(projectId);
     if (!project) return;
     const payload = {
       zen: "smoke",
@@ -652,7 +643,7 @@ export function emitPingEvent(projectId: number, origin: string): void {
       sender: buildUser(project.owner, origin),
     };
     const rawBody = JSON.stringify(payload);
-    fanOut(projectId, "issues", rawBody);
+    await fanOut(projectId, "issues", rawBody);
   } catch (e) {
     log.error("webhook: emitPingEvent failed", { err: e as Error, projectId });
   }
@@ -660,22 +651,21 @@ export function emitPingEvent(projectId: number, origin: string): void {
 
 // ─── Helpers (kept here to avoid widening store.ts surface) ──
 
-function countCommentsSafe(issueId: number): number {
+async function countCommentsSafe(issueId: number): Promise<number> {
   try {
-    const row = rawDB()
-      .query("SELECT COUNT(*) AS n FROM comments WHERE issue_id = ?")
-      .get(issueId) as { n: number } | undefined;
+    const row = await getDB().get<{ n: number }>(
+      "SELECT COUNT(*) AS n FROM {{comments}} WHERE issue_id = ?",
+      [issueId]
+    );
     return row?.n ?? 0;
   } catch {
     return 0;
   }
 }
 
-function getCommentByIdSafe(id: number): CommentRow | null {
+async function getCommentByIdSafe(id: number): Promise<CommentRow | null> {
   try {
-    const row = rawDB().query("SELECT * FROM comments WHERE id = ?").get(id) as
-      | CommentRow
-      | undefined;
+    const row = await getDB().get<CommentRow>("SELECT * FROM {{comments}} WHERE id = ?", [id]);
     return row ?? null;
   } catch {
     return null;