@useairfoil/producer-linear 0.0.1 → 0.0.3

package/src/resources/projects.ts

@@ -0,0 +1,161 @@
+import { Resource } from "@useairfoil/connector-kit";
+
+import type { LinearClientService } from "../client/client";
+
+import {
+  ProjectLabelObjectSchema,
+  ProjectLabelSchema,
+  ProjectMilestoneObjectSchema,
+  ProjectMilestoneSchema,
+  ProjectObjectSchema,
+  ProjectRelationObjectSchema,
+  ProjectRelationSchema,
+  ProjectSchema,
+  ProjectStatusObjectSchema,
+  ProjectStatusSchema,
+  ProjectUpdateObjectSchema,
+  ProjectUpdateSchema,
+} from "../schemas/projects";
+import {
+  backfillList,
+  changesList,
+  checkList,
+  listSources,
+  listSpec,
+  rowsOf,
+  webhookList,
+} from "./pages";
+
+const projectSpec = listSpec({
+  connection: "projects",
+  single: "project",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description content url icon color status_id: status { id } priority
+    priority_label: priorityLabel health health_updated_at: healthUpdatedAt progress scope
+    lead_id: lead { id } creator_id: creator { id }
+    converted_from_issue_id: convertedFromIssue { id } start_date: startDate
+    target_date: targetDate started_at: startedAt completed_at: completedAt
+    canceled_at: canceledAt auto_archived_at: autoArchivedAt label_ids: labelIds
+    team_ids: teams(first: 50) { nodes { id } } member_ids: members(first: 100) { nodes { id } }
+    trashed`,
+  item: ProjectObjectSchema,
+  // Each project reads up to 150 teams and members, so pages stay under the cost limit.
+  first: 50,
+  updatedAt: (project) => project.updated_at,
+  rows: rowsOf((project) => ({ ...project, version: project.updated_at, _deleted: false })),
+});
+
+export const makeProjects = (client: LinearClientService) =>
+  Resource.entity({
+    name: "projects",
+    rowSchema: ProjectSchema,
+    version: "version",
+
+    check: checkList(client, projectSpec),
+    backfill: backfillList(client, projectSpec),
+    changes: changesList(client, projectSpec),
+    webhook: webhookList(client, projectSpec),
+  });
+
+const projectMilestoneSpec = listSpec({
+  connection: "projectMilestones",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description project_id: project { id } target_date: targetDate status progress
+    sort_order: sortOrder`,
+  item: ProjectMilestoneObjectSchema,
+  updatedAt: (milestone) => milestone.updated_at,
+  rows: rowsOf((milestone) => ({ ...milestone, version: milestone.updated_at })),
+});
+
+export const makeProjectMilestones = (client: LinearClientService) =>
+  Resource.entity({
+    name: "project_milestones",
+    rowSchema: ProjectMilestoneSchema,
+    version: "version",
+
+    check: checkList(client, projectMilestoneSpec),
+    backfill: backfillList(client, projectMilestoneSpec),
+    changes: changesList(client, projectMilestoneSpec),
+  });
+
+const projectUpdateSpec = listSpec({
+  connection: "projectUpdates",
+  single: "projectUpdate",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    project_id: project { id } user_id: user { id } body health url edited_at: editedAt
+    comment_count: commentCount`,
+  item: ProjectUpdateObjectSchema,
+  updatedAt: (update) => update.updated_at,
+  rows: rowsOf((update) => ({ ...update, version: update.updated_at, _deleted: false })),
+});
+
+export const makeProjectUpdates = (client: LinearClientService) =>
+  Resource.entity({
+    name: "project_updates",
+    rowSchema: ProjectUpdateSchema,
+    version: "version",
+
+    check: checkList(client, projectUpdateSpec),
+    backfill: backfillList(client, projectUpdateSpec),
+    changes: changesList(client, projectUpdateSpec),
+    webhook: webhookList(client, projectUpdateSpec),
+  });
+
+const projectStatusSpec = listSpec({
+  connection: "projectStatuses",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt name type color description position`,
+  item: ProjectStatusObjectSchema,
+  updatedAt: (status) => status.updated_at,
+  rows: rowsOf((status) => ({ ...status, version: status.updated_at })),
+});
+
+export const makeProjectStatuses = (client: LinearClientService) =>
+  Resource.entity({
+    name: "project_statuses",
+    rowSchema: ProjectStatusSchema,
+    version: "version",
+    ...listSources(client, projectStatusSpec),
+  });
+
+const projectLabelSpec = listSpec({
+  connection: "projectLabels",
+  single: "projectLabel",
+  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: ProjectLabelObjectSchema,
+  updatedAt: (label) => label.updated_at,
+  rows: rowsOf((label) => ({ ...label, version: label.updated_at, _deleted: false })),
+});
+
+export const makeProjectLabels = (client: LinearClientService) =>
+  Resource.entity({
+    name: "project_labels",
+    rowSchema: ProjectLabelSchema,
+    version: "version",
+    ...listSources(client, projectLabelSpec),
+    webhook: webhookList(client, projectLabelSpec),
+  });
+
+const projectRelationSpec = listSpec({
+  connection: "projectRelations",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    type project_id: project { id } project_milestone_id: projectMilestone { id }
+    anchor_type: anchorType related_project_id: relatedProject { id }
+    related_project_milestone_id: relatedProjectMilestone { id }
+    related_anchor_type: relatedAnchorType user_id: user { id }`,
+  item: ProjectRelationObjectSchema,
+  updatedAt: (relation) => relation.updated_at,
+  rows: rowsOf((relation) => ({ ...relation, version: relation.updated_at })),
+});
+
+export const makeProjectRelations = (client: LinearClientService) =>
+  Resource.entity({
+    name: "project_relations",
+    rowSchema: ProjectRelationSchema,
+    version: "version",
+
+    check: checkList(client, projectRelationSpec),
+    backfill: backfillList(client, projectRelationSpec),
+    changes: changesList(client, projectRelationSpec),
+  });

package/src/resources/releases.ts

@@ -0,0 +1,114 @@
+import { Resource } from "@useairfoil/connector-kit";
+
+import type { LinearClientService } from "../client/client";
+
+import {
+  IssueToReleaseObjectSchema,
+  IssueToReleaseSchema,
+  ReleaseNoteObjectSchema,
+  ReleaseNoteSchema,
+  ReleaseObjectSchema,
+  ReleasePipelineObjectSchema,
+  ReleasePipelineSchema,
+  ReleaseSchema,
+  ReleaseStageObjectSchema,
+  ReleaseStageSchema,
+} from "../schemas/releases";
+import { backfillList, changesList, checkList, listSources, listSpec, rowsOf } from "./pages";
+
+const releaseSpec = listSpec({
+  connection: "releases",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description release_version: version url commit_sha: commitSha
+    pipeline_id: pipeline { id } stage_id: stage { id } creator_id: creator { id }
+    start_date: startDate target_date: targetDate started_at: startedAt
+    completed_at: completedAt canceled_at: canceledAt trashed`,
+  item: ReleaseObjectSchema,
+  updatedAt: (release) => release.updated_at,
+  rows: rowsOf((release) => ({ ...release, version: release.updated_at })),
+});
+
+export const makeReleases = (client: LinearClientService) =>
+  Resource.entity({
+    name: "releases",
+    rowSchema: ReleaseSchema,
+    version: "version",
+
+    check: checkList(client, releaseSpec),
+    backfill: backfillList(client, releaseSpec),
+    changes: changesList(client, releaseSpec),
+  });
+
+const releaseNoteSpec = listSpec({
+  connection: "releaseNotes",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    title content: documentContent { content } url pipeline_id: pipeline { id }
+    release_ids: releases { id }`,
+  item: ReleaseNoteObjectSchema,
+  updatedAt: (note) => note.updated_at,
+  rows: rowsOf((note) => ({ ...note, version: note.updated_at })),
+});
+
+export const makeReleaseNotes = (client: LinearClientService) =>
+  Resource.entity({
+    name: "release_notes",
+    rowSchema: ReleaseNoteSchema,
+    version: "version",
+
+    check: checkList(client, releaseNoteSpec),
+    backfill: backfillList(client, releaseNoteSpec),
+    changes: changesList(client, releaseNoteSpec),
+  });
+
+const releasePipelineSpec = listSpec({
+  connection: "releasePipelines",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name type is_production: isProduction url include_path_patterns: includePathPatterns
+    approximate_release_count: approximateReleaseCount trashed`,
+  item: ReleasePipelineObjectSchema,
+  updatedAt: (pipeline) => pipeline.updated_at,
+  rows: rowsOf((pipeline) => ({ ...pipeline, version: pipeline.updated_at })),
+});
+
+export const makeReleasePipelines = (client: LinearClientService) =>
+  Resource.entity({
+    name: "release_pipelines",
+    rowSchema: ReleasePipelineSchema,
+    version: "version",
+    ...listSources(client, releasePipelineSpec),
+  });
+
+const releaseStageSpec = listSpec({
+  connection: "releaseStages",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt name type color position frozen pipeline_id: pipeline { id }`,
+  item: ReleaseStageObjectSchema,
+  updatedAt: (stage) => stage.updated_at,
+  rows: rowsOf((stage) => ({ ...stage, version: stage.updated_at })),
+});
+
+export const makeReleaseStages = (client: LinearClientService) =>
+  Resource.entity({
+    name: "release_stages",
+    rowSchema: ReleaseStageSchema,
+    version: "version",
+    ...listSources(client, releaseStageSpec),
+  });
+
+const issueToReleaseSpec = listSpec({
+  connection: "issueToReleases",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt issue_id: issue { id } release_id: release { id }`,
+  item: IssueToReleaseObjectSchema,
+  updatedAt: (link) => link.updated_at,
+  rows: rowsOf((link) => ({ ...link, version: link.updated_at })),
+});
+
+export const makeIssueToReleases = (client: LinearClientService) =>
+  Resource.entity({
+    name: "issue_to_releases",
+    rowSchema: IssueToReleaseSchema,
+    version: "version",
+
+    check: checkList(client, issueToReleaseSpec),
+    backfill: backfillList(client, issueToReleaseSpec),
+    changes: changesList(client, issueToReleaseSpec),
+  });

