@useairfoil/producer-linear 0.0.1 → 0.0.3

package/src/schemas/releases.ts

@@ -0,0 +1,132 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, SchemaTransformation, Struct } from "effect";
+
+import { Long, OptionalRef, OptionalString, OptionalTimestamp, Ref, common } from "./shared";
+
+export const ReleaseSchema = Schema.Struct({
+  ...common("Release"),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Release name." })),
+  description: OptionalString.pipe(Schema.annotateKey({ description: "Description." })),
+  // `version` is the row version, so the release's own version is renamed.
+  release_version: OptionalString.pipe(
+    Schema.annotateKey({ description: "Version, such as 1.2.0." }),
+  ),
+  url: Schema.String.pipe(Schema.annotateKey({ description: "Release URL." })),
+  commit_sha: OptionalString.pipe(Schema.annotateKey({ description: "Commit SHA." })),
+  pipeline_id: Ref.pipe(Schema.annotateKey({ description: "Release pipeline." })),
+  stage_id: Ref.pipe(Schema.annotateKey({ description: "Release stage." })),
+  creator_id: OptionalRef.pipe(Schema.annotateKey({ description: "User who made the release." })),
+  start_date: OptionalString.pipe(
+    Schema.annotateKey({ description: "Start date, as YYYY-MM-DD." }),
+  ),
+  target_date: OptionalString.pipe(
+    Schema.annotateKey({ description: "Target date, as YYYY-MM-DD." }),
+  ),
+  started_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the release started." }),
+  ),
+  completed_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the release was completed." }),
+  ),
+  canceled_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the release was canceled." }),
+  ),
+  trashed: Schema.NullOr(Schema.Boolean).pipe(
+    Schema.annotateKey({ description: "Whether the release is in the trash." }),
+  ),
+})
+  .annotate({ description: "Linear releases. Needs the Business plan." })
+  .pipe(Iceberg.identifier("id"));
+
+export type Release = Schema.Schema.Type<typeof ReleaseSchema>;
+
+export const ReleaseObjectSchema = ReleaseSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);
+
+export const ReleaseNoteSchema = Schema.Struct({
+  ...common("Release note"),
+  title: OptionalString.pipe(Schema.annotateKey({ description: "Release note title." })),
+  content: Schema.NullOr(Schema.Struct({ content: OptionalString })).pipe(
+    Schema.decodeTo(
+      OptionalString,
+      SchemaTransformation.transform({
+        decode: (document) => document?.content ?? null,
+        encode: (content) => (content === null ? null : { content }),
+      }),
+    ),
+    Schema.annotateKey({ description: "Release note body in markdown." }),
+  ),
+  url: Schema.String.pipe(Schema.annotateKey({ description: "Release note URL." })),
+  pipeline_id: Ref.pipe(Schema.annotateKey({ description: "Release pipeline." })),
+  release_ids: Schema.Array(Ref).pipe(
+    Schema.annotateKey({ description: "Releases covered by the note." }),
+  ),
+})
+  .annotate({ description: "Linear release notes. Needs the Business plan." })
+  .pipe(Iceberg.identifier("id"));
+
+export type ReleaseNote = Schema.Schema.Type<typeof ReleaseNoteSchema>;
+
+export const ReleaseNoteObjectSchema = ReleaseNoteSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);
+
+export const ReleasePipelineSchema = Schema.Struct({
+  ...common("Pipeline"),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Pipeline name." })),
+  type: Schema.String.pipe(Schema.annotateKey({ description: "Pipeline type." })),
+  is_production: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether it releases to production." }),
+  ),
+  url: Schema.String.pipe(Schema.annotateKey({ description: "Pipeline URL." })),
+  include_path_patterns: Schema.Array(Schema.String).pipe(
+    Schema.annotateKey({ description: "File paths that count toward the pipeline." }),
+  ),
+  approximate_release_count: Long.pipe(
+    Schema.annotateKey({ description: "About how many releases it has." }),
+  ),
+  trashed: Schema.NullOr(Schema.Boolean).pipe(
+    Schema.annotateKey({ description: "Whether the pipeline is in the trash." }),
+  ),
+})
+  .annotate({ description: "Linear release pipelines. Needs the Business plan." })
+  .pipe(Iceberg.identifier("id"));
+
+export type ReleasePipeline = Schema.Schema.Type<typeof ReleasePipelineSchema>;
+
+export const ReleasePipelineObjectSchema = ReleasePipelineSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);
+
+export const ReleaseStageSchema = Schema.Struct({
+  ...common("Stage"),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Stage name." })),
+  type: Schema.String.pipe(Schema.annotateKey({ description: "Stage type." })),
+  color: Schema.String.pipe(Schema.annotateKey({ description: "Color, as hex." })),
+  position: Schema.Finite.pipe(Schema.annotateKey({ description: "Order in the pipeline." })),
+  frozen: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the stage is frozen." })),
+  pipeline_id: Ref.pipe(Schema.annotateKey({ description: "Release pipeline." })),
+})
+  .annotate({ description: "Linear release stages. Needs the Business plan." })
+  .pipe(Iceberg.identifier("id"));
+
+export type ReleaseStage = Schema.Schema.Type<typeof ReleaseStageSchema>;
+
+export const ReleaseStageObjectSchema = ReleaseStageSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);
+
+export const IssueToReleaseSchema = Schema.Struct({
+  ...common("Link"),
+  issue_id: Ref.pipe(Schema.annotateKey({ description: "Issue." })),
+  release_id: Ref.pipe(Schema.annotateKey({ description: "Release." })),
+})
+  .annotate({ description: "Links between Linear issues and releases. Needs the Business plan." })
+  .pipe(Iceberg.identifier("id"));
+
+export type IssueToRelease = Schema.Schema.Type<typeof IssueToReleaseSchema>;
+
+export const IssueToReleaseObjectSchema = IssueToReleaseSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);

