@pipedream/linkupapi 0.2.0 → 1.0.1

package/actions/connect-account/connect-account.mjs

@@ -0,0 +1,85 @@
+import { ConfigurationError } from "@pipedream/platform";
+import app from "../../linkupapi.app.mjs";
+import { DEFAULT_PLATFORM } from "../../common/constants.mjs";
+
+export default {
+  key: "linkupapi-connect-account",
+  name: "Connect Account",
+  description: "Authenticate a LinkedIn account and obtain a persistent `account_id` to reuse across all other actions. Connect with either a login token or email + password. If a checkpoint/challenge is required, follow up with **Verify Code**. [See the documentation](https://docs.linkupapi.com/api-reference/v2/accounts/login)",
+  version: "0.0.2",
+  type: "action",
+  ai: "optimized",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
+  props: {
+    app,
+    loginToken: {
+      type: "string",
+      label: "Login Token",
+      description: "LinkedIn authentication token/cookie for direct, token-based connection. Alternative to Email + Password that skips the 2FA step. Provide this, or both **Email** and **Password**.",
+      secret: true,
+      optional: true,
+    },
+    email: {
+      propDefinition: [
+        app,
+        "email",
+      ],
+      description: "Account email address. Required (with **Password**) for credential-based login when no **Login Token** is provided.",
+    },
+    password: {
+      propDefinition: [
+        app,
+        "password",
+      ],
+      description: "Account password. Required (with **Email**) for credential-based login when no **Login Token** is provided.",
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+    accountName: {
+      type: "string",
+      label: "Account Name",
+      description: "Display name for the account. Defaults to the email address.",
+      optional: true,
+    },
+    challengeType: {
+      type: "string",
+      label: "Challenge Type",
+      description: "Type of 2FA challenge to use if the account has two-factor authentication enabled. `code_challenge`: receive a verification code (email/SMS/authenticator) to submit via **Verify Code**. `app_challenge`: approve the login from the LinkedIn mobile app, then call **Verify Code** with only the account ID.",
+      optional: true,
+      options: [
+        "code_challenge",
+        "app_challenge",
+      ],
+    },
+  },
+  async run({ $ }) {
+    if (!this.loginToken && !(this.email && this.password)) {
+      throw new ConfigurationError("Provide a **Login Token**, or both **Email** and **Password**, to connect an account.");
+    }
+    const response = await this.app.connectAccount({
+      $,
+      data: {
+        platform: DEFAULT_PLATFORM,
+        email: this.email,
+        password: this.password,
+        login_token: this.loginToken,
+        country: this.country,
+        account_name: this.accountName,
+        challenge_type: this.challengeType,
+      },
+    });
+
+    $.export("$summary", `Successfully connected account${response.data?.account_id
+      ? `: ${response.data.account_id}`
+      : ""}`);
+    return response;
+  },
+};

package/actions/connect-to-profile/connect-to-profile.mjs

@@ -1,65 +1,68 @@
+import { ConfigurationError } from "@pipedream/platform";
 import app from "../../linkupapi.app.mjs";
 
 export default {
   type: "action",
+  ai: "optimized",
   key: "linkupapi-connect-to-profile",
-  name: "Connect to Profile",
-  description: "Send a connection request to a LinkedIn profile. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Network/connect)",
-  version: "0.0.2",
+  name: "Connect To Profile",
+  description: "Send a connection invitation to a LinkedIn profile. [See the documentation](https://docs.linkupapi.com/api-reference/v2/network/invite)",
+  version: "1.0.1",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
   props: {
     app,
+    accountId: {
+      propDefinition: [
+        app,
+        "accountId",
+      ],
+    },
     linkedinUrl: {
       propDefinition: [
         app,
         "linkedinUrl",
       ],
+      description: "LinkedIn profile URL. Eg. `https://www.linkedin.com/in/john-doe/`. Required unless **Identifier** is provided.",
+      optional: true,
     },
-    loginToken: {
+    identifier: {
       propDefinition: [
         app,
-        "loginToken",
+        "identifier",
       ],
+      description: "Unique identifier of the person to invite. Required unless **LinkedIn URL** is provided.",
     },
     message: {
       type: "string",
       label: "Message",
-      description: "Optional custom message to include with connection request",
+      description: "Message to include with the connection request (max 300 chars).",
       optional: true,
     },
-    country: {
-      propDefinition: [
-        app,
-        "country",
-      ],
-    },
-  },
-  annotations: {
-    readOnlyHint: false,
-    destructiveHint: true,
-    openWorldHint: true,
-    idempotentHint: false,
   },
   async run({ $ }) {
-    const {
-      app,
-      linkedinUrl,
-      loginToken,
-      message,
-      country,
-    } = this;
+    if (!this.linkedinUrl && !this.identifier) {
+      throw new ConfigurationError("Provide either a **LinkedIn URL** or an **Identifier** to invite.");
+    }
 
-    const response = await app.connectToProfile({
+    if (this.message && this.message.length > 300) {
+      throw new ConfigurationError("Message must be less than 300 characters.");
+    }
+
+    const response = await this.app.connectToProfile({
       $,
-      data: {
-        linkedin_url: linkedinUrl,
-        login_token: loginToken,
-        message_text: message,
-        country,
+      accountId: this.accountId,
+      params: {
+        profile_url: this.linkedinUrl,
+        identifier: this.identifier,
+        message: this.message,
       },
     });
 
-    $.export("$summary", "Successfully sent connection request");
-
+    $.export("$summary", `Successfully sent connection invitation to ${this.linkedinUrl || this.identifier}`);
     return response;
   },
 };

package/actions/create-comment/create-comment.mjs

@@ -1,61 +1,56 @@
-import linkupapi from "../../linkupapi.app.mjs";
+import app from "../../linkupapi.app.mjs";
 
 export default {
   key: "linkupapi-create-comment",
   name: "Create Comment",
-  description: "Create a comment on a post. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/posts/comment)",
-  version: "0.0.1",
+  description: "Post a comment on LinkedIn content. [See the documentation](https://docs.linkupapi.com/api-reference/v2/content/comment)",
+  version: "1.0.1",
   type: "action",
+  ai: "optimized",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,
     readOnlyHint: false,
   },
   props: {
-    linkupapi,
-    postUrl: {
-      type: "string",
-      label: "Post URL",
-      description: "LinkedIn post URL to comment on (must contain a valid activity URN)",
-    },
-    message: {
-      type: "string",
-      label: "Message",
-      description: "Text content of the comment to post",
-    },
-    loginToken: {
+    app,
+    accountId: {
       propDefinition: [
-        linkupapi,
-        "loginToken",
+        app,
+        "accountId",
       ],
     },
-    country: {
+    postUrl: {
+      type: "string",
+      label: "LinkedIn Post URL",
+      description: "LinkedIn post URL to comment on. Eg. `https://www.linkedin.com/feed/update/urn:li:activity:1234567890/`.",
+    },
+    messageText: {
       propDefinition: [
-        linkupapi,
-        "country",
+        app,
+        "messageText",
       ],
+      description: "Comment text content.",
     },
     companyUrl: {
-      propDefinition: [
-        linkupapi,
-        "companyUrl",
-      ],
+      type: "string",
+      label: "Company URL",
+      description: "Comment as a company page instead of your personal profile, by providing the company's LinkedIn URL. Eg. `https://www.linkedin.com/company/stripe/`.",
+      optional: true,
     },
   },
   async run({ $ }) {
-    const response = await this.linkupapi.createComment({
+    const response = await this.app.createComment({
       $,
-      data: {
+      accountId: this.accountId,
+      params: {
         post_url: this.postUrl,
-        message: this.message,
-        login_token: this.loginToken,
-        country: this.country,
+        comment_text: this.messageText,
         company_url: this.companyUrl,
       },
     });
 
-    $.export("$summary", "Successfully created comment");
-
+    $.export("$summary", `Successfully created comment on ${this.postUrl}`);
     return response;
   },
 };

package/actions/get-account-details/get-account-details.mjs

@@ -0,0 +1,32 @@
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  key: "linkupapi-get-account-details",
+  name: "Get Account Details",
+  description: "Retrieve details (status, active flag, platform, associated LinkedIn identifier, timestamps) for a connected LinkupAPI account. [See the documentation](https://docs.linkupapi.com/api-reference/v2/accounts/get-account)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
+  props: {
+    app,
+    accountId: {
+      propDefinition: [
+        app,
+        "accountId",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.app.getAccountDetails({
+      $,
+      accountId: this.accountId,
+    });
+
+    $.export("$summary", `Successfully retrieved details for account ${this.accountId}`);
+    return response;
+  },
+};

package/actions/get-company-info/get-company-info.mjs

@@ -4,53 +4,37 @@ export default {
   type: "action",
   key: "linkupapi-get-company-info",
   name: "Get Company Info",
-  description: "Extract detailed information about a company from LinkedIn. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Companies/company-info)",
-  version: "0.0.2",
+  description: "Fetch details for a LinkedIn company. [See the documentation](https://docs.linkupapi.com/api-reference/v2/profiles/get-company)",
+  version: "1.0.0",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
   props: {
     app,
-    companyUrl: {
-      type: "string",
-      label: "Company URL",
-      description: "LinkedIn company URLs. Eg. `https://www.linkedin.com/company/stripe/`",
-      optional: true,
-    },
-    loginToken: {
+    accountId: {
       propDefinition: [
         app,
-        "loginToken",
+        "accountId",
       ],
     },
-    country: {
-      propDefinition: [
-        app,
-        "country",
-      ],
+    companyUrl: {
+      type: "string",
+      label: "LinkedIn Company URL",
+      description: "LinkedIn company URL. Eg. `https://www.linkedin.com/company/stripe/`.",
     },
   },
-  annotations: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    openWorldHint: true,
-    idempotentHint: true,
-  },
   async run({ $ }) {
-    const {
-      app,
-      companyUrl,
-      loginToken,
-      country,
-    } = this;
-
-    const response = await app.getCompanyInfo({
+    const response = await this.app.getCompanyInfo({
       $,
-      data: {
-        company_url: companyUrl,
-        login_token: loginToken,
-        country,
+      accountId: this.accountId,
+      params: {
+        company_url: this.companyUrl,
       },
     });
 
-    $.export("$summary", "Successfully retrieved company information");
+    $.export("$summary", `Successfully retrieved company information for ${this.companyUrl}`);
     return response;
   },
 };

package/actions/get-conversation-messages/get-conversation-messages.mjs

@@ -3,81 +3,72 @@ import app from "../../linkupapi.app.mjs";
 
 export default {
   type: "action",
+  ai: "optimized",
   key: "linkupapi-get-conversation-messages",
   name: "Get Conversation Messages",
-  description: "Retrieve messages from a LinkedIn conversation. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Messages/conversation)",
-  version: "0.0.2",
+  description: "Retrieve messages from a LinkedIn conversation. Identify the conversation by its ID or by the recipient's profile URL. [See the documentation](https://docs.linkupapi.com/api-reference/v2/messages/get-conversation)",
+  version: "1.0.1",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
   props: {
     app,
-    loginToken: {
+    accountId: {
       propDefinition: [
         app,
-        "loginToken",
+        "accountId",
       ],
     },
-    linkedinUrl: {
+    conversationId: {
       propDefinition: [
         app,
-        "linkedinUrl",
+        "conversationId",
       ],
       optional: true,
-      description: "LinkedIn URL of the other party (required if **Conversation ID** is not provided)",
+      description: "LinkedIn conversation identifier. Provide this or a **LinkedIn URL**. Pick from your inbox, or run **List Inbox** to find one.",
     },
-    conversationId: {
+    linkedinUrl: {
       propDefinition: [
         app,
-        "conversationId",
-        ({ loginToken }) => ({
-          loginToken,
-        }),
+        "linkedinUrl",
       ],
+      description: "LinkedIn profile URL of the other participant; the conversation with that user is resolved automatically. Provide this or a **Conversation ID**.",
       optional: true,
-      description: "LinkedIn conversation ID (required if **LinkedIn URL** is not provided)",
     },
     totalResults: {
-      type: "integer",
-      label: "Total Results",
-      description: "Number of messages to retrieve when not in pagination mode (default: 10)",
-      optional: true,
-    },
-    country: {
       propDefinition: [
         app,
-        "country",
+        "totalResults",
       ],
     },
   },
-  annotations: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    openWorldHint: true,
-    idempotentHint: true,
-  },
   async run({ $ }) {
-    const {
-      loginToken,
-      linkedinUrl,
-      conversationId,
-      totalResults,
-      country,
-    } = this;
-
-    if (!linkedinUrl && !conversationId) {
-      throw new ConfigurationError("Either **LinkedIn URL** or **Conversation ID** is required");
+    if (!this.conversationId && !this.linkedinUrl) {
+      throw new ConfigurationError("Provide a **Conversation ID** or a **LinkedIn URL** to identify the conversation.");
     }
-
-    const response = await this.app.getConversationMessages({
-      $,
-      data: {
-        login_token: loginToken,
-        linkedin_url: linkedinUrl,
-        conversation_id: conversationId,
-        country,
-        total_results: totalResults,
-      },
+    const messages = await this.app._paginate({
+      max: this.totalResults,
+      requestPage: ({
+        next, count,
+      }) => this.app.getConversationMessages({
+        $,
+        accountId: this.accountId,
+        params: {
+          conversation_id: this.conversationId,
+          profile_url: this.linkedinUrl,
+          count,
+          cursor: next,
+        },
+      }),
+      getItems: (res) => res.data?.messages,
+      getNext: (res) => res.data?.next_cursor,
     });
 
-    $.export("$summary", "Successfully retrieved conversation messages");
-    return response;
+    $.export("$summary", `Successfully retrieved ${messages.length} message${messages.length === 1
+      ? ""
+      : "s"} for conversation ${this.conversationId || this.linkedinUrl}`);
+    return messages;
   },
 };

package/actions/get-invitations-status/get-invitations-status.mjs

@@ -2,56 +2,60 @@ import app from "../../linkupapi.app.mjs";
 
 export default {
   type: "action",
+  ai: "optimized",
   key: "linkupapi-get-invitations-status",
   name: "Get Invitations Status",
-  description: "Check the status of connection invitations for a LinkedIn profile. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Network/get_invitations_status)",
-  version: "0.0.2",
+  description: "List pending connection invitations **received** by the connected account. Note: this returns invitations received, not ones you have sent. [See the documentation](https://docs.linkupapi.com/api-reference/v2/network/list-invitations)",
+  version: "1.0.1",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
   props: {
     app,
-    linkedinUrl: {
+    accountId: {
       propDefinition: [
         app,
-        "linkedinUrl",
+        "accountId",
       ],
     },
-    loginToken: {
+    totalResults: {
       propDefinition: [
         app,
-        "loginToken",
+        "totalResults",
       ],
     },
-    country: {
-      propDefinition: [
-        app,
-        "country",
-      ],
+    invitationType: {
+      type: "string",
+      label: "Invitation Type",
+      description: "Filter received invitations by type (e.g. `CONNECTION`). Omit for all types.",
+      optional: true,
     },
   },
-  annotations: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    openWorldHint: true,
-    idempotentHint: true,
-  },
   async run({ $ }) {
-    const {
-      app,
-      linkedinUrl,
-      loginToken,
-      country,
-    } = this;
-
-    const response = await app.getInvitationsStatus({
-      $,
-      data: {
-        linkedin_url: linkedinUrl,
-        login_token: loginToken,
-        country,
-      },
+    const invitations = await this.app._paginate({
+      max: this.totalResults,
+      requestPage: ({
+        next, count,
+      }) => this.app.getInvitations({
+        $,
+        accountId: this.accountId,
+        params: {
+          count,
+          offset: next || 0,
+          invitation_type: this.invitationType,
+        },
+      }),
+      getItems: (res) => res.data?.invitations,
+      getNext: (res) => res.data?.pagination?.has_more
+        ? res.data?.pagination?.next_offset
+        : null,
     });
 
-    $.export("$summary", "Successfully retrieved invitation status");
-
-    return response;
+    $.export("$summary", `Successfully retrieved ${invitations.length} received invitation${invitations.length === 1
+      ? ""
+      : "s"}`);
+    return invitations;
   },
 };