mhsf-dev/src/lib/api.ts

/**
 *   New API file for easier API access
 *   Could be used for a JavaScript library :eyes:
 *   @author DeveloLongScript
 */
//

const connector = (
	endpoint: string,
	options: { version: number; starting?: string },
) =>
	`${options.starting == undefined ? "/" : `${options.starting}/`}api/v${options.version}${endpoint}`;

export async function getMOTDFromServer(
	list: Array<{ server: string; motd: string }>,
): Promise<Array<{ server: string; motd: string }>> {
	const result = await fetch(connector("/motd", { version: 1 }), {
		body: JSON.stringify({ motd: list }),
		method: "POST",
		headers: {
			"Content-Type": "application/json",
		},
	});

	let json = await result.json();
	return json.result;
}

export async function getCommunityServerFavorites(
	server: string,
): Promise<number> {
	const result = await fetch(
		connector(`/favorites/${server}/community-favorites`, { version: 0 }),
		{
			method: "POST",
			headers: {
				"Content-Type": "application/json",
			},
		},
	);

	let json = await result.json();
	return json.result;
}

/** requires authentication */
export async function favoriteServer(server: string) {
	try {
		await fetch(
			connector(`/favorites/${server}/favorite-server`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
			},
		);
	} catch {
		throw Error("Not authenticated with a user.");
	}
}

/** requires authentication */
export async function isFavorited(server: string): Promise<boolean> {
	try {
		const response = await fetch(
			connector(`/favorites/${server}/favorited`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
			},
		);

		return (await response.json()).result;
	} catch {
		throw Error("Not authenticated with a user.");
	}
}

/** requires authentication */
export async function getAccountFavorites(): Promise<Array<string>> {
	try {
		const response = await fetch(
			connector(`/favorites/account-favorites`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
			},
		);

		return (await response.json()).result;
	} catch {
		throw Error("Not authenticated with a user.");
	}
}

/**
 *  currently not used in frontend yet
 */
export async function getHistoricalData(
	server: string,
	scopes: Array<"player_count" | "favorites" | "server" | "time">,
): Promise<
	Array<{
		player_count?: number;
		favorites?: number;
		server?: string;
		time?: number;
	}>
> {
	const response = await fetch(
		connector(`/history/${server}/get-historical-data`, { version: 0 }),
		{
			method: "POST",
			body: JSON.stringify({ scopes }),
			headers: {
				"Content-Type": "application/json",
			},
		},
	);

	return (await response.json()).data;
}

export async function getShortTermData(
	server: string,
	scopes: Array<"player_count" | "favorites" | "server" | "date">,
): Promise<
	Array<{
		player_count?: number;
		favorites?: number;
		server?: string;
		time?: number;
	}>
> {
	const response = await fetch(
		connector(`/history/${server}/get-short-term-data`, { version: 0 }),
		{
			method: "POST",
			body: JSON.stringify({ scopes }),
			headers: {
				"Content-Type": "application/json",
			},
		},
	);

	return (await response.json()).data;
}

export async function getMetaShortTerm(
	scopes: Array<"total_players" | "total_servers" | "date">,
): Promise<
	Array<{
		total_players?: number;
		total_servers?: number;
		unix?: number;
	}>
> {
	const response = await fetch(
		connector(`/history/meta-short-term-data`, { version: 0 }),
		{
			method: "POST",
			body: JSON.stringify({ scopes }),
			headers: {
				"Content-Type": "application/json",
			},
		},
	);

	return (await response.json()).data;
}

/** requires authentication */
export async function linkMCAccount(code: string): Promise<string | undefined> {
	try {
		const response = await fetch(
			connector(`/account-linking/claim-account-code`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
				body: JSON.stringify({ code }),
			},
		);

		if (response.status == 400) {
			return undefined;
		}

		return (await response.json()).player;
	} catch {
		throw Error("Incorrect code");
	}
}

/** requires authentication */
export async function unlinkMCAccount(): Promise<boolean> {
	try {
		const response = await fetch(
			connector(`/account-linking/unlink-account`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
			},
		);

		return true;
	} catch {
		throw Error(
			"Not authenticated with a user or user already linked account.",
		);
	}
}

export async function serverOwned(server: string): Promise<boolean> {
	try {
		const response = await fetch(
			connector(`/account-linking/is-owned`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
				body: JSON.stringify({ server }),
			},
		);

		return (await response.json()).owned;
	} catch {
		throw Error("Error while running API");
	}
}

/** requires authentication */
export async function userOwnedServer(server: string): Promise<boolean> {
	try {
		const response = await fetch(
			connector(`/account-linking/owned-user`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
				body: JSON.stringify({ server }),
			},
		);

		return (await response.json()).result;
	} catch {
		throw Error("Error while running API");
	}
}

/** requires authentication */
export async function ownServer(server: string): Promise<boolean> {
	try {
		const response = await fetch(
			connector(`/account-linking/own-server`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
				body: JSON.stringify({ server }),
			},
		);

		if (response.status >= 400) {
			return false;
		}

		return true;
	} catch {
		throw Error("Error while running API");
	}
}

/** requires authentication */
export async function unownServer(server: string): Promise<boolean> {
	try {
		const response = await fetch(
			connector(`/account-linking/unown-server`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
				body: JSON.stringify({ server }),
			},
		);

		if (response.status == 400) {
			return false;
		}

		return true;
	} catch {
		throw Error("Error while running API");
	}
}

/** requires authentication */
export async function setCustomization(
	server: string,
	customization: any,
): Promise<boolean | Error> {
	try {
		const response = await fetch(
			connector(`/customization/${server}/set`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
				body: JSON.stringify({ customization }),
			},
		);

		if (response.status == 400) {
			throw Error("Error while running API");
			return false;
		}

		return true;
	} catch {
		throw Error("Error while running API");
	}
}

export async function getCustomization(server: string): Promise<any> {
	try {
		const response = await fetch(
			connector(`/customization/${server}/get`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
			},
		);

		if (response.status == 400) {
			return false;
		}

		return (await response.json()).results;
	} catch {
		throw Error("Error while running API");
	}
}

export async function sortedFavorites(): Promise<
	Array<{ server: string; favorites: number }> | boolean
> {
	try {
		const response = await fetch(
			connector(`/sorting/favorites`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
			},
		);

		if (response.status == 400) {
			return false;
		}

		return (await response.json()).results;
	} catch {
		throw Error("Error while running API");
	}
}

export async function reportServer(
	server: string,
	reason: string,
): Promise<boolean> {
	try {
		const response = await fetch(connector(`/report-server`, { version: 1 }), {
			method: "POST",
			headers: {
				"Content-Type": "application/json",
			},
			body: JSON.stringify({ server, reason }),
		});

		if (response.status == 400) {
			return false;
		}

		return true;
	} catch {
		throw Error("Error while running API");
	}
}

export async function setAccountSL(
	data: number | boolean | null,
	type: "srv" | "ipr" | "pad",
): Promise<boolean> {
	try {
		const response = await fetch(
			connector(`/account-sl/change`, { version: 0 }),
			{
				method: "POST",
				headers: {
					"Content-Type": "application/json",
				},
				body: JSON.stringify({ data, type }),
			},
		);

		if (response.status === 400) {
			return false;
		}

		return true;
	} catch {
		throw Error("Error while running API");
	}
}