linkedin-api-voyager 1.3.0 → 1.3.2

package/src/account.ts

@@ -1,116 +0,0 @@
-import { fetchData } from "./config";
-import {
-  extractDataWithReferences,
-  extractFields,
-  extractFieldsFromIncluded,
-  mergeExtraFields,
-} from "./utils";
-
-export const getProfile = async (identifier: string) => {
-  const response = await fetchData(
-    `/identity/profiles/${identifier}/profileView`
-  );
-
-  const data = response.data;
-  const dataResult: any[] = response?.included;
-
-  const getEntityByUrn = (urn: string) =>
-    dataResult.find((item) => item.entityUrn === urn);
-
-  const keyProfile = getEntityByUrn(data?.["*profile"]);
-  if (!keyProfile) throw new Error("Key profile not found");
-
-  const miniProfile = getEntityByUrn(keyProfile?.["*miniProfile"]);
-  if (!miniProfile) throw new Error("Mini profile not found");
-
-  const profile = {
-    // id_urn: keyProfile.entityUrn?.split("urn:li:fs_profile:")[1] || null,
-    publicIdentifier: miniProfile?.publicIdentifier || null,
-    firstName: keyProfile.firstName || null,
-    lastName: keyProfile.lastName || null,
-    fullName: `${keyProfile.firstName || ""} ${keyProfile.lastName || ""}`,
-    birthDate: keyProfile.birthDate
-      ? JSON.stringify({
-          month: keyProfile.birthDate.month,
-          day: keyProfile.birthDate.day,
-        })
-      : null,
-    profilePicture: miniProfile.picture
-      ? `${miniProfile.picture.rootUrl}${
-          miniProfile.picture.artifacts[
-            miniProfile.picture.artifacts.length - 1
-          ]?.fileIdentifyingUrlPathSegment
-        }`
-      : null,
-    backgroundPicture: miniProfile.backgroundImage
-      ? `${miniProfile.backgroundImage.rootUrl}${
-          miniProfile.backgroundImage.artifacts[
-            miniProfile.backgroundImage.artifacts.length - 1
-          ]?.fileIdentifyingUrlPathSegment
-        }`
-      : null,
-    location: {
-      country: keyProfile.locationName || null,
-      city: keyProfile.geoLocationName || null,
-    },
-    address: keyProfile.address || null,
-    industry: keyProfile.industryName || null,
-    headline: keyProfile.headline || null,
-    summary: keyProfile.summary || null,
-  };
-
-  return profile;
-};
-
-export const getProfissionalExperiences = async (identifier: string) => {
-  const response = await fetchData(
-    `/identity/profiles/${identifier}/positions`
-  );
-
-  let { data, included } = response;
-  const elements = data["*elements"] as string[];
-
-  // Usar a nova função para resolver referências automaticamente
-  const dataExperiences = extractDataWithReferences(elements, included);
-
-  // Extrair campos específicos do included
-  const extraFields = extractFieldsFromIncluded(included, ["universalName"]);
-
-  // Mapeamento de campos
-  const fieldsMap = {
-    id: "entityUrn",
-    title: "title",
-    companyName: "company.miniCompany.name",
-    companyUrn: "companyUrn",
-    companyEmployeeCount: "company.employeeCountRange",
-    companyIndustries: "company.miniCompany.industries",
-    description: "description",
-    location: "locationName",
-    geoLocation: "geoLocationName",
-    timePeriod: "timePeriod",
-    startDate: "timePeriod.startDate",
-    endDate: "timePeriod.endDate",
-  };
-
-  // Aplicar mapeamento aos dados resolvidos
-  const mappedExperiences = extractFields(dataExperiences, fieldsMap);
-
-  // Associar campos extras
-  const experiencesWithExtras = mergeExtraFields(
-    mappedExperiences,
-    extraFields,
-    "companyUrn"
-  );
-
-  // Ordenar: sem endDate (ativo) primeiro, depois do mais recente ao mais antigo
-  return experiencesWithExtras.sort((a, b) => {
-    if (!a.endDate && b.endDate) return -1;
-    if (a.endDate && !b.endDate) return 1;
-    if (!a.endDate && !b.endDate) return 0;
-
-    const yearDiff = (b.endDate.year || 0) - (a.endDate.year || 0);
-    if (yearDiff !== 0) return yearDiff;
-
-    return (b.endDate.month || 0) - (a.endDate.month || 0);
-  });
-};

