@useairfoil/producer-linear 0.0.1 → 0.0.3

package/src/resources/initiatives.ts

@@ -0,0 +1,136 @@
+import { Resource } from "@useairfoil/connector-kit";
+
+import type { LinearClientService } from "../client/client";
+
+import {
+  InitiativeLabelObjectSchema,
+  InitiativeLabelSchema,
+  InitiativeObjectSchema,
+  InitiativeRelationObjectSchema,
+  InitiativeRelationSchema,
+  InitiativeSchema,
+  InitiativeToProjectObjectSchema,
+  InitiativeToProjectSchema,
+  InitiativeUpdateObjectSchema,
+  InitiativeUpdateSchema,
+} from "../schemas/initiatives";
+import {
+  backfillList,
+  changesList,
+  checkList,
+  listSources,
+  listSpec,
+  rowsOf,
+  webhookList,
+} from "./pages";
+
+const initiativeSpec = listSpec({
+  connection: "initiatives",
+  single: "initiative",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description content url icon color status health
+    health_updated_at: healthUpdatedAt priority owner_id: owner { id } creator_id: creator { id }
+    parent_initiative_id: parentInitiative { id } target_date: targetDate
+    started_at: startedAt completed_at: completedAt canceled_at: canceledAt
+    label_ids: labelIds visibility trashed`,
+  item: InitiativeObjectSchema,
+  updatedAt: (initiative) => initiative.updated_at,
+  rows: rowsOf((initiative) => ({
+    ...initiative,
+    version: initiative.updated_at,
+    _deleted: false,
+  })),
+});
+
+export const makeInitiatives = (client: LinearClientService) =>
+  Resource.entity({
+    name: "initiatives",
+    rowSchema: InitiativeSchema,
+    version: "version",
+
+    check: checkList(client, initiativeSpec),
+    backfill: backfillList(client, initiativeSpec),
+    changes: changesList(client, initiativeSpec),
+    webhook: webhookList(client, initiativeSpec),
+  });
+
+const initiativeUpdateSpec = listSpec({
+  connection: "initiativeUpdates",
+  single: "initiativeUpdate",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    initiative_id: initiative { id } user_id: user { id } body health url
+    edited_at: editedAt comment_count: commentCount`,
+  item: InitiativeUpdateObjectSchema,
+  updatedAt: (update) => update.updated_at,
+  rows: rowsOf((update) => ({ ...update, version: update.updated_at, _deleted: false })),
+});
+
+export const makeInitiativeUpdates = (client: LinearClientService) =>
+  Resource.entity({
+    name: "initiative_updates",
+    rowSchema: InitiativeUpdateSchema,
+    version: "version",
+
+    check: checkList(client, initiativeUpdateSpec),
+    backfill: backfillList(client, initiativeUpdateSpec),
+    changes: changesList(client, initiativeUpdateSpec),
+    webhook: webhookList(client, initiativeUpdateSpec),
+  });
+
+const initiativeLabelSpec = listSpec({
+  connection: "initiativeLabels",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description color is_group: isGroup parent_id: parent { id }
+    creator_id: creator { id } retired_at: retiredAt`,
+  item: InitiativeLabelObjectSchema,
+  updatedAt: (label) => label.updated_at,
+  rows: rowsOf((label) => ({ ...label, version: label.updated_at })),
+});
+
+export const makeInitiativeLabels = (client: LinearClientService) =>
+  Resource.entity({
+    name: "initiative_labels",
+    rowSchema: InitiativeLabelSchema,
+    version: "version",
+    ...listSources(client, initiativeLabelSpec),
+  });
+
+const initiativeRelationSpec = listSpec({
+  connection: "initiativeRelations",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    initiative_id: initiative { id } related_initiative_id: relatedInitiative { id }
+    sort_order: sortOrder user_id: user { id }`,
+  item: InitiativeRelationObjectSchema,
+  updatedAt: (relation) => relation.updated_at,
+  rows: rowsOf((relation) => ({ ...relation, version: relation.updated_at })),
+});
+
+export const makeInitiativeRelations = (client: LinearClientService) =>
+  Resource.entity({
+    name: "initiative_relations",
+    rowSchema: InitiativeRelationSchema,
+    version: "version",
+
+    check: checkList(client, initiativeRelationSpec),
+    backfill: backfillList(client, initiativeRelationSpec),
+    changes: changesList(client, initiativeRelationSpec),
+  });
+
+const initiativeToProjectSpec = listSpec({
+  connection: "initiativeToProjects",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt initiative_id: initiative { id } project_id: project { id } sort_order: sortOrder`,
+  item: InitiativeToProjectObjectSchema,
+  updatedAt: (link) => link.updated_at,
+  rows: rowsOf((link) => ({ ...link, version: link.updated_at })),
+});
+
+export const makeInitiativeToProjects = (client: LinearClientService) =>
+  Resource.entity({
+    name: "initiative_to_projects",
+    rowSchema: InitiativeToProjectSchema,
+    version: "version",
+
+    check: checkList(client, initiativeToProjectSpec),
+    backfill: backfillList(client, initiativeToProjectSpec),
+    changes: changesList(client, initiativeToProjectSpec),
+  });

package/src/resources/issue-history.ts

@@ -0,0 +1,119 @@
+import { type ConnectorError, Resource } from "@useairfoil/connector-kit";
+import { Effect, Option, Schema, Stream } from "effect";
+
+import type { LinearClientService } from "../client/client";
+
+import { type IssueHistory, IssueHistoryObjectSchema, IssueHistorySchema } from "../schemas/issues";
+import { Timestamp } from "../schemas/shared";
+import { backfillList, changesList, checkList, listSpec } from "./pages";
+
+const historyFields = `
+  id created_at: createdAt updated_at: updatedAt archived_at: archivedAt actor_id: actorId
+  from_state_id: fromStateId to_state_id: toStateId
+  from_assignee_id: fromAssigneeId to_assignee_id: toAssigneeId
+  from_cycle_id: fromCycleId to_cycle_id: toCycleId
+  from_project_id: fromProjectId to_project_id: toProjectId
+  from_parent_id: fromParentId to_parent_id: toParentId from_team_id: fromTeamId to_team_id: toTeamId
+  from_priority: fromPriority to_priority: toPriority
+  from_estimate: fromEstimate to_estimate: toEstimate
+  from_due_date: fromDueDate to_due_date: toDueDate from_title: fromTitle to_title: toTitle
+  added_label_ids: addedLabelIds removed_label_ids: removedLabelIds
+  attachment_id: attachmentId customer_need_id: customerNeedId
+  to_converted_project_id: toConvertedProjectId updated_description: updatedDescription
+  archived trashed auto_archived: autoArchived auto_closed: autoClosed`;
+
+const HistoryPageSchema = Schema.Struct({
+  nodes: Schema.Array(IssueHistoryObjectSchema),
+  pageInfo: Schema.Struct({ hasNextPage: Schema.Boolean, endCursor: Schema.NullOr(Schema.String) }),
+});
+
+type HistoryPage = typeof HistoryPageSchema.Type;
+
+const IssueWithHistorySchema = Schema.Struct({
+  id: Schema.String,
+  updated_at: Timestamp,
+  history: HistoryPageSchema,
+});
+
+const nextCursor = ({ pageInfo }: HistoryPage) =>
+  pageInfo.hasNextPage ? Option.fromNullishOr(pageInfo.endCursor) : Option.none();
+
+/** Returns the history after the first page, without repeating that page. */
+const readMore = (
+  client: LinearClientService,
+  issueId: string,
+  first: HistoryPage,
+): Effect.Effect<HistoryPage["nodes"], ConnectorError> =>
+  Option.match(nextCursor(first), {
+    onNone: () => Effect.succeed([]),
+    onSome: (cursor) =>
+      Stream.paginate(cursor, (after) =>
+        client
+          .query(
+            Schema.Struct({ issue: Schema.Struct({ history: HistoryPageSchema }) }),
+            `query IssueHistory($id: String!, $after: String) {
+  issue(id: $id) { history(first: 250, after: $after) { nodes { ${historyFields} } pageInfo { hasNextPage endCursor } } }
+}`,
+            { id: issueId, after },
+          )
+          .pipe(
+            Effect.map(({ issue }) => [issue.history.nodes, nextCursor(issue.history)] as const),
+          ),
+      ).pipe(Stream.runCollect),
+  });
+
+/** Linear has no top-level history query. */
+const historySpec = (client: LinearClientService) =>
+  listSpec({
+    connection: "issues",
+    fields: `id updated_at: updatedAt history(first: 50) { nodes { ${historyFields} } pageInfo { hasNextPage endCursor } }`,
+    item: IssueWithHistorySchema,
+    // Each issue reads up to 50 history entries, so pages stay under the cost limit.
+    first: 25,
+    updatedAt: (issue) => issue.updated_at,
+    rows: (issues): Effect.Effect<ReadonlyArray<IssueHistory>, ConnectorError> =>
+      Effect.forEach(issues, (issue) =>
+        readMore(client, issue.id, issue.history).pipe(
+          Effect.map((more) =>
+            [...issue.history.nodes, ...more].map((entry) => ({
+              ...entry,
+              issue_id: issue.id,
+              version: entry.updated_at,
+            })),
+          ),
+        ),
+      ).pipe(Effect.map((rows) => rows.flat())),
+  });
+
+export const makeIssueHistory = (client: LinearClientService) => {
+  const spec = historySpec(client);
+  return Resource.entity({
+    name: "issue_history",
+    rowSchema: IssueHistorySchema,
+    version: "version",
+
+    check: checkList(client, spec),
+    backfill: backfillList(client, spec),
+    changes: changesList(client, spec),
+    webhook: {
+      schema: Schema.Struct({ data: Schema.Struct({ id: Schema.String }) }),
+      handler: ({ payload }) =>
+        client
+          .find(
+            Schema.Struct({ issue: IssueWithHistorySchema }),
+            `query IssueHistory($id: String!) {
+  issue(id: $id) { ${spec.fields} }
+}`,
+            { id: payload.data.id },
+          )
+          .pipe(
+            Effect.flatMap(
+              Option.match({
+                onNone: () => Effect.succeed([]),
+                onSome: ({ issue }) => spec.rows([issue]),
+              }),
+            ),
+          ),
+    },
+  });
+};

package/src/resources/issues.ts

@@ -0,0 +1,131 @@
+import { Resource } from "@useairfoil/connector-kit";
+
+import type { LinearClientService } from "../client/client";
+
+import {
+  AttachmentObjectSchema,
+  AttachmentSchema,
+  IssueLabelObjectSchema,
+  IssueLabelSchema,
+  IssueObjectSchema,
+  IssueRelationObjectSchema,
+  IssueRelationSchema,
+  IssueSchema,
+} from "../schemas/issues";
+import {
+  backfillList,
+  changesList,
+  checkList,
+  listSources,
+  listSpec,
+  rowsOf,
+  webhookList,
+} from "./pages";
+
+const issueFields = `
+  id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+  identifier number title description url branch_name: branchName
+  priority priority_label: priorityLabel estimate due_date: dueDate
+  creator_id: creator { id } assignee_id: assignee { id } delegate_id: delegate { id }
+  snoozed_by_id: snoozedBy { id } state_id: state { id } team_id: team { id }
+  project_id: project { id } project_milestone_id: projectMilestone { id }
+  cycle_id: cycle { id } parent_id: parent { id } source_comment_id: sourceComment { id }
+  external_user_creator_id: externalUserCreator { id }
+  label_ids: labelIds previous_identifiers: previousIdentifiers
+  started_at: startedAt completed_at: completedAt canceled_at: canceledAt
+  started_triage_at: startedTriageAt triaged_at: triagedAt auto_closed_at: autoClosedAt
+  auto_archived_at: autoArchivedAt added_to_cycle_at: addedToCycleAt
+  added_to_project_at: addedToProjectAt added_to_team_at: addedToTeamAt
+  snoozed_until_at: snoozedUntilAt sla_type: slaType sla_started_at: slaStartedAt
+  sla_breaches_at: slaBreachesAt customer_ticket_count: customerTicketCount
+  integration_source_type: integrationSourceType trashed`;
+
+const issueSpec = listSpec({
+  connection: "issues",
+  single: "issue",
+  fields: issueFields,
+  item: IssueObjectSchema,
+  updatedAt: (issue) => issue.updated_at,
+  rows: rowsOf((issue) => ({ ...issue, version: issue.updated_at, _deleted: false })),
+});
+
+export const makeIssues = (client: LinearClientService) =>
+  Resource.entity({
+    name: "issues",
+    rowSchema: IssueSchema,
+    version: "version",
+
+    check: checkList(client, issueSpec),
+    backfill: backfillList(client, issueSpec),
+    changes: changesList(client, issueSpec),
+    webhook: webhookList(client, issueSpec),
+  });
+
+const issueRelationSpec = listSpec({
+  connection: "issueRelations",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    issue_id: issue { id } related_issue_id: relatedIssue { id } type`,
+  item: IssueRelationObjectSchema,
+  updatedAt: (relation) => relation.updated_at,
+  rows: rowsOf((relation) => ({ ...relation, version: relation.updated_at })),
+});
+
+export const makeIssueRelations = (client: LinearClientService) =>
+  Resource.entity({
+    name: "issue_relations",
+    rowSchema: IssueRelationSchema,
+    version: "version",
+
+    check: checkList(client, issueRelationSpec),
+    backfill: backfillList(client, issueRelationSpec),
+    changes: changesList(client, issueRelationSpec),
+  });
+
+const attachmentSpec = listSpec({
+  connection: "attachments",
+  single: "attachment",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    issue_id: issue { id } creator_id: creator { id }
+    external_user_creator_id: externalUserCreator { id }
+    title subtitle url source_type: sourceType`,
+  item: AttachmentObjectSchema,
+  updatedAt: (attachment) => attachment.updated_at,
+  rows: rowsOf((attachment) => ({
+    ...attachment,
+    version: attachment.updated_at,
+    _deleted: false,
+  })),
+});
+
+export const makeAttachments = (client: LinearClientService) =>
+  Resource.entity({
+    name: "attachments",
+    rowSchema: AttachmentSchema,
+    version: "version",
+
+    check: checkList(client, attachmentSpec),
+    backfill: backfillList(client, attachmentSpec),
+    changes: changesList(client, attachmentSpec),
+    webhook: webhookList(client, attachmentSpec),
+  });
+
+const issueLabelSpec = listSpec({
+  connection: "issueLabels",
+  single: "issueLabel",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description color is_group: isGroup parent_id: parent { id } team_id: team { id }
+    creator_id: creator { id } retired_at: retiredAt`,
+  item: IssueLabelObjectSchema,
+  updatedAt: (label) => label.updated_at,
+  rows: rowsOf((label) => ({ ...label, version: label.updated_at, _deleted: false })),
+});
+
+export const makeIssueLabels = (client: LinearClientService) =>
+  Resource.entity({
+    name: "issue_labels",
+    rowSchema: IssueLabelSchema,
+    version: "version",
+
+    ...listSources(client, issueLabelSpec),
+    webhook: webhookList(client, issueLabelSpec),
+  });

