"""PostgreSQL repository: all SQL values are bound parameters.""" from datetime import datetime, timezone import hashlib import json from uuid import UUID, uuid4 import psycopg from .domain import ApiError, invalid def serialize(row): if row is None: return None result = {} for key, value in row.items(): if isinstance(value, UUID): value = str(value) elif isinstance(value, datetime): value = value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z') elif isinstance(value, list): value = [str(item) if isinstance(item, UUID) else item for item in value] result[key] = value return result USER_COLUMNS = 'id, username, display_name, created_at' # Members retain the request order, with no password/session fields in public objects. CHAT_COLUMNS = '''c.id, c.title, c.created_at, ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id=c.id ORDER BY m.position) AS member_ids''' class PostgresRepository: def __init__(self, database): self.db = database def ready(self): with self.db.transaction() as conn: conn.execute('SELECT id FROM users LIMIT 0') conn.execute('SELECT token_hash FROM sessions LIMIT 0') def cursor_key(self): with self.db.transaction() as conn: row = conn.execute("SELECT value FROM app_settings WHERE name='cursor_key'").fetchone() if row is None: raise ApiError(503, 'unavailable', 'Database is not initialized') return bytes.fromhex(row['value']) def create_user(self, username, display_name, password_hash): try: with self.db.transaction() as conn: row = conn.execute('INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING ' + USER_COLUMNS, (uuid4(), username, display_name, password_hash)).fetchone() return serialize(row) except psycopg.errors.UniqueViolation: raise ApiError(409, 'conflict', 'Username already exists') from None def credentials(self, username): with self.db.transaction() as conn: return serialize(conn.execute('SELECT ' + USER_COLUMNS + ', password_hash FROM users WHERE username=%s', (username,)).fetchone()) def create_session(self, user_id, token_hash, ttl): with self.db.transaction() as conn: row = conn.execute('INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,clock_timestamp() + %s * interval \'1 second\') RETURNING expires_at', (token_hash, user_id, ttl)).fetchone() return serialize(row)['expires_at'] def session_user(self, token_hash): with self.db.transaction() as conn: row = conn.execute('''SELECT u.id,u.username,u.display_name,u.created_at FROM users u JOIN sessions s ON s.user_id=u.id WHERE s.token_hash=%s AND s.expires_at>clock_timestamp()''', (token_hash,)).fetchone() if row is None: raise ApiError(401, 'unauthorized', 'Valid Bearer session required') return serialize(row) def revoke_session(self, token_hash): with self.db.transaction() as conn: conn.execute('DELETE FROM sessions WHERE token_hash=%s', (token_hash,)) @staticmethod def _access(conn, actor, chat_id): if conn.execute('SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s', (chat_id, actor)).fetchone() is None: raise ApiError(404, 'not_found', 'Chat not found') def create_chat(self, actor, title, members): with self.db.transaction() as conn: count = conn.execute('SELECT count(*) AS n FROM users WHERE id=ANY(%s::uuid[])', (members,)).fetchone()['n'] if actor not in members or count != len(members): invalid('Members must exist and include the current user') identifier = uuid4() conn.execute('INSERT INTO chats(id,title) VALUES (%s,%s)', (identifier, title)) with conn.cursor() as cur: cur.executemany('INSERT INTO chat_members(chat_id,user_id,position) VALUES (%s,%s,%s)', [(identifier, member, i) for i, member in enumerate(members)]) row = conn.execute('SELECT ' + CHAT_COLUMNS + ' FROM chats c WHERE c.id=%s', (identifier,)).fetchone() return serialize(row) def chat(self, actor, chat_id): with self.db.transaction() as conn: self._access(conn, actor, chat_id) row = conn.execute('SELECT ' + CHAT_COLUMNS + ' FROM chats c WHERE c.id=%s', (chat_id,)).fetchone() return serialize(row) def chats(self, actor, limit, after): params = [actor] boundary = '' if after is not None: boundary = ' AND (c.created_at,c.id)>(%s::timestamptz,%s::uuid)' params.extend(after) params.append(limit) with self.db.transaction() as conn: rows = conn.execute('SELECT ' + CHAT_COLUMNS + ''' FROM chats c JOIN chat_members own ON own.chat_id=c.id WHERE own.user_id=%s''' + boundary + ' ORDER BY c.created_at,c.id LIMIT %s', params).fetchall() return [serialize(r) for r in rows] def create_message(self, actor, chat_id, text, key, ttl): # The operation is POST /chats/{id}/messages only. Method is implicit in # this dedicated table. A transaction lock serializes this exact scope # across ALL processes; a hash collision only adds harmless contention. scope = json.dumps([actor, chat_id, key], separators=(',', ':')).encode() lock_id = int.from_bytes(hashlib.sha256(scope).digest()[:8], 'big', signed=True) with self.db.transaction() as conn: self._access(conn, actor, chat_id) conn.execute('SELECT pg_advisory_xact_lock(%s)', (lock_id,)) previous = conn.execute("""SELECT r.request_text, m.* FROM message_requests r JOIN messages m ON m.id=r.message_id WHERE r.user_id=%s AND r.chat_id=%s AND r.idempotency_key=%s AND r.expires_at>clock_timestamp()""", (actor, chat_id, key)).fetchone() if previous: if previous.pop('request_text') != text: raise ApiError(409, 'conflict', 'Idempotency key already used with another message') return serialize(previous) conn.execute('DELETE FROM message_requests WHERE user_id=%s AND chat_id=%s AND idempotency_key=%s', (actor, chat_id, key)) row = conn.execute('INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *', (uuid4(), chat_id, actor, text)).fetchone() conn.execute("""INSERT INTO message_requests(user_id,chat_id,idempotency_key,request_text,message_id,expires_at) VALUES (%s,%s,%s,%s,%s,clock_timestamp() + %s * interval '1 second')""", (actor, chat_id, key, text, row['id'], ttl)) return serialize(row) def messages(self, actor, chat_id, limit, after): params = [chat_id] boundary = '' if after is not None: boundary = ' AND (created_at,id)>(%s::timestamptz,%s::uuid)' params.extend(after) params.append(limit) with self.db.transaction() as conn: self._access(conn, actor, chat_id) rows = conn.execute('SELECT * FROM messages WHERE chat_id=%s' + boundary + ' ORDER BY created_at,id LIMIT %s', params).fetchall() return [serialize(r) for r in rows]