@useairfoil/producer-github 0.0.1 → 0.0.3

package/src/schemas/pull-requests.ts

@@ -0,0 +1,95 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Text, Timestamp, label, milestone, optionalList, user, version } from "./shared";
+
+const branch = Schema.Struct({
+  ref: Schema.String.pipe(Schema.annotateKey({ description: "Branch name." })),
+  sha: Schema.String.pipe(Schema.annotateKey({ description: "Commit SHA." })),
+  label: Schema.String.pipe(
+    Schema.annotateKey({ description: "Owner and branch, such as octocat:main." }),
+  ),
+});
+
+export const PullRequestSchema = Schema.Struct({
+  id: Long.pipe(
+    Schema.annotateKey({ description: "Unique pull request ID. Not the ID of its issue." }),
+  ),
+  version: version("pull request"),
+  node_id: Schema.String.pipe(
+    Schema.annotateKey({ description: "GraphQL node ID of the pull request." }),
+  ),
+  repository_id: Long.pipe(
+    Schema.annotateKey({ description: "ID of the repository the pull request belongs to." }),
+  ),
+  number: Long.pipe(Schema.annotateKey({ description: "Pull request number in the repository." })),
+  title: Schema.String.pipe(Schema.annotateKey({ description: "Pull request title." })),
+  body: Text.pipe(
+    Schema.annotateKey({
+      description: "Pull request description in Markdown. Empty when not set.",
+    }),
+  ),
+  state: Schema.String.pipe(
+    Schema.annotateKey({ description: "State: open or closed. Merged pull requests are closed." }),
+  ),
+  draft: Schema.optionalKey(Schema.Boolean).pipe(
+    Schema.annotateKey({ description: "Whether the pull request is a draft." }),
+  ),
+  locked: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the conversation is locked." }),
+  ),
+  user: Schema.NullOr(user).pipe(
+    Schema.annotateKey({ description: "Account that opened the pull request." }),
+  ),
+  author_association: Schema.String.pipe(
+    Schema.annotateKey({
+      description: "Author's relation to the repository, such as OWNER or CONTRIBUTOR.",
+    }),
+  ),
+  labels: Schema.Array(label).pipe(
+    Schema.annotateKey({ description: "Labels on the pull request." }),
+  ),
+  assignees: Schema.Array(user).pipe(
+    Schema.annotateKey({ description: "Accounts assigned to the pull request." }),
+  ),
+  requested_reviewers: Schema.Array(user).pipe(
+    Schema.annotateKey({ description: "Accounts asked to review that have not reviewed yet." }),
+  ),
+  milestone: Schema.NullOr(milestone).pipe(
+    Schema.annotateKey({ description: "Milestone of the pull request." }),
+  ),
+  head: branch.pipe(Schema.annotateKey({ description: "Branch the changes come from." })),
+  base: branch.pipe(Schema.annotateKey({ description: "Branch the changes merge into." })),
+  created_at: Timestamp.pipe(
+    Schema.annotateKey({ description: "Time the pull request was opened." }),
+  ),
+  closed_at: Schema.NullOr(Timestamp).pipe(
+    Schema.annotateKey({ description: "Time the pull request was closed. Null while it is open." }),
+  ),
+  merged_at: Schema.NullOr(Timestamp).pipe(
+    Schema.annotateKey({ description: "Time the pull request was merged." }),
+  ),
+  html_url: Schema.String.pipe(Schema.annotateKey({ description: "Pull request page on GitHub." })),
+})
+  .annotate({
+    description: "Pull requests in the installation's repositories.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type PullRequest = Schema.Schema.Type<typeof PullRequestSchema>;
+
+export const PullRequestObjectSchema = PullRequestSchema.mapFields((fields) => ({
+  ...Struct.omit(fields, [
+    "version",
+    "repository_id",
+    "labels",
+    "assignees",
+    "requested_reviewers",
+  ]),
+  updated_at: Timestamp,
+  labels: optionalList(label),
+  assignees: optionalList(user),
+  requested_reviewers: optionalList(user),
+}));
+
+export type PullRequestObject = Schema.Schema.Type<typeof PullRequestObjectSchema>;

package/src/schemas/releases.ts

@@ -0,0 +1,70 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Text, Timestamp, deleted, user, version } from "./shared";
+
+const asset = Schema.Struct({
+  id: Long.pipe(Schema.annotateKey({ description: "Asset ID." })),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "File name." })),
+  label: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Label shown instead of the name." }),
+  ),
+  state: Schema.String.pipe(Schema.annotateKey({ description: "State: uploaded or open." })),
+  content_type: Schema.String.pipe(Schema.annotateKey({ description: "Media type of the file." })),
+  size: Long.pipe(Schema.annotateKey({ description: "Size in bytes." })),
+  download_count: Long.pipe(
+    Schema.annotateKey({ description: "Number of downloads when the release last changed." }),
+  ),
+  created_at: Timestamp.pipe(Schema.annotateKey({ description: "Time the asset was uploaded." })),
+  updated_at: Timestamp.pipe(Schema.annotateKey({ description: "Time the asset last changed." })),
+  browser_download_url: Schema.String.pipe(Schema.annotateKey({ description: "Download link." })),
+});
+
+export const ReleaseSchema = Schema.Struct({
+  id: Long.pipe(Schema.annotateKey({ description: "Unique release ID." })),
+  version: version("release"),
+  node_id: Schema.String.pipe(
+    Schema.annotateKey({ description: "GraphQL node ID of the release." }),
+  ),
+  repository_id: Long.pipe(
+    Schema.annotateKey({ description: "ID of the repository the release belongs to." }),
+  ),
+  tag_name: Schema.String.pipe(Schema.annotateKey({ description: "Tag of the release." })),
+  target_commitish: Schema.String.pipe(
+    Schema.annotateKey({ description: "Branch or commit the tag was created from." }),
+  ),
+  name: Text.pipe(Schema.annotateKey({ description: "Release title. Empty when not set." })),
+  body: Text.pipe(
+    Schema.annotateKey({ description: "Release notes in Markdown. Empty when not set." }),
+  ),
+  draft: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the release is a draft." }),
+  ),
+  prerelease: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the release is a pre-release." }),
+  ),
+  author: user.pipe(Schema.annotateKey({ description: "Account that created the release." })),
+  assets: Schema.Array(asset).pipe(
+    Schema.annotateKey({ description: "Files attached to the release." }),
+  ),
+  created_at: Timestamp.pipe(Schema.annotateKey({ description: "Time the release was created." })),
+  published_at: Schema.NullOr(Timestamp).pipe(
+    Schema.annotateKey({ description: "Time the release was published." }),
+  ),
+  html_url: Schema.String.pipe(Schema.annotateKey({ description: "Release page on GitHub." })),
+  _deleted: deleted("release"),
+})
+  .annotate({
+    description: "Releases in the installation's repositories, with their assets.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type Release = Schema.Schema.Type<typeof ReleaseSchema>;
+
+export const ReleaseObjectSchema = ReleaseSchema.mapFields((fields) => ({
+  ...Struct.omit(fields, ["version", "repository_id", "_deleted"]),
+  // Not always set, according to the API schema.
+  updated_at: Schema.optionalKey(Schema.NullOr(Timestamp)),
+}));
+
+export type ReleaseObject = Schema.Schema.Type<typeof ReleaseObjectSchema>;

package/src/schemas/repositories.ts

@@ -0,0 +1,73 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Effect, Schema, Struct } from "effect";
+
+import { Long, Text, Timestamp, deleted, optionalList, user, version } from "./shared";
+
+export const RepositorySchema = Schema.Struct({
+  id: Long.pipe(Schema.annotateKey({ description: "Unique repository ID." })),
+  version: version("repository"),
+  node_id: Schema.String.pipe(
+    Schema.annotateKey({ description: "GraphQL node ID of the repository." }),
+  ),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Repository name." })),
+  full_name: Schema.String.pipe(
+    Schema.annotateKey({ description: "Owner and name, such as octo-org/octo-repo." }),
+  ),
+  owner: user.pipe(Schema.annotateKey({ description: "Account that owns the repository." })),
+  private: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the repository is private." }),
+  ),
+  visibility: Schema.optionalKey(Schema.String).pipe(
+    Schema.annotateKey({ description: "Visibility: public, private, or internal." }),
+  ),
+  description: Text.pipe(
+    Schema.annotateKey({ description: "Repository description. Empty when not set." }),
+  ),
+  fork: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the repository is a fork." }),
+  ),
+  archived: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the repository is archived." }),
+  ),
+  disabled: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the repository is disabled." }),
+  ),
+  default_branch: Schema.String.pipe(Schema.annotateKey({ description: "Default branch name." })),
+  language: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Main language GitHub detected." }),
+  ),
+  topics: Schema.Array(Schema.String).pipe(
+    Schema.annotateKey({ description: "Repository topics." }),
+  ),
+  html_url: Schema.String.pipe(Schema.annotateKey({ description: "Repository page on GitHub." })),
+  created_at: Timestamp.pipe(
+    Schema.annotateKey({ description: "Time the repository was created." }),
+  ),
+  _deleted: deleted("repository"),
+})
+  .annotate({
+    description: "Repositories the GitHub App installation can read.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type Repository = Schema.Schema.Type<typeof RepositorySchema>;
+
+export const RepositoryObjectSchema = RepositorySchema.mapFields((fields) => ({
+  ...Struct.omit(fields, ["version", "topics", "_deleted"]),
+  updated_at: Timestamp,
+  topics: optionalList(Schema.String),
+}));
+
+export type RepositoryObject = Schema.Schema.Type<typeof RepositoryObjectSchema>;
+
+export const RepositoryRefSchema = Schema.Struct({
+  id: Schema.Number,
+  full_name: Schema.String,
+  has_issues: Schema.Boolean,
+  // GitHub documents it as optional, defaulting to true.
+  has_pull_requests: Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect.succeed(true))),
+  // In KB. An empty repository has 0, and its git lists return 409.
+  size: Schema.Number,
+});
+
+export type RepositoryRef = Schema.Schema.Type<typeof RepositoryRefSchema>;

