stackchain-dashboard/frontend/issue-outbox.js

function createIssueOutbox({ storage, fetchJson, getOwnerLogin = () => '', createOperationId, now = () => Date.now(), maxItems = 20 }) {
  const storageKey = 'stackchain.issue-outbox.v1';
  const operationId = createOperationId || (() =>
    globalThis.crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random().toString(16).slice(2)
  );
  const pending = new Map();

  function read() {
    try {
      const record = JSON.parse(storage?.getItem(storageKey) || 'null');
      if (![1, 2].includes(record?.version) || !Array.isArray(record.items)) return [];
      return record.items.filter(item => item && typeof item === 'object');
    } catch (_error) { return []; }
  }

  function write(items) {
    storage?.setItem(storageKey, JSON.stringify({ version: 2, items }));
  }

  function enqueue(draft) {
    const ownerLogin = String(getOwnerLogin() || '').trim();
    if (!ownerLogin) throw new Error('Confirm your Gitea account before queueing an issue.');
    const items = read();
    if (items.length >= maxItems) throw new Error('Issue outbox is full. Send or discard a queued issue first.');
    const item = {
      id: String(operationId()).slice(0, 128),
      operationId: '',
      repository: String(draft?.repository || ''),
      title: String(draft?.title || ''),
      body: String(draft?.body || ''),
      labelIds: Array.isArray(draft?.labelIds) ? draft.labelIds.filter(Number.isInteger).slice(0, 20) : [],
      ownerLogin,
      status: 'queued',
      queuedAt: Number(now()),
    };
    item.operationId = item.id;
    if (Number.isInteger(Number(draft?.milestoneId)) && Number(draft.milestoneId) > 0) {
      item.milestoneId = Number(draft.milestoneId);
    }
    if (/^\d{4}-\d{2}-\d{2}$/.test(String(draft?.dueDate || ''))) item.dueDate = String(draft.dueDate);
    items.push(item);
    write(items);
    return item;
  }

  function update(id, draft) {
    let updated = null;
    write(read().map(item => {
      if (item.id !== id) return item;
      updated = {
        ...item,
        repository: String(draft?.repository || ''), title: String(draft?.title || ''),
        body: String(draft?.body || ''),
        labelIds: Array.isArray(draft?.labelIds) ? draft.labelIds.filter(Number.isInteger).slice(0, 20) : [],
        status: 'queued',
      };
      delete updated.error;
      return updated;
    }));
    return updated;
  }

  function discard(id) {
    const items = read();
    if (!items.some(item => item.id === id)) return false;
    write(items.filter(item => item.id !== id));
    return true;
  }

  async function sendItem(item, currentLogin) {
    if (!currentLogin || item.ownerLogin !== currentLogin) return { blocked: true };
    if (pending.has(item.id)) return pending.get(item.id);
    const repository = item.repository.split('/').map(encodeURIComponent).join('/');
    const request = (async () => {
      try {
        const issue = await fetchJson('api/v1/repos/' + repository + '/issues', {
          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' } : {}),
          }),
        });
        discard(item.id);
        return { issue };
      } catch (error) {
        const status = Number(error?.status || 0);
        if (status >= 400 && status < 500) {
          write(read().map(candidate => candidate.id === item.id ? {
            ...candidate, status: 'attention', error: String(error.message || 'Issue needs attention').slice(0, 240),
          } : candidate));
        }
        return { error, transient: !(status >= 400 && status < 500) };
      }
    })();
    pending.set(item.id, request);
    try { return await request; }
    finally { if (pending.get(item.id) === request) pending.delete(item.id); }
  }

  async function flush(currentLogin) {
    const confirmed = [];
    let blocked = 0;
    currentLogin = String(currentLogin || '').trim();
    for (const item of read()) {
      if (item.status === 'attention') continue;
      if (!currentLogin || item.ownerLogin !== currentLogin) { blocked += 1; continue; }
      const result = await sendItem(item, currentLogin);
      if (result.issue) confirmed.push(result.issue);
      if (result.transient) break;
    }
    return { confirmed, remaining: read(), blocked };
  }

  async function retry(id, currentLogin) {
    const item = read().find(candidate => candidate.id === id);
    if (!item) return { confirmed: [], remaining: read() };
    currentLogin = String(currentLogin || '').trim();
    if (!currentLogin || item.ownerLogin !== currentLogin) {
      return { confirmed: [], remaining: read(), blocked: 1 };
    }
    update(id, item);
    const result = await sendItem({ ...item, status: 'queued' }, currentLogin);
    return { confirmed: result.issue ? [result.issue] : [], remaining: read(), blocked: 0 };
  }

  return { enqueue, update, discard, flush, retry, list: () => read().map(item => ({ ...item })) };
}

if (typeof module !== 'undefined' && module.exports) module.exports = createIssueOutbox;