linkedin-api-voyager 1.3.0

package/README.md

@@ -0,0 +1,197 @@
+# LinkedIn API Voyager
+
+Uma biblioteca TypeScript para interagir com a API interna do LinkedIn (Voyager) de forma simples e eficiente.
+
+## 🚀 Instalação
+
+```bash
+npm install linkedin-api-voyager
+# ou
+yarn add linkedin-api-voyager
+```
+
+## 📋 Pré-requisitos
+
+Você precisa ter cookies válidos do LinkedIn para usar esta biblioteca. Os cookies devem estar salvos em um arquivo `linkedin_cookies.json` na raiz do seu projeto.
+
+### Formato dos cookies:
+
+```json
+{
+  "JSESSIONID": "seu_token_aqui",
+  "li_at": "seu_token_aqui",
+  "timestamp": "1234567890"
+}
+```
+
+## 🔧 Uso
+
+### Configuração inicial
+
+```typescript
+import {
+  getProfile,
+  getProfissionalExperiences,
+  getCompany,
+  search,
+} from "linkedin-api-voyager";
+```
+
+### 👤 Perfil de usuário
+
+```typescript
+// Obter perfil completo
+const profile = await getProfile("username-do-linkedin");
+
+// Obter experiências profissionais (ordenadas do mais recente ao mais antigo)
+const experiences = await getProfissionalExperiences("username-do-linkedin");
+```
+
+### 🏢 Informações de empresa
+
+```typescript
+// Obter dados completos da empresa
+const company = await getCompany("nome-universal-da-empresa");
+```
+
+### 🔍 Busca
+
+```typescript
+// Busca geral
+const results = await search(
+  {
+    keywords: "desenvolvedor javascript",
+    filters: "List(resultType->PEOPLE)",
+  },
+  { limit: 50 }
+);
+
+// Busca com parâmetros personalizados
+const customSearch = await search({
+  q: "all",
+  keywords: "react developer",
+  filters: "List(resultType->PEOPLE,locationFilter->br:0)",
+  start: 0,
+  count: "25",
+});
+```
+
+### 💬 Comentários de posts
+
+```typescript
+import { getCommentsByPostUrl } from "linkedin-api-voyager";
+
+// Obter todos os comentários de um post
+const comments = await getCommentsByPostUrl(
+  "https://www.linkedin.com/feed/update/urn:li:activity-1234567890/",
+  0, // início
+  50 // limite por página
+);
+```
+
+## 📊 Estrutura de dados
+
+### Perfil
+
+```typescript
+{
+  publicIdentifier: string;
+  firstName: string;
+  lastName: string;
+  fullName: string;
+  profilePicture: string;
+  backgroundPicture: string;
+  location: {
+    country: string;
+    city: string;
+  }
+  industry: string;
+  headline: string;
+  summary: string;
+  // ... outros campos
+}
+```
+
+### Experiências profissionais
+
+```typescript
+[
+  {
+    id: string;
+    title: string;
+    companyName: string;
+    companyUrn: string;
+    universalName: string; // Nome universal da empresa
+    description: string;
+    location: string;
+    startDate: { year: number; month: number };
+    endDate: { year: number; month: number } | null; // null = ativo
+    // ... outros campos
+  }
+]
+```
+
+### Empresa
+
+```typescript
+{
+  id: string;
+  name: string;
+  description: string;
+  username: string;
+  companyPageUrl: string;
+  staffCount: number;
+  url: string;
+  location: string;
+  followerCount: number;
+  logo: object;
+  // ... outros campos
+}
+```
+
+## 🛠️ Funcionalidades avançadas
+
+### Extração de campos personalizados
+
+```typescript
+import { extractFields, extractFieldsFromIncluded } from "linkedin-api-voyager";
+
+// Mapear campos específicos
+const fieldsMap = {
+  nome: "firstName",
+  empresa: "company.name",
+  cargo: "title",
+};
+
+const dadosMapeados = extractFields(dados, fieldsMap);
+```
+
+### Resolução automática de referências
+
+A biblioteca resolve automaticamente referências URN aninhadas, permitindo acesso direto a dados relacionados sem necessidade de mapeamento manual.
+
+## ⚠️ Limitações e considerações
+
+- Esta biblioteca usa a API interna do LinkedIn (Voyager)
+- Requer cookies válidos de uma sessão autenticada
+- Respeite os termos de uso do LinkedIn
+- Use com moderação para evitar bloqueios
+- Não é uma API oficial do LinkedIn
+
+## 🔒 Segurança
+
+- Mantenha seus cookies seguros
+- Não compartilhe o arquivo `linkedin_cookies.json`
+- O arquivo já está incluído no `.gitignore`
+
+## 📝 Licença
+
+MIT
+
+## 🤝 Contribuição
+
+Contribuições são bem-vindas! Por favor, abra uma issue ou pull request.
+
+## 📞 Suporte
+
+Para dúvidas ou problemas, abra uma issue no repositório.

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "linkedin-api-voyager",
+  "version": "1.3.0",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "dev": "nodemon src/index.ts",
+    "publish": "yarn build && npm publish"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.13.1",
+    "nodemon": "^3.1.9",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+    "axios": "^1.11.0",
+    "fs-extra": "^11.3.1"
+  }
+}