package/src/resources/teams.ts

@@ -0,0 +1,140 @@
+import { Resource } from "@useairfoil/connector-kit";
+
+import type { LinearClientService } from "../client/client";
+
+import {
+  CycleObjectSchema,
+  CycleSchema,
+  ExternalUserObjectSchema,
+  ExternalUserSchema,
+  TeamMembershipObjectSchema,
+  TeamMembershipSchema,
+  TeamObjectSchema,
+  TeamSchema,
+  UserObjectSchema,
+  UserSchema,
+  WorkflowStateObjectSchema,
+  WorkflowStateSchema,
+} from "../schemas/teams";
+import {
+  backfillList,
+  changesList,
+  checkList,
+  listSources,
+  listSpec,
+  rowsOf,
+  webhookList,
+} from "./pages";
+
+const teamSpec = listSpec({
+  connection: "teams",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name key display_name: displayName description visibility parent_id: parent { id }
+    timezone cycles_enabled: cyclesEnabled cycle_duration: cycleDuration
+    cycle_cooldown_time: cycleCooldownTime cycle_start_day: cycleStartDay
+    triage_enabled: triageEnabled issue_estimation_type: issueEstimationType
+    default_issue_estimate: defaultIssueEstimate auto_archive_period: autoArchivePeriod
+    auto_close_period: autoClosePeriod retired_at: retiredAt`,
+  item: TeamObjectSchema,
+  updatedAt: (team) => team.updated_at,
+  rows: rowsOf((team) => ({ ...team, version: team.updated_at })),
+});
+
+export const makeTeams = (client: LinearClientService) =>
+  Resource.entity({
+    name: "teams",
+    rowSchema: TeamSchema,
+    version: "version",
+    ...listSources(client, teamSpec),
+  });
+
+const teamMembershipSpec = listSpec({
+  connection: "teamMemberships",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt team_id: team { id } user_id: user { id } owner`,
+  item: TeamMembershipObjectSchema,
+  updatedAt: (membership) => membership.updated_at,
+  rows: rowsOf((membership) => ({ ...membership, version: membership.updated_at })),
+});
+
+export const makeTeamMemberships = (client: LinearClientService) =>
+  Resource.entity({
+    name: "team_memberships",
+    rowSchema: TeamMembershipSchema,
+    version: "version",
+    ...listSources(client, teamMembershipSpec),
+  });
+
+const workflowStateSpec = listSpec({
+  connection: "workflowStates",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt name type color description position team_id: team { id }`,
+  item: WorkflowStateObjectSchema,
+  updatedAt: (state) => state.updated_at,
+  rows: rowsOf((state) => ({ ...state, version: state.updated_at })),
+});
+
+export const makeWorkflowStates = (client: LinearClientService) =>
+  Resource.entity({
+    name: "workflow_states",
+    rowSchema: WorkflowStateSchema,
+    version: "version",
+    ...listSources(client, workflowStateSpec),
+  });
+
+const userSpec = listSpec({
+  connection: "users",
+  single: "user",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name display_name: displayName email avatar_url: avatarUrl title timezone
+    active admin owner guest app last_seen: lastSeen url`,
+  item: UserObjectSchema,
+  updatedAt: (user) => user.updated_at,
+  rows: rowsOf((user) => ({ ...user, version: user.updated_at, _deleted: false })),
+});
+
+export const makeUsers = (client: LinearClientService) =>
+  Resource.entity({
+    name: "users",
+    rowSchema: UserSchema,
+    version: "version",
+    ...listSources(client, userSpec),
+    webhook: webhookList(client, userSpec),
+  });
+
+const externalUserSpec = listSpec({
+  connection: "externalUsers",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt name display_name: displayName email avatar_url: avatarUrl last_seen: lastSeen`,
+  item: ExternalUserObjectSchema,
+  updatedAt: (user) => user.updated_at,
+  rows: rowsOf((user) => ({ ...user, version: user.updated_at })),
+});
+
+export const makeExternalUsers = (client: LinearClientService) =>
+  Resource.entity({
+    name: "external_users",
+    rowSchema: ExternalUserSchema,
+    version: "version",
+    ...listSources(client, externalUserSpec),
+  });
+
+const cycleSpec = listSpec({
+  connection: "cycles",
+  single: "cycle",
+  fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    number name description team_id: team { id } starts_at: startsAt ends_at: endsAt
+    completed_at: completedAt auto_archived_at: autoArchivedAt progress`,
+  item: CycleObjectSchema,
+  updatedAt: (cycle) => cycle.updated_at,
+  rows: rowsOf((cycle) => ({ ...cycle, version: cycle.updated_at, _deleted: false })),
+});
+
+export const makeCycles = (client: LinearClientService) =>
+  Resource.entity({
+    name: "cycles",
+    rowSchema: CycleSchema,
+    version: "version",
+
+    check: checkList(client, cycleSpec),
+    backfill: backfillList(client, cycleSpec),
+    changes: changesList(client, cycleSpec),
+    webhook: webhookList(client, cycleSpec),
+  });

