libre-webui 0.21.3 → 0.22.0

package/backend/dist/persistence/postgresResourceRepositories.js

@@ -0,0 +1,776 @@
+/*
+ * Libre WebUI
+ * Copyright (C) 2025 Kroonen AI, Inc.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { PersistenceResourceConflictError, PersistenceResourceDeletionReservedError, PersistenceResourceLimitError, } from './resourceTypes.js';
+const number = (value, field) => {
+    const converted = typeof value === 'number' ? value : Number(value);
+    if (!Number.isSafeInteger(converted)) {
+        throw new Error(`PostgreSQL returned an invalid ${field}`);
+    }
+    return converted;
+};
+const chatSession = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'session created_at'),
+    updated_at: number(row.updated_at, 'session updated_at'),
+    archived: number(row.archived, 'session archived'),
+    pinned: number(row.pinned, 'session pinned'),
+});
+const chatMessage = (row) => ({
+    ...row,
+    timestamp: number(row.timestamp, 'message timestamp'),
+    message_index: number(row.message_index, 'message index'),
+    branch_index: number(row.branch_index, 'message branch index'),
+    is_active: number(row.is_active, 'message active state'),
+    rating: row.rating === null ? null : number(row.rating, 'message rating'),
+});
+const namedResource = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'resource created_at'),
+    updated_at: number(row.updated_at, 'resource updated_at'),
+});
+const note = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'note created_at'),
+    updated_at: number(row.updated_at, 'note updated_at'),
+});
+const changes = (rowCount) => rowCount ?? 0;
+const lockOwner = async (client, userId) => {
+    const result = await client.query('SELECT id FROM users WHERE id = $1 FOR UPDATE', [userId]);
+    if (result.rowCount !== 1)
+        throw new Error('Resource owner does not exist');
+};
+class PostgresChatSessionRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async replaceAggregate(client, aggregate) {
+        await lockOwner(client, aggregate.session.user_id);
+        const result = await client.query(`INSERT INTO sessions
+         (id, user_id, title, model, persona_id, provider_type, provider_id,
+          created_at, updated_at, archived, settings, folder_id, pinned)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+       ON CONFLICT (id) DO UPDATE SET
+         title = EXCLUDED.title,
+         model = EXCLUDED.model,
+         persona_id = EXCLUDED.persona_id,
+         provider_type = EXCLUDED.provider_type,
+         provider_id = EXCLUDED.provider_id,
+         updated_at = EXCLUDED.updated_at,
+         archived = EXCLUDED.archived,
+         settings = EXCLUDED.settings,
+         folder_id = EXCLUDED.folder_id,
+         pinned = EXCLUDED.pinned
+       WHERE sessions.user_id = EXCLUDED.user_id`, [
+            aggregate.session.id,
+            aggregate.session.user_id,
+            aggregate.session.title,
+            aggregate.session.model,
+            aggregate.session.persona_id,
+            aggregate.session.provider_type,
+            aggregate.session.provider_id,
+            aggregate.session.created_at,
+            aggregate.session.updated_at,
+            aggregate.session.archived,
+            aggregate.session.settings,
+            aggregate.session.folder_id,
+            aggregate.session.pinned,
+        ]);
+        if (result.rowCount !== 1)
+            throw new PersistenceResourceConflictError();
+        await client.query('DELETE FROM session_messages WHERE session_id = $1', [
+            aggregate.session.id,
+        ]);
+        for (const message of aggregate.messages) {
+            if (message.session_id !== aggregate.session.id) {
+                throw new Error('A chat message does not belong to its aggregate');
+            }
+            await client.query(`INSERT INTO session_messages
+           (id, session_id, role, content, thinking, timestamp, message_index,
+            model, provider_metadata, images, statistics, artifacts,
+            parent_id, branch_index, is_active, rating)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12,
+                 $13, $14, $15, $16)`, [
+                message.id,
+                message.session_id,
+                message.role,
+                message.content,
+                message.thinking,
+                message.timestamp,
+                message.message_index,
+                message.model,
+                message.provider_metadata,
+                message.images,
+                message.statistics,
+                message.artifacts,
+                message.parent_id,
+                message.branch_index,
+                message.is_active,
+                message.rating,
+            ]);
+        }
+    }
+    async listByOwner(userId) {
+        const result = await this.database.query(`SELECT s.*,
+              COALESCE(
+                json_agg(to_jsonb(m) ORDER BY m.message_index, m.branch_index)
+                  FILTER (WHERE m.id IS NOT NULL),
+                '[]'::json
+              ) AS messages
+         FROM sessions s
+         LEFT JOIN session_messages m ON m.session_id = s.id
+        WHERE s.user_id = $1
+        GROUP BY s.id
+        ORDER BY s.updated_at DESC`, [userId]);
+        return result.rows.map(row => {
+            const rawMessages = Array.isArray(row.messages) ? row.messages : [];
+            return {
+                session: chatSession(row),
+                messages: rawMessages.map(item => chatMessage(item)),
+            };
+        });
+    }
+    async findByOwner(sessionId, userId) {
+        const sessionResult = await this.database.query('SELECT * FROM sessions WHERE id = $1 AND user_id = $2', [sessionId, userId]);
+        const session = sessionResult.rows[0];
+        if (!session)
+            return null;
+        const messageResult = await this.database.query(`SELECT * FROM session_messages
+        WHERE session_id = $1
+        ORDER BY message_index ASC, branch_index ASC`, [sessionId]);
+        return {
+            session: chatSession(session),
+            messages: messageResult.rows.map(chatMessage),
+        };
+    }
+    async replace(aggregate, beforeCommit) {
+        await this.database.transaction(async (client) => {
+            await this.replaceAggregate(client, aggregate);
+        }, { isolationLevel: 'serializable', beforeCommit });
+    }
+    async replaceAndEnqueue(aggregate, enqueuer, input, beforeCommit) {
+        if (input.sessionId !== aggregate.session.id ||
+            input.actorUserId !== aggregate.session.user_id) {
+            throw new Error('Chat generation enqueue does not match its aggregate');
+        }
+        await this.database.transaction(async (client) => {
+            const enqueue = await enqueuer.enqueuePostgres(client, input);
+            if (enqueue.created)
+                await this.replaceAggregate(client, aggregate);
+        }, { isolationLevel: 'serializable', beforeCommit });
+    }
+    async removeMessageIfCurrent(sessionId, userId, messageId, expectedTimestamp, expectedSessionUpdatedAt, previousSessionUpdatedAt, previousActiveMessageId) {
+        return this.database.transaction(async (client) => {
+            const owner = await client.query('SELECT user_id FROM sessions WHERE id = $1 FOR UPDATE', [sessionId]);
+            if (owner.rows[0]?.user_id !== userId)
+                return false;
+            const target = await client.query(`SELECT timestamp, parent_id, is_active
+             FROM session_messages
+            WHERE id = $1 AND session_id = $2 FOR UPDATE`, [messageId, sessionId]);
+            const row = target.rows[0];
+            if (!row ||
+                number(row.timestamp, 'message timestamp') !== expectedTimestamp)
+                return false;
+            const deleted = await client.query(`DELETE FROM session_messages
+            WHERE id = $1 AND session_id = $2 AND timestamp = $3`, [messageId, sessionId, expectedTimestamp]);
+            if (changes(deleted.rowCount) > 0) {
+                await client.query(`UPDATE sessions SET updated_at = $1
+              WHERE id = $2 AND user_id = $3 AND updated_at = $4`, [
+                    previousSessionUpdatedAt,
+                    sessionId,
+                    userId,
+                    expectedSessionUpdatedAt,
+                ]);
+            }
+            if (changes(deleted.rowCount) > 0 &&
+                number(row.is_active, 'message active state') === 1 &&
+                row.parent_id &&
+                previousActiveMessageId) {
+                const active = await client.query(`SELECT 1 FROM session_messages
+              WHERE session_id = $1 AND (id = $2 OR parent_id = $2)
+                AND is_active = 1 LIMIT 1`, [sessionId, row.parent_id]);
+                if (!active.rows[0]) {
+                    await client.query(`UPDATE session_messages SET is_active = 1
+                WHERE id = $1 AND session_id = $2
+                  AND (id = $3 OR parent_id = $3)`, [previousActiveMessageId, sessionId, row.parent_id]);
+                }
+            }
+            return changes(deleted.rowCount) > 0;
+        }, { isolationLevel: 'serializable' });
+    }
+    async deleteByOwner(sessionId, userId, beforeCommit) {
+        return this.database.transaction(async (client) => changes((await client.query('DELETE FROM sessions WHERE id = $1 AND user_id = $2', [sessionId, userId])).rowCount) > 0, { isolationLevel: 'serializable', beforeCommit });
+    }
+    async deleteAllByOwner(userId) {
+        return changes((await this.database.query('DELETE FROM sessions WHERE user_id = $1', [
+            userId,
+        ])).rowCount);
+    }
+}
+class PostgresKnowledgeCollectionRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId) {
+        const result = await this.database.query(`SELECT * FROM knowledge_collections
+        WHERE user_id = $1
+        ORDER BY lower(name), name`, [userId]);
+        return result.rows.map(namedResource);
+    }
+    async replace(collection) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, collection.user_id);
+            const result = await client.query(`INSERT INTO knowledge_collections
+           (id, user_id, name, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5)
+         ON CONFLICT (id) DO UPDATE SET
+           name = EXCLUDED.name,
+           updated_at = EXCLUDED.updated_at
+         WHERE knowledge_collections.user_id = EXCLUDED.user_id`, [
+                collection.id,
+                collection.user_id,
+                collection.name,
+                collection.created_at,
+                collection.updated_at,
+            ]);
+            if (result.rowCount !== 1)
+                throw new PersistenceResourceConflictError();
+        });
+    }
+    async deleteAndDetach(collectionId, userId) {
+        return (changes((await this.database.query('DELETE FROM knowledge_collections WHERE id = $1 AND user_id = $2', [collectionId, userId])).rowCount) > 0);
+    }
+}
+class PostgresNoteRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM notes
+        WHERE user_id = $1
+        ORDER BY updated_at DESC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(note);
+    }
+    async findByOwner(noteId, userId) {
+        const result = await this.database.query('SELECT * FROM notes WHERE id = $1 AND user_id = $2', [noteId, userId]);
+        return result.rows[0] ? note(result.rows[0]) : null;
+    }
+    async replaceWithLimit(value, maximum) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, value.user_id);
+            const existing = await client.query('SELECT user_id FROM notes WHERE id = $1 FOR UPDATE', [value.id]);
+            if (existing.rows[0] && existing.rows[0].user_id !== value.user_id) {
+                throw new PersistenceResourceConflictError();
+            }
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM notes WHERE user_id = $1', [value.user_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('note', maximum);
+                }
+            }
+            const result = await client.query(`INSERT INTO notes (id, user_id, title, content, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6)
+         ON CONFLICT (id) DO UPDATE SET
+           title = EXCLUDED.title,
+           content = EXCLUDED.content,
+           updated_at = EXCLUDED.updated_at
+         WHERE notes.user_id = EXCLUDED.user_id`, [
+                value.id,
+                value.user_id,
+                value.title,
+                value.content,
+                value.created_at,
+                value.updated_at,
+            ]);
+            if (result.rowCount !== 1)
+                throw new PersistenceResourceConflictError();
+        });
+    }
+    async patchByOwner(noteId, userId, patch) {
+        const assignments = [];
+        const values = [];
+        const assign = (column, value) => {
+            values.push(value);
+            assignments.push(`${column} = $${values.length}`);
+        };
+        if (patch.title !== undefined)
+            assign('title', patch.title);
+        if (patch.content !== undefined)
+            assign('content', patch.content);
+        assign('updated_at', patch.updated_at);
+        values.push(noteId, userId);
+        const result = await this.database.query(`UPDATE notes SET ${assignments.join(', ')}
+        WHERE id = $${values.length - 1} AND user_id = $${values.length}
+        RETURNING *`, values);
+        return result.rows[0] ? note(result.rows[0]) : null;
+    }
+    async deleteByOwner(noteId, userId) {
+        return (changes((await this.database.query('DELETE FROM notes WHERE id = $1 AND user_id = $2', [noteId, userId])).rowCount) > 0);
+    }
+}
+class PostgresSessionFolderRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM session_folders
+        WHERE user_id = $1
+        ORDER BY lower(name), name
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(namedResource);
+    }
+    async replaceWithLimit(folder, maximum) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, folder.user_id);
+            const existing = await client.query('SELECT user_id FROM session_folders WHERE id = $1 FOR UPDATE', [folder.id]);
+            if (existing.rows[0] && existing.rows[0].user_id !== folder.user_id) {
+                throw new PersistenceResourceConflictError();
+            }
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM session_folders WHERE user_id = $1', [folder.user_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('session-folder', maximum);
+                }
+            }
+            const result = await client.query(`INSERT INTO session_folders (id, user_id, name, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5)
+         ON CONFLICT (id) DO UPDATE SET
+           name = EXCLUDED.name,
+           updated_at = EXCLUDED.updated_at
+         WHERE session_folders.user_id = EXCLUDED.user_id`, [
+                folder.id,
+                folder.user_id,
+                folder.name,
+                folder.created_at,
+                folder.updated_at,
+            ]);
+            if (result.rowCount !== 1)
+                throw new PersistenceResourceConflictError();
+        });
+    }
+    async deleteAndDetach(folderId, userId) {
+        return (changes((await this.database.query('DELETE FROM session_folders WHERE id = $1 AND user_id = $2', [folderId, userId])).rowCount) > 0);
+    }
+}
+class PostgresPreferenceRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async resolveOwner(userId) {
+        if (userId)
+            return userId;
+        const result = await this.database.query('SELECT id FROM users ORDER BY created_at ASC, id ASC LIMIT 1');
+        return result.rows[0]?.id ?? null;
+    }
+    async listByOwner(userId) {
+        const result = await this.database.query('SELECT key, value FROM user_preferences WHERE user_id = $1 ORDER BY key ASC', [userId]);
+        return result.rows;
+    }
+    async mutateAll(userId, timestamp, mutation) {
+        return this.database.transaction(async (client) => {
+            const owner = userId
+                ? await client.query('SELECT id FROM users WHERE id = $1 FOR UPDATE', [userId])
+                : await client.query(`SELECT id FROM users
+              ORDER BY created_at ASC, id ASC
+              LIMIT 1
+              FOR UPDATE`);
+            const ownerId = owner.rows[0]?.id;
+            if (!ownerId) {
+                if (userId)
+                    throw new Error('Resource owner does not exist');
+                return null;
+            }
+            // READ COMMITTED gives a writer that waited for the owner lock a fresh
+            // snapshot here, including the preceding writer's committed rows.
+            const current = await client.query(`SELECT key, value FROM user_preferences
+          WHERE user_id = $1
+          ORDER BY key ASC`, [ownerId]);
+            const requested = mutation(current.rows);
+            if (requested === undefined) {
+                return { userId: ownerId, preferences: current.rows };
+            }
+            const preferences = [...requested].sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
+            if (new Set(preferences.map(preference => preference.key)).size !==
+                preferences.length) {
+                throw new Error('Preference mutation returned duplicate keys');
+            }
+            await client.query('DELETE FROM user_preferences WHERE user_id = $1', [
+                ownerId,
+            ]);
+            for (const preference of preferences) {
+                await client.query(`INSERT INTO user_preferences
+             (id, user_id, key, value, created_at, updated_at)
+           VALUES ($1, $2, $3, $4, $5, $6)`, [
+                    uuidv4(),
+                    ownerId,
+                    preference.key,
+                    preference.value,
+                    timestamp,
+                    timestamp,
+                ]);
+            }
+            return { userId: ownerId, preferences };
+        }, { isolationLevel: 'read committed' });
+    }
+    async replaceAll(userId, preferences, timestamp) {
+        await this.mutateAll(userId, timestamp, () => preferences);
+    }
+    async deleteKeys(userId, keys) {
+        if (keys.length === 0)
+            return 0;
+        return changes((await this.database.query('DELETE FROM user_preferences WHERE user_id = $1 AND key = ANY($2::text[])', [userId, [...keys]])).rowCount);
+    }
+}
+class PostgresSystemSettingRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async get(key) {
+        const result = await this.database.query('SELECT value FROM system_settings WHERE key = $1', [key]);
+        return result.rows[0]?.value ?? null;
+    }
+    async getMany(keys) {
+        if (keys.length === 0)
+            return {};
+        const result = await this.database.query('SELECT key, value FROM system_settings WHERE key = ANY($1::text[])', [[...keys]]);
+        return Object.fromEntries(result.rows.map(row => [row.key, row.value]));
+    }
+    async upsert(key, value, updatedAt) {
+        await this.database.query(`INSERT INTO system_settings (key, value, updated_at)
+       VALUES ($1, $2, $3)
+       ON CONFLICT (key) DO UPDATE SET
+         value = EXCLUDED.value,
+         updated_at = EXCLUDED.updated_at`, [key, value, updatedAt]);
+    }
+    async upsertMany(values, updatedAt) {
+        await this.database.transaction(async (client) => {
+            for (const [key, value] of Object.entries(values)) {
+                await client.query(`INSERT INTO system_settings (key, value, updated_at)
+           VALUES ($1, $2, $3)
+           ON CONFLICT (key) DO UPDATE SET
+             value = EXCLUDED.value,
+             updated_at = EXCLUDED.updated_at`, [key, value, updatedAt]);
+            }
+        });
+    }
+}
+const ARCHIVE_TABLES = {
+    session: 'sessions',
+    'session-folder': 'session_folders',
+    note: 'notes',
+    'knowledge-collection': 'knowledge_collections',
+    document: 'documents',
+    persona: 'personas',
+};
+class PostgresDataArchiveRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async ownerOf(resource, id) {
+        // The table name is selected only from this closed server-owned map.
+        const result = await this.database.query(`SELECT user_id FROM ${ARCHIVE_TABLES[resource]} WHERE id = $1`, [id]);
+        return result.rows[0]?.user_id ?? null;
+    }
+    async nestedOwnerOf(resource, id) {
+        const definition = resource === 'session-message'
+            ? {
+                child: 'session_messages',
+                owner: 'sessions',
+                parent: 'session_id',
+            }
+            : {
+                child: 'document_chunks',
+                owner: 'documents',
+                parent: 'document_id',
+            };
+        const result = await this.database.query(`SELECT owner.user_id, child.${definition.parent} AS parent_id
+         FROM ${definition.child} child
+         JOIN ${definition.owner} owner ON owner.id = child.${definition.parent}
+        WHERE child.id = $1`, [id]);
+        const row = result.rows[0];
+        return row ? { userId: row.user_id, parentId: row.parent_id } : null;
+    }
+    async countByOwner(resource, userId) {
+        const table = resource === 'session-folder' ? 'session_folders' : 'notes';
+        const result = await this.database.query(`SELECT COUNT(*)::text AS count FROM ${table} WHERE user_id = $1`, [userId]);
+        return number(result.rows[0]?.count || '0', 'archive resource count');
+    }
+    async resourceDeletionReserved(resource, id) {
+        const result = await this.database.query(`SELECT 1 FROM platform_resource_deletion_tombstones
+        WHERE resource_type = $1 AND resource_id = $2`, [resource, id]);
+        return result.rowCount === 1;
+    }
+    async applyImport(plan) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, plan.userId);
+            const shouldWrite = async (table, id) => {
+                const result = await client.query(`SELECT user_id FROM ${table} WHERE id = $1 FOR UPDATE`, [id]);
+                const existing = result.rows[0];
+                if (existing && existing.user_id !== plan.userId) {
+                    throw new PersistenceResourceConflictError();
+                }
+                return !existing || plan.strategy === 'overwrite';
+            };
+            const enforceLimit = async (table, maximum) => {
+                const result = await client.query(`SELECT COUNT(*)::text AS count FROM ${table} WHERE user_id = $1`, [plan.userId]);
+                if (Number(result.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError(table === 'notes' ? 'note' : 'session-folder', maximum);
+                }
+            };
+            const currentPreferences = await client.query(`SELECT key, value FROM user_preferences
+            WHERE user_id = $1
+            ORDER BY key ASC`, [plan.userId]);
+            const preferences = typeof plan.preferences === 'function'
+                ? [...plan.preferences(currentPreferences.rows)]
+                : plan.preferences;
+            await client.query('DELETE FROM user_preferences WHERE user_id = $1', [
+                plan.userId,
+            ]);
+            for (const preference of preferences) {
+                await client.query(`INSERT INTO user_preferences
+             (id, user_id, key, value, created_at, updated_at)
+           VALUES ($1, $2, $3, $4, $5, $6)`, [
+                    uuidv4(),
+                    plan.userId,
+                    preference.key,
+                    preference.value,
+                    plan.timestamp,
+                    plan.timestamp,
+                ]);
+            }
+            for (const folder of plan.sessionFolders) {
+                const write = await shouldWrite('session_folders', folder.id);
+                if (!write)
+                    continue;
+                const existing = await client.query('SELECT 1 FROM session_folders WHERE id = $1', [folder.id]);
+                if (existing.rowCount === 0) {
+                    await enforceLimit('session_folders', plan.maximumSessionFolders);
+                }
+                const result = await client.query(`INSERT INTO session_folders
+             (id, user_id, name, created_at, updated_at)
+           VALUES ($1, $2, $3, $4, $5)
+           ON CONFLICT (id) DO UPDATE SET
+             name = EXCLUDED.name,
+             updated_at = EXCLUDED.updated_at
+           WHERE session_folders.user_id = EXCLUDED.user_id`, [
+                    folder.id,
+                    plan.userId,
+                    folder.name,
+                    folder.created_at,
+                    folder.updated_at,
+                ]);
+                if (result.rowCount !== 1)
+                    throw new PersistenceResourceConflictError();
+            }
+            for (const note of plan.notes) {
+                const write = await shouldWrite('notes', note.id);
+                if (!write)
+                    continue;
+                const existing = await client.query('SELECT 1 FROM notes WHERE id = $1', [note.id]);
+                if (existing.rowCount === 0) {
+                    await enforceLimit('notes', plan.maximumNotes);
+                }
+                const result = await client.query(`INSERT INTO notes
+             (id, user_id, title, content, created_at, updated_at)
+           VALUES ($1, $2, $3, $4, $5, $6)
+           ON CONFLICT (id) DO UPDATE SET
+             title = EXCLUDED.title,
+             content = EXCLUDED.content,
+             updated_at = EXCLUDED.updated_at
+           WHERE notes.user_id = EXCLUDED.user_id`, [
+                    note.id,
+                    plan.userId,
+                    note.title,
+                    note.content,
+                    note.created_at,
+                    note.updated_at,
+                ]);
+                if (result.rowCount !== 1)
+                    throw new PersistenceResourceConflictError();
+            }
+            for (const collection of plan.knowledgeCollections) {
+                if (!(await shouldWrite('knowledge_collections', collection.id))) {
+                    continue;
+                }
+                const result = await client.query(`INSERT INTO knowledge_collections
+             (id, user_id, name, created_at, updated_at)
+           VALUES ($1, $2, $3, $4, $5)
+           ON CONFLICT (id) DO UPDATE SET
+             name = EXCLUDED.name,
+             updated_at = EXCLUDED.updated_at
+           WHERE knowledge_collections.user_id = EXCLUDED.user_id`, [
+                    collection.id,
+                    plan.userId,
+                    collection.name,
+                    collection.created_at,
+                    collection.updated_at,
+                ]);
+                if (result.rowCount !== 1)
+                    throw new PersistenceResourceConflictError();
+            }
+            for (const aggregate of plan.sessions) {
+                const { session } = aggregate;
+                if (!(await shouldWrite('sessions', session.id)))
+                    continue;
+                const result = await client.query(`INSERT INTO sessions
+             (id, user_id, title, model, persona_id, provider_type, provider_id,
+              created_at, updated_at, archived, settings, folder_id, pinned)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+           ON CONFLICT (id) DO UPDATE SET
+             title = EXCLUDED.title,
+             model = EXCLUDED.model,
+             persona_id = EXCLUDED.persona_id,
+             provider_type = EXCLUDED.provider_type,
+             provider_id = EXCLUDED.provider_id,
+             updated_at = EXCLUDED.updated_at,
+             archived = EXCLUDED.archived,
+             settings = EXCLUDED.settings,
+             folder_id = EXCLUDED.folder_id,
+             pinned = EXCLUDED.pinned
+           WHERE sessions.user_id = EXCLUDED.user_id`, [
+                    session.id,
+                    plan.userId,
+                    session.title,
+                    session.model,
+                    session.persona_id,
+                    session.provider_type,
+                    session.provider_id,
+                    session.created_at,
+                    session.updated_at,
+                    session.archived,
+                    session.settings,
+                    session.folder_id,
+                    session.pinned,
+                ]);
+                if (result.rowCount !== 1)
+                    throw new PersistenceResourceConflictError();
+                await client.query('DELETE FROM session_messages WHERE session_id = $1', [session.id]);
+                for (const message of aggregate.messages) {
+                    if (message.session_id !== session.id) {
+                        throw new Error('A chat message does not belong to its aggregate');
+                    }
+                    await client.query(`INSERT INTO session_messages
+               (id, session_id, role, content, thinking, timestamp,
+                message_index, model, provider_metadata, images, statistics,
+                artifacts, parent_id, branch_index, is_active, rating)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12,
+                     NULL, $13, $14, $15)`, [
+                        message.id,
+                        message.session_id,
+                        message.role,
+                        message.content,
+                        message.thinking,
+                        message.timestamp,
+                        message.message_index,
+                        message.model,
+                        message.provider_metadata,
+                        message.images,
+                        message.statistics,
+                        message.artifacts,
+                        message.branch_index,
+                        message.is_active,
+                        message.rating,
+                    ]);
+                }
+                for (const message of aggregate.messages) {
+                    if (message.parent_id) {
+                        await client.query(`UPDATE session_messages
+                  SET parent_id = $1
+                WHERE id = $2 AND session_id = $3`, [message.parent_id, message.id, session.id]);
+                    }
+                }
+            }
+            for (const aggregate of plan.documents) {
+                const { document } = aggregate;
+                await client.query('SELECT pg_advisory_xact_lock(hashtextextended($1, 0))', [JSON.stringify(['libre-resource-v1', 'document', document.id])]);
+                const reserved = await client.query(`SELECT 1 FROM platform_resource_deletion_tombstones
+              WHERE resource_type = 'document' AND resource_id = $1`, [document.id]);
+                if (reserved.rowCount) {
+                    throw new PersistenceResourceDeletionReservedError(document.id);
+                }
+                if (!(await shouldWrite('documents', document.id)))
+                    continue;
+                const result = await client.query(`INSERT INTO documents
+             (id, user_id, filename, title, content, file_type, size,
+              session_id, collection_id, metadata, uploaded_at, created_at,
+              updated_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+           ON CONFLICT (id) DO UPDATE SET
+             filename = EXCLUDED.filename,
+             title = EXCLUDED.title,
+             content = EXCLUDED.content,
+             file_type = EXCLUDED.file_type,
+             size = EXCLUDED.size,
+             session_id = EXCLUDED.session_id,
+             collection_id = EXCLUDED.collection_id,
+             metadata = EXCLUDED.metadata,
+             uploaded_at = EXCLUDED.uploaded_at,
+             updated_at = EXCLUDED.updated_at
+           WHERE documents.user_id = EXCLUDED.user_id`, [
+                    document.id,
+                    plan.userId,
+                    document.filename,
+                    document.title,
+                    document.content,
+                    document.file_type,
+                    document.size,
+                    document.session_id,
+                    document.collection_id,
+                    document.metadata,
+                    document.uploaded_at,
+                    document.created_at,
+                    document.updated_at,
+                ]);
+                if (result.rowCount !== 1)
+                    throw new PersistenceResourceConflictError();
+                await client.query('DELETE FROM document_chunks WHERE document_id = $1', [document.id]);
+                for (const chunk of aggregate.chunks) {
+                    if (chunk.document_id !== document.id) {
+                        throw new Error('A document chunk does not belong to its aggregate');
+                    }
+                    await client.query(`INSERT INTO document_chunks
+               (id, document_id, chunk_index, content, start_char, end_char,
+                embedding, created_at)
+             VALUES ($1, $2, $3, $4, $5, $6, NULL, $7)`, [
+                        chunk.id,
+                        chunk.document_id,
+                        chunk.chunk_index,
+                        chunk.content,
+                        chunk.start_char,
+                        chunk.end_char,
+                        chunk.created_at,
+                    ]);
+                }
+            }
+        }, 
+        // Every owner-scoped archive and preference mutation takes the users row
+        // lock first. READ COMMITTED lets a transaction that waited for that
+        // lock reread the preceding writer's committed preferences before merge.
+        {
+            isolationLevel: 'read committed',
+            beforeCommit: plan.assertCanCommit,
+        });
+    }
+}
+export const createPostgresResourceRepositories = (database) => ({
+    chatSessions: new PostgresChatSessionRepository(database),
+    knowledgeCollections: new PostgresKnowledgeCollectionRepository(database),
+    notes: new PostgresNoteRepository(database),
+    sessionFolders: new PostgresSessionFolderRepository(database),
+    preferences: new PostgresPreferenceRepository(database),
+    systemSettings: new PostgresSystemSettingRepository(database),
+    archive: new PostgresDataArchiveRepository(database),
+});
+/** Create transaction-scoped repositories over one pinned pooled client. */
+export const createPostgresTransactionalResourceRepositories = (database, client) => {
+    const transactionDatabase = {
+        query: client.query.bind(client),
+        transaction: async (operation) => operation(client),
+    };
+    return createPostgresResourceRepositories(transactionDatabase);
+};
+//# sourceMappingURL=postgresResourceRepositories.js.map