@hasna/connectors 0.3.16 → 0.4.1

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);
+  }
+}