package/src/sandbox.ts

@@ -0,0 +1,35 @@
+import {
+  ConnectorApp,
+  Ingestor,
+  RuntimeConfig,
+  StateStore,
+  Telemetry,
+} from "@useairfoil/connector-kit";
+import { Effect, Layer, Logger } from "effect";
+import { Command } from "effect/cli";
+
+import { LinearConnector } from "./index";
+
+const ConnectorLayer = LinearConnector.layerConfig(LinearConnector.LinearConfigDef.config);
+
+const TelemetryLayer = Layer.mergeAll(Telemetry.layerOtlp(), Telemetry.layerMetricsConsoleDump());
+
+export const sandboxCommand = Command.make("sandbox", {}, () =>
+  Effect.gen(function* () {
+    const port = yield* RuntimeConfig.httpPort;
+    const entrypoint = yield* LinearConnector.LinearConnector;
+
+    return yield* ConnectorApp.start(entrypoint, { port });
+  }).pipe(
+    Effect.annotateLogs({ component: "linear" }),
+    Effect.provide(
+      Layer.mergeAll(
+        StateStore.layerMemory,
+        Ingestor.layerConsole,
+        ConnectorLayer,
+        Logger.layer([Logger.consolePretty()]),
+        TelemetryLayer,
+      ),
+    ),
+  ),
+).pipe(Command.withDescription("Run the connector locally and log ingested data"));

