Make fetch requests using route-provided fetch() function

https://svelte.dev/docs/kit/load#Making-fetch-requests

Author: Heliodex

Site/src/hooks.server.ts

@@ -119,7 +119,7 @@ export async function handle(e) {
 	)
 		redirect(302, "/moderation")
 
-	await stipend(user.id)
+	await stipend(e.event.fetch, user.id)
 
 	return await finish(e)
 }

Site/src/lib/server/economy.ts

@@ -10,9 +10,12 @@ export type ReturnErr = { ok: true } | { ok: false; msg: string }
 
 const tryFetch =
 	<T>(transform: (res: Response) => Promise<T>) =>
-	async (url: string): Promise<ReturnValue<T>> => {
+	async (
+		f: typeof globalThis.fetch,
+		url: string
+	): Promise<ReturnValue<T>> => {
 		try {
-			const res = await fetch(url)
+			const res = await f(url)
 			if (!res.ok) return { ok: false }
 			return { ok: true, value: await transform(res) }
 		} catch {
@@ -23,9 +26,10 @@ const tryFetch =
 const tryFetchValue = tryFetch(async res => +(await res.text()))
 const tryFetchJson = <T>() => tryFetch(async res => (await res.json()) as T) // type assertion much?¿
 
-export const getStipend = () => tryFetchValue(`${economyUrl}/currentStipend`)
-export const getBalance = (user: string) =>
-	tryFetchValue(`${economyUrl}/balance/${user}`)
+export const getStipend = (f: typeof globalThis.fetch) =>
+	tryFetchValue(f, `${economyUrl}/currentStipend`)
+export const getBalance = (f: typeof globalThis.fetch, user: string) =>
+	tryFetchValue(f, `${economyUrl}/balance/${user}`)
 
 type BaseTx = {
 	Note: string
@@ -58,21 +62,20 @@ type TxTypes =
 
 type ReceivedTx = BaseTx & TxTypes
 
-export const getTransactions = (user: string) =>
-	tryFetchJson<ReceivedTx[]>()(`${economyUrl}/transactions/${user}`)
-export const getAdminTransactions = () =>
-	tryFetchJson<ReceivedTx[]>()(`${economyUrl}/transactions`)
+export const getTransactions = (f: typeof globalThis.fetch, user: string) =>
+	tryFetchJson<ReceivedTx[]>()(f, `${economyUrl}/transactions/${user}`)
+export const getAdminTransactions = (f: typeof globalThis.fetch) =>
+	tryFetchJson<ReceivedTx[]>()(f, `${economyUrl}/transactions`)
 
 // doin nothing with returns rn
-export async function stipend(To: string) {
+export async function stipend(f: typeof globalThis.fetch, To: string) {
 	try {
-		await fetch(`${economyUrl}/stipend/${To}`, {
-			method: "post",
-		})
+		await f(`${economyUrl}/stipend/${To}`, { method: "post" })
 	} catch {}
 }
 
 export async function transact(
+	f: typeof globalThis.fetch,
 	From: string,
 	To: string,
 	Amount: number,
@@ -81,7 +84,7 @@ export async function transact(
 	Returns: { [_: number]: number }
 ): Promise<ReturnErr> {
 	try {
-		const res = await fetch(`${economyUrl}/transact`, {
+		const res = await f(`${economyUrl}/transact`, {
 			method: "post",
 			body: JSON.stringify({ From, To, Amount, Note, Link, Returns }),
 		})
@@ -94,6 +97,7 @@ export async function transact(
 }
 
 async function burn(
+	f: typeof globalThis.fetch,
 	From: string,
 	Amount: number,
 	Note: string,
@@ -106,7 +110,7 @@ async function burn(
 		// When my campaign turned to a cam-pain
 		// We got $2.5 trillion stored on the blockchain
 		// Uh, ₿urn ₿aby ₿urn
-		const res = await fetch(`${economyUrl}/burn`, {
+		const res = await f(`${economyUrl}/burn`, {
 			method: "post",
 			body: JSON.stringify({ From, Amount, Note, Link, Returns }),
 		})
@@ -127,13 +131,15 @@ export const getGroupPrice = () => getFeeBasedPrice(50)
 // export const getPlacePrice = () => getFeeBasedPrice(50)
 
 export async function createAsset(
+	f: typeof globalThis.fetch,
 	To: string,
 	id: number,
 	name: string,
 	slug: string
 ): Promise<ReturnErr> {
 	const price = getAssetPrice()
 	return await burn(
+		f,
 		To,
 		price,
 		`Created asset ${name}`,
@@ -143,13 +149,15 @@ export async function createAsset(
 }
 
 // export async function createPlace(
+// 	f: typeof globalThis.fetch,
 // 	To: string,
 // 	id: number,
 // 	name: string,
 // 	slug: string
 // ): Promise<ReturnErr> {
 // 	const price = getPlacePrice()
 // 	return await burn(
+// 		fee,
 // 		To,
 // 		price,
 // 		`Created place ${name}`,
@@ -159,11 +167,19 @@ export async function createAsset(
 // }
 
 export async function createGroup(
+	f: typeof globalThis.fetch,
 	To: string,
 	name: string
 ): Promise<ReturnErr> {
 	const price = getGroupPrice()
-	return await burn(To, price, `Created group ${name}`, `/groups/${name}`, {})
+	return await burn(
+		f,
+		To,
+		price,
+		`Created group ${name}`,
+		`/groups/${name}`,
+		{}
+	)
 }
 
 export async function transformTransactions(list: ReceivedTx[]) {

Site/src/lib/server/orbiter.ts

@@ -8,9 +8,11 @@ type Gameserver = {
 
 type GameserverId = [number, Gameserver]
 
-export async function listGameservers(): ReturnValue<GameserverId[]> {
+export async function listGameservers(
+	f: typeof globalThis.fetch
+): ReturnValue<GameserverId[]> {
 	try {
-		const res = await fetch(config.OrbiterPrivateURL)
+		const res = await f(config.OrbiterPrivateURL)
 		if (!res.ok) return { ok: false }
 		return { ok: true, value: await res.json() }
 	} catch {
@@ -19,11 +21,12 @@ export async function listGameservers(): ReturnValue<GameserverId[]> {
 }
 
 async function fetchGameserver(
+	f: typeof globalThis.fetch,
 	path: string | number,
 	method: string
 ): Promise<ReturnErr> {
 	try {
-		const res = await fetch(`${config.OrbiterPrivateURL}/${path}`, { method })
+		const res = await f(`${config.OrbiterPrivateURL}/${path}`, { method })
 		if (!res.ok) return { ok: false, msg: await res.text() }
 	} catch (err) {
 		const e = err as Error
@@ -32,8 +35,12 @@ async function fetchGameserver(
 	return { ok: true }
 }
 
-export const startGameserver = async (placeId: number) =>
-	fetchGameserver(placeId, "put")
+export const startGameserver = async (
+	f: typeof globalThis.fetch,
+	placeId: number
+) => fetchGameserver(f, placeId, "put")
 
-export const closeGameserver = async (placeId: number) =>
-	fetchGameserver(placeId, "delete")
+export const closeGameserver = async (
+	f: typeof globalThis.fetch,
+	placeId: number
+) => fetchGameserver(f, placeId, "delete")

Site/src/lib/server/requestRender.ts

@@ -20,6 +20,7 @@ type Render = {
  * @param wait Whether to wait for the render to be completed before resolving.
  */
 export default async function (
+	f: typeof globalThis.fetch,
 	renderType: RenderType,
 	relativeId: string | number,
 	relativeName = relativeId,
@@ -85,7 +86,7 @@ export default async function (
 	await Promise.all([
 		waiter,
 		// Uhh carrot just got the
-		fetch(`${config.RCCServiceProxyURL}/${renderId}`, {
+		f(`${config.RCCServiceProxyURL}/${renderId}`, {
 			method: "post",
 			body: script,
 		}),

Site/src/routes/(main)/admin/asset/+page.server.ts

@@ -80,7 +80,7 @@ actions.rerender = async e => {
 	if (limit) return limit
 
 	try {
-		await requestRender("Clothing", id)
+		await requestRender(e.fetch, "Clothing", id)
 	} catch (e) {
 		console.error(e)
 		fail(500, { msg: "Failed to request render" })

Site/src/routes/(main)/admin/create/+page.server.ts

@@ -46,7 +46,7 @@ actions.default = async ({ locals, request }) => {
 	if (!fs.existsSync("../data/thumbnails")) fs.mkdirSync("../data/thumbnails")
 
 	const { asset, description, name, price, type: assetType } = data
-	form.data.asset = null // make sure to return as a POJO
+	form.data.asset = null as unknown as File// make sure to return as a POJO
 
 	const [, id] = await db.query<string[]>(createQuery, {
 		description,
@@ -59,7 +59,7 @@ actions.default = async ({ locals, request }) => {
 	await Bun.write(`../data/assets/${id}`, await asset.arrayBuffer())
 
 	// we'll just assume it's a model 4 now
-	// await requestRender("Model", id)
+	// await requestRender(f, "Model", id)
 
 	redirect(302, `/catalog/${id}`)
 }

Site/src/routes/(main)/admin/gameservers/+page.server.ts

@@ -2,10 +2,10 @@ import { error } from "@sveltejs/kit"
 import { authorise } from "$lib/server/auth"
 import { listGameservers } from "$lib/server/orbiter"
 
-export async function load({ locals }) {
+export async function load({ fetch: f, locals }) {
 	await authorise(locals, 5)
 
-	const gameservers = await listGameservers()
+	const gameservers = await listGameservers(f)
 	if (!gameservers.ok) error(500, "Failed to fetch gameservers")
 
 	return {

Site/src/routes/(main)/catalog/[id=asset]/[name]/+page.server.ts

@@ -54,7 +54,7 @@ const noTexts = Object.freeze([
 ])
 const failTexts = Object.freeze(["Bruh", "Okay", "Aight", "Rip", "Aw man..."])
 
-export async function load({ locals, params }) {
+export async function load({ fetch: f, locals, params }) {
 	const { user } = await authorise(locals)
 	const id = +params.id
 	const [[asset]] = await db.query<Asset[][]>(assetQuery, {
@@ -67,7 +67,7 @@ export async function load({ locals, params }) {
 	if (!couldMatch(asset.name, params.name))
 		redirect(302, `/catalog/${id}/${slug}`)
 
-	const balance = await getBalance(user.id)
+	const balance = await getBalance(f, user.id)
 	if (!balance.ok) error(500, economyConnFailed)
 
 	return {
@@ -91,7 +91,7 @@ async function getBuyData(e: RequestEvent) {
 }
 
 // actions that return things are here because of sveltekit typescript limitations
-async function rerender({ locals, params }: RequestEvent) {
+async function rerender({ fetch: f, locals, params }: RequestEvent) {
 	await authorise(locals, 5)
 
 	const id = +params.id
@@ -109,7 +109,7 @@ async function rerender({ locals, params }: RequestEvent) {
 
 	if ([8, 11, 12].includes(asset.type))
 		try {
-			await requestRender(asset.type === 8 ? "Model" : "Clothing", id)
+			await requestRender(f, asset.type === 8 ? "Model" : "Clothing", id)
 			const icon = `/catalog/${id}/${asset.name}/icon?r=${Math.random()}`
 			return { icon }
 		} catch (e) {
@@ -185,6 +185,7 @@ actions.buy = async e => {
 	if (asset.price > 0) {
 		// todo work out how free assets are supposed to work
 		const tx = await transact(
+			e.fetch,
 			user.id,
 			asset.creator.id,
 			asset.price,

Site/src/routes/(main)/character/+page.server.ts

@@ -72,9 +72,9 @@ async function getEquipData(e: RequestEvent) {
 	return { user, id, asset }
 }
 
-async function rerender(user: User) {
+async function rerender(f: typeof globalThis.fetch, user: User) {
 	try {
-		await requestRender("Avatar", user.id, user.username, true)
+		await requestRender(f, "Avatar", user.id, user.username, true)
 		return {
 			avatar: `/api/avatar/${user.username}-body?r=${Math.random()}`,
 		}
@@ -84,7 +84,7 @@ async function rerender(user: User) {
 	}
 }
 
-async function paint({ locals, url }: RequestEvent) {
+async function paint({ fetch: f, locals, url }: RequestEvent) {
 	const { user } = await authorise(locals)
 	const bodyPartQuery = url.searchParams.get("p")
 	const bodyColour = url.searchParams.get("c") as string
@@ -104,15 +104,15 @@ async function paint({ locals, url }: RequestEvent) {
 
 	db.merge(Record("user", user.id), { bodyColours: currentColours })
 
-	return await rerender(user)
+	return await rerender(f, user)
 }
-async function regen({ locals, getClientAddress }: RequestEvent) {
+async function regen({ fetch: f, locals, getClientAddress }: RequestEvent) {
 	const { user } = await authorise(locals)
 
 	const limit = ratelimit(null, "regen", getClientAddress, 2)
 	if (limit) return limit
 
-	return await rerender(user)
+	return await rerender(f, user)
 }
 async function equip(e: RequestEvent) {
 	const { user, id, asset, error } = await getEquipData(e)
@@ -133,7 +133,7 @@ async function equip(e: RequestEvent) {
 		...(oneEquippable.includes(asset.type) ? asset : {}),
 	})
 
-	return await rerender(user)
+	return await rerender(e.fetch, user)
 }
 async function unequip(e: RequestEvent) {
 	const { user, id, error } = await getEquipData(e)
@@ -144,7 +144,7 @@ async function unequip(e: RequestEvent) {
 		asset: Record("asset", id),
 	})
 
-	return await rerender(user)
+	return await rerender(e.fetch, user)
 }
 export const actions: import("./$types").Actions = {
 	paint,