@rawdash/connector-github 0.15.0 → 0.16.0

package/dist/index.js

@@ -1,21 +1,62 @@
 // ../../connector-shared/dist/index.js
 var HTTP_CLIENT_VERSION = "0.0.0";
 var DEFAULT_USER_AGENT = `rawdash-connector/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;
-var githubRateLimit = {
-  parse(h) {
-    const remainingRaw = h.get("x-ratelimit-remaining");
-    const resetRaw = h.get("x-ratelimit-reset");
-    if (remainingRaw === null || resetRaw === null) {
-      return null;
+function connectorUserAgent(connectorId) {
+  return `rawdash-connector-${connectorId}/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;
+}
+function standardRateLimitPolicy(config) {
+  const { remainingHeader, resetHeader, resetUnit, resetFallbackMs } = config;
+  const multiplier = resetUnit === "s" ? 1e3 : 1;
+  return {
+    parse(h) {
+      const remainingRaw = h.get(remainingHeader);
+      if (remainingRaw === null || remainingRaw.trim() === "") {
+        return null;
+      }
+      const remaining = Number(remainingRaw);
+      if (!Number.isFinite(remaining)) {
+        return null;
+      }
+      const resetRaw = h.get(resetHeader);
+      if (resetRaw === null) {
+        if (resetFallbackMs === void 0) {
+          return null;
+        }
+        return {
+          remaining,
+          resetAt: new Date(Date.now() + resetFallbackMs)
+        };
+      }
+      if (resetRaw.trim() === "") {
+        return null;
+      }
+      const reset = Number(resetRaw);
+      if (!Number.isFinite(reset) || reset < 0) {
+        return null;
+      }
+      const resetMs = reset * multiplier;
+      if (!Number.isFinite(resetMs)) {
+        return null;
+      }
+      return { remaining, resetAt: new Date(resetMs) };
     }
-    const remaining = Number(remainingRaw);
-    const reset = Number(resetRaw);
-    if (!Number.isFinite(remaining) || !Number.isFinite(reset) || reset < 0) {
+  };
+}
+function sanitizeAllowedUrl(options) {
+  const { url, host, pathname, protocol = "https:" } = options;
+  if (url === null) {
+    return null;
+  }
+  try {
+    const u = new URL(url);
+    if (u.protocol !== protocol || u.host !== host || u.pathname !== pathname) {
       return null;
     }
-    return { remaining, resetAt: new Date(reset * 1e3) };
+    return u.toString();
+  } catch {
+    return null;
   }
-};
+}
 function parseLinkHeader(header) {
   if (!header) {
     return {};
@@ -34,7 +75,11 @@ function parseLinkHeader(header) {
 import {
   BaseConnector,
   defineConfigFields,
-  paginateChunked
+  defineConnectorDoc,
+  defineResources,
+  makeChunkedCursorGuard,
+  paginateChunked,
+  schemasFromResources
 } from "@rawdash/core";
 import { z } from "zod";
 var configFields = defineConfigFields(
@@ -56,12 +101,41 @@ var configFields = defineConfigFields(
     })
   })
 );
+var doc = defineConnectorDoc({
+  displayName: "GitHub",
+  category: "engineering",
+  brandColor: "#181717",
+  tagline: "Sync pull requests, issues, deployments, releases, CI runs, and contributor activity from a GitHub repository.",
+  vendor: {
+    name: "GitHub",
+    apiDocs: "https://docs.github.com/rest",
+    website: "https://github.com"
+  },
+  auth: {
+    summary: "A personal access token is optional for public repositories but required for private repos and to avoid the low unauthenticated rate limit.",
+    setup: [
+      "Open GitHub \u2192 Settings \u2192 Developer settings \u2192 Personal access tokens.",
+      "Generate a token with the `repo` scope (read access is sufficient).",
+      'Store it as a secret and reference it from the connector config as `token: secret("GITHUB_TOKEN")`.'
+    ]
+  },
+  rateLimit: "Unauthenticated requests share GitHub\u2019s low 60 requests/hour limit; an authenticated token raises it to 5,000 requests/hour.",
+  limitations: [
+    "The GitHub REST API can return the same item more than once within a sync (cursor pagination overlapping a mutating collection, retried requests, or an item surfaced via multiple endpoints). Each resource dedupes by stable id before writing, keeping the last copy seen.",
+    "Public repositories without a token are subject to GitHub\u2019s low unauthenticated rate limit."
+  ]
+});
 var githubCredentials = {
   token: {
     description: "GitHub personal access token",
     auth: "optional"
   }
 };