package/src/schemas/comments.ts

@@ -0,0 +1,52 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { OptionalRef, OptionalString, OptionalTimestamp, common, deleted } from "./shared";
+
+export const CommentSchema = Schema.Struct({
+  ...common("Comment"),
+  _deleted: deleted("comment"),
+  body: Schema.String.pipe(Schema.annotateKey({ description: "Comment text in markdown." })),
+  user_id: OptionalRef.pipe(Schema.annotateKey({ description: "User who wrote the comment." })),
+  external_user_id: OptionalRef.pipe(
+    Schema.annotateKey({ description: "External user who wrote the comment." }),
+  ),
+  issue_id: OptionalString.pipe(Schema.annotateKey({ description: "Issue the comment is on." })),
+  project_id: OptionalString.pipe(
+    Schema.annotateKey({ description: "Project the comment is on." }),
+  ),
+  project_update_id: OptionalString.pipe(
+    Schema.annotateKey({ description: "Project update the comment is on." }),
+  ),
+  initiative_id: OptionalString.pipe(
+    Schema.annotateKey({ description: "Initiative the comment is on." }),
+  ),
+  initiative_update_id: OptionalString.pipe(
+    Schema.annotateKey({ description: "Initiative update the comment is on." }),
+  ),
+  document_content_id: OptionalString.pipe(
+    Schema.annotateKey({ description: "Document content the comment is on." }),
+  ),
+  parent_id: OptionalString.pipe(
+    Schema.annotateKey({ description: "Comment this one replies to." }),
+  ),
+  quoted_text: OptionalString.pipe(Schema.annotateKey({ description: "Text the comment quotes." })),
+  edited_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the comment was last edited." }),
+  ),
+  resolved_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the thread was resolved." }),
+  ),
+  resolving_user_id: OptionalRef.pipe(
+    Schema.annotateKey({ description: "User who resolved the thread." }),
+  ),
+  url: Schema.String.pipe(Schema.annotateKey({ description: "Comment URL." })),
+})
+  .annotate({ description: "Linear comments on issues, projects, initiatives, and updates." })
+  .pipe(Iceberg.identifier("id"));
+
+export type Comment = Schema.Schema.Type<typeof CommentSchema>;
+
+export const CommentObjectSchema = CommentSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version", "_deleted"]),
+);

