@pipedream/linkupapi 0.2.0 → 1.0.1

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

@@ -1,57 +1,62 @@
+import { ConfigurationError } from "@pipedream/platform";
 import app from "../../linkupapi.app.mjs";
 
 export default {
   type: "action",
+  ai: "optimized",
   key: "linkupapi-get-profile-info",
   name: "Get Profile Info",
-  description: "Extract information from a LinkedIn profile. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Profile/profile-info)",
-  version: "0.0.2",
+  description: "Fetch details for a LinkedIn profile. Identify the target by profile URL, public identifier, or profile URN. [See the documentation](https://docs.linkupapi.com/api-reference/v2/profiles/get-profile)",
+  version: "1.0.1",
+  annotations: {
+    readOnlyHint: true,
+    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/`. Provide this, an **Identifier**, or a **Profile URN**.",
+      optional: true,
     },
-    loginToken: {
+    identifier: {
       propDefinition: [
         app,
-        "loginToken",
+        "identifier",
       ],
     },
-    country: {
+    profileUrn: {
       propDefinition: [
         app,
-        "country",
+        "profileUrn",
       ],
     },
   },
-  annotations: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    openWorldHint: true,
-    idempotentHint: true,
-  },
   async run({ $ }) {
-    const {
-      app,
-      linkedinUrl,
-      loginToken,
-      country,
-    } = this;
-
-    const response = await app.getProfileInfo({
+    if (!this.linkedinUrl && !this.identifier && !this.profileUrn) {
+      throw new ConfigurationError("Provide a **LinkedIn URL**, an **Identifier**, or a **Profile URN** to identify the profile.");
+    }
+    const response = await this.app.getProfileInfo({
       $,
-      data: {
-        linkedin_url: linkedinUrl,
-        login_token: loginToken,
-        country,
+      accountId: this.accountId,
+      params: {
+        profile_url: this.linkedinUrl,
+        identifier: this.identifier,
+        profile_urn: this.profileUrn,
       },
     });
 
-    $.export("$summary", "Successfully retrieved profile information");
-
+    $.export("$summary", `Successfully retrieved profile information for ${this.linkedinUrl || this.identifier || this.profileUrn}`);
     return response;
   },
 };

package/actions/list-accounts/list-accounts.mjs

@@ -0,0 +1,51 @@
+import app from "../../linkupapi.app.mjs";
+import { ACCOUNTS_MAX_PAGE_SIZE } from "../../common/constants.mjs";
+
+export default {
+  key: "linkupapi-list-accounts",
+  name: "List Accounts",
+  description: "List the LinkupAPI accounts connected to your API key, each with its persistent `account_id` to use in other actions. [See the documentation](https://docs.linkupapi.com/api-reference/v2/accounts/list-accounts)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
+  props: {
+    app,
+    totalResults: {
+      propDefinition: [
+        app,
+        "totalResults",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const accounts = await this.app._paginate({
+      max: this.totalResults,
+      requestPage: ({
+        next, count,
+      }) => this.app.listAccounts({
+        $,
+        params: {
+          limit: Math.min(ACCOUNTS_MAX_PAGE_SIZE, count),
+          offset: next || 0,
+        },
+      }),
+      getItems: (res) => res.data?.items,
+      getNext: (res) => {
+        const data = res.data || {};
+        const nextOffset = (data.offset || 0) + (data.items?.length || 0);
+        return nextOffset < (data.total || 0)
+          ? nextOffset
+          : null;
+      },
+    });
+
+    $.export("$summary", `Successfully retrieved ${accounts.length} account${accounts.length === 1
+      ? ""
+      : "s"}`);
+    return accounts;
+  },
+};

package/actions/list-inbox/list-inbox.mjs

@@ -0,0 +1,67 @@
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  key: "linkupapi-list-inbox",
+  name: "List Inbox",
+  description: "List conversations from the LinkedIn inbox, each with its `conversation_id` to use with **Get Conversation Messages**. [See the documentation](https://docs.linkupapi.com/api-reference/v2/messages/list-inbox)",
+  version: "0.0.2",
+  type: "action",
+  ai: "optimized",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
+  props: {
+    app,
+    accountId: {
+      propDefinition: [
+        app,
+        "accountId",
+      ],
+    },
+    totalResults: {
+      propDefinition: [
+        app,
+        "totalResults",
+      ],
+    },
+    category: {
+      type: "string",
+      label: "Category",
+      description: "Filter conversations by category.",
+      optional: true,
+      options: [
+        "INBOX",
+        "UNREAD",
+        "MY_CONNECTIONS",
+        "INMAIL",
+        "STARRED",
+      ],
+      default: "INBOX",
+    },
+  },
+  async run({ $ }) {
+    const conversations = await this.app._paginate({
+      max: this.totalResults,
+      requestPage: ({
+        next, count,
+      }) => this.app.listInbox({
+        $,
+        accountId: this.accountId,
+        params: {
+          count,
+          cursor: next,
+          category: this.category,
+        },
+      }),
+      getItems: (res) => res.data?.conversations,
+      getNext: (res) => res.data?.next_cursor,
+    });
+
+    $.export("$summary", `Successfully retrieved ${conversations.length} conversation${conversations.length === 1
+      ? ""
+      : "s"}`);
+    return conversations;
+  },
+};

package/actions/search-companies/search-companies.mjs

@@ -1,28 +1,32 @@
 import app from "../../linkupapi.app.mjs";
-import utils from "../../common/utils.mjs";
 
 export default {
   type: "action",
   key: "linkupapi-search-companies",
   name: "Search Companies",
-  description: "Search for companies on LinkedIn based on criteria. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Companies/search)",
-  version: "0.0.2",
+  description: "Search for LinkedIn companies. [See the documentation](https://docs.linkupapi.com/api-reference/v2/profiles/search-companies)",
+  version: "1.0.0",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
   props: {
     app,
-    loginToken: {
+    accountId: {
       propDefinition: [
         app,
-        "loginToken",
+        "accountId",
       ],
     },
     keyword: {
-      type: "string",
-      label: "Keyword",
-      description: "Search keyword for company filtering",
-      optional: true,
+      propDefinition: [
+        app,
+        "keyword",
+      ],
+      description: "Free-text keyword to search companies by (e.g. company name or industry).",
     },
     location: {
-      description: "Geographic locations to filter companies",
       propDefinition: [
         app,
         "location",
@@ -31,69 +35,39 @@ export default {
     sector: {
       type: "string[]",
       label: "Sector",
-      description: "Industry sector you can [find the label here](https://learn.microsoft.com/en-us/linkedin/shared/references/reference-tables/industry-codes-v2)",
+      description: "Industry sectors to filter by, passed as an array of strings.",
       optional: true,
     },
     companySize: {
-      type: "string",
+      type: "string[]",
       label: "Company Size",
-      description: "Employee count range: 1-10 employees 11-50 employees 51-200 employees 201-500 employees 501-1000 employees 1001-5000 employees 5001-10000 employees 10001+ employees",
+      description: "Company size ranges to filter by, passed as an array of strings, e.g. `[\"11-50\", \"51-200\"]`.",
       optional: true,
-      options: [
-        "1-10",
-        "11-50",
-        "51-200",
-        "201-500",
-        "501-1000",
-        "1001-5000",
-        "5001-10000",
-        "10001+",
-      ],
     },
     totalResults: {
-      type: "integer",
-      label: "Total Results",
-      description: "Number of companies 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,
-      country,
-      keyword,
-      location,
-      sector,
-      companySize,
-      totalResults,
-    } = this;
-
     const response = await this.app.searchCompanies({
       $,
-      data: {
-        login_token: loginToken,
-        country,
-        keyword,
-        location: utils.getOptionalProp(location),
-        sector: utils.getOptionalProp(sector),
-        company_size: companySize,
-        total_results: totalResults,
+      accountId: this.accountId,
+      params: {
+        keyword: this.keyword,
+        location: this.location,
+        sector: this.sector,
+        company_size: this.companySize,
+        total_results: this.totalResults,
       },
     });
 
-    $.export("$summary", "Successfully retrieved companies");
+    const count = response.data?.companies?.length || 0;
+    $.export("$summary", `Successfully retrieved ${count} compan${count === 1
+      ? "y"
+      : "ies"}`);
     return response;
   },
 };

package/actions/search-profiles/search-profiles.mjs

@@ -1,144 +1,143 @@
 import app from "../../linkupapi.app.mjs";
-import utils from "../../common/utils.mjs";
 
 export default {
   type: "action",
   key: "linkupapi-search-profiles",
   name: "Search Profiles",
-  description: "Search for LinkedIn profiles based on criteria. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Profile/search)",
-  version: "0.0.2",
+  description: "Search for LinkedIn people. [See the documentation](https://docs.linkupapi.com/api-reference/v2/profiles/search-people)",
+  version: "1.0.0",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
   props: {
     app,
-    loginToken: {
+    accountId: {
       propDefinition: [
         app,
-        "loginToken",
+        "accountId",
       ],
     },
     keyword: {
-      type: "string",
-      label: "Keyword",
-      description: "Search keyword to find relevant profiles",
-      optional: true,
+      propDefinition: [
+        app,
+        "keyword",
+      ],
+      description: "Free-text keyword to search people by (e.g. name, title, or company).",
     },
     firstName: {
       type: "string",
       label: "First Name",
-      description: "First name parameter for advanced keyword search",
+      description: "Filter by first name.",
       optional: true,
     },
     lastName: {
       type: "string",
       label: "Last Name",
-      description: "Last name parameter for advanced keyword search",
+      description: "Filter by last name.",
       optional: true,
     },
     title: {
       type: "string",
-      label: "Job Title",
-      description: "Job title parameter for advanced keyword search",
+      label: "Title",
+      description: "Filter by current job title.",
       optional: true,
     },
-    companyUrl: {
+    companyName: {
+      type: "string",
+      label: "Company Name",
+      description: "Filter by current company name.",
+      optional: true,
+    },
+    location: {
       propDefinition: [
         app,
-        "companyUrl",
+        "location",
       ],
     },
-    location: {
-      description: "Geographic locations to filter profiles",
+    companyUrl: {
       propDefinition: [
         app,
-        "location",
+        "companyUrl",
       ],
     },
+    pastCompany: {
+      type: "string[]",
+      label: "Past Companies",
+      description: "Filter by past companies, passed as an array of LinkedIn company URLs.",
+      optional: true,
+    },
     schoolUrl: {
       type: "string[]",
       label: "School URLs",
-      description: "LinkedIn school URLs",
+      description: "Filter by schools, passed as an array of LinkedIn school URLs.",
+      optional: true,
+    },
+    industry: {
+      type: "string[]",
+      label: "Industries",
+      description: "Filter by industries, passed as an array of strings.",
       optional: true,
     },
     network: {
       type: "string[]",
-      label: "Network Connection Level",
-      description: "Filter by connection level",
-      options: [
-        {
-          value: "F",
-          label: "First-degree connections (1st)",
-        },
-        {
-          value: "S",
-          label: "Second-degree connections (2nd)",
-        },
-        {
-          value: "O",
-          label: "Out-of-network connections (3rd+)",
-        },
-      ],
+      label: "Network",
+      description: "Filter by network degree, passed as an array (e.g. `[\"F\"]` for 1st, `[\"S\"]` for 2nd, `[\"O\"]` for 3rd+).",
       optional: true,
     },
-    totalResults: {
-      type: "integer",
-      label: "Total Results",
-      description: "Number of profiles to retrieve (default: `10`)",
+    connectionOf: {
+      type: "string",
+      label: "Connection Of",
+      description: "Return people who are connections of this profile (LinkedIn profile URN or public identifier).",
+      optional: true,
+    },
+    followerOf: {
+      type: "string",
+      label: "Follower Of",
+      description: "Return people who are followers of this profile (LinkedIn profile URN or public identifier).",
       optional: true,
     },
     fetchInvitationState: {
       type: "boolean",
       label: "Fetch Invitation State",
-      description: "Whether to fetch the invitation/connection status for each profile",
+      description: "Whether to include each result's connection/invitation state.",
       optional: true,
     },
-    country: {
+    totalResults: {
       propDefinition: [
         app,
-        "country",
+        "totalResults",
       ],
     },
   },
-  annotations: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    openWorldHint: true,
-    idempotentHint: true,
-  },
   async run({ $ }) {
-    const {
-      app,
-      loginToken,
-      country,
-      keyword,
-      firstName,
-      lastName,
-      title,
-      companyUrl,
-      location,
-      schoolUrl,
-      network,
-      totalResults,
-      fetchInvitationState,
-    } = this;
-
-    const response = await app.searchProfiles({
+    const response = await this.app.searchProfiles({
       $,
-      data: {
-        login_token: loginToken,
-        country,
-        keyword,
-        first_name: firstName,
-        last_name: lastName,
-        title,
-        company_url: utils.getOptionalProp(companyUrl),
-        location: utils.getOptionalProp(location),
-        school_url: utils.getOptionalProp(schoolUrl),
-        network: utils.getOptionalProp(network, ","),
-        fetch_invitation_state: fetchInvitationState,
-        total_results: totalResults,
+      accountId: this.accountId,
+      params: {
+        keyword: this.keyword,
+        first_name: this.firstName,
+        last_name: this.lastName,
+        title: this.title,
+        company_name: this.companyName,
+        location: this.location,
+        company_url: this.companyUrl,
+        past_company: this.pastCompany,
+        school_url: this.schoolUrl,
+        industry: this.industry,
+        network: this.network,
+        connection_of: this.connectionOf,
+        follower_of: this.followerOf,
+        fetch_invitation_state: this.fetchInvitationState,
+        total_results: this.totalResults,
       },
     });
 
-    $.export("$summary", "Successfully retrieved profiles");
+    const count = response.data?.results?.length || 0;
+    $.export("$summary", `Successfully retrieved ${count} profile${count === 1
+      ? ""
+      : "s"}`);
     return response;
   },
 };

package/actions/send-message/send-message.mjs

@@ -2,22 +2,22 @@ import app from "../../linkupapi.app.mjs";
 
 export default {
   type: "action",
+  ai: "optimized",
   key: "linkupapi-send-message",
   name: "Send Message",
-  description: "Send a message to a LinkedIn profile. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Messages/send)",
-  version: "0.0.2",
+  description: "Send a message to a LinkedIn profile. Make sure you are already connected to the recipient. [See the documentation](https://docs.linkupapi.com/api-reference/v2/messages/send)",
+  version: "1.0.1",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
   props: {
     app,
-    // eslint-disable-next-line pipedream/props-label, pipedream/props-description
-    info: {
-      type: "alert",
-      alertType: "info",
-      content: "Make sure you previously connected to the LinkedIn profile you want to send a message to.",
-    },
-    loginToken: {
+    accountId: {
       propDefinition: [
         app,
-        "loginToken",
+        "accountId",
       ],
     },
     linkedinUrl: {
@@ -25,6 +25,7 @@ export default {
         app,
         "linkedinUrl",
       ],
+      description: "LinkedIn profile URL of the recipient. Eg. `https://www.linkedin.com/in/john-doe/`.",
     },
     messageText: {
       propDefinition: [
@@ -32,47 +33,25 @@ export default {
         "messageText",
       ],
     },
-    country: {
-      propDefinition: [
-        app,
-        "country",
-      ],
+    mediaLink: {
+      type: "string",
+      label: "Media Link",
+      description: "URL of a media attachment (image, document, etc.) to include with the message.",
+      optional: true,
     },
   },
-  annotations: {
-    readOnlyHint: false,
-    destructiveHint: true,
-    openWorldHint: true,
-    idempotentHint: false,
-  },
   async run({ $ }) {
-    const {
-      app,
-      linkedinUrl,
-      messageText,
-      loginToken,
-      country,
-    } = this;
-
-    try {
-      const response = await app.sendMessage({
-        $,
-        data: {
-          linkedin_url: linkedinUrl,
-          message_text: messageText,
-          login_token: loginToken,
-          country,
-        },
-      });
-
-      $.export("$summary", "Successfully sent message request");
+    const response = await this.app.sendMessage({
+      $,
+      accountId: this.accountId,
+      params: {
+        profile_url: this.linkedinUrl,
+        message_text: this.messageText,
+        media_link: this.mediaLink,
+      },
+    });
 
-      return response;
-    } catch (error) {
-      if (error.response?.data?.data === "Invalid parameter") {
-        throw new Error("Invalid parameter. Make sure you previously connected to the LinkedIn profile you want to send a message to.");
-      }
-      throw error;
-    }
+    $.export("$summary", `Successfully sent message to ${this.linkedinUrl}`);
+    return response;
   },
 };