import { NeopleDFClient } from 'neople-sdk-js';

const dfClient = new NeopleDFClient(process.env.NEOPLE_DF_API_KEY);

// 캐릭터 검색
const characters = await dfClient.searchCharacter('홍길동');

// 캐릭터 정보 조회
const character = await dfClient.getCharacter('cain', 'characterId');

// 캐릭터 장비 정보 조회
const equipment = await dfClient.getCharacterEquipment('cain', 'characterId');

import { NeopleCyphersClient } from 'neople-sdk-js';

const cyphersClient = new NeopleCyphersClient(process.env.NEOPLE_CYPHERS_API_KEY);

// 플레이어 검색
const players = await cyphersClient.searchPlayer('플레이어닉네임');

// 플레이어 정보 조회
const playerInfo = await cyphersClient.getPlayerInfo('playerId');

// 플레이어 매치 기록 조회
const matches = await cyphersClient.getPlayerMatches('playerId', { gameTypeId: 'rating' });

import express from 'express';
import { NeopleDFClient } from 'neople-sdk-js';

const app = express();
const dfClient = new NeopleDFClient(process.env.NEOPLE_DF_API_KEY);

app.get('/api/character/:name', async (req, res) => {
  try {
    const result = await dfClient.searchCharacter(req.params.name);
    res.json(result);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// app/api/character/[name]/route.ts
import { NeopleDFClient } from 'neople-sdk-js';

const dfClient = new NeopleDFClient(process.env.NEOPLE_DF_API_KEY);

export async function GET(
  request: Request,
  { params }: { params: { name: string } }
) {
  try {
    const result = await dfClient.searchCharacter(params.name);
    return Response.json(result);
  } catch (error) {
    return Response.json({ error: error.message }, { status: 500 });
  }
}

import { NeopleDFUrlBuilder } from 'neople-sdk-js';

const urlBuilder = new NeopleDFUrlBuilder(process.env.NEOPLE_DF_API_KEY);

// URL 생성
const characterUrl = urlBuilder.searchCharacter('홍길동', 'cain');
const equipmentUrl = urlBuilder.getCharacterEquipment('cain', 'characterId');
const auctionUrl = urlBuilder.searchAuction({ itemName: '해방무기', limit: 10 });

// 원하는 HTTP 클라이언트로 직접 호출
const response = await fetch(characterUrl);
const data = await response.json();

import { NeopleCyphersUrlBuilder } from 'neople-sdk-js';

const urlBuilder = new NeopleCyphersUrlBuilder(process.env.NEOPLE_CYPHERS_API_KEY);

// URL 생성
const playerUrl = urlBuilder.searchPlayer('플레이어닉네임');
const matchUrl = urlBuilder.getPlayerMatches('playerId', { gameTypeId: 'rating' });
const rankingUrl = urlBuilder.getOverallRanking({ limit: 10 });

// axios나 다른 HTTP 클라이언트 사용
const response = await axios.get(playerUrl);

const urls = urlBuilder.batch([
  builder => builder.searchCharacter('플레이어1'),
  builder => builder.searchCharacter('플레이어2'),
  builder => builder.searchAuction({ itemName: '무기' })
]);

// 여러 URL을 동시에 처리
const promises = urls.map(url => fetch(url));
const responses = await Promise.all(promises);

import { NeopleDFClient, FetchAdapter } from 'neople-sdk-js';

// 기본 어댑터 (내장 fetch 사용, 의존성 없음)
const client = new NeopleDFClient(process.env.NEOPLE_DF_API_KEY);

// 또는 명시적으로 FetchAdapter 사용
const clientWithFetch = new NeopleDFClient(
  process.env.NEOPLE_DF_API_KEY,
  new FetchAdapter()
);

// API 호출 예제 - 내부적으로 Node.js 내장 fetch 사용
const result = await client.searchCharacter('홍길동');
console.log(result);

import { NeopleDFClient, AxiosAdapter } from 'neople-sdk-js';
import axios from 'axios';

const client = new NeopleDFClient(
  process.env.NEOPLE_DF_API_KEY,
  new AxiosAdapter(axios.create({ 
    timeout: 5000,
    retry: 3 
  }))
);

// API 호출 예제
const result = await client.searchCharacter('홍길동');
console.log(result);

import { NeopleDFClient, NodeFetchAdapter } from 'neople-sdk-js';
import fetch from 'node-fetch';

const client = new NeopleDFClient(
  process.env.NEOPLE_DF_API_KEY,
  new NodeFetchAdapter(fetch)
);

// API 호출 예제
const result = await client.searchCharacter('홍길동');
console.log(result);

import { NeopleDFClient, GotAdapter } from 'neople-sdk-js';
import got from 'got';

const client = new NeopleDFClient(
  process.env.NEOPLE_DF_API_KEY,
  new GotAdapter(got.extend({
    timeout: { request: 5000 },
    retry: { limit: 2 }
  }))
);

// API 호출 예제
const result = await client.searchCharacter('홍길동');
console.log(result);

import { NeopleDFClient, NeopleApiError } from 'neople-sdk-js';

const client = new NeopleDFClient(process.env.NEOPLE_DF_API_KEY);

try {
  const result = await client.searchCharacter('존재하지않는캐릭터');
} catch (error) {
  if (error instanceof NeopleApiError) {
    console.log(`API 오류: ${error.status} - ${error.message}`);
    // error.response에서 원본 응답 데이터 확인 가능
  } else {
    console.log('네트워크 오류:', error.message);
  }
}

// FetchAdapter 사용 시
const fetchClient = new NeopleDFClient(apiKey, new FetchAdapter());

// AxiosAdapter 사용 시  
const axiosClient = new NeopleDFClient(apiKey, new AxiosAdapter(axios.create()));

// GotAdapter 사용 시
const gotClient = new NeopleDFClient(apiKey, new GotAdapter(got.extend()));

// 모든 클라이언트에서 동일한 에러 처리
[fetchClient, axiosClient, gotClient].forEach(async (client) => {
  try {
    await client.searchCharacter('잘못된요청');
  } catch (error) {
    if (error instanceof NeopleApiError) {
      // 어댑터와 관계없이 항상 동일한 에러 타입
      console.log(`상태 코드: ${error.status}`);
      console.log(`에러 메시지: ${error.message}`);
    }
  }
});