package/src/schemas/shared.ts

@@ -0,0 +1,68 @@
+import { Schema, SchemaTransformation } from "effect";
+
+export const Timestamp = Schema.DateFromString;
+
+/** Decodes a GraphQL Int as bigint for an Iceberg long. */
+export const Long = Schema.Int.pipe(
+  Schema.decodeTo(
+    Schema.BigInt,
+    SchemaTransformation.transform({
+      decode: (value) => BigInt(value),
+      encode: (value) => Number(value),
+    }),
+  ),
+);
+
+/** Decodes a linked object such as `assignee { id }` as its ID. */
+export const Ref = Schema.Struct({ id: Schema.String }).pipe(
+  Schema.decodeTo(
+    Schema.String,
+    SchemaTransformation.transform({
+      decode: (ref) => ref.id,
+      encode: (id) => ({ id }),
+    }),
+  ),
+);
+
+export const OptionalRef = Schema.NullOr(Ref);
+
+export const OptionalTimestamp = Schema.NullOr(Timestamp);
+
+export const OptionalString = Schema.NullOr(Schema.String);
+
+const RefConnection = Schema.Struct({ nodes: Schema.Array(Schema.Struct({ id: Schema.String })) });
+
+/** Decodes connection nodes as IDs. The query must fetch any extra pages. */
+export const RefList = RefConnection.pipe(
+  Schema.decodeTo(
+    Schema.Array(Schema.String),
+    SchemaTransformation.transform<ReadonlyArray<string>, typeof RefConnection.Type>({
+      decode: (connection) => connection.nodes.map((node) => node.id),
+      encode: (ids) => ({ nodes: ids.map((id) => ({ id })) }),
+    }),
+  ),
+);
+
+/** Rows use updated_at as version; lifecycle webhooks use the webhook time. */
+export const common = (object: string) => ({
+  id: Schema.String.pipe(Schema.annotateKey({ description: `${object} ID.` })),
+  version: Schema.Date.pipe(
+    Schema.annotateKey({ description: `Time Linear last changed the ${object.toLowerCase()}.` }),
+  ),
+  created_at: Timestamp.pipe(
+    Schema.annotateKey({ description: `Time the ${object.toLowerCase()} was created.` }),
+  ),
+  updated_at: Timestamp.pipe(
+    Schema.annotateKey({ description: `Time the ${object.toLowerCase()} was last updated.` }),
+  ),
+  archived_at: Schema.NullOr(Timestamp).pipe(
+    Schema.annotateKey({
+      description: `Time the ${object.toLowerCase()} was archived or trashed.`,
+    }),
+  ),
+});
+
+export const deleted = (object: string) =>
+  Schema.optional(Schema.Boolean).pipe(
+    Schema.annotateKey({ description: `Whether the ${object} was deleted in Linear.` }),
+  );

