@entergreat/unipile-wrapper 1.0.11 → 2.1.0

package/src/types/profile.ts

@@ -0,0 +1,50 @@
+import { AccountIdParam } from "./common.js";
+
+export interface RetrieveProfileRequest extends AccountIdParam {
+  profileId: string;
+  linkedinSections?: string[];
+  notify?: boolean;
+}
+
+export interface ProfileData {
+  headline?: string;
+  summary?: string;
+  location?: { id: string };
+  picture?: Record<string, unknown>;
+  experience?: {
+    skills?: string[];
+    [key: string]: unknown;
+  };
+  education?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface EditProfileRequest extends AccountIdParam {
+  profileData: ProfileData;
+}
+
+export interface ExperienceData {
+  role: string;
+  company: string;
+  company_id?: string;
+  description?: string;
+  location?: string;
+  start_month?: number;
+  start_year?: number;
+  end_month?: number;
+  end_year?: number;
+  skills?: string[];
+  notify_network?: boolean;
+}
+
+export interface AddExperienceRequest extends AccountIdParam {
+  experience: ExperienceData;
+}
+
+export interface ProfileResponse {
+  object: string;
+  id: string;
+  name?: string;
+  headline?: string;
+  // Add more fields as needed
+}

package/src/types/search.ts

@@ -0,0 +1,27 @@
+import { AccountIdParam, PaginationParams } from "./common.js";
+
+export interface SearchByParamsRequest extends AccountIdParam, PaginationParams {
+  params?: Record<string, unknown>;
+}
+
+export interface SearchByUrlRequest extends AccountIdParam, PaginationParams {
+  searchUrl: string;
+}
+
+export interface RetrieveSearchParametersRequest extends AccountIdParam {
+  type: string;
+  keywords?: string;
+  limit?: number;
+}
+
+export interface SearchResult {
+  object: string;
+  items: unknown[];
+  cursor?: string;
+  // Add more fields as needed
+}
+
+export interface SearchParametersResult {
+  object: string;
+  items: unknown[];
+}

package/src/utils/helpers.ts

@@ -0,0 +1,41 @@
+/**
+ * Extracts company ID from a LinkedIn company URL
+ * Handles URLs like:
+ * - https://www.linkedin.com/company/company-name/
+ * - https://www.linkedin.com/company/12345678/
+ * - https://linkedin.com/company/company-name
+ */
+export function extractCompanyIdFromUrl(url: string): string | null {
+  const match = url.match(/linkedin\.com\/company\/([^\/\?]+)/i);
+  return match ? match[1] : null;
+}
+
+/**
+ * Converts nested objects to bracket notation for API compatibility
+ * Example: { experience: { role: "Dev" } } -> { "experience[role]": "Dev" }
+ */
+export function convertToBracketNotation(
+  obj: Record<string, unknown>,
+  prefix = ""
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+
+  for (const key in obj) {
+    if (obj[key] === undefined) continue;
+
+    const fullKey = prefix ? `${prefix}[${key}]` : key;
+
+    if (Array.isArray(obj[key])) {
+      result[fullKey] = obj[key];
+    } else if (typeof obj[key] === "object" && obj[key] !== null) {
+      Object.assign(
+        result,
+        convertToBracketNotation(obj[key] as Record<string, unknown>, fullKey)
+      );
+    } else {
+      result[fullKey] = obj[key];
+    }
+  }
+
+  return result;
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./validators.js";
+export * from "./helpers.js";
+export * from "./urlBuilder.js";

package/src/utils/urlBuilder.ts

@@ -0,0 +1,29 @@
+type QueryParams = Record<string, string | number | boolean | undefined>;
+
+/**
+ * Builds a URL with query parameters, filtering out undefined values
+ */
+export function buildUrl(baseUrl: string, path: string, params: QueryParams = {}): string {
+  const url = new URL(path, baseUrl);
+
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== "") {
+      url.searchParams.append(key, String(value));
+    }
+  }
+
+  return url.toString();
+}
+
+/**
+ * Appends array values as repeated query parameters
+ */
+export function appendArrayParams(url: string, key: string, values: string[]): string {
+  const urlObj = new URL(url);
+
+  for (const value of values) {
+    urlObj.searchParams.append(key, value);
+  }
+
+  return urlObj.toString();
+}

package/src/utils/validators.ts

