specrails-desktop 2.2.1 → 2.4.0

package/server/dist/jira/jira-db.js

@@ -0,0 +1,341 @@
+"use strict";
+// Data-access layer for the per-project Jira tables (migration 29).
+//
+// All three tables live in the per-project `jobs.sqlite`. The outbox is the
+// durable source of truth for "what must reach Jira": an outbox row is inserted
+// in the SAME SQLite transaction as the record of a status change, so a crash
+// between the local cache mutation and the network flush can never lose a write.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnection = getConnection;
+exports.getDecryptedToken = getDecryptedToken;
+exports.hasToken = hasToken;
+exports.getConnectionPublic = getConnectionPublic;
+exports.upsertConnection = upsertConnection;
+exports.setConnectionEnabled = setConnectionEnabled;
+exports.setHighWater = setHighWater;
+exports.setSprintFieldId = setSprintFieldId;
+exports.setDiscardStatus = setDiscardStatus;
+exports.setStatusMap = setStatusMap;
+exports.deleteConnection = deleteConnection;
+exports.getLinkByIssueId = getLinkByIssueId;
+exports.getLinkByLocalId = getLinkByLocalId;
+exports.listLinks = listLinks;
+exports.ensureLink = ensureLink;
+exports.nextLocalId = nextLocalId;
+exports.insertLinkWithId = insertLinkWithId;
+exports.updateLinkStatusCategory = updateLinkStatusCategory;
+exports.setLinkState = setLinkState;
+exports.tombstoneLink = tombstoneLink;
+exports.enqueueOutbox = enqueueOutbox;
+exports.enqueueMany = enqueueMany;
+exports.claimDrainable = claimDrainable;
+exports.markOutboxDone = markOutboxDone;
+exports.markOutboxRetry = markOutboxRetry;
+exports.markOutboxDead = markOutboxDead;
+exports.resetInflight = resetInflight;
+exports.retryDeadOutbox = retryDeadOutbox;
+exports.listOutbox = listOutbox;
+exports.countOutboxByState = countOutboxByState;
+const jira_credential_store_1 = require("./jira-credential-store");
+function mapConnection(r) {
+    let statusMap = null;
+    if (r.status_map) {
+        try {
+            statusMap = JSON.parse(r.status_map);
+        }
+        catch {
+            statusMap = null;
+        }
+    }
+    return {
+        projectId: r.project_id,
+        baseUrl: r.base_url,
+        deployment: r.deployment,
+        apiVersion: r.api_version === '2' ? '2' : '3',
+        authScheme: r.auth_scheme === 'bearer' ? 'bearer' : 'basic',
+        accountEmail: r.account_email,
+        jiraProjectKey: r.jira_project_key,
+        jiraProjectId: r.jira_project_id,
+        enabled: r.enabled === 1,
+        statusMap,
+        highWaterMs: r.high_water_ms,
+        sprintFieldId: r.sprint_field_id ?? null,
+        discardStatus: r.discard_status ?? null,
+        createdAt: r.created_at,
+        updatedAt: r.updated_at,
+    };
+}
+function getConnection(db, projectId) {
+    const row = db.prepare('SELECT * FROM jira_connection WHERE project_id = ?').get(projectId);
+    return row ? mapConnection(row) : null;
+}
+/** Read the raw encrypted token blob (server-internal only — never returned to client). */
+function getDecryptedToken(db, projectId) {
+    const row = db.prepare('SELECT encrypted_token FROM jira_connection WHERE project_id = ?').get(projectId);
+    if (!row?.encrypted_token)
+        return null;
+    try {
+        return (0, jira_credential_store_1.getSecretStore)().decrypt(row.encrypted_token);
+    }
+    catch {
+        return null;
+    }
+}
+function hasToken(db, projectId) {
+    const row = db.prepare('SELECT encrypted_token FROM jira_connection WHERE project_id = ?').get(projectId);
+    return !!row?.encrypted_token;
+}
+/** Client-safe connection (token redacted to a boolean). */
+function getConnectionPublic(db, projectId) {
+    const conn = getConnection(db, projectId);
+    if (!conn)
+        return null;
+    return { ...conn, hasToken: hasToken(db, projectId) };
+}
+function upsertConnection(db, input) {
+    const existing = getConnection(db, input.projectId);
+    const now = new Date().toISOString();
+    const prevToken = existing
+        ? db.prepare('SELECT encrypted_token FROM jira_connection WHERE project_id = ?').get(input.projectId)?.encrypted_token ?? null
+        : null;
+    const encryptedToken = input.token !== undefined ? (0, jira_credential_store_1.getSecretStore)().encrypt(input.token) : prevToken;
+    const statusMapJson = input.statusMap !== undefined
+        ? input.statusMap === null
+            ? null
+            : JSON.stringify(input.statusMap)
+        : existing?.statusMap
+            ? JSON.stringify(existing.statusMap)
+            : null;
+    const enabled = input.enabled !== undefined ? (input.enabled ? 1 : 0) : existing ? (existing.enabled ? 1 : 0) : 1;
+    db.prepare(`INSERT INTO jira_connection
+       (project_id, base_url, deployment, api_version, auth_scheme, account_email,
+        jira_project_key, jira_project_id, encrypted_token, enabled, status_map,
+        high_water_ms, created_at, updated_at)
+     VALUES (@project_id, @base_url, @deployment, @api_version, @auth_scheme, @account_email,
+        @jira_project_key, @jira_project_id, @encrypted_token, @enabled, @status_map,
+        @high_water_ms, @created_at, @updated_at)
+     ON CONFLICT(project_id) DO UPDATE SET
+        base_url=@base_url, deployment=@deployment, api_version=@api_version,
+        auth_scheme=@auth_scheme, account_email=@account_email,
+        jira_project_key=@jira_project_key, jira_project_id=@jira_project_id,
+        encrypted_token=@encrypted_token, enabled=@enabled, status_map=@status_map,
+        updated_at=@updated_at`).run({
+        project_id: input.projectId,
+        base_url: input.baseUrl,
+        deployment: input.deployment,
+        api_version: input.apiVersion,
+        auth_scheme: input.authScheme,
+        account_email: input.accountEmail,
+        jira_project_key: input.jiraProjectKey,
+        jira_project_id: input.jiraProjectId,
+        encrypted_token: encryptedToken,
+        enabled,
+        status_map: statusMapJson,
+        high_water_ms: existing?.highWaterMs ?? null,
+        created_at: existing?.createdAt ?? now,
+        updated_at: now,
+    });
+    return getConnection(db, input.projectId);
+}
+function setConnectionEnabled(db, projectId, enabled) {
+    db.prepare('UPDATE jira_connection SET enabled = ?, updated_at = ? WHERE project_id = ?').run(enabled ? 1 : 0, new Date().toISOString(), projectId);
+}
+function setHighWater(db, projectId, highWaterMs) {
+    db.prepare('UPDATE jira_connection SET high_water_ms = ?, updated_at = ? WHERE project_id = ?').run(highWaterMs, new Date().toISOString(), projectId);
+}
+/** Cache the discovered sprint custom-field id ('none' when none exists). */
+function setSprintFieldId(db, projectId, fieldId) {
+    db.prepare('UPDATE jira_connection SET sprint_field_id = ?, updated_at = ? WHERE project_id = ?').run(fieldId, new Date().toISOString(), projectId);
+}
+/** Set (or clear with null) the discard target status name. */
+function setDiscardStatus(db, projectId, status) {
+    db.prepare('UPDATE jira_connection SET discard_status = ?, updated_at = ? WHERE project_id = ?').run(status && status.trim() ? status.trim() : null, new Date().toISOString(), projectId);
+}
+/** Replace (or clear with null/empty) the per-logical-state status map. */
+function setStatusMap(db, projectId, statusMap) {
+    const json = statusMap && Object.keys(statusMap).length ? JSON.stringify(statusMap) : null;
+    db.prepare('UPDATE jira_connection SET status_map = ?, updated_at = ? WHERE project_id = ?').run(json, new Date().toISOString(), projectId);
+}
+function deleteConnection(db, projectId) {
+    db.prepare('DELETE FROM jira_connection WHERE project_id = ?').run(projectId);
+}
+function mapLink(r) {
+    return {
+        localId: r.local_id,
+        jiraIssueId: r.jira_issue_id,
+        jiraKey: r.jira_key,
+        jiraProjectId: r.jira_project_id,
+        deployment: r.deployment,
+        statusCategory: r.status_category ?? null,
+        state: r.state ?? 'linked',
+        tombstoned: r.tombstoned === 1,
+        createdAt: r.created_at,
+        updatedAt: r.updated_at,
+    };
+}
+function getLinkByIssueId(db, jiraIssueId) {
+    const row = db.prepare('SELECT * FROM jira_links WHERE jira_issue_id = ?').get(jiraIssueId);
+    return row ? mapLink(row) : null;
+}
+function getLinkByLocalId(db, localId) {
+    const row = db.prepare('SELECT * FROM jira_links WHERE local_id = ?').get(localId);
+    return row ? mapLink(row) : null;
+}
+function listLinks(db) {
+    return db.prepare('SELECT * FROM jira_links ORDER BY local_id').all().map(mapLink);
+}
+/**
+ * Resolve (or mint) the stable local `#id` for a Jira issue. The local id is
+ * monotonic and never reused — tombstoned rows keep their id so a previously
+ * issued `/specrails:implement #N` never rebinds to a different issue.
+ */
+function ensureLink(db, args) {
+    const existing = getLinkByIssueId(db, args.jiraIssueId);
+    const now = new Date().toISOString();
+    if (existing) {
+        // Refresh the display key (issues can be moved/renamed; id is immutable).
+        if (args.jiraKey && args.jiraKey !== existing.jiraKey) {
+            db.prepare('UPDATE jira_links SET jira_key = ?, updated_at = ? WHERE jira_issue_id = ?').run(args.jiraKey, now, args.jiraIssueId);
+            return getLinkByIssueId(db, args.jiraIssueId);
+        }
+        return existing;
+    }
+    const localId = nextLocalId(db);
+    db.prepare(`INSERT INTO jira_links (local_id, jira_issue_id, jira_key, jira_project_id, deployment, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(localId, args.jiraIssueId, args.jiraKey, args.jiraProjectId, args.deployment, now, now);
+    return getLinkByLocalId(db, localId);
+}
+/** Next monotonic local id: max(existing local_ids) + 1, never reusing. */
+function nextLocalId(db) {
+    const row = db.prepare('SELECT MAX(local_id) AS maxId FROM jira_links').get();
+    return (row.maxId ?? 0) + 1;
+}
+/**
+ * Insert a link with a caller-chosen local id. Used by the materializer, which
+ * allocates ids from the UNION of the ticket store's `next_id` and the jira_links
+ * max so Jira-sourced `#id`s never collide with locally-created specs.
+ */
+function insertLinkWithId(db, args) {
+    const now = new Date().toISOString();
+    db.prepare(`INSERT INTO jira_links (local_id, jira_issue_id, jira_key, jira_project_id, deployment, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(args.localId, args.jiraIssueId, args.jiraKey, args.jiraProjectId, args.deployment, now, now);
+    return getLinkByLocalId(db, args.localId);
+}
+function updateLinkStatusCategory(db, jiraIssueId, category) {
+    db.prepare('UPDATE jira_links SET status_category = ?, updated_at = ? WHERE jira_issue_id = ?').run(category, new Date().toISOString(), jiraIssueId);
+}
+function setLinkState(db, jiraIssueId, state) {
+    db.prepare('UPDATE jira_links SET state = ?, updated_at = ? WHERE jira_issue_id = ?').run(state, new Date().toISOString(), jiraIssueId);
+}
+/** Tombstone a deleted/orphaned issue's link (keeps the local id reserved). */
+function tombstoneLink(db, jiraIssueId) {
+    db.prepare("UPDATE jira_links SET tombstoned = 1, state = 'orphaned', updated_at = ? WHERE jira_issue_id = ?").run(new Date().toISOString(), jiraIssueId);
+}
+function mapOutbox(r) {
+    return {
+        id: r.id,
+        jiraIssueId: r.jira_issue_id,
+        opType: r.op_type,
+        idempotencyKey: r.idempotency_key,
+        payload: r.payload,
+        state: r.state,
+        attempts: r.attempts,
+        nextAttemptAt: r.next_attempt_at,
+        lastError: r.last_error,
+        deadReason: r.dead_reason,
+        createdAt: r.created_at,
+        updatedAt: r.updated_at,
+    };
+}
+/**
+ * Insert an outbox op. Idempotent on `idempotencyKey` (INSERT OR IGNORE) so a
+ * crash-replay of the same logical op never double-enqueues. Returns the row id
+ * (existing or new). Intended to be called inside a transaction together with
+ * the status-change record (see `enqueueMany`).
+ */
+function enqueueOutbox(db, input) {
+    const now = new Date().toISOString();
+    const info = db
+        .prepare(`INSERT OR IGNORE INTO jira_outbox
+        (jira_issue_id, op_type, idempotency_key, payload, state, attempts, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 'pending', 0, ?, ?)`)
+        .run(input.jiraIssueId, input.opType, input.idempotencyKey, JSON.stringify(input.payload), now, now);
+    if (info.changes > 0)
+        return Number(info.lastInsertRowid);
+    const existing = db.prepare('SELECT id FROM jira_outbox WHERE idempotency_key = ?').get(input.idempotencyKey);
+    return existing?.id ?? 0;
+}
+/** Enqueue several ops atomically (one SQLite transaction). */
+function enqueueMany(db, ops) {
+    const tx = db.transaction((items) => {
+        for (const op of items)
+            enqueueOutbox(db, op);
+    });
+    tx(ops);
+}
+/**
+ * Claim the next batch of drainable ops (state=pending and due), one per issue
+ * (FIFO-per-issue: never two concurrent ops on the same issue), up to `limit`
+ * distinct issues. Marks them `inflight`.
+ */
+function claimDrainable(db, limit, nowIso = new Date().toISOString()) {
+    const tx = db.transaction((max) => {
+        const rows = db
+            .prepare(`SELECT * FROM jira_outbox
+          WHERE state = 'pending' AND (next_attempt_at IS NULL OR next_attempt_at <= ?)
+          ORDER BY id ASC`)
+            .all(nowIso);
+        const claimed = [];
+        const seenIssues = new Set();
+        for (const r of rows) {
+            if (seenIssues.has(r.jira_issue_id))
+                continue; // one op per issue per drain pass
+            seenIssues.add(r.jira_issue_id);
+            db.prepare("UPDATE jira_outbox SET state = 'inflight', updated_at = ? WHERE id = ?").run(nowIso, r.id);
+            claimed.push(mapOutbox({ ...r, state: 'inflight' }));
+            if (claimed.length >= max)
+                break;
+        }
+        return claimed;
+    });
+    return tx(limit);
+}
+function markOutboxDone(db, id) {
+    db.prepare("UPDATE jira_outbox SET state = 'done', updated_at = ? WHERE id = ?").run(new Date().toISOString(), id);
+}
+function markOutboxRetry(db, id, nextAttemptAt, error) {
+    db.prepare("UPDATE jira_outbox SET state = 'pending', attempts = attempts + 1, next_attempt_at = ?, last_error = ?, updated_at = ? WHERE id = ?").run(nextAttemptAt, error.slice(0, 500), new Date().toISOString(), id);
+}
+function markOutboxDead(db, id, reason) {
+    db.prepare("UPDATE jira_outbox SET state = 'dead', dead_reason = ?, updated_at = ? WHERE id = ?").run(reason.slice(0, 500), new Date().toISOString(), id);
+}
+/** Reset all `inflight` rows back to `pending` (startup recovery after a crash). */
+function resetInflight(db) {
+    const info = db
+        .prepare("UPDATE jira_outbox SET state = 'pending', updated_at = ? WHERE state = 'inflight'")
+        .run(new Date().toISOString());
+    return info.changes;
+}
+/** Re-queue a dead-lettered op for a manual retry. */
+function retryDeadOutbox(db, id) {
+    const info = db
+        .prepare("UPDATE jira_outbox SET state = 'pending', next_attempt_at = NULL, dead_reason = NULL, last_error = NULL, updated_at = ? WHERE id = ? AND state = 'dead'")
+        .run(new Date().toISOString(), id);
+    return info.changes > 0;
+}
+function listOutbox(db, opts = {}) {
+    const limit = Math.min(opts.limit ?? 200, 1000);
+    if (opts.state) {
+        return db.prepare('SELECT * FROM jira_outbox WHERE state = ? ORDER BY id DESC LIMIT ?').all(opts.state, limit).map(mapOutbox);
+    }
+    return db.prepare('SELECT * FROM jira_outbox ORDER BY id DESC LIMIT ?').all(limit).map(mapOutbox);
+}
+function countOutboxByState(db) {
+    const rows = db.prepare('SELECT state, COUNT(*) AS n FROM jira_outbox GROUP BY state').all();
+    const out = { pending: 0, inflight: 0, done: 0, dead: 0 };
+    for (const r of rows) {
+        if (r.state in out)
+            out[r.state] = r.n;
+    }
+    return out;
+}