package/src/schemas/teams.ts

@@ -0,0 +1,177 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import {
+  OptionalRef,
+  OptionalString,
+  OptionalTimestamp,
+  Ref,
+  Timestamp,
+  common,
+  deleted,
+} from "./shared";
+
+export const TeamSchema = Schema.Struct({
+  ...common("Team"),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Team name." })),
+  key: Schema.String.pipe(
+    Schema.annotateKey({ description: "Team key, used in issue IDs such as ENG-123." }),
+  ),
+  display_name: Schema.String.pipe(Schema.annotateKey({ description: "Name shown in Linear." })),
+  description: OptionalString.pipe(Schema.annotateKey({ description: "Team description." })),
+  visibility: Schema.String.pipe(Schema.annotateKey({ description: "Who can see the team." })),
+  parent_id: OptionalRef.pipe(Schema.annotateKey({ description: "Parent team." })),
+  timezone: Schema.String.pipe(Schema.annotateKey({ description: "Team timezone." })),
+  cycles_enabled: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the team uses cycles." }),
+  ),
+  cycle_duration: Schema.Finite.pipe(Schema.annotateKey({ description: "Cycle length in weeks." })),
+  cycle_cooldown_time: Schema.Finite.pipe(
+    Schema.annotateKey({ description: "Weeks between cycles." }),
+  ),
+  cycle_start_day: Schema.Finite.pipe(
+    Schema.annotateKey({ description: "Day cycles start, 0 for Sunday." }),
+  ),
+  triage_enabled: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the team uses triage." }),
+  ),
+  issue_estimation_type: Schema.String.pipe(Schema.annotateKey({ description: "Estimate scale." })),
+  default_issue_estimate: Schema.Finite.pipe(
+    Schema.annotateKey({ description: "Default estimate." }),
+  ),
+  auto_archive_period: Schema.Finite.pipe(
+    Schema.annotateKey({ description: "Months before closed issues are archived." }),
+  ),
+  auto_close_period: Schema.NullOr(Schema.Finite).pipe(
+    Schema.annotateKey({ description: "Months before stale issues are closed." }),
+  ),
+  retired_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the team was retired." }),
+  ),
+})
+  .annotate({ description: "Linear teams." })
+  .pipe(Iceberg.identifier("id"));
+
+export type Team = Schema.Schema.Type<typeof TeamSchema>;
+
+export const TeamObjectSchema = TeamSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+
+export const TeamMembershipSchema = Schema.Struct({
+  ...common("Membership"),
+  team_id: Ref.pipe(Schema.annotateKey({ description: "Team." })),
+  user_id: Ref.pipe(Schema.annotateKey({ description: "User." })),
+  owner: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the user owns the team." }),
+  ),
+})
+  .annotate({ description: "Linear team members. Removed members aren't seen." })
+  .pipe(Iceberg.identifier("id"));
+
+export type TeamMembership = Schema.Schema.Type<typeof TeamMembershipSchema>;
+
+export const TeamMembershipObjectSchema = TeamMembershipSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);
+
+export const WorkflowStateSchema = Schema.Struct({
+  ...common("Workflow state"),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "State name." })),
+  type: Schema.String.pipe(
+    Schema.annotateKey({
+      description: "State type: triage, backlog, unstarted, started, completed, or canceled.",
+    }),
+  ),
+  color: Schema.String.pipe(Schema.annotateKey({ description: "State color, as hex." })),
+  description: OptionalString.pipe(Schema.annotateKey({ description: "State description." })),
+  position: Schema.Finite.pipe(Schema.annotateKey({ description: "Order within the team." })),
+  team_id: Ref.pipe(Schema.annotateKey({ description: "Team." })),
+})
+  .annotate({ description: "Linear workflow states. Names the IDs in `issues.state_id`." })
+  .pipe(Iceberg.identifier("id"));
+
+export type WorkflowState = Schema.Schema.Type<typeof WorkflowStateSchema>;
+
+export const WorkflowStateObjectSchema = WorkflowStateSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);
+
+export const UserSchema = Schema.Struct({
+  ...common("User"),
+  _deleted: deleted("user"),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Full name." })),
+  display_name: Schema.String.pipe(Schema.annotateKey({ description: "Display name." })),
+  email: Schema.String.pipe(Schema.annotateKey({ description: "Email address." })),
+  avatar_url: OptionalString.pipe(Schema.annotateKey({ description: "Avatar image URL." })),
+  title: OptionalString.pipe(Schema.annotateKey({ description: "Job title." })),
+  timezone: OptionalString.pipe(Schema.annotateKey({ description: "Timezone." })),
+  active: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the user is active." })),
+  admin: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the user is an admin." })),
+  owner: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the user owns the workspace." }),
+  ),
+  guest: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the user is a guest." })),
+  app: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the user is an app or agent." }),
+  ),
+  last_seen: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the user was last online." }),
+  ),
+  url: Schema.String.pipe(Schema.annotateKey({ description: "Profile URL." })),
+})
+  .annotate({ description: "Linear users." })
+  .pipe(Iceberg.identifier("id"));
+
+export type User = Schema.Schema.Type<typeof UserSchema>;
+
+export const UserObjectSchema = UserSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version", "_deleted"]),
+);
+
+export const ExternalUserSchema = Schema.Struct({
+  ...common("External user"),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Name." })),
+  display_name: Schema.String.pipe(Schema.annotateKey({ description: "Display name." })),
+  email: OptionalString.pipe(Schema.annotateKey({ description: "Email address." })),
+  avatar_url: OptionalString.pipe(Schema.annotateKey({ description: "Avatar image URL." })),
+  last_seen: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the user was last seen." }),
+  ),
+})
+  .annotate({
+    description: "People from integrations, such as Slack, who create issues and comments.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type ExternalUser = Schema.Schema.Type<typeof ExternalUserSchema>;
+
+export const ExternalUserObjectSchema = ExternalUserSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);
+
+export const CycleSchema = Schema.Struct({
+  ...common("Cycle"),
+  _deleted: deleted("cycle"),
+  number: Schema.Finite.pipe(Schema.annotateKey({ description: "Cycle number within its team." })),
+  name: OptionalString.pipe(Schema.annotateKey({ description: "Cycle name." })),
+  description: OptionalString.pipe(Schema.annotateKey({ description: "Cycle description." })),
+  team_id: Ref.pipe(Schema.annotateKey({ description: "Team." })),
+  starts_at: Timestamp.pipe(Schema.annotateKey({ description: "Time the cycle starts." })),
+  ends_at: Timestamp.pipe(Schema.annotateKey({ description: "Time the cycle ends." })),
+  completed_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the cycle was completed." }),
+  ),
+  auto_archived_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the cycle was archived automatically." }),
+  ),
+  progress: Schema.Finite.pipe(
+    Schema.annotateKey({ description: "Share of the scope completed, from 0 to 1." }),
+  ),
+})
+  .annotate({ description: "Linear cycles." })
+  .pipe(Iceberg.identifier("id"));
+
+export type Cycle = Schema.Schema.Type<typeof CycleSchema>;
+
+export const CycleObjectSchema = CycleSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version", "_deleted"]),
+);

