sync: 鍚屾灞€鍩熺綉鏈€鏂颁唬鐮?(source master @ b69568e4)
This commit is contained in:
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)
|
||||
|
||||
Reference in new issue
Block a user