ework-web 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-web",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "type": "module",
   "description": "ework-web — standalone multi-project issue tracker. Local SQLite-backed, no external API dependency. Bun + TypeScript + SSR HTML.",
   "license": "MIT",
@@ -42,7 +42,8 @@
     "start": "bun src/index.ts",
     "check": "tsc --noEmit",
     "typecheck": "tsc --noEmit",
-    "test": "bun test"
+    "test": "bun test",
+    "test:mysql": "bash scripts/test-mysql.sh"
   },
   "dependencies": {
     "@types/dompurify": "^3.2.0",
@@ -51,6 +52,7 @@
     "jsdom": "^29.1.1",
     "marked": "^15.0.0",
     "marked-highlight": "^2.2.0",
+    "mysql2": "^3.23.1",
     "zod": "^3.23.8"
   },
   "devDependencies": {

package/src/auth.ts

@@ -94,7 +94,7 @@ export async function checkAuth(req: Request, cfg: Config, ip?: string | null):
       const payload = `${COOKIE_VERSION}.${parsed.login}.${parsed.issued}`;
       const expected = await hmac(cfg.cookieSecret, payload);
       if (!ctEqual(parsed.sig, expected)) return { ok: false, user: null };
-      const user = getUserByLogin(parsed.login);
+      const user = await getUserByLogin(parsed.login);
       if (!user || !user.is_active) return { ok: false, user: null };
       return { ok: true, user };
     }
@@ -110,7 +110,7 @@ export async function checkAuth(req: Request, cfg: Config, ip?: string | null):
     if (!ctEqual(sig, expected) || !ctEqual(token, cfg.authToken)) {
       return { ok: false, user: null };
     }
-    const user = getUserByLogin(cfg.operatorLogin);
+    const user = await getUserByLogin(cfg.operatorLogin);
     if (!user || !user.is_active) return { ok: false, user: null };
     return { ok: true, user };
   }
@@ -138,19 +138,19 @@ export async function checkAuth(req: Request, cfg: Config, ip?: string | null):
   return { ok: false, user: null };
 }
 
