linkedin-api-voyager 1.0.0 → 1.1.0

package/lib/utils.js

@@ -0,0 +1,193 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterKeys = filterKeys;
+exports.filterOutKeys = filterOutKeys;
+exports.getNestedValue = getNestedValue;
+exports.extractFields = extractFields;
+exports.debugObjectStructure = debugObjectStructure;
+exports.resolveReferences = resolveReferences;
+exports.extractDataWithReferences = extractDataWithReferences;
+exports.debugResolvedStructure = debugResolvedStructure;
+exports.extractFieldsFromIncluded = extractFieldsFromIncluded;
+exports.mergeExtraFields = mergeExtraFields;
+function filterKeys(obj, keysToKeep) {
+    const filteredObject = {};
+    keysToKeep.forEach((key) => {
+        if (obj.hasOwnProperty(key)) {
+            filteredObject[key] = obj[key];
+        }
+    });
+    return filteredObject;
+}
+function filterOutKeys(obj, keysToIgnore) {
+    const filteredObject = {};
+    Object.keys(obj).forEach((key) => {
+        if (!keysToIgnore.includes(key)) {
+            filteredObject[key] = obj[key];
+        }
+    });
+    return filteredObject;
+}
+// Nova função para extrair valores de caminhos aninhados
+function getNestedValue(obj, path) {
+    return path.split('.').reduce((current, key) => {
+        var _a;
+        // Lidar com arrays como attributes[0]
+        if (key.includes('[') && key.includes(']')) {
+            const [arrayKey, indexStr] = key.split('[');
+            const index = parseInt(indexStr.replace(']', ''));
+            return (_a = current === null || current === void 0 ? void 0 : current[arrayKey]) === null || _a === void 0 ? void 0 : _a[index];
+        }
+        return current === null || current === void 0 ? void 0 : current[key];
+    }, obj);
+}
+// Nova função melhorada para filtrar com caminhos aninhados
+function extractFields(data, fieldsMap) {
+    return data.map(item => {
+        const extracted = {};
+        Object.entries(fieldsMap).forEach(([newKey, path]) => {
+            const value = getNestedValue(item, path);
+            if (value !== undefined) {
+                extracted[newKey] = value;
+            }
+        });
+        return extracted;
+    });
+}
+// Função para debug - mostra a estrutura do objeto
+function debugObjectStructure(obj, maxDepth = 3, currentDepth = 0) {
+    if (currentDepth >= maxDepth)
+        return;
+    const indent = '  '.repeat(currentDepth);
+    if (Array.isArray(obj)) {
+        console.log(`${indent}Array[${obj.length}]:`);
+        if (obj.length > 0) {
+            console.log(`${indent}  [0]:`);
+            debugObjectStructure(obj[0], maxDepth, currentDepth + 2);
+        }
+    }
+    else if (obj && typeof obj === 'object') {
+        Object.keys(obj).slice(0, 10).forEach(key => {
+            const value = obj[key];
+            if (typeof value === 'object' && value !== null) {
+                console.log(`${indent}${key}:`);
+                debugObjectStructure(value, maxDepth, currentDepth + 1);
+            }
+            else {
+                console.log(`${indent}${key}: ${typeof value} = ${String(value).slice(0, 50)}...`);
+            }
+        });
+    }
+}
+// Função para resolver referências URN dinamicamente
+function resolveReferences(data, included) {
+    if (!data || !included)
+        return data;
+    // Criar um mapa de URN para acesso rápido
+    const urnMap = new Map();
+    included.forEach(item => {
+        if (item.entityUrn) {
+            urnMap.set(item.entityUrn, item);
+        }
+    });
+    // Função recursiva para resolver referências
+    function resolveObject(obj) {
+        if (Array.isArray(obj)) {
+            return obj.map(item => resolveObject(item));
+        }
+        if (obj && typeof obj === 'object') {
+            const resolved = {};
+            Object.entries(obj).forEach(([key, value]) => {
+                // Detectar chaves que começam com * (referências URN)
+                if (key.startsWith('*') && typeof value === 'string') {
+                    const referencedData = urnMap.get(value);
+                    if (referencedData) {
+                        // Remover o * e usar como chave
+                        const cleanKey = key.substring(1);
+                        resolved[cleanKey] = resolveObject(referencedData);
+                    }
+                    else {
+                        resolved[key] = value; // Manter original se não encontrar
+                    }
+                }
+                // Detectar arrays de URNs
+                else if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'string' && value[0].startsWith('urn:li:')) {
+                    const resolvedArray = value.map(urn => {
+                        const referencedData = urnMap.get(urn);
+                        return referencedData ? resolveObject(referencedData) : urn;
+                    }).filter(item => item !== null);
+                    resolved[key] = resolvedArray;
+                }
+                // Recursão para objetos aninhados
+                else if (value && typeof value === 'object') {
+                    resolved[key] = resolveObject(value);
+                }
+                // Valores primitivos
+                else {
+                    resolved[key] = value;
+                }
+            });
+            return resolved;
+        }
+        return obj;
+    }
+    return resolveObject(data);
+}
+// Função para extrair dados com resolução automática de referências
+function extractDataWithReferences(elements, included, fieldsMap) {
+    // Filtrar dados pelos elementos
+    const filteredData = included.filter(item => elements.includes(item.entityUrn));
+    // Resolver todas as referências
+    const resolvedData = filteredData.map(item => resolveReferences(item, included));
+    // Se há mapeamento de campos, aplicar
+    if (fieldsMap) {
+        return extractFields(resolvedData, fieldsMap);
+    }
+    return resolvedData;
+}
+// Função para debug de estrutura com referências resolvidas
+function debugResolvedStructure(elements, included, maxDepth = 2) {
+    console.log('🔍 Estrutura dos dados com referências resolvidas:');
+    const resolved = extractDataWithReferences(elements, included);
+    if (resolved.length > 0) {
+        console.log(`📊 Total de itens: ${resolved.length}`);
+        console.log('📋 Estrutura do primeiro item:');
+        debugObjectStructure(resolved[0], maxDepth);
+    }
+}
+// Função para extrair campos específicos de todos os objetos no included
+function extractFieldsFromIncluded(included, fields) {
+    return included
+        .filter(item => fields.some(field => item[field] !== undefined))
+        .map(item => {
+        const extracted = { entityUrn: item.entityUrn };
+        fields.forEach(field => {
+            if (item[field] !== undefined) {
+                extracted[field] = item[field];
+            }
+        });
+        return extracted;
+    });
+}
+// Função para associar dados extras aos dados principais
+function mergeExtraFields(mainData, extraData, matchKey = 'companyUrn') {
+    return mainData.map(item => {
+        const extraItem = extraData.find(extra => item[matchKey] && extra.entityUrn === item[matchKey]);
+        if (extraItem) {
+            const { entityUrn } = extraItem, extraFields = __rest(extraItem, ["entityUrn"]);
+            return Object.assign(Object.assign({}, item), extraFields);
+        }
+        return item;
+    });
+}

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "linkedin-api-voyager",
-  "version": "1.0.0",
+  "version": "1.1.0",
+  "description": "Uma biblioteca TypeScript para interagir com a API interna do LinkedIn (Voyager)",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "license": "MIT",
+  "files": [
+    "lib/**/*"
+  ],
   "scripts": {
     "build": "tsc",
     "prepare": "npm run build",
     "dev": "nodemon src/index.ts",
-    "publish": "yarn build && npm publish"
+    "prepublishOnly": "npm run build"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

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 [];
-};