sync: 鍚屾灞€鍩熺綉鏈€鏂颁唬鐮?(source master @ b69568e4)

This commit is contained in:
gozeros committed 2026-10-21 14:51:31 +08:00
1 parent 4f7f07504a
commit 8bc8b0e082
1651 files changed
+278599 -11416

No files matched your search

@@ -15,13 +15,13 @@ from __future__ import annotations
from datetime import UTC
from uuid import UUID
from sqlalchemy import func, select
from sqlalchemy import func, select, update
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from app.gateway.auth.models import User
from app.gateway.auth.repositories.base import UserNotFoundError, UserRepository
from deerflow.persistence.user.model import UserRow
from app.gateway.auth.repositories.base import CredentialConflictError, UserNotFoundError, UserRepository
from deerflow.persistence.user.model import AuthInitializationRow, AuthUsernameRow, UserRow
class SQLiteUserRepository(UserRepository):
@@ -72,6 +72,7 @@ class SQLiteUserRepository(UserRepository):
"""Insert a new user. Raises ``ValueError`` on duplicate email."""
row = self._user_to_row(user)
async with self._sf() as session:
await self._reserve_username(session, user.email)
session.add(row)
try:
await session.commit()
@@ -80,13 +81,43 @@ class SQLiteUserRepository(UserRepository):
raise ValueError(f"Email already registered: {user.email}") from exc
return user
@staticmethod
async def _reserve_username(session: AsyncSession, email: str) -> None:
"""Fence new registrations without rewriting historical user rows."""
local = email.split("@", 1)[0].lower()
escaped = local.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
existing = await session.scalar(select(UserRow.id).where(func.lower(UserRow.email).like(f"{escaped}@%", escape="\\")).limit(1))
if existing is not None:
raise ValueError("Username already registered")
session.add(AuthUsernameRow(username=local))
async def create_initial_admin(self, user: User) -> User:
"""Claim a singleton and create the first admin in one transaction.
A unique primary key fences concurrent requests across Gateway workers,
including requests using different email addresses.
"""
async with self._sf() as session:
count = await session.scalar(select(func.count()).select_from(UserRow).where(UserRow.system_role == "admin"))
if count:
raise ValueError("System already initialized")
await self._reserve_username(session, user.email)
session.add(AuthInitializationRow(id="initial-admin"))
session.add(self._user_to_row(user))
try:
await session.commit()
except IntegrityError as exc:
await session.rollback()
raise ValueError("System already initialized") from exc
return user
async def get_user_by_id(self, user_id: str) -> User | None:
async with self._sf() as session:
row = await session.get(UserRow, user_id)
return self._row_to_user(row) if row is not None else None
async def get_user_by_email(self, email: str) -> User | None:
stmt = select(UserRow).where(UserRow.email == email)
stmt = select(UserRow).where(func.lower(UserRow.email) == email.strip().lower()).order_by(UserRow.created_at.asc()).limit(1)
async with self._sf() as session:
result = await session.execute(stmt)
row = result.scalar_one_or_none()
@@ -102,12 +133,7 @@ class SQLiteUserRepository(UserRepository):
pattern = f"{escaped}@%"
# Case-insensitive prefix match on the email field, oldest first so a
# subsequent registration cannot shadow an existing account.
stmt = (
select(UserRow)
.where(func.lower(UserRow.email).like(pattern, escape="\\"))
.order_by(UserRow.created_at.asc())
.limit(1)
)
stmt = select(UserRow).where(func.lower(UserRow.email).like(pattern, escape="\\")).order_by(UserRow.created_at.asc()).limit(1)
async with self._sf() as session:
result = await session.execute(stmt)
row = result.scalar_one_or_none()
@@ -124,12 +150,7 @@ class SQLiteUserRepository(UserRepository):
# Prefilter in SQL on the whole email (portable across sqlite/postgres/
# mysql), then keep only rows whose *local part* contains the term so a
# domain-only hit (e.g. searching "gmail") doesn't pull unrelated users.
stmt = (
select(UserRow)
.where(func.lower(UserRow.email).like(pattern, escape="\\"))
.order_by(UserRow.created_at.asc())
.limit(max(1, limit))
)
stmt = select(UserRow).where(func.lower(UserRow.email).like(pattern, escape="\\")).order_by(UserRow.created_at.asc()).limit(max(1, limit))
async with self._sf() as session:
result = await session.execute(stmt)
rows = result.scalars().all()
@@ -142,26 +163,85 @@ class SQLiteUserRepository(UserRepository):
async def update_user(self, user: User) -> User:
async with self._sf() as session:
row = await session.get(UserRow, str(user.id))
if row is None:
# Hard fail on concurrent delete: callers (reset_admin,
# password change handlers, _ensure_admin_user) all
# fetched the user just before this call, so a missing
# row here means the row vanished underneath us. Silent
# success would let the caller log "password reset" for
# a row that no longer exists.
raise UserNotFoundError(f"User {user.id} no longer exists")
row.email = user.email
row.password_hash = user.password_hash
row.system_role = user.system_role
row.oauth_provider = user.oauth_provider
row.oauth_id = user.oauth_id
row.needs_setup = user.needs_setup
row.token_version = user.token_version
row.approved = user.approved
row.login_password = user.login_password
# Profile/approval writes cannot restore credentials from a stale
# User object after a concurrent password reset.
result = await session.execute(
update(UserRow)
.where(UserRow.id == str(user.id), UserRow.token_version == user.token_version)
.values(
email=user.email,
system_role=user.system_role,
oauth_provider=user.oauth_provider,
oauth_id=user.oauth_id,
needs_setup=user.needs_setup,
approved=user.approved,
)
)
if result.rowcount != 1:
row = await session.get(UserRow, str(user.id))
await session.rollback()
if row is None:
raise UserNotFoundError(f"User {user.id} no longer exists")
raise CredentialConflictError("账号密码已更新,请刷新后重试")
await session.commit()
return user
async def update_credentials(self, user: User, password_hash: str | None, *, email: str | None = None) -> User:
values = {
"password_hash": password_hash,
"login_password": password_hash,
"token_version": UserRow.token_version + 1,
"needs_setup": False,
}
if email is not None:
values["email"] = email
async with self._sf() as session:
if email is not None and email.split("@", 1)[0].lower() != user.email.split("@", 1)[0].lower():
await self._reserve_username(session, email)
with session.no_autoflush:
result = await session.execute(update(UserRow).where(UserRow.id == str(user.id), UserRow.token_version == user.token_version).values(**values))
if result.rowcount != 1:
await session.rollback()
raise CredentialConflictError("账号密码已更新,请重新登录后操作")
try:
await session.commit()
except IntegrityError as exc:
await session.rollback()
raise ValueError("Email already registered") from exc
user.password_hash = password_hash
user.login_password = password_hash
user.token_version += 1
user.needs_setup = False
if email is not None:
user.email = email
return user
async def start_login_session(self, user: User) -> User:
"""Atomically fence older logins without accepting a concurrently reset password.
Ordinary login races may advance the version again; the last issued
generation alone remains usable. Credential/approval changes after the
original check require the caller to authenticate again instead.
"""
async with self._sf() as session:
result = await session.execute(
update(UserRow)
.where(
UserRow.id == str(user.id),
UserRow.password_hash == user.password_hash,
UserRow.login_password == user.login_password,
UserRow.approved == user.approved,
UserRow.system_role == user.system_role,
)
.values(token_version=UserRow.token_version + 1)
)
if result.rowcount != 1:
await session.rollback()
raise CredentialConflictError("账号凭据或权限已变更,请重新登录")
row = (await session.execute(select(UserRow).where(UserRow.id == str(user.id)))).scalar_one()
saved = self._row_to_user(row)
await session.commit()
return saved
async def count_users(self) -> int:
stmt = select(func.count()).select_from(UserRow)