mirror of
https://github.com/Drop-OSS/drop.git
synced 2025-11-09 20:12:10 +10:00
414 lines
11 KiB
TypeScript
414 lines
11 KiB
TypeScript
import type { Developer, Publisher } from "@prisma/client";
|
|
import { MetadataSource } from "@prisma/client";
|
|
import type { MetadataProvider } from ".";
|
|
import { MissingMetadataProviderConfig } from ".";
|
|
import type {
|
|
GameMetadataSearchResult,
|
|
_FetchGameMetadataParams,
|
|
GameMetadata,
|
|
_FetchPublisherMetadataParams,
|
|
PublisherMetadata,
|
|
_FetchDeveloperMetadataParams,
|
|
DeveloperMetadata,
|
|
} from "./types";
|
|
import type { AxiosRequestConfig } from "axios";
|
|
import axios from "axios";
|
|
import { DateTime } from "luxon";
|
|
|
|
type IGDBID = number;
|
|
|
|
interface TwitchAuthResponse {
|
|
access_token: string;
|
|
expires_in: number;
|
|
token_type: string; // likely 'bearer'
|
|
}
|
|
|
|
interface IGDBErrorResponse {
|
|
title: string;
|
|
status: number;
|
|
cause: string;
|
|
}
|
|
|
|
interface IGDBItem {
|
|
id: IGDBID;
|
|
}
|
|
|
|
// denotes role a company had in a game
|
|
interface IGDBInvolvedCompany extends IGDBItem {
|
|
company: IGDBID;
|
|
game: IGDBID;
|
|
|
|
developer: boolean;
|
|
porting: boolean;
|
|
publisher: boolean;
|
|
supporting: boolean;
|
|
|
|
created_at: number;
|
|
updated_at: number;
|
|
}
|
|
|
|
interface IGDBCompany extends IGDBItem {
|
|
name: string;
|
|
country: number; // ISO 3166-1 country code
|
|
description: string;
|
|
logo: IGDBID;
|
|
parent: IGDBID;
|
|
slug: string;
|
|
start_date: number;
|
|
status: IGDBID;
|
|
websites: IGDBID[];
|
|
}
|
|
|
|
interface IGDBCompanyWebsite extends IGDBItem {
|
|
trusted: boolean;
|
|
url: string;
|
|
}
|
|
|
|
interface IGDBCover extends IGDBItem {
|
|
url: string;
|
|
}
|
|
|
|
interface IGDBSearchStub extends IGDBItem {
|
|
name: string;
|
|
cover: IGDBID;
|
|
first_release_date: number; // unix timestamp
|
|
summary: string;
|
|
}
|
|
|
|
// https://api-docs.igdb.com/?shell#game
|
|
interface IGDBGameFull extends IGDBSearchStub {
|
|
age_ratings?: IGDBID[];
|
|
aggregated_rating?: number;
|
|
aggregated_rating_count?: number;
|
|
alternative_names?: IGDBID[];
|
|
artworks?: IGDBID[];
|
|
bundles?: IGDBID[];
|
|
checksum?: string;
|
|
collections?: IGDBID[];
|
|
created_at: number; // unix timestamp
|
|
dlcs?: IGDBID[];
|
|
expanded_games?: IGDBID[];
|
|
expansions?: IGDBID[];
|
|
external_games?: IGDBID[];
|
|
forks?: IGDBID[];
|
|
franchise?: IGDBID;
|
|
franchises?: IGDBID[];
|
|
game_engines?: IGDBID[];
|
|
game_localizations?: IGDBID[];
|
|
game_modes?: IGDBID[];
|
|
game_status?: IGDBID;
|
|
game_type?: IGDBID;
|
|
genres?: IGDBID[];
|
|
hypes?: number;
|
|
involved_companies?: IGDBID[];
|
|
keywords?: IGDBID[];
|
|
language_supports?: IGDBID[];
|
|
multiplayer_modes?: IGDBID[];
|
|
platforms?: IGDBID[];
|
|
player_perspectives?: IGDBID[];
|
|
ports?: IGDBID[];
|
|
rating?: number;
|
|
rating_count?: number;
|
|
release_dates?: IGDBID[];
|
|
remakes?: IGDBID[];
|
|
remasters?: IGDBID[];
|
|
screenshots?: IGDBID[];
|
|
similar_games?: IGDBID[];
|
|
slug: string;
|
|
standalone_expansions?: IGDBID[];
|
|
storyline?: string;
|
|
tags?: IGDBID[];
|
|
themes?: IGDBID[];
|
|
total_rating?: number;
|
|
total_rating_count?: number;
|
|
updated_at: number;
|
|
url: string;
|
|
version_parent?: IGDBID;
|
|
version_title?: string;
|
|
videos?: IGDBID[];
|
|
websites?: IGDBID[];
|
|
}
|
|
|
|
// Api Docs: https://api-docs.igdb.com/
|
|
export class IGDBProvider implements MetadataProvider {
|
|
private clientId: string;
|
|
private clientSecret: string;
|
|
private accessToken: string;
|
|
private accessTokenExpiry: DateTime;
|
|
|
|
constructor() {
|
|
const client_id = process.env.IGDB_CLIENT_ID;
|
|
if (!client_id)
|
|
throw new MissingMetadataProviderConfig("IGDB_CLIENT_ID", this.name());
|
|
const client_secret = process.env.IGDB_CLIENT_SECRET;
|
|
if (!client_secret)
|
|
throw new MissingMetadataProviderConfig(
|
|
"IGDB_CLIENT_SECRET",
|
|
this.name(),
|
|
);
|
|
|
|
this.clientId = client_id;
|
|
this.clientSecret = client_secret;
|
|
|
|
this.accessToken = "";
|
|
this.accessTokenExpiry = DateTime.now().minus({
|
|
year: 1,
|
|
});
|
|
}
|
|
|
|
private async authWithTwitch() {
|
|
console.log("authorizing with twitch");
|
|
const params = new URLSearchParams({
|
|
client_id: this.clientId,
|
|
client_secret: this.clientSecret,
|
|
grant_type: "client_credentials",
|
|
});
|
|
|
|
const response = await axios.request<TwitchAuthResponse>({
|
|
url: `https://id.twitch.tv/oauth2/token?${params.toString()}`,
|
|
baseURL: "",
|
|
method: "POST",
|
|
});
|
|
|
|
this.accessToken = response.data.access_token;
|
|
this.accessTokenExpiry = DateTime.now().plus({
|
|
seconds: response.data.expires_in,
|
|
});
|
|
}
|
|
|
|
private async refreshCredentials() {
|
|
const futureTime = DateTime.now().plus({
|
|
day: 1,
|
|
});
|
|
|
|
// if the token expires in less than a day
|
|
if (this.accessTokenExpiry < futureTime) await this.authWithTwitch();
|
|
}
|
|
|
|
private async request<T extends object>(
|
|
resource: string,
|
|
body: string,
|
|
options?: AxiosRequestConfig,
|
|
) {
|
|
await this.refreshCredentials();
|
|
|
|
// prevent calling api before auth is complete
|
|
if (this.accessToken.length <= 0)
|
|
throw new Error(
|
|
"IGDB either failed to authenticate, or has not done so yet",
|
|
);
|
|
|
|
const finalURL = `https://api.igdb.com/v4/${resource}`;
|
|
|
|
const overlay: AxiosRequestConfig = {
|
|
url: finalURL,
|
|
baseURL: "",
|
|
method: "POST",
|
|
data: body,
|
|
headers: {
|
|
Accept: "application/json",
|
|
"Client-ID": this.clientId,
|
|
Authorization: `Bearer ${this.accessToken}`,
|
|
"content-type": "text/plain",
|
|
},
|
|
};
|
|
const response = await axios.request<T[] | IGDBErrorResponse[]>(
|
|
Object.assign({}, options, overlay),
|
|
);
|
|
|
|
if (response.status !== 200) {
|
|
let cause = "";
|
|
|
|
response.data.forEach((item) => {
|
|
if ("cause" in item) cause = item.cause;
|
|
});
|
|
|
|
throw new Error(
|
|
`Error in igdb \nStatus Code: ${response.status} \nCause: ${cause}`,
|
|
);
|
|
}
|
|
|
|
// should not have an error object if the status code is 200
|
|
return <T[]>response.data;
|
|
}
|
|
|
|
private async _getMediaInternal(mediaID: IGDBID, type: string) {
|
|
const body = `where id = ${mediaID}; fields url;`;
|
|
const response = await this.request<IGDBCover>(type, body);
|
|
|
|
let result = "";
|
|
|
|
response.forEach((cover) => {
|
|
if (cover.url.startsWith("https:")) {
|
|
result = cover.url;
|
|
} else {
|
|
// twitch *sometimes* provides it in the format "//images.igdb.com"
|
|
result = `https:${cover.url}`;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
private async getCoverURL(id: IGDBID) {
|
|
return await this._getMediaInternal(id, "covers");
|
|
}
|
|
|
|
private async getArtworkURL(id: IGDBID) {
|
|
return await this._getMediaInternal(id, "artworks");
|
|
}
|
|
|
|
private async getCompanyLogoURl(id: IGDBID) {
|
|
return await this._getMediaInternal(id, "company_logos");
|
|
}
|
|
|
|
private trimMessage(msg: string, len: number) {
|
|
return msg.length > len ? msg.substring(0, 280) + "..." : msg;
|
|
}
|
|
|
|
id() {
|
|
return "igdb";
|
|
}
|
|
name() {
|
|
return "IGDB";
|
|
}
|
|
source() {
|
|
return MetadataSource.IGDB;
|
|
}
|
|
|
|
async search(query: string): Promise<GameMetadataSearchResult[]> {
|
|
const body = `search "${query}"; fields name,cover,first_release_date,summary; limit 3;`;
|
|
const response = await this.request<IGDBSearchStub>("games", body);
|
|
|
|
const results: GameMetadataSearchResult[] = [];
|
|
for (let i = 0; i < response.length; i++) {
|
|
results.push({
|
|
id: "" + response[i].id,
|
|
name: response[i].name,
|
|
icon: await this.getCoverURL(response[i].cover),
|
|
description: response[i].summary,
|
|
year: DateTime.fromSeconds(response[i].first_release_date).year,
|
|
});
|
|
}
|
|
|
|
return results;
|
|
}
|
|
async fetchGame({
|
|
id,
|
|
publisher,
|
|
developer,
|
|
createObject,
|
|
}: _FetchGameMetadataParams): Promise<GameMetadata> {
|
|
const body = `where id = ${id}; fields *;`;
|
|
const response = await this.request<IGDBGameFull>("games", body);
|
|
|
|
for (let i = 0; i < response.length; i++) {
|
|
const icon = createObject(await this.getCoverURL(response[i].cover));
|
|
let banner = "";
|
|
|
|
const images = [icon];
|
|
for (const art of response[i]?.artworks ?? []) {
|
|
// if banner not set
|
|
if (banner.length <= 0) {
|
|
banner = createObject(await this.getArtworkURL(art));
|
|
images.push(banner);
|
|
} else {
|
|
images.push(createObject(await this.getArtworkURL(art)));
|
|
}
|
|
}
|
|
|
|
const publishers: Publisher[] = [];
|
|
const developers: Developer[] = [];
|
|
for (const involvedCompany of response[i]?.involved_companies ?? []) {
|
|
// get details about the involved company
|
|
const involved_company_response =
|
|
await this.request<IGDBInvolvedCompany>(
|
|
"involved_companies",
|
|
`where id = ${involvedCompany}; fields *;`,
|
|
);
|
|
for (const foundInvolved of involved_company_response) {
|
|
// now we need to get the actual company so we can get the name
|
|
const findCompanyResponse = await this.request<
|
|
{ name: string } & IGDBItem
|
|
>("companies", `where id = ${foundInvolved.company}; fields name;`);
|
|
|
|
for (const company of findCompanyResponse) {
|
|
// if company was a dev or publisher
|
|
// CANNOT use else since a company can be both
|
|
if (foundInvolved.developer)
|
|
developers.push(await developer(company.name));
|
|
if (foundInvolved.publisher)
|
|
publishers.push(await publisher(company.name));
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
id: "" + response[i].id,
|
|
name: response[i].name,
|
|
shortDescription: this.trimMessage(response[i].summary, 280),
|
|
description: response[i].summary,
|
|
released: DateTime.fromSeconds(
|
|
response[i].first_release_date,
|
|
).toJSDate(),
|
|
|
|
reviewCount: response[i]?.total_rating_count ?? 0,
|
|
reviewRating: (response[i]?.total_rating ?? 0) / 100,
|
|
|
|
publishers: [],
|
|
developers: [],
|
|
|
|
icon,
|
|
bannerId: banner,
|
|
coverId: icon,
|
|
images,
|
|
};
|
|
}
|
|
|
|
throw new Error("No game found on igdb with that id");
|
|
}
|
|
async fetchPublisher({
|
|
query,
|
|
createObject,
|
|
}: _FetchPublisherMetadataParams): Promise<PublisherMetadata> {
|
|
const response = await this.request<IGDBCompany>(
|
|
"companies",
|
|
`where name = "${query}"; fields *; limit 1;`,
|
|
);
|
|
|
|
for (const company of response) {
|
|
const logo = createObject(await this.getCompanyLogoURl(company.logo));
|
|
|
|
let company_url = "";
|
|
for (const companySite of company.websites) {
|
|
const companySiteRes = await this.request<IGDBCompanyWebsite>(
|
|
"company_websites",
|
|
`where id = ${companySite}; fields *;`,
|
|
);
|
|
|
|
for (const site of companySiteRes) {
|
|
if (company_url.length <= 0) company_url = site.url;
|
|
}
|
|
}
|
|
const metadata: PublisherMetadata = {
|
|
id: "" + company.id,
|
|
name: company.name,
|
|
shortDescription: this.trimMessage(company.description, 280),
|
|
description: company.description,
|
|
website: company_url,
|
|
|
|
logo: logo,
|
|
banner: logo,
|
|
};
|
|
|
|
return metadata;
|
|
}
|
|
|
|
throw new Error("No results found");
|
|
}
|
|
async fetchDeveloper(
|
|
params: _FetchDeveloperMetadataParams,
|
|
): Promise<DeveloperMetadata> {
|
|
return await this.fetchPublisher(params);
|
|
}
|
|
}
|