@henrikogard/auroradocs-mcp 0.1.1

package/dist/auroraClient.js

@@ -0,0 +1,706 @@
+/**
+ * auroraClient.ts — AuroraCloud client helpers for the MCP server.
+ *
+ * SECURITY: Every query is scoped to the configured workspace.
+ * On authenticate(), the server verifies the caller is a member of
+ * that workspace — if not, the process exits.
+ */
+// ── Types ────────────────────────────────────────────────────────────────────
+export const WORKSPACE_KNOWLEDGE_SOURCE_KINDS = [
+    'object',
+    'content_chunk',
+    'property',
+    'comment',
+    'attachment_metadata',
+    'relationship',
+];
+export const WORKSPACE_KNOWLEDGE_AVAILABILITY_STATES = [
+    'available',
+    'encrypted_locked',
+    'not_indexed',
+    'unsupported_type',
+    'permission_denied',
+];
+export const WORKSPACE_KNOWLEDGE_RELATIONSHIP_TYPES = [
+    'parent',
+    'child',
+    'link',
+    'backlink',
+    'tag',
+    'task_project',
+];
+// ── Singleton backend instance ───────────────────────────────────────────────
+let _client = null;
+export function resetAuroraClientForTests() {
+    _client = null;
+}
+export function getAuroraClient() {
+    if (_client)
+        return _client;
+    _client = createAuroraCloudClient(getAuroraApiUrl());
+    return _client;
+}
+/**
+ * Authenticate and verify workspace membership.
+ * Exits the process if the user is not a member of the target workspace.
+ */
+export async function authenticate() {
+    const client = getAuroraClient();
+    const workspaceId = process.env['AURORA_WORKSPACE_ID'];
+    const token = process.env['AURORA_API_TOKEN'];
+    if (token) {
+        client.authStore.save(token, null);
+    }
+    else {
+        const email = process.env['AURORA_API_EMAIL'];
+        const password = process.env['AURORA_API_PASSWORD'];
+        const users = client.collection('users');
+        if (email && password && users.authWithPassword) {
+            await users.authWithPassword(email, password);
+        }
+        else {
+            throw new Error('Provide AURORA_API_TOKEN (recommended: workspace MCP token `aur_mcp_...`), or AURORA_API_EMAIL + AURORA_API_PASSWORD for local development only.');
+        }
+    }
+    await ensureAuthRecord();
+    // Verify workspace membership
+    if (workspaceId) {
+        const userId = getAuthUserId();
+        if (!userId)
+            throw new Error('Could not determine authenticated user ID');
+        const members = await client.collection('workspace_members').list({
+            filter: client.filter('workspace_id = {:wid} && user_id = {:uid}', { wid: workspaceId, uid: userId }),
+        });
+        if (!members.length) {
+            throw new Error(`Authenticated user ${userId} is not a member of workspace ${workspaceId}`);
+        }
+        process.stderr.write(`Authenticated as ${userId} (role: ${members[0]['role']})\n`);
+    }
+}
+/** Get the authenticated user's ID from the auth store. */
+function getAuthUserId() {
+    const client = getAuroraClient();
+    const record = client.authStore.record;
+    return record?.['id'] ?? null;
+}
+// ── Object CRUD ──────────────────────────────────────────────────────────────
+export async function listObjects(workspaceId, type) {
+    const client = getAuroraClient();
+    const filter = type
+        ? client.filter('workspace_id = {:wid} && is_deleted = false && type = {:type}', { wid: workspaceId, type })
+        : client.filter('workspace_id = {:wid} && is_deleted = false', { wid: workspaceId });
+    const records = await client.collection('objects').list({ filter, sort: '-updated_at' });
+    return records.map(mapObject);
+}
+export async function getObject(id, workspaceId) {
+    const client = getAuroraClient();
+    try {
+        const r = await client.collection('objects').get(id);
+        const obj = mapObject(r);
+        // SECURITY: reject objects outside the configured workspace
+        if (obj.workspace_id !== workspaceId)
+            return null;
+        return obj;
+    }
+    catch {
+        return null;
+    }
+}
+export async function createObject(workspaceId, type, title) {
+    const client = getAuroraClient();
+    const r = await client.collection('objects').create({
+        workspace_id: workspaceId,
+        type,
+        title,
+        is_deleted: false,
+        is_template: false,
+    });
+    return mapObject(r);
+}
+export async function updateObjectTitle(id, title, workspaceId) {
+    // Verify ownership before update
+    const obj = await getObject(id, workspaceId);
+    if (!obj)
+        throw new Error(`Object ${id} not found in this workspace`);
+    const client = getAuroraClient();
+    await client.collection('objects').update(id, { title });
+}
+export async function deleteObject(id, workspaceId) {
+    const obj = await getObject(id, workspaceId);
+    if (!obj)
+        throw new Error(`Object ${id} not found in this workspace`);
+    const client = getAuroraClient();
+    await client.collection('objects').update(id, { is_deleted: true });
+}
+// ── Content ──────────────────────────────────────────────────────────────────
+export async function getContent(objectId, workspaceId) {
+    // Verify object belongs to workspace
+    const obj = await getObject(objectId, workspaceId);
+    if (!obj)
+        return null;
+    const client = getAuroraClient();
+    try {
+        const records = await client.collection('content').list({
+            filter: client.filter('object_id = {:id}', { id: objectId }),
+        });
+        const r = records[0];
+        if (!r)
+            return null;
+        const json = r['content_json'];
+        if (!json)
+            return null;
+        return extractTextFromDoc(typeof json === 'string' ? JSON.parse(json) : json);
+    }
+    catch {
+        return null;
+    }
+}
+export async function getContentJson(objectId, workspaceId) {
+    const obj = await getObject(objectId, workspaceId);
+    if (!obj)
+        return null;
+    const client = getAuroraClient();
+    const records = await client.collection('content').list({
+        filter: client.filter('object_id = {:id}', { id: objectId }),
+    });
+    const r = records[0];
+    if (!r)
+        return null;
+    const json = r['content_json'];
+    if (!json)
+        return null;
+    if (typeof json === 'string') {
+        if (json.startsWith('v1:') || json.startsWith('v2:')) {
+            throw new Error('Object content is end-to-end encrypted and cannot be modified by the MCP server');
+        }
+        return JSON.parse(json);
+    }
+    return json;
+}
+export async function searchWorkspaceKnowledgeServer(workspaceId, query, limit = 20) {
+    const trimmedWorkspaceId = workspaceId.trim();
+    const trimmedQuery = query.trim();
+    if (!trimmedWorkspaceId || !trimmedQuery)
+        return [];
+    const payload = await getAuroraClient().request(`/api/knowledge/workspaces/${trimmedWorkspaceId}/search?q=${encodeURIComponent(trimmedQuery)}&limit=${Math.max(1, Math.min(50, limit))}`, { method: 'GET' });
+    return normalizeWorkspaceKnowledgeResponse(payload).items;
+}
+export async function getWorkspaceKnowledgeObjectServer(workspaceId, objectId, includeFullText = false) {
+    const trimmedWorkspaceId = workspaceId.trim();
+    const trimmedObjectId = objectId.trim();
+    if (!trimmedWorkspaceId || !trimmedObjectId)
+        return null;
+    const payload = await getAuroraClient().request(`/api/knowledge/workspaces/${trimmedWorkspaceId}/objects/${trimmedObjectId}`, { method: 'GET' });
+    const source = normalizeWorkspaceKnowledgeResponse(payload).items[0] ?? null;
+    if (!source)
+        return null;
+    return includeFullText ? source : { ...source, plainText: null };
+}
+export async function listWorkspaceRelatedKnowledgeServer(workspaceId, objectId, limit = 6) {
+    const trimmedWorkspaceId = workspaceId.trim();
+    const trimmedObjectId = objectId.trim();
+    if (!trimmedWorkspaceId || !trimmedObjectId)
+        return [];
+    const payload = await getAuroraClient().request(`/api/knowledge/workspaces/${trimmedWorkspaceId}/related/${trimmedObjectId}?limit=${Math.max(1, Math.min(10, limit))}`, { method: 'GET' });
+    return normalizeWorkspaceKnowledgeResponse(payload).items;
+}
+export async function listWorkspaceRecentKnowledgeServer(workspaceId, limit = 6) {
+    const trimmedWorkspaceId = workspaceId.trim();
+    if (!trimmedWorkspaceId)
+        return [];
+    const payload = await getAuroraClient().request(`/api/knowledge/workspaces/${trimmedWorkspaceId}/recent?limit=${Math.max(1, Math.min(10, limit))}`, { method: 'GET' });
+    return normalizeWorkspaceKnowledgeResponse(payload).items;
+}
+export async function setContent(objectId, workspaceId, contentJson) {
+    const obj = await getObject(objectId, workspaceId);
+    if (!obj)
+        throw new Error(`Object ${objectId} not found in this workspace`);
+    const client = getAuroraClient();
+    const existing = await client.collection('content').list({
+        filter: client.filter('object_id = {:id}', { id: objectId }),
+    });
+    if (existing.length > 0) {
+        await client.collection('content').update(String(existing[0].id), { content_json: contentJson });
+    }
+    else {
+        await client.collection('content').create({ object_id: objectId, content_json: contentJson });
+    }
+}
+export async function appendContentText(objectId, workspaceId, text) {
+    const current = await getContentJson(objectId, workspaceId);
+    const currentContent = Array.isArray(current?.['content']) ? current['content'] : [];
+    const appended = text.split('\n').map((line) => ({
+        type: 'paragraph',
+        content: line ? [{ type: 'text', text: line }] : [],
+    }));
+    await setContent(objectId, workspaceId, {
+        ...(current ?? { type: 'doc' }),
+        type: 'doc',
+        content: [...currentContent, ...appended],
+    });
+}
+// ── Properties (parameterized queries) ───────────────────────────────────────
+export async function listProperties(objectIds, workspaceId) {
+    if (!objectIds.length)
+        return [];
+    const client = getAuroraClient();
+    const results = [];
+    // Batch in groups of 50, using parameterized filters
+    for (let i = 0; i < objectIds.length; i += 50) {
+        const batch = objectIds.slice(i, i + 50);
+        // Build parameterized OR filter for AuroraCloud collection queries.
+        const conditions = batch.map((_, idx) => `object_id = {:id${idx}}`);
+        const params = {};
+        batch.forEach((id, idx) => { params[`id${idx}`] = id; });
+        const filter = client.filter(conditions.join(' || '), params);
+        const records = await client.collection('object_properties').list({ filter });
+        for (const r of records) {
+            results.push({
+                id: r['id'],
+                object_id: r['object_id'],
+                key: r['key'],
+                value_type: r['value_type'],
+                value_text: r['value_text'] ?? null,
+                value_num: r['value_num'] ?? null,
+                value_date: r['value_date'] ?? null,
+                value_bool: r['value_bool'] != null ? Boolean(r['value_bool']) : null,
+                value_ref: r['value_ref'] ?? null,
+            });
+        }
+    }
+    return results;
+}
+export async function upsertProperty(objectId, workspaceId, key, valueType, value) {
+    // Verify object belongs to workspace
+    const obj = await getObject(objectId, workspaceId);
+    if (!obj)
+        throw new Error(`Object ${objectId} not found in this workspace`);
+    const client = getAuroraClient();
+    const existing = await client.collection('object_properties').list({
+        filter: client.filter('object_id = {:oid} && key = {:key}', { oid: objectId, key }),
+    });
+    const valueField = valueType === 'number' ? 'value_num' :
+        valueType === 'date' ? 'value_date' :
+            valueType === 'boolean' ? 'value_bool' :
+                'value_text';
+    const parsedValue = valueType === 'number' ? Number(value) :
+        valueType === 'boolean' ? (value === 'true') :
+            value;
+    if (existing.length > 0) {
+        await client.collection('object_properties').update(String(existing[0].id), { value_type: valueType, [valueField]: parsedValue });
+    }
+    else {
+        await client.collection('object_properties').create({ object_id: objectId, key, value_type: valueType, [valueField]: parsedValue });
+    }
+}
+// ── Members ──────────────────────────────────────────────────────────────────
+export async function listMembers(workspaceId) {
+    const response = await getAuroraClient().request(`/workspaces/${workspaceId}/members`, {
+        method: 'GET',
+    });
+    if (Array.isArray(response.members)) {
+        return response.members.map((member) => ({
+            id: member.userId ?? '',
+            name: member.name,
+            email: member.email,
+            role: member.role,
+        }));
+    }
+    if (Array.isArray(response.items)) {
+        return response.items.map((member) => ({
+            id: member.userId ?? '',
+            name: member.user?.displayName ?? null,
+            email: member.user?.email ?? '',
+            role: member.role ?? 'viewer',
+        }));
+    }
+    return [];
+}
+// ── Task lists & statuses ────────────────────────────────────────────────────
+export async function listTaskLists(workspaceId) {
+    const client = getAuroraClient();
+    try {
+        const records = await client.collection('task_lists').list({
+            filter: client.filter('workspace_id = {:wid}', { wid: workspaceId }),
+            sort: 'position',
+        });
+        return records.map((r) => ({
+            id: r['id'],
+            name: r['name'],
+            default_status: r['default_status'] ?? null,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function listTaskStatuses(_workspaceId) {
+    // Task statuses are defined in the schema, not per-workspace.
+    // Return the standard set.
+    return ['Backlog', 'To Do', 'In Progress', 'In Review', 'Done', 'Cancelled'];
+}
+export async function getTaskProps(objectId, workspaceId) {
+    const props = await listProperties([objectId], workspaceId);
+    const get = (key) => props.find((p) => p.object_id === objectId && p.key === key);
+    return {
+        status: get('status')?.value_text ?? null,
+        priority: get('priority')?.value_text ?? null,
+        due_date: get('due_date')?.value_date ?? get('due_date')?.value_text ?? null,
+        assignees: (() => {
+            const raw = get('assignees')?.value_text;
+            if (!raw)
+                return [];
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                return [];
+            }
+        })(),
+        labels: parseTaskListProperty(get('tags')?.value_text, get('labels')?.value_text),
+        description: get('description')?.value_text ?? null,
+        task_list_id: get('task_list_id')?.value_ref ?? get('task_list_id')?.value_text ?? null,
+    };
+}
+function parseTaskListProperty(...values) {
+    const items = [];
+    for (const raw of values) {
+        if (!raw)
+            continue;
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                items.push(...parsed.map((entry) => String(entry).trim()).filter(Boolean));
+                continue;
+            }
+        }
+        catch {
+            // Fall through to comma-separated legacy/current property storage.
+        }
+        items.push(...raw.split(',').map((entry) => entry.trim()).filter(Boolean));
+    }
+    return [...new Set(items)];
+}
+export async function updateTaskProps(objectId, workspaceId, patch) {
+    const obj = await getObject(objectId, workspaceId);
+    if (!obj)
+        throw new Error(`Object ${objectId} not found in this workspace`);
+    if (obj.type !== 'task')
+        throw new Error(`${objectId} is not a task`);
+    const client = getAuroraClient();
+    const upsert = async (key, valueType, value) => {
+        if (value === null || value === '')
+            return;
+        const existing = await client.collection('object_properties').list({
+            filter: client.filter('object_id = {:oid} && key = {:key}', { oid: objectId, key }),
+        });
+        const valueField = valueType === 'number' ? 'value_num' :
+            valueType === 'date' ? 'value_date' :
+                valueType === 'boolean' ? 'value_bool' :
+                    valueType === 'ref' ? 'value_ref' :
+                        'value_text';
+        if (existing.length > 0) {
+            await client.collection('object_properties').update(String(existing[0].id), { value_type: valueType, [valueField]: value });
+        }
+        else {
+            await client.collection('object_properties').create({ object_id: objectId, key, value_type: valueType, [valueField]: value });
+        }
+    };
+    if (patch.status !== undefined)
+        await upsert('status', 'text', patch.status);
+    if (patch.priority !== undefined)
+        await upsert('priority', 'text', patch.priority);
+    if (patch.due_date !== undefined)
+        await upsert('due_date', 'date', patch.due_date);
+    if (patch.description !== undefined)
+        await upsert('description', 'text', patch.description);
+    if (patch.task_list_id !== undefined)
+        await upsert('task_list_id', 'ref', patch.task_list_id);
+    if (patch.assignees !== undefined)
+        await upsert('assignees', 'text', JSON.stringify(patch.assignees));
+    if (patch.labels !== undefined)
+        await upsert('labels', 'text', JSON.stringify(patch.labels));
+}
+export async function listPlanningTasks(workspaceId) {
+    const tasks = await listObjects(workspaceId, 'task');
+    const results = [];
+    for (const task of tasks) {
+        const props = await getTaskProps(task.id, workspaceId);
+        results.push({
+            id: task.id,
+            title: task.title,
+            updated_at: task.updated_at,
+            ...props,
+        });
+    }
+    return results;
+}
+export async function readCanvasContent(workspaceId, objectId) {
+    const object = await getObject(objectId, workspaceId);
+    if (!object)
+        return null;
+    if (object.type !== 'canvas')
+        throw new Error(`${objectId} is not a canvas`);
+    const contentJson = await getContentJson(objectId, workspaceId);
+    return { object, contentJson };
+}
+export async function createPlanningTimeBlock(workspaceId, input) {
+    const object = await createObject(workspaceId, 'task', input.title);
+    await updateTaskProps(object.id, workspaceId, {
+        due_date: input.dueDate,
+        labels: input.labels,
+        description: input.description,
+    });
+    return object;
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function mapObject(r) {
+    return {
+        id: r['id'],
+        workspace_id: r['workspace_id'],
+        type: r['type'],
+        title: r['title'] ?? null,
+        icon: r['icon'] ?? null,
+        parent_id: r['parent_id'] ?? null,
+        is_deleted: Boolean(r['is_deleted']),
+        is_template: Boolean(r['is_template']),
+        created_at: r['created_at'],
+        updated_at: r['updated_at'],
+    };
+}
+function extractTextFromDoc(doc) {
+    const parts = [];
+    function walk(node) {
+        if (typeof node['text'] === 'string')
+            parts.push(node['text']);
+        const content = node['content'];
+        if (content)
+            content.forEach(walk);
+    }
+    walk(doc);
+    return parts.join(' ').slice(0, 3000);
+}
+function normalizeWorkspaceKnowledgeResponse(payload) {
+    const items = Array.isArray(payload?.items)
+        ? payload.items
+            .map((item) => normalizeWorkspaceKnowledgeSource(item))
+            .filter((item) => item !== null)
+        : [];
+    return {
+        workspaceId: typeof payload?.workspaceId === 'string' ? payload.workspaceId : '',
+        query: typeof payload?.query === 'string' ? payload.query : null,
+        limit: typeof payload?.limit === 'number' && Number.isFinite(payload.limit) ? payload.limit : items.length,
+        items,
+    };
+}
+function normalizeWorkspaceKnowledgeSource(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const kind = normalizeWorkspaceKnowledgeKind(value.kind);
+    const objectId = typeof value.objectId === 'string' ? value.objectId.trim() : '';
+    const workspaceId = typeof value.workspaceId === 'string' ? value.workspaceId.trim() : '';
+    const title = typeof value.title === 'string' ? value.title : null;
+    const objectType = typeof value.objectType === 'string' ? value.objectType : 'page';
+    const icon = typeof value.icon === 'string' ? value.icon : null;
+    const breadcrumb = Array.isArray(value.breadcrumb)
+        ? value.breadcrumb.filter((entry) => typeof entry === 'string')
+        : [];
+    const deepLink = typeof value.deepLink === 'string' ? value.deepLink : objectId ? `/object/${objectId}` : '';
+    const snippet = typeof value.snippet === 'string' ? value.snippet : null;
+    const plainText = typeof value.plainText === 'string' ? value.plainText : null;
+    const blockId = typeof value.blockId === 'string' ? value.blockId : null;
+    const updatedAt = typeof value.updatedAt === 'string' ? value.updatedAt : new Date().toISOString();
+    const score = typeof value.score === 'number' && Number.isFinite(value.score) ? value.score : null;
+    const matchedFields = Array.isArray(value.matchedFields)
+        ? value.matchedFields.filter((field) => field === 'title' || field === 'content' || field === 'properties' || field === 'relationships')
+        : [];
+    const availability = normalizeWorkspaceKnowledgeAvailability(value.availability);
+    const relationships = Array.isArray(value.relationships)
+        ? value.relationships
+            .map((relationship) => normalizeWorkspaceKnowledgeRelationship(relationship))
+            .filter((relationship) => relationship !== null)
+        : [];
+    const sourceId = typeof value.sourceId === 'string' && value.sourceId.trim().length
+        ? value.sourceId.trim()
+        : buildWorkspaceKnowledgeSourceId(kind, objectId);
+    if (!workspaceId || !objectId || !deepLink)
+        return null;
+    return {
+        sourceId,
+        workspaceId,
+        objectId,
+        kind,
+        title,
+        objectType,
+        icon,
+        breadcrumb,
+        deepLink,
+        snippet,
+        plainText,
+        blockId,
+        updatedAt,
+        score,
+        matchedFields,
+        availability,
+        relationships,
+    };
+}
+function normalizeWorkspaceKnowledgeKind(value) {
+    return value === 'content_chunk'
+        || value === 'property'
+        || value === 'comment'
+        || value === 'attachment_metadata'
+        || value === 'relationship'
+        ? value
+        : 'object';
+}
+function normalizeWorkspaceKnowledgeAvailability(value) {
+    return WORKSPACE_KNOWLEDGE_AVAILABILITY_STATES.includes(value)
+        ? value
+        : 'available';
+}
+function normalizeWorkspaceKnowledgeRelationship(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const type = value.type;
+    const objectId = typeof value.objectId === 'string' ? value.objectId.trim() : '';
+    if (!WORKSPACE_KNOWLEDGE_RELATIONSHIP_TYPES.includes(type) || !objectId) {
+        return null;
+    }
+    return {
+        type: type,
+        objectId,
+        title: typeof value.title === 'string' ? value.title : null,
+    };
+}
+function buildWorkspaceKnowledgeSourceId(kind, objectId, suffix) {
+    const normalizedSuffix = suffix === undefined || suffix === null ? '' : `:${String(suffix)}`;
+    switch (kind) {
+        case 'object':
+            return `object:${objectId}`;
+        case 'content_chunk':
+            return `chunk:${objectId}${normalizedSuffix}`;
+        case 'property':
+            return `property:${objectId}${normalizedSuffix}`;
+        case 'relationship':
+            return `relationship:${objectId}${normalizedSuffix}`;
+        case 'comment':
+            return `comment:${objectId}${normalizedSuffix}`;
+        case 'attachment_metadata':
+            return `attachment:${objectId}${normalizedSuffix}`;
+        default:
+            return `${kind}:${objectId}${normalizedSuffix}`;
+    }
+}
+function getAuroraApiUrl() {
+    const value = process.env['AURORA_API_URL']?.trim();
+    if (!value)
+        throw new Error('AURORA_API_URL environment variable is required for AuroraCloud MCP mode');
+    return value.replace(/\/+$/, '');
+}
+async function ensureAuthRecord() {
+    const client = getAuroraClient();
+    if (client.authStore.record?.['id'])
+        return;
+    if (!client.authStore.token)
+        throw new Error('Authenticated token missing.');
+    const response = await client.request('/auth/me', { method: 'GET' });
+    client.authStore.save(client.authStore.token, response.user);
+}
+function createAuroraCloudClient(baseUrl) {
+    const authStore = {
+        token: '',
+        record: null,
+        save(token, record) {
+            this.token = token;
+            this.record = record;
+        },
+    };
+    const filter = (template, params) => template.replace(/\{:(\w+)\}/g, (_match, key) => {
+        const value = params[key];
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        return `"${String(value ?? '').replaceAll('"', '\\"')}"`;
+    });
+    const request = async (path, options = {}) => {
+        const headers = new Headers();
+        if (authStore.token)
+            headers.set('authorization', `Bearer ${authStore.token}`);
+        if (options.body !== undefined)
+            headers.set('content-type', 'application/json');
+        const response = await fetch(`${baseUrl}${path.startsWith('/') ? path : `/${path}`}`, {
+            method: options.method ?? 'GET',
+            headers,
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+        });
+        if (!response.ok) {
+            let message = `${response.status} ${response.statusText}`;
+            try {
+                const json = await response.json();
+                message = json.error ?? json.message ?? message;
+            }
+            catch {
+                // ignore parse failure
+            }
+            throw new Error(message);
+        }
+        if (response.status === 204)
+            return undefined;
+        return await response.json();
+    };
+    const collection = (name) => ({
+        async list(options = {}) {
+            const pageSize = options.batch ?? 500;
+            const first = await request(`/api/collections/${name}/records?${toQueryString(1, pageSize, options)}`, { method: 'GET' });
+            const items = [...first.items];
+            for (let page = 2; page <= (first.totalPages ?? 1); page += 1) {
+                const next = await request(`/api/collections/${name}/records?${toQueryString(page, pageSize, options)}`, { method: 'GET' });
+                items.push(...next.items);
+            }
+            return items;
+        },
+        async get(id) {
+            return request(`/api/collections/${name}/records/${encodeURIComponent(id)}`, { method: 'GET' });
+        },
+        async create(data) {
+            if (name === 'users') {
+                const result = await request('/auth/register', {
+                    method: 'POST',
+                    body: {
+                        email: data['email'],
+                        password: data['password'],
+                        displayName: data['name'] ?? data['display_name'] ?? null,
+                    },
+                });
+                authStore.save(result.accessToken, result.user);
+                return result.user;
+            }
+            return request(`/api/collections/${name}/records`, { method: 'POST', body: data });
+        },
+        async update(id, data) {
+            return request(`/api/collections/${name}/records/${encodeURIComponent(id)}`, {
+                method: 'PATCH',
+                body: data,
+            });
+        },
+        async authWithPassword(email, password) {
+            const result = await request('/auth/login', { method: 'POST', body: { email, password } });
+            authStore.save(result.accessToken, result.user);
+            return { record: result.user, token: result.accessToken };
+        },
+    });
+    return { authStore, filter, collection, request };
+}
+function toQueryString(page, perPage, options) {
+    const params = new URLSearchParams({
+        page: String(page),
+        perPage: String(perPage),
+    });
+    if (options.filter)
+        params.set('filter', options.filter);
+    if (options.sort)
+        params.set('sort', options.sort);
+    if (options.expand)
+        params.set('expand', options.expand);
+    return params.toString();
+}