@useairfoil/producer-github 0.0.1 → 0.0.2

package/src/schemas/check-runs.ts

@@ -0,0 +1,48 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Timestamp, field, readVersion } from "./shared";
+
+export const CheckRunSchema = Schema.Struct({
+  id: Long.pipe(field(1, "Unique check run ID.")),
+  version: readVersion(2, "check run"),
+  node_id: Schema.String.pipe(field(3, "GraphQL node ID of the check run.")),
+  repository_id: Long.pipe(field(4, "ID of the repository the check run belongs to.")),
+  head_sha: Schema.String.pipe(field(5, "SHA of the commit the check ran on.")),
+  name: Schema.String.pipe(field(6, "Check name.")),
+  status: Schema.String.pipe(field(7, "Status, such as queued, in_progress, or completed.")),
+  conclusion: Schema.NullOr(Schema.String).pipe(
+    field(8, "Result of a completed check, such as success or failure."),
+  ),
+  started_at: Schema.NullOr(Timestamp).pipe(field(9, "Time the check started.")),
+  completed_at: Schema.NullOr(Timestamp).pipe(field(10, "Time the check completed.")),
+  app: Schema.NullOr(
+    Schema.Struct({
+      id: Long.pipe(field(100, "GitHub App ID.")),
+      name: Schema.String.pipe(field(101, "GitHub App name.")),
+    }),
+  ).pipe(field(11, "GitHub App that created the check, such as GitHub Actions.")),
+  check_suite: Schema.NullOr(Schema.Struct({ id: Long.pipe(field(102, "Check suite ID.")) })).pipe(
+    field(12, "Check suite the check run belongs to."),
+  ),
+  output: Schema.Struct({
+    title: Schema.NullOr(Schema.String).pipe(field(103, "Output title.")),
+    summary: Schema.NullOr(Schema.String).pipe(field(104, "Output summary in Markdown.")),
+  }).pipe(field(13, "Output the check reported.")),
+  external_id: Schema.NullOr(Schema.String).pipe(field(14, "ID the app gave the check.")),
+  details_url: Schema.NullOr(Schema.String).pipe(field(15, "Details page from the app.")),
+  html_url: Schema.NullOr(Schema.String).pipe(field(16, "Check run page on GitHub.")),
+})
+  .annotate({
+    description:
+      "Check runs, such as GitHub Actions jobs. Polled for default-branch commits; webhooks cover all branches.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type CheckRun = Schema.Schema.Type<typeof CheckRunSchema>;
+
+export const CheckRunObjectSchema = CheckRunSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version", "repository_id"]),
+);
+
+export type CheckRunObject = Schema.Schema.Type<typeof CheckRunObjectSchema>;

package/src/schemas/commit-statuses.ts

@@ -0,0 +1,31 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Text, Timestamp, field, user, version } from "./shared";
+
+export const CommitStatusSchema = Schema.Struct({
+  id: Long.pipe(field(1, "Unique status ID. Each new status of a context gets a new ID.")),
+  version: version(2, "status"),
+  node_id: Schema.String.pipe(field(3, "GraphQL node ID of the status.")),
+  repository_id: Long.pipe(field(4, "ID of the repository the status belongs to.")),
+  sha: Schema.String.pipe(field(5, "SHA of the commit the status is on.")),
+  state: Schema.String.pipe(field(6, "State: error, failure, pending, or success.")),
+  context: Schema.String.pipe(field(7, "Label that tells the status apart, such as ci/build.")),
+  description: Text.pipe(field(8, "Short description. Empty when not set.")),
+  target_url: Schema.NullOr(Schema.String).pipe(field(9, "Link the status points to.")),
+  creator: Schema.NullOr(user(100)).pipe(field(10, "Account that created the status.")),
+  created_at: Timestamp.pipe(field(11, "Time the status was created.")),
+})
+  .annotate({
+    description: "Commit statuses. Polled for default-branch commits; webhooks cover all branches.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type CommitStatus = Schema.Schema.Type<typeof CommitStatusSchema>;
+
+export const CommitStatusObjectSchema = CommitStatusSchema.mapFields((fields) => ({
+  ...Struct.omit(fields, ["version", "repository_id", "sha"]),
+  updated_at: Timestamp,
+}));
+
+export type CommitStatusObject = Schema.Schema.Type<typeof CommitStatusObjectSchema>;

package/src/schemas/commits.ts

@@ -0,0 +1,64 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, SchemaTransformation } from "effect";
+
+import { Long, Timestamp, field, list, user } from "./shared";
+
+export const gitActor = (baseId: number) =>
+  Schema.Struct({
+    name: Schema.String.pipe(field(baseId, "Name in the commit.")),
+    date: Timestamp.pipe(field(baseId + 1, "Time in the commit.")),
+  });
+
+/**
+ * The GitHub account of a commit's author or committer. GitHub sends `null` or
+ * `{}` when the email matches no account, and both become `null`.
+ */
+export const account = (baseId: number) =>
+  Schema.NullOr(Schema.Union([user(baseId), Schema.Struct({})])).pipe(
+    Schema.decodeTo(
+      Schema.NullOr(Schema.toType(user(baseId))),
+      SchemaTransformation.transform({
+        decode: (value) => (value !== null && "id" in value ? value : null),
+        encode: (value) => value,
+      }),
+    ),
+  );
+
+export const CommitSchema = Schema.Struct({
+  key: Schema.String.pipe(field(1, "Repository ID and SHA, such as `1406396726:9eb3a7d`.")),
+  version: Schema.Date.pipe(field(2, "Commit time. A commit never changes.")),
+  repository_id: Long.pipe(field(3, "ID of the repository the commit is in.")),
+  sha: Schema.String.pipe(field(4, "Commit SHA.")),
+  node_id: Schema.String.pipe(field(5, "GraphQL node ID of the commit.")),
+  message: Schema.String.pipe(field(6, "Commit message.")),
+  author: gitActor(100).pipe(field(7, "Author name and time from the commit.")),
+  committer: gitActor(102).pipe(field(8, "Committer name and time from the commit.")),
+  author_user: account(104).pipe(field(9, "GitHub account of the author.")),
+  committer_user: account(107).pipe(field(10, "GitHub account of the committer.")),
+  parents: list(110, Schema.String).pipe(field(11, "SHAs of the parent commits.")),
+  verified: Schema.Boolean.pipe(field(12, "Whether GitHub verified the commit signature.")),
+  html_url: Schema.String.pipe(field(13, "Commit page on GitHub.")),
+})
+  .annotate({
+    description: "Commits on the default branch of the installation's repositories.",
+  })
+  .pipe(Iceberg.identifier("key"));
+
+export type Commit = Schema.Schema.Type<typeof CommitSchema>;
+
+export const CommitObjectSchema = Schema.Struct({
+  sha: Schema.String,
+  node_id: Schema.String,
+  commit: Schema.Struct({
+    author: gitActor(100),
+    committer: gitActor(102),
+    message: Schema.String,
+    verification: Schema.optionalKey(Schema.Struct({ verified: Schema.Boolean })),
+  }),
+  author: account(104),
+  committer: account(107),
+  parents: Schema.Array(Schema.Struct({ sha: Schema.String })),
+  html_url: Schema.String,
+});
+
+export type CommitObject = Schema.Schema.Type<typeof CommitObjectSchema>;

package/src/schemas/events.ts

@@ -0,0 +1,139 @@
+import { Schema, Struct } from "effect";
+
+import { IssueCommentObjectSchema } from "./issue-comments";
+import { IssueObjectSchema } from "./issues";
+import { PullRequestReviewCommentObjectSchema } from "./pull-request-review-comments";
+import { PullRequestObjectSchema } from "./pull-requests";
+import { ReleaseObjectSchema } from "./releases";
+import { RepositoryObjectSchema } from "./repositories";
+import { Long, ObjectRefSchema, Timestamp } from "./shared";
+import { WorkflowRunObjectSchema } from "./workflow-runs";
+
+/**
+ * The webhook route passes the payload on as it is. GitHub puts the event name
+ * in a header, so each resource decodes its own event.
+ */
+export const WebhookPayloadSchema = Schema.Record(Schema.String, Schema.Unknown);
+
+export type WebhookPayload = Schema.Schema.Type<typeof WebhookPayloadSchema>;
+
+export const InstallationEventSchema = Schema.Struct({
+  installation: Schema.optional(Schema.Struct({ id: Schema.Number })),
+});
+
+/** For handlers that read the API again. */
+const RepositoryNameSchema = Schema.Struct({ id: Long, full_name: Schema.String });
+
+/** A transferred issue no longer exists in its old repository. */
+export const IssueRemovedEventSchema = Schema.Struct({
+  action: Schema.Literals(["deleted", "transferred"]),
+  issue: ObjectRefSchema,
+});
+
+export const IssuesEventSchema = Schema.Union([
+  IssueRemovedEventSchema,
+  Schema.Struct({
+    action: Schema.String,
+    repository: RepositoryNameSchema,
+    issue: IssueObjectSchema,
+  }),
+]);
+
+export const IssueCommentDeletedEventSchema = Schema.Struct({
+  action: Schema.Literal("deleted"),
+  comment: ObjectRefSchema,
+});
+
+export const IssueCommentEventSchema = Schema.Union([
+  IssueCommentDeletedEventSchema,
+  Schema.Struct({
+    action: Schema.String,
+    repository: ObjectRefSchema,
+    comment: IssueCommentObjectSchema,
+  }),
+]);
+
+export const PullRequestReviewCommentDeletedEventSchema = Schema.Struct({
+  action: Schema.Literal("deleted"),
+  comment: ObjectRefSchema,
+});
+
+export const PullRequestReviewCommentEventSchema = Schema.Union([
+  PullRequestReviewCommentDeletedEventSchema,
+  Schema.Struct({
+    action: Schema.String,
+    repository: ObjectRefSchema,
+    comment: PullRequestReviewCommentObjectSchema,
+  }),
+]);
+
+export const PullRequestEventSchema = Schema.Struct({
+  repository: RepositoryNameSchema,
+  pull_request: PullRequestObjectSchema,
+});
+
+export const RepositoryDeletedEventSchema = Schema.Struct({
+  action: Schema.Literal("deleted"),
+  repository: ObjectRefSchema,
+});
+
+export const RepositoryEventSchema = Schema.Union([
+  RepositoryDeletedEventSchema,
+  Schema.Struct({ action: Schema.String, repository: RepositoryObjectSchema }),
+]);
+
+export const ReleaseDeletedEventSchema = Schema.Struct({
+  action: Schema.Literal("deleted"),
+  release: ObjectRefSchema,
+});
+
+export const ReleaseEventSchema = Schema.Union([
+  ReleaseDeletedEventSchema,
+  Schema.Struct({
+    action: Schema.String,
+    repository: ObjectRefSchema,
+    release: ReleaseObjectSchema,
+  }),
+]);
+
+export const WorkflowRunEventSchema = Schema.Struct({
+  repository: ObjectRefSchema,
+  workflow_run: WorkflowRunObjectSchema,
+});
+
+export const PushEventSchema = Schema.Struct({
+  ref: Schema.String,
+  before: Schema.String,
+  after: Schema.String,
+  repository: RepositoryNameSchema.mapFields(Struct.assign({ default_branch: Schema.String })),
+});
+
+export const PullRequestReviewEventSchema = Schema.Struct({
+  repository: RepositoryNameSchema,
+  pull_request: Schema.Struct({ number: Long }),
+  review: ObjectRefSchema,
+});
+
+export const PullRequestCommitsEventSchema = Schema.Struct({
+  action: Schema.String,
+  changes: Schema.optionalKey(Schema.Struct({ base: Schema.optionalKey(Schema.Unknown) })),
+  repository: RepositoryNameSchema,
+  pull_request: Schema.Struct({ number: Long, updated_at: Timestamp }),
+});
+
+export const CheckRunEventSchema = Schema.Struct({
+  repository: RepositoryNameSchema,
+  check_run: ObjectRefSchema,
+});
+
+export const WorkflowJobEventSchema = Schema.Struct({
+  repository: RepositoryNameSchema,
+  workflow_job: ObjectRefSchema,
+});
+
+/** The status payload is flat. */
+export const StatusEventSchema = Schema.Struct({
+  id: Long,
+  sha: Schema.String,
+  repository: RepositoryNameSchema,
+});

package/src/schemas/issue-comments.ts

@@ -0,0 +1,38 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Text, Timestamp, deleted, field, user, version } from "./shared";
+
+export const IssueCommentSchema = Schema.Struct({
+  id: Long.pipe(field(1, "Unique comment ID.")),
+  version: version(2, "comment"),
+  node_id: Schema.String.pipe(field(3, "GraphQL node ID of the comment.")),
+  repository_id: Long.pipe(field(4, "ID of the repository the comment belongs to.")),
+  issue_number: Long.pipe(
+    field(5, "Number of the issue or pull request the comment is on, in its repository."),
+  ),
+  user: Schema.NullOr(user(100)).pipe(field(6, "Account that wrote the comment.")),
+  author_association: Schema.String.pipe(
+    field(7, "Author's relation to the repository, such as OWNER or CONTRIBUTOR."),
+  ),
+  body: Text.pipe(field(8, "Comment in Markdown. Empty when not set.")),
+  created_at: Timestamp.pipe(field(9, "Time the comment was written.")),
+  html_url: Schema.String.pipe(field(10, "Comment on GitHub.")),
+  _deleted: deleted(11, "comment"),
+})
+  .annotate({
+    description:
+      "Comments on issues and pull requests. Pull request review comments are not included.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type IssueComment = Schema.Schema.Type<typeof IssueCommentSchema>;
+
+export const IssueCommentObjectSchema = IssueCommentSchema.mapFields((fields) => ({
+  ...Struct.omit(fields, ["version", "repository_id", "issue_number", "_deleted"]),
+  updated_at: Timestamp,
+  // The list has no issue number, only this URL, which ends in it.
+  issue_url: Schema.String.check(Schema.isPattern(/\/issues\/\d+$/)),
+}));
+
+export type IssueCommentObject = Schema.Schema.Type<typeof IssueCommentObjectSchema>;

package/src/schemas/issues.ts

@@ -0,0 +1,62 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import {
+  Long,
+  Text,
+  Timestamp,
+  deleted,
+  field,
+  label,
+  list,
+  milestone,
+  optionalList,
+  user,
+  version,
+} from "./shared";
+
+export const IssueSchema = Schema.Struct({
+  id: Long.pipe(field(1, "Unique issue ID.")),
+  version: version(2, "issue"),
+  node_id: Schema.String.pipe(field(3, "GraphQL node ID of the issue.")),
+  repository_id: Long.pipe(field(4, "ID of the repository the issue belongs to.")),
+  number: Long.pipe(field(5, "Issue number in the repository.")),
+  title: Schema.String.pipe(field(6, "Issue title.")),
+  body: Text.pipe(field(7, "Issue description in Markdown. Empty when not set.")),
+  state: Schema.String.pipe(field(8, "State: open or closed.")),
+  state_reason: Schema.NullOr(Schema.String).pipe(
+    field(9, "Why the issue was closed or reopened, such as completed or not_planned."),
+  ),
+  locked: Schema.Boolean.pipe(field(10, "Whether the conversation is locked.")),
+  user: Schema.NullOr(user(100)).pipe(field(11, "Account that opened the issue.")),
+  author_association: Schema.String.pipe(
+    field(12, "Author's relation to the repository, such as OWNER or CONTRIBUTOR."),
+  ),
+  labels: list(103, label(104)).pipe(field(13, "Labels on the issue.")),
+  assignees: list(106, user(107)).pipe(field(14, "Accounts assigned to the issue.")),
+  milestone: Schema.NullOr(milestone(110)).pipe(field(15, "Milestone of the issue.")),
+  comments: Long.pipe(field(16, "Number of comments.")),
+  created_at: Timestamp.pipe(field(17, "Time the issue was opened.")),
+  closed_at: Schema.NullOr(Timestamp).pipe(
+    field(18, "Time the issue was closed. Null while it is open."),
+  ),
+  html_url: Schema.String.pipe(field(19, "Issue page on GitHub.")),
+  _deleted: deleted(20, "issue"),
+})
+  .annotate({
+    description: "Issues in the installation's repositories. Pull requests are not included.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type Issue = Schema.Schema.Type<typeof IssueSchema>;
+
+export const IssueObjectSchema = IssueSchema.mapFields((fields) => ({
+  ...Struct.omit(fields, ["version", "repository_id", "labels", "assignees", "_deleted"]),
+  updated_at: Timestamp,
+  labels: optionalList(label(104)),
+  assignees: optionalList(user(107)),
+  // Set on pull requests, which the issues list also returns.
+  pull_request: Schema.optionalKey(Schema.Unknown),
+}));
+
+export type IssueObject = Schema.Schema.Type<typeof IssueObjectSchema>;

package/src/schemas/pull-request-commits.ts

@@ -0,0 +1,28 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema } from "effect";
+
+import { account, gitActor } from "./commits";
+import { Long, field } from "./shared";
+
+export const PullRequestCommitSchema = Schema.Struct({
+  key: Schema.String.pipe(
+    field(1, "Repository ID, pull request number, and SHA, such as `1406396726:3:9eb3a7d`."),
+  ),
+  version: Schema.Date.pipe(field(2, "Time GitHub last updated the pull request.")),
+  repository_id: Long.pipe(field(3, "ID of the repository the pull request belongs to.")),
+  pull_request_number: Long.pipe(field(4, "Pull request number in the repository.")),
+  sha: Schema.String.pipe(field(5, "Commit SHA.")),
+  message: Schema.String.pipe(field(6, "Commit message.")),
+  author: gitActor(100).pipe(field(7, "Author name and time from the commit.")),
+  committer: gitActor(102).pipe(field(8, "Committer name and time from the commit.")),
+  author_user: account(104).pipe(field(9, "GitHub account of the author.")),
+  committer_user: account(107).pipe(field(10, "GitHub account of the committer.")),
+  html_url: Schema.String.pipe(field(11, "Commit page on GitHub.")),
+})
+  .annotate({
+    description:
+      "Commits in pull requests, up to 250 per pull request. Commits removed by a force push stay.",
+  })
+  .pipe(Iceberg.identifier("key"));
+
+export type PullRequestCommit = Schema.Schema.Type<typeof PullRequestCommitSchema>;

package/src/schemas/pull-request-review-comments.ts

@@ -0,0 +1,67 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Timestamp, deleted, field, user, version } from "./shared";
+
+export const PullRequestReviewCommentSchema = Schema.Struct({
+  id: Long.pipe(field(1, "Unique review comment ID.")),
+  version: version(2, "review comment"),
+  node_id: Schema.String.pipe(field(3, "GraphQL node ID of the review comment.")),
+  repository_id: Long.pipe(field(4, "ID of the repository the comment belongs to.")),
+  pull_request_number: Long.pipe(
+    field(5, "Number of the pull request the comment is on, in its repository."),
+  ),
+  pull_request_review_id: Schema.NullOr(Long).pipe(
+    field(6, "ID of the review the comment belongs to."),
+  ),
+  in_reply_to_id: Schema.optionalKey(Long).pipe(field(7, "ID of the comment this one replies to.")),
+  user: Schema.NullOr(user(100)).pipe(field(8, "Account that wrote the comment.")),
+  author_association: Schema.String.pipe(
+    field(9, "Author's relation to the repository, such as OWNER or CONTRIBUTOR."),
+  ),
+  body: Schema.String.pipe(field(10, "Comment in Markdown.")),
+  path: Schema.String.pipe(field(11, "Path of the file the comment is on.")),
+  commit_id: Schema.String.pipe(field(12, "SHA of the commit the comment is on now.")),
+  original_commit_id: Schema.String.pipe(
+    field(13, "SHA of the commit the comment was written on."),
+  ),
+  diff_hunk: Schema.String.pipe(field(14, "Part of the diff the comment is on.")),
+  // GitHub sends null for a comment on a line that is no longer in the diff.
+  line: Schema.optionalKey(Schema.NullOr(Long)).pipe(
+    field(15, "Last line of the commented range in the current diff."),
+  ),
+  original_line: Schema.optionalKey(Schema.NullOr(Long)).pipe(
+    field(16, "Last line of the commented range in the original diff."),
+  ),
+  start_line: Schema.optionalKey(Schema.NullOr(Long)).pipe(
+    field(17, "First line of a multi-line comment."),
+  ),
+  side: Schema.optionalKey(Schema.NullOr(Schema.String)).pipe(
+    field(18, "Side of the diff: LEFT or RIGHT."),
+  ),
+  subject_type: Schema.optionalKey(Schema.String).pipe(
+    field(19, "What the comment is on: line or file."),
+  ),
+  created_at: Timestamp.pipe(field(20, "Time the comment was written.")),
+  html_url: Schema.String.pipe(field(21, "Comment on GitHub.")),
+  _deleted: deleted(22, "review comment"),
+})
+  .annotate({
+    description: "Review comments on pull request diffs.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type PullRequestReviewComment = Schema.Schema.Type<typeof PullRequestReviewCommentSchema>;
+
+export const PullRequestReviewCommentObjectSchema = PullRequestReviewCommentSchema.mapFields(
+  (fields) => ({
+    ...Struct.omit(fields, ["version", "repository_id", "pull_request_number", "_deleted"]),
+    updated_at: Timestamp,
+    // The list has no pull request number, only this URL, which ends in it.
+    pull_request_url: Schema.String.check(Schema.isPattern(/\/pulls\/\d+$/)),
+  }),
+);
+
+export type PullRequestReviewCommentObject = Schema.Schema.Type<
+  typeof PullRequestReviewCommentObjectSchema
+>;

package/src/schemas/pull-request-reviews.ts

@@ -0,0 +1,37 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Timestamp, field, readVersion, user } from "./shared";
+
+export const PullRequestReviewSchema = Schema.Struct({
+  id: Long.pipe(field(1, "Unique review ID.")),
+  version: readVersion(2, "review"),
+  node_id: Schema.String.pipe(field(3, "GraphQL node ID of the review.")),
+  repository_id: Long.pipe(field(4, "ID of the repository the review belongs to.")),
+  pull_request_number: Long.pipe(
+    field(5, "Number of the pull request the review is on, in its repository."),
+  ),
+  user: Schema.NullOr(user(100)).pipe(field(6, "Account that wrote the review.")),
+  author_association: Schema.String.pipe(
+    field(7, "Author's relation to the repository, such as OWNER or CONTRIBUTOR."),
+  ),
+  state: Schema.String.pipe(
+    field(8, "State, such as APPROVED, CHANGES_REQUESTED, COMMENTED, or DISMISSED."),
+  ),
+  body: Schema.String.pipe(field(9, "Review summary in Markdown.")),
+  commit_id: Schema.NullOr(Schema.String).pipe(field(10, "SHA of the commit the review is on.")),
+  submitted_at: Schema.optionalKey(Timestamp).pipe(field(11, "Time the review was submitted.")),
+  html_url: Schema.String.pipe(field(12, "Review on GitHub.")),
+})
+  .annotate({
+    description: "Reviews on pull requests. Pending reviews are only visible to their author.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type PullRequestReview = Schema.Schema.Type<typeof PullRequestReviewSchema>;
+
+export const PullRequestReviewObjectSchema = PullRequestReviewSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version", "repository_id", "pull_request_number"]),
+);
+
+export type PullRequestReviewObject = Schema.Schema.Type<typeof PullRequestReviewObjectSchema>;

package/src/schemas/pull-requests.ts

@@ -0,0 +1,75 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import {
+  Long,
+  Text,
+  Timestamp,
+  field,
+  label,
+  list,
+  milestone,
+  optionalList,
+  user,
+  version,
+} from "./shared";
+
+const branch = (baseId: number) =>
+  Schema.Struct({
+    ref: Schema.String.pipe(field(baseId, "Branch name.")),
+    sha: Schema.String.pipe(field(baseId + 1, "Commit SHA.")),
+    label: Schema.String.pipe(field(baseId + 2, "Owner and branch, such as octocat:main.")),
+  });
+
+export const PullRequestSchema = Schema.Struct({
+  id: Long.pipe(field(1, "Unique pull request ID. Not the ID of its issue.")),
+  version: version(2, "pull request"),
+  node_id: Schema.String.pipe(field(3, "GraphQL node ID of the pull request.")),
+  repository_id: Long.pipe(field(4, "ID of the repository the pull request belongs to.")),
+  number: Long.pipe(field(5, "Pull request number in the repository.")),
+  title: Schema.String.pipe(field(6, "Pull request title.")),
+  body: Text.pipe(field(7, "Pull request description in Markdown. Empty when not set.")),
+  state: Schema.String.pipe(field(8, "State: open or closed. Merged pull requests are closed.")),
+  draft: Schema.optionalKey(Schema.Boolean).pipe(field(9, "Whether the pull request is a draft.")),
+  locked: Schema.Boolean.pipe(field(10, "Whether the conversation is locked.")),
+  user: Schema.NullOr(user(100)).pipe(field(11, "Account that opened the pull request.")),
+  author_association: Schema.String.pipe(
+    field(12, "Author's relation to the repository, such as OWNER or CONTRIBUTOR."),
+  ),
+  labels: list(103, label(104)).pipe(field(13, "Labels on the pull request.")),
+  assignees: list(106, user(107)).pipe(field(14, "Accounts assigned to the pull request.")),
+  requested_reviewers: list(110, user(111)).pipe(
+    field(15, "Accounts asked to review that have not reviewed yet."),
+  ),
+  milestone: Schema.NullOr(milestone(114)).pipe(field(16, "Milestone of the pull request.")),
+  head: branch(117).pipe(field(17, "Branch the changes come from.")),
+  base: branch(120).pipe(field(18, "Branch the changes merge into.")),
+  created_at: Timestamp.pipe(field(19, "Time the pull request was opened.")),
+  closed_at: Schema.NullOr(Timestamp).pipe(
+    field(20, "Time the pull request was closed. Null while it is open."),
+  ),
+  merged_at: Schema.NullOr(Timestamp).pipe(field(21, "Time the pull request was merged.")),
+  html_url: Schema.String.pipe(field(22, "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(104)),
+  assignees: optionalList(user(107)),
+  requested_reviewers: optionalList(user(111)),
+}));
+
+export type PullRequestObject = Schema.Schema.Type<typeof PullRequestObjectSchema>;

package/src/schemas/releases.ts

@@ -0,0 +1,53 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, Text, Timestamp, deleted, field, list, user, version } from "./shared";
+
+const asset = (baseId: number) =>
+  Schema.Struct({
+    id: Long.pipe(field(baseId, "Asset ID.")),
+    name: Schema.String.pipe(field(baseId + 1, "File name.")),
+    label: Schema.NullOr(Schema.String).pipe(field(baseId + 2, "Label shown instead of the name.")),
+    state: Schema.String.pipe(field(baseId + 3, "State: uploaded or open.")),
+    content_type: Schema.String.pipe(field(baseId + 4, "Media type of the file.")),
+    size: Long.pipe(field(baseId + 5, "Size in bytes.")),
+    download_count: Long.pipe(
+      field(baseId + 6, "Number of downloads when the release last changed."),
+    ),
+    created_at: Timestamp.pipe(field(baseId + 7, "Time the asset was uploaded.")),
+    updated_at: Timestamp.pipe(field(baseId + 8, "Time the asset last changed.")),
+    browser_download_url: Schema.String.pipe(field(baseId + 9, "Download link.")),
+  });
+
+export const ReleaseSchema = Schema.Struct({
+  id: Long.pipe(field(1, "Unique release ID.")),
+  version: version(2, "release"),
+  node_id: Schema.String.pipe(field(3, "GraphQL node ID of the release.")),
+  repository_id: Long.pipe(field(4, "ID of the repository the release belongs to.")),
+  tag_name: Schema.String.pipe(field(5, "Tag of the release.")),
+  target_commitish: Schema.String.pipe(field(6, "Branch or commit the tag was created from.")),
+  name: Text.pipe(field(7, "Release title. Empty when not set.")),
+  body: Text.pipe(field(8, "Release notes in Markdown. Empty when not set.")),
+  draft: Schema.Boolean.pipe(field(9, "Whether the release is a draft.")),
+  prerelease: Schema.Boolean.pipe(field(10, "Whether the release is a pre-release.")),
+  author: user(100).pipe(field(11, "Account that created the release.")),
+  assets: list(103, asset(104)).pipe(field(12, "Files attached to the release.")),
+  created_at: Timestamp.pipe(field(13, "Time the release was created.")),
+  published_at: Schema.NullOr(Timestamp).pipe(field(14, "Time the release was published.")),
+  html_url: Schema.String.pipe(field(15, "Release page on GitHub.")),
+  _deleted: deleted(16, "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>;