package/src/start.ts

@@ -0,0 +1,47 @@
+import { PgClient } from "@effect/sql-pg";
+import {
+  ConnectorApp,
+  Ingestor,
+  RuntimeConfig,
+  StateStore,
+  Telemetry,
+} from "@useairfoil/connector-kit";
+import { Config, Effect, Layer, Logger, Schema } from "effect";
+import { Command } from "effect/cli";
+
+import { LinearConnector } from "./index";
+
+const ConnectorLayer = LinearConnector.layerConfig(LinearConnector.LinearConfigDef.config);
+const TelemetryLayer = Telemetry.layerOtlp();
+const PostgresLayer = PgClient.layerConfig({
+  url: Config.schema(
+    Schema.Redacted(Schema.NonEmptyString),
+    RuntimeConfig.PlatformRuntimeKey.postgresConnectionString,
+  ),
+  maxConnections: Config.succeed(2),
+  connectTimeout: Config.succeed("5 seconds"),
+  applicationName: Config.succeed("airfoil-producer-linear"),
+});
+const StateStoreLayer = StateStore.layerSql().pipe(Layer.provide(PostgresLayer));
+
+export const startCommand = Command.make("start", {}, () =>
+  Effect.gen(function* () {
+    const port = yield* RuntimeConfig.httpPort;
+    const entrypoint = yield* LinearConnector.LinearConnector;
+
+    return yield* ConnectorApp.start(entrypoint, { port }).pipe(
+      Effect.provide(Ingestor.layerArrowFlightConfig(entrypoint)),
+    );
+  }).pipe(
+    Effect.annotateLogs({ component: "linear" }),
+    Effect.provide(
+      Layer.mergeAll(
+        StateStoreLayer,
+        ConnectorLayer,
+        Logger.layer([Logger.consolePretty()]),
+        TelemetryLayer,
+      ),
+    ),
+    Effect.provide(RuntimeConfig.layerHosted()),
+  ),
+).pipe(Command.withDescription("Run the connector"));