package/src/account.ts

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,109 @@
+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/index.ts

@@ -0,0 +1,6 @@
+export * from "./account";
+export * from "./company";
+export * from "./posts";
+export * from "./search";
+export * from "./utils";
+export * from "./config";

package/src/posts.ts

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,183 @@
+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 });
+// };

package/src/utils.ts

@@ -0,0 +1,213 @@
+export function filterKeys(obj: any, keysToKeep: string[]) {
+  const filteredObject: any = {};
+  keysToKeep.forEach((key) => {
+    if (obj.hasOwnProperty(key)) {
+      filteredObject[key] = obj[key];
+    }
+  });
+  return filteredObject;
+}
+
+export function filterOutKeys(obj: any, keysToIgnore: string[]) {
+  const filteredObject: any = {};
+  Object.keys(obj).forEach((key) => {
+    if (!keysToIgnore.includes(key)) {
+      filteredObject[key] = obj[key];
+    }
+  });
+  return filteredObject;
+}
+
+// Nova função para extrair valores de caminhos aninhados
+export function getNestedValue(obj: any, path: string): any {
+  return path.split('.').reduce((current, key) => {
+    // Lidar com arrays como attributes[0]
+    if (key.includes('[') && key.includes(']')) {
+      const [arrayKey, indexStr] = key.split('[');
+      const index = parseInt(indexStr.replace(']', ''));
+      return current?.[arrayKey]?.[index];
+    }
+    return current?.[key];
+  }, obj);
+}
+
+// Nova função melhorada para filtrar com caminhos aninhados
+export function extractFields(data: any[], fieldsMap: Record<string, string>): any[] {
+  return data.map(item => {
+    const extracted: any = {};
+    
+    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
+export function debugObjectStructure(obj: any, maxDepth: number = 3, currentDepth: number = 0): void {
+  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
+export function resolveReferences(data: any, included: any[]): any {
+  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: any): any {
+    if (Array.isArray(obj)) {
+      return obj.map(item => resolveObject(item));
+    }
+    
+    if (obj && typeof obj === 'object') {
+      const resolved: any = {};
+      
+      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
+export function extractDataWithReferences(
+  elements: string[], 
+  included: any[], 
+  fieldsMap?: Record<string, string>
+): any[] {
+  // 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
+export function debugResolvedStructure(
+  elements: string[], 
+  included: any[], 
+  maxDepth: number = 2
+): void {
+  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
+export function extractFieldsFromIncluded(
+  included: any[], 
+  fields: string[]
+): Record<string, any>[] {
+  return included
+    .filter(item => fields.some(field => item[field] !== undefined))
+    .map(item => {
+      const extracted: any = { 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
+export function mergeExtraFields(
+  mainData: any[],
+  extraData: Record<string, any>[],
+  matchKey: string = 'companyUrn'
+): any[] {
+  return mainData.map(item => {
+    const extraItem = extraData.find(extra => 
+      item[matchKey] && extra.entityUrn === item[matchKey]
+    );
+    
+    if (extraItem) {
+      const { entityUrn, ...extraFields } = extraItem;
+      return { ...item, ...extraFields };
+    }
+    
+    return item;
+  });
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "ES6",
+    "module": "CommonJS",
+    "declaration": true,
+    "outDir": "./lib",
+    "strict": true
+  },
+  "include": ["src/**/*"]
+}