Defining endpoints

import { defineMutation, defineQuery, page, tag, type } from '@svelte-lean/query';
import type { Member, MemberFilters, MemberInput, Team } from './types';

export const listMembers = defineQuery({
	get: 'api/members',
	params: type<MemberFilters>(),
	result: page<Member>(),
	entity: 'Member', // every row carries tag('Member', row.id)
	tags: ['Members'],
	fresh: '15s',
	access: 'members.view'
});

export const getMember = defineQuery({
	get: 'api/members/{id}',
	result: type<Member>(),
	entity: 'Member',
	access: 'members.view'
});

// `{team}` and `{id}` are required params, typed string | number, encoded into the URL.
export const getTeamMember = defineQuery({
	get: 'api/teams/{team}/members/{id}',
	result: type<Member>(),
	entity: 'Member'
});
// getTeamMember.fetch({ team: 'design', id: 7 }) → GET api/teams/design/members/7

// A read sent as POST: the params are the JSON body, and still the cache key.
export const searchMembers = defineQuery({
	post: 'api/members/search',
	params: type<{ query: string; teams: string[] }>(),
	result: type<Member[]>(),
	tags: ['Members']
});

// Params in the query string whatever the method: `true` (all of them, no body) or these keys.
export const memberReport = defineQuery({
	post: 'api/members/report',
	params: type<{ team: string; from: string }>(),
	result: type<{ total: number }>(),
	search: true
});
// memberReport.fetch({ team: 'design', from: '2026-01-01' })
//   → POST api/members/report?team=design&from=2026-01-01, no body
export const reorderMembers = defineMutation({
	put: 'api/teams/{team}/order',
	body: type<{ ids: number[]; dry_run?: boolean }>(),
	search: ['dry_run']
});
// reorderMembers.run({ team: 'design', ids: [3, 1], dry_run: true })
//   → PUT api/teams/design/order?dry_run=true, body {"ids":[3,1]}

// `{+name}` is sent as given: an address the server handed over keeps its `/`, `?` and `&`;
// a full URL is requested as it is.
export const optionsFrom = defineQuery({
	get: '{+source}',
	params: type<{ search?: string }>(),
	result: type<{ id: number; name: string }[]>()
});
// optionsFrom.fetch({ source: 'api/teams/options?active=1', search: 'de' })
//   → GET api/teams/options?active=1&search=de

// A download: `data` is { blob, filename, type }, the name from Content-Disposition. A JSON
// answer counts as a file only when it is an attachment; any other JSON rejects (kind 'parse').
export const exportMembers = defineQuery({
	get: 'api/members/export',
	params: type<{ format: 'csv' | 'xlsx' }>(),
	result: file()
});

// The server nests its paginator: reshape the answer once per commit. `params` are the params the
// entry was asked with; `pageParams` names the page params createPaged / createInfinite send.
export const listTeamMembers = defineQuery({
	get: 'api/teams/{team}/members',
	params: type<{ role?: string }>(),
	result: page<Member>(),
	map: (raw: { members: Member[] }, { page, params }) =>
		page(params.role ? raw.members.filter((m) => m.role === params.role) : raw.members),
	pageParams: (n, size) => ({ p: n, size })
});

// A dashboard's figures are background work: they queue behind the reads a page waits for and
// never take the last request slot. Per use: createQuery(…, { priority }); per call: { priority }.
export const memberStats = defineQuery({
	get: 'api/members/stats',
	result: type<{ active: number; invited: number }>(),
	priority: 'low'
});

export const createMember = defineMutation({
	post: 'api/members',
	body: type<MemberInput>(),
	result: type<Member>(),
	invalidates: ['Members', 'Teams'],
	access: 'members.edit'
});

export const updateMember = defineMutation({
	patch: 'api/members/{id}',
	body: type<Partial<MemberInput>>(),
	result: type<Member>(),
	invalidates: (member) => [tag('Member', member.id), 'Members'],
	access: 'members.edit'
});

export const deleteMember = defineMutation({
	delete: 'api/members/{id}',
	invalidates: ['Members', 'Teams'],
	access: 'members.delete'
});

// `encode: 'json'` always sends a body: `{}` when the input holds only path params.
export const archiveMember = defineMutation({
	post: 'api/members/{id}/archive',
	encode: 'json'
});

// The tag and permission registries: a typo in a tag or a permission is a compile error.
declare module '@svelte-lean/query' {
	interface Tags {
		Member: number;
		Members: void;
		Teams: void;
	}
	interface Permissions {
		'members.view': true;
		'members.edit': true;
		'members.delete': true;
	}
}

// Tags computed from the answer: a change to any of its members refetches the team.
export const getTeam = defineQuery({
	get: 'api/teams/{id}',
	result: type<Team & { memberIds: number[] }>(),
	tags: (team) => ['Teams', ...team.memberIds.map((id) => tag('Member', id))]
});

invalidate(tag('Member', id)); // entries that carry Member:<id>: rows in pages, the detail
invalidate('Members'); // every entry that provides Members
invalidate(listMembers); // every entry of one endpoint
invalidate([listMembers, { team: 'Design' }]); // entries whose params contain these fields
listMembers.invalidate({ team: 'Design' }); // the same, from the endpoint

// One permission, resolved by the client's `can`.
export const listAll = defineQuery({
	get: 'api/members/all',
	result: type<Member[]>(),
	access: 'members.view'
});

// One of them is enough.
export const listMine = defineQuery({
	get: 'api/members/mine',
	result: type<Member[]>(),
	access: any('members.view', 'members.view-own')
});

// Depends on the input: promoting to owner needs one more permission.
export const setRole = defineMutation({
	put: 'api/members/{id}/role',
	body: type<{ role: Member['role'] }>(),
	access: all('members.edit', (input) => (input.role === 'owner' ? 'members.owners' : true))
});

// Any code: a read-only session may not delete.
export const removeAll = defineMutation({
	delete: 'api/members',
	access: all(
		'members.delete',
		not(() => session.userId === null)
	)
});

const member = await getMember.fetch({ id }); // cached and fresh, or one request
getMember.prefetch({ id: id + 1 }); // low priority; an error stays on the entry
const cached = getMember.get({ id }); // synchronous; undefined when not cached
getMember.set({ id }, { ...member, pinned: true }); // a local write, shown everywhere
getMember.invalidate({ id }); // stale now; refetched where it is on screen
const visible = listMembers.allowed(); // the access verdict, without a request
await updateMember.run({ id, name: 'Mei Tanaka' }); // a write without reactive state