@@ -0,0 +1,47 @@
+export class ValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ValidationError";
+  }
+}
+
+export function validateRequired(
+  params: Record<string, unknown>,
+  requiredFields: string[]
+): void {
+  for (const field of requiredFields) {
+    if (!params[field]) {
+      throw new ValidationError(`${field} must be provided`);
+    }
+  }
+}
+
+export function validateAccountId(accountId: string | undefined): void {
+  if (!accountId) {
+    throw new ValidationError("accountId must be provided");
+  }
+}
+
+export function validateProfileId(profileId: string | undefined): void {
+  if (!profileId) {
+    throw new ValidationError("profileId must be provided");
+  }
+}
+
+export function validateExperience(experience: { role?: string; company?: string } | undefined): void {
+  if (!experience || !experience.role || !experience.company) {
+    throw new ValidationError("experience with role and company is required");
+  }
+}
+
+export function validateProfileData(profileData: Record<string, unknown> | undefined): void {
+  if (!profileData || Object.keys(profileData).length === 0) {
+    throw new ValidationError("profileData must be provided with at least one field to update");
+  }
+}
+
+export function validateCompanyIdOrUrl(companyId?: string, companyUrl?: string): void {
+  if (!companyId && !companyUrl) {
+    throw new ValidationError("companyId or companyUrl must be provided");
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/src/index.js

@@ -1,3 +0,0 @@
-import LinkedinService from "./services/linkedinService.js";
-
-export { LinkedinService };

package/src/services/linkedinService.js

@@ -1,262 +0,0 @@
-import { get, post, patch } from "../utils/api.js";
-import FormData from "form-data";
-
-function extractCompanyIdFromUrl(url) {
-  // Handle URLs like:
-  // https://www.linkedin.com/company/company-name/
-  // https://www.linkedin.com/company/12345678/
-  // https://linkedin.com/company/company-name
-  const match = url.match(/linkedin\.com\/company\/([^\/\?]+)/i);
-  return match ? match[1] : null;
-}
-
-function convertToBracketNotation(obj, prefix = '') {
-  const result = {};
-
-  for (const key in obj) {
-    if (obj[key] === undefined) continue;
-
-    const fullKey = prefix ? `${prefix}[${key}]` : key;
-
-    if (Array.isArray(obj[key])) {
-      result[fullKey] = obj[key];
-    } else if (typeof obj[key] === 'object' && obj[key] !== null) {
-      Object.assign(result, convertToBracketNotation(obj[key], fullKey));
-    } else {
-      result[fullKey] = obj[key];
-    }
-  }
-
-  return result;
-}
-
-export default class LinkedinService {
-  constructor({ uniphileToken, subdomain, port }) {
-    this.unipileUrl = `https://${subdomain}.unipile.com:${port}/api/v1`;
-    this.headers = {
-      accept: "application/json",
-      "content-type": "application/json",
-      "X-API-KEY": uniphileToken,
-    };
-  }
-
-  // connect to linkedin account via li_at cookie
-  async connect({ loginCookie }) {
-    try {
-      const body = {
-        provider: "LINKEDIN",
-        access_token: loginCookie,
-      };
-
-      return await post(`${this.unipileUrl}/accounts`, body, this.headers);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  // preform a linkedin search by params
-  async searchByParams({ accountId, params = {}, cursor = "", limit = 10 }) {
-    try {
-      if (!accountId) {
-        throw "account_id must be provided";
-      }
-
-      let url = `${this.unipileUrl}/linkedin/search?account_id=${accountId}&limit=${limit}`;
-
-      params["api"] = "classic";
-      params["category"] = "people";
-
-      if (cursor) {
-        url += `&cursor=${cursor}`;
-      }
-
-      return await post(url, params, this.headers);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  // preform a linkedin search by url
-  async searchByUrl({ accountId, searchUrl, cursor = "", limit = 10 }) {
-    try {
-      if (!accountId) {
-        throw "account_id must be provided";
-      }
-
-      const body = {
-        api: "classic",
-        category: "people",
-        url: searchUrl,
-      };
-
-      let url = `${this.unipileUrl}/linkedin/search?account_id=${accountId}&limit=${limit}`;
-
-      if (cursor) {
-        url += `&cursor=${cursor}`;
-      }
-
-      return await post(url, body, this.headers);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  // retrieve LinkedIn search parameters
-  async retrieveSearchParameters({
-    accountId,
-    type,
-    keywords = "",
-    limit = 3,
-  }) {
-    try {
-      if (!accountId) {
-        throw "account_id must be provided";
-      }
-
-      const url = `${
-        this.unipileUrl
-      }/linkedin/search/parameters?account_id=${accountId}&keywords=${keywords}&type=${type.toUpperCase()}&limit=${limit}`;
-
-      return await get(url, this.headers);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  // retrieve LinkedIn profile
-  async retrieveProfile({
-    accountId,
-    profileId,
-    linkedinSections = [],
-    notify = false,
-  }) {
-    try {
-      if (!accountId) {
-        throw "account_id must be provided";
-      }
-
-      if (!profileId) {
-        throw "profile_id must be provided";
-      }
-
-      let url = `${this.unipileUrl}/users/${profileId}?account_id=${accountId}&notify=${notify}`;
-
-      for (const linkedinSection of linkedinSections) {
-        url += `&linkedin_sections=${linkedinSection}`;
-      }
-
-      return await get(url, this.headers);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  // retrieve LinkedIn company by URL or ID
-  async retrieveCompany({ accountId, companyId, companyUrl }) {
-    try {
-      if (!accountId) {
-        throw "account_id must be provided";
-      }
-
-      let id = companyId;
-      if (!id && companyUrl) {
-        id = extractCompanyIdFromUrl(companyUrl);
-      }
-
-      if (!id) {
-        throw "company_id or company_url must be provided";
-      }
-
-      const url = `${this.unipileUrl}/linkedin/company/${id}?account_id=${accountId}`;
-
-      return await get(url, this.headers);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  // edit LinkedIn profile (headline, summary - JSON format)
-  async editProfile({ accountId, profileData }) {
-    try {
-      if (!accountId) {
-        throw "account_id must be provided";
-      }
-
-      if (!profileData || Object.keys(profileData).length === 0) {
-        throw "profileData must be provided with at least one field to update";
-      }
-
-      const url = `${this.unipileUrl}/users/me/edit?account_id=${accountId}`;
-
-      const body = convertToBracketNotation(profileData);
-
-      return await patch(url, body, this.headers);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  // add experience position (multipart/form-data format with bracket notation)
-  async addExperience({ accountId, experience }) {
-    try {
-      if (!accountId) {
-        throw "account_id must be provided";
-      }
-
-      if (!experience || !experience.role || !experience.company) {
-        throw "experience with role and company is required";
-      }
-
-      const url = `${this.unipileUrl}/users/me/edit?account_id=${accountId}`;
-
-      const formData = new FormData();
-      formData.append("type", "LINKEDIN");
-      formData.append("account_id", accountId);
-
-      // Experience fields use bracket notation
-      formData.append("experience[role]", experience.role);
-      formData.append("experience[company]", experience.company);
-
-      if (experience.description) {
-        formData.append("experience[description]", experience.description);
-      }
-      if (experience.notify_network !== undefined) {
-        formData.append("experience[notify_network]", experience.notify_network.toString());
-      }
-
-      // Start date with bracket notation
-      if (experience.start_month) {
-        formData.append("experience[seniority][start_date][month]", experience.start_month.toString());
-      }
-      if (experience.start_year) {
-        formData.append("experience[seniority][start_date][year]", experience.start_year.toString());
-      }
-
-      // End date with bracket notation (optional - for non-current positions)
-      if (experience.end_month) {
-        formData.append("experience[seniority][end_date][month]", experience.end_month.toString());
-      }
-      if (experience.end_year) {
-        formData.append("experience[seniority][end_date][year]", experience.end_year.toString());
-      }
-
-      // Skills array - repeat key for each skill
-      if (experience.skills && Array.isArray(experience.skills)) {
-        for (const skill of experience.skills) {
-          formData.append("experience[skills]", skill);
-        }
-      }
-
-      // Use formData.getHeaders() to get correct content-type with boundary
-      const headers = {
-        accept: "application/json",
-        "X-API-KEY": this.headers["X-API-KEY"],
-        ...formData.getHeaders(),
-      };
-
-      return await patch(url, formData, headers);
-    } catch (error) {
-      throw error;
-    }
-  }
-}

package/src/utils/api.js

@@ -1,28 +0,0 @@
-import axios from "axios";
-
-export const get = async (route, headers = {}) => {
-  try {
-    const response = await axios.get(route, { headers });
-    return response.data;
-  } catch (error) {
-    throw error;
-  }
-};
-
-export const post = async (route, body = {}, headers = {}) => {
-  try {
-    const response = await axios.post(route, body, { headers });
-    return response.data;
-  } catch (error) {
-    throw error;
-  }
-};
-
-export const patch = async (route, body = {}, headers = {}) => {
-  try {
-    const response = await axios.patch(route, body, { headers });
-    return response.data;
-  } catch (error) {
-    throw error;
-  }
-};