@useairfoil/producer-linear 0.0.2 → 0.0.3

package/src/schemas/releases.ts

@@ -1,34 +1,39 @@
 import { Iceberg } from "@useairfoil/connector-kit";
 import { Schema, SchemaTransformation, Struct } from "effect";
 
-import {
-  Long,
-  OptionalRef,
-  OptionalString,
-  OptionalTimestamp,
-  Ref,
-  common,
-  field,
-  list,
-} from "./shared";
+import { Long, OptionalRef, OptionalString, OptionalTimestamp, Ref, common } from "./shared";
 
 export const ReleaseSchema = Schema.Struct({
   ...common("Release"),
-  name: Schema.String.pipe(field(10, "Release name.")),
-  description: OptionalString.pipe(field(11, "Description.")),
+  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(field(12, "Version, such as 1.2.0.")),
-  url: Schema.String.pipe(field(13, "Release URL.")),
-  commit_sha: OptionalString.pipe(field(14, "Commit SHA.")),
-  pipeline_id: Ref.pipe(field(15, "Release pipeline.")),
-  stage_id: Ref.pipe(field(16, "Release stage.")),
-  creator_id: OptionalRef.pipe(field(17, "User who made the release.")),
-  start_date: OptionalString.pipe(field(18, "Start date, as YYYY-MM-DD.")),
-  target_date: OptionalString.pipe(field(19, "Target date, as YYYY-MM-DD.")),
-  started_at: OptionalTimestamp.pipe(field(20, "Time the release started.")),
-  completed_at: OptionalTimestamp.pipe(field(21, "Time the release was completed.")),
-  canceled_at: OptionalTimestamp.pipe(field(22, "Time the release was canceled.")),
-  trashed: Schema.NullOr(Schema.Boolean).pipe(field(23, "Whether the release is in the trash.")),
+  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"));
@@ -41,7 +46,7 @@ export const ReleaseObjectSchema = ReleaseSchema.mapFields((fields) =>
 
 export const ReleaseNoteSchema = Schema.Struct({
   ...common("Release note"),
-  title: OptionalString.pipe(field(10, "Release note title.")),
+  title: OptionalString.pipe(Schema.annotateKey({ description: "Release note title." })),
   content: Schema.NullOr(Schema.Struct({ content: OptionalString })).pipe(
     Schema.decodeTo(
       OptionalString,
@@ -50,11 +55,13 @@ export const ReleaseNoteSchema = Schema.Struct({
         encode: (content) => (content === null ? null : { content }),
       }),
     ),
-    field(11, "Release note body in markdown."),
+    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." }),
   ),
-  url: Schema.String.pipe(field(12, "Release note URL.")),
-  pipeline_id: Ref.pipe(field(13, "Release pipeline.")),
-  release_ids: list(101, Ref).pipe(field(14, "Releases covered by the note.")),
 })
   .annotate({ description: "Linear release notes. Needs the Business plan." })
   .pipe(Iceberg.identifier("id"));
@@ -67,15 +74,21 @@ export const ReleaseNoteObjectSchema = ReleaseNoteSchema.mapFields((fields) =>
 
 export const ReleasePipelineSchema = Schema.Struct({
   ...common("Pipeline"),
-  name: Schema.String.pipe(field(10, "Pipeline name.")),
-  type: Schema.String.pipe(field(11, "Pipeline type.")),
-  is_production: Schema.Boolean.pipe(field(12, "Whether it releases to production.")),
-  url: Schema.String.pipe(field(13, "Pipeline URL.")),
-  include_path_patterns: list(101, Schema.String).pipe(
-    field(14, "File paths that count toward the 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." }),
   ),
-  approximate_release_count: Long.pipe(field(15, "About how many releases it has.")),
-  trashed: Schema.NullOr(Schema.Boolean).pipe(field(16, "Whether the pipeline is in the trash.")),
 })
   .annotate({ description: "Linear release pipelines. Needs the Business plan." })
   .pipe(Iceberg.identifier("id"));
@@ -88,12 +101,12 @@ export const ReleasePipelineObjectSchema = ReleasePipelineSchema.mapFields((fiel
 
 export const ReleaseStageSchema = Schema.Struct({
   ...common("Stage"),
-  name: Schema.String.pipe(field(10, "Stage name.")),
-  type: Schema.String.pipe(field(11, "Stage type.")),
-  color: Schema.String.pipe(field(12, "Color, as hex.")),
-  position: Schema.Finite.pipe(field(13, "Order in the pipeline.")),
-  frozen: Schema.Boolean.pipe(field(14, "Whether the stage is frozen.")),
-  pipeline_id: Ref.pipe(field(15, "Release pipeline.")),
+  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"));
@@ -106,8 +119,8 @@ export const ReleaseStageObjectSchema = ReleaseStageSchema.mapFields((fields) =>
 
 export const IssueToReleaseSchema = Schema.Struct({
   ...common("Link"),
-  issue_id: Ref.pipe(field(10, "Issue.")),
-  release_id: Ref.pipe(field(11, "Release.")),
+  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"));

package/src/schemas/shared.ts

@@ -1,9 +1,5 @@
-import { Iceberg } from "@useairfoil/connector-kit";
 import { Schema, SchemaTransformation } from "effect";
 
-export const field = (fieldId: number, description: string) =>
-  Iceberg.field(fieldId, { description });
-
 export const Timestamp = Schema.DateFromString;
 
 /** Decodes a GraphQL Int as bigint for an Iceberg long. */
@@ -37,30 +33,36 @@ 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 = (elementId: number) =>
-  RefConnection.pipe(
-    Schema.decodeTo(
-      Schema.Array(Schema.String.annotate({ fieldId: elementId })),
-      SchemaTransformation.transform<ReadonlyArray<string>, typeof RefConnection.Type>({
-        decode: (connection) => connection.nodes.map((node) => node.id),
-        encode: (ids) => ({ nodes: ids.map((id) => ({ id })) }),
-      }),
-    ),
-  );
-
-export const list = <S extends Schema.Top>(elementId: number, item: S) =>
-  Schema.Array(item.annotate({ fieldId: elementId }));
+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(field(1, `${object} ID.`)),
-  version: Schema.Date.pipe(field(2, `Time Linear last changed the ${object.toLowerCase()}.`)),
-  created_at: Timestamp.pipe(field(3, `Time the ${object.toLowerCase()} was created.`)),
-  updated_at: Timestamp.pipe(field(4, `Time the ${object.toLowerCase()} was last updated.`)),
+  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(
-    field(5, `Time the ${object.toLowerCase()} was archived or trashed.`),
+    Schema.annotateKey({
+      description: `Time the ${object.toLowerCase()} was archived or trashed.`,
+    }),
   ),
 });
 
 export const deleted = (object: string) =>
-  Schema.optional(Schema.Boolean).pipe(field(6, `Whether the ${object} was deleted in Linear.`));
+  Schema.optional(Schema.Boolean).pipe(
+    Schema.annotateKey({ description: `Whether the ${object} was deleted in Linear.` }),
+  );

package/src/schemas/teams.ts

@@ -9,30 +9,45 @@ import {
   Timestamp,
   common,
   deleted,
-  field,
 } from "./shared";
 
 export const TeamSchema = Schema.Struct({
   ...common("Team"),
-  name: Schema.String.pipe(field(10, "Team name.")),
-  key: Schema.String.pipe(field(11, "Team key, used in issue IDs such as ENG-123.")),
-  display_name: Schema.String.pipe(field(12, "Name shown in Linear.")),
-  description: OptionalString.pipe(field(13, "Team description.")),
-  visibility: Schema.String.pipe(field(14, "Who can see the team.")),
-  parent_id: OptionalRef.pipe(field(15, "Parent team.")),
-  timezone: Schema.String.pipe(field(16, "Team timezone.")),
-  cycles_enabled: Schema.Boolean.pipe(field(17, "Whether the team uses cycles.")),
-  cycle_duration: Schema.Finite.pipe(field(18, "Cycle length in weeks.")),
-  cycle_cooldown_time: Schema.Finite.pipe(field(19, "Weeks between cycles.")),
-  cycle_start_day: Schema.Finite.pipe(field(20, "Day cycles start, 0 for Sunday.")),
-  triage_enabled: Schema.Boolean.pipe(field(21, "Whether the team uses triage.")),
-  issue_estimation_type: Schema.String.pipe(field(22, "Estimate scale.")),
-  default_issue_estimate: Schema.Finite.pipe(field(23, "Default estimate.")),
-  auto_archive_period: Schema.Finite.pipe(field(24, "Months before closed issues are archived.")),
+  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(
-    field(25, "Months before stale issues are closed."),
+    Schema.annotateKey({ description: "Months before stale issues are closed." }),
+  ),
+  retired_at: OptionalTimestamp.pipe(
+    Schema.annotateKey({ description: "Time the team was retired." }),
   ),
-  retired_at: OptionalTimestamp.pipe(field(26, "Time the team was retired.")),
 })
   .annotate({ description: "Linear teams." })
   .pipe(Iceberg.identifier("id"));
@@ -43,9 +58,11 @@ export const TeamObjectSchema = TeamSchema.mapFields((fields) => Struct.omit(fie
 
 export const TeamMembershipSchema = Schema.Struct({
   ...common("Membership"),
-  team_id: Ref.pipe(field(10, "Team.")),
-  user_id: Ref.pipe(field(11, "User.")),
-  owner: Schema.Boolean.pipe(field(12, "Whether the user owns the team.")),
+  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"));
@@ -58,14 +75,16 @@ export const TeamMembershipObjectSchema = TeamMembershipSchema.mapFields((fields
 
 export const WorkflowStateSchema = Schema.Struct({
   ...common("Workflow state"),
-  name: Schema.String.pipe(field(10, "State name.")),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "State name." })),
   type: Schema.String.pipe(
-    field(11, "State type: triage, backlog, unstarted, started, completed, or canceled."),
+    Schema.annotateKey({
+      description: "State type: triage, backlog, unstarted, started, completed, or canceled.",
+    }),
   ),
-  color: Schema.String.pipe(field(12, "State color, as hex.")),
-  description: OptionalString.pipe(field(13, "State description.")),
-  position: Schema.Finite.pipe(field(14, "Order within the team.")),
-  team_id: Ref.pipe(field(15, "Team.")),
+  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"));
@@ -79,19 +98,25 @@ export const WorkflowStateObjectSchema = WorkflowStateSchema.mapFields((fields)
 export const UserSchema = Schema.Struct({
   ...common("User"),
   _deleted: deleted("user"),
-  name: Schema.String.pipe(field(10, "Full name.")),
-  display_name: Schema.String.pipe(field(11, "Display name.")),
-  email: Schema.String.pipe(field(12, "Email address.")),
-  avatar_url: OptionalString.pipe(field(13, "Avatar image URL.")),
-  title: OptionalString.pipe(field(14, "Job title.")),
-  timezone: OptionalString.pipe(field(15, "Timezone.")),
-  active: Schema.Boolean.pipe(field(16, "Whether the user is active.")),
-  admin: Schema.Boolean.pipe(field(17, "Whether the user is an admin.")),
-  owner: Schema.Boolean.pipe(field(18, "Whether the user owns the workspace.")),
-  guest: Schema.Boolean.pipe(field(19, "Whether the user is a guest.")),
-  app: Schema.Boolean.pipe(field(20, "Whether the user is an app or agent.")),
-  last_seen: OptionalTimestamp.pipe(field(21, "Time the user was last online.")),
-  url: Schema.String.pipe(field(22, "Profile URL.")),
+  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"));
@@ -104,11 +129,13 @@ export const UserObjectSchema = UserSchema.mapFields((fields) =>
 
 export const ExternalUserSchema = Schema.Struct({
   ...common("External user"),
-  name: Schema.String.pipe(field(10, "Name.")),
-  display_name: Schema.String.pipe(field(11, "Display name.")),
-  email: OptionalString.pipe(field(12, "Email address.")),
-  avatar_url: OptionalString.pipe(field(13, "Avatar image URL.")),
-  last_seen: OptionalTimestamp.pipe(field(14, "Time the user was last seen.")),
+  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.",
@@ -124,15 +151,21 @@ export const ExternalUserObjectSchema = ExternalUserSchema.mapFields((fields) =>
 export const CycleSchema = Schema.Struct({
   ...common("Cycle"),
   _deleted: deleted("cycle"),
-  number: Schema.Finite.pipe(field(10, "Cycle number within its team.")),
-  name: OptionalString.pipe(field(11, "Cycle name.")),
-  description: OptionalString.pipe(field(12, "Cycle description.")),
-  team_id: Ref.pipe(field(13, "Team.")),
-  starts_at: Timestamp.pipe(field(14, "Time the cycle starts.")),
-  ends_at: Timestamp.pipe(field(15, "Time the cycle ends.")),
-  completed_at: OptionalTimestamp.pipe(field(16, "Time the cycle was completed.")),
-  auto_archived_at: OptionalTimestamp.pipe(field(17, "Time the cycle was archived automatically.")),
-  progress: Schema.Finite.pipe(field(18, "Share of the scope completed, from 0 to 1.")),
+  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"));

package/src/start.ts

@@ -30,7 +30,7 @@ export const startCommand = Command.make("start", {}, () =>
     const entrypoint = yield* LinearConnector.LinearConnector;
 
     return yield* ConnectorApp.start(entrypoint, { port }).pipe(
-      Effect.provide(Ingestor.layerWingsConfig(entrypoint)),
+      Effect.provide(Ingestor.layerArrowFlightConfig(entrypoint)),
     );
   }).pipe(
     Effect.annotateLogs({ component: "linear" }),
@@ -44,4 +44,4 @@ export const startCommand = Command.make("start", {}, () =>
     ),
     Effect.provide(RuntimeConfig.layerHosted()),
   ),
-).pipe(Command.withDescription("Run the production connector against Wings"));
+).pipe(Command.withDescription("Run the connector"));