package/src/resources/pages.ts

@@ -0,0 +1,264 @@
+import { ConnectorError, Cursor, Fetch } from "@useairfoil/connector-kit";
+import {
+  Array as Arr,
+  DateTime,
+  Duration,
+  Effect,
+  Option,
+  Schema,
+  SchemaTransformation,
+  Stream,
+  String as Str,
+} from "effect";
+
+import type { LinearClientService } from "../client/client";
+
+const changesInterval = Duration.minutes(5);
+const hourly = Duration.hours(1);
+// A run stops after this many pages and the next one starts right away.
+const maxPagesPerRun = 20;
+// Updates can show up in a list late, so each changes read starts a bit early.
+const changesOverlap = Duration.minutes(1);
+
+type ListSpec<Item, Row> = {
+  /** List query, such as `issues`. */
+  readonly connection: string;
+  /** Single-item query for webhooks, such as `issue`. */
+  readonly single?: string;
+  /** GraphQL fields, aliased to match the schema. */
+  readonly fields: string;
+  readonly item: Schema.Decoder<Item>;
+  /** Page size. Lower it for queries with nested lists. */
+  readonly first?: number;
+  readonly updatedAt: (item: Item) => Date;
+  /** Builds rows and may fetch more nested pages. */
+  readonly rows: (items: ReadonlyArray<Item>) => Effect.Effect<ReadonlyArray<Row>, ConnectorError>;
+};
+
+/** Keeps item types inferred in the callbacks. */
+export const listSpec = <Item, Row>(spec: ListSpec<Item, Row>) => spec;
+
+export const rowsOf =
+  <Item, Row>(toRow: (item: Item) => Row) =>
+  (items: ReadonlyArray<Item>) =>
+    Effect.succeed(items.map(toRow));
+
+type Page<Item> = {
+  readonly items: ReadonlyArray<Item>;
+  readonly next: Option.Option<string>;
+};
+
+const PageInfoSchema = Schema.Struct({
+  hasNextPage: Schema.Boolean,
+  endCursor: Schema.NullOr(Schema.String),
+});
+
+const readPage = <Item, Row>(
+  client: LinearClientService,
+  spec: ListSpec<Item, Row>,
+  options: {
+    readonly orderBy: "createdAt" | "updatedAt";
+    readonly after: Option.Option<string>;
+    readonly first?: number;
+  },
+): Effect.Effect<Page<Item>, ConnectorError> =>
+  client
+    .query(
+      Schema.Struct({
+        page: Schema.Struct({ nodes: Schema.Array(spec.item), pageInfo: PageInfoSchema }),
+      }).pipe(Schema.encodeKeys({ page: spec.connection })),
+      `query ${Str.capitalize(spec.connection)}($first: Int!, $after: String, $orderBy: PaginationOrderBy) {
+  ${spec.connection}(first: $first, after: $after, orderBy: $orderBy, includeArchived: true) {
+    nodes { ${spec.fields} }
+    pageInfo { hasNextPage endCursor }
+  }
+}`,
+      {
+        first: options.first ?? spec.first ?? 250,
+        after: Option.getOrNull(options.after),
+        orderBy: options.orderBy,
+      },
+    )
+    .pipe(
+      Effect.map(({ page }) => ({
+        items: page.nodes,
+        next: page.pageInfo.hasNextPage
+          ? Option.fromNullishOr(page.pageInfo.endCursor)
+          : Option.none(),
+      })),
+    );
+
+const listAll = <Item, Row>(
+  client: LinearClientService,
+  spec: ListSpec<Item, Row>,
+): Effect.Effect<ReadonlyArray<Item>, ConnectorError> =>
+  Stream.paginate(Option.none<string>(), (after) =>
+    readPage(client, spec, { orderBy: "createdAt", after }).pipe(
+      Effect.map(({ items, next }) => [items, Option.map(next, Option.some)] as const),
+    ),
+  ).pipe(Stream.runCollect);
+
+export const checkList = <Item, Row>(client: LinearClientService, spec: ListSpec<Item, Row>) =>
+  readPage(client, spec, { orderBy: "createdAt", after: Option.none(), first: 1 }).pipe(
+    Effect.flatMap(({ items }) => spec.rows(items)),
+    Effect.asVoid,
+  );
+
+/** Small lists are read in full every hour. */
+export const listSources = <Item, Row extends object>(
+  client: LinearClientService,
+  spec: ListSpec<Item, Row>,
+) => {
+  const read = listAll(client, spec).pipe(Effect.flatMap(spec.rows));
+  return {
+    check: checkList(client, spec),
+    backfill: Fetch.page({
+      pageCursor: Cursor.string(),
+      cutoff: Cursor.isoDateTime(),
+      fetch: () => read.pipe(Effect.map((rows) => ({ rows, hasMore: false }))),
+    }),
+    changes: Fetch.changes({
+      cursor: Cursor.string(),
+      interval: hourly,
+      fetch: () =>
+        Effect.all([read, DateTime.now]).pipe(
+          Effect.map(([rows, now]) => ({ rows, cursor: DateTime.formatIso(now) })),
+        ),
+    }),
+  };
+};
+
+/** Changes pick up items created during backfill. */
+export const backfillList = <Item, Row extends object>(
+  client: LinearClientService,
+  spec: ListSpec<Item, Row>,
+) =>
+  Fetch.page({
+    pageCursor: Cursor.string(),
+    cutoff: Cursor.isoDateTime(),
+    fetch: ({ pageCursor }) =>
+      Effect.gen(function* () {
+        const page = yield* readPage(client, spec, {
+          orderBy: "createdAt",
+          after: Option.fromNullishOr(typeof pageCursor === "string" ? pageCursor : undefined),
+        });
+        return {
+          rows: yield* spec.rows(page.items),
+          hasMore: Option.isSome(page.next),
+          ...Option.match(page.next, {
+            onNone: () => ({}),
+            onSome: (nextPageCursor) => ({ nextPageCursor }),
+          }),
+        };
+      }),
+  });
+
+/**
+ * `since` is when the last run started. `pending` is set while a run is split:
+ * `until` is the start of that run, and `after` the page to go on from.
+ */
+const ChangesCursorSchema = Schema.Struct({
+  since: Schema.DateTimeUtcFromString,
+  pending: Schema.optional(
+    Schema.Struct({ until: Schema.DateTimeUtcFromString, after: Schema.String }),
+  ),
+});
+
+type ChangesCursor = Schema.Schema.Type<typeof ChangesCursorSchema>;
+
+const ChangesCursorCodec = Schema.Union([
+  Schema.fromJsonString(ChangesCursorSchema),
+  // The first cursor is the backfill cutoff, a plain ISO time.
+  Schema.DateTimeUtcFromString.pipe(
+    Schema.decodeTo(
+      Schema.toType(ChangesCursorSchema),
+      SchemaTransformation.transform({
+        decode: (since): ChangesCursor => ({ since }),
+        encode: (cursor) => cursor.since,
+      }),
+    ),
+  ),
+]);
+
+const cursorError = (cause: Schema.SchemaError) =>
+  new ConnectorError({ message: "Invalid Linear changes cursor", cause });
+
+/**
+ * Newest first: an edit during paging is read again on the next run.
+ */
+export const changesList = <Item, Row extends object>(
+  client: LinearClientService,
+  spec: ListSpec<Item, Row>,
+) =>
+  Fetch.changes({
+    cursor: Cursor.string(),
+    interval: changesInterval,
+    fetch: ({ cursor }) =>
+      Effect.gen(function* () {
+        const state = yield* Schema.decodeUnknownEffect(ChangesCursorCodec)(String(cursor)).pipe(
+          Effect.mapError(cursorError),
+        );
+        const until = state.pending?.until ?? (yield* DateTime.now);
+        const from = DateTime.toDateUtc(DateTime.subtractDuration(state.since, changesOverlap));
+        const isRecent = (item: Item) => spec.updatedAt(item).getTime() >= from.getTime();
+
+        const pages = yield* Stream.paginate(Option.fromNullishOr(state.pending?.after), (after) =>
+          Effect.gen(function* () {
+            const page = yield* readPage(client, spec, { orderBy: "updatedAt", after });
+            const recent = page.items.filter(isRecent);
+            const next = recent.length === page.items.length ? page.next : Option.none();
+            const rows = yield* spec.rows(recent);
+            return [[{ rows, next }], Option.map(next, Option.some)] as const;
+          }),
+        ).pipe(Stream.take(maxPagesPerRun), Stream.runCollect);
+
+        const rows = pages.flatMap((page) => page.rows);
+        const after = Option.flatMap(Arr.last(pages), (page) => page.next);
+        const next: ChangesCursor =
+          pages.length === maxPagesPerRun && Option.isSome(after)
+            ? { since: state.since, pending: { until, after: after.value } }
+            : { since: until };
+        return {
+          rows,
+          cursor: yield* Schema.encodeEffect(Schema.fromJsonString(ChangesCursorSchema))(next).pipe(
+            Effect.mapError(cursorError),
+          ),
+          hasMore: next.pending !== undefined,
+        };
+      }),
+  });
+
+const WebhookPayloadSchema = Schema.Struct({
+  data: Schema.Struct({ id: Schema.String }),
+  webhookTimestamp: Schema.Number,
+});
+
+type WebhookPayload = Schema.Schema.Type<typeof WebhookPayloadSchema>;
+
+/**
+ * Archive and trash also send `remove`, without changing `updatedAt`.
+ * Read the item again; delete only if it's gone. Use the webhook time as the version.
+ */
+export const webhookList = <Item, Row extends object>(
+  client: LinearClientService,
+  spec: ListSpec<Item, Row>,
+) => ({
+  schema: WebhookPayloadSchema,
+  handler: ({ payload }: { readonly payload: WebhookPayload }) =>
+    Effect.gen(function* () {
+      const version = new Date(payload.webhookTimestamp);
+      const single = spec.single ?? spec.connection;
+      const found = yield* client.find(
+        Schema.Struct({ item: spec.item }).pipe(Schema.encodeKeys({ item: single })),
+        `query ${Str.capitalize(single)}($id: String!) {
+  ${single}(id: $id) { ${spec.fields} }
+}`,
+        { id: payload.data.id },
+      );
+      return yield* Option.match(found, {
+        onNone: () => Effect.succeed([{ id: payload.data.id, version, _deleted: true as const }]),
+        onSome: ({ item }) =>
+          spec.rows([item]).pipe(Effect.map((rows) => rows.map((row) => ({ ...row, version })))),
+      });
+    }),
+});