reslop 0.2.5 → 0.2.7

package/lib/git.js

@@ -3,47 +3,18 @@
 const capabilities = require('./capabilities.js');
 const { capabilitiesFor, attachCapabilities } = capabilities;
 const worktree = require('./git-worktree.js');
-const { readSnapshot, readSnapshotAsync, toplevel, resolveRev } = worktree;
-const { listScopeFiles, fileText, editItem, writeFile, stagePath } = worktree;
-const { addItem, unstageItem, revertItem, currentBranch } = worktree;
 const branches = require('./git-branches.js');
 const gitDeps = require('./git-deps.js');
 
 const load = (cwd, paths = [], options = {}) => {
-  const snapshot = readSnapshot(cwd, paths, options);
+  const snapshot = worktree.readSnapshot(cwd, paths, options);
   return gitDeps.finishLoad(snapshot, { ...options, paths });
 };
 
 const loadAsync = async (cwd, paths = [], options = {}) => {
-  const snapshot = await readSnapshotAsync(cwd, paths, options);
-  return gitDeps.finishLoad(snapshot, {
-    ...options,
-    paths,
-    deferExtras: options.deferExtras ?? true,
-  });
-};
-
-const addGitItem = (top, item) => {
-  if (item.dep) return gitDeps.addItem(top, item);
-  return addItem(top, item);
-};
-
-const addGitItemAsync = async (top, item) => {
-  if (item.dep) return gitDeps.addItemAsync(top, item);
-  return addItem(top, item);
-};
-
-const unstageGitItem = (top, item) => {
-  if (item.dep) return gitDeps.unstageItem(top, item);
-  return unstageItem(top, item);
-};
-
-const revertGitItem = (top, item) => {
-  if (item.origin === 'commit') return;
-  if (item.dep) {
-    return void gitDeps.revertDepItem(top, item);
-  }
-  revertItem(top, item);
+  const snapshot = await worktree.readSnapshotAsync(cwd, paths, options);
+  const deferExtras = options.deferExtras ?? true;
+  return gitDeps.finishLoad(snapshot, { ...options, paths, deferExtras });
 };
 
 const createGitRepo = () =>
@@ -52,18 +23,18 @@ const createGitRepo = () =>
       load,
       loadAsync,
       loadExtras: gitDeps.loadExtras,
-      toplevel,
-      resolveRev,
-      listFiles: listScopeFiles,
-      fileText,
-      add: addGitItem,
-      addAsync: addGitItemAsync,
-      unstage: unstageGitItem,
-      revert: revertGitItem,
+      toplevel: worktree.toplevel,
+      resolveRev: worktree.resolveRev,
+      listFiles: worktree.listScopeFiles,
+      fileText: worktree.fileText,
+      add: gitDeps.addItem,
+      addAsync: gitDeps.addItemAsync,
+      unstage: gitDeps.unstageItem,
+      revert: gitDeps.revertItem,
       revertFile: gitDeps.revertFile,
-      edit: editItem,
-      writeFile,
-      stagePath,
+      edit: worktree.editItem,
+      writeFile: worktree.writeFile,
+      stagePath: worktree.stagePath,
       commit: branches.commitChanges,
       commitAsync: branches.commitChangesAsync,
       hasStaged: branches.hasStaged,
@@ -71,7 +42,7 @@ const createGitRepo = () =>
       commitMessage: branches.commitMessage,
       listBranches: branches.listBranches,
       listCommits: branches.listCommits,
-      currentBranch,
+      currentBranch: worktree.currentBranch,
       checkout: branches.checkoutBranch,
       checkoutAsync: branches.checkoutBranchAsync,
       createBranch: branches.createBranch,
@@ -95,13 +66,14 @@ const createGitRepo = () =>
   );
 
 module.exports = {
-  ...worktree,
   ...branches,
+  currentBranch: worktree.currentBranch,
+  editItem: worktree.editItem,
   load,
   loadAsync,
   loadExtras: gitDeps.loadExtras,
-  addItem: addGitItem,
-  unstageItem: unstageGitItem,
-  revertItem: revertGitItem,
+  addItem: gitDeps.addItem,
+  unstageItem: gitDeps.unstageItem,
+  revertItem: gitDeps.revertItem,
   createGitRepo,
 };

package/lib/github.js