package/src/schemas/shared.ts

@@ -0,0 +1,76 @@
+import { Schema, SchemaTransformation } from "effect";
+
+/** IDs and counts. Connector Kit maps whole numbers to Iceberg longs. */
+export const Long = Schema.Int.pipe(
+  Schema.decodeTo(
+    Schema.BigInt,
+    SchemaTransformation.transform({
+      decode: (value) => BigInt(value),
+      encode: (value) => Number(value),
+    }),
+  ),
+);
+
+export const Timestamp = Schema.DateFromString;
+
+/** Text GitHub can clear, such as a body. */
+export const Text = Schema.NullOr(Schema.String).pipe(
+  Schema.decodeTo(
+    Schema.String,
+    SchemaTransformation.transform({
+      decode: (value) => value ?? "",
+      encode: (value) => value,
+    }),
+  ),
+);
+
+/** `null` becomes an empty list. A webhook can leave the list out. */
+export const optionalList = <S extends Schema.Top>(item: S) =>
+  Schema.optionalKey(
+    Schema.NullOr(Schema.Array(item)).pipe(
+      Schema.decodeTo(
+        Schema.Array(Schema.toType(item)),
+        SchemaTransformation.transform({
+          decode: (value) => value ?? [],
+          encode: (value) => value,
+        }),
+      ),
+    ),
+  );
+
+export const user = Schema.Struct({
+  id: Long.pipe(Schema.annotateKey({ description: "GitHub user ID." })),
+  login: Schema.String.pipe(Schema.annotateKey({ description: "GitHub username." })),
+  type: Schema.String.pipe(
+    Schema.annotateKey({ description: "Account type, such as User, Bot, or Organization." }),
+  ),
+});
+
+export const label = Schema.Struct({
+  id: Long.pipe(Schema.annotateKey({ description: "Label ID." })),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Label name." })),
+});
+
+export const milestone = Schema.Struct({
+  id: Long.pipe(Schema.annotateKey({ description: "Milestone ID." })),
+  number: Long.pipe(Schema.annotateKey({ description: "Milestone number in the repository." })),
+  title: Schema.String.pipe(Schema.annotateKey({ description: "Milestone title." })),
+});
+
+export const version = (object: string) =>
+  Schema.Date.pipe(Schema.annotateKey({ description: `Time GitHub last updated the ${object}.` }));
+
+/** For objects without an update time. A newer read wins. */
+export const readVersion = (object: string) =>
+  Schema.Date.pipe(
+    Schema.annotateKey({
+      description: `Time the connector read the ${object}. GitHub has no update time for it.`,
+    }),
+  );
+
+export const deleted = (object: string) =>
+  Schema.optional(Schema.Boolean).pipe(
+    Schema.annotateKey({ description: `Whether the ${object} was deleted in GitHub.` }),
+  );
+
+export const ObjectRefSchema = Schema.Struct({ id: Long });

