@rawdash/connector-gitlab 0.1.0

package/dist/index.js

@@ -0,0 +1,811 @@
+// ../../connector-shared/dist/index.js
+var HTTP_CLIENT_VERSION = "0.0.0";
+var DEFAULT_USER_AGENT = `rawdash-connector/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;
+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) };
+    }
+  };
+}
+function parseLinkHeader(header) {
+  if (!header) {
+    return {};
+  }
+  const result = {};
+  for (const part of header.split(",")) {
+    const match = part.match(/<([^>]+)>\s*;\s*rel="([^"]+)"/);
+    if (match) {
+      result[match[2]] = match[1];
+    }
+  }
+  return result;
+}
+
+// src/gitlab.ts
+import {
+  BaseConnector,
+  defineConfigFields,
+  defineConnectorDoc,
+  defineResources,
+  makeChunkedCursorGuard,
+  paginateChunked,
+  schemasFromResources,
+  selectActivePhases
+} from "@rawdash/core";
+import { z } from "zod";
+var positiveInt = z.number().int().positive();
+var configFields = defineConfigFields(
+  z.object({
+    apiToken: z.object({ $secret: z.string() }).meta({
+      label: "API Token",
+      description: "GitLab Personal Access Token with `read_api` scope. Create one at GitLab -> Preferences -> Access Tokens.",
+      placeholder: "glpat-...",
+      secret: true
+    }),
+    host: z.string().min(1).regex(
+      /^[^/\s:?#]+$/,
+      "Use host only (no protocol, port, path, or query)."
+    ).optional().meta({
+      label: "Host (optional)",
+      description: "Your GitLab host. Defaults to `gitlab.com`. For self-hosted, supply the hostname only (e.g. `gitlab.example.com`).",
+      placeholder: "gitlab.com"
+    }),
+    projectIds: z.array(positiveInt).nonempty().optional().meta({
+      label: "Project IDs (optional)",
+      description: "Numeric project IDs to sync directly (find one in Project -> Settings -> General). Combined with any projects discovered via `groupIds`."
+    }),
+    groupIds: z.array(positiveInt).nonempty().optional().meta({
+      label: "Group IDs (optional)",
+      description: "Numeric group IDs whose projects (including subgroups) will be discovered and synced."
+    }),
+    resources: z.array(
+      z.enum([
+        "project",
+        "merge_request",
+        "pipeline",
+        "pipeline_event",
+        "issue",
+        "release"
+      ])
+    ).nonempty().optional().meta({
+      label: "Resources",
+      description: "Which GitLab resources to sync. Omit to sync all of them. 'pipeline_event' rides the 'pipeline' phase - enabling it without 'pipeline' still fetches pipelines but skips writing pipeline entities."
+    })
+  }).refine(
+    (v) => v.projectIds && v.projectIds.length > 0 || v.groupIds && v.groupIds.length > 0,
+    {
+      message: "At least one of `projectIds` or `groupIds` must be provided.",
+      path: ["projectIds"]
+    }
+  )
+);
+var doc = defineConnectorDoc({
+  displayName: "GitLab",
+  category: "engineering",
+  brandColor: "#FC6D26",
+  tagline: "Sync projects, merge requests, pipelines, issues, and releases from GitLab.com or a self-hosted GitLab instance.",
+  vendor: {
+    name: "GitLab",
+    apiDocs: "https://docs.gitlab.com/ee/api/",
+    website: "https://gitlab.com"
+  },
+  auth: {
+    summary: "A GitLab Personal Access Token (PAT) with the `read_api` scope is required. The PAT must belong to an account with read access to the projects and groups you want to sync. Self-hosted GitLab is supported by overriding the `host` field.",
+    setup: [
+      "Open GitLab -> User Preferences -> Access Tokens (or the equivalent on your self-hosted instance).",
+      "Create a Personal Access Token with the `read_api` scope.",
+      'Store it as a secret and reference it from the connector config as `apiToken: secret("GITLAB_API_TOKEN")`.',
+      "Set `projectIds` to a list of numeric project IDs, or `groupIds` to a list of numeric group IDs (or both). At least one must be set.",
+      "For self-hosted GitLab, set `host` to your instance hostname (no protocol or path), e.g. `gitlab.example.com`."
+    ]
+  },
+  rateLimit: "GitLab returns standard `RateLimit-Remaining` / `RateLimit-Reset` headers (reset is a Unix timestamp in seconds); list pagination uses the Link header (page size 100).",
+  limitations: [
+    "Container Registry, Packages, and GitLab Duo / AI features are out of scope.",
+    "Pipeline state-transition events are synthesized: one `pipeline_event` is emitted per pipeline lifecycle (created_at to finished_at/updated_at), not one per intermediate state change.",
+    "Group project discovery walks each group with `include_subgroups=true`; very large groups may take multiple sync chunks to enumerate."
+  ]
+});
+var gitlabCredentials = {
+  apiToken: {
+    description: "GitLab Personal Access Token",
+    auth: "required"
+  }
+};
+var DEFAULT_HOST = "gitlab.com";
+var PAGE_SIZE = 100;
+var gitlabRateLimit = standardRateLimitPolicy({
+  remainingHeader: "ratelimit-remaining",
+  resetHeader: "ratelimit-reset",
+  resetUnit: "s"
+});
+var PHASE_ORDER = [
+  "projects",
+  "merge_requests",
+  "pipelines",
+  "issues",
+  "releases"
+];
+var isGitLabSyncCursor = makeChunkedCursorGuard(PHASE_ORDER);
+function decodePage(page) {
+  if (page === null) {
+    return { idx: 0, url: null };
+  }
+  const sep = page.indexOf("|");
+  if (sep === -1) {
+    return { idx: 0, url: null };
+  }
+  const idxRaw = Number.parseInt(page.slice(0, sep), 10);
+  const url = page.slice(sep + 1);
+  return {
+    idx: Number.isFinite(idxRaw) && idxRaw >= 0 ? idxRaw : 0,
+    url: url === "" ? null : url
+  };
+}
+function encodePage(idx, url) {
+  return `${idx}|${url ?? ""}`;
+}
+var userRefSchema = z.object({
+  id: z.number().int(),
+  username: z.string().min(1),
+  name: z.string().nullable().optional()
+});
+var projectSchema = z.object({
+  id: z.number().int(),
+  name: z.string().min(1),
+  path_with_namespace: z.string().min(1),
+  default_branch: z.string().nullable(),
+  web_url: z.string(),
+  created_at: z.iso.datetime(),
+  last_activity_at: z.iso.datetime().nullable().optional(),
+  archived: z.boolean().optional(),
+  visibility: z.string().optional()
+});
+var projectsResponseSchema = z.array(projectSchema);
+var mergeRequestSchema = z.object({
+  id: z.number().int(),
+  iid: z.number().int(),
+  project_id: z.number().int(),
+  title: z.string(),
+  state: z.string().min(1),
+  draft: z.boolean().optional(),
+  work_in_progress: z.boolean().optional(),
+  author: userRefSchema.nullable(),
+  assignees: z.array(userRefSchema).optional(),
+  source_branch: z.string(),
+  target_branch: z.string(),
+  created_at: z.iso.datetime(),
+  updated_at: z.iso.datetime(),
+  merged_at: z.iso.datetime().nullable(),
+  closed_at: z.iso.datetime().nullable(),
+  web_url: z.string()
+});
+var mergeRequestsResponseSchema = z.array(mergeRequestSchema);
+var pipelineSchema = z.object({
+  id: z.number().int(),
+  iid: z.number().int().optional(),
+  project_id: z.number().int(),
+  status: z.string().min(1),
+  ref: z.string().nullable(),
+  sha: z.string().min(1),
+  source: z.string().nullable(),
+  created_at: z.iso.datetime(),
+  updated_at: z.iso.datetime(),
+  started_at: z.iso.datetime().nullable().optional(),
+  finished_at: z.iso.datetime().nullable().optional(),
+  duration: z.number().nullable().optional(),
+  web_url: z.string()
+});
+var pipelinesResponseSchema = z.array(pipelineSchema);
+var issueSchema = z.object({
+  id: z.number().int(),
+  iid: z.number().int(),
+  project_id: z.number().int(),
+  title: z.string(),
+  state: z.string().min(1),
+  labels: z.array(z.string()),
+  author: userRefSchema.nullable(),
+  assignees: z.array(userRefSchema).optional(),
+  created_at: z.iso.datetime(),
+  updated_at: z.iso.datetime(),
+  closed_at: z.iso.datetime().nullable(),
+  web_url: z.string()
+});
+var issuesResponseSchema = z.array(issueSchema);
+var releaseSchema = z.object({
+  tag_name: z.string().min(1),
+  name: z.string().nullable(),
+  description: z.string().nullable().optional(),
+  created_at: z.iso.datetime(),
+  released_at: z.iso.datetime().nullable(),
+  author: userRefSchema.nullable().optional()
+});
+var releasesResponseSchema = z.array(releaseSchema);
+var gitlabResources = defineResources({
+  project: {
+    shape: "entity",
+    description: "GitLab projects (repositories) with namespace path, default branch, and archived/visibility flags.",
+    endpoint: "GET /api/v4/projects/{id}",
+    notes: "Discovered from configured `projectIds` and from `groupIds` via GET /api/v4/groups/{id}/projects?include_subgroups=true.",
+    responses: { projects: projectsResponseSchema }
+  },
+  merge_request: {
+    shape: "entity",
+    description: "Open, merged, and closed merge requests with author, source/target branches, and merge timestamps.",
+    endpoint: "GET /api/v4/projects/{id}/merge_requests",
+    responses: { merge_requests: mergeRequestsResponseSchema }
+  },
+  pipeline: {
+    shape: "entity",
+    description: "CI/CD pipelines with status, ref, commit sha, source, duration, and start/finish timestamps.",
+    endpoint: "GET /api/v4/projects/{id}/pipelines",
+    responses: { pipelines: pipelinesResponseSchema }
+  },
+  pipeline_event: {
+    shape: "event",
+    description: "Pipeline lifecycle events. One event per pipeline covering created_at to finished_at (or updated_at if not yet finished), tagged with the terminal status.",
+    endpoint: "GET /api/v4/projects/{id}/pipelines",
+    notes: "Derived from the same pipelines response that builds the `pipeline` resource; the GitLab API does not expose an intermediate state-transition history endpoint."
+  },
+  issue: {
+    shape: "entity",
+    description: "Open and closed issues with labels, author, assignees, and close timestamp.",
+    endpoint: "GET /api/v4/projects/{id}/issues",
+    responses: { issues: issuesResponseSchema }
+  },
+  release: {
+    shape: "entity",
+    description: "Project releases keyed by tag name, including released_at and the publishing author.",
+    endpoint: "GET /api/v4/projects/{id}/releases",
+    responses: { releases: releasesResponseSchema }
+  }
+});
+var id = "gitlab";
+var GitLabConnector = class _GitLabConnector extends BaseConnector {
+  static id = id;
+  static resources = gitlabResources;
+  static schemas = schemasFromResources(gitlabResources);
+  static create(input, ctx) {
+    const parsed = configFields.parse(input);
+    return new _GitLabConnector(
+      {
+        host: parsed.host ?? DEFAULT_HOST,
+        projectIds: parsed.projectIds,
+        groupIds: parsed.groupIds,
+        resources: parsed.resources
+      },
+      { apiToken: parsed.apiToken },
+      ctx
+    );
+  }
+  id = id;
+  credentials = gitlabCredentials;
+  effectiveProjectIds = null;
+  projectMetadataCache = /* @__PURE__ */ new Map();
+  constructor(settings, creds, ctx) {
+    super({ ...settings, host: settings.host || DEFAULT_HOST }, creds, ctx);
+  }
+  buildHeaders() {
+    return {
+      "PRIVATE-TOKEN": this.creds.apiToken,
+      Accept: "application/json",
+      "User-Agent": connectorUserAgent("gitlab")
+    };
+  }
+  apiBase() {
+    return `https://${this.settings.host}/api/v4`;
+  }
+  fetch(url, resource, signal) {
+    return this.get(url, {
+      resource,
+      headers: this.buildHeaders(),
+      signal,
+      rateLimit: gitlabRateLimit
+    });
+  }
+  sanitizeUrl(url, expectedPath) {
+    if (!url) {
+      return null;
+    }
+    try {
+      const u = new URL(url);
+      if (u.protocol !== "https:" || u.host !== this.settings.host) {
+        return null;
+      }
+      if (u.pathname !== expectedPath) {
+        return null;
+      }
+      return u.toString();
+    } catch {
+      return null;
+    }
+  }
+  static PHASE_RESOURCES = {
+    projects: ["project"],
+    merge_requests: ["merge_request"],
+    pipelines: ["pipeline", "pipeline_event"],
+    issues: ["issue"],
+    releases: ["release"]
+  };
+  activePhases(optionsResources) {
+    const fromSettings = selectActivePhases(
+      (r) => {
+        switch (r) {
+          case "project":
+            return "projects";
+          case "merge_request":
+            return "merge_requests";
+          case "pipeline":
+          case "pipeline_event":
+            return "pipelines";
+          case "issue":
+            return "issues";
+          case "release":
+            return "releases";
+        }
+      },
+      PHASE_ORDER,
+      this.settings.resources
+    );
+    if (optionsResources === void 0) {
+      return fromSettings;
+    }
+    return fromSettings.filter(
+      (phase) => _GitLabConnector.PHASE_RESOURCES[phase].some(
+        (r) => optionsResources.has(r)
+      )
+    );
+  }
+  isResourceAllowed(resource, optionsResources) {
+    const fromSettings = this.settings.resources;
+    if (fromSettings && fromSettings.length > 0 && !fromSettings.includes(resource)) {
+      return false;
+    }
+    if (optionsResources !== void 0 && !optionsResources.has(resource)) {
+      return false;
+    }
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // Effective project ID resolution.  Combines explicit `projectIds` with all
+  // projects under each configured `groupIds` (recursing into subgroups).
+  // -------------------------------------------------------------------------
+  async resolveEffectiveProjectIds(signal) {
+    if (this.effectiveProjectIds !== null) {
+      return this.effectiveProjectIds;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const ordered = [];
+    const addId = (n) => {
+      if (!seen.has(n)) {
+        seen.add(n);
+        ordered.push(n);
+      }
+    };
+    for (const pid of this.settings.projectIds ?? []) {
+      addId(pid);
+    }
+    for (const gid of this.settings.groupIds ?? []) {
+      const projects = await this.fetchGroupProjects(gid, signal);
+      for (const p of projects) {
+        this.projectMetadataCache.set(p.id, p);
+        addId(p.id);
+      }
+    }
+    ordered.sort((a, b) => a - b);
+    this.effectiveProjectIds = ordered;
+    return ordered;
+  }
+  async fetchGroupProjects(groupId, signal) {
+    const out = [];
+    const baseUrl = `${this.apiBase()}/groups/${groupId}/projects`;
+    let url = `${baseUrl}?per_page=${PAGE_SIZE}&include_subgroups=true&archived=false`;
+    const expectedPath = `/api/v4/groups/${groupId}/projects`;
+    while (url !== null) {
+      const res = await this.fetch(
+        url,
+        "group_projects",
+        signal
+      );
+      for (const project of res.body) {
+        out.push(project);
+      }
+      const next = parseLinkHeader(res.headers.get("link"))["next"] ?? null;
+      url = this.sanitizeUrl(next, expectedPath);
+    }
+    return out;
+  }
+  // -------------------------------------------------------------------------
+  // Per-phase fetchers
+  // -------------------------------------------------------------------------
+  async fetchProjectMetadata(projectId, signal) {
+    if (this.projectMetadataCache.has(projectId)) {
+      return this.projectMetadataCache.get(projectId);
+    }
+    const url = `${this.apiBase()}/projects/${projectId}`;
+    const res = await this.fetch(url, "project", signal);
+    this.projectMetadataCache.set(projectId, res.body);
+    return res.body;
+  }
+  async fetchProjectsPhase(page, signal) {
+    const projects = await this.resolveEffectiveProjectIds(signal);
+    if (projects.length === 0) {
+      return { items: [], next: null };
+    }
+    const { idx } = decodePage(page);
+    if (idx >= projects.length) {
+      return { items: [], next: null };
+    }
+    const projectId = projects[idx];
+    const project = await this.fetchProjectMetadata(projectId, signal);
+    const nextIdx = idx + 1;
+    const next = nextIdx < projects.length ? encodePage(nextIdx, null) : null;
+    return { items: project ? [project] : [], next };
+  }
+  buildListPageUrl(projectId, resource, options) {
+    const u = new URL(`${this.apiBase()}/projects/${projectId}/${resource}`);
+    u.searchParams.set("per_page", String(PAGE_SIZE));
+    switch (resource) {
+      case "merge_requests":
+        u.searchParams.set("state", "all");
+        u.searchParams.set("order_by", "updated_at");
+        u.searchParams.set("sort", "desc");
+        u.searchParams.set("scope", "all");
+        if (options.since) {
+          u.searchParams.set("updated_after", options.since);
+        }
+        break;
+      case "pipelines":
+        u.searchParams.set("order_by", "updated_at");
+        u.searchParams.set("sort", "desc");
+        if (options.since) {
+          u.searchParams.set("updated_after", options.since);
+        }
+        break;
+      case "issues":
+        u.searchParams.set("state", "all");
+        u.searchParams.set("order_by", "updated_at");
+        u.searchParams.set("sort", "desc");
+        u.searchParams.set("scope", "all");
+        if (options.since) {
+          u.searchParams.set("updated_after", options.since);
+        }
+        break;
+      case "releases":
+        u.searchParams.set("order_by", "released_at");
+        u.searchParams.set("sort", "desc");
+        break;
+    }
+    return u.toString();
+  }
+  async fetchListPhase(options, page, signal, resource, rowUpdatedAt) {
+    const projects = await this.resolveEffectiveProjectIds(signal);
+    if (projects.length === 0) {
+      return { items: [], next: null };
+    }
+    const { idx, url: rawPageUrl } = decodePage(page);
+    if (idx >= projects.length) {
+      return { items: [], next: null };
+    }
+    const projectId = projects[idx];
+    const expectedPath = `/api/v4/projects/${projectId}/${resource}`;
+    const fetchUrl = this.sanitizeUrl(rawPageUrl, expectedPath) ?? this.buildListPageUrl(projectId, resource, options);
+    const res = await this.fetch(fetchUrl, resource, signal);
+    const rawNext = parseLinkHeader(res.headers.get("link"))["next"] ?? null;
+    const safeNext = this.sanitizeUrl(rawNext, expectedPath);
+    const rows = res.body;
+    const cutoff = options.since ? new Date(options.since).getTime() : null;
+    let filtered;
+    let cutoffReached;
+    if (cutoff !== null) {
+      filtered = rows.filter((row) => rowUpdatedAt(row) >= cutoff);
+      const last = rows.at(-1);
+      cutoffReached = last !== void 0 && rowUpdatedAt(last) < cutoff;
+    } else {
+      filtered = rows;
+      cutoffReached = false;
+    }
+    const nextWithinProject = cutoffReached ? null : safeNext;
+    const batch = { projectId, items: filtered };
+    if (nextWithinProject !== null) {
+      return { items: [batch], next: encodePage(idx, nextWithinProject) };
+    }
+    const nextIdx = idx + 1;
+    const next = nextIdx < projects.length ? encodePage(nextIdx, null) : null;
+    return { items: [batch], next };
+  }
+  // -------------------------------------------------------------------------
+  // Writers
+  // -------------------------------------------------------------------------
+  async writeProjects(storage, items, page) {
+    if (page === null) {
+      await storage.entities([], { types: ["project"] });
+    }
+    const projects = items;
+    for (const project of projects) {
+      const updatedAt = new Date(
+        project.last_activity_at ?? project.created_at
+      ).getTime();
+      await storage.entity({
+        type: "project",
+        id: String(project.id),
+        attributes: {
+          name: project.name,
+          path_with_namespace: project.path_with_namespace,
+          default_branch: project.default_branch ?? "",
+          web_url: project.web_url,
+          visibility: project.visibility ?? "",
+          archived: project.archived ?? false,
+          created_at: new Date(project.created_at).getTime()
+        },
+        updated_at: updatedAt
+      });
+    }
+  }
+  async writeMergeRequests(storage, items, page, options) {
+    if (page === null && !options.since) {
+      await storage.entities([], { types: ["merge_request"] });
+    }
+    const batches = items;
+    for (const batch of batches) {
+      for (const mr of batch.items) {
+        await storage.entity({
+          type: "merge_request",
+          id: `${batch.projectId}:${mr.iid}`,
+          attributes: {
+            project_id: batch.projectId,
+            iid: mr.iid,
+            title: mr.title,
+            state: mr.state,
+            draft: mr.draft ?? mr.work_in_progress ?? false,
+            author: mr.author?.username ?? "",
+            assignees: (mr.assignees ?? []).map((a) => a.username),
+            source_branch: mr.source_branch,
+            target_branch: mr.target_branch,
+            web_url: mr.web_url,
+            created_at: new Date(mr.created_at).getTime(),
+            merged_at: mr.merged_at ? new Date(mr.merged_at).getTime() : null,
+            closed_at: mr.closed_at ? new Date(mr.closed_at).getTime() : null
+          },
+          updated_at: new Date(mr.updated_at).getTime()
+        });
+      }
+    }
+  }
+  async writePipelines(storage, items, page, options) {
+    const pipelineAllowed = this.isResourceAllowed(
+      "pipeline",
+      options.resources
+    );
+    const eventAllowed = this.isResourceAllowed(
+      "pipeline_event",
+      options.resources
+    );
+    if (page === null && !options.since) {
+      if (pipelineAllowed) {
+        await storage.entities([], { types: ["pipeline"] });
+      }
+      if (eventAllowed) {
+        await storage.events([], { names: ["pipeline_event"] });
+      }
+    }
+    const batches = items;
+    for (const batch of batches) {
+      for (const pipeline of batch.items) {
+        const createdMs = new Date(pipeline.created_at).getTime();
+        const updatedMs = new Date(pipeline.updated_at).getTime();
+        const finishedMs = pipeline.finished_at ? new Date(pipeline.finished_at).getTime() : null;
+        const durationMs = pipeline.duration !== null && pipeline.duration !== void 0 ? Math.round(pipeline.duration * 1e3) : finishedMs !== null ? finishedMs - createdMs : null;
+        if (pipelineAllowed) {
+          await storage.entity({
+            type: "pipeline",
+            id: `${batch.projectId}:${pipeline.id}`,
+            attributes: {
+              project_id: batch.projectId,
+              pipeline_id: pipeline.id,
+              status: pipeline.status,
+              ref: pipeline.ref ?? "",
+              sha: pipeline.sha,
+              source: pipeline.source ?? "",
+              web_url: pipeline.web_url,
+              created_at: createdMs,
+              finished_at: finishedMs,
+              duration_ms: durationMs
+            },
+            updated_at: updatedMs
+          });
+        }
+        if (eventAllowed) {
+          await storage.event({
+            name: "pipeline_event",
+            start_ts: createdMs,
+            end_ts: finishedMs ?? updatedMs,
+            attributes: {
+              project_id: batch.projectId,
+              pipeline_id: pipeline.id,
+              status: pipeline.status,
+              ref: pipeline.ref ?? "",
+              sha: pipeline.sha,
+              source: pipeline.source ?? "",
+              duration_ms: durationMs
+            }
+          });
+        }
+      }
+    }
+  }
+  async writeIssues(storage, items, page, options) {
+    if (page === null && !options.since) {
+      await storage.entities([], { types: ["issue"] });
+    }
+    const batches = items;
+    for (const batch of batches) {
+      for (const issue of batch.items) {
+        await storage.entity({
+          type: "issue",
+          id: `${batch.projectId}:${issue.iid}`,
+          attributes: {
+            project_id: batch.projectId,
+            iid: issue.iid,
+            title: issue.title,
+            state: issue.state,
+            labels: issue.labels,
+            author: issue.author?.username ?? "",
+            assignees: (issue.assignees ?? []).map((a) => a.username),
+            web_url: issue.web_url,
+            created_at: new Date(issue.created_at).getTime(),
+            closed_at: issue.closed_at ? new Date(issue.closed_at).getTime() : null
+          },
+          updated_at: new Date(issue.updated_at).getTime()
+        });
+      }
+    }
+  }
+  async writeReleases(storage, items, page, options) {
+    if (page === null && !options.since) {
+      await storage.entities([], { types: ["release"] });
+    }
+    const batches = items;
+    for (const batch of batches) {
+      for (const release of batch.items) {
+        const createdMs = new Date(release.created_at).getTime();
+        const releasedMs = release.released_at ? new Date(release.released_at).getTime() : null;
+        await storage.entity({
+          type: "release",
+          id: `${batch.projectId}:${release.tag_name}`,
+          attributes: {
+            project_id: batch.projectId,
+            tag_name: release.tag_name,
+            name: release.name ?? "",
+            description: release.description ?? "",
+            author: release.author?.username ?? "",
+            created_at: createdMs,
+            released_at: releasedMs
+          },
+          updated_at: releasedMs ?? createdMs
+        });
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Cursor resume
+  // -------------------------------------------------------------------------
+  resolveCursor(cursor) {
+    if (!isGitLabSyncCursor(cursor)) {
+      return void 0;
+    }
+    return { phase: cursor.phase, page: cursor.page };
+  }
+  // -------------------------------------------------------------------------
+  // sync()
+  // -------------------------------------------------------------------------
+  async sync(options, storage, signal) {
+    const cursor = this.resolveCursor(options.cursor);
+    const phases = this.activePhases(options.resources);
+    return paginateChunked({
+      phases,
+      cursor,
+      signal,
+      logger: this.logger,
+      fetchPage: async (phase, page, sig) => {
+        switch (phase) {
+          case "projects":
+            return this.fetchProjectsPhase(page, sig);
+          case "merge_requests":
+            return this.fetchListPhase(
+              options,
+              page,
+              sig,
+              "merge_requests",
+              (mr) => new Date(mr.updated_at).getTime()
+            );
+          case "pipelines":
+            return this.fetchListPhase(
+              options,
+              page,
+              sig,
+              "pipelines",
+              (p) => new Date(p.updated_at).getTime()
+            );
+          case "issues":
+            return this.fetchListPhase(
+              options,
+              page,
+              sig,
+              "issues",
+              (i) => new Date(i.updated_at).getTime()
+            );
+          case "releases":
+            return this.fetchListPhase(
+              options,
+              page,
+              sig,
+              "releases",
+              (r) => new Date(r.released_at ?? r.created_at).getTime()
+            );
+        }
+      },
+      writeBatch: async (phase, items, page) => {
+        switch (phase) {
+          case "projects":
+            return this.writeProjects(storage, items, page);
+          case "merge_requests":
+            return this.writeMergeRequests(storage, items, page, options);
+          case "pipelines":
+            return this.writePipelines(storage, items, page, options);
+          case "issues":
+            return this.writeIssues(storage, items, page, options);
+          case "releases":
+            return this.writeReleases(storage, items, page, options);
+        }
+      }
+    });
+  }
+};
+
+// src/index.ts
+var index_default = GitLabConnector;
+export {
+  GitLabConnector,
+  configFields,
+  index_default as default,
+  doc,
+  id,
+  gitlabResources as resources
+};
+//# sourceMappingURL=index.js.map