reslop 0.2.7 → 0.3.0

package/lib/{remote.js → source/remote.js}

@@ -1,15 +1,10 @@
 'use strict';
 
-const metautil = require('metautil');
-const { delay, jsonParse, isHashObject } = metautil;
-const utilities = require('./utilities.js');
-const { oneLine } = utilities;
-const files = require('./files.js');
-const { itemPath, isPathInScope } = files;
-const diff = require('./diff/diff.js');
-const { parseDiff, itemsFromFiles, isCtxType } = diff;
-const deps = require('./deps.js');
-const { foldDepItems } = deps;
+const { delay, jsonParse, isHashObject } = require('metautil');
+const { oneLine, trimText } = require('../common/utilities.js');
+const { itemPath, isPathInScope, ISSUE_FILE } = require('../common/files.js');
+const { parseDiff, itemsFromFiles, isCtxType } = require('../diff/diff.js');
+const { foldDepItems } = require('../deps/deps.js');
 
 const RETRY_ATTEMPTS = 3;
 const RETRY_DELAY_MS = 200;
@@ -62,19 +57,18 @@ class RemoteClient {
     throw this.error('PARSE', `${this.name} API: invalid ${label}`);
   }
 
-  httpError(status, body, token) {
+  httpError(status, body, token, subject = this.subject) {
     const { name, prefix } = this;
-    const text = `${body ?? ''}`.trim();
+    const text = trimText(body);
     const parsed = jsonParse(text);
     const fields = this.errorFields;
     const field = fields.find((key) => typeof parsed?.[key] === 'string');
-    const message =
-      isHashObject(parsed) && field ? parsed[field] : oneLine(text);
+    const fromField = isHashObject(parsed) && field;
+    const message = fromField ? parsed[field] : oneLine(text);
     if (status === 404) {
-      const hint = token
-        ? ''
-        : ` (set ${prefix}_TOKEN for private repositories)`;
-      const notFound = `${name} ${this.subject} not found${hint}`;
+      let hint = '';
+      if (!token) hint = ` (set ${prefix}_TOKEN for private repositories)`;
+      const notFound = `${name} ${subject} not found${hint}`;
       return this.error('NOT_FOUND', notFound, { status });
     }
     if (status === 401) {
@@ -101,18 +95,22 @@ class RemoteClient {
     const init = { method: options.method || 'GET', headers };
     if (options.body !== undefined) init.body = options.body;
     if (signal) init.signal = signal;
-    let response;
-    try {
-      response = await options.fetch(url, init);
-    } catch (cause) {
-      if (isAbortError(cause, signal)) throw cause;
-      const detail = oneLine(cause && cause.message);
-      const suffix = detail ? `: ${detail}` : '';
-      const message = `${this.name} request failed${suffix}`;
-      throw this.error('NETWORK', message, { cause });
-    }
+    const load = async () => {
+      try {
+        return await options.fetch(url, init);
+      } catch (cause) {
+        if (isAbortError(cause, signal)) throw cause;
+        const detail = oneLine(cause && cause.message);
+        const suffix = detail ? `: ${detail}` : '';
+        const message = `${this.name} request failed${suffix}`;
+        throw this.error('NETWORK', message, { cause });
+      }
+    };
+    const response = await load();
     const text = await response.text();
-    if (!response.ok) throw this.httpError(response.status, text, token);
+    if (!response.ok) {
+      throw this.httpError(response.status, text, token, options.subject);
+    }
     return { body: text, headers: response.headers };
   }
 
@@ -183,7 +181,14 @@ const listUrl = (base) => {
   return url.toString();
 };
 
-const commentBody = (value) => `${value ?? ''}`.trim();
+const commentBody = (value) => trimText(value);
+
+const issueText = (title, body) => {
+  const head = trimText(title);
+  const rest = commentBody(body);
+  if (head && rest) return `${head}\n\n${rest}`;
+  return head || rest;
+};
 
 const sideLineNumber = (type, oldNo, newNo, side) => {
   if (side === 'LEFT') return type === 'add' ? 0 : oldNo;
@@ -228,6 +233,21 @@ const importedTodo = (file, entry, host) => ({
   done: entry.resolved === true,
 });
 
+const issueTodoText = (entry, host) => {
+  const reviewer = entry.reviewer || 'unknown';
+  const body = `@${reviewer} at ${host}: ${commentBody(entry.body)}`;
+  const url = trimText(entry.url);
+  if (!url) return body;
+  return `${body}\nIssue: ${url}`;
+};
+
+const issueTodo = (entry, host) => ({
+  kind: 'todo',
+  file: ISSUE_FILE,
+  text: issueTodoText(entry, host),
+  done: entry.resolved === true,
+});
+
 const importedFeedback = (item, path, entry, host) => {
   const hunk = item.hunk;
   return {
@@ -281,17 +301,100 @@ const changeFiles = (items) => {
   return [...rels];
 };
 
+const requestOptions = (options) => ({
+  fetch: options.fetch ?? globalThis.fetch,
+  token: options.token ?? '',
+  retry: options.retry ?? {},
+  signal: options.signal,
+});
+
+const stateIs = (state, name) => `${state ?? ''}`.toLowerCase() === name;
+
+const issueChange = (site, issue) => {
+  const number = issue.number || 0;
+  const tail = number ? `/${number}` : '';
+  return {
+    id: `${site.id}${tail}`,
+    source: 'issue',
+    title: issue.title || '',
+    author: issue.author || '',
+    base: '',
+    head: '',
+    url: issue.url || `${site.page}${tail}`,
+    repository: site.repository,
+    number,
+  };
+};
+
+const issueTasks = (source, issue, url, comments) => {
+  const { host, readComment } = source;
+  const tasks = [];
+  const body = issueText(issue.title, issue.body);
+  if (body) {
+    const resolved = stateIs(issue.state, 'closed');
+    const entry = { reviewer: issue.author, body, resolved, url };
+    tasks.push(issueTodo(entry, host));
+  }
+  for (const comment of comments) {
+    const entry = readComment(comment);
+    if (!entry || !commentBody(entry.body)) continue;
+    tasks.push(issueTodo(entry, host));
+  }
+  return tasks;
+};
+
+const loadIssue = async (ref, options, source) => {
+  const { client, site, issuesUrl, readIssue } = source;
+  const request = { ...requestOptions(options), subject: 'issue' };
+  const readComments = (number) => {
+    const url = `${issuesUrl}/${number}/${source.comments}`;
+    return client.list(listUrl(url), request);
+  };
+  const tasks = [];
+  let change = issueChange(site, {});
+  if (ref.list) {
+    const open = listUrl(`${issuesUrl}?state=${source.openState}`);
+    for (const data of await client.list(open, request)) {
+      if (!source.isOpen(data)) continue;
+      const issue = readIssue(data);
+      const quiet = issue.comments === 0;
+      const comments = quiet ? [] : await readComments(issue.number);
+      const { url } = issueChange(site, issue);
+      tasks.push(...issueTasks(source, issue, url, comments));
+    }
+  } else {
+    const [page, comments] = await Promise.all([
+      client.request(`${issuesUrl}/${ref.number}`, request),
+      readComments(ref.number),
+    ]);
+    const data = client.parseJson(page.body, 'issue payload');
+    const issue = readIssue(data);
+    issue.number ||= ref.number;
+    change = issueChange(site, issue);
+    tasks.push(...issueTasks(source, issue, change.url, comments));
+  }
+  return {
+    top: options.cwd,
+    items: [],
+    sourceLabel: ref.list ? site.repository : `#${change.number}`,
+    change,
+    imported: { feedback: [], tasks },
+  };
+};
+
 const loadChange = async (ref, options, source) => {
   const { client, url, diffUrl = url, diffAccept } = source;
-  const { cwd, paths = [], fetch = globalThis.fetch } = options;
-  const { token = '', retry = {}, signal } = options;
-  const request = { fetch, token, retry, signal };
-  const jsonPage = await client.request(url, request);
+  const { cwd, paths = [], signal } = options;
+  const request = requestOptions(options);
+  const discussion = Promise.resolve().then(() =>
+    source.loadDiscussion(ref, request),
+  );
+  discussion.catch(() => {});
+  const [jsonPage, diffPage] = await Promise.all([
+    client.request(url, request),
+    client.request(diffUrl, { ...request, accept: diffAccept }),
+  ]);
   const data = client.parseJson(jsonPage.body, `${client.subject} payload`);
-  const diffPage = await client.request(diffUrl, {
-    ...request,
-    accept: diffAccept,
-  });
   const files = filterChangeFiles(parseDiff(diffPage.body), paths);
   const items = foldDepItems(itemsFromFiles(files, 'pr'));
   const change = {
@@ -302,8 +405,7 @@ const loadChange = async (ref, options, source) => {
   const sourceLabel = `${source.prefix}${change.number}`;
   let imported = { feedback: [], tasks: [] };
   try {
-    const discussion = await source.loadDiscussion(ref, request);
-    imported = source.discussionToNotes(discussion, items, paths);
+    imported = source.discussionToNotes(await discussion, items, paths);
   } catch (error) {
     if (isAbortError(error, signal)) throw error;
   }
@@ -320,6 +422,8 @@ module.exports = {
   importedTodo,
   noteFromLocation,
   splitNotes,
+  stateIs,
   filterChangeFiles,
+  loadIssue,
   loadChange,
 };

package/lib/source/review-threads.graphql

@@ -0,0 +1,20 @@
+query ($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100, after: $after) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+          isResolved
+          comments(first: 100) {
+            nodes {
+              databaseId
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/lib/source/source.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const github = require('./github.js');
+const gitlab = require('./gitlab.js');
+const { capabilitiesFor, attachCapabilities } = require('./capabilities.js');
+const { parseGithubPrUrl, parseGithubIssueUrl } = github;
+const { parseGithubIssueListUrl } = github;
+const { parseGitlabMrUrl, parseGitlabIssueUrl } = gitlab;
+const { parseGitlabIssueListUrl } = gitlab;
+
+const REMOTE_KINDS = {
+  pr: {
+    option: 'loadPullRequest',
+    load: github.loadPullRequest,
+    token: github.githubToken,
+    target: (selected) => selected.pr,
+  },
+  mr: {
+    option: 'loadMergeRequest',
+    load: gitlab.loadMergeRequest,
+    token: gitlab.gitlabToken,
+    target: (selected) => selected.mr,
+  },
+  issue: {
+    option: 'loadGithubIssue',
+    load: github.loadGithubIssue,
+    token: github.githubToken,
+    target: (selected) => selected.issue,
+  },
+  'gl-issue': {
+    option: 'loadGitlabIssue',
+    load: gitlab.loadGitlabIssue,
+    token: gitlab.gitlabToken,
+    target: (selected) => selected.issue,
+  },
+};
+
+const remoteKind = (selected) => REMOTE_KINDS[selected.kind] ?? null;
+
+const selectChangeSource = (paths) => {
+  if (!paths.length) return { kind: 'local', paths };
+  const first = paths[0];
+  const rest = paths.slice(1);
+  const pr = parseGithubPrUrl(first);
+  if (pr) return { kind: 'pr', pr, paths: rest };
+  const githubIssue = parseGithubIssueUrl(first);
+  if (githubIssue) return { kind: 'issue', issue: githubIssue, paths: rest };
+  const githubIssues = parseGithubIssueListUrl(first);
+  if (githubIssues) return { kind: 'issue', issue: githubIssues, paths: rest };
+  const mr = parseGitlabMrUrl(first);
+  if (mr) return { kind: 'mr', mr, paths: rest };
+  const gitlabIssue = parseGitlabIssueUrl(first);
+  if (gitlabIssue) return { kind: 'gl-issue', issue: gitlabIssue, paths: rest };
+  const gitlabIssues = parseGitlabIssueListUrl(first);
+  if (gitlabIssues) {
+    return { kind: 'gl-issue', issue: gitlabIssues, paths: rest };
+  }
+  return { kind: 'local', paths };
+};
+
+const createLoadedSource = (loaded, kind = 'pr', extra = {}) => {
+  const load = async () => {
+    const items = loaded.items ?? [];
+    return { ...loaded, items: [...items] };
+  };
+  const impl = { load: extra.load ?? load, resolveRev: () => null };
+  return attachCapabilities(impl, capabilitiesFor(kind));
+};
+
+module.exports = {
+  remoteKind,
+  selectChangeSource,
+  createLoadedSource,
+};