package/src/schemas/customers.ts

@@ -0,0 +1,96 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { Long, OptionalRef, OptionalString, Ref, common, deleted } from "./shared";
+
+export const CustomerSchema = Schema.Struct({
+  ...common("Customer"),
+  _deleted: deleted("customer"),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Customer name." })),
+  domains: Schema.Array(Schema.String).pipe(
+    Schema.annotateKey({ description: "Email domains of the customer." }),
+  ),
+  external_ids: Schema.Array(Schema.String).pipe(
+    Schema.annotateKey({ description: "IDs in other systems." }),
+  ),
+  logo_url: OptionalString.pipe(Schema.annotateKey({ description: "Logo URL." })),
+  owner_id: OptionalRef.pipe(Schema.annotateKey({ description: "User who owns the customer." })),
+  status_id: Ref.pipe(Schema.annotateKey({ description: "Customer status." })),
+  tier_id: OptionalRef.pipe(Schema.annotateKey({ description: "Customer tier." })),
+  revenue: Schema.NullOr(Long).pipe(Schema.annotateKey({ description: "Annual revenue." })),
+  size: Schema.NullOr(Schema.Finite).pipe(Schema.annotateKey({ description: "Company size." })),
+  approximate_need_count: Schema.Finite.pipe(
+    Schema.annotateKey({ description: "About how many requests it has." }),
+  ),
+  url: Schema.String.pipe(Schema.annotateKey({ description: "Customer URL." })),
+})
+  .annotate({ description: "Linear customers." })
+  .pipe(Iceberg.identifier("id"));
+
+export type Customer = Schema.Schema.Type<typeof CustomerSchema>;
+
+export const CustomerObjectSchema = CustomerSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version", "_deleted"]),
+);
+
+export const CustomerNeedSchema = Schema.Struct({
+  ...common("Request"),
+  _deleted: deleted("request"),
+  customer_id: OptionalRef.pipe(Schema.annotateKey({ description: "Customer." })),
+  issue_id: OptionalRef.pipe(
+    Schema.annotateKey({ description: "Issue the request is linked to." }),
+  ),
+  project_id: OptionalRef.pipe(
+    Schema.annotateKey({ description: "Project the request is linked to." }),
+  ),
+  original_issue_id: OptionalRef.pipe(
+    Schema.annotateKey({ description: "Issue the request was first linked to." }),
+  ),
+  comment_id: OptionalRef.pipe(
+    Schema.annotateKey({ description: "Comment the request came from." }),
+  ),
+  attachment_id: OptionalRef.pipe(
+    Schema.annotateKey({ description: "Attachment the request came from." }),
+  ),
+  creator_id: OptionalRef.pipe(Schema.annotateKey({ description: "User who added the request." })),
+  body: OptionalString.pipe(Schema.annotateKey({ description: "Request text in markdown." })),
+  priority: Schema.Finite.pipe(Schema.annotateKey({ description: "0 normal, 1 important." })),
+  url: OptionalString.pipe(Schema.annotateKey({ description: "Source URL." })),
+})
+  .annotate({ description: "Linear customer requests, linked to issues or projects." })
+  .pipe(Iceberg.identifier("id"));
+
+export type CustomerNeed = Schema.Schema.Type<typeof CustomerNeedSchema>;
+
+export const CustomerNeedObjectSchema = CustomerNeedSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version", "_deleted"]),
+);
+
+const levelFields = (object: string) => ({
+  ...common(object),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Name." })),
+  display_name: Schema.String.pipe(Schema.annotateKey({ description: "Name shown in Linear." })),
+  description: OptionalString.pipe(Schema.annotateKey({ description: "Description." })),
+  color: Schema.String.pipe(Schema.annotateKey({ description: "Color, as hex." })),
+  position: Schema.Finite.pipe(Schema.annotateKey({ description: "Order in the list." })),
+});
+
+export const CustomerStatusSchema = Schema.Struct(levelFields("Status"))
+  .annotate({ description: "Linear customer statuses. Names the IDs in `customers.status_id`." })
+  .pipe(Iceberg.identifier("id"));
+
+export type CustomerStatus = Schema.Schema.Type<typeof CustomerStatusSchema>;
+
+export const CustomerStatusObjectSchema = CustomerStatusSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);
+
+export const CustomerTierSchema = Schema.Struct(levelFields("Tier"))
+  .annotate({ description: "Linear customer tiers. Names the IDs in `customers.tier_id`." })
+  .pipe(Iceberg.identifier("id"));
+
+export type CustomerTier = Schema.Schema.Type<typeof CustomerTierSchema>;
+
+export const CustomerTierObjectSchema = CustomerTierSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version"]),
+);