+var githubRateLimit = standardRateLimitPolicy({
+  remainingHeader: "x-ratelimit-remaining",
+  resetHeader: "x-ratelimit-reset",
+  resetUnit: "s"
+});
 var PHASE_ORDER = [
   "repo_stats",
   "workflow_runs",
@@ -71,6 +145,23 @@ var PHASE_ORDER = [
   "releases",
   "contributors"
 ];
+var PHASE_RESOURCES = {
+  repo_stats: ["repo"],
+  workflow_runs: ["workflow_run"],
+  pull_requests: ["pull_request"],
+  issues: ["issue"],
+  deployments: ["deployment"],
+  releases: ["release"],
+  contributors: ["contributor"]
+};
+function selectPhases(allowlist) {
+  if (allowlist === void 0) {
+    return PHASE_ORDER;
+  }
+  return PHASE_ORDER.filter(
+    (phase) => PHASE_RESOURCES[phase].some((r) => allowlist.has(r))
+  );
+}
 var CONTRIBUTORS_SKIPPED = /* @__PURE__ */ Symbol("contributors-skipped");
 function dedupeByKey(items, keyFn, resource) {
   if (items.length < 2) {
@@ -92,23 +183,9 @@ function dedupeByKey(items, keyFn, resource) {
   }
   return Array.from(seen.values());
 }
-function isGitHubSyncCursor(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const v = value;
-  if (typeof v.phase !== "string") {
-    return false;
-  }
-  if (!PHASE_ORDER.includes(v.phase)) {
-    return false;
-  }
-  if (v.page !== null && typeof v.page !== "string") {
-    return false;
-  }
-  return true;
-}
+var isGitHubSyncCursor = makeChunkedCursorGuard(PHASE_ORDER);
 var workflowRunsResponseSchema = z.object({
+  total_count: z.number().int().optional(),
   workflow_runs: z.array(
     z.object({
       id: z.number().int(),
@@ -119,7 +196,33 @@ var workflowRunsResponseSchema = z.object({
       actor: z.object({ login: z.string().min(1) }).nullable(),
       created_at: z.iso.datetime(),
       updated_at: z.iso.datetime(),
-      run_attempt: z.number().int()
+      run_attempt: z.number().int(),
+      artifacts_url: z.string().optional(),
+      cancel_url: z.string().optional(),
+      check_suite_id: z.number().int().optional(),
+      check_suite_node_id: z.string().optional(),
+      check_suite_url: z.string().optional(),
+      display_title: z.string().optional(),
+      event: z.string().optional(),
+      head_commit: z.unknown().optional(),
+      head_repository: z.unknown().optional(),
+      head_sha: z.string().optional(),
+      html_url: z.string().optional(),
+      jobs_url: z.string().optional(),
+      logs_url: z.string().optional(),
+      node_id: z.string().optional(),
+      path: z.string().optional(),
+      previous_attempt_url: z.string().nullable().optional(),
+      pull_requests: z.array(z.unknown()).optional(),
+      referenced_workflows: z.array(z.unknown()).optional(),
+      repository: z.unknown().optional(),
+      rerun_url: z.string().optional(),
+      run_number: z.number().int().optional(),
+      run_started_at: z.iso.datetime().optional(),
+      triggering_actor: z.object({ login: z.string().min(1) }).optional(),
+      url: z.string().optional(),
+      workflow_id: z.number().int().optional(),
+      workflow_url: z.string().optional()
     })
   )
 });
@@ -129,9 +232,58 @@ var pullRequestsSchema = z.array(
     title: z.string(),
     state: z.string(),
     draft: z.boolean(),
-    user: z.object({ login: z.string().min(1) }),
+    user: z.object({
+      login: z.string().min(1),
+      avatar_url: z.string().optional(),
+      events_url: z.string().optional(),
+      followers_url: z.string().optional(),
+      following_url: z.string().optional(),
+      gists_url: z.string().optional(),
+      gravatar_id: z.string().nullable().optional(),
+      html_url: z.string().optional(),
+      id: z.number().int().optional(),
+      node_id: z.string().optional(),
+      organizations_url: z.string().optional(),
+      received_events_url: z.string().optional(),
+      repos_url: z.string().optional(),
+      site_admin: z.boolean().optional(),
+      starred_url: z.string().optional(),
+      subscriptions_url: z.string().optional(),
+      type: z.string().optional(),
+      url: z.string().optional(),
+      user_view_type: z.string().optional()
+    }),
     created_at: z.iso.datetime(),
-    updated_at: z.iso.datetime()
+    updated_at: z.iso.datetime(),
+    _links: z.unknown().optional(),
+    active_lock_reason: z.string().nullable().optional(),
+    assignee: z.unknown().optional(),
+    assignees: z.unknown().optional(),
+    author_association: z.string().optional(),
+    auto_merge: z.unknown().optional(),
+    base: z.unknown().optional(),
+    body: z.string().nullable().optional(),
+    closed_at: z.string().nullable().optional(),
+    comments_url: z.string().optional(),
+    commits_url: z.string().optional(),
+    diff_url: z.string().optional(),
+    head: z.unknown().optional(),
+    html_url: z.string().optional(),
+    id: z.number().int().optional(),
+    issue_url: z.string().optional(),
+    labels: z.unknown().optional(),
+    locked: z.boolean().optional(),
+    merge_commit_sha: z.string().nullable().optional(),
+    merged_at: z.string().nullable().optional(),
+    milestone: z.unknown().optional(),
+    node_id: z.string().optional(),
+    patch_url: z.string().optional(),
+    requested_reviewers: z.unknown().optional(),
+    requested_teams: z.unknown().optional(),
+    review_comment_url: z.string().optional(),
+    review_comments_url: z.string().optional(),
+    statuses_url: z.string().optional(),
+    url: z.string().optional()
   })
 );
 var reviewsSchema = z.array(
@@ -148,10 +300,34 @@ var issuesSchema = z.array(
     state: z.string(),
     labels: z.array(z.object({ name: z.string() })),
     assignees: z.array(z.object({ login: z.string().min(1) })),
-    user: z.object({ login: z.string().min(1) }),
+    user: z.object({ login: z.string().min(1) }).catchall(z.unknown()),
     created_at: z.iso.datetime(),
     updated_at: z.iso.datetime(),
-    closed_at: z.iso.datetime().nullable()
+    closed_at: z.iso.datetime().nullable(),
+    pull_request: z.unknown().optional(),
+    active_lock_reason: z.unknown().optional(),
+    assignee: z.unknown().optional(),
+    author_association: z.string().optional(),
+    body: z.string().nullable().optional(),
+    closed_by: z.unknown().optional(),
+    comments: z.number().int().optional(),
+    comments_url: z.string().optional(),
+    draft: z.boolean().optional(),
+    events_url: z.string().optional(),
+    html_url: z.string().optional(),
+    id: z.number().int().optional(),
+    issue_field_values: z.unknown().optional(),
+    labels_url: z.string().optional(),
+    locked: z.boolean().optional(),
+    milestone: z.unknown().optional(),
+    node_id: z.string().optional(),
+    performed_via_github_app: z.unknown().optional(),
+    reactions: z.unknown().optional(),
+    repository_url: z.string().optional(),
+    state_reason: z.unknown().optional(),
+    timeline_url: z.string().optional(),
+    type: z.unknown().optional(),
+    url: z.string().optional()
   })
 );
 var deploymentsSchema = z.array(
@@ -201,19 +377,62 @@ var repoStatsSchema = z.object({
   forks_count: z.number().int(),
   subscribers_count: z.number().int()
 });
+var githubResources = defineResources({
+  repo: {
+    shape: "entity",
+    description: "Top-level repository stats (stars, forks, and watchers) as a single entity.",
+    endpoint: "GET /repos/{owner}/{repo}",
+    responses: { repo: repoStatsSchema }
+  },
+  workflow_run: {
+    shape: "event",
+    description: "GitHub Actions CI pipeline executions.",
+    endpoint: "GET /repos/{owner}/{repo}/actions/runs",
+    responses: { workflow_runs: workflowRunsResponseSchema }
+  },
+  pull_request: {
+    shape: "entity",
+    description: "Open and closed pull requests, including draft state, author, and review state.",
+    endpoint: "GET /repos/{owner}/{repo}/pulls",
+    notes: "Review state is folded in from GET /repos/{owner}/{repo}/pulls/{number}/reviews per PR.",
+    responses: {
+      pull_requests: pullRequestsSchema,
+      pull_request_reviews: reviewsSchema
+    }
+  },
+  issue: {
+    shape: "entity",
+    description: "Open and closed issues with labels, assignees, and author (pull requests excluded).",
+    endpoint: "GET /repos/{owner}/{repo}/issues",
+    responses: { issues: issuesSchema }
+  },
+  deployment: {
+    shape: "entity",
+    description: "Deployments with their latest status, keyed by environment and ref.",
+    endpoint: "GET /repos/{owner}/{repo}/deployments",
+    notes: "The latest status is folded in from GET /repos/{owner}/{repo}/deployments/{id}/statuses.",
+    responses: {
+      deployments: deploymentsSchema,
+      deployment_statuses: deploymentStatusesSchema
+    }
+  },
+  release: {
+    shape: "entity",
+    description: "Published, draft, and prerelease GitHub releases.",
+    endpoint: "GET /repos/{owner}/{repo}/releases",
+    responses: { releases: releasesSchema }
+  },
+  contributor: {
+    shape: "entity",
+    description: "Per-author commit activity (commits, additions, deletions) for the repository.",
+    endpoint: "GET /repos/{owner}/{repo}/stats/contributors",
+    responses: { contributors: contributorsSchema }
+  }
+});
 var GitHubConnector = class _GitHubConnector extends BaseConnector {
   static id = "github-actions";
-  static schemas = {
-    repo: repoStatsSchema,
-    workflow_runs: workflowRunsResponseSchema,
-    pull_requests: pullRequestsSchema,
-    pull_request_reviews: reviewsSchema,
-    issues: issuesSchema,
-    deployments: deploymentsSchema,
-    deployment_statuses: deploymentStatusesSchema,
-    releases: releasesSchema,
-    contributors: contributorsSchema
-  };
+  static resources = githubResources;
+  static schemas = schemasFromResources(githubResources);
   static create(input, ctx) {
     const parsed = configFields.parse(input);
     return new _GitHubConnector(
@@ -225,11 +444,12 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
   id = "github-actions";
   credentials = githubCredentials;
   seenWorkflowRunIds = /* @__PURE__ */ new Set();
+  preservedDeploymentStatus = /* @__PURE__ */ new Map();
   buildHeaders() {
     const headers = {
       Accept: "application/vnd.github+json",
       "X-GitHub-Api-Version": "2022-11-28",
-      "User-Agent": "rawdash/connector-github (+https://rawdash.dev)"
+      "User-Agent": connectorUserAgent("github")
     };
     if (this.creds.token) {
       headers["Authorization"] = `Bearer ${this.creds.token}`;
@@ -263,22 +483,21 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
     }
   }
   sanitizePageUrl(phase, pageUrl) {
-    if (pageUrl === null) {
-      return null;
-    }
     const allowedPath = this.allowedPageBasePath(phase);
     if (allowedPath === null) {
       return null;
     }
-    try {
-      const u = new URL(pageUrl);
-      if (u.protocol !== "https:" || u.host !== "api.github.com" || u.pathname !== allowedPath) {
-        return null;
-      }
-      return u.toString();
-    } catch {
-      return null;
+    return sanitizeAllowedUrl({
+      url: pageUrl,
+      host: "api.github.com",
+      pathname: allowedPath
+    });
+  }
+  isResourceAllowed(options, resource) {
+    if (!options.resources) {
+      return true;
     }
+    return options.resources.has(resource);
   }
   resolveCursor(cursor) {
     if (!isGitHubSyncCursor(cursor)) {
@@ -334,24 +553,30 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
       next: cutoffReached ? null : nextLink
     };
   }
-  async fetchPullRequests(page, signal) {
+  async fetchPullRequests(options, page, signal) {
     const { owner, repo } = this.settings;
-    const url = page ?? `https://api.github.com/repos/${owner}/${repo}/pulls?state=all&per_page=100`;
+    const url = page ?? `https://api.github.com/repos/${owner}/${repo}/pulls?state=all&sort=updated&direction=desc&per_page=100`;
     const res = await this.fetch(url, "pull_requests", signal);
     const nextLink = parseLinkHeader(res.headers.get("link"))["next"] ?? null;
     const prs = res.body;
+    const cutoff = options.since ? new Date(options.since).getTime() : null;
+    const filteredPrs = cutoff !== null ? prs.filter((pr) => new Date(pr.updated_at).getTime() >= cutoff) : prs;
+    const lastPr = prs.at(-1);
+    const cutoffReached = cutoff !== null && lastPr !== void 0 && new Date(lastPr.updated_at).getTime() < cutoff;
     const reviewsByPR = /* @__PURE__ */ new Map();
-    for (const pr of prs) {
-      signal?.throwIfAborted();
-      const reviews = await this.fetch(
-        `https://api.github.com/repos/${owner}/${repo}/pulls/${pr.number}/reviews`,
-        "pull_request_reviews",
-        signal
-      );
-      reviewsByPR.set(pr.number, reviews.body);
+    if (this.isResourceAllowed(options, "pull_request_reviews")) {
+      for (const pr of filteredPrs) {
+        signal?.throwIfAborted();
+        const reviews = await this.fetch(
+          `https://api.github.com/repos/${owner}/${repo}/pulls/${pr.number}/reviews`,
+          "pull_request_reviews",
+          signal
+        );
+        reviewsByPR.set(pr.number, reviews.body);
+      }
     }
-    const items = [{ prs, reviewsByPR }];
-    return { items, next: nextLink };
+    const items = [{ prs: filteredPrs, reviewsByPR }];
+    return { items, next: cutoffReached ? null : nextLink };
   }
   async fetchIssues(options, page, signal) {
     const { owner, repo } = this.settings;
@@ -371,7 +596,7 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
     const nextLink = parseLinkHeader(res.headers.get("link"))["next"] ?? null;
     return { items: res.body, next: nextLink };
   }
-  async fetchDeployments(page, signal) {
+  async fetchDeployments(options, page, signal) {
     const { owner, repo } = this.settings;
     const url = page ?? `https://api.github.com/repos/${owner}/${repo}/deployments?per_page=100`;
     const res = await this.fetch(
@@ -381,25 +606,41 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
     );
     const nextLink = parseLinkHeader(res.headers.get("link"))["next"] ?? null;
     const deployments = res.body;
+    const cutoff = options.since ? new Date(options.since).getTime() : null;
+    const filteredDeployments = cutoff !== null ? deployments.filter((d) => new Date(d.created_at).getTime() >= cutoff) : deployments;
+    const lastDeployment = deployments.at(-1);
+    const cutoffReached = cutoff !== null && lastDeployment !== void 0 && new Date(lastDeployment.created_at).getTime() < cutoff;
     const latestStatusById = /* @__PURE__ */ new Map();
-    for (const deployment of deployments) {
-      signal?.throwIfAborted();
-      const statusRes = await this.fetch(
-        `https://api.github.com/repos/${owner}/${repo}/deployments/${deployment.id}/statuses?per_page=1`,
-        "deployment_statuses",
-        signal
-      );
-      latestStatusById.set(deployment.id, statusRes.body[0] ?? null);
+    if (this.isResourceAllowed(options, "deployment_statuses")) {
+      for (const deployment of filteredDeployments) {
+        signal?.throwIfAborted();
+        const statusRes = await this.fetch(
+          `https://api.github.com/repos/${owner}/${repo}/deployments/${deployment.id}/statuses?per_page=1`,
+          "deployment_statuses",
+          signal
+        );
+        latestStatusById.set(deployment.id, statusRes.body[0] ?? null);
+      }
     }
-    const items = [{ deployments, latestStatusById }];
-    return { items, next: nextLink };
+    const items = [
+      { deployments: filteredDeployments, latestStatusById }
+    ];
+    return { items, next: cutoffReached ? null : nextLink };
   }
-  async fetchReleases(page, signal) {
+  async fetchReleases(options, page, signal) {
     const { owner, repo } = this.settings;
     const url = page ?? `https://api.github.com/repos/${owner}/${repo}/releases?per_page=100`;
     const res = await this.fetch(url, "releases", signal);
     const nextLink = parseLinkHeader(res.headers.get("link"))["next"] ?? null;
-    return { items: res.body, next: nextLink };
+    const releases = res.body;
+    const cutoff = options.since ? new Date(options.since).getTime() : null;
+    const filtered = cutoff !== null ? releases.filter((r) => {
+      const ts = new Date(r.published_at ?? r.created_at).getTime();
+      return ts >= cutoff;
+    }) : releases;
+    const lastRelease = releases.at(-1);
+    const cutoffReached = cutoff !== null && lastRelease !== void 0 && new Date(lastRelease.published_at ?? lastRelease.created_at).getTime() < cutoff;
+    return { items: filtered, next: cutoffReached ? null : nextLink };
   }
   async fetchContributors(signal) {
     const { owner, repo } = this.settings;
@@ -513,10 +754,16 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
       });
     }
   }
-  async writePullRequests(storage, items, page) {
+  async writePullRequests(storage, items, page, options) {
+    const reviewsAllowed = this.isResourceAllowed(
+      options,
+      "pull_request_reviews"
+    );
     if (page === null) {
       await storage.entities([], { types: ["pull_request"] });
-      await storage.edges([], { kinds: ["reviewed_by"] });
+      if (reviewsAllowed) {
+        await storage.edges([], { kinds: ["reviewed_by"] });
+      }
     }
     const pageItems = items;
     for (const { prs: rawPrs, reviewsByPR } of pageItems) {
@@ -539,6 +786,9 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
           updated_at: new Date(pr.updated_at).getTime()
         });
       }
+      if (!reviewsAllowed) {
+        continue;
+      }
       for (const pr of prs) {
         const reviews = reviewsByPR.get(pr.number) ?? [];
         for (const review of reviews) {
@@ -586,8 +836,21 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
       });
     }
   }
-  async writeDeployments(storage, items, page) {
+  async writeDeployments(storage, items, page, options) {
+    const statusesAllowed = this.isResourceAllowed(
+      options,
+      "deployment_statuses"
+    );
     if (page === null) {
+      if (!statusesAllowed) {
+        const existing = await storage.queryEntities({ type: "deployment" });
+        for (const entity of existing) {
+          const prev = entity.attributes["latest_status"];
+          if (typeof prev === "string") {
+            this.preservedDeploymentStatus.set(entity.id, prev);
+          }
+        }
+      }
       await storage.entities([], { types: ["deployment"] });
     }
     const pageItems = items;
@@ -598,9 +861,16 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
         "deployments"
       );
       for (const deployment of deployments) {
-        const status = latestStatusById.get(deployment.id) ?? null;
         const createdMs = new Date(deployment.created_at).getTime();
-        const statusUpdatedMs = status?.updated_at ? new Date(status.updated_at).getTime() : null;
+        let latestStatus;
+        let statusUpdatedMs = null;
+        if (statusesAllowed) {
+          const status = latestStatusById.get(deployment.id) ?? null;
+          latestStatus = status?.state ?? "unknown";
+          statusUpdatedMs = status?.updated_at ? new Date(status.updated_at).getTime() : null;
+        } else {
+          latestStatus = this.preservedDeploymentStatus.get(String(deployment.id)) ?? "unknown";
+        }
         await storage.entity({
           type: "deployment",
           id: String(deployment.id),
@@ -610,7 +880,7 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
             sha: deployment.sha,
             creator: deployment.creator?.login ?? "",
             created_at: createdMs,
-            latest_status: status?.state ?? "unknown"
+            latest_status: latestStatus
           },
           updated_at: Math.max(createdMs, statusUpdatedMs ?? 0)
         });
@@ -676,10 +946,12 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
   }
   async sync(options, storage, signal) {
     const cursor = this.resolveCursor(options.cursor);
+    const phases = selectPhases(options.resources);
     return paginateChunked({
-      phases: PHASE_ORDER,
+      phases,
       cursor,
       signal,
+      logger: this.logger,
       fetchPage: async (phase, page, sig) => {
         switch (phase) {
           case "repo_stats":
@@ -687,13 +959,13 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
           case "workflow_runs":
             return options.mode === "latest" ? this.fetchWorkflowRunsLatest(sig) : this.fetchWorkflowRunsFull(options, page, sig);
           case "pull_requests":
-            return this.fetchPullRequests(page, sig);
+            return this.fetchPullRequests(options, page, sig);
           case "issues":
             return this.fetchIssues(options, page, sig);
           case "deployments":
-            return this.fetchDeployments(page, sig);
+            return this.fetchDeployments(options, page, sig);
           case "releases":
-            return this.fetchReleases(page, sig);
+            return this.fetchReleases(options, page, sig);
           case "contributors":
             return this.fetchContributors(sig);
         }
@@ -705,11 +977,11 @@ var GitHubConnector = class _GitHubConnector extends BaseConnector {
           case "workflow_runs":
             return options.mode === "latest" ? this.writeWorkflowRunsLatest(storage, items) : this.writeWorkflowRunsFull(storage, items, page);
           case "pull_requests":
-            return this.writePullRequests(storage, items, page);
+            return this.writePullRequests(storage, items, page, options);
           case "issues":
             return this.writeIssues(storage, items, page);
           case "deployments":
-            return this.writeDeployments(storage, items, page);
+            return this.writeDeployments(storage, items, page, options);
           case "releases":
             return this.writeReleases(storage, items, page);
           case "contributors":
@@ -725,6 +997,7 @@ var index_default = GitHubConnector;
 export {
   GitHubConnector,
   configFields,
-  index_default as default
+  index_default as default,
+  doc
 };
 //# sourceMappingURL=index.js.map