@hasna/connectors 0.3.16 → 0.4.0

package/connectors/connect-linear/src/api/issues.ts

@@ -0,0 +1,247 @@
+import type { LinearClient } from './client';
+import type {
+  LinearIssue,
+  IssueListOptions,
+  CreateIssueInput,
+  UpdateIssueInput,
+  IssuesResponse,
+  IssueResponse,
+  CreateIssueResponse,
+  UpdateIssueResponse,
+  ArchiveIssueResponse,
+  IssueFilter,
+} from '../types';
+
+const ISSUE_FRAGMENT = `
+  fragment IssueFragment on Issue {
+    id
+    identifier
+    title
+    description
+    priority
+    priorityLabel
+    estimate
+    sortOrder
+    boardOrder
+    startedAt
+    completedAt
+    canceledAt
+    dueDate
+    createdAt
+    updatedAt
+    archivedAt
+    url
+    number
+    team {
+      id
+      name
+      key
+    }
+    state {
+      id
+      name
+      color
+      type
+    }
+    assignee {
+      id
+      name
+      displayName
+      email
+    }
+    creator {
+      id
+      name
+      displayName
+    }
+    labels {
+      nodes {
+        id
+        name
+        color
+      }
+    }
+    project {
+      id
+      name
+    }
+  }
+`;
+
+export class IssuesApi {
+  constructor(private readonly client: LinearClient) {}
+
+  /**
+   * List issues with optional filters
+   */
+  async list(options: IssueListOptions = {}): Promise<LinearIssue[]> {
+    const { first = 50, after, teamId, projectId, assigneeId, filter } = options;
+
+    // Build filter object
+    const filterObj: IssueFilter = filter || {};
+    if (teamId) {
+      filterObj.team = { id: { eq: teamId } };
+    }
+    if (projectId) {
+      filterObj.project = { id: { eq: projectId } };
+    }
+    if (assigneeId) {
+      filterObj.assignee = { id: { eq: assigneeId } };
+    }
+
+    const query = `
+      ${ISSUE_FRAGMENT}
+      query Issues($first: Int, $after: String, $filter: IssueFilter) {
+        issues(first: $first, after: $after, filter: $filter) {
+          nodes {
+            ...IssueFragment
+          }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.query<IssuesResponse>(query, {
+      first,
+      after,
+      filter: Object.keys(filterObj).length > 0 ? filterObj : undefined,
+    });
+
+    return result.issues.nodes;
+  }
+
+  /**
+   * Get a single issue by ID
+   */
+  async get(id: string): Promise<LinearIssue> {
+    const query = `
+      ${ISSUE_FRAGMENT}
+      query Issue($id: String!) {
+        issue(id: $id) {
+          ...IssueFragment
+        }
+      }
+    `;
+
+    const result = await this.client.query<IssueResponse>(query, { id });
+    return result.issue;
+  }
+
+  /**
+   * Create a new issue
+   */
+  async create(input: CreateIssueInput): Promise<LinearIssue> {
+    const mutation = `
+      ${ISSUE_FRAGMENT}
+      mutation CreateIssue($input: IssueCreateInput!) {
+        issueCreate(input: $input) {
+          success
+          issue {
+            ...IssueFragment
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.mutate<CreateIssueResponse>(mutation, {
+      input,
+    });
+
+    if (!result.issueCreate.success || !result.issueCreate.issue) {
+      throw new Error('Failed to create issue');
+    }
+
+    return result.issueCreate.issue;
+  }
+
+  /**
+   * Update an existing issue
+   */
+  async update(id: string, input: UpdateIssueInput): Promise<LinearIssue> {
+    const mutation = `
+      ${ISSUE_FRAGMENT}
+      mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+        issueUpdate(id: $id, input: $input) {
+          success
+          issue {
+            ...IssueFragment
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.mutate<UpdateIssueResponse>(mutation, {
+      id,
+      input,
+    });
+
+    if (!result.issueUpdate.success || !result.issueUpdate.issue) {
+      throw new Error('Failed to update issue');
+    }
+
+    return result.issueUpdate.issue;
+  }
+
+  /**
+   * Archive an issue (soft delete)
+   */
+  async archive(id: string): Promise<boolean> {
+    const mutation = `
+      mutation ArchiveIssue($id: String!) {
+        issueArchive(id: $id) {
+          success
+        }
+      }
+    `;
+
+    const result = await this.client.mutate<ArchiveIssueResponse>(mutation, { id });
+    return result.issueArchive.success;
+  }
+
+  /**
+   * Change issue state by state ID
+   */
+  async changeState(id: string, stateId: string): Promise<LinearIssue> {
+    return this.update(id, { stateId });
+  }
+
+  /**
+   * Assign issue to a user
+   */
+  async assign(id: string, assigneeId: string): Promise<LinearIssue> {
+    return this.update(id, { assigneeId });
+  }
+
+  /**
+   * Add issue to a project
+   */
+  async addToProject(id: string, projectId: string): Promise<LinearIssue> {
+    return this.update(id, { projectId });
+  }
+
+  /**
+   * Search issues by query text
+   */
+  async search(query: string, first = 20): Promise<LinearIssue[]> {
+    const gqlQuery = `
+      ${ISSUE_FRAGMENT}
+      query SearchIssues($query: String!, $first: Int) {
+        issueSearch(query: $query, first: $first) {
+          nodes {
+            ...IssueFragment
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.query<{ issueSearch: { nodes: LinearIssue[] } }>(
+      gqlQuery,
+      { query, first }
+    );
+
+    return result.issueSearch.nodes;
+  }
+}

package/connectors/connect-linear/src/api/projects.ts

@@ -0,0 +1,179 @@
+import type { LinearClient } from './client';
+import type { LinearProject, ProjectsResponse, ProjectResponse, ListOptions } from '../types';
+
+const PROJECT_FRAGMENT = `
+  fragment ProjectFragment on Project {
+    id
+    name
+    description
+    icon
+    color
+    state
+    progress
+    startDate
+    targetDate
+    createdAt
+    updatedAt
+    lead {
+      id
+      name
+      displayName
+      email
+    }
+    teams {
+      nodes {
+        id
+        name
+        key
+      }
+    }
+  }
+`;
+
+export interface CreateProjectInput {
+  name: string;
+  description?: string;
+  teamIds: string[];
+  leadId?: string;
+  startDate?: string;
+  targetDate?: string;
+  color?: string;
+  icon?: string;
+}
+
+export interface UpdateProjectInput {
+  name?: string;
+  description?: string;
+  leadId?: string;
+  startDate?: string;
+  targetDate?: string;
+  color?: string;
+  icon?: string;
+  state?: string;
+}
+
+interface ProjectPayload {
+  success: boolean;
+  project?: LinearProject;
+}
+
+interface CreateProjectResponse {
+  projectCreate: ProjectPayload;
+}
+
+interface UpdateProjectResponse {
+  projectUpdate: ProjectPayload;
+}
+
+export class ProjectsApi {
+  constructor(private readonly client: LinearClient) {}
+
+  /**
+   * List all projects
+   */
+  async list(options: ListOptions = {}): Promise<LinearProject[]> {
+    const { first = 50, after } = options;
+
+    const query = `
+      ${PROJECT_FRAGMENT}
+      query Projects($first: Int, $after: String) {
+        projects(first: $first, after: $after) {
+          nodes {
+            ...ProjectFragment
+          }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.query<ProjectsResponse>(query, {
+      first,
+      after,
+    });
+
+    return result.projects.nodes;
+  }
+
+  /**
+   * Get a single project by ID
+   */
+  async get(id: string): Promise<LinearProject> {
+    const query = `
+      ${PROJECT_FRAGMENT}
+      query Project($id: String!) {
+        project(id: $id) {
+          ...ProjectFragment
+        }
+      }
+    `;
+
+    const result = await this.client.query<ProjectResponse>(query, { id });
+    return result.project;
+  }
+
+  /**
+   * Create a new project
+   */
+  async create(input: CreateProjectInput): Promise<LinearProject> {
+    const mutation = `
+      ${PROJECT_FRAGMENT}
+      mutation CreateProject($input: ProjectCreateInput!) {
+        projectCreate(input: $input) {
+          success
+          project {
+            ...ProjectFragment
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.mutate<CreateProjectResponse>(mutation, {
+      input,
+    });
+
+    if (!result.projectCreate.success || !result.projectCreate.project) {
+      throw new Error('Failed to create project');
+    }
+
+    return result.projectCreate.project;
+  }
+
+  /**
+   * Update a project
+   */
+  async update(id: string, input: UpdateProjectInput): Promise<LinearProject> {
+    const mutation = `
+      ${PROJECT_FRAGMENT}
+      mutation UpdateProject($id: String!, $input: ProjectUpdateInput!) {
+        projectUpdate(id: $id, input: $input) {
+          success
+          project {
+            ...ProjectFragment
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.mutate<UpdateProjectResponse>(mutation, {
+      id,
+      input,
+    });
+
+    if (!result.projectUpdate.success || !result.projectUpdate.project) {
+      throw new Error('Failed to update project');
+    }
+
+    return result.projectUpdate.project;
+  }
+
+  /**
+   * Search projects by name
+   */
+  async findByName(name: string): Promise<LinearProject | undefined> {
+    const projects = await this.list();
+    return projects.find(p => p.name.toLowerCase() === name.toLowerCase());
+  }
+}

package/connectors/connect-linear/src/api/teams.ts

@@ -0,0 +1,125 @@
+import type { LinearClient } from './client';
+import type { LinearTeam, LinearWorkflowState, TeamsResponse, TeamResponse, ListOptions } from '../types';
+
+const TEAM_FRAGMENT = `
+  fragment TeamFragment on Team {
+    id
+    name
+    key
+    description
+    icon
+    color
+    private
+    createdAt
+    updatedAt
+  }
+`;
+
+const WORKFLOW_STATE_FRAGMENT = `
+  fragment WorkflowStateFragment on WorkflowState {
+    id
+    name
+    color
+    type
+    position
+  }
+`;
+
+interface WorkflowStatesResponse {
+  workflowStates: {
+    nodes: LinearWorkflowState[];
+  };
+}
+
+export class TeamsApi {
+  constructor(private readonly client: LinearClient) {}
+
+  /**
+   * List all teams
+   */
+  async list(options: ListOptions = {}): Promise<LinearTeam[]> {
+    const { first = 50, after } = options;
+
+    const query = `
+      ${TEAM_FRAGMENT}
+      query Teams($first: Int, $after: String) {
+        teams(first: $first, after: $after) {
+          nodes {
+            ...TeamFragment
+          }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.query<TeamsResponse>(query, {
+      first,
+      after,
+    });
+
+    return result.teams.nodes;
+  }
+
+  /**
+   * Get a single team by ID
+   */
+  async get(id: string): Promise<LinearTeam> {
+    const query = `
+      ${TEAM_FRAGMENT}
+      query Team($id: String!) {
+        team(id: $id) {
+          ...TeamFragment
+        }
+      }
+    `;
+
+    const result = await this.client.query<TeamResponse>(query, { id });
+    return result.team;
+  }
+
+  /**
+   * Find team by key (e.g., "ENG", "DES")
+   */
+  async findByKey(key: string): Promise<LinearTeam | undefined> {
+    const teams = await this.list();
+    return teams.find(t => t.key.toLowerCase() === key.toLowerCase());
+  }
+
+  /**
+   * Find team by name
+   */
+  async findByName(name: string): Promise<LinearTeam | undefined> {
+    const teams = await this.list();
+    return teams.find(t => t.name.toLowerCase() === name.toLowerCase());
+  }
+
+  /**
+   * Get workflow states for a team
+   */
+  async getWorkflowStates(teamId: string): Promise<LinearWorkflowState[]> {
+    const query = `
+      ${WORKFLOW_STATE_FRAGMENT}
+      query WorkflowStates($teamId: String!) {
+        workflowStates(filter: { team: { id: { eq: $teamId } } }) {
+          nodes {
+            ...WorkflowStateFragment
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.query<WorkflowStatesResponse>(query, { teamId });
+    return result.workflowStates.nodes;
+  }
+
+  /**
+   * Get a specific workflow state by name for a team
+   */
+  async findWorkflowState(teamId: string, stateName: string): Promise<LinearWorkflowState | undefined> {
+    const states = await this.getWorkflowStates(teamId);
+    return states.find(s => s.name.toLowerCase() === stateName.toLowerCase());
+  }
+}

package/connectors/connect-linear/src/api/users.ts

@@ -0,0 +1,112 @@
+import type { LinearClient } from './client';
+import type { LinearUser, UsersResponse, UserResponse, ViewerResponse, ListOptions } from '../types';
+
+const USER_FRAGMENT = `
+  fragment UserFragment on User {
+    id
+    name
+    displayName
+    email
+    avatarUrl
+    active
+    admin
+    createdAt
+    updatedAt
+  }
+`;
+
+export class UsersApi {
+  constructor(private readonly client: LinearClient) {}
+
+  /**
+   * List all users
+   */
+  async list(options: ListOptions = {}): Promise<LinearUser[]> {
+    const { first = 100, after } = options;
+
+    const query = `
+      ${USER_FRAGMENT}
+      query Users($first: Int, $after: String) {
+        users(first: $first, after: $after) {
+          nodes {
+            ...UserFragment
+          }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+        }
+      }
+    `;
+
+    const result = await this.client.query<UsersResponse>(query, {
+      first,
+      after,
+    });
+
+    return result.users.nodes;
+  }
+
+  /**
+   * Get a single user by ID
+   */
+  async get(id: string): Promise<LinearUser> {
+    const query = `
+      ${USER_FRAGMENT}
+      query User($id: String!) {
+        user(id: $id) {
+          ...UserFragment
+        }
+      }
+    `;
+
+    const result = await this.client.query<UserResponse>(query, { id });
+    return result.user;
+  }
+
+  /**
+   * Get the currently authenticated user
+   */
+  async me(): Promise<LinearUser> {
+    const query = `
+      ${USER_FRAGMENT}
+      query Viewer {
+        viewer {
+          ...UserFragment
+        }
+      }
+    `;
+
+    const result = await this.client.query<ViewerResponse>(query);
+    return result.viewer;
+  }
+
+  /**
+   * Find user by email
+   */
+  async findByEmail(email: string): Promise<LinearUser | undefined> {
+    const users = await this.list();
+    return users.find(u => u.email.toLowerCase() === email.toLowerCase());
+  }
+
+  /**
+   * Find user by name or display name
+   */
+  async findByName(name: string): Promise<LinearUser | undefined> {
+    const users = await this.list();
+    const lowerName = name.toLowerCase();
+    return users.find(
+      u =>
+        u.name.toLowerCase() === lowerName ||
+        u.displayName.toLowerCase() === lowerName
+    );
+  }
+
+  /**
+   * List only active users
+   */
+  async listActive(options: ListOptions = {}): Promise<LinearUser[]> {
+    const users = await this.list(options);
+    return users.filter(u => u.active);
+  }
+}