package/src/tables.ts

@@ -0,0 +1,83 @@
+import type { Schema } from "effect";
+
+import { CommentSchema } from "./schemas/comments";
+import {
+  CustomerNeedSchema,
+  CustomerSchema,
+  CustomerStatusSchema,
+  CustomerTierSchema,
+} from "./schemas/customers";
+import { DocumentSchema } from "./schemas/documents";
+import {
+  InitiativeLabelSchema,
+  InitiativeRelationSchema,
+  InitiativeSchema,
+  InitiativeToProjectSchema,
+  InitiativeUpdateSchema,
+} from "./schemas/initiatives";
+import {
+  AttachmentSchema,
+  IssueHistorySchema,
+  IssueLabelSchema,
+  IssueRelationSchema,
+  IssueSchema,
+} from "./schemas/issues";
+import {
+  ProjectLabelSchema,
+  ProjectMilestoneSchema,
+  ProjectRelationSchema,
+  ProjectSchema,
+  ProjectStatusSchema,
+  ProjectUpdateSchema,
+} from "./schemas/projects";
+import {
+  IssueToReleaseSchema,
+  ReleaseNoteSchema,
+  ReleasePipelineSchema,
+  ReleaseSchema,
+  ReleaseStageSchema,
+} from "./schemas/releases";
+import {
+  CycleSchema,
+  ExternalUserSchema,
+  TeamMembershipSchema,
+  TeamSchema,
+  UserSchema,
+  WorkflowStateSchema,
+} from "./schemas/teams";
+
+export const tableSchemas: Readonly<Record<string, Schema.Top>> = {
+  issues: IssueSchema,
+  issue_history: IssueHistorySchema,
+  comments: CommentSchema,
+  issue_relations: IssueRelationSchema,
+  attachments: AttachmentSchema,
+  issue_labels: IssueLabelSchema,
+  workflow_states: WorkflowStateSchema,
+  teams: TeamSchema,
+  team_memberships: TeamMembershipSchema,
+  users: UserSchema,
+  external_users: ExternalUserSchema,
+  cycles: CycleSchema,
+  projects: ProjectSchema,
+  project_milestones: ProjectMilestoneSchema,
+  project_updates: ProjectUpdateSchema,
+  project_statuses: ProjectStatusSchema,
+  project_labels: ProjectLabelSchema,
+  project_relations: ProjectRelationSchema,
+  initiatives: InitiativeSchema,
+  initiative_updates: InitiativeUpdateSchema,
+  initiative_labels: InitiativeLabelSchema,
+  initiative_relations: InitiativeRelationSchema,
+  initiative_to_projects: InitiativeToProjectSchema,
+  documents: DocumentSchema,
+  customers: CustomerSchema,
+  customer_needs: CustomerNeedSchema,
+  customer_statuses: CustomerStatusSchema,
+  customer_tiers: CustomerTierSchema,
+  releases: ReleaseSchema,
+  release_notes: ReleaseNoteSchema,
+  release_pipelines: ReleasePipelineSchema,
+  release_stages: ReleaseStageSchema,
+  issue_to_releases: IssueToReleaseSchema,
+};