package/src/company.ts

@@ -1,33 +0,0 @@
-import { fetchData } from "./config";
-import { extractDataWithReferences, extractFields } from "./utils";
-
-export const getCompany = async (identifier: string) => {
-  const response = await fetchData(
-    `/organization/companies?decorationId=com.linkedin.voyager.deco.organization.web.WebFullCompanyMain-12&q=universalName&universalName=${identifier}`
-  );
-
-  const data = extractDataWithReferences(
-    response.data["*elements"],
-    response.included
-  );
-
-  const fieldsMap = {
-    id: "entityUrn",
-    name: "name",
-    description: "description",
-    username: "universalName",
-    companyPageUrl: "companyPageUrl",
-    staffCount: "staffCount",
-    url: "url",
-    companyIndustries: "*companyIndustries[0].localizedName",
-    location: "locationName",
-    jobSearchPageUrl: "jobSearchPageUrl",
-    phone: "phone",
-    followerCount: "followingInfo.followerCount",
-    backgroundCoverImage: "backgroundCoverImage.image",
-    logo: "logo.image",
-    permissions: "permissions",
-  };
-
-  return extractFields(data, fieldsMap)[0];
-};

package/src/config.ts

@@ -1,109 +0,0 @@
-import * as path from "path";
-import * as os from "os";
-import * as fs from "fs-extra";
-import axios from "axios";
-
-export const COOKIE_FILE_PATH = "linkedin_cookies.json";
-
-export const API_BASE_URL = "https://www.linkedin.com/voyager/api";
-export const AUTH_BASE_URL = "https://www.linkedin.com";
-
-// Interface para os cookies
-interface LinkedInCookies {
-  JSESSIONID: string;
-  li_at: string;
-  timestamp: number;
-}
-
-// Função para salvar cookies no arquivo JSON
-export const saveCookies = async (
-  JSESSIONID: string,
-  li_at: string
-): Promise<void> => {
-  try {
-    const cookies: LinkedInCookies = {
-      JSESSIONID,
-      li_at,
-      timestamp: Date.now(),
-    };
-
-    await fs.ensureFile(COOKIE_FILE_PATH);
-    await fs.writeJson(COOKIE_FILE_PATH, cookies, { spaces: 2 });
-    console.log(`Cookies salvos em: ${COOKIE_FILE_PATH}`);
-  } catch (error) {
-    console.error("Erro ao salvar cookies:", error);
-    throw error;
-  }
-};
-
-// Função para carregar cookies do arquivo JSON
-export const loadCookies = async (): Promise<LinkedInCookies | null> => {
-  try {
-    const exists = await fs.pathExists(COOKIE_FILE_PATH);
-    if (!exists) {
-      console.log("Arquivo de cookies não encontrado");
-      return null;
-    }
-
-    const cookies = await fs.readJson(COOKIE_FILE_PATH);
-
-    // Verificar se os cookies têm a estrutura esperada
-    if (!cookies.JSESSIONID || !cookies.li_at) {
-      console.log("Cookies inválidos encontrados no arquivo");
-      return null;
-    }
-
-    console.log(`Cookies carregados de: ${COOKIE_FILE_PATH}`);
-    return cookies;
-  } catch (error) {
-    console.error("Erro ao carregar cookies:", error);
-    return null;
-  }
-};
-
-// Função para criar cliente com cookies automáticos
-export const Client = async (providedCookies?: {
-  JSESSIONID: string;
-  li_at: string;
-}): Promise<ReturnType<typeof api>> => {
-  let cookiesToUse: { JSESSIONID: string; li_at: string };
-  const savedCookies = await loadCookies();
-
-  if (savedCookies) {
-    cookiesToUse = {
-      JSESSIONID: savedCookies.JSESSIONID,
-      li_at: savedCookies.li_at,
-    };
-  } else {
-    if (providedCookies) {
-      await saveCookies(providedCookies.JSESSIONID, providedCookies.li_at);
-      cookiesToUse = providedCookies;
-    } else {
-      throw new Error("Nenhum cookie válido fornecido");
-    }
-  }
-
-  return api({
-    JSESSIONID: parseInt(cookiesToUse.JSESSIONID),
-    li_at: cookiesToUse.li_at,
-  });
-};
-
-const api = ({ JSESSIONID, li_at }: { li_at: string; JSESSIONID: number }) => {
-  return axios.create({
-    baseURL: API_BASE_URL,
-    headers: {
-      "accept-language":
-        "pt-BR,pt;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
-      accept: "application/vnd.linkedin.normalized+json+2.1",
-      cookie: `li_at=${li_at}; JSESSIONID="ajax:${JSESSIONID}"`,
-      "csrf-token": `ajax:${JSESSIONID}`,
-    },
-  });
-};
-
-export const fetchData = async (endpoint: string) => {
-  const api = await Client();
-  const response = await api.get(endpoint);
-  return response.data;
-};

