553 lines
20 KiB
JavaScript
553 lines
20 KiB
JavaScript
/**
|
|
* Twitch provider using Helix API.
|
|
*
|
|
* Search mixte façon directory Twitch (category/: lives + videos + clips) :
|
|
* - chaînes via /helix/search/channels (type 'channel' hors-ligne, 'live' en direct)
|
|
* - lives via /helix/streams enrichis (viewer_count, game_name, started_at)
|
|
* - VODs via /helix/videos par broadcaster (+ par game_id quand la requête
|
|
* matche une catégorie Twitch, ex. "sports")
|
|
* - clips via /helix/clips par broadcaster (+ par game_id le cas échéant)
|
|
*
|
|
* Token applicatif caché process-wide + retries (cf. historique).
|
|
*/
|
|
|
|
let cachedToken = null; // { token, clientId, expiresAtMs }
|
|
|
|
function sleep(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
async function fetchWithTimeout(url, options = {}, timeoutMs = 10_000) {
|
|
const controller = new AbortController();
|
|
const tid = setTimeout(() => controller.abort(), timeoutMs);
|
|
try {
|
|
return await fetch(url, { ...options, signal: controller.signal });
|
|
} finally {
|
|
clearTimeout(tid);
|
|
}
|
|
}
|
|
|
|
async function getAppAccessToken(force = false) {
|
|
const clientId = process.env.TWITCH_CLIENT_ID;
|
|
const clientSecret = process.env.TWITCH_CLIENT_SECRET;
|
|
if (!clientId || !clientSecret) {
|
|
const err = new Error('twitch_not_configured: TWITCH_CLIENT_ID / TWITCH_CLIENT_SECRET missing');
|
|
err.code = 'NOT_CONFIGURED';
|
|
throw err;
|
|
}
|
|
if (!force && cachedToken && Date.now() < cachedToken.expiresAtMs) {
|
|
return cachedToken;
|
|
}
|
|
|
|
let lastErr = null;
|
|
for (let attempt = 0; attempt < 3; attempt++) {
|
|
try {
|
|
const authResponse = await fetchWithTimeout('https://id.twitch.tv/oauth2/token', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
|
|
body: new URLSearchParams({
|
|
client_id: clientId,
|
|
client_secret: clientSecret,
|
|
grant_type: 'client_credentials',
|
|
}),
|
|
});
|
|
if (!authResponse.ok) {
|
|
if (authResponse.status === 400 || authResponse.status === 401 || authResponse.status === 403) {
|
|
throw Object.assign(new Error(`twitch_auth_rejected_${authResponse.status}`), { code: 'AUTH_REJECTED' });
|
|
}
|
|
throw new Error(`twitch_auth_error_${authResponse.status}`);
|
|
}
|
|
const { access_token, expires_in } = await authResponse.json();
|
|
if (!access_token) throw new Error('twitch_auth_no_token');
|
|
cachedToken = {
|
|
token: access_token,
|
|
clientId,
|
|
expiresAtMs: Date.now() + Math.max(3600, Number(expires_in || 3600) - 86_400) * 1000,
|
|
};
|
|
return cachedToken;
|
|
} catch (e) {
|
|
lastErr = e;
|
|
if (e && e.code === 'AUTH_REJECTED') throw e;
|
|
if (attempt < 2) await sleep(400 * (attempt + 1));
|
|
}
|
|
}
|
|
throw lastErr || new Error('twitch_auth_failed');
|
|
}
|
|
|
|
function helixHeaders(token, clientId) {
|
|
return { 'Client-ID': clientId, 'Authorization': `Bearer ${token}` };
|
|
}
|
|
|
|
/** GET Helix avec retry + refresh token sur 401. Retourne le JSON décodé. */
|
|
async function helixGet(path, params, auth, { retries = 2 } = {}) {
|
|
let { token, clientId } = auth;
|
|
let lastErr = null;
|
|
for (let attempt = 0; attempt <= retries; attempt++) {
|
|
try {
|
|
const qs = params ? `?${params.toString()}` : '';
|
|
const resp = await fetchWithTimeout(`https://api.twitch.tv/helix${path}${qs}`, {
|
|
headers: helixHeaders(token, clientId),
|
|
});
|
|
if (resp.status === 401 && attempt < retries) {
|
|
const fresh = await getAppAccessToken(true);
|
|
token = fresh.token;
|
|
clientId = fresh.clientId;
|
|
auth.token = token;
|
|
auth.clientId = clientId;
|
|
continue;
|
|
}
|
|
if (!resp.ok) throw new Error(`twitch_api_error_${resp.status}`);
|
|
return await resp.json();
|
|
} catch (e) {
|
|
lastErr = e;
|
|
if (attempt < retries) await sleep(350 * (attempt + 1));
|
|
}
|
|
}
|
|
throw lastErr || new Error('twitch_api_failed');
|
|
}
|
|
|
|
function thumbStream(raw, w = 640, h = 360) {
|
|
const s = String(raw || '');
|
|
if (!s) return 'https://static-cdn.jtvnw.net/ttv-static/404_preview-640x360.jpg';
|
|
return s.replace('{width}x{height}', `${w}x${h}`).replace('{width}', String(w)).replace('{height}', String(h));
|
|
}
|
|
|
|
function thumbVod(raw) {
|
|
const s = String(raw || '');
|
|
if (!s) return undefined;
|
|
// VODs: motif "%{width}x%{height}"
|
|
return s.replace('%{width}', '640').replace('%{height}', '360');
|
|
}
|
|
|
|
function parseTwitchDurationToSeconds(raw) {
|
|
// Formats Helix videos : "2h13m5s" / "13m5s" / "45s"
|
|
const s = String(raw || '').trim();
|
|
if (!s) return 0;
|
|
if (/^\d+(\.\d+)?$/.test(s)) return Math.round(Number(s));
|
|
let total = 0;
|
|
const h = /(\d+)h/.exec(s);
|
|
const m = /(\d+)m/.exec(s);
|
|
const sec = /(\d+)s/.exec(s);
|
|
if (h) total += Number(h[1]) * 3600;
|
|
if (m) total += Number(m[1]) * 60;
|
|
if (sec) total += Number(sec[1]);
|
|
return total;
|
|
}
|
|
|
|
function mapChannel(item) {
|
|
const login = item.broadcaster_login || item.user_login || undefined;
|
|
const live = Boolean(item.is_live);
|
|
const thumb = String(item.thumbnail_url || '');
|
|
const avatar = thumb || undefined;
|
|
return {
|
|
title: item.title || item.display_name || login || '',
|
|
id: item.id,
|
|
url: login ? `https://www.twitch.tv/${login}` : undefined,
|
|
thumbnail: thumb || undefined,
|
|
uploaderName: item.display_name || item.broadcaster_name || undefined,
|
|
channelId: item.id || undefined,
|
|
channelHandle: login,
|
|
channelExternalId: login,
|
|
uploaderAvatar: avatar,
|
|
type: live ? 'live' : 'channel',
|
|
isLive: live,
|
|
views: undefined,
|
|
publishedAt: item.started_at || undefined,
|
|
game: item.game_name || item.game || undefined,
|
|
};
|
|
}
|
|
|
|
function mapStream(s) {
|
|
const login = s.user_login || s.broadcaster_login || undefined;
|
|
return {
|
|
title: s.title || s.user_name || login || '',
|
|
// id = login : le player embed une chaîne via ?channel=<login>
|
|
id: login || s.id,
|
|
url: login ? `https://www.twitch.tv/${login}` : undefined,
|
|
thumbnail: thumbStream(s.thumbnail_url, 640, 360),
|
|
uploaderName: s.user_name || undefined,
|
|
channelId: s.user_id || undefined,
|
|
channelHandle: login,
|
|
channelExternalId: login,
|
|
uploaderAvatar: thumbStream(s.thumbnail_url, 70, 70),
|
|
type: 'live',
|
|
isLive: true,
|
|
views: typeof s.viewer_count === 'number' ? s.viewer_count : undefined,
|
|
publishedAt: s.started_at || undefined,
|
|
game: s.game_name || undefined,
|
|
language: s.language || undefined,
|
|
};
|
|
}
|
|
|
|
function mapVod(v) {
|
|
const login = v.user_login || v.broadcaster_login || undefined;
|
|
return {
|
|
title: v.title || '',
|
|
id: v.id,
|
|
url: v.url || (v.id ? `https://www.twitch.tv/videos/${v.id}` : undefined),
|
|
thumbnail: thumbVod(v.thumbnail_url),
|
|
uploaderName: v.user_name || v.broadcaster_name || undefined,
|
|
channelId: v.user_id || undefined,
|
|
channelHandle: login,
|
|
channelExternalId: login,
|
|
uploaderAvatar: undefined,
|
|
type: 'video',
|
|
kind: 'vod',
|
|
isLive: false,
|
|
duration: parseTwitchDurationToSeconds(v.duration),
|
|
views: typeof v.view_count === 'number' ? v.view_count : undefined,
|
|
publishedAt: v.created_at || v.published_at || undefined,
|
|
game: v.game_name || undefined,
|
|
language: v.language || undefined,
|
|
};
|
|
}
|
|
|
|
function mapClip(c) {
|
|
return {
|
|
title: c.title || '',
|
|
id: c.id,
|
|
url: c.url || `https://clips.twitch.tv/${c.id}`,
|
|
thumbnail: thumbVod(c.thumbnail_url),
|
|
uploaderName: c.broadcaster_name || c.creator_name || undefined,
|
|
channelId: c.broadcaster_id || undefined,
|
|
channelHandle: undefined,
|
|
channelExternalId: undefined,
|
|
uploaderAvatar: undefined,
|
|
type: 'video',
|
|
kind: 'clip',
|
|
isLive: false,
|
|
duration: typeof c.duration === 'number' ? Math.round(c.duration) : Number(c.duration || 0) || undefined,
|
|
views: typeof c.view_count === 'number' ? c.view_count : undefined,
|
|
publishedAt: c.created_at || undefined,
|
|
game: undefined,
|
|
language: c.language || undefined,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Mots-clés unitaires exploitables par Helix : /search/channels et
|
|
* /search/categories ne matchent que des noms proches, jamais de longues
|
|
* phrases multi-mots (ex. "cooking food Food Cooking Recipe").
|
|
*/
|
|
function twitchKeywords(q, max = 3) {
|
|
const words = String(q || '')
|
|
.toLowerCase()
|
|
.split(/[^a-z0-9à-ÿ]+/i)
|
|
.map((w) => w.trim())
|
|
.filter((w) => w.length >= 3);
|
|
const seen = new Set();
|
|
const out = [];
|
|
for (const w of words) {
|
|
if (seen.has(w)) continue;
|
|
seen.add(w);
|
|
out.push(w);
|
|
if (out.length >= max) break;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/** Catégorie Twitch la plus pertinente pour une requête (ex. "sports" -> Sports). */
|
|
async function findCategoryId(q, auth) {
|
|
const attempts = [String(q || '').trim(), ...twitchKeywords(q, 3)].filter(Boolean).slice(0, 4);
|
|
// Déduplique en conservant l'ordre (requête complète d'abord).
|
|
const seen = new Set();
|
|
const ordered = attempts.filter((a) => {
|
|
const k = String(a).toLowerCase();
|
|
if (seen.has(k)) return false;
|
|
seen.add(k);
|
|
return true;
|
|
});
|
|
for (const attempt of ordered) {
|
|
try {
|
|
const data = await helixGet('/search/categories', new URLSearchParams({ query: attempt, first: '5' }), auth, { retries: 1 });
|
|
const list = Array.isArray(data?.data) ? data.data : [];
|
|
if (!list.length) continue;
|
|
const needle = String(attempt || '').trim().toLowerCase();
|
|
const exact = list.find((c) => String(c?.name || '').toLowerCase() === needle);
|
|
const best = exact || list[0];
|
|
if (best?.id) return best.id;
|
|
} catch {
|
|
// Essaie le mot-clé suivant.
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** Recherche de chaînes sur plusieurs mots-clés (fusion dédupliquée). */
|
|
async function searchChannelsMulti(queries, first, auth, after = '') {
|
|
const seen = new Set();
|
|
const merged = [];
|
|
let cursor = null;
|
|
for (let i = 0; i < queries.length; i++) {
|
|
try {
|
|
const params = new URLSearchParams({ query: queries[i], first: String(first) });
|
|
if (i === 0 && after) params.set('after', after);
|
|
const data = await helixGet('/search/channels', params, auth, { retries: 1 });
|
|
const list = Array.isArray(data?.data) ? data.data : [];
|
|
if (i === 0) cursor = data?.pagination?.cursor || null;
|
|
else if (!cursor && data?.pagination?.cursor) cursor = data.pagination.cursor;
|
|
for (const c of list) {
|
|
const key = String(c?.id || '');
|
|
if (!key || seen.has(key)) continue;
|
|
seen.add(key);
|
|
merged.push(c);
|
|
}
|
|
// Assez de candidats : inutile de spammer Helix.
|
|
if (merged.length >= 10) break;
|
|
} catch {}
|
|
}
|
|
return { channels: merged, cursor };
|
|
}
|
|
|
|
const handler = {
|
|
id: 'tw',
|
|
label: 'Twitch',
|
|
/**
|
|
* Recherche mixte : lives + VODs + clips + chaînes.
|
|
* @param {string} q
|
|
* @param {{ limit: number, page?: number, sort?: string }} opts
|
|
*/
|
|
async search(q, opts) {
|
|
const { limit = 24, page = 1, sort = 'relevance' } = opts || {};
|
|
const query = String(q || '').trim();
|
|
if (!query) return [];
|
|
|
|
try {
|
|
const appToken = await getAppAccessToken();
|
|
const auth = { token: appToken.token, clientId: appToken.clientId };
|
|
const perPage = Math.min(Math.max(1, Number(limit || 24)), 50);
|
|
const targetPage = Math.max(1, Number(page || 1));
|
|
|
|
// 1) Chaînes (paginées : la pagination repose sur ce curseur).
|
|
// Helix ne matche pas les longues phrases : on cherche la requête
|
|
// complète puis chaque mot-clé (ex. "cooking" pour "cooking food...").
|
|
const channelQueries = [query, ...twitchKeywords(query, 3).filter((k) => k !== query.toLowerCase())].slice(0, 4);
|
|
let after = '';
|
|
let currentPage = 1;
|
|
let channelsData = [];
|
|
let channelsCursor = null;
|
|
while (currentPage <= targetPage) {
|
|
const { channels, cursor } = await searchChannelsMulti(
|
|
channelQueries,
|
|
Math.min(20, perPage),
|
|
auth,
|
|
after,
|
|
);
|
|
// Alternative brute si Helix a tout filtré : top streams comme base de chaînes.
|
|
let list = channels;
|
|
let cur = cursor;
|
|
if (!list.length && currentPage === 1 && targetPage === 1) {
|
|
try {
|
|
const top = await helixGet('/streams', new URLSearchParams({ first: '20' }), auth, { retries: 1 });
|
|
const streams = Array.isArray(top?.data) ? top.data : [];
|
|
list = streams.map((s) => ({
|
|
id: s.user_id,
|
|
broadcaster_login: s.user_login,
|
|
user_login: s.user_login,
|
|
display_name: s.user_name,
|
|
is_live: true,
|
|
title: s.title,
|
|
thumbnail_url: s.thumbnail_url,
|
|
started_at: s.started_at,
|
|
game_name: s.game_name,
|
|
}));
|
|
cur = top?.pagination?.cursor || null;
|
|
} catch {}
|
|
}
|
|
channelsCursor = cur;
|
|
if (currentPage === targetPage) {
|
|
channelsData = list;
|
|
break;
|
|
}
|
|
if (!channelsCursor) {
|
|
channelsData = [];
|
|
break;
|
|
}
|
|
after = String(channelsCursor);
|
|
currentPage++;
|
|
}
|
|
|
|
const liveChannels = channelsData.filter((c) => c?.is_live);
|
|
const userIds = [...new Set(channelsData.map((c) => c?.id).filter(Boolean))].slice(0, 8);
|
|
const logins = [...new Set(channelsData.map((c) => c?.broadcaster_login || c?.user_login).filter(Boolean))].slice(0, 20);
|
|
|
|
// 2) Catégorie éventuelle (thèmes génériques : sports, music...) + streams enrichis en parallèle.
|
|
const [categoryId, streamsByLogin] = await Promise.all([
|
|
targetPage === 1 ? findCategoryId(query, auth) : Promise.resolve(null),
|
|
(async () => {
|
|
if (!logins.length) return new Map();
|
|
try {
|
|
const params = new URLSearchParams();
|
|
logins.forEach((l) => params.append('user_login', l));
|
|
params.set('first', String(Math.min(100, logins.length)));
|
|
const data = await helixGet('/streams', params, auth, { retries: 1 });
|
|
const map = new Map();
|
|
for (const s of Array.isArray(data?.data) ? data.data : []) {
|
|
const key = String(s?.user_login || '').toLowerCase();
|
|
if (key) map.set(key, s);
|
|
}
|
|
return map;
|
|
} catch {
|
|
return new Map();
|
|
}
|
|
})(),
|
|
]);
|
|
|
|
// Lives : streams enrichis des chaînes live + top streams de la catégorie si dispo.
|
|
let lives = [];
|
|
for (const c of liveChannels) {
|
|
const login = String(c?.broadcaster_login || c?.user_login || '').toLowerCase();
|
|
const s = login ? streamsByLogin.get(login) : null;
|
|
if (s) lives.push(mapStream(s));
|
|
else lives.push(mapChannel(c));
|
|
}
|
|
if (targetPage === 1 && categoryId) {
|
|
try {
|
|
const data = await helixGet('/streams', new URLSearchParams({ game_id: String(categoryId), first: '12' }), auth, { retries: 1 });
|
|
const extra = (Array.isArray(data?.data) ? data.data : []).map(mapStream);
|
|
const seen = new Set(lives.map((v) => String(v.id).toLowerCase()));
|
|
for (const v of extra) {
|
|
if (!seen.has(String(v.id).toLowerCase())) {
|
|
seen.add(String(v.id).toLowerCase());
|
|
lives.push(v);
|
|
}
|
|
}
|
|
} catch {}
|
|
}
|
|
|
|
// Tri des lives : vues décroissantes quand sort=views, sinon pertinence (ordre Helix).
|
|
if (sort === 'views') lives = [...lives].sort((a, b) => Number(b.views || 0) - Number(a.views || 0));
|
|
|
|
// 3) VODs : par broadcaster (pertinence requête) + par jeu (thèmes).
|
|
const vodSort = sort === 'views' ? 'views' : sort === 'date' ? 'time' : 'trending';
|
|
let vods = [];
|
|
try {
|
|
const perUser = userIds.slice(0, 6);
|
|
const lists = await Promise.all(
|
|
perUser.map(async (uid) => {
|
|
try {
|
|
const data = await helixGet(
|
|
'/videos',
|
|
new URLSearchParams({ user_id: String(uid), first: '4', type: 'archive', sort: vodSort }),
|
|
auth,
|
|
{ retries: 1 },
|
|
);
|
|
return Array.isArray(data?.data) ? data.data : [];
|
|
} catch {
|
|
return [];
|
|
}
|
|
}),
|
|
);
|
|
vods = lists.flat().map(mapVod);
|
|
if (targetPage === 1 && categoryId) {
|
|
try {
|
|
const data = await helixGet(
|
|
'/videos',
|
|
new URLSearchParams({ game_id: String(categoryId), first: '12', sort: vodSort }),
|
|
auth,
|
|
{ retries: 1 },
|
|
);
|
|
const extra = (Array.isArray(data?.data) ? data.data : []).map(mapVod);
|
|
const seen = new Set(vods.map((v) => String(v.id)));
|
|
for (const v of extra) {
|
|
if (!seen.has(String(v.id))) {
|
|
seen.add(String(v.id));
|
|
vods.push(v);
|
|
}
|
|
}
|
|
} catch {}
|
|
}
|
|
} catch {}
|
|
|
|
// 4) Clips : par broadcaster (30 derniers jours) + par jeu.
|
|
let clips = [];
|
|
try {
|
|
const since = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
|
|
const perUser = userIds.slice(0, 5);
|
|
const lists = await Promise.all(
|
|
perUser.map(async (uid) => {
|
|
try {
|
|
const data = await helixGet(
|
|
'/clips',
|
|
new URLSearchParams({ broadcaster_id: String(uid), first: '3', started_at: since }),
|
|
auth,
|
|
{ retries: 1 },
|
|
);
|
|
return Array.isArray(data?.data) ? data.data : [];
|
|
} catch {
|
|
return [];
|
|
}
|
|
}),
|
|
);
|
|
clips = lists.flat().map(mapClip);
|
|
if (targetPage === 1 && categoryId) {
|
|
try {
|
|
const data = await helixGet(
|
|
'/clips',
|
|
new URLSearchParams({ game_id: String(categoryId), first: '10', started_at: since }),
|
|
auth,
|
|
{ retries: 1 },
|
|
);
|
|
const extra = (Array.isArray(data?.data) ? data.data : []).map(mapClip);
|
|
const seen = new Set(clips.map((v) => String(v.id)));
|
|
for (const v of extra) {
|
|
if (!seen.has(String(v.id))) {
|
|
seen.add(String(v.id));
|
|
clips.push(v);
|
|
}
|
|
}
|
|
} catch {}
|
|
}
|
|
} catch {}
|
|
|
|
// 5) Assemblage façon directory : lives, vidéos, clips, chaînes (hors-ligne).
|
|
const channels = channelsData.map(mapChannel);
|
|
const offlineChannels = channels.filter((c) => c.type === 'channel');
|
|
const liveFallbacks = channels.filter((c) => c.type === 'live' && !lives.some((l) => String(l.id).toLowerCase() === String(c.channelHandle || c.id).toLowerCase()));
|
|
const allLives = [...lives, ...liveFallbacks];
|
|
|
|
const byDateDesc = (a, b) => Date.parse(b.publishedAt || '') - Date.parse(a.publishedAt || '');
|
|
const byViewsDesc = (a, b) => Number(b.views || 0) - Number(a.views || 0);
|
|
if (sort === 'date') {
|
|
vods = [...vods].sort(byDateDesc);
|
|
clips = [...clips].sort(byDateDesc);
|
|
} else if (sort === 'views') {
|
|
vods = [...vods].sort(byViewsDesc);
|
|
clips = [...clips].sort(byViewsDesc);
|
|
}
|
|
|
|
// Budgets : on remplit chaque section sans noyer les autres.
|
|
const takeLives = allLives.slice(0, Math.max(4, Math.ceil(perPage / 3)));
|
|
const takeVods = vods.slice(0, Math.max(6, Math.ceil(perPage / 2)));
|
|
const takeClips = clips.slice(0, Math.max(4, Math.ceil(perPage / 3)));
|
|
const takeChannels = offlineChannels.slice(0, Math.max(4, Math.ceil(perPage / 3)));
|
|
|
|
const merged = [...takeLives, ...takeVods, ...takeClips, ...takeChannels];
|
|
// Déduplique par id (les lives login vs chaînes id numérique ne collisionnent pas).
|
|
const seen = new Set();
|
|
const out = [];
|
|
for (const item of merged) {
|
|
const key = `${item.type}:${String(item.id)}`;
|
|
if (seen.has(key)) continue;
|
|
seen.add(key);
|
|
out.push(item);
|
|
}
|
|
// Filet de sécurité : ne jamais renvoyer une page thème vide quand
|
|
// Twitch est configuré (thèmes sans chaîne ni catégorie correspondante).
|
|
if (!out.length && targetPage === 1) {
|
|
try {
|
|
const top = await helixGet('/streams', new URLSearchParams({ first: String(Math.min(20, perPage)) }), auth, { retries: 1 });
|
|
const fallback = (Array.isArray(top?.data) ? top.data : []).map(mapStream);
|
|
return fallback;
|
|
} catch {}
|
|
}
|
|
return out;
|
|
} catch (error) {
|
|
console.error('Twitch search error:', error?.message || error);
|
|
return [];
|
|
}
|
|
},
|
|
};
|
|
|
|
export default handler;
|