Build equipment borrowing in the Community App

// Hosted campai TypeScript. Install this entire file in the indicated group.
const KEY = ['community-equipment', 'v1'] as const;
const YEAR = 2026;
const TASKS: { id: string; title: string; detail: string }[] = [];
const ITEMS = [
    { id: 'racket', name: 'Training racket', description: 'A beginner-friendly racket with a protective cover.', quantity: 3 },
    { id: 'jersey', name: 'Training jersey', description: 'Ask the equipment team about sizing at collection.', quantity: 6 },
    { id: 'kit', name: 'Practice kit', description: 'Cones, markers and a carry bag for a small group.', quantity: 2 },
];
type Person = { userId: string; name: string };
type Profile = { contactId: string; name: string; targetMinutes: number; done: string[]; visit: string; updatedAt: string };
type Entry = { id: string; contactId: string; name: string; actor: Person; createdAt: string; status: string; title: string; note: string; date: string; minutes: number; itemId: string; returnDate: string; category: string; reply: string; reviewedBy: Person | null; updatedAt: string };
type State = { schema: 1; profiles: Profile[]; entries: Entry[] };
function text(value: unknown, label: string, max = 500, optional = false): string {
    if (typeof value !== 'string' || value.trim().length > max || (!optional && !value.trim())) throw new Error(`${label} is required (maximum ${max} characters).`);
    return value.trim();
}
function object(input: unknown): Record<string, unknown> {
    if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('Invalid request.');
    return input as Record<string, unknown>;
}
function day(value: unknown): string {
    const result = text(value, 'Date', 10);
    if (!/^\d{4}-\d{2}-\d{2}$/.test(result) || !Number.isFinite(Date.parse(result + 'T00:00:00Z')) || new Date(result + 'T00:00:00Z').toISOString().slice(0, 10) !== result) throw new Error('Enter a valid calendar date.');
    return result;
}
function caller() {
    if (typeof context === 'undefined' || !context.caller?.userId) throw new Error('Sign in to use this app. The runtime must support verified caller context.');
    return context.caller;
}
function actor(): Person { const user = caller(); return { userId: user.userId, name: user.name }; }
async function read() {
    const entry = await storage.get<State>(KEY);
    const state = entry.versionstamp === null ? { schema: 1 as const, profiles: [], entries: [] } : entry.value;
    if (!state || state.schema !== 1 || !Array.isArray(state.profiles) || !Array.isArray(state.entries) || state.profiles.length > 100 || state.entries.length > 300) throw new Error('Stored data needs review. No changes were made.');
    return { state, version: entry.versionstamp };
}
async function save(current: Awaited<ReturnType<typeof read>>) {
    if (current.state.profiles.length > 100 || current.state.entries.length > 300) throw new Error('This sample has reached its storage limit. Export and review the records before extending it.');
    const result = await storage.atomic().check({ key: KEY, versionstamp: current.version }).set(KEY, current.state).commit();
    if (!result.ok) throw new Error('Another action changed the data. Refresh and review before trying again.');
}
function profile(state: State, contact: { contactId: string; name: string }) {
    let found = state.profiles.find(row => row.contactId === contact.contactId);
    if (!found) { found = { ...contact, targetMinutes: 480, done: [], visit: 'Meet the welcome team at reception. Ask us to confirm your first visit before travelling.', updatedAt: new Date().toISOString() }; state.profiles.push(found); }
    found.name = contact.name;
    return found;
}
function requestId(value: unknown) { const id = text(value, 'Request reference', 36); if (!/^[a-f0-9-]{36}$/.test(id)) throw new Error('Invalid request reference.'); return id; }
function newEntry(input: Record<string, unknown>, contact: { contactId: string; name: string }): Entry {
    const now = new Date().toISOString();
    return { id: requestId(input.id), contactId: contact.contactId, name: contact.name, actor: actor(), createdAt: now, updatedAt: now, status: 'pending', title: '', note: '', date: '', minutes: 0, itemId: '', returnDate: '', category: '', reply: '', reviewedBy: null };
}
// Contact scope only. This project deliberately has no administrative exports.
function contactFor(value: unknown) {
    const user = caller();
    const contact = user.contacts.find(row => row.contactId === value);
    if (!contact) throw new Error('This contact is not available to your account. Refresh your contacts.');
    return contact;
}
function available(state: State, itemId: string) {
    return (ITEMS.find(item => item.id === itemId)?.quantity ?? 0) - state.entries.filter(row => row.itemId === itemId && ['approved', 'collected'].includes(row.status)).length;
}
export async function loadMember(contactId?: string) {
    const user = caller();
    if (!user.contacts.length) throw new Error('No eligible linked contacts. Ask your organization to check your access.');
    const contact = contactFor(contactId ?? (user.contacts.length === 1 ? user.contacts[0].contactId : ''));
    const { state } = await read();
    const person = state.profiles.find(row => row.contactId === contact.contactId) ?? { ...contact, targetMinutes: 480, done: [], visit: 'Meet the welcome team at reception. Ask us to confirm your first visit before travelling.' };
    return { name: user.name, contacts: user.contacts.map(row => ({ contactId: row.contactId, name: row.name })), profile: person, year: YEAR,
        entries: state.entries.filter(row => row.contactId === contact.contactId).map(({ actor: by, reviewedBy, ...row }) => ({ ...row, submittedBy: by.name, reviewedBy: reviewedBy?.name ?? null })).reverse(),
        tasks: TASKS, items: ITEMS.map(item => ({ ...item, available: available(state, item.id) })) };
}
export async function getContacts() {
    const user = caller();
    if (!user.contacts.length) throw new Error('No eligible linked contacts. Ask your organization to check your access.');
    return { name: user.name, contacts: user.contacts.map(row => ({ contactId: row.contactId, name: row.name })) };
}
export async function submit(input: unknown) {
    const request = object(input), contact = contactFor(request.contactId), current = await read();
    const id = requestId(request.id);
    const entry = newEntry(request, contact);
    const item = ITEMS.find(row => row.id === request.itemId);
    if (!item) throw new Error('Choose an item from the catalogue.');
    entry.itemId = item.id; entry.title = item.name; entry.date = day(request.date); entry.returnDate = day(request.returnDate);
    if (entry.returnDate < entry.date) throw new Error('Choose a return date on or after collection.');
    entry.note = text(request.note ?? '', 'Note', 500, true);
    const previous = current.state.entries.find(row => row.id === id);
    if (previous) {
        if (previous.contactId !== contact.contactId || previous.actor.userId !== caller().userId) throw new Error('This reference is already in use.');
        if (['title', 'note', 'date', 'minutes', 'itemId', 'returnDate', 'category'].some(key => (previous as any)[key] !== (entry as any)[key])) throw new Error('This reference belongs to a different request. Refresh your history.');
        return { id: previous.id, saved: true };
    }
    if (entry.date < new Date().toISOString().slice(0, 10)) throw new Error('Choose today or a future collection date.');
    profile(current.state, contact);
    current.state.entries.push(entry);
    await save(current);
    return { id: entry.id, saved: true };
}
export async function cancel(input: unknown) {
    const request = object(input), contact = contactFor(request.contactId), current = await read();
    const entry = current.state.entries.find(row => row.id === request.id && row.contactId === contact.contactId);
    if (!entry || entry.status !== 'pending') throw new Error('Only a pending request can be withdrawn. Refresh to see its current status.');
    entry.status = 'withdrawn'; entry.updatedAt = new Date().toISOString();
    await save(current); return { saved: true };
}