stackchain-dashboard/frontend/background-issue-sync.js

function createIndexedDbTransaction(indexedDB, dbName = 'stackchain-background-outbox-v1') {
  let databasePromise;
  function database() {
    if (!databasePromise) databasePromise = new Promise((resolve, reject) => {
      const request = indexedDB.open(dbName, 1);
      request.onupgradeneeded = () => {
        if (!request.result.objectStoreNames.contains('issues')) {
          request.result.createObjectStore('issues', { keyPath: 'id' });
        }
      };
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error);
    });
    return databasePromise;
  }
  const requested = request => new Promise((resolve, reject) => {
    request.onsuccess = () => resolve(request.result);
    request.onerror = () => reject(request.error);
  });
  return async work => {
    const db = await database();
    return new Promise((resolve, reject) => {
      const transaction = db.transaction('issues', 'readwrite');
      const objectStore = transaction.objectStore('issues');
      let result;
      let failed = false;
      transaction.oncomplete = () => failed ? undefined : resolve(result);
      transaction.onerror = () => reject(transaction.error);
      transaction.onabort = () => reject(transaction.error || new Error('Issue outbox transaction aborted'));
      Promise.resolve(work({
        getAll: () => requested(objectStore.getAll()),
        put: value => requested(objectStore.put(value)),
        delete: id => requested(objectStore.delete(id)),
      })).then(value => { result = value; }).catch(error => {
        failed = true;
        try { transaction.abort(); } catch (_abortError) { reject(error); }
        reject(error);
      });
    });
  };
}

function createIssueSyncStore({ transaction, indexedDB = globalThis.indexedDB, now = () => Date.now(), claimMs = 30000 } = {}) {
  const transact = transaction || createIndexedDbTransaction(indexedDB);

  async function reconcile(items) {
    return transact(async records => {
      const existing = await records.getAll();
      const incoming = new Map(items.map(item => [item.id, { ...item }]));
      for (const current of existing) {
        const replacement = incoming.get(current.id);
        if (!replacement) {
          if (current.status !== 'sending' || Number(current.claimUntil) <= Number(now())) {
            await records.delete(current.id);
          }
          continue;
        }
        if ((current.status === 'sending' && Number(current.claimUntil) > Number(now())) ||
            (current.status === 'attention' && replacement.status === 'attention') ||
            current.status === 'sent') {
          incoming.set(current.id, current);
        }
      }
      for (const item of incoming.values()) await records.put(item);
    });
  }

  async function claimNext(ownerLogin) {
    return transact(async records => {
      const timestamp = Number(now());
      const items = await records.getAll();
      const item = items.find(candidate => candidate.ownerLogin === ownerLogin &&
        (candidate.status === 'queued' || candidate.status === 'sending') &&
        (candidate.status !== 'sending' || Number(candidate.claimUntil) <= timestamp));
      if (!item) return null;
      const claimed = { ...item, status: 'sending', claimUntil: timestamp + claimMs };
      await records.put(claimed);
      return claimed;
    });
  }

  async function claim(id, ownerLogin) {
    return transact(async records => {
      const timestamp = Number(now());
      const item = (await records.getAll()).find(candidate => candidate.id === id);
      if (!item || item.ownerLogin !== ownerLogin ||
          !['queued', 'sending'].includes(item.status) ||
          (item.status === 'sending' && Number(item.claimUntil) > timestamp)) return null;
      const claimed = { ...item, status: 'sending', claimUntil: timestamp + claimMs };
      await records.put(claimed);
      return claimed;
    });
  }

  async function upsert(item) {
    return transact(async records => {
      const current = (await records.getAll()).find(candidate => candidate.id === item.id);
      if (current && ((current.status === 'sending' && Number(current.claimUntil) > Number(now())) ||
          (current.status === 'attention' && item.status === 'attention') ||
          current.status === 'sent')) return current;
      await records.put({ ...item });
      return item;
    });
  }

  async function update(id, transform) {
    return transact(async records => {
      const item = (await records.getAll()).find(candidate => candidate.id === id);
      if (item) await records.put(transform(item));
    });
  }

  return {
    reconcile,
    upsert,
    claim,
    claimNext,
    complete: id => update(id, item => ({ ...item, status: 'sent', claimUntil: 0 })),
    release: id => update(id, item => ({ ...item, status: 'queued', claimUntil: 0 })),
    fail: (id, error) => update(id, item => ({ ...item, status: 'attention', claimUntil: 0, error })),
    snapshot: () => transact(records => records.getAll()),
    countBlocked: ownerLogin => transact(async records =>
      (await records.getAll()).filter(item => item.status !== 'sent' && item.ownerLogin !== ownerLogin).length),
  };
}

function createBackgroundIssueSync({ store, fetchJson, base = '' }) {
  function issueRequest(item) {
    const repository = String(item.repository || '').split('/').map(encodeURIComponent).join('/');
    return {
      url: base + 'api/v1/repos/' + repository + '/issues',
      options: {
        method: 'POST',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json',
          'Idempotency-Key': item.operationId,
        },
        body: JSON.stringify({
          title: item.title,
          body: item.body,
          label_ids: item.labelIds,
          ...(item.milestoneId ? { milestone_id: item.milestoneId } : {}),
          ...(item.dueDate ? { due_date: item.dueDate + 'T23:59:59Z' } : {}),
        }),
      },
    };
  }

  async function deliver(item) {
    const request = issueRequest(item);
    try {
      const issue = await fetchJson(request.url, request.options);
      await store.complete(item.id);
      return { issue };
    } catch (error) {
      const status = Number(error?.status || 0);
      if (status >= 400 && status < 500) {
        await store.fail(item.id, String(error?.message || 'Issue needs attention').slice(0, 240));
        return { attention: true, error };
      }
      await store.release(item.id);
      throw error;
    }
  }

  async function send(item, currentLogin) {
    if (!currentLogin || item.ownerLogin !== currentLogin) return { blocked: true };
    await store.upsert(item);
    const claimed = await store.claim(item.id, currentLogin);
    if (!claimed) return { busy: true };
    return deliver(claimed);
  }

  async function flush() {
    const identity = await fetchJson(base + 'api/v1/background-identity', {
      headers: { Accept: 'application/json' }, cache: 'no-store',
    });
    const login = String(identity?.login || '').trim();
    const confirmed = [];
    let attention = 0;
    if (!login) return { confirmed, blocked: 0, attention };
    while (true) {
      const item = await store.claimNext(login);
      if (!item) break;
      const result = await deliver(item);
      if (result.issue) confirmed.push(result.issue);
      if (result.attention) attention += 1;
    }
    const blocked = store.countBlocked ? await store.countBlocked(login) : 0;
    return { confirmed, blocked, attention };
  }

  return {
    flush, send,
    reconcile: items => store.reconcile(items),
    snapshot: () => store.snapshot(),
  };
}

createBackgroundIssueSync.createIssueSyncStore = createIssueSyncStore;
if (typeof module !== 'undefined' && module.exports) module.exports = createBackgroundIssueSync;
if (typeof globalThis !== 'undefined') {
  globalThis.createBackgroundIssueSync = createBackgroundIssueSync;
  globalThis.createIssueSyncStore = createIssueSyncStore;
}