New Components - lusha

components/lusha/actions/company-enrich/company-enrich.mjs

@@ -0,0 +1,37 @@
+import lusha from "../../lusha.app.mjs";
+
+export default {
+  key: "lusha-company-enrich",
+  name: "Enrich Companies",
+  description: "Enriches company information based on provided company IDs. [See the documentation](https://www.lusha.com/docs/#company-enrich)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    lusha,
+    requestId: {
+      propDefinition: [
+        lusha,
+        "requestId",
+      ],
+      label: "Company Request ID",
+      description: "The request ID generated from the company search response.",
+    },
+    companiesIds: {
+      propDefinition: [
+        lusha,
+        "companiesIds",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.lusha.enrichCompanies({
+      $,
+      data: {
+        requestId: this.requestId,
+        companiesIds: this.companiesIds,
+      },
+    });
+    $.export("$summary", `Successfully enriched ${this.companiesIds.length} companies`);
+    return response;
+  },
+};

components/lusha/actions/company-search/company-search.mjs

@@ -0,0 +1,105 @@
+import { parseObject } from "../../common/utils.mjs";
+import lusha from "../../lusha.app.mjs";
+
+export default {
+  key: "lusha-company-search",
+  name: "Search Companies",
+  description: "Search for companies using various filters. [See the documentation](https://www.lusha.com/docs/#contactcompany-search)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    lusha,
+    names: {
+      propDefinition: [
+        lusha,
+        "companyNames",
+      ],
+      optional: true,
+    },
+    domains: {
+      propDefinition: [
+        lusha,
+        "domains",
+      ],
+      optional: true,
+    },
+    locations: {
+      propDefinition: [
+        lusha,
+        "locations",
+      ],
+      optional: true,
+    },
+    sizes: {
+      propDefinition: [
+        lusha,
+        "sizes",
+      ],
+      optional: true,
+    },
+    revenues: {
+      propDefinition: [
+        lusha,
+        "revenues",
+      ],
+      optional: true,
+    },
+    sicCodes: {
+      propDefinition: [
+        lusha,
+        "sicCodes",
+      ],
+      optional: true,
+    },
+    naicsCodes: {
+      propDefinition: [
+        lusha,
+        "naicsCodes",
+      ],
+      optional: true,
+    },
+    limit: {
+      type: "string",
+      label: "Limit",
+      description: "The maximum number of results to return. **This feature is used to avoid timeouts due to very long returns.**",
+    },
+  },
+  async run({ $ }) {
+    try {
+      const include = {};
+
+      if (this.names) include.names = parseObject(this.names);
+      if (this.domains) include.domains = parseObject(this.domains);
+      if (this.locations) include.locations = parseObject(this.locations);
+      if (this.sizes) include.sizes = parseObject(this.sizes);
+      if (this.revenues) include.revenues = parseObject(this.revenues);
+      if (this.sicCodes) include.sicCodes = parseObject(this.sicCodes);
+      if (this.naicsCodes) include.naicsCodes = parseObject(this.naicsCodes);
+
+      const response = this.lusha.paginate({
+        $,
+        maxResults: this.limit,
+        fn: this.lusha.searchCompanies,
+        data: {
+          filters: {
+            companies: {
+              include,
+            },
+          },
+        },
+      });
+
+      const responseArray = [];
+
+      for await (const item of response) {
+        responseArray.push(item);
+      }
+
+      $.export("$summary", `Successfully retrieved ${responseArray.length} companies`);
+      return responseArray;
+    } catch (error) {
+      $.export("$summary", "Failed to search companies");
+      throw error;
+    }
+  },
+};

components/lusha/actions/contact-enrich/contact-enrich.mjs

@@ -0,0 +1,37 @@
+import lusha from "../../lusha.app.mjs";
+
+export default {
+  key: "lusha-contact-enrich",
+  name: "Enrich Contacts",
+  description: "Enriches contacts based on provided IDs. [See the documentation](https://www.lusha.com/docs/#contact-enrich)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    lusha,
+    requestId: {
+      propDefinition: [
+        lusha,
+        "requestId",
+      ],
+      label: "Contact Request ID",
+      description: "The request ID generated from the contact search response.",
+    },
+    contactIds: {
+      propDefinition: [
+        lusha,
+        "contactIds",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.lusha.enrichContacts({
+      $,
+      data: {
+        requestId: this.requestId,
+        contactIds: this.contactIds,
+      },
+    });
+    $.export("$summary", `Successfully enriched ${this.contactIds.length} contacts`);
+    return response;
+  },
+};

components/lusha/actions/contact-search/contact-search.mjs

@@ -0,0 +1,98 @@
+import { parseObject } from "../../common/utils.mjs";
+import lusha from "../../lusha.app.mjs";
+
+export default {
+  key: "lusha-contact-search",
+  name: "Search Contacts",
+  description: "Search for contacts using various filters. [See the documentation](https://www.lusha.com/docs/#contactcompany-search)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    lusha,
+    names: {
+      propDefinition: [
+        lusha,
+        "contactNames",
+      ],
+      label: "Contact Names",
+      description: "Names of contacts to search.",
+    },
+    jobTitles: {
+      propDefinition: [
+        lusha,
+        "jobTitles",
+      ],
+    },
+    jobTitlesExactMatch: {
+      propDefinition: [
+        lusha,
+        "jobTitlesExactMatch",
+      ],
+    },
+    countries: {
+      propDefinition: [
+        lusha,
+        "countries",
+      ],
+    },
+    seniority: {
+      propDefinition: [
+        lusha,
+        "seniority",
+      ],
+    },
+    departments: {
+      propDefinition: [
+        lusha,
+        "departments",
+      ],
+    },
+    existingDataPoints: {
+      propDefinition: [
+        lusha,
+        "existingDataPoints",
+      ],
+    },
+    location: {
+      propDefinition: [
+        lusha,
+        "location",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const include = {};
+
+    if (this.names) include.names = parseObject(this.names);
+    if (this.jobTitles) include.jobTitles = parseObject(this.jobTitles);
+    if (this.jobTitlesExactMatch)
+      include.jobTitlesExactMatch = parseObject(this.jobTitlesExactMatch);
+    if (this.countries) include.countries = parseObject(this.countries);
+    if (this.seniority) include.seniority = parseObject(this.seniority);
+    if (this.departments) include.departments = parseObject(this.departments);
+    if (this.existingDataPoints) include.existingDataPoints = parseObject(this.existingDataPoints);
+    if (this.location) include.location = parseObject(this.location);
+
+    const response = this.lusha.paginate({
+      $,
+      maxResults: this.limit,
+      fn: this.lusha.searchContacts,
+      data: {
+        filters: {
+          contacts: {
+            include,
+          },
+        },
+      },
+    });
+
+    const responseArray = [];
+
+    for await (const item of response) {
+      responseArray.push(item);
+    }
+
+    $.export("$summary", `Found ${responseArray.length} contacts`);
+    return response;
+  },
+};

components/lusha/common/utils.mjs

@@ -0,0 +1,24 @@
+export const parseObject = (obj) => {
+  if (!obj) return undefined;
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => {
+      if (typeof item === "string") {
+        try {
+          return JSON.parse(item);
+        } catch (e) {
+          return item;
+        }
+      }
+      return item;
+    });
+  }
+  if (typeof obj === "string") {
+    try {
+      return JSON.parse(obj);
+    } catch (e) {
+      return obj;
+    }
+  }
+  return obj;
+};