package/src/schemas/documents.ts

@@ -0,0 +1,40 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, Struct } from "effect";
+
+import { OptionalRef, OptionalString, OptionalTimestamp, common, deleted } from "./shared";
+
+export const DocumentSchema = Schema.Struct({
+  ...common("Document"),
+  _deleted: deleted("document"),
+  title: Schema.String.pipe(Schema.annotateKey({ description: "Title." })),
+  content: OptionalString.pipe(Schema.annotateKey({ description: "Content in markdown." })),
+  url: Schema.String.pipe(Schema.annotateKey({ description: "Document URL." })),
+  icon: OptionalString.pipe(Schema.annotateKey({ description: "Icon." })),
+  color: OptionalString.pipe(Schema.annotateKey({ description: "Icon color." })),
+  creator_id: OptionalRef.pipe(Schema.annotateKey({ description: "User who made the document." })),
+  updated_by_id: OptionalRef.pipe(
+    Schema.annotateKey({ description: "User who last changed the document." }),
+  ),
+  project_id: OptionalRef.pipe(Schema.annotateKey({ description: "Project the document is in." })),
+  initiative_id: OptionalRef.pipe(
+    Schema.annotateKey({ description: "Initiative the document is in." }),
+  ),
+  issue_id: OptionalRef.pipe(Schema.annotateKey({ description: "Issue the document is in." })),
+  cycle_id: OptionalRef.pipe(Schema.annotateKey({ description: "Cycle the document is in." })),
+  team_id: OptionalRef.pipe(Schema.annotateKey({ description: "Team the document is in." })),
+  parent_document_id: OptionalRef.pipe(Schema.annotateKey({ description: "Parent document." })),
+  hidden_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the document was hidden." }),
+  ),
+  trashed: Schema.NullOr(Schema.Boolean).pipe(
+    Schema.annotateKey({ description: "Whether the document is in the trash." }),
+  ),
+})
+  .annotate({ description: "Linear documents, including archived and trashed ones." })
+  .pipe(Iceberg.identifier("id"));
+
+export type Document = Schema.Schema.Type<typeof DocumentSchema>;
+
+export const DocumentObjectSchema = DocumentSchema.mapFields((fields) =>
+  Struct.omit(fields, ["version", "_deleted"]),
+);