package/src/posts.ts

@@ -1,71 +0,0 @@
-import { fetchData } from "./config";
-import { extractFields } from "./utils";
-
-export const getCommentsByPostUrl = async (
-  url: string,
-  start: number = 0,
-  limit: number = 50,
-  accumulatedComments: any[] = []
-): Promise<any[]> => {
-  const postID = url.match(/activity-(\d+)/)?.[1];
-
-  const response = await fetchData(
-    `/graphql?includeWebMetadata=false&queryId=voyagerSocialDashComments.95ed44bc87596acce7c460c70934d0ff&variables=(count:${limit},start:${start},numReplies:1,socialDetailUrn:urn%3Ali%3Afsd_socialDetail%3A%28urn%3Ali%3Aactivity%${postID}%2Curn%3Ali%3Aactivity%3A${postID}%2Curn%3Ali%3AhighlightedReply%3A-%29,sortOrder:RELEVANCE)`
-  );
-
-  const elements = response.data?.data?.socialDashCommentsBySocialDetail?.[
-    "*elements"
-  ] as string[];
-
-  // Se não há elementos, retorna os comentários acumulados
-  if (!elements || elements.length === 0) {
-    // console.log(
-    //   "✅ Busca finalizada. Total de comentários:",
-    //   accumulatedComments.length
-    // );
-    return accumulatedComments;
-  }
-
-  const data =
-    response.included?.filter((item: any) =>
-      elements.includes(item.entityUrn)
-    ) || [];
-
-  // Mapeamento melhorado dos campos
-  const fieldsMap = {
-    id: "entityUrn",
-    createdAt: "createdAt",
-    isAuthor: "commenter.author",
-    name: "commenter.title.text",
-    headline: "commenter.subtitle",
-    profileUrl: "commenter.navigationUrl",
-    comment: "commentary.text",
-    permalink: "permalink",
-    image:
-      "commenter.image.attributes.0.detailData.nonEntityProfilePicture.vectorImage",
-  };
-
-  const currentComments = extractFields(data, fieldsMap);
-  const allComments = [...accumulatedComments, ...currentComments];
-
-  //   console.log(
-  //     `🔍 Encontrados ${elements.length} comentários (Total: ${allComments.length})`
-  //   );
-
-  // Continua a busca se há mais elementos
-  if (elements.length > 0) {
-    return await getCommentsByPostUrl(
-      url,
-      start + elements.length,
-      limit,
-      allComments
-    );
-  }
-
-  // Se retornou menos que o limite, chegou ao fim
-  return allComments;
-};
-
-export const getPosts = async () => {
-  return [];
-};

package/src/search.ts