package/src/webhook/route.ts

@@ -0,0 +1,50 @@
+import { type ResourceDefinition, Webhook } from "@useairfoil/connector-kit";
+import { Effect, Result, Schema } from "effect";
+import { HttpServerResponse } from "effect/http";
+
+import { verifySignature } from "./signature";
+
+export const webhookPath = "/webhooks/linear";
+
+const WebhookEventSchema = Schema.Struct({
+  type: Schema.String,
+  action: Schema.String,
+  webhookTimestamp: Schema.Number,
+  data: Schema.Struct({ id: Schema.String }),
+});
+
+export const makeWebhookRoute = (options: {
+  readonly secret: string;
+  /** Resources by the event's `type`, such as `Issue`. */
+  readonly targets: ReadonlyMap<string, ResourceDefinition>;
+  readonly issueHistory: ResourceDefinition;
+}) =>
+  Webhook.route({
+    path: webhookPath,
+    ackMode: "after-enqueue",
+    schema: WebhookEventSchema,
+    handler: ({ request, rawBody, payload, to }) =>
+      Effect.gen(function* () {
+        const verified = yield* verifySignature({
+          rawBody,
+          header: request.headers["linear-signature"],
+          secret: options.secret,
+          timestamp: payload.webhookTimestamp,
+        }).pipe(Effect.result);
+        if (Result.isFailure(verified)) {
+          return HttpServerResponse.jsonUnsafe(
+            { ok: false, error: verified.failure.message },
+            { status: 401 },
+          );
+        }
+
+        // Polling reads creates and updates.
+        const resource = options.targets.get(payload.type);
+        if (payload.action === "remove" || payload.action === "restore") {
+          if (resource !== undefined) yield* to(resource, payload);
+          if (payload.type === "Issue") yield* to(options.issueHistory, payload);
+        }
+
+        return HttpServerResponse.jsonUnsafe({ ok: true });
+      }),
+  });

package/src/webhook/signature.ts

@@ -0,0 +1,28 @@
+import { ConnectorError } from "@useairfoil/connector-kit";
+import { DateTime, Effect } from "effect";
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+// Linear suggests rejecting deliveries more than a minute old, to stop replays.
+const maxAgeMillis = 60_000;
+
+export const verifySignature = (options: {
+  readonly rawBody: Uint8Array;
+  readonly header: string | undefined;
+  readonly secret: string;
+  /** `webhookTimestamp` from the body, in milliseconds. */
+  readonly timestamp: number | undefined;
+}): Effect.Effect<void, ConnectorError> =>
+  Effect.gen(function* () {
+    const expected = createHmac("sha256", options.secret).update(options.rawBody).digest();
+    const provided = Buffer.from(options.header ?? "", "hex");
+    if (provided.length !== expected.length || !timingSafeEqual(provided, expected)) {
+      return yield* new ConnectorError({ message: "Invalid Linear webhook signature" });
+    }
+    const now = yield* DateTime.nowAsDate;
+    if (
+      options.timestamp === undefined ||
+      Math.abs(now.getTime() - options.timestamp) > maxAgeMillis
+    ) {
+      return yield* new ConnectorError({ message: "Linear webhook is too old" });
+    }
+  });