package/src/schemas/workflow-jobs.ts

@@ -0,0 +1,78 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Timestamp, readVersion } from "./shared";
+
+const step = Schema.Struct({
+  number: Long.pipe(Schema.annotateKey({ description: "Step number." })),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Step name." })),
+  status: Schema.String.pipe(
+    Schema.annotateKey({ description: "Status, such as queued, in_progress, or completed." }),
+  ),
+  conclusion: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Result of a completed step." }),
+  ),
+  started_at: Schema.optionalKey(Schema.NullOr(Timestamp)).pipe(
+    Schema.annotateKey({ description: "Time the step started." }),
+  ),
+  completed_at: Schema.optionalKey(Schema.NullOr(Timestamp)).pipe(
+    Schema.annotateKey({ description: "Time the step completed." }),
+  ),
+});
+
+export const WorkflowJobSchema = Schema.Struct({
+  id: Long.pipe(Schema.annotateKey({ description: "Unique job ID." })),
+  version: readVersion("job"),
+  node_id: Schema.String.pipe(Schema.annotateKey({ description: "GraphQL node ID of the job." })),
+  repository_id: Long.pipe(
+    Schema.annotateKey({ description: "ID of the repository the job belongs to." }),
+  ),
+  run_id: Long.pipe(Schema.annotateKey({ description: "ID of the workflow run." })),
+  run_attempt: Schema.optionalKey(Long).pipe(
+    Schema.annotateKey({ description: "Attempt of the run the job belongs to." }),
+  ),
+  workflow_name: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Workflow name." }),
+  ),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Job name." })),
+  head_sha: Schema.String.pipe(
+    Schema.annotateKey({ description: "SHA of the commit the job ran on." }),
+  ),
+  head_branch: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Branch the job ran on." }),
+  ),
+  status: Schema.String.pipe(
+    Schema.annotateKey({ description: "Status, such as queued, in_progress, or completed." }),
+  ),
+  conclusion: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Result of a completed job, such as success or failure." }),
+  ),
+  created_at: Timestamp.pipe(Schema.annotateKey({ description: "Time the job was queued." })),
+  started_at: Timestamp.pipe(Schema.annotateKey({ description: "Time the job started." })),
+  completed_at: Schema.NullOr(Timestamp).pipe(
+    Schema.annotateKey({ description: "Time the job completed." }),
+  ),
+  runner_name: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Name of the runner." }),
+  ),
+  labels: Schema.Array(Schema.String).pipe(
+    Schema.annotateKey({ description: "Runner labels the job asked for." }),
+  ),
+  steps: Schema.Array(step).pipe(Schema.annotateKey({ description: "Steps of the job." })),
+  html_url: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Job page on GitHub." }),
+  ),
+})
+  .annotate({
+    description: "Jobs of GitHub Actions workflow runs. Each run attempt has its own jobs.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type WorkflowJob = Schema.Schema.Type<typeof WorkflowJobSchema>;
+
+export const WorkflowJobObjectSchema = WorkflowJobSchema.mapFields((fields) => ({
+  ...Struct.omit(fields, ["version", "repository_id", "steps"]),
+  steps: Schema.optionalKey(Schema.Array(step)),
+}));
+
+export type WorkflowJobObject = Schema.Schema.Type<typeof WorkflowJobObjectSchema>;

package/src/schemas/workflow-runs.ts

@@ -0,0 +1,72 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Timestamp, user, version } from "./shared";
+
+export const WorkflowRunSchema = Schema.Struct({
+  id: Long.pipe(Schema.annotateKey({ description: "Unique workflow run ID." })),
+  version: version("workflow run"),
+  node_id: Schema.String.pipe(Schema.annotateKey({ description: "GraphQL node ID of the run." })),
+  repository_id: Long.pipe(
+    Schema.annotateKey({ description: "ID of the repository the run belongs to." }),
+  ),
+  workflow_id: Long.pipe(Schema.annotateKey({ description: "ID of the workflow." })),
+  name: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Workflow name." })),
+  display_title: Schema.String.pipe(
+    Schema.annotateKey({ description: "Title of the run, such as the commit message." }),
+  ),
+  path: Schema.String.pipe(Schema.annotateKey({ description: "Path of the workflow file." })),
+  event: Schema.String.pipe(
+    Schema.annotateKey({ description: "Event that started the run, such as push." }),
+  ),
+  status: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Status, such as queued, in_progress, or completed." }),
+  ),
+  conclusion: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Result of a completed run, such as success or failure." }),
+  ),
+  head_branch: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Branch the run is for." }),
+  ),
+  head_sha: Schema.String.pipe(
+    Schema.annotateKey({ description: "SHA of the commit the run is for." }),
+  ),
+  run_number: Long.pipe(Schema.annotateKey({ description: "Run number of the workflow." })),
+  run_attempt: Schema.optionalKey(Long).pipe(
+    Schema.annotateKey({ description: "Attempt number. Re-runs count up." }),
+  ),
+  check_suite_id: Schema.optionalKey(Long).pipe(
+    Schema.annotateKey({ description: "ID of the run's check suite." }),
+  ),
+  actor: Schema.optionalKey(user).pipe(
+    Schema.annotateKey({ description: "Account that started the first attempt." }),
+  ),
+  triggering_actor: Schema.optionalKey(user).pipe(
+    Schema.annotateKey({ description: "Account that started the latest attempt." }),
+  ),
+  pull_requests: Schema.Array(
+    Schema.Struct({
+      id: Long.pipe(Schema.annotateKey({ description: "Pull request ID." })),
+      number: Long.pipe(Schema.annotateKey({ description: "Pull request number." })),
+    }),
+  ).pipe(Schema.annotateKey({ description: "Pull requests the run is for. Empty for forks." })),
+  created_at: Timestamp.pipe(Schema.annotateKey({ description: "Time the run was created." })),
+  run_started_at: Schema.optionalKey(Timestamp).pipe(
+    Schema.annotateKey({ description: "Time the latest attempt started." }),
+  ),
+  html_url: Schema.String.pipe(Schema.annotateKey({ description: "Run page on GitHub." })),
+})
+  .annotate({
+    description: "GitHub Actions workflow runs in the installation's repositories.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type WorkflowRun = Schema.Schema.Type<typeof WorkflowRunSchema>;
+
+export const WorkflowRunObjectSchema = WorkflowRunSchema.mapFields((fields) => ({
+  ...Struct.omit(fields, ["version", "repository_id", "pull_requests"]),
+  updated_at: Timestamp,
+  pull_requests: Schema.NullOr(fields.pull_requests),
+}));
+
+export type WorkflowRunObject = Schema.Schema.Type<typeof WorkflowRunObjectSchema>;

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 { GitHubConnector } from "./index";
+
+const ConnectorLayer = GitHubConnector.layerConfig(GitHubConnector.GitHubConfigDef.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-github"),
+});
+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* GitHubConnector.GitHubConnector;
+
+    return yield* ConnectorApp.start(entrypoint, { port }).pipe(
+      Effect.provide(Ingestor.layerArrowFlightConfig(entrypoint)),
+    );
+  }).pipe(
+    Effect.annotateLogs({ component: "github" }),
+    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,31 @@
+import type { Schema } from "effect";
+
+import { CheckRunSchema } from "./schemas/check-runs";
+import { CommitStatusSchema } from "./schemas/commit-statuses";
+import { CommitSchema } from "./schemas/commits";
+import { IssueCommentSchema } from "./schemas/issue-comments";
+import { IssueSchema } from "./schemas/issues";
+import { PullRequestCommitSchema } from "./schemas/pull-request-commits";
+import { PullRequestReviewCommentSchema } from "./schemas/pull-request-review-comments";
+import { PullRequestReviewSchema } from "./schemas/pull-request-reviews";
+import { PullRequestSchema } from "./schemas/pull-requests";
+import { ReleaseSchema } from "./schemas/releases";
+import { RepositorySchema } from "./schemas/repositories";
+import { WorkflowJobSchema } from "./schemas/workflow-jobs";
+import { WorkflowRunSchema } from "./schemas/workflow-runs";
+
+export const tableSchemas: Readonly<Record<string, Schema.Top>> = {
+  repositories: RepositorySchema,
+  issues: IssueSchema,
+  pull_requests: PullRequestSchema,
+  issue_comments: IssueCommentSchema,
+  pull_request_reviews: PullRequestReviewSchema,
+  pull_request_review_comments: PullRequestReviewCommentSchema,
+  pull_request_commits: PullRequestCommitSchema,
+  commits: CommitSchema,
+  check_runs: CheckRunSchema,
+  commit_statuses: CommitStatusSchema,
+  workflow_runs: WorkflowRunSchema,
+  workflow_jobs: WorkflowJobSchema,
+  releases: ReleaseSchema,
+};

package/src/webhook/route.ts

@@ -0,0 +1,46 @@
+import { type ResourceDefinition, Webhook } from "@useairfoil/connector-kit";
+import { Effect, Option, Result, Schema } from "effect";
+import { HttpServerResponse } from "effect/http";
+
+import { InstallationEventSchema, WebhookPayloadSchema } from "../schemas/events";
+import { verifySignature } from "./signature";
+
+export const webhookPath = "/webhooks/github";
+
+export const makeWebhookRoute = (options: {
+  readonly secret: string;
+  readonly installationId: number;
+  /** Resources by `X-GitHub-Event` name. One event can feed several. */
+  readonly targets: ReadonlyMap<string, ReadonlyArray<ResourceDefinition>>;
+}) =>
+  Webhook.route({
+    path: webhookPath,
+    ackMode: "after-enqueue",
+    schema: WebhookPayloadSchema,
+    handler: ({ request, rawBody, payload, to }) =>
+      Effect.gen(function* () {
+        const verified = yield* verifySignature({
+          rawBody,
+          header: request.headers["x-hub-signature-256"],
+          secret: options.secret,
+        }).pipe(Effect.result);
+        if (Result.isFailure(verified)) {
+          return HttpServerResponse.jsonUnsafe(
+            { ok: false, error: verified.failure.message },
+            { status: 401 },
+          );
+        }
+
+        // One app can be installed on several accounts, and all of their events
+        // come to the same URL. Only ours are stored. `ping` has no installation.
+        const installationId = Schema.decodeUnknownOption(InstallationEventSchema)(payload).pipe(
+          Option.flatMap(({ installation }) => Option.fromNullishOr(installation?.id)),
+        );
+        if (Option.contains(installationId, options.installationId)) {
+          const resources = options.targets.get(request.headers["x-github-event"] ?? "") ?? [];
+          yield* Effect.forEach(resources, (resource) => to(resource, payload), { discard: true });
+        }
+
+        return HttpServerResponse.jsonUnsafe({ ok: true });
+      }),
+  });

package/src/webhook/signature.ts

@@ -0,0 +1,20 @@
+import { ConnectorError } from "@useairfoil/connector-kit";
+import { Effect } from "effect";
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+const prefix = "sha256=";
+
+export const verifySignature = (options: {
+  readonly rawBody: Uint8Array;
+  readonly header: string | undefined;
+  readonly secret: string;
+}): Effect.Effect<void, ConnectorError> => {
+  const header = options.header ?? "";
+  const expected = createHmac("sha256", options.secret).update(options.rawBody).digest();
+  const provided = Buffer.from(header.slice(prefix.length), "hex");
+  return header.startsWith(prefix) &&
+    provided.length === expected.length &&
+    timingSafeEqual(provided, expected)
+    ? Effect.void
+    : Effect.fail(new ConnectorError({ message: "Invalid GitHub webhook signature" }));
+};