@@ -1,12 +1,13 @@
 'use strict';
 
+const metautil = require('metautil');
+const { isHashObject } = metautil;
 const files = require('./files.js');
 const { isPathInScope } = files;
 const remote = require('./remote.js');
-const { isRecord, isAbortError } = remote;
-const { createClient, listUrl, parseLinkNext } = remote;
-const { filterChangeFiles, changeFiles, loadChange } = remote;
-const { importedText, importedTodo, noteFromLocation } = remote;
+const { RemoteClient, isAbortError, listUrl, parseLinkNext } = remote;
+const { commentBody, importedTodo, noteFromLocation } = remote;
+const { splitNotes, loadChange } = remote;
 
 const GITHUB_API = 'https://api.github.com';
 const API_VERSION = '2022-11-28';
@@ -34,15 +35,12 @@ const GITHUB_PR_RE = new RegExp(
   'i',
 );
 
-const asRecord = (value) => (isRecord(value) ? value : {});
-
 const parseGithubPrUrl = (text) => {
   if (typeof text !== 'string' || !text) return null;
   const match = GITHUB_PR_RE.exec(text.trim());
   if (!match) return null;
   const owner = match[1];
-  const rawRepo = match[2];
-  const repo = rawRepo.replace(/\.git$/i, '');
+  const repo = match[2].replace(/\.git$/i, '');
   const number = parseInt(match[3], 10);
   const hasNumber = Number.isFinite(number) && number >= 1;
   if (!owner || !repo || !hasNumber) return null;
@@ -64,29 +62,12 @@ const githubHeaders = (token, accept = JSON_ACCEPT) => {
   return { ...headers, Authorization: `Bearer ${token}` };
 };
 
-const client = createClient({
+const client = new RemoteClient({
   name: 'GitHub',
   subject: 'pull request',
   headers: githubHeaders,
   nextPage: parseLinkNext,
 });
-const {
-  request: requestGithub,
-  list: requestGithubList,
-  parseJson: parseGithubJson,
-} = client;
-
-const requestGraphql = async (query, variables, options) => {
-  const payload = JSON.stringify({ query, variables });
-  const page = await requestGithub(GRAPHQL_URL, {
-    ...options,
-    method: 'POST',
-    accept: JSON_ACCEPT,
-    contentType: 'application/json',
-    body: payload,
-  });
-  return parseGithubJson(page.body, 'GraphQL payload');
-};
 
 const prApiUrl = (pr) => {
   const owner = encodeURIComponent(pr.owner);
@@ -94,213 +75,120 @@ const prApiUrl = (pr) => {
   return `${GITHUB_API}/repos/${owner}/${repo}/pulls/${pr.number}`;
 };
 
-const discussionUrls = (pr) => {
-  const pull = prApiUrl(pr);
-  const issue = pull.replace('/pulls/', '/issues/');
-  return {
-    reviewComments: listUrl(`${pull}/comments`),
-    reviews: listUrl(`${pull}/reviews`),
-    issueComments: listUrl(`${issue}/comments`),
-  };
-};
-
-const readLogin = (user) => {
-  if (!isRecord(user)) return '';
-  return user.login || '';
-};
-
-const readRef = (side) => {
-  if (!isRecord(side)) return '';
-  return side.ref || '';
-};
+const loginOf = (user) => user?.login || '';
 
-const readRepoName = (data, pr) => {
-  const base = isRecord(data.base) ? data.base : null;
-  const repo = base && isRecord(base.repo) ? base.repo : null;
-  const fromBase = repo && repo['full_name'];
-  if (fromBase) return fromBase;
-  return `${pr.owner}/${pr.repo}`;
-};
-
-const toChange = (pr, data, items) => {
+const toChange = (pr, data) => {
   const number = data.number || pr.number;
-  const repository = readRepoName(data, pr);
-  const title = data.title || '';
-  const author = readLogin(data.user);
-  const files = changeFiles(items);
-  const base = readRef(data.base);
-  const head = readRef(data.head);
+  const fullName = data.base?.repo?.['full_name'];
+  const repository = fullName || `${pr.owner}/${pr.repo}`;
   const fallbackUrl = `https://github.com/${repository}/pull/${number}`;
-  const url = data['html_url'] || fallbackUrl;
-  const id = `github.com/${repository}/pull/${number}`;
   return {
-    id,
+    id: `github.com/${repository}/pull/${number}`,
     source: 'pr',
-    title,
-    author,
-    files,
-    status: 'reviewing',
-    base,
-    head,
-    url,
+    title: data.title || '',
+    author: loginOf(data.user),
+    base: data.base?.ref || '',
+    head: data.head?.ref || '',
+    url: data['html_url'] || fallbackUrl,
     repository,
     number,
   };
 };
 
-const readCommentBody = (value) => `${value ?? ''}`.trim();
-
-const reviewerOf = (record) => {
-  const login = readLogin(record && record.user);
-  return login || 'unknown';
-};
-
-const formatImportedText = (entry) => importedText(entry, IMPORT_HOST);
-
 const commentLine = (comment) => {
   const side = comment.side === 'LEFT' ? 'LEFT' : 'RIGHT';
-  const raw = comment.line ?? comment['original_line'];
-  const line = Number(raw);
+  const line = Number(comment.line ?? comment['original_line']);
   if (!Number.isFinite(line) || line < 1) return { side, line: 0 };
   return { side, line };
 };
 
-const resolvedOf = (resolvedById, id) => {
-  const commentId = Number(id);
-  if (!Number.isFinite(commentId) || !resolvedById.has(commentId)) {
-    return null;
-  }
-  return resolvedById.get(commentId);
-};
-
 const reviewCommentToNote = (comment, items, resolvedById, paths) => {
-  if (!isRecord(comment)) return null;
-  const body = readCommentBody(comment.body);
+  if (!isHashObject(comment)) return null;
+  const body = commentBody(comment.body);
   if (!body) return null;
   const path = comment.path || '';
   if (path && !isPathInScope(path, paths)) return null;
-  const { side, line } = commentLine(comment);
-  const resolved = resolvedOf(resolvedById, comment.id);
-  const entry = {
-    reviewer: reviewerOf(comment),
-    body,
-    resolved,
-  };
-  const subject = comment['subject_type'] || 'line';
-  if (subject === 'file') {
-    if (path) return importedTodo(path, entry, IMPORT_HOST);
-    return importedTodo(PR_TODO_FILE, entry, IMPORT_HOST);
+  const resolved = resolvedById.get(Number(comment.id)) ?? null;
+  const entry = { reviewer: loginOf(comment.user), body, resolved };
+  if (comment['subject_type'] === 'file') {
+    return importedTodo(path || PR_TODO_FILE, entry, IMPORT_HOST);
   }
-  return noteFromLocation(
-    items,
-    { path, line, side },
-    entry,
-    IMPORT_HOST,
-    PR_TODO_FILE,
-  );
+  const { side, line } = commentLine(comment);
+  const loc = { path, line, side };
+  return noteFromLocation(items, loc, entry, IMPORT_HOST, PR_TODO_FILE);
 };
 
 const summaryToTodo = (record) => {
-  if (!isRecord(record)) return null;
-  const body = readCommentBody(record.body);
+  if (!isHashObject(record)) return null;
+  const body = commentBody(record.body);
   if (!body) return null;
-  return importedTodo(
-    PR_TODO_FILE,
-    {
-      reviewer: reviewerOf(record),
-      body,
-    },
-    IMPORT_HOST,
-  );
+  const entry = { reviewer: loginOf(record.user), body };
+  return importedTodo(PR_TODO_FILE, entry, IMPORT_HOST);
 };
 
 const discussionToNotes = (discussion, items, paths = []) => {
-  const feedback = [];
-  const tasks = [];
   const resolvedById = discussion.resolvedById ?? new Map();
-  const reviewComments = discussion.reviewComments ?? [];
-  for (const comment of reviewComments) {
-    const note = reviewCommentToNote(comment, items, resolvedById, paths);
-    if (!note) continue;
-    if (note.kind === 'feedback') feedback.push(note);
-    else tasks.push(note);
-  }
+  const comments = discussion.reviewComments ?? [];
   const reviews = discussion.reviews ?? [];
-  for (const review of reviews) {
-    const task = summaryToTodo(review);
-    if (task) tasks.push(task);
-  }
   const issueComments = discussion.issueComments ?? [];
-  for (const comment of issueComments) {
-    const task = summaryToTodo(comment);
-    if (task) tasks.push(task);
-  }
-  return { feedback, tasks };
+  return splitNotes([
+    ...comments.map((comment) =>
+      reviewCommentToNote(comment, items, resolvedById, paths),
+    ),
+    ...[...reviews, ...issueComments].map((record) => summaryToTodo(record)),
+  ]);
+};
+
+const requestThreads = async (variables, options) => {
+  const page = await client.request(GRAPHQL_URL, {
+    ...options,
+    method: 'POST',
+    accept: JSON_ACCEPT,
+    contentType: 'application/json',
+    body: JSON.stringify({ query: REVIEW_THREADS_QUERY, variables }),
+  });
+  const payload = client.parseJson(page.body, 'GraphQL payload');
+  return payload.data?.repository?.pullRequest?.reviewThreads;
 };
 
 const loadReviewThreads = async (pr, options) => {
   const threads = [];
   let after = null;
   for (;;) {
-    const payload = await requestGraphql(
-      REVIEW_THREADS_QUERY,
-      {
-        owner: pr.owner,
-        name: pr.repo,
-        number: pr.number,
-        after,
-      },
-      options,
-    );
-    if (!isRecord(payload.data)) return threads;
-    const data = payload.data;
-    const repository = asRecord(data.repository);
-    const pullRequest = asRecord(repository.pullRequest);
-    const reviewThreads = asRecord(pullRequest.reviewThreads);
-    const nodes = Array.isArray(reviewThreads.nodes) ? reviewThreads.nodes : [];
-    for (const thread of nodes) threads.push(thread);
-    const pageInfo = asRecord(reviewThreads.pageInfo);
-    if (!pageInfo.hasNextPage) return threads;
-    const cursor = pageInfo.endCursor || null;
+    const variables = { owner: pr.owner, name: pr.repo, number: pr.number };
+    const page = await requestThreads({ ...variables, after }, options);
+    if (Array.isArray(page?.nodes)) threads.push(...page.nodes);
+    const pageInfo = page?.pageInfo;
+    const cursor = pageInfo?.hasNextPage ? pageInfo.endCursor : null;
     if (!cursor || cursor === after) return threads;
     after = cursor;
   }
 };
 
-const threadComments = (thread) => {
-  if (!isRecord(thread)) return [];
-  const comments = thread.comments;
-  if (isRecord(comments) && Array.isArray(comments.nodes)) {
-    return comments.nodes;
-  }
-  return [];
-};
-
 const loadResolvedById = async (pr, options) => {
   const resolved = new Map();
   try {
-    const threads = await loadReviewThreads(pr, options);
-    for (const thread of threads) {
-      const isResolved = thread.isResolved === true;
-      for (const comment of threadComments(thread)) {
-        if (!isRecord(comment)) continue;
-        const id = Number(comment.databaseId);
-        if (!Number.isFinite(id)) continue;
-        resolved.set(id, isResolved);
+    for (const thread of await loadReviewThreads(pr, options)) {
+      const comments = thread?.comments?.nodes;
+      if (!Array.isArray(comments)) continue;
+      for (const comment of comments) {
+        const id = Number(comment?.databaseId);
+        if (Number.isFinite(id)) resolved.set(id, thread.isResolved === true);
       }
     }
   } catch (error) {
     if (isAbortError(error, options.signal)) throw error;
-    // ignore: resolved state is optional
   }
   return resolved;
 };
 
 const loadDiscussion = async (pr, options) => {
-  const urls = discussionUrls(pr);
-  const reviewComments = await requestGithubList(urls.reviewComments, options);
-  const reviews = await requestGithubList(urls.reviews, options);
-  const issueComments = await requestGithubList(urls.issueComments, options);
+  const pull = prApiUrl(pr);
+  const issue = pull.replace('/pulls/', '/issues/');
+  const list = (url) => client.list(listUrl(url), options);
+  const reviewComments = await list(`${pull}/comments`);
+  const reviews = await list(`${pull}/reviews`);
+  const issueComments = await list(`${issue}/comments`);
   const resolvedById = await loadResolvedById(pr, options);
   return { reviewComments, reviews, issueComments, resolvedById };
 };
@@ -319,9 +207,7 @@ const loadPullRequest = (pr, options = {}) =>
 module.exports = {
   parseGithubPrUrl,
   githubToken,
-  filterChangeFiles,
   prApiUrl,
-  formatImportedText,
   discussionToNotes,
   loadPullRequest,
 };

package/lib/gitlab.js

@@ -1,18 +1,19 @@
 'use strict';
 
+const metautil = require('metautil');
+const { isHashObject } = metautil;
 const files = require('./files.js');
 const { isPathInScope } = files;
 const remote = require('./remote.js');
-const { isRecord } = remote;
-const { createClient, listUrl, parseNextPage } = remote;
-const { filterChangeFiles, changeFiles, loadChange } = remote;
-const { importedText, importedTodo, noteFromLocation } = remote;
+const { RemoteClient, listUrl, parseNextPage, commentBody } = remote;
+const { importedTodo, noteFromLocation, splitNotes, loadChange } = remote;
 
 const USER_AGENT = 'reslop';
 const JSON_ACCEPT = 'application/json';
 const DIFF_ACCEPT = 'text/plain';
 const MR_TODO_FILE = 'merge request';
 const IMPORT_HOST = 'gitlab';
+const NO_LINE = { side: 'RIGHT', line: 0 };
 
 const GITLAB_MR_RE = new RegExp(
   String.raw`^(?:(https?)://)?(?:www\.)?([^/?#]+)/` +
@@ -29,13 +30,11 @@ const parseGitlabMrUrl = (text) => {
   if (!match) return null;
   const scheme = (match[1] || 'https').toLowerCase();
   const host = match[2];
-  const rawProject = match[3];
-  const project = rawProject.replace(/\.git$/i, '');
+  const project = match[3].replace(/\.git$/i, '');
   const number = parseInt(match[4], 10);
   const hasNumber = Number.isFinite(number) && number >= 1;
   if (!host || !project || !hasNumber) return null;
-  const origin = `${scheme}://${host}`;
-  return { host, project, number, origin };
+  return { host, project, number, origin: `${scheme}://${host}` };
 };
 
 const gitlabToken = (env) => {
@@ -44,84 +43,54 @@ const gitlabToken = (env) => {
 };
 
 const gitlabHeaders = (token, accept = JSON_ACCEPT) => {
-  const headers = {
-    Accept: accept,
-    'User-Agent': USER_AGENT,
-  };
+  const headers = { Accept: accept, 'User-Agent': USER_AGENT };
   if (!token) return headers;
   return { ...headers, 'PRIVATE-TOKEN': token };
 };
 
-const client = createClient({
+const client = new RemoteClient({
   name: 'GitLab',
   subject: 'merge request',
   headers: gitlabHeaders,
   nextPage: parseNextPage,
+  errorFields: ['message', 'error'],
+  limitStatus: 429,
 });
-const { list: requestGitlabList } = client;
 
 const mrApiUrl = (mr) => {
   const project = encodeURIComponent(mr.project);
-  const base = `${mr.origin}/api/v4/projects/${project}`;
-  return `${base}/merge_requests/${mr.number}`;
+  return `${mr.origin}/api/v4/projects/${project}/merge_requests/${mr.number}`;
 };
 
-const readUsername = (user) => {
-  if (!isRecord(user)) return '';
-  return user.username || '';
-};
+const usernameOf = (user) => user?.username || '';
 
 const readProject = (data, mr) => {
-  const refs = isRecord(data.references) ? data.references : null;
-  const full = refs && refs.full;
-  if (typeof full === 'string') {
-    const cut = full.lastIndexOf('!');
-    if (cut > 0) return full.slice(0, cut);
-  }
-  return mr.project;
+  const full = data.references?.full;
+  const cut = typeof full === 'string' ? full.lastIndexOf('!') : -1;
+  return cut > 0 ? full.slice(0, cut) : mr.project;
 };
 
-const toChange = (mr, data, items) => {
+const toChange = (mr, data) => {
   const number = data.iid || mr.number;
   const repository = readProject(data, mr);
-  const title = data.title || '';
-  const author = readUsername(data.author);
-  const files = changeFiles(items);
-  const base = data.target_branch || '';
-  const head = data.source_branch || '';
   const fallbackUrl = `${mr.origin}/${repository}/-/merge_requests/${number}`;
-  const url = data.web_url || fallbackUrl;
-  const id = `${mr.host}/${repository}/merge_requests/${number}`;
   return {
-    id,
+    id: `${mr.host}/${repository}/merge_requests/${number}`,
     source: 'mr',
-    title,
-    author,
-    files,
-    status: 'reviewing',
-    base,
-    head,
-    url,
+    title: data.title || '',
+    author: usernameOf(data.author),
+    base: data.target_branch || '',
+    head: data.source_branch || '',
+    url: data.web_url || fallbackUrl,
     repository,
     number,
   };
 };
 
-const readCommentBody = (value) => `${value ?? ''}`.trim();
-
-const reviewerOf = (record) => {
-  const login = readUsername(record && record.author);
-  return login || 'unknown';
-};
-
-const formatImportedText = (entry) => importedText(entry, IMPORT_HOST);
-
 const noteLine = (position) => {
-  if (!isRecord(position)) return { side: 'RIGHT', line: 0 };
+  if (!position) return NO_LINE;
   const kind = position.position_type || 'text';
-  if (kind === 'file' || kind === 'image') {
-    return { side: 'RIGHT', line: 0 };
-  }
+  if (kind === 'file' || kind === 'image') return NO_LINE;
   const newLine = Number(position.new_line);
   if (Number.isFinite(newLine) && newLine >= 1) {
     return { side: 'RIGHT', line: newLine };
@@ -130,56 +99,39 @@ const noteLine = (position) => {
   if (Number.isFinite(oldLine) && oldLine >= 1) {
     return { side: 'LEFT', line: oldLine };
   }
-  return { side: 'RIGHT', line: 0 };
+  return NO_LINE;
 };
 
 const noteToImported = (note, items, paths) => {
-  if (!isRecord(note) || note.system === true) return null;
-  const body = readCommentBody(note.body);
+  if (!isHashObject(note) || note.system === true) return null;
+  const body = commentBody(note.body);
   if (!body) return null;
   const resolved = note.resolved === true;
-  const entry = {
-    reviewer: reviewerOf(note),
-    body,
-    resolved,
-  };
+  const entry = { reviewer: usernameOf(note.author), body, resolved };
   if (note.type !== 'DiffNote') {
     return importedTodo(MR_TODO_FILE, entry, IMPORT_HOST);
   }
-  const position = isRecord(note.position) ? note.position : null;
+  const position = isHashObject(note.position) ? note.position : null;
   const path = position ? position.new_path || position.old_path || '' : '';
   if (path && !isPathInScope(path, paths)) return null;
   const { side, line } = noteLine(position);
-  return noteFromLocation(
-    items,
-    { path, line, side },
-    entry,
-    IMPORT_HOST,
-    MR_TODO_FILE,
-  );
+  const loc = { path, line, side };
+  return noteFromLocation(items, loc, entry, IMPORT_HOST, MR_TODO_FILE);
 };
 
 const discussionToNotes = (discussions, items, paths = []) => {
-  const feedback = [];
-  const tasks = [];
-  const threads = discussions ?? [];
-  for (const discussion of threads) {
-    if (!isRecord(discussion)) continue;
-    const notes = Array.isArray(discussion.notes) ? discussion.notes : [];
-    for (const note of notes) {
-      const mapped = noteToImported(note, items, paths);
-      if (!mapped) continue;
-      if (mapped.kind === 'feedback') feedback.push(mapped);
-      else tasks.push(mapped);
+  const notes = [];
+  for (const discussion of discussions ?? []) {
+    if (!Array.isArray(discussion?.notes)) continue;
+    for (const note of discussion.notes) {
+      notes.push(noteToImported(note, items, paths));
     }
   }
-  return { feedback, tasks };
+  return splitNotes(notes);
 };
 
-const loadDiscussion = async (mr, options) => {
-  const url = listUrl(`${mrApiUrl(mr)}/discussions`);
-  return requestGitlabList(url, options);
-};
+const loadDiscussion = (mr, options) =>
+  client.list(listUrl(`${mrApiUrl(mr)}/discussions`), options);
 
 const loadMergeRequest = (mr, options = {}) => {
   const url = mrApiUrl(mr);
@@ -198,9 +150,7 @@ const loadMergeRequest = (mr, options = {}) => {
 module.exports = {
   parseGitlabMrUrl,
   gitlabToken,
-  filterChangeFiles,
   mrApiUrl,
-  formatImportedText,
   discussionToNotes,
   loadMergeRequest,
 };