Invitations

Author: KirillSergeevich

examples/connections.ts

@@ -1,7 +1,10 @@
-import LinkedApi, { LinkedApiError } from '@linkedapi/node';
+import LinkedApi, {
+  INVITATION_TYPE,
+  LinkedApiError,
+  TRetrieveInvitationsResult,
+} from '@linkedapi/node';
 
 async function connectionsExample(): Promise<void> {
-
   const linkedapi = new LinkedApi({
     linkedApiToken: process.env.LINKED_API_TOKEN!,
     identificationToken: process.env.IDENTIFICATION_TOKEN!,
@@ -17,12 +20,11 @@ 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 retrieveInvitations(linkedapi);
+    await acceptInvitation(linkedapi, targetPersonUrl2);
+    await ignoreInvitation(linkedapi, targetPersonUrl2);
     await retrieveConnections(linkedapi);
     await removeConnection(linkedapi, targetPersonUrl2);
-
   } catch (error) {
     if (error instanceof LinkedApiError) {
       console.error('🚨 Linked API Error:', error.message);
@@ -59,7 +61,7 @@ async function sendConnectionRequest(linkedapi: LinkedApi, personUrl: string): P
 
   const requestParams = {
     personUrl: personUrl,
-    note: 'Hi! I\'d love to connect and discuss potential collaboration opportunities. Looking forward to connecting with you!',
+    note: "Hi! I'd love to connect and discuss potential collaboration opportunities. Looking forward to connecting with you!",
     email: 'example@gmail.com',
   };
 
@@ -199,53 +201,77 @@ async function removeConnection(linkedapi: LinkedApi, personUrl: string): Promis
   }
 }
 
-async function retrieveConnectionRequests(linkedapi: LinkedApi): Promise<void> {
-  console.log('\n📥 Retrieving incoming connection requests...');
+async function retrieveInvitations(linkedapi: LinkedApi): Promise<void> {
+  console.log('\n📥 Retrieving incoming invitations...');
 
-  const workflow = await linkedapi.retrieveConnectionRequests.execute();
-  console.log('📥 Retrieve connection requests workflow started:', workflow.workflowId);
+  const workflow = await linkedapi.retrieveInvitations.execute();
+  console.log('📥 Retrieve invitations 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}`);
-    });
+  const invitationsResult = await linkedapi.retrieveInvitations.result(workflow.workflowId);
+  if (invitationsResult.data) {
+    const invitations = invitationsResult.data;
+    console.log('✅ Incoming invitations retrieval completed');
+    console.log(`📊 Found ${invitations.length} incoming invitations`);
+    for (const [index, invitation] of invitations.entries()) {
+      console.log(`  ${index + 1}. ${invitation.name}`);
+      logInvitationTarget(invitation);
+    }
   }
-  if (requestsResult.errors.length > 0) {
-    console.error('🚨 Errors:', JSON.stringify(requestsResult.errors, null, 2));
+  if (invitationsResult.errors.length > 0) {
+    console.error('🚨 Errors:', JSON.stringify(invitationsResult.errors, null, 2));
   }
 }
 
-async function acceptConnectionRequest(linkedapi: LinkedApi, personUrl: string): Promise<void> {
-  console.log('\n🤝 Accepting incoming connection request...');
+async function acceptInvitation(linkedapi: LinkedApi, personUrl: string): Promise<void> {
+  console.log('\n🤝 Accepting incoming invitation...');
 
-  const workflow = await linkedapi.acceptConnectionRequest.execute({ personUrl });
-  console.log('🤝 Accept connection request workflow started:', workflow.workflowId);
+  const workflow = await linkedapi.acceptInvitation.execute({
+    invitationType: INVITATION_TYPE.connect,
+    personUrl,
+  });
+  console.log('🤝 Accept invitation workflow started:', workflow.workflowId);
 
-  const acceptResult = await linkedapi.acceptConnectionRequest.result(workflow.workflowId);
+  const acceptResult = await linkedapi.acceptInvitation.result(workflow.workflowId);
   if (acceptResult.errors.length > 0) {
     console.error('🚨 Errors:', JSON.stringify(acceptResult.errors, null, 2));
   } else {
-    console.log('✅ Connection request accepted successfully');
+    console.log('✅ Invitation accepted successfully');
   }
 }
 
-async function ignoreConnectionRequest(linkedapi: LinkedApi, personUrl: string): Promise<void> {
-  console.log('\n🙈 Ignoring incoming connection request...');
+async function ignoreInvitation(linkedapi: LinkedApi, personUrl: string): Promise<void> {
+  console.log('\n🙈 Ignoring incoming invitation...');
 
-  const workflow = await linkedapi.ignoreConnectionRequest.execute({ personUrl });
-  console.log('🙈 Ignore connection request workflow started:', workflow.workflowId);
+  const workflow = await linkedapi.ignoreInvitation.execute({
+    invitationType: INVITATION_TYPE.connect,
+    personUrl,
+  });
+  console.log('🙈 Ignore invitation workflow started:', workflow.workflowId);
 
-  const ignoreResult = await linkedapi.ignoreConnectionRequest.result(workflow.workflowId);
+  const ignoreResult = await linkedapi.ignoreInvitation.result(workflow.workflowId);
   if (ignoreResult.errors.length > 0) {
     console.error('🚨 Errors:', JSON.stringify(ignoreResult.errors, null, 2));
   } else {
-    console.log('✅ Connection request ignored successfully');
+    console.log('✅ Invitation ignored successfully');
+  }
+}
+
+function logInvitationTarget(invitation: TRetrieveInvitationsResult): void {
+  console.log(`     Type: ${invitation.invitationType}`);
+  switch (invitation.invitationType) {
+    case INVITATION_TYPE.connect:
+      console.log(`     Profile: ${invitation.publicUrl}`);
+      console.log(`     Headline: ${invitation.headline}`);
+      console.log(`     Note: ${invitation.note}`);
+      break;
+    case INVITATION_TYPE.companyFollow:
+      console.log(`     Company: ${invitation.companyName}`);
+      console.log(`     Company URL: ${invitation.companyUrl}`);
+      break;
+    case INVITATION_TYPE.newsletterSubscribe:
+      console.log(`     Newsletter: ${invitation.newsletterName}`);
+      console.log(`     Newsletter URL: ${invitation.newsletterUrl}`);
+      break;
   }
 }
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linkedapi/node",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "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

@@ -24,9 +24,9 @@ export const OPERATION_NAME = {
   sendConnectionRequest: 'sendConnectionRequest',
   withdrawConnectionRequest: 'withdrawConnectionRequest',
   retrievePendingRequests: 'retrievePendingRequests',
-  retrieveConnectionRequests: 'retrieveConnectionRequests',
-  acceptConnectionRequest: 'acceptConnectionRequest',
-  ignoreConnectionRequest: 'ignoreConnectionRequest',
+  retrieveInvitations: 'retrieveInvitations',
+  acceptInvitation: 'acceptInvitation',
+  ignoreInvitation: 'ignoreInvitation',
   retrieveConnections: 'retrieveConnections',
   removeConnection: 'removeConnection',
   searchCompanies: 'searchCompanies',

src/index.ts

@@ -2,7 +2,7 @@ import { Operation } from './core';
 import { buildLinkedApiHttpClient } from './core/linked-api-http-client';
 import type { TMappedResponse } from './mappers/base-mapper.abstract';
 import {
-  AcceptConnectionRequest,
+  AcceptInvitation,
   CheckConnectionStatus,
   CommentOnPost,
   CreatePost,
@@ -11,7 +11,7 @@ import {
   FetchJob,
   FetchPerson,
   FetchPost,
-  IgnoreConnectionRequest,
+  IgnoreInvitation,
   ManageConversation,
   NvFetchCompany,
   NvFetchPerson,
@@ -23,8 +23,8 @@ import {
   NvSyncInbox,
   ReactToPost,
   RemoveConnection,
-  RetrieveConnectionRequests,
   RetrieveConnections,
+  RetrieveInvitations,
   RetrievePendingRequests,
   RetrievePerformance,
   RetrieveSSI,
@@ -111,9 +111,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.retrieveInvitations = new RetrieveInvitations(this.httpClient);
+    this.acceptInvitation = new AcceptInvitation(this.httpClient);
+    this.ignoreInvitation = new IgnoreInvitation(this.httpClient);
     this.retrieveConnections = new RetrieveConnections(this.httpClient);
     this.removeConnection = new RemoveConnection(this.httpClient);
     this.searchCompanies = new SearchCompanies(this.httpClient);
@@ -148,9 +148,9 @@ class LinkedApi {
       this.sendConnectionRequest,
       this.withdrawConnectionRequest,
       this.retrievePendingRequests,
-      this.retrieveConnectionRequests,
-      this.acceptConnectionRequest,
-      this.ignoreConnectionRequest,
+      this.retrieveInvitations,
+      this.acceptInvitation,
+      this.ignoreInvitation,
       this.retrieveConnections,
       this.removeConnection,
       this.searchCompanies,
@@ -1025,7 +1025,7 @@ class LinkedApi {
    * @param params - Parameters including the person's URL and optional connection message
    * @returns Promise resolving to the connection request action
    *
-   * @see {@link https://linkedapi.io/docs/working-with-connection-requests/ Working with Connection Requests Documentation}
+   * @see {@link https://linkedapi.io/docs/working-with-invitations/ Working with Invitations Documentation}
    * @see {@link https://linkedapi.io/docs/action-st-send-connection-request/ st.sendConnectionRequest Action Documentation}
    *
    * @example
@@ -1076,7 +1076,7 @@ class LinkedApi {
    * @param params - Parameters including the person's URL
    * @returns Promise resolving to the withdrawal action
    *
-   * @see {@link https://linkedapi.io/docs/working-with-connection-requests/ Working with Connection Requests Documentation}
+   * @see {@link https://linkedapi.io/docs/working-with-invitations/ Working with Invitations Documentation}
    * @see {@link https://linkedapi.io/docs/action-st-withdraw-connection-request/ st.withdrawConnectionRequest Action Documentation}
    *
    * @example
@@ -1099,7 +1099,7 @@ class LinkedApi {
    *
    * @returns Promise resolving to an object containing an array of pending requests
    *
-   * @see {@link https://linkedapi.io/docs/working-with-connection-requests/ Working with Connection Requests Documentation}
+   * @see {@link https://linkedapi.io/docs/working-with-invitations/ Working with Invitations Documentation}
    * @see {@link https://linkedapi.io/docs/action-st-retrieve-pending-requests/ st.retrievePendingRequests Action Documentation}
    *
    * @example
@@ -1120,67 +1120,75 @@ class LinkedApi {
   public retrievePendingRequests: RetrievePendingRequests;
 
   /**
-   * Retrieve incoming connection requests (invitations others have sent you).
+   * Retrieve incoming connection, company-follow, and newsletter-subscription invitations.
    *
-   * This method fetches the list of received connection requests from your invitation manager.
+   * This method fetches the list of received invitations from your invitation manager.
    *
-   * @returns Promise resolving to an object containing an array of received requests
+   * @returns Promise resolving to an object containing an array of received invitations
    *
-   * @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}
+   * @see {@link https://linkedapi.io/docs/working-with-invitations/ Working with Invitations Documentation}
+   * @see {@link https://linkedapi.io/docs/action-st-retrieve-invitations/ st.retrieveInvitations Action Documentation}
    *
    * @example
    * ```typescript
-   * const workflow = await linkedapi.retrieveConnectionRequests.execute();
+   * const workflow = await linkedapi.retrieveInvitations.execute();
    *
-   * const result = await linkedapi.retrieveConnectionRequests.result(workflow.workflowId);
+   * const result = await linkedapi.retrieveInvitations.result(workflow.workflowId);
    * if (result.data) {
-   *   result.data.forEach(request => {
-   *     console.log(`${request.name}: ${request.headline}`);
-   *     console.log(`Profile: ${request.publicUrl}`);
-   *   });
+   *   for (const invitation of result.data) {
+   *     console.log(`${invitation.invitationType}: ${invitation.name}`);
+   *     if (invitation.invitationType === "connect") {
+   *       console.log(`Profile: ${invitation.publicUrl}`);
+   *     } else if (invitation.invitationType === "companyFollow") {
+   *       console.log(`Company: ${invitation.companyUrl}`);
+   *     } else {
+   *       console.log(`Newsletter: ${invitation.newsletterUrl}`);
+   *     }
+   *   }
    * }
    * ```
    */
-  public retrieveConnectionRequests: RetrieveConnectionRequests;
+  public retrieveInvitations: RetrieveInvitations;
 
   /**
-   * Accept an incoming connection request from a person's profile.
+   * Accept an incoming connection, company-follow, or newsletter-subscription invitation.
    *
-   * @param params - Parameters including the person's profile URL
+   * @param params - Invitation type and its matching target 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}
+   * @see {@link https://linkedapi.io/docs/working-with-invitations/ Working with Invitations Documentation}
+   * @see {@link https://linkedapi.io/docs/action-st-accept-invitation/ st.acceptInvitation Action Documentation}
    *
    * @example
    * ```typescript
-   * const workflow = await linkedapi.acceptConnectionRequest.execute({
+   * const workflow = await linkedapi.acceptInvitation.execute({
+   *   invitationType: "connect",
    *   personUrl: "https://www.linkedin.com/in/john-doe",
    * });
    *
-   * await linkedapi.acceptConnectionRequest.result(workflow.workflowId);
+   * await linkedapi.acceptInvitation.result(workflow.workflowId);
    * ```
    */
-  public acceptConnectionRequest: AcceptConnectionRequest;
+  public acceptInvitation: AcceptInvitation;
 
   /**
-   * Ignore an incoming connection request from a person's profile.
+   * Ignore an incoming connection, company-follow, or newsletter-subscription invitation.
    *
-   * @param params - Parameters including the person's profile URL
+   * @param params - Invitation type and its matching target 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}
+   * @see {@link https://linkedapi.io/docs/working-with-invitations/ Working with Invitations Documentation}
+   * @see {@link https://linkedapi.io/docs/action-st-ignore-invitation/ st.ignoreInvitation Action Documentation}
    *
    * @example
    * ```typescript
-   * const workflow = await linkedapi.ignoreConnectionRequest.execute({
-   *   personUrl: "https://www.linkedin.com/in/john-doe",
+   * const workflow = await linkedapi.ignoreInvitation.execute({
+   *   invitationType: "newsletterSubscribe",
+   *   newsletterUrl: "https://www.linkedin.com/newsletters/example-1234567890/",
    * });
    *
-   * await linkedapi.ignoreConnectionRequest.result(workflow.workflowId);
+   * await linkedapi.ignoreInvitation.result(workflow.workflowId);
    * ```
    */
-  public ignoreConnectionRequest: IgnoreConnectionRequest;
+  public ignoreInvitation: IgnoreInvitation;
 
   /**
    * 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 { TAcceptInvitationParams } from '../types';
+
+export class AcceptInvitation extends Operation<TAcceptInvitationParams, void> {
+  public override readonly operationName: TOperationName = 'acceptInvitation';
+  protected override readonly mapper = new VoidWorkflowMapper<TAcceptInvitationParams>(
+    'st.acceptInvitation',
+  );
+}

src/operations/accept-invitation.ts

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