Client setup

<!-- src/routes/+layout.svelte — one client for the application -->
<script lang="ts">
	import { createClient, setClient } from '@svelte-lean/query';
	import { http } from '@svelte-lean/query/http';
	import { can, session } from '$api/session.svelte';

	let { children } = $props();

	setClient(
		createClient({
			transport: http({
				base: '/',
				headers: () => ({ authorization: `Bearer ${session.token}` })
			}),
			scope: () => [session.workspace], // part of every cache key
			can // resolves the permission strings of `access` rules
		})
	);
</script>

{@render children()}

// src/lib/api/transport.ts
import { http } from '@svelte-lean/query/http';
import { laravel } from '@svelte-lean/query/laravel';
import { refreshToken, session } from '$api/session.svelte';

export const transport = http({
	base: '/',
	headers: () => ({ authorization: `Bearer ${session.token}` }),
	timeout: '30s',
	// The platform's conventions: envelope, refusals, 422 field errors, paginators.
	profile: laravel(),
	// The last word on a response: refresh the token once on a 401 and send again.
	intercept: async (response, _request, retry) => {
		if (response.status !== 401) return response;
		await refreshToken();
		return retry();
	}
});

// Part of every cache key: entries of one workspace never answer another.
scope: () => [session.workspace],
// On a change, the previous workspace's entries are dropped (the default) or kept.
onScopeChange: 'drop',

// Resolves the permission strings of `access` rules. `undefined` = not known yet.
can,
// One more rule for every endpoint, combined with each endpoint's own `access`.
access: () => (session.userId === null ? false : true),

defaults: {
	fresh: '10s', // default 0: stale at once, revalidated on the next use
	keep: '10m', // default '5m': how long an unobserved entry stays
	retry: 2, // queries only; writes are never retried unless they say so
	slowAfter: '8s', // `info.slow` turns true after this
	focus: true // revalidate stale observed entries when the tab is shown again
},
limits: {
	concurrency: 'auto', // 6 per origin; 'auto' raises it once HTTP/2 or HTTP/3 is seen
	inactiveEntries: 2000 // with inactiveBytes: the budget of unobserved entries
},

// Optional behavior, each its own import: nothing else is in the bundle.
modules: [devtools(), tabs({ session: () => String(session.userId) })]

// Reports every failed answer; setup returns the teardown.
export const reportFailures = defineModule({
	name: 'report-failures',
	setup(_client, hooks) {
		return hooks.onCommit((entry) => {
			if (entry.status === 'error') console.warn(entry.endpoint.id, entry.error?.kind);
		});
	}
});
// createClient({ transport, modules: [reportFailures] })

// Every engine part in the first load: no chunk request, no loading step.
createClient({ transport: http({ base: '/' }), parts: allParts });

import { access, limiter, polling } from '@svelte-lean/query/parts';

// Only some; the others still load on first use.
createClient({ transport: http({ base: '/' }), parts: [access, limiter, polling] });

// A class or a plain module reaches the same client: the browser has one per page.
import { getClient, invalidate, send } from '@svelte-lean/query';

export function signOut() {
	getClient().clear(); // abort everything, drop every entry and optimistic layer
}

export function afterImport() {
	invalidate(['Members', 'Teams']); // the free form of getClient().invalidate(…)
}

// One request through the transport (headers, envelope, typed errors) without the cache.
export async function ping(): Promise<{ ok: boolean }> {
	return send<{ ok: boolean }>({ method: 'GET', path: 'api/health' });
}