@@ -1,183 +0,0 @@
-import { Client as ClientState } from "./config";
-
-// Constantes
-const MAX_SEARCH_COUNT = 25;
-const MAX_REPEATED_REQUESTS = 40;
-
-// Interfaces
-export interface SearchParams {
-  count?: string;
-  filters?: string;
-  origin?: string;
-  q?: string;
-  start?: number;
-  queryContext?: string;
-  [key: string]: any; // Para permitir parâmetros adicionais
-}
-
-export interface SearchElement {
-  [key: string]: any; // Estrutura flexível para elementos de busca
-}
-
-export interface SearchDataElement {
-  elements: SearchElement[];
-  extendedElements?: SearchElement[];
-}
-
-export interface SearchResponse {
-  data: {
-    elements: SearchDataElement[];
-  };
-}
-
-export interface SearchOptions {
-  limit?: number;
-  results?: SearchElement[];
-}
-
-// Função utilitária para criar query string
-const createQueryString = (params: Record<string, any>): string => {
-  return Object.entries(params)
-    .map(
-      ([key, value]) =>
-        `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
-    )
-    .join("&");
-};
-
-// Função utilitária para fazer fetch (assumindo que existe uma função _fetch no client)
-const fetchData = async (endpoint: string): Promise<SearchResponse> => {
-  const api = await ClientState();
-  const response = await api.get(endpoint);
-  return response.data;
-};
-
-// Função principal de busca
-export const search = async (
-  params: SearchParams,
-  options: SearchOptions = {}
-): Promise<SearchElement[]> => {
-  const { limit, results = [] } = options;
-
-  // Determinar o count baseado no limite
-  const count = limit && limit <= MAX_SEARCH_COUNT ? limit : MAX_SEARCH_COUNT;
-
-  // Parâmetros padrão
-  const defaultParams: SearchParams = {
-    count: count.toString(),
-    filters: "List()",
-    origin: "GLOBAL_SEARCH_HEADER",
-    q: "all",
-    start: results.length,
-    queryContext:
-      "List(spellCorrectionEnabled->true,relatedSearchesEnabled->true,kcardTypes->PROFILE|COMPANY)",
-  };
-
-  // Mesclar parâmetros padrão com os fornecidos
-  const mergedParams = { ...defaultParams, ...params };
-
-  // Fazer a requisição
-  const endpoint = `/search/blended?${createQueryString(mergedParams)}`;
-
-  const response = await fetchData(endpoint);
-
-  // Processar os dados da resposta
-  const newElements: SearchElement[] = [];
-
-  if (response.data && response.data.elements) {
-    for (let i = 0; i < response.data.elements.length; i++) {
-      if (response.data.elements[i].elements) {
-        newElements.push(...response.data.elements[i].elements);
-      }
-      // Comentário: não tenho certeza do que extendedElements geralmente se refere
-      // - busca por palavra-chave retorna um único trabalho?
-      // if (response.data.elements[i].extendedElements) {
-      //   newElements.push(...response.data.elements[i].extendedElements);
-      // }
-    }
-  }
-
-  // Adicionar novos elementos aos resultados
-  const updatedResults = [...results, ...newElements];
-
-  // Sempre cortar os resultados, não importa o que a requisição retorna
-  const trimmedResults = limit
-    ? updatedResults.slice(0, limit)
-    : updatedResults;
-
-  // Caso base da recursão
-  const shouldStop =
-    (limit !== undefined &&
-      (trimmedResults.length >= limit || // se nossos resultados excedem o limite definido
-        trimmedResults.length / count >= MAX_REPEATED_REQUESTS)) ||
-    newElements.length === 0;
-
-  if (shouldStop) {
-    return trimmedResults;
-  }
-
-  // Chamada recursiva
-  return search(params, {
-    limit,
-    results: trimmedResults,
-  });
-};
-
-// Função auxiliar para busca simples (não recursiva)
-// export const searchSingle = async (
-//   client: ClientState,
-//   params: SearchParams
-// ): Promise<SearchElement[]> => {
-//   return search(client, params, { limit: MAX_SEARCH_COUNT });
-// };
-
-// // Função para busca com limite específico
-// export const searchWithLimit = async (
-//   client: ClientState,
-//   params: SearchParams,
-//   limit: number
-// ): Promise<SearchElement[]> => {
-//   return search(client, params, { limit });
-// };
-
-// // Função para busca de pessoas
-// export const searchPeople = async (
-//   client: ClientState,
-//   query: string,
-//   limit?: number
-// ): Promise<SearchElement[]> => {
-//   const params: SearchParams = {
-//     keywords: query,
-//     filters: "List(resultType->PEOPLE)",
-//   };
-
-//   return search(client, params, { limit });
-// };
-
-// // Função para busca de empresas
-// export const searchCompanies = async (
-//   client: ClientState,
-//   query: string,
-//   limit?: number
-// ): Promise<SearchElement[]> => {
-//   const params: SearchParams = {
-//     keywords: query,
-//     filters: "List(resultType->COMPANIES)",
-//   };
-
-//   return search(client, params, { limit });
-// };
-
-// // Função para busca de empregos
-// export const searchJobs = async (
-//   client: ClientState,
-//   query: string,
-//   limit?: number
-// ): Promise<SearchElement[]> => {
-//   const params: SearchParams = {
-//     keywords: query,
-//     filters: "List(resultType->JOBS)",
-//   };
-
-//   return search(client, params, { limit });
-// };