Manage invatations

Author: KirillSergeevich

examples/connections.ts

@@ -17,6 +17,9 @@ async function connectionsExample(): Promise<void> {
     await sendConnectionRequest(linkedapi, targetPersonUrl);
     await retrievePendingRequests(linkedapi);
     await withdrawConnectionRequest(linkedapi, targetPersonUrl);
+    await retrieveConnectionRequests(linkedapi);
+    await acceptConnectionRequest(linkedapi, targetPersonUrl2);
+    await ignoreConnectionRequest(linkedapi, targetPersonUrl2);
     await retrieveConnections(linkedapi);
     await removeConnection(linkedapi, targetPersonUrl2);
 
@@ -196,6 +199,56 @@ async function removeConnection(linkedapi: LinkedApi, personUrl: string): Promis
   }
 }
 
+async function retrieveConnectionRequests(linkedapi: LinkedApi): Promise<void> {
+  console.log('\n📥 Retrieving incoming connection requests...');
+
+  const workflow = await linkedapi.retrieveConnectionRequests.execute();
+  console.log('📥 Retrieve connection requests workflow started:', workflow.workflowId);
+
+  const requestsResult = await linkedapi.retrieveConnectionRequests.result(workflow.workflowId);
+  if (requestsResult.data) {
+    const requests = requestsResult.data;
+    console.log('✅ Incoming requests retrieval completed');
+    console.log(`📊 Found ${requests.length} incoming requests`);
+    requests.forEach((request, index) => {
+      console.log(`  ${index + 1}. ${request.name}`);
+      console.log(`     Profile: ${request.publicUrl}`);
+      console.log(`     Headline: ${request.headline}`);
+    });
+  }
+  if (requestsResult.errors.length > 0) {
+    console.error('🚨 Errors:', JSON.stringify(requestsResult.errors, null, 2));
+  }
+}
+
+async function acceptConnectionRequest(linkedapi: LinkedApi, personUrl: string): Promise<void> {
+  console.log('\n🤝 Accepting incoming connection request...');
+
+  const workflow = await linkedapi.acceptConnectionRequest.execute({ personUrl });
+  console.log('🤝 Accept connection request workflow started:', workflow.workflowId);
+
+  const acceptResult = await linkedapi.acceptConnectionRequest.result(workflow.workflowId);
+  if (acceptResult.errors.length > 0) {
+    console.error('🚨 Errors:', JSON.stringify(acceptResult.errors, null, 2));
+  } else {
+    console.log('✅ Connection request accepted successfully');
+  }
+}
+
+async function ignoreConnectionRequest(linkedapi: LinkedApi, personUrl: string): Promise<void> {
+  console.log('\n🙈 Ignoring incoming connection request...');
+
+  const workflow = await linkedapi.ignoreConnectionRequest.execute({ personUrl });
+  console.log('🙈 Ignore connection request workflow started:', workflow.workflowId);
+
+  const ignoreResult = await linkedapi.ignoreConnectionRequest.result(workflow.workflowId);
+  if (ignoreResult.errors.length > 0) {
+    console.error('🚨 Errors:', JSON.stringify(ignoreResult.errors, null, 2));
+  } else {
+    console.log('✅ Connection request ignored successfully');
+  }
+}
+
 if (require.main === module) {
   connectionsExample();
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linkedapi/node",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "Control your LinkedIn accounts and retrieve real-time data, all through this Node.js SDK.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/core/operation.ts

@@ -23,6 +23,9 @@ export const OPERATION_NAME = {
   sendConnectionRequest: 'sendConnectionRequest',
   withdrawConnectionRequest: 'withdrawConnectionRequest',
   retrievePendingRequests: 'retrievePendingRequests',
+  retrieveConnectionRequests: 'retrieveConnectionRequests',
+  acceptConnectionRequest: 'acceptConnectionRequest',
+  ignoreConnectionRequest: 'ignoreConnectionRequest',
   retrieveConnections: 'retrieveConnections',
   removeConnection: 'removeConnection',
   searchCompanies: 'searchCompanies',

src/index.ts

@@ -2,6 +2,7 @@ import { Operation } from './core';
 import { buildLinkedApiHttpClient } from './core/linked-api-http-client';
 import type { TMappedResponse } from './mappers/base-mapper.abstract';
 import {
+  AcceptConnectionRequest,
   CheckConnectionStatus,
   CommentOnPost,
   CreatePost,
@@ -10,6 +11,7 @@ import {
   FetchJob,
   FetchPerson,
   FetchPost,
+  IgnoreConnectionRequest,
   ManageConversation,
   NvFetchCompany,
   NvFetchPerson,
@@ -21,6 +23,7 @@ import {
   NvSyncInbox,
   ReactToPost,
   RemoveConnection,
+  RetrieveConnectionRequests,
   RetrieveConnections,
   RetrievePendingRequests,
   RetrievePerformance,
@@ -104,6 +107,9 @@ class LinkedApi {
     this.sendConnectionRequest = new SendConnectionRequest(this.httpClient);
     this.withdrawConnectionRequest = new WithdrawConnectionRequest(this.httpClient);
     this.retrievePendingRequests = new RetrievePendingRequests(this.httpClient);
+    this.retrieveConnectionRequests = new RetrieveConnectionRequests(this.httpClient);
+    this.acceptConnectionRequest = new AcceptConnectionRequest(this.httpClient);
+    this.ignoreConnectionRequest = new IgnoreConnectionRequest(this.httpClient);
     this.retrieveConnections = new RetrieveConnections(this.httpClient);
     this.removeConnection = new RemoveConnection(this.httpClient);
     this.searchCompanies = new SearchCompanies(this.httpClient);
@@ -137,6 +143,9 @@ class LinkedApi {
       this.sendConnectionRequest,
       this.withdrawConnectionRequest,
       this.retrievePendingRequests,
+      this.retrieveConnectionRequests,
+      this.acceptConnectionRequest,
+      this.ignoreConnectionRequest,
       this.retrieveConnections,
       this.removeConnection,
       this.searchCompanies,
@@ -1037,6 +1046,69 @@ class LinkedApi {
    */
   public retrievePendingRequests: RetrievePendingRequests;
 
+  /**
+   * Retrieve incoming connection requests (invitations others have sent you).
+   *
+   * This method fetches the list of received connection requests from your invitation manager.
+   *
+   * @returns Promise resolving to an object containing an array of received requests
+   *
+   * @see {@link https://linkedapi.io/docs/working-with-connection-requests/ Working with Connection Requests Documentation}
+   * @see {@link https://linkedapi.io/docs/action-st-retrieve-connection-requests/ st.retrieveConnectionRequests Action Documentation}
+   *
+   * @example
+   * ```typescript
+   * const workflow = await linkedapi.retrieveConnectionRequests.execute();
+   *
+   * const result = await linkedapi.retrieveConnectionRequests.result(workflow.workflowId);
+   * if (result.data) {
+   *   result.data.forEach(request => {
+   *     console.log(`${request.name}: ${request.headline}`);
+   *     console.log(`Profile: ${request.publicUrl}`);
+   *   });
+   * }
+   * ```
+   */
+  public retrieveConnectionRequests: RetrieveConnectionRequests;
+
+  /**
+   * Accept an incoming connection request from a person's profile.
+   *
+   * @param params - Parameters including the person's profile URL
+   *
+   * @see {@link https://linkedapi.io/docs/working-with-connection-requests/ Working with Connection Requests Documentation}
+   * @see {@link https://linkedapi.io/docs/action-st-accept-connection-request/ st.acceptConnectionRequest Action Documentation}
+   *
+   * @example
+   * ```typescript
+   * const workflow = await linkedapi.acceptConnectionRequest.execute({
+   *   personUrl: "https://www.linkedin.com/in/john-doe",
+   * });
+   *
+   * await linkedapi.acceptConnectionRequest.result(workflow.workflowId);
+   * ```
+   */
+  public acceptConnectionRequest: AcceptConnectionRequest;
+
+  /**
+   * Ignore an incoming connection request from a person's profile.
+   *
+   * @param params - Parameters including the person's profile URL
+   *
+   * @see {@link https://linkedapi.io/docs/working-with-connection-requests/ Working with Connection Requests Documentation}
+   * @see {@link https://linkedapi.io/docs/action-st-ignore-connection-request/ st.ignoreConnectionRequest Action Documentation}
+   *
+   * @example
+   * ```typescript
+   * const workflow = await linkedapi.ignoreConnectionRequest.execute({
+   *   personUrl: "https://www.linkedin.com/in/john-doe",
+   * });
+   *
+   * await linkedapi.ignoreConnectionRequest.result(workflow.workflowId);
+   * ```
+   */
+  public ignoreConnectionRequest: IgnoreConnectionRequest;
+
   /**
    * Retrieve your LinkedIn connections with optional filtering.
    *

src/operations/accept-connection-request.ts

@@ -0,0 +1,10 @@
+import { Operation, TOperationName } from '../core';
+import { VoidWorkflowMapper } from '../mappers';
+import { TAcceptConnectionRequestParams } from '../types';
+
+export class AcceptConnectionRequest extends Operation<TAcceptConnectionRequestParams, void> {
+  public override readonly operationName: TOperationName = 'acceptConnectionRequest';
+  protected override readonly mapper = new VoidWorkflowMapper<TAcceptConnectionRequestParams>(
+    'st.acceptConnectionRequest',
+  );
+}

src/operations/ignore-connection-request.ts

@@ -0,0 +1,10 @@
+import { Operation, TOperationName } from '../core';
+import { VoidWorkflowMapper } from '../mappers';
+import { TIgnoreConnectionRequestParams } from '../types';
+
+export class IgnoreConnectionRequest extends Operation<TIgnoreConnectionRequestParams, void> {
+  public override readonly operationName: TOperationName = 'ignoreConnectionRequest';
+  protected override readonly mapper = new VoidWorkflowMapper<TIgnoreConnectionRequestParams>(
+    'st.ignoreConnectionRequest',
+  );
+}

src/operations/index.ts

@@ -22,6 +22,9 @@ export * from './send-connection-request';
 export * from './check-connection-status';
 export * from './withdraw-connection-request';
 export * from './retrieve-pending-requests';
+export * from './retrieve-connection-requests';
+export * from './accept-connection-request';
+export * from './ignore-connection-request';
 export * from './retrieve-connections';
 export * from './remove-connection';
 export * from './react-to-post';

src/operations/retrieve-connection-requests.ts

@@ -0,0 +1,14 @@
+import { Operation, TOperationName } from '../core';
+import { ArrayWorkflowMapper } from '../mappers/array-workflow-mapper';
+import { TRetrieveConnectionRequestsResult } from '../types';
+
+export class RetrieveConnectionRequests extends Operation<
+  void,
+  TRetrieveConnectionRequestsResult[]
+> {
+  public override readonly operationName: TOperationName = 'retrieveConnectionRequests';
+  protected override readonly mapper = new ArrayWorkflowMapper<
+    void,
+    TRetrieveConnectionRequestsResult
+  >('st.retrieveConnectionRequests');
+}

src/types/actions/connection.ts

@@ -26,10 +26,25 @@ export interface TCheckConnectionStatusResult {
 export const CONNECTION_STATUS = {
   connected: 'connected',
   pending: 'pending',
+  incoming: 'incoming',
   notConnected: 'notConnected',
 } as const;
 export type TConnectionStatus = (typeof CONNECTION_STATUS)[keyof typeof CONNECTION_STATUS];
 
+export interface TAcceptConnectionRequestParams extends TBaseActionParams {
+  personUrl: string;
+}
+
+export interface TIgnoreConnectionRequestParams extends TBaseActionParams {
+  personUrl: string;
+}
+
+export interface TRetrieveConnectionRequestsResult {
+  name: string;
+  publicUrl: string;
+  headline: string;
+}
+
 export interface TWithdrawConnectionRequestParams extends TBaseActionParams {
   personUrl: string;
   unfollow?: boolean;