-export function ensureBootstrapAdmin(login: string): UserRow {
-  const existing = getUserByLogin(login);
+export async function ensureBootstrapAdmin(login: string): Promise<UserRow> {
+  const existing = await getUserByLogin(login);
   if (existing) return existing;
-  return ensureUser(login, "human");
+  return await ensureUser(login, "human");
 }
 
 // Reserved system user for automated actions (cron, import jobs, future CI
 // integration). kind=system, no password (cannot login via UI). Created on
 // boot if missing. UI guards prevent disabling/deleting it.
-export function ensureBootstrapSystem(login: string): UserRow {
-  const existing = getUserByLogin(login);
+export async function ensureBootstrapSystem(login: string): Promise<UserRow> {
+  const existing = await getUserByLogin(login);
   if (existing) return existing;
-  return ensureUser(login, "system");
+  return await ensureUser(login, "system");
 }
 
 export function isReservedSystemLogin(login: string, cfg: Config): boolean {

package/src/config.ts

@@ -148,8 +148,8 @@ export const SETTINGS_GROUPS: SettingGroup[] = [
 ];
 export const DB_OVERRIDABLE: (keyof Config)[] = SETTINGS_GROUPS.flatMap((g) => g.fields.map((f) => f.key));
 
-export function loadConfig(): Config {
-  const db = getConfigAll();
+export async function loadConfig(): Promise<Config> {
+  const db = await getConfigAll();
   return configSchema.parse({
     port: process.env.WORK_PORT,
     host: process.env.WORK_HOST,

package/src/db.ts

@@ -1,19 +1,78 @@
-// SQLite store. One DB file holds the runtime config table AND the ework schema
-// (projects/issues/comments/labels/reactions/attachments/users) so transactions
-// span them. Schema is applied on boot via schema.sql.
+// Storage bootstrap. Owns the AsyncDatabase singleton. Two drivers behind one
+// AsyncDatabase surface: SQLite (bun:sqlite, default) and MySQL (mysql2/promise).
+// Driver picked by WORK_DB_DRIVER (sqlite|mysql). Schema + migrations run in
+// connect(). Callers MUST `await initDB()` once at boot before issuing queries.
+//
+// Table prefix: every table reference in SQL is written as a {{table}} token;
+// applyPrefix() rewrites {{name}} -> <WORK_DB_PREFIX>+name before execution.
+// Default prefix "" leaves SQL identical (backward-compatible with existing
+// ework.db files). WORK_DB_PREFIX is ENV-ONLY (never stored in the config
+// table) — the prefix is needed to locate the config table itself, so it
+// cannot live inside it (chicken-and-egg).
 
-import { Database } from "bun:sqlite";
+import { Database, type SQLQueryBindings } from "bun:sqlite";
+import { createPool, type Pool, type PoolConnection, type ResultSetHeader } from "mysql2/promise";
 import { mkdirSync, readFileSync } from "fs";
 import { dirname, join } from "path";
 
+// ---- public async interface (driver-agnostic) ----
+export interface DbRunResult {
+  /** Rowid of the last inserted row (SQLite lastInsertRowid / MySQL insertId). */
+  insertId: number;
+  /** Number of rows affected by the statement. */
+  changes: number;
+}
+
+export interface AsyncDatabase {
+  /** SELECT → all matching rows. Empty array when none. */
+  all<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+  /** SELECT → first matching row or null. */
+  get<T = unknown>(sql: string, params?: unknown[]): Promise<T | null>;
+  /** INSERT/UPDATE/DELETE → insertId + affected-row count. */
+  run(sql: string, params?: unknown[]): Promise<DbRunResult>;
+  /** Execute DDL / raw statement (no params, no rows back). */
+  exec(sql: string): Promise<void>;
+  /** Run fn inside a transaction: commit on resolve, rollback on throw. */
+  transaction<T>(fn: () => Promise<T>): Promise<T>;
+  /** Release the connection/pool. Idempotent. */
+  close(): Promise<void>;
+  /** Driver dialect — lets callers branch on SQLite vs MySQL specifics. */
+  readonly dialect: "sqlite" | "mysql";
+}
+
 const DB_PATH =
   process.env.WORK_DB_PATH ||
   join(process.env.XDG_DATA_HOME || `${process.env.HOME}/.local/share`, "ework", "ework.db");
 
-let _db: Database | null = null;
+// ---- table prefix (env-only; read once at module load) ----
+// Validated as a safe SQL identifier prefix. Empty = no prefix (default,
+// backward-compatible). A non-empty prefix lets multiple ework instances (or
+// ework + another app) share one database without colliding on table names.
+const DB_PREFIX = (() => {
+  const raw = (process.env.WORK_DB_PREFIX ?? "").trim();
+  if (raw && !/^[A-Za-z_][A-Za-z0-9_]{0,31}$/.test(raw)) {
+    throw new Error(
+      `Invalid WORK_DB_PREFIX "${raw}": must match ^[A-Za-z_][A-Za-z0-9_]{0,31}$`
+    );
+  }
+  return raw;
+})();
+
+/** Rewrite {{table}} tokens -> <prefix>table. No-op when sql contains no tokens. */
+export function applyPrefix(sql: string): string {
+  if (!sql.includes("{{")) return sql;
+  return sql.replace(/\{\{(\w+)\}\}/g, (_m, name: string) => DB_PREFIX + name);
+}
+
+// ---- driver selection (env-only; read once at module load) ----
+const DB_DRIVER = (process.env.WORK_DB_DRIVER ?? "sqlite").trim().toLowerCase();
+const DB_SKIP_CREATE = process.env.WORK_DB_SKIP_CREATE === "1" || process.env.WORK_DB_SKIP_CREATE === "true";
+if (DB_DRIVER !== "sqlite" && DB_DRIVER !== "mysql") {
+  throw new Error(`Unsupported WORK_DB_DRIVER "${DB_DRIVER}": must be "sqlite" or "mysql"`);
+}
 
 function userTableColumns(db: Database): Set<string> {
-  const rows = db.query("PRAGMA table_info(users)").all() as { name: string }[];
+  const rows = db.query(applyPrefix("PRAGMA table_info({{users}})")).all() as { name: string }[];
   return new Set(rows.map((r) => r.name));
 }
 
@@ -23,21 +82,21 @@ function migrateUsersTable(db: Database): void {
   if (userTableColumns(db).size === 0) return; // users doesn't exist yet; schema.sql will create it
   const have = userTableColumns(db);
   const additions: { col: string; ddl: string }[] = [
-    { col: "password_hash", ddl: "ALTER TABLE users ADD COLUMN password_hash TEXT" },
-    { col: "email", ddl: "ALTER TABLE users ADD COLUMN email TEXT" },
-    { col: "is_admin", ddl: "ALTER TABLE users ADD COLUMN is_admin INTEGER NOT NULL DEFAULT 0" },
-    { col: "is_active", ddl: "ALTER TABLE users ADD COLUMN is_active INTEGER NOT NULL DEFAULT 1" },
-    { col: "updated_at", ddl: "ALTER TABLE users ADD COLUMN updated_at TEXT NOT NULL DEFAULT ''" },
+    { col: "password_hash", ddl: "ALTER TABLE {{users}} ADD COLUMN password_hash TEXT" },
+    { col: "email", ddl: "ALTER TABLE {{users}} ADD COLUMN email TEXT" },
+    { col: "is_admin", ddl: "ALTER TABLE {{users}} ADD COLUMN is_admin INTEGER NOT NULL DEFAULT 0" },
+    { col: "is_active", ddl: "ALTER TABLE {{users}} ADD COLUMN is_active INTEGER NOT NULL DEFAULT 1" },
+    { col: "updated_at", ddl: "ALTER TABLE {{users}} ADD COLUMN updated_at TEXT NOT NULL DEFAULT ''" },
   ];
   for (const m of additions) {
     if (have.has(m.col)) continue;
-    db.exec(m.ddl);
+    db.exec(applyPrefix(m.ddl));
   }
-  db.exec("CREATE INDEX IF NOT EXISTS users_is_admin ON users (is_admin) WHERE is_admin = 1");
+  db.exec(applyPrefix("CREATE INDEX IF NOT EXISTS users_is_admin ON {{users}} (is_admin) WHERE is_admin = 1"));
 }
 
 function tableColumns(db: Database, name: string): Set<string> {
-  const rows = db.query(`PRAGMA table_info(${name})`).all() as { name: string }[];
+  const rows = db.query(applyPrefix(`PRAGMA table_info({{${name}}})`)).all() as { name: string }[];
   return new Set(rows.map((r) => r.name));
 }
 
@@ -45,7 +104,7 @@ function migratePatTable(db: Database): void {
   const have = tableColumns(db, "personal_access_tokens");
   if (have.size === 0) return;
   if (!have.has("ip_allowlist")) {
-    db.exec("ALTER TABLE personal_access_tokens ADD COLUMN ip_allowlist TEXT NOT NULL DEFAULT '[]'");
+    db.exec(applyPrefix("ALTER TABLE {{personal_access_tokens}} ADD COLUMN ip_allowlist TEXT NOT NULL DEFAULT '[]'"));
   }
 }
 
@@ -53,10 +112,10 @@ function migrateProjectsTable(db: Database): void {
   const have = tableColumns(db, "projects");
   if (have.size === 0) return;
   if (!have.has("upstream_urls")) {
-    db.exec("ALTER TABLE projects ADD COLUMN upstream_urls TEXT NOT NULL DEFAULT '[]'");
+    db.exec(applyPrefix("ALTER TABLE {{projects}} ADD COLUMN upstream_urls TEXT NOT NULL DEFAULT '[]'"));
   }
   if (!have.has("model")) {
-    db.exec("ALTER TABLE projects ADD COLUMN model TEXT NOT NULL DEFAULT ''");
+    db.exec(applyPrefix("ALTER TABLE {{projects}} ADD COLUMN model TEXT NOT NULL DEFAULT ''"));
   }
 }
 
@@ -64,37 +123,216 @@ function migrateIssuesTable(db: Database): void {
   const have = tableColumns(db, "issues");
   if (have.size === 0) return;
   if (!have.has("closed_at")) {
-    db.exec("ALTER TABLE issues ADD COLUMN closed_at TEXT");
+    db.exec(applyPrefix("ALTER TABLE {{issues}} ADD COLUMN closed_at TEXT"));
   }
 }
 
-function db(): Database {
-  if (_db) return _db;
-  mkdirSync(dirname(DB_PATH), { recursive: true });
-  _db = new Database(DB_PATH, { create: true, readwrite: true });
-  _db.exec("PRAGMA journal_mode = WAL");
-  _db.exec("PRAGMA foreign_keys = ON");
-  _db.exec(
-    "CREATE TABLE IF NOT EXISTS config (key TEXT PRIMARY KEY, value TEXT NOT NULL, updated_at TEXT NOT NULL)"
-  );
-  // Migration must run BEFORE schema.sql: schema.sql's CREATE TABLE for fresh
-  // DBs doesn't help legacy DBs, and any index that references a new column
-  // would fail if schema.sql ran first.
-  migrateUsersTable(_db);
-  migratePatTable(_db);
-  migrateProjectsTable(_db);
-  migrateIssuesTable(_db);
-  _db.exec(readFileSync(join(import.meta.dir, "schema.sql"), "utf8"));
-  return _db;
+// ---- SqliteDriver: wraps bun:sqlite behind AsyncDatabase ----
+class SqliteDriver implements AsyncDatabase {
+  readonly dialect = "sqlite" as const;
+  private readonly db: Database;
+  private inTx = false;
+  private constructor(db: Database) { this.db = db; }
+
+  static async create(): Promise<SqliteDriver> {
+    mkdirSync(dirname(DB_PATH), { recursive: true });
+    const db = new Database(DB_PATH, { create: true, readwrite: true });
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    db.exec(
+      applyPrefix(
+        "CREATE TABLE IF NOT EXISTS {{config}} (key TEXT PRIMARY KEY, value TEXT NOT NULL, updated_at TEXT NOT NULL)"
+      )
+    );
+    // Migration must run BEFORE schema.sql (same ordering as the original file).
+    migrateUsersTable(db);
+    migratePatTable(db);
+    migrateProjectsTable(db);
+    migrateIssuesTable(db);
+    db.exec(applyPrefix(readFileSync(join(import.meta.dir, "schema.sql"), "utf8")));
+    return new SqliteDriver(db);
+  }
+
+  async all<T = unknown>(sql: string, params: unknown[] = []): Promise<T[]> {
+    return this.db.query(applyPrefix(sql)).all(...(params as SQLQueryBindings[])) as T[];
+  }
+  async get<T = unknown>(sql: string, params: unknown[] = []): Promise<T | null> {
+    return (this.db.query(applyPrefix(sql)).get(...(params as SQLQueryBindings[])) as T | null) ?? null;
+  }
+  async run(sql: string, params: unknown[] = []): Promise<DbRunResult> {
+    const info = this.db.query(applyPrefix(sql)).run(...(params as SQLQueryBindings[])) as unknown as {
+      lastInsertRowid: number | bigint;
+      changes: number;
+    };
+    return { insertId: Number(info.lastInsertRowid), changes: info.changes };
+  }
+  async exec(sql: string): Promise<void> {
+    this.db.exec(applyPrefix(sql));
+  }
+  async transaction<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.inTx) {
+      // SQLite can't nest BEGIN without SAVEPOINT; current codebase has no
+      // nesting, so this safety net just runs the body inline.
+      return fn();
+    }
+    this.db.exec("BEGIN");
+    this.inTx = true;
+    try {
+      const r = await fn();
+      this.db.exec("COMMIT");
+      return r;
+    } catch (e) {
+      try { this.db.exec("ROLLBACK"); } catch { /* already rolled back */ }
+      throw e;
+    } finally {
+      this.inTx = false;
+    }
+  }
+  async close(): Promise<void> {
+    try { this.db.close(); } catch { /* already closed */ }
+  }
 }
 
-export function rawDB(): Database {
-  return db();
+// ---- MysqlDriver: wraps mysql2/promise behind AsyncDatabase ----
+// MySQL transactions must run on a single connection, so transaction() checks
+// out a connection, pins it as txConn, and routes all/get/run/exec through it
+// until commit/rollback. Outside a transaction, queries hit the pool. SQLite-
+// specific SQL (INSERT OR IGNORE, ON CONFLICT ... excluded.x) is translated to
+// MySQL equivalents by translateForMysql() so store.ts stays single-dialect.
+interface MysqlOptions {
+  host: string;
+  port: number;
+  user: string;
+  password: string;
+  database: string;
+  skipCreate: boolean;
 }
 
-export function getConfigAll(): Record<string, string> {
+function translateForMysql(sql: string): string {
+  return sql
+    .replace(/INSERT OR IGNORE INTO/g, "INSERT IGNORE INTO")
+    .replace(/ON CONFLICT\((\w+)\) DO UPDATE SET/g, "ON DUPLICATE KEY UPDATE")
+    .replace(/excluded\.(\w+)/g, "VALUES($1)");
+}
+
+class MysqlDriver implements AsyncDatabase {
+  readonly dialect = "mysql" as const;
+  private readonly pool: Pool;
+  private txConn: PoolConnection | null = null;
+  private constructor(pool: Pool) { this.pool = pool; }
+
+  private get conn(): Pool | PoolConnection {
+    return this.txConn ?? this.pool;
+  }
+
+  static async create(opts: MysqlOptions): Promise<MysqlDriver> {
+    const pool = createPool({
+      host: opts.host,
+      port: opts.port,
+      user: opts.user,
+      password: opts.password,
+      database: opts.database,
+      waitForConnections: true,
+      connectionLimit: 10,
+      charset: "utf8mb4",
+    });
+    const probe = await pool.getConnection();
+    try {
+      await probe.ping();
+    } finally {
+      probe.release();
+    }
+    if (!opts.skipCreate) {
+      const raw = applyPrefix(readFileSync(join(import.meta.dir, "schema-mysql.sql"), "utf8"));
+      // MySQL has no CREATE INDEX IF NOT EXISTS, so split into statements and
+      // tolerate ER_DUP_KEYNAME (1061) so re-runs stay idempotent. Comment lines
+      // are stripped first — they may contain ';' which would corrupt the split.
+      const schema = raw.split("\n").filter((l) => !l.trimStart().startsWith("--")).join("\n");
+      for (const stmt of schema.split(";").map((s) => s.trim()).filter((s) => s.length > 0)) {
+        try {
+          await pool.query(stmt);
+        } catch (e) {
+          if (e && typeof e === "object" && "errno" in e && (e as { errno: number }).errno === 1061) continue;
+          throw e;
+        }
+      }
+    }
+    return new MysqlDriver(pool);
+  }
+
+  private prepare(sql: string): string {
+    return translateForMysql(applyPrefix(sql));
+  }
+
+  async all<T = unknown>(sql: string, params: unknown[] = []): Promise<T[]> {
+    const [rows] = await this.conn.query(this.prepare(sql), params);
+    return rows as T[];
+  }
+  async get<T = unknown>(sql: string, params: unknown[] = []): Promise<T | null> {
+    const [rows] = await this.conn.query(this.prepare(sql), params);
+    const arr = rows as T[];
+    return arr[0] ?? null;
+  }
+  async run(sql: string, params: unknown[] = []): Promise<DbRunResult> {
+    const [result] = await this.conn.query(this.prepare(sql), params);
+    const r = result as ResultSetHeader;
+    return { insertId: Number(r.insertId), changes: r.affectedRows };
+  }
+  async exec(sql: string): Promise<void> {
+    await this.conn.query(this.prepare(sql));
+  }
+  async transaction<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.txConn) return fn();
+    const conn = await this.pool.getConnection();
+    this.txConn = conn;
+    await conn.beginTransaction();
+    try {
+      const r = await fn();
+      await conn.commit();
+      return r;
+    } catch (e) {
+      try { await conn.rollback(); } catch { /* already rolled back */ }
+      throw e;
+    } finally {
+      this.txConn = null;
+      conn.release();
+    }
+  }
+  async close(): Promise<void> {
+    try { await this.pool.end(); } catch { /* already closed */ }
+  }
+}
+
+let _driver: AsyncDatabase | null = null;
+
+/** Initialize + connect the database. MUST be awaited once at boot. */
+export async function initDB(): Promise<AsyncDatabase> {
+  if (_driver) return _driver;
+  if (DB_DRIVER === "mysql") {
+    _driver = await MysqlDriver.create({
+      host: process.env.WORK_DB_HOST ?? "127.0.0.1",
+      port: Number(process.env.WORK_DB_PORT ?? 3306),
+      user: process.env.WORK_DB_USER ?? "ework",
+      password: process.env.WORK_DB_PASSWORD ?? "",
+      database: process.env.WORK_DB_NAME ?? "ework",
+      skipCreate: DB_SKIP_CREATE,
+    });
+  } else {
+    _driver = await SqliteDriver.create();
+  }
+  return _driver;
+}
+
+/** Returns the initialized AsyncDatabase. Throws if initDB() wasn't awaited. */
+export function getDB(): AsyncDatabase {
+  if (!_driver) throw new Error("getDB() called before initDB(); await initDB() at boot first");
+  return _driver;
+}
+
+export async function getConfigAll(): Promise<Record<string, string>> {
   try {
-    const rows = db().query("SELECT key, value FROM config").all() as { key: string; value: string }[];
+    const driver = getDB();
+    const rows = await driver.all<{ key: string; value: string }>("SELECT key, value FROM {{config}}");
     const out: Record<string, string> = {};
     for (const r of rows) out[r.key] = r.value;
     return out;
@@ -103,16 +341,15 @@ export function getConfigAll(): Record<string, string> {
   }
 }
 
-export function setConfig(key: string, value: string): void {
+export async function setConfig(key: string, value: string): Promise<void> {
   const now = new Date().toISOString();
-  db()
-    .query(
-      "INSERT INTO config (key, value, updated_at) VALUES (?, ?, ?) " +
-        "ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at"
-    )
-    .run(key, value, now);
+  await getDB().run(
+    "INSERT INTO {{config}} (key, value, updated_at) VALUES (?, ?, ?) " +
+      "ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at",
+    [key, value, now]
+  );
 }
 
-export function deleteConfig(key: string): void {
-  db().query("DELETE FROM config WHERE key = ?").run(key);
+export async function deleteConfig(key: string): Promise<void> {
+  await getDB().run("DELETE FROM {{config}} WHERE key = ?", [key]);
 }