Hugging Face's logo

Datasets:
TIGER-Lab
/
WebsiteBench

Languages:
English
Tags:
benchmark
agents
web-agents
website-reconstruction
harbor
Libraries:
Harbor
License:
Dataset card Files
xet
 Community
WebsiteBench / tasks /amazon /tests /oracle-runtime /clone /store.py
AgPerry's picture
AgPerry
Add files using upload-large-folder tool
3c88293 verified
Raw History Blame Contribute Delete
384 kB
from __future__ import annotations
import hashlib
import hmac
import json
import os
import re
import secrets
import sqlite3
import threading
import time
import unicodedata
from pathlib import Path
from typing import Any, Mapping
from urllib.parse import urlparse
from websitebench.site_backend import PaymentError, SiteBackend, SiteBackendError
from websitebench_site_backend_migration import (
NamespaceMigrationError,
migrate_amazon_source_copy,
)
from deals_catalog import load_deals_default_card_offers
from external_verification import ensure_sqlite_email_verified
from home_catalog import load_home_product_catalog
from home_category_catalog import load_home_category_offers
from home_commerce import load_home_commerce_offers
from payment_methods import (
LEGACY_TEST_CARD,
PAYMENT_APPROVED,
SANDBOX_CARD_APPROVED,
payment_method,
payment_method_label,
)
from product_options import (
UNAVAILABLE_SELECTION_COPY,
canonical_selection_key,
default_selection,
load_source_option_specs,
load_source_transaction_quote_specs,
normalize_complete_selection,
resolve_transaction_quote,
)
from product_catalog import (
EXPECTED_PRODUCT_COUNT,
build_product_display_catalog,
display_catalog_summary,
)
from search_commerce import load_search_commerce_cards
from search_catalog import SOURCE_DEPARTMENTS
from stripe_gateway import (
STRIPE_MAX_PRODUCT_LINES,
STRIPE_PROVIDER_SESSION_PATTERN,
STRIPE_SESSION_TTL_SECONDS,
)
from review_store import (
ReviewNotFound,
install_schema as install_review_schema,
list_reviews as list_local_reviews,
register_review_product as register_local_review_product,
reset_review_data,
toggle_helpful_vote as toggle_local_review_helpful,
upsert_review as upsert_local_review,
)
TARGET_ASIN = "B0874XN4D8"
TARGET_QUANTITY = "2"
TASK_ID = "900136"
BEST_SELLERS_PATH = "/Best-Sellers-External-Solid-State-Drives/zgbs/pc/3015429011"
PDP_PATH = "/SAMSUNG-Portable-SSD-1TB-MU-PC1T0T/dp/B0874XN4D8"
DESKTOP_TERMINAL_PATH = "/gp/product/handle-buy-box/ref=dp_start-bbf_1_glance"
MOBILE_TERMINAL_PATH = "/cart/add-to-cart/ref=mw_dp_buy_crt"
TERMINAL_PATHS = {DESKTOP_TERMINAL_PATH, MOBILE_TERMINAL_PATH}
HOME_PDP_EVIDENCE_FIXTURE = "home-pdp-evidence.json"
ACTIVE_CART_STATE = "ACTIVE"
SAVED_CART_STATE = "SAVED"
_CART_STATES = {ACTIVE_CART_STATE, SAVED_CART_STATE}
CART_LINE_ID_PATTERN = re.compile(r"^[A-Za-z0-9_-]{24,128}$")
COMPARE_LINE_ID_PATTERN = re.compile(r"^[A-Za-z0-9_-]{24,128}$")
COMPARE_LIMIT = 4
CHECKOUT_STATES = (
"CART_READY",
"ADDRESS_SELECTED",
"DELIVERY_SELECTED",
"PAYMENT_SELECTED",
"PAYMENT_PENDING",
"PLACED",
)
CHECKOUT_MODE_CART = "CART"
CHECKOUT_MODE_BUY_NOW = "BUY_NOW"
DELIVERY_SHIPPING_MINOR = {"standard": 0, "expedited": 1299}
SUPPORTED_DELIVERY_COUNTRIES: tuple[tuple[str, str], ...] = (
("SG", "Singapore"),
("US", "United States"),
("CA", "Canada"),
("GB", "United Kingdom"),
("AU", "Australia"),
)
SUPPORTED_DELIVERY_COUNTRY_CODES = frozenset(
code for code, _ in SUPPORTED_DELIVERY_COUNTRIES
)
# The frozen storefront baseline is Singapore/USD (clone.yaml `delivery_region`).
# A browser that has never chosen a location resolves to this row.
DEFAULT_DELIVERY_COUNTRY: tuple[str, str] = SUPPORTED_DELIVERY_COUNTRIES[0]
DELIVERY_COUNTRY_LABELS: dict[str, str] = dict(SUPPORTED_DELIVERY_COUNTRIES)
# Kept as an import-compatible name for older callers. The public checkout
# now exposes several explicit sandbox scenarios from payment_methods.py.
TEST_PAYMENT_METHOD = SANDBOX_CARD_APPROVED
STRIPE_TEST_PAYMENT_METHOD = "stripe-test"
ORDER_STATUSES = frozenset(
{
"PREPARING",
"SHIPPED",
"DELIVERED",
"CANCELLED",
"RETURN_REQUESTED",
"RETURN_RECEIVED",
"REFUNDED",
}
)
SHIPMENT_STATUSES = frozenset({"PREPARING", "SHIPPED", "DELIVERED", "CANCELLED"})
RETURN_STATUSES = frozenset({"REQUESTED", "RECEIVED", "REFUNDED"})
RETURN_REASON_CODES = frozenset(
{"DAMAGED", "DEFECTIVE", "NOT_AS_DESCRIBED", "WRONG_ITEM", "NO_LONGER_NEEDED"}
)
RETURN_NOTE_MAX_LENGTH = 500
LOCAL_SIMULATED_CARRIER = "Amazon Clone Local Carrier"
SIMULATION_NOTICE = (
"Simulation only: no real card is charged, no carrier shipment is booked, "
"and no real-world order is created."
)
REDACTED_REJECTED_POST_BODY = "<redacted rejected POST body>"
PASSWORD_SCHEME = "scrypt-v1"
SCRYPT_N = 1 << 14
SCRYPT_R = 8
SCRYPT_P = 1
SCRYPT_DKLEN = 32
SCRYPT_MAXMEM = 64 * 1024 * 1024
PASSWORD_SALT_BYTES = 32
REGISTRATION_CODE_BYTES = 32
REGISTRATION_CODE_TTL_SECONDS = 10 * 60
REGISTRATION_CODE_MAX_ATTEMPTS = 5
PASSWORD_RESET_CODE_TTL_SECONDS = 10 * 60
PASSWORD_RESET_CODE_MAX_ATTEMPTS = 5
AUTH_MAIL_COOLDOWN_SECONDS = 30
AUTH_MAIL_WINDOW_SECONDS = 60 * 60
AUTH_MAIL_MAX_SENDS_PER_WINDOW = 6
MAIL_LOCAL_ONLY = "LOCAL_ONLY"
MAIL_SMTP_PENDING = "SMTP_PENDING"
MAIL_SMTP_SENT = "SMTP_SENT"
MAIL_SMTP_FAILED = "SMTP_FAILED"
MAIL_DELIVERY_STATUSES = frozenset(
{MAIL_LOCAL_ONLY, MAIL_SMTP_PENDING, MAIL_SMTP_SENT, MAIL_SMTP_FAILED}
)
MAIL_DELIVERY_MAX_ATTEMPTS = 3
MAIL_ERROR_SUMMARY_PATTERN = re.compile(
r"[A-Za-z][A-Za-z0-9_]{0,95}(?::smtp-[1-5][0-9]{2})?"
)
SQLITE_INTEGER_MAX = (1 << 63) - 1
ORDER_ACTION_HMAC_KEY = hashlib.sha256(
b"amazon-clone-local-order-action-v1"
).digest()
_DUMMY_SALT = bytes.fromhex(
"7df1c7ca11974cad61c349713f974ba3f07f14b17e3c323cb3449f1560659fbb"
)
def normalize_email(value: str) -> str:
"""Canonical account identifier used consistently for registration and sign-in."""
return unicodedata.normalize("NFKC", value).strip().casefold()
def _scrypt(password: str, salt: bytes) -> bytes:
return hashlib.scrypt(
password.encode("utf-8"),
salt=salt,
n=SCRYPT_N,
r=SCRYPT_R,
p=SCRYPT_P,
dklen=SCRYPT_DKLEN,
maxmem=SCRYPT_MAXMEM,
)
def password_record(password: str) -> tuple[bytes, bytes, str]:
salt = secrets.token_bytes(PASSWORD_SALT_BYTES)
return salt, _scrypt(password, salt), PASSWORD_SCHEME
def verify_password(password: str, salt: bytes, expected_hash: bytes) -> bool:
candidate = _scrypt(password, salt)
return hmac.compare_digest(candidate, expected_hash)
_DUMMY_HASH = _scrypt("amazon-clone-invalid-account", _DUMMY_SALT)
class ContractError(ValueError):
pass
class CheckoutReconciliationRequired(ContractError):
"""A final checkout write atomically invalidated stale browser state."""
def __init__(self, reason: str) -> None:
self.reason = reason
message = {
"cart-changed": (
"the simulated payment is stale; select a sandbox payment method again"
),
"unsupported-delivery-country": (
"checkout delivery country is not supported"
),
}.get(reason, "checkout state must be reviewed")
super().__init__(message)
class CheckoutPaymentLocked(ContractError):
"""A hosted payment owns an immutable checkout snapshot."""
class StripeCheckoutMismatch(ContractError):
"""A provider Session did not match the server-frozen checkout."""
class AddressNotFound(ContractError):
"""The account does not own the requested active address."""
class AddressRevisionConflict(ContractError):
"""An address mutation was based on a stale form revision."""
class AddressInUse(ContractError):
"""An address cannot be deleted while an open checkout references it."""
class OrderNotFound(ContractError):
"""The account does not own the requested order, or the record is absent."""
class OrderStateConflict(ContractError):
"""An order lifecycle transition is not allowed from the current state."""
class ReturnNotFound(ContractError):
"""The requested local return record is absent."""
class OrderActionTokenInvalid(ContractError):
"""A customer order mutation did not carry its session-bound action token."""
class ClosingConnection(sqlite3.Connection):
"""Commit or roll back like sqlite3.Connection, then release Windows handles."""
def __exit__(self, exc_type, exc_value, traceback):
try:
return super().__exit__(exc_type, exc_value, traceback)
finally:
self.close()
class Store:
def __init__(
self,
db_path: Path,
schema_path: Path,
fixture_root: Path,
*,
authorize_legacy_site_binding: bool = False,
legacy_database_path: Path | None = None,
) -> None:
self.db_path = db_path.resolve()
runtime_path = Path(
os.environ.get(
"WEBSITEBENCH_SITE_BACKEND_RUNTIME",
str(Path(__file__).resolve().parents[1] / "backend" / "runtime.json"),
)
)
runtime = json.loads(runtime_path.read_text(encoding="utf-8"))
expected_filename = str(runtime["database"]["filename"])
if self.db_path.name != expected_filename:
raise ContractError(
"Amazon database filename does not match the runtime contract"
)
preflight_database = os.environ.get("WEBSITEBENCH_SITE_BACKEND_DATABASE")
if (
preflight_database is not None
and Path(preflight_database).resolve() != self.db_path
):
raise ContractError(
"Amazon database path does not match the site-backend preflight"
)
if legacy_database_path is not None:
legacy_source = legacy_database_path.resolve()
elif self.db_path.parent.name == "websitebench":
legacy_source = self.db_path.parent.parent / expected_filename
else:
legacy_source = None
if legacy_source is not None and (
legacy_source.name != expected_filename
or legacy_source == self.db_path
):
raise ContractError(
"Amazon legacy database path does not match the runtime contract"
)
self.schema_path = schema_path
self.fixture_root = fixture_root.resolve()
self._home_commerce_offers = load_home_commerce_offers(
self.fixture_root,
load_home_product_catalog(self.fixture_root),
)
self._home_category_offers = list(
load_home_category_offers(self.fixture_root)
)
self._option_specs = load_source_option_specs(self.fixture_root)
self._option_quote_specs = load_source_transaction_quote_specs(
self.fixture_root
)
self._compare_profiles = self._load_compare_profiles()
# Cleartext OTPs are deliberately process-local. SQLite stores only
# salts/hashes and delivery metadata: a delivered code remains
# verifiable after restart, but an unsent outbox cannot replay it.
self._auth_mail_secrets: dict[tuple[str, str], str] = {}
self._auth_mail_secrets_lock = threading.RLock()
self.db_path.parent.mkdir(parents=True, exist_ok=True)
try:
if (
not self.db_path.exists()
and legacy_source is not None
and legacy_source.exists()
):
migrate_amazon_source_copy(
legacy_source,
self.db_path,
expected_site_id="amazon",
authorize_unbound=authorize_legacy_site_binding,
prepare_copy=self._create_schema,
)
elif authorize_legacy_site_binding and not self.db_path.exists():
raise ContractError(
"legacy site binding authorization requires an existing database"
)
# The runtime contract freezes production identity and semantics.
# Tests and migration copies inject only the exact SQLite path.
runtime["database"]["data_dir"] = "."
self.site_backend = SiteBackend.open(
runtime, data_root=self.db_path.parent
)
if self.db_path.is_file() and self.db_path.stat().st_size > 0:
# Existing Amazon databases are already site-bound. Their
# additive business migration must run before the final
# foreign-key check because old schemas can be repairable but
# temporarily violate today's constraints.
self.site_backend.lifecycle.prepare_bound_site_migration()
else:
self.site_backend.lifecycle.initialize()
except ContractError:
raise
except NamespaceMigrationError as exc:
message = str(exc)
if (
"requires explicit site binding" in message
or "does not match the Amazon schema" in message
):
raise ContractError(message) from exc
raise ContractError("Amazon database failed site binding") from exc
except (OSError, ValueError, SiteBackendError) as exc:
raise ContractError("Amazon database failed site binding") from exc
self._create_schema()
try:
self.site_backend.lifecycle.health()
except SiteBackendError as exc:
raise ContractError(
"Amazon database failed post-migration integrity"
) from exc
self._invalidate_unrecoverable_auth_challenges()
def connect(self, database_path: Path | None = None) -> sqlite3.Connection:
conn = sqlite3.connect(
database_path or self.db_path,
timeout=5,
factory=ClosingConnection,
)
conn.row_factory = sqlite3.Row
conn.execute("PRAGMA foreign_keys = ON")
conn.execute("PRAGMA secure_delete = ON")
conn.execute("PRAGMA busy_timeout = 5000")
return conn
def _create_schema(self, database_path: Path | None = None) -> None:
with self.connect(database_path) as conn:
conn.executescript(self.schema_path.read_text(encoding="utf-8"))
# This additive schema must be installed before startup migrations
# begin DML because sqlite3.executescript owns its transaction edge.
install_review_schema(conn)
self._migrate_mail_delivery_schema(conn)
session_columns = {
row["name"] for row in conn.execute("PRAGMA table_info(browser_sessions)")
}
# Every persisted Amazon account is created only after its local or
# external registration challenge succeeds. Other clones must make
# their own explicit legacy-row decision when using this helper.
ensure_sqlite_email_verified(
conn,
table="accounts",
legacy_rows_verified=True,
)
if "account_id" not in session_columns:
conn.execute(
"ALTER TABLE browser_sessions ADD COLUMN account_id INTEGER "
"REFERENCES accounts(account_id) ON DELETE SET NULL"
)
# Databases created before the header delivery-location control
# carry no stored preference. The column is nullable so those rows
# keep resolving to DEFAULT_DELIVERY_COUNTRY without a backfill.
if "delivery_country_code" not in session_columns:
conn.execute(
"ALTER TABLE browser_sessions ADD COLUMN delivery_country_code TEXT"
)
conn.execute(
"CREATE INDEX IF NOT EXISTS browser_sessions_account_idx "
"ON browser_sessions(account_id)"
)
# Existing installations predate the transaction offer registry and
# stored cart lines against catalog_products. Seed every offer first,
# then rebuild that small child table without losing cart contents.
self._sync_commerce_offers(conn)
self._sync_product_display_catalog(conn)
self._migrate_option_selections(conn)
self._migrate_checkout_sessions(conn)
# Removing an old composite primary/unique key requires a SQLite
# table rebuild. Do it with foreign-key enforcement temporarily
# disabled, then validate the entire graph before startup returns.
conn.commit()
conn.execute("PRAGMA foreign_keys = OFF")
try:
conn.execute("BEGIN IMMEDIATE")
self._migrate_cart_line_identity(conn)
self._migrate_compare_item_identity(conn)
self._migrate_checkout_payment_state(conn)
self._migrate_checkout_order_variant_constraints(conn)
self._migrate_payment_attempts_schema(conn)
self._migrate_site_backend_payment_links(conn)
self._migrate_site_backend_mail_links(conn)
conn.commit()
except Exception:
conn.rollback()
raise
finally:
conn.execute("PRAGMA foreign_keys = ON")
self._migrate_address_book_schema(conn)
self._migrate_checkout_sessions(conn)
self._migrate_order_lifecycle_schema(conn)
violations = conn.execute("PRAGMA foreign_key_check").fetchall()
if violations:
raise ContractError("database migration left invalid foreign keys")
@staticmethod
def _migrate_mail_delivery_schema(conn: sqlite3.Connection) -> None:
"""Upgrade auth outboxes without ever copying a legacy cleartext OTP."""
registration_columns = {
row["name"]
for row in conn.execute(
"PRAGMA table_info(auth_registration_email_outbox)"
)
}
registration_required = {
"delivery_attempts",
"claim_token",
"last_error",
"attempted_at",
"sent_at",
}
if (
"verification_code" in registration_columns
or not registration_required.issubset(registration_columns)
):
# No current process can prove possession of a legacy cleartext
# secret. Delete its challenge before rebuilding the table; the
# browser must request a fresh code after migration.
conn.execute("DELETE FROM auth_registration_flows")
conn.execute(
"ALTER TABLE auth_registration_email_outbox "
"RENAME TO auth_registration_email_outbox_legacy"
)
conn.execute(
"""
CREATE TABLE auth_registration_email_outbox (
email_id INTEGER PRIMARY KEY AUTOINCREMENT,
pending_id TEXT NOT NULL UNIQUE
REFERENCES auth_registration_flows(pending_id) ON DELETE CASCADE,
recipient TEXT NOT NULL,
template TEXT NOT NULL
CHECK (template = 'registration-verification'),
status TEXT NOT NULL CHECK (status IN (
'LOCAL_ONLY','SMTP_PENDING','SMTP_SENT','SMTP_FAILED'
)),
is_simulation INTEGER NOT NULL DEFAULT 1
CHECK (is_simulation IN (0,1)),
delivery_attempts INTEGER NOT NULL DEFAULT 0
CHECK (delivery_attempts >= 0),
claim_token TEXT,
last_error TEXT,
attempted_at INTEGER,
sent_at INTEGER,
created_at INTEGER NOT NULL,
CHECK (
(status='LOCAL_ONLY' AND is_simulation=1)
OR (status<>'LOCAL_ONLY' AND is_simulation=0)
)
)
"""
)
conn.execute("DROP TABLE auth_registration_email_outbox_legacy")
reset_columns = {
row["name"]
for row in conn.execute(
"PRAGMA table_info(auth_password_reset_email_outbox)"
)
}
reset_required = {
"delivery_attempts",
"claim_token",
"last_error",
"attempted_at",
"sent_at",
}
if (
"verification_code" in reset_columns
or not reset_required.issubset(reset_columns)
):
conn.execute(
"DELETE FROM auth_password_reset_flows WHERE verified_at IS NULL"
)
conn.execute(
"ALTER TABLE auth_password_reset_email_outbox "
"RENAME TO auth_password_reset_email_outbox_legacy"
)
conn.execute(
"""
CREATE TABLE auth_password_reset_email_outbox (
email_id INTEGER PRIMARY KEY AUTOINCREMENT,
reset_id TEXT NOT NULL UNIQUE
REFERENCES auth_password_reset_flows(reset_id) ON DELETE CASCADE,
recipient TEXT NOT NULL,
template TEXT NOT NULL
CHECK (template = 'password-reset-verification'),
status TEXT NOT NULL CHECK (status IN (
'LOCAL_ONLY','SMTP_PENDING','SMTP_SENT','SMTP_FAILED'
)),
is_simulation INTEGER NOT NULL DEFAULT 1
CHECK (is_simulation IN (0,1)),
delivery_attempts INTEGER NOT NULL DEFAULT 0
CHECK (delivery_attempts >= 0),
claim_token TEXT,
last_error TEXT,
attempted_at INTEGER,
sent_at INTEGER,
created_at INTEGER NOT NULL,
CHECK (
(status='LOCAL_ONLY' AND is_simulation=1)
OR (status<>'LOCAL_ONLY' AND is_simulation=0)
)
)
"""
)
conn.execute("DROP TABLE auth_password_reset_email_outbox_legacy")
order_columns = {
row["name"] for row in conn.execute("PRAGMA table_info(email_outbox)")
}
order_required = {
"delivery_attempts",
"claim_token",
"last_error",
"attempted_at",
"sent_at",
}
order_has_delivery_state = {
"delivery_attempts",
"last_error",
"attempted_at",
"sent_at",
}.issubset(order_columns)
if not order_required.issubset(order_columns):
conn.execute("ALTER TABLE email_outbox RENAME TO email_outbox_legacy")
conn.execute(
"""
CREATE TABLE email_outbox (
email_id INTEGER PRIMARY KEY AUTOINCREMENT,
account_id INTEGER NOT NULL
REFERENCES accounts(account_id) ON DELETE CASCADE,
order_id INTEGER NOT NULL UNIQUE
REFERENCES orders(order_id) ON DELETE CASCADE,
recipient TEXT NOT NULL,
template TEXT NOT NULL CHECK (template='order-confirmation'),
subject TEXT NOT NULL,
payload_json TEXT NOT NULL,
status TEXT NOT NULL CHECK (status IN (
'LOCAL_ONLY','SMTP_PENDING','SMTP_SENT','SMTP_FAILED'
)),
is_simulation INTEGER NOT NULL DEFAULT 1
CHECK (is_simulation IN (0,1)),
delivery_attempts INTEGER NOT NULL DEFAULT 0
CHECK (delivery_attempts >= 0),
claim_token TEXT,
last_error TEXT,
attempted_at INTEGER,
sent_at INTEGER,
created_at TEXT NOT NULL,
CHECK (
(status='LOCAL_ONLY' AND is_simulation=1)
OR (status<>'LOCAL_ONLY' AND is_simulation=0)
)
)
"""
)
if order_has_delivery_state:
conn.execute(
"""
INSERT INTO email_outbox(
email_id,account_id,order_id,recipient,template,subject,
payload_json,status,is_simulation,delivery_attempts,
claim_token,last_error,attempted_at,sent_at,created_at
)
SELECT email_id,account_id,order_id,recipient,template,subject,
payload_json,status,is_simulation,delivery_attempts,
NULL,last_error,attempted_at,sent_at,created_at
FROM email_outbox_legacy
"""
)
else:
conn.execute(
"""
INSERT INTO email_outbox(
email_id,account_id,order_id,recipient,template,subject,
payload_json,status,is_simulation,delivery_attempts,
claim_token,last_error,attempted_at,sent_at,created_at
)
SELECT email_id,account_id,order_id,recipient,template,subject,
payload_json,'LOCAL_ONLY',1,0,NULL,NULL,NULL,NULL,created_at
FROM email_outbox_legacy
"""
)
conn.execute("DROP TABLE email_outbox_legacy")
@staticmethod
def _compare_label_key(value: Any) -> str:
if not isinstance(value, str):
return ""
normalized = unicodedata.normalize("NFKC", value).casefold().replace("&", " and ")
return " ".join(re.findall(r"[a-z0-9]+", normalized))
@classmethod
def _compare_family_key(cls, category_key: str, label: str) -> str:
normalized = unicodedata.normalize("NFKD", label).encode(
"ascii", "ignore"
).decode("ascii")
slug = re.sub(r"[^a-z0-9]+", "-", normalized.casefold()).strip("-")
return f"{category_key}:{slug or category_key}"
@classmethod
def _compare_department(
cls, candidates: list[Any]
) -> tuple[str, str] | None:
aliases: dict[str, tuple[str, str]] = {}
for department in SOURCE_DEPARTMENTS:
slug = str(department["slug"])
title = str(department["title"])
for candidate in (
slug,
title,
*tuple(department.get("aliases", ())),
):
key = cls._compare_label_key(candidate)
if key:
aliases[key] = (slug, title)
for candidate in candidates:
match = aliases.get(cls._compare_label_key(candidate))
if match is not None:
return match
return None
def _load_compare_profiles(self) -> dict[str, dict[str, Any]]:
"""Build comparison taxonomy only from retained source classifications."""
profiles: dict[str, dict[str, Any]] = {}
priorities: dict[str, int] = {}
def install(
asin: Any,
category: tuple[str, str] | None,
family_label: Any,
*,
priority: int,
specs: Mapping[str, Any] | None = None,
reviews_display: Any = None,
) -> None:
if (
not isinstance(asin, str)
or not asin
or category is None
or priorities.get(asin, -1) > priority
):
return
category_key, category_label = category
normalized_family_label = (
" ".join(family_label.split())
if isinstance(family_label, str) and family_label.strip()
else category_label
)
clean_specs = {
str(label): str(value)
for label, value in (specs or {}).items()
if isinstance(label, str)
and label.strip()
and isinstance(value, (str, int, float))
and str(value).strip()
}
profiles[asin] = {
"category_key": category_key,
"category_label": category_label,
"family_key": self._compare_family_key(
category_key, normalized_family_label
),
"family_label": normalized_family_label,
"specs": clean_specs,
"reviews_display": (
reviews_display.strip()
if isinstance(reviews_display, str) and reviews_display.strip()
else None
),
}
priorities[asin] = priority
# Broad search-card departments are explicit source fields and give
# newly loaded purchasable cards dynamic eligibility without ASIN lists.
for product in load_search_commerce_cards(self.fixture_root):
raw_departments = product.get("department_slugs")
candidates = (
list(raw_departments)
if isinstance(raw_departments, (list, tuple))
else []
)
category = self._compare_department(candidates)
department_label = category[1] if category is not None else ""
raw_format = product.get("format")
install(
product.get("asin"),
category,
department_label,
priority=10,
specs={"Format": raw_format} if raw_format else None,
reviews_display=product.get("reviews_display"),
)
# The frozen ranking itself is explicit External SSD family evidence;
# every product in that source list is comparable without hardcoding it.
frozen_path = (self.fixture_root / "task-frozen-900136-v1.json").resolve()
try:
frozen = json.loads(frozen_path.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc:
raise ContractError("comparison ranking evidence is invalid") from exc
ranking = frozen.get("ranking") if isinstance(frozen, dict) else None
frozen_products = frozen.get("products") if isinstance(frozen, dict) else None
if not isinstance(ranking, dict) or not isinstance(frozen_products, list):
raise ContractError("comparison ranking evidence is invalid")
ranking_title = str(ranking.get("title") or "External Solid State Drives")
family_label = re.sub(
r"^Best Sellers in\s+", "", ranking_title, flags=re.IGNORECASE
)
computer_category = self._compare_department(["computers"])
for product in frozen_products:
if isinstance(product, dict):
install(
product.get("asin"),
computer_category,
family_label,
priority=20,
)
# Direct PDP breadcrumbs supply a narrower family and win broad card
# taxonomy for overlapping ASINs.
direct_path = (self.fixture_root / HOME_PDP_EVIDENCE_FIXTURE).resolve()
try:
direct = json.loads(direct_path.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc:
raise ContractError("comparison PDP evidence is invalid") from exc
direct_products = direct.get("products") if isinstance(direct, dict) else None
if not isinstance(direct_products, list):
raise ContractError("comparison PDP evidence is invalid")
for product in direct_products:
if not isinstance(product, dict):
continue
detail = product.get("pdp")
if not isinstance(detail, dict):
continue
breadcrumb = detail.get("breadcrumb")
breadcrumb_values = (
[value for value in breadcrumb if isinstance(value, str)]
if isinstance(breadcrumb, list)
else []
)
category = self._compare_department(
[*breadcrumb_values, detail.get("page_category")]
)
family = breadcrumb_values[-1] if len(breadcrumb_values) > 1 else (
category[1] if category is not None else ""
)
install(
product.get("asin"),
category,
family,
priority=30,
)
return profiles
def _load_direct_commerce_offers(self) -> list[dict[str, Any]]:
candidate = (self.fixture_root / HOME_PDP_EVIDENCE_FIXTURE).resolve()
if self.fixture_root not in candidate.parents or not candidate.is_file():
raise ContractError("direct PDP evidence fixture does not exist")
try:
payload = json.loads(candidate.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc:
raise ContractError("direct PDP evidence fixture is invalid") from exc
if payload.get("schema") != "amazon-clone.home-pdp-evidence.v1":
raise ContractError("unsupported direct PDP evidence schema")
products = payload.get("products")
if not isinstance(products, list) or not products:
raise ContractError("direct PDP evidence must contain at least one offer")
normalized: list[dict[str, Any]] = []
seen: set[str] = set()
for product in products:
if not isinstance(product, dict):
raise ContractError("direct PDP offers must be objects")
asin = product.get("asin")
slug = product.get("slug")
canonical_path = product.get("canonicalPath")
image_path = product.get("image_path")
price_minor = product.get("price_minor")
list_price_minor = product.get("list_price_minor")
reviews = product.get("reviews")
if (
not isinstance(asin, str)
or len(asin) != 10
or any(character not in "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" for character in asin)
or asin in seen
):
raise ContractError("direct PDP offer has an invalid or duplicate ASIN")
if not isinstance(slug, str) or not slug or "/" in slug:
raise ContractError(f"direct PDP offer {asin} has an invalid slug")
if (
not isinstance(canonical_path, str)
or not canonical_path.startswith("/")
or not canonical_path.endswith(f"/dp/{asin}")
or canonical_path.startswith("//")
):
raise ContractError(f"direct PDP offer {asin} has an invalid canonical path")
if (
not isinstance(image_path, str)
or not image_path.startswith("/static/")
or "\\" in image_path
or ".." in Path(image_path).parts
):
raise ContractError(f"direct PDP offer {asin} has an invalid image")
if isinstance(price_minor, bool) or not isinstance(price_minor, int) or price_minor < 0:
raise ContractError(f"direct PDP offer {asin} has an invalid price")
if (
list_price_minor is not None
and (
isinstance(list_price_minor, bool)
or not isinstance(list_price_minor, int)
or list_price_minor < 0
)
):
raise ContractError(f"direct PDP offer {asin} has an invalid list price")
if isinstance(reviews, bool) or not isinstance(reviews, int) or reviews < 0:
raise ContractError(f"direct PDP offer {asin} has invalid reviews")
required_text = {
"title": product.get("title"),
"brand": product.get("brand"),
"capacity": product.get("capacity"),
"color": product.get("color"),
"currency": product.get("currency"),
"rating": product.get("rating"),
"evidence_class": product.get("evidence_class"),
}
if any(not isinstance(value, str) for value in required_text.values()):
raise ContractError(f"direct PDP offer {asin} has invalid text fields")
seen.add(asin)
normalized.append(
{
"asin": asin,
"slug": slug,
"canonical_path": canonical_path,
"title": required_text["title"],
"brand": required_text["brand"],
"capacity": required_text["capacity"],
"color": required_text["color"],
"price_minor": price_minor,
"list_price_minor": list_price_minor,
"currency": required_text["currency"],
"rating": required_text["rating"],
"reviews": reviews,
"image_path": image_path,
"badge": str(product.get("badge") or ""),
"evidence_class": required_text["evidence_class"],
}
)
return normalized
def _load_current_offer_overrides(self) -> list[dict[str, Any]]:
"""Load newer same-context facts that supersede retained snapshots."""
candidate = (
self.fixture_root / "current-offer-overrides-2026-07-31.json"
).resolve()
if self.fixture_root not in candidate.parents or not candidate.is_file():
raise ContractError("current offer override fixture does not exist")
try:
payload = json.loads(candidate.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc:
raise ContractError("current offer override fixture is invalid") from exc
offers = payload.get("offers")
ledger = payload.get("change_ledger")
if (
payload.get("schema") != "amazon-clone.current-offer-overrides.v1"
or payload.get("marketplace") != "amazon.com"
or payload.get("region") != "Singapore"
or payload.get("currency") != "USD"
or not isinstance(offers, list)
or len(offers) != 1
or not isinstance(ledger, list)
or len(ledger) != 1
):
raise ContractError("current offer override boundary is invalid")
offer = offers[0]
required = {
"asin": "B0874XN4D8",
"price_minor": 21400,
"list_price_minor": 27499,
"currency": "USD",
"rating": "4.7",
"reviews": 21124,
"evidence_class": "direct-current-pdp-2026-07-31",
"source_sha256": "4856b4a46e15159502f0602313aa0e7a7e843c350475cee5f7178bed4e1f3624",
}
if not isinstance(offer, dict) or any(
offer.get(key) != value for key, value in required.items()
):
raise ContractError("current T7 offer facts are invalid")
source_ref = offer.get("source_ref")
source_path = (
self.fixture_root / str(source_ref)
).resolve() if isinstance(source_ref, str) else Path()
amazon_root = self.fixture_root.parent.parent.resolve()
if (
amazon_root not in source_path.parents
or not source_path.is_file()
or hashlib.sha256(source_path.read_bytes()).hexdigest()
!= offer["source_sha256"]
):
raise ContractError("current T7 source screenshot integrity failed")
previous = ledger[0]
if (
not isinstance(previous, dict)
or previous.get("asin") != offer["asin"]
or not isinstance(previous.get("superseded"), list)
or len(previous["superseded"]) < 2
):
raise ContractError("current T7 change ledger is incomplete")
return [
{
key: offer[key]
for key in (
"asin", "slug", "canonical_path", "title", "brand",
"capacity", "color", "price_minor", "list_price_minor",
"currency", "rating", "reviews", "image_path", "badge",
"evidence_class",
)
}
]
@staticmethod
def _upsert_commerce_offers(
conn: sqlite3.Connection, products: list[dict[str, Any]], source: str
) -> None:
rows = []
for product in products:
normalized = dict(product)
normalized["canonical_path"] = normalized.get("canonical_path") or (
f"/{normalized['slug']}/dp/{normalized['asin']}"
)
normalized["source"] = source
rows.append(normalized)
if not rows:
return
conn.executemany(
"""
INSERT INTO commerce_offers(
asin,slug,canonical_path,title,brand,capacity,color,price_minor,
list_price_minor,currency,rating,reviews,image_path,badge,
evidence_class,source
) VALUES (
:asin,:slug,:canonical_path,:title,:brand,:capacity,:color,:price_minor,
:list_price_minor,:currency,:rating,:reviews,:image_path,:badge,
:evidence_class,:source
)
ON CONFLICT(asin) DO UPDATE SET
slug=excluded.slug,
canonical_path=excluded.canonical_path,
title=excluded.title,
brand=excluded.brand,
capacity=excluded.capacity,
color=excluded.color,
price_minor=excluded.price_minor,
list_price_minor=excluded.list_price_minor,
currency=excluded.currency,
rating=excluded.rating,
reviews=excluded.reviews,
image_path=excluded.image_path,
badge=excluded.badge,
evidence_class=excluded.evidence_class,
source=excluded.source
""",
rows,
)
def _sync_commerce_offers(
self,
conn: sqlite3.Connection,
task_products: list[dict[str, Any]] | None = None,
) -> None:
if task_products is None:
task_products = [
dict(row)
for row in conn.execute(
"""
SELECT asin,slug,title,brand,capacity,color,price_minor,
list_price_minor,currency,rating,reviews,image_path,
badge,evidence_class
FROM catalog_products
ORDER BY asin
"""
)
]
self._upsert_commerce_offers(conn, task_products, "task-fixture")
# Direct PDP observations are the current transaction offer. They must
# win the one overlapping ASIN without changing catalog_products.
direct_offers = self._load_direct_commerce_offers()
self._upsert_commerce_offers(conn, direct_offers, "direct-pdp")
current_overrides = self._load_current_offer_overrides()
self._upsert_commerce_offers(conn, current_overrides, "direct-pdp")
# Current Deals cards establish ten additional default USD offers. The
# legacy source column accepts ``direct-pdp`` for directly observed
# offers; evidence_class keeps the narrower card-only boundary so the
# renderer never invents PDP, rating, delivery, inventory, or options.
deals_offers = list(load_deals_default_card_offers(self.fixture_root))
self._upsert_commerce_offers(conn, deals_offers, "direct-pdp")
# Current search cards establish only their visible default offer.
# ``evidence_class`` retains that narrower boundary even though the
# legacy source column groups all directly observed offers together.
search_card_offers = list(load_search_commerce_cards(self.fixture_root))
self._upsert_commerce_offers(conn, search_card_offers, "direct-pdp")
# Each homepage category tile now owns four dated Amazon.com search-card
# identities. They stay card-scoped but have a complete default USD
# quote, so cart and Buy Now use the same server-authoritative path.
# Existing homepage quotes also remain authoritative for overlaps.
richer_asins = {
str(product["asin"])
for product in [
*task_products,
*direct_offers,
*current_overrides,
*deals_offers,
*search_card_offers,
*self._home_commerce_offers,
]
}
home_category_offers = [
product
for product in self._home_category_offers
if str(product["asin"]) not in richer_asins
]
self._upsert_commerce_offers(conn, home_category_offers, "direct-pdp")
# The dated homepage commerce crawl contributes one default USD quote
# only where the current product or buying-options page exposed a
# purchase affordance. Richer task/PDP/Deals/search evidence wins for
# overlapping ASINs; category-card overlaps were excluded above.
prior_asins = {
str(product["asin"])
for product in [
*task_products,
*direct_offers,
*current_overrides,
*deals_offers,
*search_card_offers,
*home_category_offers,
]
}
home_commerce_offers = [
offer
for offer in self._home_commerce_offers
if str(offer["asin"]) not in prior_asins
]
self._upsert_commerce_offers(
conn, home_commerce_offers, "direct-pdp"
)
if len(task_products) == 9:
expected_asins = {
str(product["asin"])
for product in [
*task_products,
*direct_offers,
*current_overrides,
*deals_offers,
*search_card_offers,
*home_category_offers,
*home_commerce_offers,
]
}
offer_count = int(
conn.execute("SELECT COUNT(*) FROM commerce_offers").fetchone()[0]
)
if offer_count != len(expected_asins):
raise ContractError(
"commerce catalog offer count does not match current source evidence: "
f"expected {len(expected_asins)}, found {offer_count}"
)
def _sync_product_display_catalog(self, conn: sqlite3.Connection) -> None:
"""Deterministically upsert the complete 458-ASIN presentation catalog."""
offers = [
dict(row)
for row in conn.execute(
"SELECT * FROM commerce_offers ORDER BY asin"
).fetchall()
]
# A brand-new database is seeded by reset immediately after Store
# construction. Do not materialize a partial display catalog during the
# constructor's additive migration pass.
if len(offers) != EXPECTED_PRODUCT_COUNT:
conn.execute("DELETE FROM product_display_catalog")
return
products = build_product_display_catalog(self.fixture_root, offers)
rows = [
{
"asin": str(product["asin"]),
"source_index": int(product["source_index"]),
"provenance": str(product["display_provenance"]),
"payload_json": json.dumps(
product,
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
),
}
for product in products
]
conn.executemany(
"""
INSERT INTO product_display_catalog(
asin,source_index,provenance,payload_json
) VALUES (
:asin,:source_index,:provenance,:payload_json
)
ON CONFLICT(asin) DO UPDATE SET
source_index=excluded.source_index,
provenance=excluded.provenance,
payload_json=excluded.payload_json
""",
rows,
)
conn.execute(
"DELETE FROM product_display_catalog "
"WHERE asin NOT IN (SELECT asin FROM commerce_offers)"
)
summary = display_catalog_summary(products)
persisted = int(
conn.execute("SELECT COUNT(*) FROM product_display_catalog").fetchone()[0]
)
provenance = summary.get("provenance", {})
if (
persisted != EXPECTED_PRODUCT_COUNT
or summary.get("schema")
!= "amazon-clone.product-display-catalog.v1"
or summary.get("products") != EXPECTED_PRODUCT_COUNT
or summary.get("reachable") != EXPECTED_PRODUCT_COUNT
or summary.get("purchasable") != EXPECTED_PRODUCT_COUNT
or not isinstance(provenance, dict)
or provenance.get("legacy") != 1
or int(provenance.get("direct", 0)) < 12
or sum(int(value) for value in provenance.values())
!= EXPECTED_PRODUCT_COUNT
):
raise ContractError(
f"product display catalog is incomplete: persisted={persisted}, "
f"summary={summary}"
)
@staticmethod
def _new_cart_line_id() -> str:
return secrets.token_urlsafe(24)
def _canonical_stored_selection(
self, asin: str, raw_value: Any
) -> tuple[str, str]:
selected_options = self._stored_product_options(asin, raw_value)
return (
json.dumps(
selected_options,
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
),
canonical_selection_key(selected_options),
)
def _migrate_cart_line_identity(self, conn: sqlite3.Connection) -> None:
"""Give every cart row an opaque identity and a variant-aware key.
SQLite cannot remove the legacy ``PRIMARY KEY(owner, asin)`` in place,
so both guest and account tables are rebuilt transactionally. Existing
selections are validated and canonicalized; a partially migrated table
with duplicate canonical variants is folded without exceeding the
existing quantity cap.
"""
table_specs = (
("cart_lines", "cart_id", "carts", "cart_id"),
("account_cart_lines", "account_id", "accounts", "account_id"),
)
for table, owner_column, owner_table, owner_reference in table_specs:
columns = {
row["name"] for row in conn.execute(f"PRAGMA table_info({table})")
}
foreign_tables = {
row["table"]
for row in conn.execute(f"PRAGMA foreign_key_list({table})")
}
if {
"line_id",
"selection_json",
"selection_key",
"line_state",
}.issubset(columns) and "commerce_offers" in foreign_tables:
conn.execute(
f"CREATE INDEX IF NOT EXISTS {table}_owner_state_idx "
f"ON {table}({owner_column},line_state)"
)
continue
rows = conn.execute(
f"SELECT * FROM {table} ORDER BY {owner_column},asin"
).fetchall()
merged: dict[tuple[int, str, str], dict[str, Any]] = {}
used_line_ids: set[str] = set()
for row in rows:
asin = str(row["asin"])
selection_json, selection_key = self._canonical_stored_selection(
asin,
row["selection_json"] if "selection_json" in columns else "{}",
)
owner_id = int(row[owner_column])
identity = (owner_id, asin, selection_key)
state = (
SAVED_CART_STATE
if "line_state" in columns
and str(row["line_state"]) == SAVED_CART_STATE
else ACTIVE_CART_STATE
)
if identity in merged:
current = merged[identity]
current["quantity"] = min(
30, int(current["quantity"]) + int(row["quantity"])
)
if state == ACTIVE_CART_STATE:
current["line_state"] = ACTIVE_CART_STATE
continue
candidate = (
str(row["line_id"])
if "line_id" in columns and row["line_id"] is not None
else ""
)
if (
CART_LINE_ID_PATTERN.fullmatch(candidate) is None
or candidate in used_line_ids
):
candidate = self._new_cart_line_id()
while candidate in used_line_ids:
candidate = self._new_cart_line_id()
used_line_ids.add(candidate)
merged[identity] = {
"line_id": candidate,
owner_column: owner_id,
"asin": asin,
"quantity": int(row["quantity"]),
"selection_json": selection_json,
"selection_key": selection_key,
"line_state": state,
}
replacement = f"{table}_line_identity_v2"
conn.execute(f"DROP TABLE IF EXISTS {replacement}")
conn.execute(
f"""
CREATE TABLE {replacement} (
line_id TEXT PRIMARY KEY NOT NULL,
{owner_column} INTEGER NOT NULL
REFERENCES {owner_table}({owner_reference}) ON DELETE CASCADE,
asin TEXT NOT NULL REFERENCES commerce_offers(asin),
quantity INTEGER NOT NULL CHECK (quantity BETWEEN 1 AND 30),
selection_json TEXT NOT NULL DEFAULT '{{}}',
selection_key TEXT NOT NULL,
line_state TEXT NOT NULL DEFAULT 'ACTIVE'
CHECK (line_state IN ('ACTIVE', 'SAVED')),
UNIQUE ({owner_column}, asin, selection_key)
)
"""
)
if merged:
conn.executemany(
f"""
INSERT INTO {replacement}(
line_id,{owner_column},asin,quantity,selection_json,
selection_key,line_state
) VALUES (
:line_id,:{owner_column},:asin,:quantity,:selection_json,
:selection_key,:line_state
)
""",
list(merged.values()),
)
conn.execute(f"DROP TABLE {table}")
conn.execute(f"ALTER TABLE {replacement} RENAME TO {table}")
conn.execute(
f"CREATE INDEX IF NOT EXISTS {table}_owner_state_idx "
f"ON {table}({owner_column},line_state)"
)
@staticmethod
def _new_compare_line_id() -> str:
return secrets.token_urlsafe(24)
def _migrate_compare_item_identity(self, conn: sqlite3.Connection) -> None:
"""Upgrade legacy ASIN-only comparisons without discarding selections.
Compare rows now belong either to an anonymous browser session or to a
durable account. Each row has its own opaque mutation identity and a
canonical option key, allowing two captured variants of one ASIN to
coexist while keeping all removal operations owner-scoped. A legacy
list may contain products admitted by the old hard-coded registry but
rejected by the current source-backed taxonomy. Preserve source order
while letting each owner's first eligible row choose the one family
that survives migration.
"""
offer_asins = {
str(row["asin"])
for row in conn.execute("SELECT asin FROM commerce_offers")
}
eligible_asins = offer_asins.intersection(self._compare_profiles)
table_specs = (
(
"compare_items",
"session_digest",
"TEXT",
"browser_sessions",
"session_digest",
),
(
"account_compare_items",
"account_id",
"INTEGER",
"accounts",
"account_id",
),
)
for table, owner_column, owner_type, owner_table, owner_reference in table_specs:
columns = {
row["name"] for row in conn.execute(f"PRAGMA table_info({table})")
}
foreign_tables = {
row["table"]
for row in conn.execute(f"PRAGMA foreign_key_list({table})")
}
required = {
"compare_line_id",
owner_column,
"asin",
"selection_json",
"selection_key",
"position",
"created_at",
}
if required.issubset(columns) and "commerce_offers" in foreign_tables:
conn.execute(
f"CREATE INDEX IF NOT EXISTS {table}_owner_idx "
f"ON {table}({owner_column},position)"
)
continue
rows = conn.execute(
f"SELECT * FROM {table} ORDER BY {owner_column},position,asin"
).fetchall()
rebuilt: list[dict[str, Any]] = []
used_line_ids: set[str] = set()
owner_identities: dict[Any, set[tuple[str, str]]] = {}
owner_family_keys: dict[Any, str] = {}
owner_positions: dict[Any, int] = {}
for row in rows:
owner_id = row[owner_column]
asin = str(row["asin"])
profile = self._compare_profiles.get(asin)
if asin not in eligible_asins or profile is None:
continue
family_key = str(profile["family_key"])
retained_family = owner_family_keys.get(owner_id)
if retained_family is not None and retained_family != family_key:
continue
selection_json, selection_key = self._canonical_stored_selection(
asin,
row["selection_json"] if "selection_json" in columns else "{}",
)
identities = owner_identities.setdefault(owner_id, set())
identity = (asin, selection_key)
if identity in identities or owner_positions.get(owner_id, 0) >= COMPARE_LIMIT:
continue
candidate = (
str(row["compare_line_id"])
if "compare_line_id" in columns
and row["compare_line_id"] is not None
else ""
)
if (
COMPARE_LINE_ID_PATTERN.fullmatch(candidate) is None
or candidate in used_line_ids
):
candidate = self._new_compare_line_id()
while candidate in used_line_ids:
candidate = self._new_compare_line_id()
used_line_ids.add(candidate)
identities.add(identity)
owner_family_keys.setdefault(owner_id, family_key)
position = owner_positions.get(owner_id, 0) + 1
owner_positions[owner_id] = position
rebuilt.append(
{
"compare_line_id": candidate,
owner_column: owner_id,
"asin": asin,
"selection_json": selection_json,
"selection_key": selection_key,
"position": position,
"created_at": str(row["created_at"]),
}
)
replacement = f"{table}_variant_v2"
conn.execute(f"DROP TABLE IF EXISTS {replacement}")
conn.execute(
f"""
CREATE TABLE {replacement} (
compare_line_id TEXT PRIMARY KEY NOT NULL,
{owner_column} {owner_type} NOT NULL
REFERENCES {owner_table}({owner_reference}) ON DELETE CASCADE,
asin TEXT NOT NULL REFERENCES commerce_offers(asin),
selection_json TEXT NOT NULL DEFAULT '{{}}',
selection_key TEXT NOT NULL,
position INTEGER NOT NULL CHECK (position BETWEEN 1 AND 4),
created_at TEXT NOT NULL,
UNIQUE ({owner_column}, asin, selection_key),
UNIQUE ({owner_column}, position)
)
"""
)
if rebuilt:
conn.executemany(
f"""
INSERT INTO {replacement}(
compare_line_id,{owner_column},asin,selection_json,
selection_key,position,created_at
) VALUES (
:compare_line_id,:{owner_column},:asin,:selection_json,
:selection_key,:position,:created_at
)
""",
rebuilt,
)
conn.execute(f"DROP TABLE {table}")
conn.execute(f"ALTER TABLE {replacement} RENAME TO {table}")
conn.execute(
f"CREATE INDEX IF NOT EXISTS {table}_owner_idx "
f"ON {table}({owner_column},position)"
)
@staticmethod
def _migrate_option_selections(conn: sqlite3.Connection) -> None:
"""Add source-option snapshots without discarding pre-existing carts/orders."""
for table in (
"cart_lines",
"account_cart_lines",
"pending_buy_now",
"checkout_lines",
"order_items",
):
columns = {
row["name"] for row in conn.execute(f"PRAGMA table_info({table})")
}
if "selection_json" not in columns:
conn.execute(
f"ALTER TABLE {table} ADD COLUMN selection_json "
"TEXT NOT NULL DEFAULT '{}'"
)
@staticmethod
def _has_unique_index(
conn: sqlite3.Connection, table: str, columns: tuple[str, ...]
) -> bool:
for index in conn.execute(f"PRAGMA index_list({table})"):
if not bool(index["unique"]):
continue
indexed = tuple(
str(row["name"])
for row in conn.execute(f"PRAGMA index_info({index['name']})")
)
if indexed == columns:
return True
return False
@staticmethod
def _migrate_checkout_payment_state(conn: sqlite3.Connection) -> None:
"""Add PAYMENT_PENDING without discarding an existing checkout."""
row = conn.execute(
"SELECT sql FROM sqlite_master "
"WHERE type='table' AND name='checkout_sessions'"
).fetchone()
if row is None or "PAYMENT_PENDING" in str(row["sql"] or ""):
return
for trigger in (
"checkout_address_owner_insert_guard",
"checkout_address_owner_update_guard",
"address_checkout_owner_update_guard",
):
conn.execute(f"DROP TRIGGER IF EXISTS {trigger}")
conn.execute("DROP INDEX IF EXISTS checkout_sessions_one_open_account_idx")
conn.execute("DROP INDEX IF EXISTS checkout_sessions_idempotency_key_idx")
conn.execute("DROP TABLE IF EXISTS checkout_sessions_payment_v3")
conn.execute(
"""
CREATE TABLE checkout_sessions_payment_v3 (
checkout_id INTEGER PRIMARY KEY AUTOINCREMENT,
account_id INTEGER NOT NULL
REFERENCES accounts(account_id) ON DELETE CASCADE,
idempotency_key TEXT NOT NULL,
checkout_mode TEXT NOT NULL DEFAULT 'CART'
CHECK (checkout_mode IN ('CART','BUY_NOW')),
status TEXT NOT NULL CHECK (status IN (
'CART_READY','ADDRESS_SELECTED','DELIVERY_SELECTED',
'PAYMENT_SELECTED','PAYMENT_PENDING','PLACED'
)),
address_id INTEGER REFERENCES addresses(address_id),
delivery_method TEXT CHECK (
delivery_method IS NULL
OR delivery_method IN ('standard','expedited')
),
shipping_minor INTEGER CHECK (
shipping_minor IS NULL OR shipping_minor IN (0,1299)
),
currency TEXT NOT NULL DEFAULT 'USD',
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
placed_at TEXT,
CHECK (
(status='CART_READY' AND address_id IS NULL
AND delivery_method IS NULL AND shipping_minor IS NULL
AND placed_at IS NULL)
OR
(status='ADDRESS_SELECTED' AND address_id IS NOT NULL
AND delivery_method IS NULL AND shipping_minor IS NULL
AND placed_at IS NULL)
OR
(status IN (
'DELIVERY_SELECTED','PAYMENT_SELECTED','PAYMENT_PENDING'
) AND address_id IS NOT NULL
AND delivery_method IS NOT NULL
AND shipping_minor IS NOT NULL AND placed_at IS NULL)
OR
(status='PLACED' AND address_id IS NOT NULL
AND delivery_method IS NOT NULL
AND shipping_minor IS NOT NULL
AND placed_at IS NOT NULL)
)
)
"""
)
conn.execute(
"""
INSERT INTO checkout_sessions_payment_v3(
checkout_id,account_id,idempotency_key,checkout_mode,status,
address_id,delivery_method,shipping_minor,currency,
created_at,updated_at,placed_at
)
SELECT checkout_id,account_id,idempotency_key,checkout_mode,status,
address_id,delivery_method,shipping_minor,currency,
created_at,updated_at,placed_at
FROM checkout_sessions
"""
)
conn.execute("DROP TABLE checkout_sessions")
conn.execute(
"ALTER TABLE checkout_sessions_payment_v3 RENAME TO checkout_sessions"
)
conn.execute(
"""
CREATE UNIQUE INDEX checkout_sessions_one_open_account_idx
ON checkout_sessions(account_id) WHERE status<>'PLACED'
"""
)
conn.execute(
"""
CREATE UNIQUE INDEX checkout_sessions_idempotency_key_idx
ON checkout_sessions(idempotency_key)
"""
)
@classmethod
def _migrate_checkout_order_variant_constraints(
cls, conn: sqlite3.Connection
) -> None:
"""Remove legacy per-ASIN uniqueness from snapshots and order history."""
checkout_columns = {
row["name"] for row in conn.execute("PRAGMA table_info(checkout_lines)")
}
if "selection_json" not in checkout_columns or cls._has_unique_index(
conn, "checkout_lines", ("checkout_id", "asin")
):
conn.execute("DROP TABLE IF EXISTS checkout_lines_variant_v2")
conn.execute(
"""
CREATE TABLE checkout_lines_variant_v2 (
checkout_id INTEGER NOT NULL
REFERENCES checkout_sessions(checkout_id) ON DELETE CASCADE,
ordinal INTEGER NOT NULL CHECK (ordinal > 0),
asin TEXT NOT NULL REFERENCES commerce_offers(asin),
quantity INTEGER NOT NULL CHECK (quantity BETWEEN 1 AND 30),
selection_json TEXT NOT NULL DEFAULT '{}',
PRIMARY KEY (checkout_id, ordinal)
)
"""
)
selection_expression = (
"selection_json" if "selection_json" in checkout_columns else "'{}'"
)
conn.execute(
f"""
INSERT INTO checkout_lines_variant_v2(
checkout_id,ordinal,asin,quantity,selection_json
)
SELECT checkout_id,ordinal,asin,quantity,{selection_expression}
FROM checkout_lines
"""
)
conn.execute("DROP TABLE checkout_lines")
conn.execute(
"ALTER TABLE checkout_lines_variant_v2 RENAME TO checkout_lines"
)
order_columns = {
row["name"] for row in conn.execute("PRAGMA table_info(order_items)")
}
if "selection_json" not in order_columns or cls._has_unique_index(
conn, "order_items", ("order_id", "asin")
):
# This child-table trigger names order_items in its body. SQLite
# validates trigger SQL during ALTER TABLE, so recreate it later in
# _migrate_order_lifecycle_schema after the replacement is in place.
conn.execute("DROP TRIGGER IF EXISTS return_item_order_insert_guard")
conn.execute("DROP TABLE IF EXISTS order_items_variant_v2")
conn.execute(
"""
CREATE TABLE order_items_variant_v2 (
order_item_id INTEGER PRIMARY KEY AUTOINCREMENT,
order_id INTEGER NOT NULL
REFERENCES orders(order_id) ON DELETE CASCADE,
ordinal INTEGER NOT NULL CHECK (ordinal > 0),
asin TEXT NOT NULL,
title TEXT NOT NULL,
image_path TEXT NOT NULL,
quantity INTEGER NOT NULL CHECK (quantity BETWEEN 1 AND 30),
selection_json TEXT NOT NULL DEFAULT '{}',
unit_price_minor INTEGER NOT NULL CHECK (unit_price_minor >= 0),
line_total_minor INTEGER NOT NULL CHECK (
line_total_minor = unit_price_minor * quantity
),
currency TEXT NOT NULL,
UNIQUE (order_id, ordinal)
)
"""
)
selection_expression = (
"selection_json" if "selection_json" in order_columns else "'{}'"
)
conn.execute(
f"""
INSERT INTO order_items_variant_v2(
order_item_id,order_id,ordinal,asin,title,image_path,quantity,
selection_json,unit_price_minor,line_total_minor,currency
)
SELECT order_item_id,order_id,ordinal,asin,title,image_path,quantity,
{selection_expression},unit_price_minor,line_total_minor,currency
FROM order_items
"""
)
conn.execute("DROP TABLE order_items")
conn.execute("ALTER TABLE order_items_variant_v2 RENAME TO order_items")
@staticmethod
def _migrate_payment_attempts_schema(conn: sqlite3.Connection) -> None:
"""Add deterministic decline/retry methods without losing old orders."""
row = conn.execute(
"SELECT sql FROM sqlite_master WHERE type='table' AND name='payment_attempts'"
).fetchone()
if row is None:
return
table_sql = str(row["sql"] or "")
if (
"sandbox-card-approved" in table_sql
and "'DECLINED'" in table_sql
and "stripe-test" in table_sql
):
conn.execute(
"""
CREATE UNIQUE INDEX IF NOT EXISTS
payment_attempts_one_approved_checkout_idx
ON payment_attempts(checkout_id) WHERE status='APPROVED'
"""
)
return
conn.execute(
"DROP INDEX IF EXISTS payment_attempts_one_approved_checkout_idx"
)
conn.execute("DROP TABLE IF EXISTS payment_attempts_sandbox_v2")
conn.execute(
"""
CREATE TABLE payment_attempts_sandbox_v2 (
payment_attempt_id INTEGER PRIMARY KEY AUTOINCREMENT,
checkout_id INTEGER NOT NULL
REFERENCES checkout_sessions(checkout_id) ON DELETE CASCADE,
account_id INTEGER NOT NULL
REFERENCES accounts(account_id) ON DELETE CASCADE,
method TEXT NOT NULL CHECK (method IN (
'test-card','sandbox-card-approved','sandbox-card-declined',
'sandbox-bank-approved','stripe-test'
)),
status TEXT NOT NULL CHECK (
status IN ('APPROVED','DECLINED','SUPERSEDED')
),
amount_minor INTEGER NOT NULL CHECK (amount_minor >= 0),
currency TEXT NOT NULL,
cart_fingerprint TEXT NOT NULL,
is_simulation INTEGER NOT NULL DEFAULT 1
CHECK (is_simulation = 1),
created_at TEXT NOT NULL
)
"""
)
conn.execute(
"""
INSERT INTO payment_attempts_sandbox_v2(
payment_attempt_id,checkout_id,account_id,method,status,
amount_minor,currency,cart_fingerprint,is_simulation,created_at
)
SELECT payment_attempt_id,checkout_id,account_id,method,status,
amount_minor,currency,cart_fingerprint,is_simulation,created_at
FROM payment_attempts
"""
)
conn.execute("DROP TABLE payment_attempts")
conn.execute(
"ALTER TABLE payment_attempts_sandbox_v2 RENAME TO payment_attempts"
)
conn.execute(
"""
CREATE UNIQUE INDEX payment_attempts_one_approved_checkout_idx
ON payment_attempts(checkout_id) WHERE status='APPROVED'
"""
)
@staticmethod
def _migrate_site_backend_payment_links(conn: sqlite3.Connection) -> None:
"""Add nullable links while keeping historical Amazon attempts readable."""
columns = {
str(row["name"])
for row in conn.execute("PRAGMA table_info(payment_attempts)")
}
for name in ("site_backend_flow_id", "site_backend_attempt_id"):
if name not in columns:
conn.execute(
f"ALTER TABLE payment_attempts ADD COLUMN {name} TEXT"
)
stripe_columns = {
str(row["name"])
for row in conn.execute("PRAGMA table_info(stripe_payment_sessions)")
}
if "site_backend_flow_id" not in stripe_columns:
conn.execute(
"ALTER TABLE stripe_payment_sessions "
"ADD COLUMN site_backend_flow_id TEXT"
)
@staticmethod
def _migrate_site_backend_mail_links(conn: sqlite3.Connection) -> None:
"""Link the compatibility order outbox to the shared mail ledger."""
columns = {
str(row["name"])
for row in conn.execute("PRAGMA table_info(email_outbox)")
}
for name in ("site_backend_mail_id", "site_backend_claim_token"):
if name not in columns:
conn.execute(f"ALTER TABLE email_outbox ADD COLUMN {name} TEXT")
@staticmethod
def _migrate_address_book_schema(conn: sqlite3.Connection) -> None:
"""Upgrade checkout-only addresses into a durable account address book."""
columns = {
row["name"] for row in conn.execute("PRAGMA table_info(addresses)")
}
if "is_default" not in columns:
conn.execute(
"ALTER TABLE addresses ADD COLUMN is_default INTEGER "
"NOT NULL DEFAULT 0 CHECK (is_default IN (0,1))"
)
if "is_archived" not in columns:
conn.execute(
"ALTER TABLE addresses ADD COLUMN is_archived INTEGER "
"NOT NULL DEFAULT 0 CHECK (is_archived IN (0,1))"
)
if "revision" not in columns:
conn.execute(
"ALTER TABLE addresses ADD COLUMN revision INTEGER "
"NOT NULL DEFAULT 1 CHECK (revision > 0)"
)
conn.execute(
"UPDATE addresses SET is_default=0 WHERE is_archived=1"
)
account_rows = conn.execute(
"SELECT DISTINCT account_id FROM addresses ORDER BY account_id"
).fetchall()
for account_row in account_rows:
account_id = int(account_row["account_id"])
rows = conn.execute(
"""
SELECT address_id,is_default FROM addresses
WHERE account_id=? AND is_archived=0
ORDER BY is_default DESC,address_id
""",
(account_id,),
).fetchall()
if not rows:
continue
chosen_id = int(rows[0]["address_id"])
conn.execute(
"""
UPDATE addresses SET is_default=CASE WHEN address_id=? THEN 1 ELSE 0 END
WHERE account_id=? AND is_archived=0
""",
(chosen_id, account_id),
)
conn.execute(
"""
CREATE UNIQUE INDEX IF NOT EXISTS addresses_one_default_account_idx
ON addresses(account_id) WHERE is_default=1 AND is_archived=0
"""
)
conn.execute(
"""
CREATE INDEX IF NOT EXISTS addresses_account_active_idx
ON addresses(account_id,is_archived,is_default,address_id)
"""
)
conn.execute(
"""
CREATE TRIGGER IF NOT EXISTS addresses_archived_default_insert_guard
BEFORE INSERT ON addresses
WHEN NEW.is_archived=1 AND NEW.is_default=1
BEGIN
SELECT RAISE(ABORT,'archived address cannot be default');
END
"""
)
conn.execute(
"""
CREATE TRIGGER IF NOT EXISTS addresses_archived_default_update_guard
BEFORE UPDATE OF is_archived,is_default ON addresses
WHEN NEW.is_archived=1 AND NEW.is_default=1
BEGIN
SELECT RAISE(ABORT,'archived address cannot be default');
END
"""
)
ownership_mismatch = conn.execute(
"""
SELECT checkout.checkout_id
FROM checkout_sessions AS checkout
JOIN addresses AS address ON address.address_id=checkout.address_id
WHERE checkout.account_id<>address.account_id
LIMIT 1
"""
).fetchone()
if ownership_mismatch is not None:
raise ContractError(
"database contains a checkout address owned by another account"
)
conn.execute(
"""
CREATE TRIGGER IF NOT EXISTS checkout_address_owner_insert_guard
BEFORE INSERT ON checkout_sessions
WHEN NEW.address_id IS NOT NULL AND NOT EXISTS (
SELECT 1 FROM addresses
WHERE address_id=NEW.address_id AND account_id=NEW.account_id
)
BEGIN
SELECT RAISE(ABORT,'checkout address must belong to checkout account');
END
"""
)
conn.execute(
"""
CREATE TRIGGER IF NOT EXISTS checkout_address_owner_update_guard
BEFORE UPDATE OF account_id,address_id ON checkout_sessions
WHEN NEW.address_id IS NOT NULL AND NOT EXISTS (
SELECT 1 FROM addresses
WHERE address_id=NEW.address_id AND account_id=NEW.account_id
)
BEGIN
SELECT RAISE(ABORT,'checkout address must belong to checkout account');
END
"""
)
conn.execute(
"""
CREATE TRIGGER IF NOT EXISTS address_checkout_owner_update_guard
BEFORE UPDATE OF account_id ON addresses
WHEN EXISTS (
SELECT 1 FROM checkout_sessions
WHERE address_id=OLD.address_id AND account_id<>NEW.account_id
)
BEGIN
SELECT RAISE(ABORT,'address account must match referencing checkouts');
END
"""
)
@staticmethod
def _migrate_checkout_sessions(conn: sqlite3.Connection) -> None:
columns = {
row["name"]
for row in conn.execute("PRAGMA table_info(checkout_sessions)")
}
if "idempotency_key" not in columns:
conn.execute(
"ALTER TABLE checkout_sessions ADD COLUMN idempotency_key TEXT"
)
if "checkout_mode" not in columns:
conn.execute(
"ALTER TABLE checkout_sessions ADD COLUMN checkout_mode TEXT "
"NOT NULL DEFAULT 'CART' "
"CHECK (checkout_mode IN ('CART','BUY_NOW'))"
)
missing_rows = conn.execute(
"""
SELECT checkout_id FROM checkout_sessions
WHERE idempotency_key IS NULL OR idempotency_key=''
ORDER BY checkout_id
"""
).fetchall()
for row in missing_rows:
conn.execute(
"UPDATE checkout_sessions SET idempotency_key=? WHERE checkout_id=?",
(secrets.token_urlsafe(24), int(row["checkout_id"])),
)
conn.execute(
"""
CREATE UNIQUE INDEX IF NOT EXISTS checkout_sessions_idempotency_key_idx
ON checkout_sessions(idempotency_key)
"""
)
@staticmethod
def _migrate_order_lifecycle_schema(conn: sqlite3.Connection) -> None:
"""Add orthogonal shipment/return/refund lifecycle state to legacy orders."""
shipment_columns = {
row["name"] for row in conn.execute("PRAGMA table_info(shipments)")
}
additions = {
"lifecycle_status": (
"TEXT NOT NULL DEFAULT 'PREPARING' CHECK ("
"lifecycle_status IN ('PREPARING','SHIPPED','DELIVERED','CANCELLED'))"
),
"revision": "INTEGER NOT NULL DEFAULT 1 CHECK (revision > 0)",
"shipped_at": "TEXT",
"delivered_at": "TEXT",
"cancelled_at": "TEXT",
}
migrated_legacy_shipments = "lifecycle_status" not in shipment_columns
for column, declaration in additions.items():
if column not in shipment_columns:
conn.execute(
f"ALTER TABLE shipments ADD COLUMN {column} {declaration}"
)
if migrated_legacy_shipments:
conn.execute(
"""
UPDATE shipments SET lifecycle_status='PREPARING',revision=1,
shipped_at=NULL,delivered_at=NULL,cancelled_at=NULL,
tracking_code=NULL
"""
)
return_columns = {
row["name"]
for row in conn.execute("PRAGMA table_info(return_requests)")
}
if "revision" not in return_columns:
conn.execute(
"ALTER TABLE return_requests ADD COLUMN revision "
"INTEGER NOT NULL DEFAULT 1 CHECK (revision > 0)"
)
conn.execute(
"""
INSERT OR IGNORE INTO order_events(
order_id,account_id,event_type,actor,from_status,to_status,
idempotency_key,detail_json,created_at
)
SELECT order_id,account_id,'ORDER_PLACED','SYSTEM',NULL,'PREPARING',
idempotency_key,'{"source":"migration-backfill"}',created_at
FROM orders
"""
)
lifecycle_error = conn.execute(
"""
SELECT orders.order_id
FROM orders
LEFT JOIN shipments ON shipments.order_id=orders.order_id
WHERE orders.status<>'PLACED'
OR shipments.shipment_id IS NULL
OR shipments.status<>'PREPARING'
OR shipments.lifecycle_status NOT IN (
'PREPARING','SHIPPED','DELIVERED','CANCELLED'
)
OR (shipments.lifecycle_status IN ('PREPARING','CANCELLED')
AND shipments.tracking_code IS NOT NULL)
OR (shipments.lifecycle_status IN ('SHIPPED','DELIVERED')
AND (
shipments.tracking_code IS NULL
OR length(shipments.tracking_code) NOT BETWEEN 8 AND 64
OR shipments.shipped_at IS NULL
))
OR (shipments.lifecycle_status='DELIVERED'
AND shipments.delivered_at IS NULL)
OR (shipments.lifecycle_status='CANCELLED'
AND shipments.cancelled_at IS NULL)
LIMIT 1
"""
).fetchone()
if lifecycle_error is not None:
raise ContractError("database contains inconsistent order shipment state")
ownership_checks = (
"""
SELECT event.order_event_id
FROM order_events AS event JOIN orders ON orders.order_id=event.order_id
WHERE event.account_id<>orders.account_id LIMIT 1
""",
"""
SELECT action.order_action_key_id
FROM order_action_keys AS action JOIN orders ON orders.order_id=action.order_id
WHERE action.account_id<>orders.account_id LIMIT 1
""",
"""
SELECT request.return_request_id
FROM return_requests AS request JOIN orders ON orders.order_id=request.order_id
WHERE request.account_id<>orders.account_id LIMIT 1
""",
"""
SELECT item.return_request_id
FROM return_request_items AS item
JOIN return_requests AS request USING(return_request_id)
JOIN order_items AS order_item ON order_item.order_item_id=item.order_item_id
WHERE request.order_id<>order_item.order_id
OR item.quantity>order_item.quantity
LIMIT 1
""",
"""
SELECT refund.refund_id
FROM refunds AS refund JOIN orders ON orders.order_id=refund.order_id
LEFT JOIN return_requests AS request
ON request.return_request_id=refund.return_request_id
WHERE refund.account_id<>orders.account_id
OR refund.payment_attempt_id<>orders.payment_attempt_id
OR refund.amount_minor<>orders.total_minor
OR refund.currency<>orders.currency
OR (refund.kind='RETURN' AND (
request.return_request_id IS NULL
OR request.order_id<>orders.order_id
OR request.account_id<>orders.account_id
))
LIMIT 1
""",
)
if any(
conn.execute(statement).fetchone() is not None
for statement in ownership_checks
):
raise ContractError("database contains invalid order lifecycle ownership")
return_state_error = conn.execute(
"""
SELECT request.return_request_id
FROM return_requests AS request
JOIN shipments ON shipments.order_id=request.order_id
LEFT JOIN refunds AS refund
ON refund.return_request_id=request.return_request_id
AND refund.kind='RETURN'
WHERE shipments.lifecycle_status<>'DELIVERED'
OR (request.status='REFUNDED' AND refund.refund_id IS NULL)
OR (request.status<>'REFUNDED' AND refund.refund_id IS NOT NULL)
LIMIT 1
"""
).fetchone()
cancellation_error = conn.execute(
"""
SELECT shipments.shipment_id
FROM shipments
LEFT JOIN refunds AS refund
ON refund.order_id=shipments.order_id
AND refund.kind='CANCELLATION'
WHERE (shipments.lifecycle_status='CANCELLED'
AND refund.refund_id IS NULL)
OR (shipments.lifecycle_status<>'CANCELLED'
AND refund.refund_id IS NOT NULL)
LIMIT 1
"""
).fetchone()
if return_state_error is not None or cancellation_error is not None:
raise ContractError("database contains inconsistent return or refund state")
trigger_statements = (
"""
CREATE TRIGGER IF NOT EXISTS immutable_order_placement_status_guard
BEFORE UPDATE OF status ON orders WHEN NEW.status<>OLD.status
BEGIN SELECT RAISE(ABORT,'order placement status is immutable'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS immutable_shipment_placement_status_guard
BEFORE UPDATE OF status ON shipments WHEN NEW.status<>OLD.status
BEGIN SELECT RAISE(ABORT,'shipment placement status is immutable'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS shipment_lifecycle_transition_guard
BEFORE UPDATE OF lifecycle_status ON shipments
WHEN NOT (
NEW.lifecycle_status=OLD.lifecycle_status
OR (OLD.lifecycle_status='PREPARING'
AND NEW.lifecycle_status IN ('SHIPPED','CANCELLED'))
OR (OLD.lifecycle_status='SHIPPED'
AND NEW.lifecycle_status='DELIVERED')
)
BEGIN SELECT RAISE(ABORT,'invalid shipment lifecycle transition'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS shipment_lifecycle_shape_guard
BEFORE UPDATE OF lifecycle_status,tracking_code,shipped_at,delivered_at,cancelled_at
ON shipments
WHEN (NEW.lifecycle_status IN ('PREPARING','CANCELLED')
AND NEW.tracking_code IS NOT NULL)
OR (NEW.lifecycle_status IN ('SHIPPED','DELIVERED')
AND (NEW.tracking_code IS NULL
OR length(NEW.tracking_code) NOT BETWEEN 8 AND 64
OR NEW.shipped_at IS NULL))
OR (NEW.lifecycle_status='DELIVERED' AND NEW.delivered_at IS NULL)
OR (NEW.lifecycle_status='CANCELLED' AND NEW.cancelled_at IS NULL)
BEGIN SELECT RAISE(ABORT,'invalid shipment lifecycle fields'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS order_event_owner_insert_guard
BEFORE INSERT ON order_events
WHEN NOT EXISTS (
SELECT 1 FROM orders
WHERE order_id=NEW.order_id AND account_id=NEW.account_id
)
BEGIN SELECT RAISE(ABORT,'order event account mismatch'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS order_action_owner_insert_guard
BEFORE INSERT ON order_action_keys
WHEN NOT EXISTS (
SELECT 1 FROM orders
WHERE order_id=NEW.order_id AND account_id=NEW.account_id
)
BEGIN SELECT RAISE(ABORT,'order action account mismatch'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS return_request_owner_insert_guard
BEFORE INSERT ON return_requests
WHEN NOT EXISTS (
SELECT 1 FROM orders
WHERE order_id=NEW.order_id AND account_id=NEW.account_id
)
OR NOT EXISTS (
SELECT 1 FROM shipments
WHERE order_id=NEW.order_id AND lifecycle_status='DELIVERED'
)
BEGIN SELECT RAISE(ABORT,'return account mismatch'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS return_status_transition_guard
BEFORE UPDATE OF status ON return_requests
WHEN NOT (
NEW.status=OLD.status
OR (OLD.status='REQUESTED' AND NEW.status='RECEIVED')
OR (OLD.status='RECEIVED' AND NEW.status='REFUNDED')
)
BEGIN SELECT RAISE(ABORT,'invalid return transition'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS return_delivered_insert_guard
BEFORE INSERT ON return_requests
WHEN NOT EXISTS (
SELECT 1 FROM shipments
WHERE order_id=NEW.order_id AND lifecycle_status='DELIVERED'
)
BEGIN SELECT RAISE(ABORT,'return requires delivered shipment'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS return_owner_update_guard
BEFORE UPDATE OF account_id,order_id ON return_requests
WHEN NEW.account_id<>OLD.account_id OR NEW.order_id<>OLD.order_id
BEGIN SELECT RAISE(ABORT,'return ownership is immutable'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS return_item_order_insert_guard
BEFORE INSERT ON return_request_items
WHEN NOT EXISTS (
SELECT 1 FROM return_requests AS request
JOIN order_items AS item ON item.order_item_id=NEW.order_item_id
WHERE request.return_request_id=NEW.return_request_id
AND request.order_id=item.order_id
AND NEW.quantity<=item.quantity
)
BEGIN SELECT RAISE(ABORT,'return item order mismatch'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS refund_owner_insert_guard
BEFORE INSERT ON refunds
WHEN NOT EXISTS (
SELECT 1 FROM orders
WHERE order_id=NEW.order_id AND account_id=NEW.account_id
AND payment_attempt_id=NEW.payment_attempt_id
AND total_minor=NEW.amount_minor
AND currency=NEW.currency
) OR (
NEW.kind='RETURN' AND NOT EXISTS (
SELECT 1 FROM return_requests
WHERE return_request_id=NEW.return_request_id
AND order_id=NEW.order_id AND account_id=NEW.account_id
)
)
BEGIN SELECT RAISE(ABORT,'refund ownership mismatch'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS refund_state_insert_guard
BEFORE INSERT ON refunds
WHEN (
NEW.kind='CANCELLATION' AND NOT EXISTS (
SELECT 1 FROM shipments
WHERE order_id=NEW.order_id
AND lifecycle_status='CANCELLED'
)
) OR (
NEW.kind='RETURN' AND NOT EXISTS (
SELECT 1 FROM return_requests
WHERE return_request_id=NEW.return_request_id
AND order_id=NEW.order_id AND status='REFUNDED'
)
)
BEGIN SELECT RAISE(ABORT,'refund lifecycle mismatch'); END
""",
"""
CREATE TRIGGER IF NOT EXISTS refund_identity_update_guard
BEFORE UPDATE OF account_id,order_id,payment_attempt_id,
return_request_id,kind,amount_minor,currency
ON refunds
WHEN NEW.account_id<>OLD.account_id
OR NEW.order_id<>OLD.order_id
OR NEW.payment_attempt_id<>OLD.payment_attempt_id
OR COALESCE(NEW.return_request_id,-1)<>COALESCE(OLD.return_request_id,-1)
OR NEW.kind<>OLD.kind
OR NEW.amount_minor<>OLD.amount_minor
OR NEW.currency<>OLD.currency
BEGIN SELECT RAISE(ABORT,'refund identity is immutable'); END
""",
)
for statement in trigger_statements:
conn.execute(statement)
def ensure_seeded(self, fixture_name: str = "task-frozen-900136-v1.json") -> None:
with self.connect() as conn:
row = conn.execute("SELECT value FROM meta WHERE key='snapshot_id'").fetchone()
if row is None:
self.reset(fixture_name)
def _load_fixture(self, fixture_name: str) -> tuple[dict[str, Any], str]:
candidate = (self.fixture_root / fixture_name).resolve()
if self.fixture_root not in candidate.parents:
raise ContractError("fixture path escapes fixture root")
if candidate.suffix != ".json" or not candidate.is_file():
raise ContractError("fixture does not exist")
raw = candidate.read_bytes()
fixture = json.loads(raw.decode("utf-8"))
self._validate_fixture(fixture)
return fixture, hashlib.sha256(raw).hexdigest()
@staticmethod
def _validate_fixture(fixture: dict[str, Any]) -> None:
if fixture.get("schema") != "amazon-clone.fixture.v1":
raise ContractError("unsupported fixture schema")
if fixture.get("task_id") != TASK_ID:
raise ContractError("fixture task id does not match")
ranking = fixture.get("ranking") or {}
if ranking.get("canonical_path") != BEST_SELLERS_PATH:
raise ContractError("fixture ranking path does not match")
rank_two = [item for item in ranking.get("items", []) if item.get("rank") == 2]
if len(rank_two) != 1 or rank_two[0].get("asin") != TARGET_ASIN:
raise ContractError("target ASIN must be frozen at rank 2")
items = ranking.get("items") or []
ranks = [item.get("rank") for item in items]
asins = [item.get("asin") for item in items]
if ranks != list(range(1, len(items) + 1)) or len(set(asins)) != len(asins):
raise ContractError("ranking must use unique contiguous ranks")
products = fixture.get("products") or []
product_by_asin = {product.get("asin"): product for product in products}
if len(product_by_asin) != len(products) or None in product_by_asin:
raise ContractError("catalog ASINs must be present and unique")
if not set(asins).issubset(product_by_asin):
raise ContractError("every ranking ASIN must exist in the catalog")
region = fixture.get("region") or {}
if region.get("marketplace") != "amazon.com" or region.get("delivery_country") != "Singapore":
raise ContractError("fixture marketplace and delivery region must match the observed source")
if region.get("currency") != "USD":
raise ContractError("fixture currency must be USD")
if any(product.get("currency") != region["currency"] for product in products):
raise ContractError("all catalog offers must use the fixture currency")
for product in products:
detail = product.get("pdp")
if detail is not None and not isinstance(detail, dict):
raise ContractError("product PDP evidence must be an object")
if detail:
gallery = detail.get("gallery") or []
if not isinstance(gallery, list) or not gallery:
raise ContractError("detailed PDP evidence requires a gallery")
local_paths = [detail.get("main_image"), *gallery]
if any(not isinstance(path, str) or not path.startswith("/static/") for path in local_paths):
raise ContractError("PDP media paths must be local static resources")
target = product_by_asin.get(TARGET_ASIN) or {}
if (
target.get("brand") != "Samsung"
or target.get("capacity") != "1 TB"
or target.get("color") != "Titan Gray"
or target.get("slug") != "SAMSUNG-Portable-SSD-1TB-MU-PC1T0T"
):
raise ContractError("target variant must be the Samsung T7 1 TB in Titan Gray")
contract = fixture.get("terminal_contract") or {}
expected = {
"asin": TARGET_ASIN,
"quantity": TARGET_QUANTITY,
"desktop_path": DESKTOP_TERMINAL_PATH,
"mobile_path": MOBILE_TERMINAL_PATH,
"canonical_body": f"ASIN={TARGET_ASIN}&quantity={TARGET_QUANTITY}",
}
for key, value in expected.items():
if contract.get(key) != value:
raise ContractError(f"terminal contract mismatch: {key}")
def reset(self, fixture_name: str = "task-frozen-900136-v1.json") -> dict[str, Any]:
fixture, fixture_sha = self._load_fixture(fixture_name)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
previous = conn.execute("SELECT value FROM meta WHERE key='reset_epoch'").fetchone()
reset_epoch = int(previous[0]) + 1 if previous else 1
self.site_backend.lifecycle.reset_embedded(
conn,
confirm_site_id=self.site_backend.config.site_id,
)
reset_review_data(conn)
for table in (
"auth_password_reset_email_outbox",
"auth_password_reset_flows",
"auth_registration_email_outbox",
"auth_registration_flows",
"auth_mail_rate_limits",
"refunds",
"return_request_items",
"return_requests",
"order_action_keys",
"order_events",
"email_outbox",
"shipments",
"order_items",
"orders",
"payment_attempts",
"stripe_webhook_events",
"stripe_checkout_lines",
"stripe_payment_sessions",
"checkout_lines",
"checkout_sessions",
"addresses",
"task_completions",
"request_journal",
"task_progress",
"navigation_events",
"account_compare_items",
"compare_items",
"pending_buy_now",
"account_cart_lines",
"cart_lines",
"carts",
"auth_signin_flows",
"browser_sessions",
"accounts",
"ranking_items",
"ranking_lists",
"product_details",
"product_display_catalog",
"commerce_offers",
"catalog_products",
"meta",
):
conn.execute(f"DELETE FROM {table}")
products = fixture["products"]
conn.executemany(
"""
INSERT INTO catalog_products (
asin, slug, title, brand, capacity, color, price_minor,
list_price_minor, currency, rating, reviews, image_path,
badge, evidence_class
) VALUES (
:asin, :slug, :title, :brand, :capacity, :color, :price_minor,
:list_price_minor, :currency, :rating, :reviews, :image_path,
:badge, :evidence_class
)
""",
products,
)
self._sync_commerce_offers(conn, products)
self._sync_product_display_catalog(conn)
detail_rows = [
(
product["asin"],
json.dumps(product["pdp"], ensure_ascii=False, sort_keys=True, separators=(",", ":")),
)
for product in products
if product.get("pdp")
]
if detail_rows:
conn.executemany(
"INSERT INTO product_details(asin,payload_json) VALUES (?,?)",
detail_rows,
)
ranking = fixture["ranking"]
conn.execute(
"INSERT INTO ranking_lists(list_id,title,canonical_path) VALUES (?,?,?)",
(ranking["list_id"], ranking["title"], ranking["canonical_path"]),
)
conn.executemany(
"INSERT INTO ranking_items(list_id,rank,asin) VALUES (?,?,?)",
[(ranking["list_id"], item["rank"], item["asin"]) for item in ranking["items"]],
)
metadata = {
"schema": "amazon-clone.state.v1",
"run_id": fixture["snapshot_id"],
"seed": fixture["snapshot_id"],
"controlled_now": fixture["controlled_now"],
"reset_epoch": str(reset_epoch),
"fixture_sha256": fixture_sha,
"snapshot_id": fixture["snapshot_id"],
"region": json.dumps(fixture["region"], sort_keys=True, separators=(",", ":")),
"terminal_canonical_body": fixture["terminal_contract"]["canonical_body"],
}
conn.executemany("INSERT INTO meta(key,value) VALUES (?,?)", metadata.items())
conn.commit()
with self._auth_mail_secrets_lock:
self._auth_mail_secrets.clear()
return self.normalized_state()
def now(self, conn: sqlite3.Connection | None = None) -> str:
owns_connection = conn is None
db = conn or self.connect()
try:
row = db.execute("SELECT value FROM meta WHERE key='controlled_now'").fetchone()
return row[0] if row else "2026-07-21T12:00:00Z"
finally:
if owns_connection:
db.close()
def meta(self) -> dict[str, str]:
with self.connect() as conn:
return {row["key"]: row["value"] for row in conn.execute("SELECT key,value FROM meta")}
def ensure_session(self, session_digest: str) -> int:
with self.connect() as conn:
epoch = int(conn.execute("SELECT value FROM meta WHERE key='reset_epoch'").fetchone()[0])
now = self.now(conn)
conn.execute(
"INSERT OR IGNORE INTO browser_sessions(session_digest,reset_epoch,created_at) VALUES (?,?,?)",
(session_digest, epoch, now),
)
conn.execute(
"INSERT OR IGNORE INTO carts(session_digest,created_at) VALUES (?,?)",
(session_digest, now),
)
cart_id = conn.execute(
"SELECT cart_id FROM carts WHERE session_digest=?", (session_digest,)
).fetchone()[0]
return int(cart_id)
@staticmethod
def _account_id_for_session(
conn: sqlite3.Connection, session_digest: str
) -> int | None:
row = conn.execute(
"SELECT account_id FROM browser_sessions WHERE session_digest=?",
(session_digest,),
).fetchone()
if row is None or row["account_id"] is None:
return None
return int(row["account_id"])
@staticmethod
def _session_cart_id(conn: sqlite3.Connection, session_digest: str) -> int:
row = conn.execute(
"SELECT cart_id FROM carts WHERE session_digest=?", (session_digest,)
).fetchone()
if row is None:
raise ContractError("browser session has no anonymous cart")
return int(row["cart_id"])
def _merge_anonymous_cart_into_account(
self,
conn: sqlite3.Connection,
session_digest: str,
account_id: int,
) -> None:
"""Move guest lines into the durable account cart in the caller's transaction."""
cart_id = self._session_cart_id(conn, session_digest)
rows = conn.execute(
"""
SELECT asin,quantity,selection_json,selection_key,line_state
FROM cart_lines
WHERE cart_id=?
ORDER BY asin,selection_key,line_id
""",
(cart_id,),
).fetchall()
for row in rows:
conn.execute(
"""
INSERT INTO account_cart_lines(
line_id,account_id,asin,quantity,selection_json,
selection_key,line_state
) VALUES (?,?,?,?,?,?,?)
ON CONFLICT(account_id,asin,selection_key) DO UPDATE SET
quantity=MIN(30,account_cart_lines.quantity+excluded.quantity),
line_state=CASE
WHEN account_cart_lines.line_state='ACTIVE'
OR excluded.line_state='ACTIVE'
THEN 'ACTIVE'
ELSE 'SAVED'
END
""",
(
self._new_cart_line_id(),
account_id,
row["asin"],
int(row["quantity"]),
row["selection_json"],
row["selection_key"],
row["line_state"],
),
)
conn.execute("DELETE FROM cart_lines WHERE cart_id=?", (cart_id,))
def _merge_anonymous_compare_into_account(
self,
conn: sqlite3.Connection,
session_digest: str,
account_id: int,
) -> None:
"""Merge compatible guest comparisons behind one durable account.
Account rows keep their ordering and win duplicates. Guest rows get
fresh opaque identities so a pre-authentication browser cannot replay
an old line token after session rotation.
"""
account_rows = conn.execute(
"""
SELECT asin,selection_key,position
FROM account_compare_items
WHERE account_id=?
ORDER BY position
""",
(account_id,),
).fetchall()
family_keys = {
str(profile["family_key"])
for row in account_rows
if (profile := self._compare_profiles.get(str(row["asin"]))) is not None
}
identities = {
(str(row["asin"]), str(row["selection_key"]))
for row in account_rows
}
position = len(account_rows)
guest_rows = conn.execute(
"""
SELECT asin,selection_json,selection_key,created_at
FROM compare_items
WHERE session_digest=?
ORDER BY position
""",
(session_digest,),
).fetchall()
for row in guest_rows:
if position >= COMPARE_LIMIT:
break
asin = str(row["asin"])
profile = self._compare_profiles.get(asin)
identity = (asin, str(row["selection_key"]))
if profile is None or identity in identities:
continue
family_key = str(profile["family_key"])
if family_keys and family_keys != {family_key}:
continue
position += 1
conn.execute(
"""
INSERT INTO account_compare_items(
compare_line_id,account_id,asin,selection_json,
selection_key,position,created_at
) VALUES (?,?,?,?,?,?,?)
""",
(
self._new_compare_line_id(),
account_id,
asin,
row["selection_json"],
row["selection_key"],
position,
row["created_at"],
),
)
identities.add(identity)
family_keys.add(family_key)
conn.execute(
"DELETE FROM compare_items WHERE session_digest=?", (session_digest,)
)
def begin_signin(
self, session_digest: str, email: str, return_to: str | None
) -> None:
"""Persist only the pending identifier needed by the two-stage sign-in flow."""
self.ensure_session(session_digest)
email_normalized = normalize_email(email)
with self.connect() as conn:
conn.execute(
"""
INSERT INTO auth_signin_flows(
session_digest,email_normalized,return_to,updated_at
) VALUES (?,?,?,?)
ON CONFLICT(session_digest) DO UPDATE SET
email_normalized=excluded.email_normalized,
return_to=excluded.return_to,
updated_at=excluded.updated_at
""",
(session_digest, email_normalized, return_to, self.now(conn)),
)
def account_exists(self, email: str) -> bool:
email_normalized = normalize_email(email)
with self.connect() as conn:
return bool(
conn.execute(
"SELECT 1 FROM accounts WHERE email_normalized=?",
(email_normalized,),
).fetchone()
)
def create_externally_verified_account(
self,
session_digest: str,
email: str,
display_name: str,
password: str,
) -> bool:
"""Create an account after a separate Redis verification succeeds.
This path deliberately receives no OTP and writes no verification
challenge to SQLite. The caller must validate and consume the
session/email-bound Redis verification ticket.
"""
self.ensure_session(session_digest)
email_normalized = normalize_email(email)
password_salt, password_hash, scheme = password_record(password)
try:
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
if conn.execute(
"SELECT 1 FROM accounts WHERE email_normalized=?",
(email_normalized,),
).fetchone():
conn.rollback()
return False
cursor = conn.execute(
"""
INSERT INTO accounts(
email_normalized,display_name,password_salt,password_hash,
password_scheme,email_verified,created_at
) VALUES (?,?,?,?,?,?,?)
""",
(
email_normalized,
display_name,
password_salt,
password_hash,
scheme,
1,
self.now(conn),
),
)
account_id = int(cursor.lastrowid)
self._merge_anonymous_cart_into_account(
conn, session_digest, account_id
)
self._merge_anonymous_compare_into_account(
conn, session_digest, account_id
)
conn.execute(
"UPDATE browser_sessions SET account_id=? WHERE session_digest=?",
(account_id, session_digest),
)
conn.execute(
"DELETE FROM auth_signin_flows WHERE session_digest=?",
(session_digest,),
)
conn.execute(
"DELETE FROM auth_registration_flows WHERE session_digest=?",
(session_digest,),
)
conn.commit()
return True
except sqlite3.IntegrityError:
return False
@staticmethod
def _registration_code_hash(code: str, salt: bytes) -> bytes:
return hmac.new(salt, code.encode("ascii"), hashlib.sha256).digest()
@staticmethod
def _masked_email(email: str) -> str:
local, separator, domain = email.partition("@")
if not separator:
return "***"
visible = local[:1]
return f"{visible}{'*' * max(3, len(local) - 1)}@{domain}"
@staticmethod
def _queued_mail_state(mail_mode: str) -> tuple[str, int]:
if mail_mode == MAIL_LOCAL_ONLY:
return MAIL_LOCAL_ONLY, 1
if mail_mode == MAIL_SMTP_PENDING:
return MAIL_SMTP_PENDING, 0
raise ContractError("mail mode must be LOCAL_ONLY or SMTP_PENDING")
@staticmethod
def _auth_secret_key(kind: str, flow_id: str) -> tuple[str, str]:
if kind not in {"registration", "password-reset"}:
raise ContractError("unknown auth mail delivery kind")
if not isinstance(flow_id, str) or not flow_id:
raise ContractError("auth mail flow id is invalid")
return kind, flow_id
def _remember_auth_code(self, kind: str, flow_id: str, code: str) -> None:
if re.fullmatch(r"[0-9]{6}", code) is None:
raise ContractError("auth mail code is invalid")
key = self._auth_secret_key(kind, flow_id)
with self._auth_mail_secrets_lock:
self._auth_mail_secrets[key] = code
def _auth_code(self, kind: str, flow_id: str) -> str | None:
key = self._auth_secret_key(kind, flow_id)
with self._auth_mail_secrets_lock:
return self._auth_mail_secrets.get(key)
def _forget_auth_code(self, kind: str, flow_id: str) -> None:
key = self._auth_secret_key(kind, flow_id)
with self._auth_mail_secrets_lock:
self._auth_mail_secrets.pop(key, None)
def _invalidate_unrecoverable_auth_challenges(self) -> None:
"""Require reissue after a process restart or legacy OTP migration."""
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
conn.execute("DELETE FROM auth_registration_flows")
conn.execute(
"DELETE FROM auth_password_reset_flows WHERE verified_at IS NULL"
)
conn.commit()
@staticmethod
def _recipient_rate_key(email_normalized: str) -> str:
return hashlib.sha256(email_normalized.encode("utf-8")).hexdigest()
@staticmethod
def _consume_auth_mail_budget(
conn: sqlite3.Connection,
purpose: str,
scopes: list[tuple[str, str]],
current_time: int,
) -> bool:
"""Atomically enforce cooldown and a persistent rolling-window budget."""
normalized_scopes = list(dict.fromkeys(scopes))
rows: dict[tuple[str, str], sqlite3.Row | None] = {}
for scope_type, scope_key in normalized_scopes:
row = conn.execute(
"""
SELECT window_started_at,send_count,last_sent_at
FROM auth_mail_rate_limits
WHERE purpose=? AND scope_type=? AND scope_key=?
""",
(purpose, scope_type, scope_key),
).fetchone()
rows[(scope_type, scope_key)] = row
if row is None:
continue
if current_time < int(row["last_sent_at"]) + AUTH_MAIL_COOLDOWN_SECONDS:
return False
window_is_current = (
current_time
< int(row["window_started_at"]) + AUTH_MAIL_WINDOW_SECONDS
)
if (
window_is_current
and int(row["send_count"]) >= AUTH_MAIL_MAX_SENDS_PER_WINDOW
):
return False
for scope_type, scope_key in normalized_scopes:
row = rows[(scope_type, scope_key)]
if row is None:
conn.execute(
"""
INSERT INTO auth_mail_rate_limits(
purpose,scope_type,scope_key,window_started_at,
send_count,last_sent_at
) VALUES (?,?,?,?,1,?)
""",
(purpose, scope_type, scope_key, current_time, current_time),
)
continue
window_is_current = (
current_time
< int(row["window_started_at"]) + AUTH_MAIL_WINDOW_SECONDS
)
conn.execute(
"""
UPDATE auth_mail_rate_limits
SET window_started_at=?,send_count=?,last_sent_at=?
WHERE purpose=? AND scope_type=? AND scope_key=?
""",
(
int(row["window_started_at"])
if window_is_current
else current_time,
int(row["send_count"]) + 1 if window_is_current else 1,
current_time,
purpose,
scope_type,
scope_key,
),
)
return True
def begin_registration(
self,
session_digest: str,
email: str,
display_name: str,
password: str,
return_to: str | None,
*,
mail_mode: str = MAIL_LOCAL_ONLY,
) -> bool:
"""Queue verification without creating an account until its OTP succeeds."""
self.ensure_session(session_digest)
mail_status, is_simulation = self._queued_mail_state(mail_mode)
email_normalized = normalize_email(email)
password_salt, password_hash, scheme = password_record(password)
code = f"{secrets.randbelow(1_000_000):06d}"
code_salt = secrets.token_bytes(REGISTRATION_CODE_BYTES)
code_hash = self._registration_code_hash(code, code_salt)
pending_id = secrets.token_urlsafe(24)
created_at = int(time.time())
expires_at = created_at + REGISTRATION_CODE_TTL_SECONDS
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
if conn.execute(
"SELECT 1 FROM accounts WHERE email_normalized=?",
(email_normalized,),
).fetchone():
conn.rollback()
return False
if not self._consume_auth_mail_budget(
conn,
"registration",
[
("session", session_digest),
("recipient", self._recipient_rate_key(email_normalized)),
],
created_at,
):
conn.rollback()
return False
conn.execute(
"DELETE FROM auth_registration_flows WHERE session_digest=?",
(session_digest,),
)
conn.execute(
"""
INSERT INTO auth_registration_flows(
pending_id,session_digest,email_normalized,display_name,
password_salt,password_hash,password_scheme,return_to,
code_salt,code_hash,expires_at,attempts,created_at,updated_at
) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
""",
(
pending_id,
session_digest,
email_normalized,
display_name,
password_salt,
password_hash,
scheme,
return_to,
code_salt,
code_hash,
expires_at,
0,
created_at,
created_at,
),
)
conn.execute(
"""
INSERT INTO auth_registration_email_outbox(
pending_id,recipient,template,status,
is_simulation,created_at
) VALUES (?,?,?,?,?,?)
""",
(
pending_id,
email_normalized,
"registration-verification",
mail_status,
is_simulation,
created_at,
),
)
conn.commit()
self._remember_auth_code("registration", pending_id, code)
return True
def pending_registration(self, session_digest: str) -> dict[str, Any] | None:
self.ensure_session(session_digest)
with self.connect() as conn:
row = conn.execute(
"""
SELECT email_normalized,expires_at,attempts
FROM auth_registration_flows
WHERE session_digest=?
""",
(session_digest,),
).fetchone()
if row is None:
return None
return {
"masked_email": self._masked_email(str(row["email_normalized"])),
"expires_at": int(row["expires_at"]),
"attempts_remaining": max(
0, REGISTRATION_CODE_MAX_ATTEMPTS - int(row["attempts"])
),
}
def registration_outbox(
self, session_digest: str | None = None
) -> list[dict[str, Any]]:
"""Read protected registration delivery state, exposing OTP only locally."""
where = "WHERE f.session_digest=?" if session_digest else ""
parameters: tuple[str, ...] = (session_digest,) if session_digest else ()
with self.connect() as conn:
rows = conn.execute(
f"""
SELECT o.email_id,o.pending_id,o.recipient,o.template,
o.status,o.is_simulation,o.created_at,
o.delivery_attempts,o.last_error,o.attempted_at,o.sent_at,
f.expires_at,f.attempts
FROM auth_registration_email_outbox o
JOIN auth_registration_flows f ON f.pending_id=o.pending_id
{where}
ORDER BY o.email_id
""",
parameters,
).fetchall()
current_time = int(time.time())
return [
{
"email_id": int(row["email_id"]),
"pending_id": str(row["pending_id"]),
"recipient_masked": self._masked_email(str(row["recipient"])),
"template": str(row["template"]),
"verification_code": (
self._auth_code("registration", str(row["pending_id"]))
if str(row["status"]) == MAIL_LOCAL_ONLY
else None
),
"status": str(row["status"]),
"is_simulation": bool(row["is_simulation"]),
"created_at": int(row["created_at"]),
"expires_at": int(row["expires_at"]),
"expired": current_time > int(row["expires_at"]),
"attempts": int(row["attempts"]),
"delivery_attempts": int(row["delivery_attempts"]),
"last_error": row["last_error"],
"attempted_at": row["attempted_at"],
"sent_at": row["sent_at"],
}
for row in rows
]
def resend_registration_code(
self, session_digest: str, *, mail_mode: str = MAIL_LOCAL_ONLY
) -> bool:
"""Invalidate the previous code and queue one replacement delivery."""
self.ensure_session(session_digest)
mail_status, is_simulation = self._queued_mail_state(mail_mode)
created_at = int(time.time())
expires_at = created_at + REGISTRATION_CODE_TTL_SECONDS
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
row = conn.execute(
"""
SELECT f.pending_id,f.email_normalized,f.code_salt,f.code_hash,
f.attempts
FROM auth_registration_flows f
WHERE f.session_digest=?
""",
(session_digest,),
).fetchone()
if row is None:
conn.rollback()
return False
if int(row["attempts"]) >= REGISTRATION_CODE_MAX_ATTEMPTS:
conn.rollback()
return False
if not self._consume_auth_mail_budget(
conn,
"registration",
[
("session", session_digest),
(
"recipient",
self._recipient_rate_key(str(row["email_normalized"])),
),
],
created_at,
):
conn.rollback()
return False
code = f"{secrets.randbelow(1_000_000):06d}"
while hmac.compare_digest(
self._registration_code_hash(code, bytes(row["code_salt"])),
bytes(row["code_hash"]),
):
code = f"{secrets.randbelow(1_000_000):06d}"
code_salt = secrets.token_bytes(REGISTRATION_CODE_BYTES)
code_hash = self._registration_code_hash(code, code_salt)
conn.execute(
"""
UPDATE auth_registration_flows
SET code_salt=?,code_hash=?,expires_at=?,attempts=0,updated_at=?
WHERE session_digest=?
""",
(code_salt, code_hash, expires_at, created_at, session_digest),
)
conn.execute(
"""
DELETE FROM auth_registration_email_outbox WHERE pending_id=?
""",
(str(row["pending_id"]),),
)
conn.execute(
"""
INSERT INTO auth_registration_email_outbox(
pending_id,recipient,template,status,
is_simulation,created_at
) VALUES (?,?,'registration-verification',?,?,?)
""",
(
str(row["pending_id"]),
str(row["email_normalized"]),
mail_status,
is_simulation,
created_at,
),
)
conn.commit()
self._remember_auth_code("registration", str(row["pending_id"]), code)
return True
def verify_registration_code(
self, session_digest: str, code: str
) -> tuple[str, str | None]:
"""Consume one pending OTP and create/bind the account atomically."""
self.ensure_session(session_digest)
current_time = int(time.time())
try:
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
row = conn.execute(
"""
SELECT * FROM auth_registration_flows
WHERE session_digest=?
""",
(session_digest,),
).fetchone()
if row is None:
conn.rollback()
return "missing", None
attempts = int(row["attempts"])
if current_time > int(row["expires_at"]):
conn.rollback()
return "expired", None
if attempts >= REGISTRATION_CODE_MAX_ATTEMPTS:
conn.rollback()
return "locked", None
candidate_hash = self._registration_code_hash(
code, bytes(row["code_salt"])
)
if not hmac.compare_digest(candidate_hash, bytes(row["code_hash"])):
attempts += 1
conn.execute(
"""
UPDATE auth_registration_flows
SET attempts=?,updated_at=?
WHERE session_digest=?
""",
(attempts, current_time, session_digest),
)
conn.commit()
return (
"locked"
if attempts >= REGISTRATION_CODE_MAX_ATTEMPTS
else "invalid",
None,
)
cursor = conn.execute(
"""
INSERT INTO accounts(
email_normalized,display_name,password_salt,password_hash,
password_scheme,email_verified,created_at
) VALUES (?,?,?,?,?,?,?)
""",
(
str(row["email_normalized"]),
str(row["display_name"]),
bytes(row["password_salt"]),
bytes(row["password_hash"]),
str(row["password_scheme"]),
1,
self.now(conn),
),
)
account_id = int(cursor.lastrowid)
self._merge_anonymous_cart_into_account(
conn, session_digest, account_id
)
self._merge_anonymous_compare_into_account(
conn, session_digest, account_id
)
conn.execute(
"UPDATE browser_sessions SET account_id=? WHERE session_digest=?",
(account_id, session_digest),
)
conn.execute(
"DELETE FROM auth_signin_flows WHERE session_digest=?",
(session_digest,),
)
conn.execute(
"DELETE FROM auth_registration_flows WHERE session_digest=?",
(session_digest,),
)
return_to = str(row["return_to"]) if row["return_to"] else None
conn.commit()
return "verified", return_to
except sqlite3.IntegrityError:
with self.connect() as conn:
conn.execute(
"DELETE FROM auth_registration_flows WHERE session_digest=?",
(session_digest,),
)
return "duplicate", None
def begin_password_reset(
self,
session_digest: str,
email: str,
return_to: str | None,
*,
mail_mode: str = MAIL_LOCAL_ONLY,
) -> None:
"""Start an enumeration-resistant reset flow for known or unknown email."""
self.ensure_session(session_digest)
mail_status, is_simulation = self._queued_mail_state(mail_mode)
email_normalized = normalize_email(email)
code = f"{secrets.randbelow(1_000_000):06d}"
code_salt = secrets.token_bytes(REGISTRATION_CODE_BYTES)
code_hash = self._registration_code_hash(code, code_salt)
reset_id = secrets.token_urlsafe(24)
created_at = int(time.time())
expires_at = created_at + PASSWORD_RESET_CODE_TTL_SECONDS
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_row = conn.execute(
"""
SELECT account_id,email_normalized
FROM accounts WHERE email_normalized=?
""",
(email_normalized,),
).fetchone()
account_id = (
int(account_row["account_id"]) if account_row is not None else None
)
rate_scopes = [
("session", session_digest),
("recipient", self._recipient_rate_key(email_normalized)),
]
if account_id is not None:
rate_scopes.append(("account", str(account_id)))
if not self._consume_auth_mail_budget(
conn,
"password-reset",
rate_scopes,
created_at,
):
# Preserve an already-issued code only when this same browser
# asked for the same account again. A different target replaces
# the session flow with a decoy, preventing an old code for A
# from being entered after the UI has requested account B.
existing_session_flow = conn.execute(
"""
SELECT f.account_id,a.email_normalized
FROM auth_password_reset_flows f
LEFT JOIN accounts a ON a.account_id=f.account_id
WHERE f.session_digest=?
""",
(session_digest,),
).fetchone()
preserve_existing = bool(
existing_session_flow is not None
and existing_session_flow["account_id"] is not None
and str(existing_session_flow["email_normalized"])
== email_normalized
)
if not preserve_existing:
conn.execute(
"DELETE FROM auth_password_reset_flows WHERE session_digest=?",
(session_digest,),
)
conn.execute(
"""
INSERT INTO auth_password_reset_flows(
reset_id,session_digest,account_id,return_to,code_salt,
code_hash,expires_at,attempts,verified_at,created_at,
updated_at
) VALUES (?,?,NULL,NULL,?,?,?,0,NULL,?,?)
""",
(
reset_id,
session_digest,
code_salt,
code_hash,
expires_at,
created_at,
created_at,
),
)
conn.commit()
return
conn.execute(
"DELETE FROM auth_password_reset_flows WHERE session_digest=?",
(session_digest,),
)
if account_id is not None:
# One active reset code per account: a request from another
# browser replaces every older code for that account.
conn.execute(
"DELETE FROM auth_password_reset_flows WHERE account_id=?",
(account_id,),
)
conn.execute(
"""
INSERT INTO auth_password_reset_flows(
reset_id,session_digest,account_id,return_to,code_salt,
code_hash,expires_at,attempts,verified_at,created_at,updated_at
) VALUES (?,?,?,?,?,?,?,0,NULL,?,?)
""",
(
reset_id,
session_digest,
account_id,
return_to,
code_salt,
code_hash,
expires_at,
created_at,
created_at,
),
)
if account_row is not None:
# The recipient is loaded from the account row, never copied
# from an arbitrary form field after lookup.
conn.execute(
"""
INSERT INTO auth_password_reset_email_outbox(
reset_id,recipient,template,status,
is_simulation,created_at
) VALUES (?,?,'password-reset-verification',?,?,?)
""",
(
reset_id,
str(account_row["email_normalized"]),
mail_status,
is_simulation,
created_at,
),
)
conn.commit()
if account_row is not None:
self._remember_auth_code("password-reset", reset_id, code)
def pending_password_reset(
self, session_digest: str
) -> dict[str, Any] | None:
self.ensure_session(session_digest)
with self.connect() as conn:
row = conn.execute(
"""
SELECT expires_at,attempts,verified_at
FROM auth_password_reset_flows WHERE session_digest=?
""",
(session_digest,),
).fetchone()
if row is None:
return None
return {
"expires_at": int(row["expires_at"]),
"attempts_remaining": max(
0, PASSWORD_RESET_CODE_MAX_ATTEMPTS - int(row["attempts"])
),
"verified": row["verified_at"] is not None,
}
def password_reset_outbox(
self, session_digest: str | None = None
) -> list[dict[str, Any]]:
"""Read protected reset delivery state, exposing OTP only locally."""
where = "WHERE f.session_digest=?" if session_digest else ""
parameters: tuple[str, ...] = (session_digest,) if session_digest else ()
with self.connect() as conn:
rows = conn.execute(
f"""
SELECT o.email_id,o.reset_id,o.recipient,o.template,
o.status,o.is_simulation,o.created_at,
o.delivery_attempts,o.last_error,o.attempted_at,o.sent_at,
f.expires_at,f.attempts,f.verified_at
FROM auth_password_reset_email_outbox o
JOIN auth_password_reset_flows f ON f.reset_id=o.reset_id
{where}
ORDER BY o.email_id
""",
parameters,
).fetchall()
current_time = int(time.time())
return [
{
"email_id": int(row["email_id"]),
"reset_id": str(row["reset_id"]),
"recipient_masked": self._masked_email(str(row["recipient"])),
"template": str(row["template"]),
"verification_code": (
self._auth_code("password-reset", str(row["reset_id"]))
if str(row["status"]) == MAIL_LOCAL_ONLY
else None
),
"status": str(row["status"]),
"is_simulation": bool(row["is_simulation"]),
"created_at": int(row["created_at"]),
"expires_at": int(row["expires_at"]),
"expired": current_time > int(row["expires_at"]),
"attempts": int(row["attempts"]),
"verified": row["verified_at"] is not None,
"delivery_attempts": int(row["delivery_attempts"]),
"last_error": row["last_error"],
"attempted_at": row["attempted_at"],
"sent_at": row["sent_at"],
}
for row in rows
]
@staticmethod
def _public_mail_status(
message: dict[str, Any], *, flow_attempt_limit: int
) -> dict[str, Any]:
"""Return only the delivery fields safe for a flow-owning browser."""
status = str(message["status"])
delivery_attempts = int(message["delivery_attempts"])
flow_attempts = int(message.get("attempts", flow_attempt_limit))
expired = bool(message.get("expired", False))
verified = bool(message.get("verified", False))
return {
"status": status,
"delivery_attempts": delivery_attempts,
"can_retry": (
status == MAIL_SMTP_FAILED
and delivery_attempts < MAIL_DELIVERY_MAX_ATTEMPTS
and flow_attempts < flow_attempt_limit
and not expired
and not verified
),
}
def registration_mail_status(
self, session_digest: str
) -> dict[str, Any] | None:
"""Read mail state only for this browser's active registration flow."""
self.ensure_session(session_digest)
messages = self.registration_outbox(session_digest)
return (
self._public_mail_status(
messages[0], flow_attempt_limit=REGISTRATION_CODE_MAX_ATTEMPTS
)
if messages
else None
)
def password_reset_mail_status(
self, session_digest: str
) -> dict[str, Any] | None:
"""Read mail state only for this browser's active recovery flow."""
self.ensure_session(session_digest)
messages = self.password_reset_outbox(session_digest)
if not messages:
return None
return self._public_mail_status(
messages[0], flow_attempt_limit=PASSWORD_RESET_CODE_MAX_ATTEMPTS
)
def resend_password_reset_code(
self, session_digest: str, *, mail_mode: str = MAIL_LOCAL_ONLY
) -> bool:
"""Replace the current reset OTP without revealing account existence."""
self.ensure_session(session_digest)
mail_status, is_simulation = self._queued_mail_state(mail_mode)
created_at = int(time.time())
expires_at = created_at + PASSWORD_RESET_CODE_TTL_SECONDS
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
row = conn.execute(
"""
SELECT f.reset_id,f.account_id,f.code_salt,f.code_hash,
f.attempts,a.email_normalized
FROM auth_password_reset_flows f
LEFT JOIN accounts a ON a.account_id=f.account_id
WHERE f.session_digest=?
""",
(session_digest,),
).fetchone()
if row is None:
conn.rollback()
return False
if int(row["attempts"]) >= PASSWORD_RESET_CODE_MAX_ATTEMPTS:
conn.rollback()
return False
rate_scopes = [("session", session_digest)]
if row["account_id"] is not None:
rate_scopes.extend(
[
("account", str(row["account_id"])),
(
"recipient",
self._recipient_rate_key(str(row["email_normalized"])),
),
]
)
if not self._consume_auth_mail_budget(
conn,
"password-reset",
rate_scopes,
created_at,
):
conn.rollback()
return False
code = f"{secrets.randbelow(1_000_000):06d}"
while hmac.compare_digest(
self._registration_code_hash(code, bytes(row["code_salt"])),
bytes(row["code_hash"]),
):
code = f"{secrets.randbelow(1_000_000):06d}"
code_salt = secrets.token_bytes(REGISTRATION_CODE_BYTES)
code_hash = self._registration_code_hash(code, code_salt)
conn.execute(
"""
UPDATE auth_password_reset_flows
SET code_salt=?,code_hash=?,expires_at=?,attempts=0,
verified_at=NULL,updated_at=?
WHERE session_digest=?
""",
(code_salt, code_hash, expires_at, created_at, session_digest),
)
if row["account_id"] is not None:
conn.execute(
"""
DELETE FROM auth_password_reset_email_outbox WHERE reset_id=?
""",
(str(row["reset_id"]),),
)
conn.execute(
"""
INSERT INTO auth_password_reset_email_outbox(
reset_id,recipient,template,status,
is_simulation,created_at
) VALUES (?,?,'password-reset-verification',?,?,?)
""",
(
str(row["reset_id"]),
str(row["email_normalized"]),
mail_status,
is_simulation,
created_at,
),
)
conn.commit()
if row["account_id"] is not None:
self._remember_auth_code("password-reset", str(row["reset_id"]), code)
return True
def verify_password_reset_code(
self, session_digest: str, code: str
) -> str:
"""Consume one reset OTP and unlock only this session's password form."""
self.ensure_session(session_digest)
current_time = int(time.time())
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
row = conn.execute(
"""
SELECT * FROM auth_password_reset_flows WHERE session_digest=?
""",
(session_digest,),
).fetchone()
if row is None:
conn.rollback()
return "missing"
if row["verified_at"] is not None:
conn.rollback()
return "used"
if current_time > int(row["expires_at"]):
conn.rollback()
return "expired"
attempts = int(row["attempts"])
if attempts >= PASSWORD_RESET_CODE_MAX_ATTEMPTS:
conn.rollback()
return "locked"
candidate_hash = self._registration_code_hash(
code, bytes(row["code_salt"])
)
valid = hmac.compare_digest(candidate_hash, bytes(row["code_hash"]))
if not valid or row["account_id"] is None:
attempts += 1
conn.execute(
"""
UPDATE auth_password_reset_flows
SET attempts=?,updated_at=? WHERE session_digest=?
""",
(attempts, current_time, session_digest),
)
conn.commit()
return (
"locked"
if attempts >= PASSWORD_RESET_CODE_MAX_ATTEMPTS
else "invalid"
)
conn.execute(
"""
UPDATE auth_password_reset_flows
SET verified_at=?,updated_at=?,code_salt=?,code_hash=?
WHERE session_digest=?
""",
(
current_time,
current_time,
secrets.token_bytes(REGISTRATION_CODE_BYTES),
secrets.token_bytes(32),
session_digest,
),
)
conn.commit()
return "verified"
def complete_password_reset(
self, session_digest: str, password: str
) -> tuple[str, str | None]:
"""Set the new password, revoke other sessions, and authenticate this one."""
self.ensure_session(session_digest)
current_time = int(time.time())
password_salt, password_hash, scheme = password_record(password)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
row = conn.execute(
"""
SELECT f.*,a.email_normalized
FROM auth_password_reset_flows f
LEFT JOIN accounts a ON a.account_id=f.account_id
WHERE f.session_digest=?
""",
(session_digest,),
).fetchone()
if row is None or row["account_id"] is None:
conn.rollback()
return "missing", None
if current_time > int(row["expires_at"]):
conn.rollback()
return "expired", None
if row["verified_at"] is None:
conn.rollback()
return "unverified", None
account_id = int(row["account_id"])
return_to = str(row["return_to"]) if row["return_to"] else None
conn.execute(
"""
UPDATE accounts
SET password_salt=?,password_hash=?,password_scheme=?
WHERE account_id=?
""",
(password_salt, password_hash, scheme, account_id),
)
# Password reset revokes every existing authenticated browser. The
# recovery session is rebound below and then rotated by the server.
conn.execute(
"UPDATE browser_sessions SET account_id=NULL WHERE account_id=?",
(account_id,),
)
conn.execute(
"DELETE FROM auth_signin_flows WHERE email_normalized=?",
(str(row["email_normalized"]),),
)
conn.execute(
"DELETE FROM auth_password_reset_flows WHERE account_id=?",
(account_id,),
)
self._merge_anonymous_cart_into_account(
conn, session_digest, account_id
)
self._merge_anonymous_compare_into_account(
conn, session_digest, account_id
)
conn.execute(
"UPDATE browser_sessions SET account_id=? WHERE session_digest=?",
(account_id, session_digest),
)
conn.commit()
return "reset", return_to
def _retry_auth_mail(self, session_digest: str, kind: str) -> bool:
"""Requeue one failed OTP delivery without accepting a public mail id.
The browser session selects the active flow. Normally the original
still-valid OTP is retained. Older databases may contain failed jobs
whose plaintext code was redacted; in that case a replacement code is
generated atomically and the old hash is invalidated.
"""
self.ensure_session(session_digest)
if kind == "registration":
outbox = "auth_registration_email_outbox"
flow_table = "auth_registration_flows"
flow_key = "pending_id"
ttl_seconds = REGISTRATION_CODE_TTL_SECONDS
verified_clause = ""
elif kind == "password-reset":
outbox = "auth_password_reset_email_outbox"
flow_table = "auth_password_reset_flows"
flow_key = "reset_id"
ttl_seconds = PASSWORD_RESET_CODE_TTL_SECONDS
verified_clause = "AND f.verified_at IS NULL"
else:
raise ContractError("unknown auth mail delivery kind")
current_time = int(time.time())
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
row = conn.execute(
f"""
SELECT o.email_id,o.delivery_attempts,
f.{flow_key} AS flow_id,f.code_salt,f.code_hash,
f.expires_at,f.attempts
FROM {outbox} o
JOIN {flow_table} f ON f.{flow_key}=o.{flow_key}
WHERE f.session_digest=? AND o.status='SMTP_FAILED'
AND o.claim_token IS NULL
AND o.delivery_attempts < ?
AND f.expires_at >= ?
AND f.attempts < ?
{verified_clause}
""",
(
session_digest,
MAIL_DELIVERY_MAX_ATTEMPTS,
current_time,
(
REGISTRATION_CODE_MAX_ATTEMPTS
if kind == "registration"
else PASSWORD_RESET_CODE_MAX_ATTEMPTS
),
),
).fetchone()
if row is None:
conn.rollback()
return False
flow_id = str(row["flow_id"])
code = self._auth_code(kind, flow_id)
retained_code_is_valid = bool(
code is not None
and re.fullmatch(r"[0-9]{6}", code)
and hmac.compare_digest(
# mypy cannot narrow through the regular-expression call.
self._registration_code_hash(code, bytes(row["code_salt"])),
bytes(row["code_hash"]),
)
)
if not retained_code_is_valid:
code = f"{secrets.randbelow(1_000_000):06d}"
code_salt = secrets.token_bytes(REGISTRATION_CODE_BYTES)
code_hash = self._registration_code_hash(code, code_salt)
expires_at = current_time + ttl_seconds
conn.execute(
f"""
UPDATE {flow_table}
SET code_salt=?,code_hash=?,expires_at=?,attempts=0,updated_at=?
WHERE {flow_key}=?
""",
(
code_salt,
code_hash,
expires_at,
current_time,
str(row["flow_id"]),
),
)
cursor = conn.execute(
f"""
UPDATE {outbox}
SET status='SMTP_PENDING',is_simulation=0,
claim_token=NULL,last_error=NULL,attempted_at=NULL,sent_at=NULL
WHERE email_id=? AND status='SMTP_FAILED'
AND claim_token IS NULL
""",
(int(row["email_id"]),),
)
if cursor.rowcount != 1:
conn.rollback()
return False
conn.commit()
self._remember_auth_code(kind, flow_id, code)
return True
def retry_registration_mail(self, session_digest: str) -> bool:
return self._retry_auth_mail(session_digest, "registration")
def retry_password_reset_mail(self, session_digest: str) -> bool:
return self._retry_auth_mail(session_digest, "password-reset")
def retry_order_mail(
self, session_digest: str, order_id: int | str
) -> bool:
"""Requeue a failed confirmation only for the authenticated owner."""
self.ensure_session(session_digest)
normalized = self._normalized_order_id(order_id)
if normalized is None:
raise ContractError("order id must be a positive integer")
with self.connect() as conn:
cursor = conn.execute(
"""
UPDATE email_outbox
SET status='SMTP_PENDING',is_simulation=0,claim_token=NULL,
last_error=NULL,attempted_at=NULL,sent_at=NULL
WHERE order_id=? AND status='SMTP_FAILED'
AND claim_token IS NULL
AND delivery_attempts < ?
AND account_id=(
SELECT account_id FROM browser_sessions
WHERE session_digest=? AND account_id IS NOT NULL
)
""",
(normalized, MAIL_DELIVERY_MAX_ATTEMPTS, session_digest),
)
return cursor.rowcount == 1
def registration_delivery(
self, session_digest: str
) -> dict[str, Any] | None:
with self.connect() as conn:
row = conn.execute(
"""
SELECT o.email_id,o.recipient,o.pending_id,f.expires_at
FROM auth_registration_email_outbox o
JOIN auth_registration_flows f ON f.pending_id=o.pending_id
WHERE f.session_digest=? AND o.status='SMTP_PENDING'
AND o.claim_token IS NULL
AND o.delivery_attempts < ?
""",
(session_digest, MAIL_DELIVERY_MAX_ATTEMPTS),
).fetchone()
if row is None:
return None
code = self._auth_code("registration", str(row["pending_id"]))
if code is None:
return None
return {
"kind": "registration",
"email_id": int(row["email_id"]),
"recipient": str(row["recipient"]),
"subject": "Verify your Amazon Clone email address",
"body": (
"Your Amazon Clone verification code is "
f"{code}. It expires in 10 minutes.\n\n"
"If you did not create this account, you can ignore this message."
),
}
def password_reset_delivery(
self, session_digest: str
) -> dict[str, Any] | None:
with self.connect() as conn:
row = conn.execute(
"""
SELECT o.email_id,o.recipient,o.reset_id
FROM auth_password_reset_email_outbox o
JOIN auth_password_reset_flows f ON f.reset_id=o.reset_id
WHERE f.session_digest=? AND o.status='SMTP_PENDING'
AND o.claim_token IS NULL
AND o.delivery_attempts < ?
""",
(session_digest, MAIL_DELIVERY_MAX_ATTEMPTS),
).fetchone()
if row is None:
return None
code = self._auth_code("password-reset", str(row["reset_id"]))
if code is None:
return None
return {
"kind": "password-reset",
"email_id": int(row["email_id"]),
"recipient": str(row["recipient"]),
"subject": "Reset your Amazon Clone password",
"body": (
"Your Amazon Clone password reset code is "
f"{code}. It expires in 10 minutes.\n\n"
"If you did not request a password reset, you can ignore this message."
),
}
def order_mail_delivery(self, order_id: int | str) -> dict[str, Any] | None:
normalized = self._normalized_order_id(order_id)
if normalized is None:
raise ContractError("order id must be a positive integer")
with self.connect() as conn:
row = conn.execute(
"""
SELECT email_id,recipient,subject,payload_json
FROM email_outbox
WHERE order_id=? AND status='SMTP_PENDING'
AND claim_token IS NULL
AND delivery_attempts < ?
""",
(normalized, MAIL_DELIVERY_MAX_ATTEMPTS),
).fetchone()
if row is None:
return None
payload = json.loads(str(row["payload_json"]))
item_lines = [
f"- {item['asin']} × {int(item['quantity'])}"
for item in payload.get("items", [])
]
return {
"kind": "order-confirmation",
"email_id": int(row["email_id"]),
"recipient": str(row["recipient"]),
"subject": str(row["subject"]),
"body": (
f"Your Amazon Clone order #{normalized} was placed.\n\n"
+ ("\n".join(item_lines) or "No item summary is available.")
+ "\n\n"
+ f"Total: {int(payload['total_minor']) / 100:.2f} "
+ str(payload["currency"])
+ "\n\nThis message confirms a local simulated order; no card was charged."
),
}
@staticmethod
def _mail_delivery_target(kind: str) -> tuple[str, str]:
targets = {
"registration": ("auth_registration_email_outbox", "email_id"),
"password-reset": ("auth_password_reset_email_outbox", "email_id"),
"order-confirmation": ("email_outbox", "email_id"),
}
target = targets.get(kind)
if target is None:
raise ContractError("unknown mail delivery kind")
return target
def claim_mail_delivery(self, kind: str, email_id: int) -> str | None:
"""Claim one pending job so concurrent requests cannot send it twice."""
if isinstance(email_id, bool) or not isinstance(email_id, int) or email_id <= 0:
raise ContractError("mail delivery id must be a positive integer")
table, id_column = self._mail_delivery_target(kind)
claim_token = secrets.token_urlsafe(24)
attempted_at = int(time.time())
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
shared_mail_id: str | None = None
if kind == "order-confirmation":
shared = conn.execute(
"SELECT site_backend_mail_id FROM email_outbox "
"WHERE email_id=?",
(email_id,),
).fetchone()
if shared is not None and shared["site_backend_mail_id"]:
shared_mail_id = str(shared["site_backend_mail_id"])
cursor = conn.execute(
f"""
UPDATE {table}
SET claim_token=?,attempted_at=?,
delivery_attempts=delivery_attempts+1
WHERE {id_column}=? AND status='SMTP_PENDING'
AND claim_token IS NULL
AND delivery_attempts < ?
""",
(
claim_token,
attempted_at,
email_id,
MAIL_DELIVERY_MAX_ATTEMPTS,
),
)
if cursor.rowcount != 1:
conn.rollback()
return None
if shared_mail_id is not None:
shared_claim = self.site_backend.mail.claim_pending(
mail_id=shared_mail_id,
now=attempted_at,
connection=conn,
)
if shared_claim is None:
conn.rollback()
return None
conn.execute(
"UPDATE email_outbox SET site_backend_claim_token=? "
"WHERE email_id=?",
(str(shared_claim["claim_token"]), email_id),
)
conn.commit()
return claim_token
def recover_pending_mail_claims(self) -> int:
"""Release claims left by a previous single-process server instance."""
recovered = 0
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
for table in (
"auth_registration_email_outbox",
"auth_password_reset_email_outbox",
"email_outbox",
):
cursor = conn.execute(
f"""
UPDATE {table} SET claim_token=NULL
WHERE status='SMTP_PENDING' AND claim_token IS NOT NULL
AND delivery_attempts < ?
""",
(MAIL_DELIVERY_MAX_ATTEMPTS,),
)
recovered += cursor.rowcount
current_time = int(time.time())
recovered += self.site_backend.mail.release_stale_claims(
older_than=current_time,
now=current_time,
connection=conn,
)
conn.commit()
return recovered
def fail_exhausted_pending_mail(self) -> int:
"""Close jobs that already consumed the bounded SMTP attempt budget."""
failed = 0
attempted_at = int(time.time())
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
for table in (
"auth_registration_email_outbox",
"auth_password_reset_email_outbox",
"email_outbox",
):
cursor = conn.execute(
f"""
UPDATE {table}
SET status='SMTP_FAILED',is_simulation=0,claim_token=NULL,
last_error='DeliveryAttemptsExhausted',
attempted_at=COALESCE(attempted_at,?),sent_at=NULL
WHERE status='SMTP_PENDING' AND delivery_attempts >= ?
""",
(attempted_at, MAIL_DELIVERY_MAX_ATTEMPTS),
)
failed += cursor.rowcount
conn.commit()
return failed
def reconcile_mail_for_local_only(self) -> int:
"""Convert unfinished SMTP jobs when this startup has no transport.
Auth flows keep a usable local OTP. A legacy failed row may contain a
redacted code, so repair its code/hash atomically before exposing it in
the protected LOCAL_ONLY outbox.
"""
current_time = int(time.time())
localized = 0
auth_targets = (
(
"registration",
"auth_registration_email_outbox",
"auth_registration_flows",
"pending_id",
REGISTRATION_CODE_TTL_SECONDS,
"NULL AS verified_at",
),
(
"password-reset",
"auth_password_reset_email_outbox",
"auth_password_reset_flows",
"reset_id",
PASSWORD_RESET_CODE_TTL_SECONDS,
"f.verified_at AS verified_at",
),
)
remembered: list[tuple[str, str, str]] = []
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
for (
kind,
outbox,
flow_table,
flow_key,
ttl_seconds,
verified_column,
) in auth_targets:
rows = conn.execute(
f"""
SELECT o.email_id,
f.{flow_key} AS flow_id,f.code_salt,f.code_hash,
f.expires_at,{verified_column}
FROM {outbox} o
JOIN {flow_table} f ON f.{flow_key}=o.{flow_key}
WHERE o.status IN ('SMTP_PENDING','SMTP_FAILED')
"""
).fetchall()
for row in rows:
flow_id = str(row["flow_id"])
code = self._auth_code(kind, flow_id)
usable = bool(
code is not None
and re.fullmatch(r"[0-9]{6}", code)
and hmac.compare_digest(
self._registration_code_hash(
code, bytes(row["code_salt"])
),
bytes(row["code_hash"]),
)
and int(row["expires_at"]) >= current_time
)
if not usable and row["verified_at"] is None:
code = f"{secrets.randbelow(1_000_000):06d}"
code_salt = secrets.token_bytes(REGISTRATION_CODE_BYTES)
conn.execute(
f"""
UPDATE {flow_table}
SET code_salt=?,code_hash=?,expires_at=?,attempts=0,
updated_at=?
WHERE {flow_key}=?
""",
(
code_salt,
self._registration_code_hash(code, code_salt),
current_time + ttl_seconds,
current_time,
flow_id,
),
)
if code is not None and row["verified_at"] is None:
remembered.append((kind, flow_id, code))
cursor = conn.execute(
f"""
UPDATE {outbox}
SET status='LOCAL_ONLY',
is_simulation=1,claim_token=NULL,last_error=NULL,
attempted_at=NULL,sent_at=NULL
WHERE email_id=?
AND status IN ('SMTP_PENDING','SMTP_FAILED')
""",
(int(row["email_id"]),),
)
localized += cursor.rowcount
cursor = conn.execute(
"""
UPDATE email_outbox
SET status='LOCAL_ONLY',is_simulation=1,claim_token=NULL,
last_error=NULL,attempted_at=NULL,sent_at=NULL
WHERE status IN ('SMTP_PENDING','SMTP_FAILED')
"""
)
localized += cursor.rowcount
conn.execute(
"""
UPDATE websitebench_mail_jobs
SET status='LOCAL_SIMULATION',is_simulation=1,
claim_token=NULL,claimed_at=NULL,error_category=NULL,
next_attempt_at=0,updated_at=?
WHERE site_id='amazon'
AND purpose='order-receipt'
AND status IN ('PENDING','FAILED')
""",
(self.now(conn),),
)
conn.commit()
for kind, flow_id, code in remembered:
self._remember_auth_code(kind, flow_id, code)
return localized
def expire_stale_pending_auth_mail(self) -> int:
"""Fail pending OTP mail that can no longer arrive before code expiry."""
current_time = int(time.time())
expired = 0
targets = (
(
"auth_registration_email_outbox",
"pending_id",
"auth_registration_flows",
"pending_id",
),
(
"auth_password_reset_email_outbox",
"reset_id",
"auth_password_reset_flows",
"reset_id",
),
)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
for outbox, outbox_key, flow_table, flow_key in targets:
cursor = conn.execute(
f"""
UPDATE {outbox}
SET status='SMTP_FAILED',is_simulation=0,claim_token=NULL,
last_error='ExpiredBeforeDelivery',
attempted_at=COALESCE(attempted_at,?)
WHERE status='SMTP_PENDING' AND {outbox_key} IN (
SELECT {flow_key} FROM {flow_table} WHERE expires_at < ?
)
""",
(current_time, current_time),
)
expired += cursor.rowcount
conn.commit()
return expired
def pending_mail_deliveries(self) -> list[dict[str, Any]]:
"""Build every unclaimed SMTP job for startup replay."""
with self.connect() as conn:
registration_sessions = [
str(row["session_digest"])
for row in conn.execute(
"""
SELECT f.session_digest
FROM auth_registration_email_outbox o
JOIN auth_registration_flows f ON f.pending_id=o.pending_id
WHERE o.status='SMTP_PENDING' AND o.claim_token IS NULL
AND o.delivery_attempts < ?
ORDER BY o.email_id
""",
(MAIL_DELIVERY_MAX_ATTEMPTS,),
)
]
reset_sessions = [
str(row["session_digest"])
for row in conn.execute(
"""
SELECT f.session_digest
FROM auth_password_reset_email_outbox o
JOIN auth_password_reset_flows f ON f.reset_id=o.reset_id
WHERE o.status='SMTP_PENDING' AND o.claim_token IS NULL
AND o.delivery_attempts < ?
ORDER BY o.email_id
""",
(MAIL_DELIVERY_MAX_ATTEMPTS,),
)
]
order_ids = [
int(row["order_id"])
for row in conn.execute(
"""
SELECT order_id FROM email_outbox
WHERE status='SMTP_PENDING' AND claim_token IS NULL
AND delivery_attempts < ?
ORDER BY email_id
""",
(MAIL_DELIVERY_MAX_ATTEMPTS,),
)
]
deliveries: list[dict[str, Any]] = []
for session_digest in registration_sessions:
delivery = self.registration_delivery(session_digest)
if delivery is not None:
deliveries.append(delivery)
for session_digest in reset_sessions:
delivery = self.password_reset_delivery(session_digest)
if delivery is not None:
deliveries.append(delivery)
for order_id in order_ids:
delivery = self.order_mail_delivery(order_id)
if delivery is not None:
deliveries.append(delivery)
return deliveries
def mark_mail_delivery(
self,
kind: str,
email_id: int,
*,
claim_token: str,
sent: bool,
error_summary: str | None = None,
) -> bool:
"""Record SMTP outcome without accepting message bodies or credentials."""
if isinstance(email_id, bool) or not isinstance(email_id, int) or email_id <= 0:
raise ContractError("mail delivery id must be a positive integer")
if (
not isinstance(claim_token, str)
or not 20 <= len(claim_token) <= 128
or any(ord(character) < 33 or ord(character) > 126 for character in claim_token)
):
raise ContractError("mail delivery claim token is invalid")
safe_error = None
if not sent:
safe_error = (error_summary or "SMTPDeliveryError").strip()
if MAIL_ERROR_SUMMARY_PATTERN.fullmatch(safe_error) is None:
safe_error = "SMTPDeliveryError"
table, id_column = self._mail_delivery_target(kind)
completed_at = int(time.time())
status = MAIL_SMTP_SENT if sent else MAIL_SMTP_FAILED
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
shared = (
conn.execute(
"SELECT site_backend_mail_id,site_backend_claim_token "
"FROM email_outbox WHERE email_id=?",
(email_id,),
).fetchone()
if kind == "order-confirmation"
else None
)
cursor = conn.execute(
f"""
UPDATE {table}
SET status=?,is_simulation=0,claim_token=NULL,
last_error=?,sent_at=?
WHERE {id_column}=? AND status='SMTP_PENDING'
AND claim_token=?
""",
(
status,
safe_error,
completed_at if sent else None,
email_id,
claim_token,
),
)
if cursor.rowcount != 1:
conn.rollback()
return False
if (
shared is not None
and shared["site_backend_mail_id"]
and shared["site_backend_claim_token"]
):
if sent:
self.site_backend.mail.mark_sent(
str(shared["site_backend_mail_id"]),
claim_token=str(shared["site_backend_claim_token"]),
connection=conn,
)
else:
self.site_backend.mail.mark_failed(
str(shared["site_backend_mail_id"]),
category="network",
claim_token=str(shared["site_backend_claim_token"]),
connection=conn,
)
conn.execute(
"UPDATE email_outbox SET site_backend_claim_token=NULL "
"WHERE email_id=?",
(email_id,),
)
conn.commit()
return True
def mail_delivery_health(self) -> dict[str, int]:
counts = {status: 0 for status in sorted(MAIL_DELIVERY_STATUSES)}
with self.connect() as conn:
for table in (
"auth_registration_email_outbox",
"auth_password_reset_email_outbox",
"email_outbox",
):
for row in conn.execute(
f"SELECT status,COUNT(*) AS count FROM {table} GROUP BY status"
):
counts[str(row["status"])] += int(row["count"])
return counts
def mail_delivery_outbox(self) -> list[dict[str, Any]]:
"""Return an admin-safe combined view with recipients always masked."""
messages: list[dict[str, Any]] = []
for message in self.registration_outbox():
messages.append({"kind": "registration", **message})
for message in self.password_reset_outbox():
messages.append({"kind": "password-reset", **message})
for message in self.mail_outbox():
messages.append(
{
"kind": "order-confirmation",
"email_id": int(message["email_id"]),
"recipient_masked": self._masked_email(
str(message["recipient"])
),
"template": str(message["template"]),
"status": str(message["status"]),
"is_simulation": bool(message["is_simulation"]),
"delivery_attempts": int(message["delivery_attempts"]),
"last_error": message["last_error"],
"attempted_at": message["attempted_at"],
"sent_at": message["sent_at"],
"created_at": message["created_at"],
"order_id": int(message["order_id"]),
}
)
return sorted(messages, key=lambda message: (str(message["kind"]), int(message["email_id"])))
def register_account(
self,
session_digest: str,
email: str,
display_name: str,
password: str,
) -> bool:
"""Create an account and bind the existing anonymous browser session atomically."""
self.ensure_session(session_digest)
email_normalized = normalize_email(email)
salt, password_hash, scheme = password_record(password)
try:
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
cursor = conn.execute(
"""
INSERT INTO accounts(
email_normalized,display_name,password_salt,password_hash,
password_scheme,email_verified,created_at
) VALUES (?,?,?,?,?,?,?)
""",
(
email_normalized,
display_name,
salt,
password_hash,
scheme,
1,
self.now(conn),
),
)
account_id = int(cursor.lastrowid)
self._merge_anonymous_cart_into_account(
conn, session_digest, account_id
)
self._merge_anonymous_compare_into_account(
conn, session_digest, account_id
)
conn.execute(
"UPDATE browser_sessions SET account_id=? WHERE session_digest=?",
(account_id, session_digest),
)
conn.execute(
"DELETE FROM auth_signin_flows WHERE session_digest=?",
(session_digest,),
)
conn.execute(
"DELETE FROM auth_registration_flows WHERE session_digest=?",
(session_digest,),
)
conn.commit()
return True
except sqlite3.IntegrityError:
return False
def authenticate_session(
self, session_digest: str, password: str
) -> tuple[bool, str | None]:
"""Verify a pending sign-in without disclosing whether its account exists."""
self.ensure_session(session_digest)
with self.connect() as conn:
row = conn.execute(
"""
SELECT f.email_normalized,f.return_to,a.account_id,
a.password_salt,a.password_hash,a.password_scheme
FROM auth_signin_flows f
LEFT JOIN accounts a ON a.email_normalized=f.email_normalized
WHERE f.session_digest=?
""",
(session_digest,),
).fetchone()
salt = bytes(row["password_salt"]) if row and row["password_salt"] is not None else _DUMMY_SALT
expected_hash = (
bytes(row["password_hash"])
if row and row["password_hash"] is not None
else _DUMMY_HASH
)
scheme_ok = bool(row and row["password_scheme"] == PASSWORD_SCHEME)
password_ok = verify_password(password, salt, expected_hash)
if not row or row["account_id"] is None or not scheme_ok or not password_ok:
return False, None
account_id = int(row["account_id"])
return_to = row["return_to"]
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
current = conn.execute(
"""
SELECT a.account_id
FROM auth_signin_flows f
JOIN accounts a ON a.email_normalized=f.email_normalized
WHERE f.session_digest=?
""",
(session_digest,),
).fetchone()
if current is None or int(current["account_id"]) != account_id:
conn.rollback()
return False, None
self._merge_anonymous_cart_into_account(
conn, session_digest, account_id
)
self._merge_anonymous_compare_into_account(
conn, session_digest, account_id
)
conn.execute(
"UPDATE browser_sessions SET account_id=? WHERE session_digest=?",
(account_id, session_digest),
)
conn.execute(
"DELETE FROM auth_signin_flows WHERE session_digest=?",
(session_digest,),
)
conn.commit()
return True, str(return_to) if return_to else None
def account_for_session(self, session_digest: str) -> dict[str, Any] | None:
self.ensure_session(session_digest)
with self.connect() as conn:
row = conn.execute(
"""
SELECT a.account_id,a.email_normalized,a.display_name,a.created_at
FROM browser_sessions s
JOIN accounts a ON a.account_id=s.account_id
WHERE s.session_digest=?
""",
(session_digest,),
).fetchone()
return dict(row) if row else None
def delivery_country(self, session_digest: str) -> tuple[str, str]:
"""Return the (code, label) storefront delivery location for a browser.
Ownership is the browser session itself, so this read is deliberately
anonymous: signing in neither grants nor revokes the preference, and a
row that predates the column resolves to the frozen baseline.
"""
self.ensure_session(session_digest)
with self.connect() as conn:
row = conn.execute(
"SELECT delivery_country_code FROM browser_sessions WHERE session_digest=?",
(session_digest,),
).fetchone()
code = str((row["delivery_country_code"] if row else None) or "").upper()
if code not in SUPPORTED_DELIVERY_COUNTRY_CODES:
return DEFAULT_DELIVERY_COUNTRY
return code, DELIVERY_COUNTRY_LABELS[code]
def set_delivery_country(self, session_digest: str, country_code: str) -> bool:
"""Persist a storefront delivery location for this browser session.
Returns False for anything outside SUPPORTED_DELIVERY_COUNTRIES instead
of raising, so the handler answers a rejected choice with the same
redirect shape as an accepted one. Writing the same code twice is a
no-op, which keeps an exact retry stable.
"""
code = str(country_code or "").strip().upper()
if code not in SUPPORTED_DELIVERY_COUNTRY_CODES:
return False
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute(
"UPDATE browser_sessions SET delivery_country_code=? WHERE session_digest=?",
(code, session_digest),
)
return True
def reviews_for_session(
self,
session_digest: str,
asin: str,
*,
star: int | None = None,
sort: str = "recent",
) -> list[dict[str, Any]]:
"""Return local reviews without accepting a client-supplied identity."""
self.ensure_session(session_digest)
with self.connect() as conn:
return list_local_reviews(
conn,
asin,
star=star,
sort=sort,
viewer_session_digest=session_digest,
)
def register_review_product(self, asin: str, source_scope: str) -> str:
"""Register a product identity proven by a server-owned catalog."""
with self.connect() as conn:
normalized_asin = register_local_review_product(
conn, asin=asin, source_scope=source_scope
)
conn.commit()
return normalized_asin
def upsert_review(
self,
session_digest: str,
asin: str,
rating: int,
headline: str,
body: str,
) -> dict[str, Any]:
"""Create/update the account review resolved from ``session_digest``."""
self.ensure_session(session_digest)
with self.connect() as conn:
review = upsert_local_review(
conn,
session_digest=session_digest,
asin=asin,
rating=rating,
headline=headline,
body=body,
at=self.now(conn),
)
conn.commit()
return review
def toggle_review_helpful(
self, session_digest: str, asin: str, review_id: int | str
) -> dict[str, Any]:
"""Toggle the helpful identity resolved from ``session_digest``."""
self.ensure_session(session_digest)
with self.connect() as conn:
review_row = conn.execute(
"SELECT 1 FROM product_reviews WHERE review_id=? AND asin=?",
(review_id, asin),
).fetchone()
if review_row is None:
raise ReviewNotFound("review does not belong to this product")
result = toggle_local_review_helpful(
conn,
session_digest=session_digest,
review_id=review_id,
at=self.now(conn),
)
conn.commit()
return result
def rotate_authenticated_session(
self, old_session_digest: str, new_session_digest: str
) -> None:
"""Move authenticated state and the active cart onto a fresh browser session.
Navigation history stays attached to the anonymous session that produced it,
while account access and cart contents are removed from the old identifier.
"""
if old_session_digest == new_session_digest:
raise ContractError("session rotation requires a fresh identifier")
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
old_session = conn.execute(
"""
SELECT reset_epoch,account_id
FROM browser_sessions
WHERE session_digest=?
""",
(old_session_digest,),
).fetchone()
if old_session is None or old_session["account_id"] is None:
conn.rollback()
raise ContractError("only authenticated sessions can be rotated")
if conn.execute(
"SELECT 1 FROM browser_sessions WHERE session_digest=?",
(new_session_digest,),
).fetchone():
conn.rollback()
raise ContractError("fresh session identifier already exists")
account_id = int(old_session["account_id"])
# A legacy or concurrently prepared guest line must not be stranded
# when the raw session cookie rotates after authentication.
self._merge_anonymous_cart_into_account(
conn, old_session_digest, account_id
)
self._merge_anonymous_compare_into_account(
conn, old_session_digest, account_id
)
now = self.now(conn)
conn.execute(
"""
INSERT INTO browser_sessions(
session_digest,reset_epoch,created_at,account_id
) VALUES (?,?,?,?)
""",
(
new_session_digest,
int(old_session["reset_epoch"]),
now,
account_id,
),
)
conn.execute(
"INSERT INTO carts(session_digest,created_at) VALUES (?,?)",
(new_session_digest, now),
)
conn.execute(
"UPDATE pending_buy_now SET session_digest=? WHERE session_digest=?",
(new_session_digest, old_session_digest),
)
# Helpful votes cast before sign-in belong to the same person as
# the authenticated account after rotation. Remove votes that
# would become self-votes, migrate the remaining guest identity,
# then discard rows ignored because the account had already voted
# for the same review in another session.
conn.execute(
"""
DELETE FROM review_helpful_votes
WHERE voter_account_id IS NULL
AND voter_session_digest=?
AND EXISTS (
SELECT 1
FROM product_reviews r
WHERE r.review_id=review_helpful_votes.review_id
AND r.account_id=?
)
""",
(old_session_digest, account_id),
)
conn.execute(
"""
UPDATE OR IGNORE review_helpful_votes
SET voter_account_id=?, voter_session_digest=NULL
WHERE voter_account_id IS NULL AND voter_session_digest=?
""",
(account_id, old_session_digest),
)
conn.execute(
"""
DELETE FROM review_helpful_votes
WHERE voter_account_id IS NULL AND voter_session_digest=?
""",
(old_session_digest,),
)
conn.execute(
"UPDATE browser_sessions SET account_id=NULL WHERE session_digest=?",
(old_session_digest,),
)
conn.execute(
"DELETE FROM auth_signin_flows WHERE session_digest=?",
(old_session_digest,),
)
conn.execute(
"DELETE FROM auth_registration_flows WHERE session_digest=?",
(old_session_digest,),
)
conn.commit()
def sign_out(self, session_digest: str) -> None:
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
conn.execute(
"UPDATE browser_sessions SET account_id=NULL WHERE session_digest=?",
(session_digest,),
)
conn.execute(
"DELETE FROM auth_signin_flows WHERE session_digest=?",
(session_digest,),
)
conn.execute(
"DELETE FROM auth_registration_flows WHERE session_digest=?",
(session_digest,),
)
conn.commit()
def compare_eligible_asins(self) -> frozenset[str]:
"""Return purchasable products with source-backed comparison taxonomy."""
with self.connect() as conn:
offer_asins = {
str(row["asin"])
for row in conn.execute("SELECT asin FROM commerce_offers")
}
return frozenset(offer_asins.intersection(self._compare_profiles))
def compare_profile(self, asin: str) -> dict[str, Any] | None:
profile = self._compare_profiles.get(asin)
if profile is None:
return None
with self.connect() as conn:
if conn.execute(
"SELECT 1 FROM commerce_offers WHERE asin=?", (asin,)
).fetchone() is None:
return None
return {
**profile,
"specs": dict(profile.get("specs") or {}),
}
def _compare_owner(
self, conn: sqlite3.Connection, session_digest: str
) -> tuple[str, str, str | int]:
account_id = self._account_id_for_session(conn, session_digest)
if account_id is not None:
return "account_compare_items", "account_id", account_id
return "compare_items", "session_digest", session_digest
@staticmethod
def _require_compare_line_id(value: str) -> str:
if (
not isinstance(value, str)
or COMPARE_LINE_ID_PATTERN.fullmatch(value) is None
):
raise ContractError("compare line identity is invalid")
return value
def _unused_compare_line_id(self, conn: sqlite3.Connection) -> str:
while True:
candidate = self._new_compare_line_id()
exists = conn.execute(
"""
SELECT 1 FROM compare_items WHERE compare_line_id=?
UNION ALL
SELECT 1 FROM account_compare_items WHERE compare_line_id=?
LIMIT 1
""",
(candidate, candidate),
).fetchone()
if exists is None:
return candidate
def compare_items(self, session_digest: str) -> list[dict[str, Any]]:
"""Resolve each stored selection against the current server quote."""
self.ensure_session(session_digest)
with self.connect() as conn:
table, owner_column, owner_id = self._compare_owner(
conn, session_digest
)
rows = conn.execute(
f"""
SELECT offer.*,line.compare_line_id,line.selection_json,
line.selection_key,line.position,line.created_at
FROM {table} AS line
JOIN commerce_offers AS offer ON offer.asin=line.asin
WHERE line.{owner_column}=?
ORDER BY line.position
""",
(owner_id,),
).fetchall()
items: list[dict[str, Any]] = []
for row in rows:
item = dict(row)
asin = str(item["asin"])
selected_options = self._stored_product_options(
asin, item.pop("selection_json", "{}")
)
self._apply_transaction_quote(item, selected_options)
profile = self._compare_profiles.get(asin)
if profile is not None:
# Search-card captures preserve abbreviated aggregate copy
# such as ``19.7K`` without inventing an exact integer. In
# that evidence class the legacy zero is only a database
# sentinel, never a customer-facing review count.
if item.get("evidence_class") == "direct-search-card":
reviews_display = profile.get("reviews_display")
item["reviews"] = (
reviews_display
if isinstance(reviews_display, str)
and reviews_display
else None
)
item["compare"] = {
"category": str(profile["category_label"]),
"category_key": str(profile["category_key"]),
"family": str(profile["family_label"]),
"family_key": str(profile["family_key"]),
"selected_options": dict(item["selected_options"]),
"specs": dict(profile.get("specs") or {}),
}
item["availability"] = str(item["display_availability"])
items.append(item)
return items
def compare_asins(self, session_digest: str) -> list[str]:
"""Compatibility projection for callers that only need column ASINs."""
return [str(item["asin"]) for item in self.compare_items(session_digest)]
def add_compare(
self,
session_digest: str,
asin: str,
selected_options: Mapping[str, Any] | None = None,
) -> str:
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
profile = self._compare_profiles.get(asin)
offer_row = conn.execute(
"SELECT * FROM commerce_offers WHERE asin=?", (asin,)
).fetchone()
if profile is None or offer_row is None:
conn.rollback()
raise ContractError("product is not eligible for comparison")
quote = self._transaction_quote(
asin, selected_options, dict(offer_row)
)
selection_json = json.dumps(
quote["selected_options"],
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
)
selection_key = str(quote["selection_key"])
table, owner_column, owner_id = self._compare_owner(
conn, session_digest
)
rows = conn.execute(
f"""
SELECT asin,selection_key FROM {table}
WHERE {owner_column}=?
ORDER BY position
""",
(owner_id,),
).fetchall()
if any(
str(row["asin"]) == asin
and str(row["selection_key"]) == selection_key
for row in rows
):
conn.commit()
return "duplicate"
current_families = {
str(existing_profile["family_key"])
for row in rows
if (
existing_profile := self._compare_profiles.get(
str(row["asin"])
)
)
is not None
}
if any(str(row["asin"]) not in self._compare_profiles for row in rows):
conn.commit()
return "incompatible"
if current_families and current_families != {str(profile["family_key"])}:
conn.commit()
return "incompatible"
if len(rows) >= COMPARE_LIMIT:
conn.commit()
return "full"
conn.execute(
f"""
INSERT INTO {table}(
compare_line_id,{owner_column},asin,selection_json,
selection_key,position,created_at
) VALUES (?,?,?,?,?,?,?)
""",
(
self._unused_compare_line_id(conn),
owner_id,
asin,
selection_json,
selection_key,
len(rows) + 1,
self.now(conn),
),
)
conn.commit()
return "added"
def remove_compare(self, session_digest: str, compare_line_id: str) -> bool:
normalized_line_id = self._require_compare_line_id(compare_line_id)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
table, owner_column, owner_id = self._compare_owner(
conn, session_digest
)
rows = conn.execute(
f"""
SELECT compare_line_id,asin,selection_json,selection_key,created_at
FROM {table}
WHERE {owner_column}=?
ORDER BY position
""",
(owner_id,),
).fetchall()
if not any(
str(row["compare_line_id"]) == normalized_line_id for row in rows
):
conn.commit()
return False
remaining = [
row
for row in rows
if str(row["compare_line_id"]) != normalized_line_id
]
conn.execute(
f"DELETE FROM {table} WHERE {owner_column}=?", (owner_id,)
)
conn.executemany(
f"""
INSERT INTO {table}(
compare_line_id,{owner_column},asin,selection_json,
selection_key,position,created_at
) VALUES (?,?,?,?,?,?,?)
""",
[
(
row["compare_line_id"],
owner_id,
row["asin"],
row["selection_json"],
row["selection_key"],
position,
row["created_at"],
)
for position, row in enumerate(remaining, start=1)
],
)
conn.commit()
return True
def clear_compare(self, session_digest: str) -> None:
self.ensure_session(session_digest)
with self.connect() as conn:
table, owner_column, owner_id = self._compare_owner(
conn, session_digest
)
conn.execute(
f"DELETE FROM {table} WHERE {owner_column}=?", (owner_id,)
)
@staticmethod
def _quantity(value: int | str) -> int:
if isinstance(value, bool):
raise ContractError("cart quantity must be an integer from 1 to 30")
if isinstance(value, int):
quantity = value
elif isinstance(value, str) and value and value.isascii() and value.isdecimal():
quantity = int(value)
if str(quantity) != value:
raise ContractError("cart quantity must use canonical decimal form")
else:
raise ContractError("cart quantity must be an integer from 1 to 30")
if quantity < 1 or quantity > 30:
raise ContractError("cart quantity must be between 1 and 30")
return quantity
def _cart_line_owner(
self, conn: sqlite3.Connection, session_digest: str
) -> tuple[str, str, int]:
account_id = self._account_id_for_session(conn, session_digest)
if account_id is not None:
return "account_cart_lines", "account_id", account_id
return "cart_lines", "cart_id", self._session_cart_id(conn, session_digest)
@staticmethod
def _require_cart_not_payment_locked(
conn: sqlite3.Connection, table: str, owner_id: int
) -> None:
if table != "account_cart_lines":
return
if conn.execute(
"""
SELECT 1 FROM checkout_sessions
WHERE account_id=? AND status='PAYMENT_PENDING'
LIMIT 1
""",
(owner_id,),
).fetchone():
raise CheckoutPaymentLocked(
"the cart is locked while Stripe test payment is pending"
)
@staticmethod
def _require_cart_line_id(value: str) -> str:
if not isinstance(value, str) or CART_LINE_ID_PATTERN.fullmatch(value) is None:
raise ContractError("cart line identity is invalid")
return value
def commerce_offer(self, asin: str) -> dict[str, Any] | None:
with self.connect() as conn:
row = conn.execute(
"SELECT * FROM commerce_offers WHERE asin=?", (asin,)
).fetchone()
return dict(row) if row else None
@staticmethod
def _display_product_payload(
display_row: sqlite3.Row, offer_row: sqlite3.Row
) -> dict[str, Any]:
try:
product = json.loads(str(display_row["payload_json"]))
except (TypeError, json.JSONDecodeError) as exc:
raise ContractError("product display catalog payload is corrupted") from exc
if not isinstance(product, dict):
raise ContractError("product display catalog payload must be an object")
# Transaction identity and quote fields always come from commerce_offers,
# never from the presentation JSON.
offer = dict(offer_row)
# commerce_offers owns transaction identity, selection and quote values.
# Public title, brand and review facts belong to the display payload;
# reapplying older source-card copy here would erase newer live-PDP
# evidence selected by build_product_display_catalog().
for key in (
"asin",
"slug",
"canonical_path",
"capacity",
"color",
"price_minor",
"list_price_minor",
"currency",
"image_path",
"badge",
"evidence_class",
"source",
):
product[key] = offer[key]
product["source_index"] = int(display_row["source_index"])
product["display_provenance"] = str(display_row["provenance"])
return product
def display_products(self) -> list[dict[str, Any]]:
with self.connect() as conn:
rows = conn.execute(
"""
SELECT d.asin,d.source_index,d.provenance,d.payload_json
FROM product_display_catalog AS d
ORDER BY d.source_index,d.asin
"""
).fetchall()
offers = {
str(row["asin"]): row
for row in conn.execute("SELECT * FROM commerce_offers").fetchall()
}
return [
self._display_product_payload(row, offers[str(row["asin"])])
for row in rows
]
def display_product(self, asin: str) -> dict[str, Any] | None:
with self.connect() as conn:
display_row = conn.execute(
"SELECT * FROM product_display_catalog WHERE asin=?", (asin,)
).fetchone()
if display_row is None:
return None
offer_row = conn.execute(
"SELECT * FROM commerce_offers WHERE asin=?", (asin,)
).fetchone()
if offer_row is None:
raise ContractError("display product has no transaction offer")
return self._display_product_payload(display_row, offer_row)
def product_recommendations(self, asin: str) -> list[dict[str, Any]]:
product = self.display_product(asin)
if product is None:
return []
raw_asins = product.get("recommendation_asins")
if not isinstance(raw_asins, list):
raw_asins = []
related: list[dict[str, Any]] = []
seen: set[str] = {asin}
for raw_asin in raw_asins:
related_asin = str(raw_asin)
if related_asin in seen:
continue
recommendation = self.display_product(related_asin)
if recommendation is not None:
related.append(recommendation)
seen.add(related_asin)
if len(related) == 6:
break
if len(related) < 6:
# Not every retained source record exposed a recommendation rail.
# Complete the bounded UI relation deterministically from products
# in the same page category, then from stable catalogue order. The
# display records keep their own provenance; no source membership
# claim is added to the public page.
detail = product.get("pdp")
page_category = (
str(detail.get("page_category") or "")
if isinstance(detail, Mapping)
else ""
)
candidates = self.display_products()
candidates.sort(
key=lambda candidate: (
0
if page_category
and isinstance(candidate.get("pdp"), Mapping)
and str(candidate["pdp"].get("page_category") or "")
== page_category
else 1,
str(candidate["asin"]),
)
)
for recommendation in candidates:
related_asin = str(recommendation["asin"])
if related_asin in seen:
continue
related.append(recommendation)
seen.add(related_asin)
if len(related) == 6:
break
return related
def product_display_summary(self) -> dict[str, Any]:
return display_catalog_summary(self.display_products())
def product_option_spec(self, asin: str) -> tuple[dict[str, Any], ...]:
"""Return a detached copy of the captured option allow-list for one ASIN."""
return tuple(
{
"label": str(group["label"]),
"default": str(group["default"]),
"options": tuple(str(value) for value in group["options"]),
}
for group in self._option_specs.get(asin, ())
)
def default_product_options(self, asin: str) -> dict[str, str]:
return default_selection(self._option_specs.get(asin))
def _complete_product_options(
self, asin: str, selected_options: Mapping[str, Any] | None
) -> dict[str, str]:
"""Normalize a new request while distinguishing omitted and empty maps."""
try:
return normalize_complete_selection(
self._option_specs.get(asin), selected_options
)
except ValueError as exc:
raise ContractError(str(exc)) from exc
def _transaction_quote(
self,
asin: str,
selected_options: Mapping[str, Any] | None,
base_offer: Mapping[str, Any],
) -> dict[str, Any]:
try:
quote = resolve_transaction_quote(
asin,
selected_options,
option_specs=self._option_specs,
quote_specs=self._option_quote_specs,
base_offer=base_offer,
)
except ValueError as exc:
raise ContractError(str(exc)) from exc
if quote is None:
raise ContractError(UNAVAILABLE_SELECTION_COPY)
return quote
def product_option_quotes(self, asin: str) -> list[dict[str, Any]]:
"""Return the server-resolved quote matrix safe to embed in one PDP."""
offer = self.commerce_offer(asin)
if offer is None:
return []
rules = self._option_quote_specs.get(asin, ())
quotes: list[dict[str, Any]] = []
for rule in rules:
selected_options = rule.get("selected_options")
if not isinstance(selected_options, Mapping):
raise ContractError("product option quote evidence is corrupted")
quotes.append(self._transaction_quote(asin, selected_options, offer))
return quotes
@staticmethod
def _selection_payload(raw_value: Any) -> dict[str, str]:
try:
payload = json.loads(str(raw_value or "{}"))
except json.JSONDecodeError as exc:
raise ContractError("cart option selection is corrupted") from exc
if not isinstance(payload, dict) or any(
not isinstance(label, str) or not isinstance(value, str)
for label, value in payload.items()
):
raise ContractError("cart option selection is corrupted")
return payload
def _stored_product_options(self, asin: str, raw_value: Any) -> dict[str, str]:
"""Read a stored selection, backfilling only legacy empty option maps."""
payload = self._selection_payload(raw_value)
if not payload and self._option_specs.get(asin):
return self.default_product_options(asin)
return self._complete_product_options(asin, payload)
def _apply_transaction_quote(
self, payload: dict[str, Any], selected_options: Mapping[str, Any]
) -> dict[str, Any]:
"""Overlay a server quote on a commerce-offer/cart payload in place."""
asin = str(payload.get("asin") or "")
quote = self._transaction_quote(asin, selected_options, payload)
payload["selected_options"] = dict(quote["selected_options"])
payload["price_minor"] = int(quote["price_minor"])
payload["currency"] = str(quote["currency"])
payload["image_path"] = str(quote["image_path"])
payload["display_availability"] = str(quote["display_availability"])
payload["transaction_target"] = dict(quote["transaction_target"])
payload["selection_key"] = str(quote["selection_key"])
payload["transaction_quote"] = quote
return payload
def _cart_lines(
self, session_digest: str, line_state: str
) -> list[dict[str, Any]]:
if line_state not in _CART_STATES:
raise ContractError("invalid cart line state")
self.ensure_session(session_digest)
with self.connect() as conn:
table, owner_column, owner_id = self._cart_line_owner(
conn, session_digest
)
rows = conn.execute(
f"""
SELECT offer.*,line.line_id,line.quantity,line.selection_json,
line.selection_key,line.line_state
FROM {table} AS line
JOIN commerce_offers AS offer ON offer.asin=line.asin
WHERE line.{owner_column}=? AND line.line_state=?
ORDER BY offer.asin,line.selection_key,line.line_id
""",
(owner_id, line_state),
).fetchall()
lines: list[dict[str, Any]] = []
for row in rows:
line = dict(row)
selected_options = self._stored_product_options(
str(line["asin"]), line.pop("selection_json", "{}")
)
lines.append(self._apply_transaction_quote(line, selected_options))
return lines
def cart(self, session_digest: str) -> list[dict[str, Any]]:
return self._cart_lines(session_digest, ACTIVE_CART_STATE)
def saved_cart(self, session_digest: str) -> list[dict[str, Any]]:
return self._cart_lines(session_digest, SAVED_CART_STATE)
def cart_count(self, session_digest: str) -> int:
return sum(int(line["quantity"]) for line in self.cart(session_digest))
def add_cart_item(
self,
session_digest: str,
asin: str,
quantity: int | str,
selected_options: Mapping[str, Any] | None = None,
) -> int:
requested = self._quantity(quantity)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
offer_row = conn.execute(
"SELECT * FROM commerce_offers WHERE asin=?", (asin,)
).fetchone()
if offer_row is None:
conn.rollback()
raise ContractError("product does not have a current commerce offer")
quote = self._transaction_quote(asin, selected_options, dict(offer_row))
selection_json = json.dumps(
quote["selected_options"],
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
)
selection_key = str(quote["selection_key"])
table, owner_column, owner_id = self._cart_line_owner(
conn, session_digest
)
self._require_cart_not_payment_locked(conn, table, owner_id)
existing = conn.execute(
f"SELECT line_id,quantity FROM {table} "
f"WHERE {owner_column}=? AND asin=? AND selection_key=?",
(owner_id, asin, selection_key),
).fetchone()
resulting_quantity = (
min(30, int(existing["quantity"]) + requested)
if existing
else requested
)
if existing:
conn.execute(
f"""
UPDATE {table}
SET quantity=?,line_state='ACTIVE'
WHERE {owner_column}=? AND line_id=?
""",
(resulting_quantity, owner_id, str(existing["line_id"])),
)
else:
conn.execute(
f"""
INSERT INTO {table}(
line_id,{owner_column},asin,quantity,selection_json,
selection_key,line_state
) VALUES (?,?,?,?,?,?,'ACTIVE')
""",
(
self._new_cart_line_id(),
owner_id,
asin,
resulting_quantity,
selection_json,
selection_key,
),
)
conn.commit()
return resulting_quantity
def set_cart_quantity(
self, session_digest: str, line_id: str, quantity: int | str
) -> bool:
normalized_line_id = self._require_cart_line_id(line_id)
normalized_quantity = self._quantity(quantity)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
table, owner_column, owner_id = self._cart_line_owner(
conn, session_digest
)
self._require_cart_not_payment_locked(conn, table, owner_id)
cursor = conn.execute(
f"""
UPDATE {table} SET quantity=?
WHERE {owner_column}=? AND line_id=? AND line_state='ACTIVE'
""",
(normalized_quantity, owner_id, normalized_line_id),
)
conn.commit()
return cursor.rowcount == 1
@staticmethod
def _cancel_empty_cart_checkout(
conn: sqlite3.Connection, table: str, owner_id: int
) -> None:
"""Release checkout-owned state when an account cart has no active lines."""
if table != "account_cart_lines":
return
has_active_line = conn.execute(
"""
SELECT 1 FROM account_cart_lines
WHERE account_id=? AND line_state='ACTIVE' LIMIT 1
""",
(owner_id,),
).fetchone()
if has_active_line is None:
# A Buy Now checkout owns checkout_lines and must remain independent
# from ordinary cart edits. An empty CART checkout, however, can no
# longer advance and must release its selected address/payment state.
conn.execute(
"""
DELETE FROM checkout_sessions
WHERE account_id=? AND checkout_mode='CART' AND status<>'PLACED'
""",
(owner_id,),
)
def delete_cart_item(self, session_digest: str, line_id: str) -> bool:
normalized_line_id = self._require_cart_line_id(line_id)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
table, owner_column, owner_id = self._cart_line_owner(
conn, session_digest
)
self._require_cart_not_payment_locked(conn, table, owner_id)
cursor = conn.execute(
f"DELETE FROM {table} WHERE {owner_column}=? AND line_id=?",
(owner_id, normalized_line_id),
)
self._cancel_empty_cart_checkout(conn, table, owner_id)
conn.commit()
return cursor.rowcount == 1
def save_for_later(self, session_digest: str, line_id: str) -> bool:
normalized_line_id = self._require_cart_line_id(line_id)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
table, owner_column, owner_id = self._cart_line_owner(
conn, session_digest
)
self._require_cart_not_payment_locked(conn, table, owner_id)
cursor = conn.execute(
f"""
UPDATE {table} SET line_state='SAVED'
WHERE {owner_column}=? AND line_id=? AND line_state='ACTIVE'
""",
(owner_id, normalized_line_id),
)
self._cancel_empty_cart_checkout(conn, table, owner_id)
conn.commit()
return cursor.rowcount == 1
def move_to_cart(self, session_digest: str, line_id: str) -> bool:
normalized_line_id = self._require_cart_line_id(line_id)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
table, owner_column, owner_id = self._cart_line_owner(
conn, session_digest
)
self._require_cart_not_payment_locked(conn, table, owner_id)
cursor = conn.execute(
f"""
UPDATE {table} SET line_state='ACTIVE'
WHERE {owner_column}=? AND line_id=? AND line_state='SAVED'
""",
(owner_id, normalized_line_id),
)
conn.commit()
return cursor.rowcount == 1
@staticmethod
def _require_account_id(
conn: sqlite3.Connection, session_digest: str
) -> int:
account_id = Store._account_id_for_session(conn, session_digest)
if account_id is None:
raise ContractError("checkout requires a signed-in account")
return account_id
@staticmethod
def _validated_address_fields(fields: dict[str, Any]) -> dict[str, str]:
if not isinstance(fields, dict):
raise ContractError("delivery address fields must be an object")
limits = {
"full_name": (128, True),
"address_line1": (200, True),
"address_line2": (200, False),
"city": (100, True),
"state_region": (100, True),
"postal_code": (32, True),
"country_code": (2, True),
"phone": (32, False),
}
unknown = set(fields) - set(limits)
if unknown:
raise ContractError(f"unsupported delivery address fields: {sorted(unknown)}")
normalized: dict[str, str] = {}
for name, (limit, required) in limits.items():
value = fields.get(name, "")
if not isinstance(value, str):
raise ContractError(f"delivery address field {name} must be text")
value = value.strip()
if required and not value:
raise ContractError(f"delivery address field {name} is required")
if len(value) > limit or any(
ord(character) < 32 or ord(character) == 127 for character in value
):
raise ContractError(f"delivery address field {name} is invalid")
normalized[name] = value
country_code = normalized["country_code"].upper()
if country_code not in SUPPORTED_DELIVERY_COUNTRY_CODES:
raise ContractError("delivery country is not supported")
normalized["country_code"] = country_code
return normalized
@staticmethod
def _require_supported_delivery_address(
address: Mapping[str, Any] | None,
) -> Mapping[str, Any]:
if address is None:
raise ContractError("checkout delivery address is unavailable")
country_code = str(address.get("country_code") or "").upper()
if country_code not in SUPPORTED_DELIVERY_COUNTRY_CODES:
raise ContractError("checkout delivery country is not supported")
return address
@staticmethod
def _normalized_address_number(value: int | str) -> int | None:
if isinstance(value, bool):
return None
if isinstance(value, int):
return value if 0 < value <= SQLITE_INTEGER_MAX else None
if (
isinstance(value, str)
and 0 < len(value) <= 19
and value.isascii()
and value.isdecimal()
):
try:
normalized = int(value)
except ValueError:
return None
return (
normalized
if str(normalized) == value
and 0 < normalized <= SQLITE_INTEGER_MAX
else None
)
return None
@staticmethod
def _address_row_payload(row: sqlite3.Row) -> dict[str, Any]:
return {
"address_id": int(row["address_id"]),
"full_name": str(row["full_name"]),
"address_line1": str(row["address_line1"]),
"address_line2": str(row["address_line2"]),
"city": str(row["city"]),
"state_region": str(row["state_region"]),
"postal_code": str(row["postal_code"]),
"country_code": str(row["country_code"]),
"phone": str(row["phone"]),
"is_default": bool(row["is_default"]),
"revision": int(row["revision"]),
"created_at": str(row["created_at"]),
"updated_at": str(row["updated_at"]),
}
@staticmethod
def _active_address_rows(
conn: sqlite3.Connection, account_id: int
) -> list[sqlite3.Row]:
return conn.execute(
"""
SELECT address_id,full_name,address_line1,address_line2,city,
state_region,postal_code,country_code,phone,is_default,
revision,created_at,updated_at
FROM addresses
WHERE account_id=? AND is_archived=0
ORDER BY is_default DESC,address_id
""",
(account_id,),
).fetchall()
def addresses_for_session(self, session_digest: str) -> list[dict[str, Any]]:
self.ensure_session(session_digest)
with self.connect() as conn:
account_id = self._require_account_id(conn, session_digest)
return [
self._address_row_payload(row)
for row in self._active_address_rows(conn, account_id)
]
def address_for_session(
self, session_digest: str, address_id: int | str
) -> dict[str, Any] | None:
normalized_id = self._normalized_address_number(address_id)
if normalized_id is None:
return None
self.ensure_session(session_digest)
with self.connect() as conn:
account_id = self._require_account_id(conn, session_digest)
row = conn.execute(
"""
SELECT address_id,full_name,address_line1,address_line2,city,
state_region,postal_code,country_code,phone,is_default,
revision,created_at,updated_at
FROM addresses
WHERE address_id=? AND account_id=? AND is_archived=0
""",
(normalized_id, account_id),
).fetchone()
return self._address_row_payload(row) if row else None
@staticmethod
def _validate_make_default(value: bool) -> bool:
if not isinstance(value, bool):
raise ContractError("make_default must be a boolean")
return value
def _insert_account_address(
self,
conn: sqlite3.Connection,
account_id: int,
address: dict[str, str],
*,
make_default: bool,
) -> sqlite3.Row:
now = self.now(conn)
has_active = bool(
conn.execute(
"SELECT 1 FROM addresses WHERE account_id=? AND is_archived=0 LIMIT 1",
(account_id,),
).fetchone()
)
should_default = make_default or not has_active
if should_default:
conn.execute(
"""
UPDATE addresses SET is_default=0,revision=revision+1,updated_at=?
WHERE account_id=? AND is_archived=0 AND is_default=1
""",
(now, account_id),
)
cursor = conn.execute(
"""
INSERT INTO addresses(
account_id,full_name,address_line1,address_line2,city,
state_region,postal_code,country_code,phone,is_default,
is_archived,revision,created_at,updated_at
) VALUES (
:account_id,:full_name,:address_line1,:address_line2,:city,
:state_region,:postal_code,:country_code,:phone,:is_default,
0,1,:created_at,:updated_at
)
""",
{
**address,
"account_id": account_id,
"is_default": 1 if should_default else 0,
"created_at": now,
"updated_at": now,
},
)
row = conn.execute(
"""
SELECT address_id,full_name,address_line1,address_line2,city,
state_region,postal_code,country_code,phone,is_default,
revision,created_at,updated_at
FROM addresses WHERE address_id=?
""",
(int(cursor.lastrowid),),
).fetchone()
assert row is not None
return row
def create_address(
self,
session_digest: str,
fields: dict[str, Any],
*,
make_default: bool = False,
) -> dict[str, Any]:
address = self._validated_address_fields(fields)
make_default = self._validate_make_default(make_default)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
row = self._insert_account_address(
conn, account_id, address, make_default=make_default
)
payload = self._address_row_payload(row)
conn.commit()
return payload
def _owned_active_address(
self, conn: sqlite3.Connection, account_id: int, address_id: int
) -> sqlite3.Row:
row = conn.execute(
"SELECT * FROM addresses WHERE address_id=? AND account_id=? AND is_archived=0",
(address_id, account_id),
).fetchone()
if row is None:
raise AddressNotFound("address is unavailable")
return row
@staticmethod
def _require_address_revision(row: sqlite3.Row, revision: int) -> None:
if int(row["revision"]) != revision:
raise AddressRevisionConflict("address was changed in another request")
def _invalidate_checkout_after_address_edit(
self,
conn: sqlite3.Connection,
account_id: int,
address_id: int,
now: str,
) -> None:
checkout = conn.execute(
"""
SELECT checkout_id FROM checkout_sessions
WHERE account_id=? AND address_id=? AND status<>'PLACED'
""",
(account_id, address_id),
).fetchone()
if checkout is None:
return
checkout_id = int(checkout["checkout_id"])
status = conn.execute(
"SELECT status FROM checkout_sessions WHERE checkout_id=?",
(checkout_id,),
).fetchone()
if status is not None and status["status"] == "PAYMENT_PENDING":
raise CheckoutPaymentLocked(
"the selected address is locked while Stripe test payment is pending"
)
self._supersede_checkout_payments(conn, checkout_id)
conn.execute(
"""
UPDATE checkout_sessions SET
status='ADDRESS_SELECTED',delivery_method=NULL,
shipping_minor=NULL,updated_at=?
WHERE checkout_id=?
""",
(now, checkout_id),
)
def update_address(
self,
session_digest: str,
address_id: int | str,
revision: int | str,
fields: dict[str, Any],
*,
make_default: bool = False,
) -> dict[str, Any]:
normalized_id = self._normalized_address_number(address_id)
normalized_revision = self._normalized_address_number(revision)
if normalized_id is None:
raise AddressNotFound("address is unavailable")
if normalized_revision is None:
raise AddressRevisionConflict("address revision is invalid")
address = self._validated_address_fields(fields)
make_default = self._validate_make_default(make_default)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
current = self._owned_active_address(conn, account_id, normalized_id)
self._require_address_revision(current, normalized_revision)
now = self.now(conn)
conn.execute(
"""
UPDATE addresses SET
full_name=:full_name,address_line1=:address_line1,
address_line2=:address_line2,city=:city,
state_region=:state_region,postal_code=:postal_code,
country_code=:country_code,phone=:phone,
revision=revision+1,updated_at=:updated_at
WHERE address_id=:address_id AND account_id=:account_id
AND is_archived=0 AND revision=:revision
""",
{
**address,
"address_id": normalized_id,
"account_id": account_id,
"revision": normalized_revision,
"updated_at": now,
},
)
if make_default and not bool(current["is_default"]):
conn.execute(
"""
UPDATE addresses SET is_default=0,revision=revision+1,updated_at=?
WHERE account_id=? AND is_archived=0 AND is_default=1
""",
(now, account_id),
)
conn.execute(
"UPDATE addresses SET is_default=1 WHERE address_id=?",
(normalized_id,),
)
self._invalidate_checkout_after_address_edit(
conn, account_id, normalized_id, now
)
updated = self._owned_active_address(conn, account_id, normalized_id)
payload = self._address_row_payload(updated)
conn.commit()
return payload
def set_default_address(
self,
session_digest: str,
address_id: int | str,
revision: int | str,
) -> dict[str, Any]:
normalized_id = self._normalized_address_number(address_id)
normalized_revision = self._normalized_address_number(revision)
if normalized_id is None:
raise AddressNotFound("address is unavailable")
if normalized_revision is None:
raise AddressRevisionConflict("address revision is invalid")
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
target = self._owned_active_address(conn, account_id, normalized_id)
self._require_address_revision(target, normalized_revision)
if not bool(target["is_default"]):
now = self.now(conn)
conn.execute(
"""
UPDATE addresses SET is_default=0,revision=revision+1,updated_at=?
WHERE account_id=? AND is_archived=0 AND is_default=1
""",
(now, account_id),
)
conn.execute(
"""
UPDATE addresses SET is_default=1,revision=revision+1,updated_at=?
WHERE address_id=? AND account_id=? AND is_archived=0
""",
(now, normalized_id, account_id),
)
updated = self._owned_active_address(conn, account_id, normalized_id)
payload = self._address_row_payload(updated)
conn.commit()
return payload
def delete_address(
self,
session_digest: str,
address_id: int | str,
revision: int | str,
) -> None:
normalized_id = self._normalized_address_number(address_id)
normalized_revision = self._normalized_address_number(revision)
if normalized_id is None:
raise AddressNotFound("address is unavailable")
if normalized_revision is None:
raise AddressRevisionConflict("address revision is invalid")
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
target = self._owned_active_address(conn, account_id, normalized_id)
self._require_address_revision(target, normalized_revision)
if conn.execute(
"""
SELECT 1 FROM checkout_sessions
WHERE account_id=? AND address_id=? AND status<>'PLACED'
""",
(account_id, normalized_id),
).fetchone():
raise AddressInUse("address is selected by an active checkout")
now = self.now(conn)
conn.execute(
"""
UPDATE addresses SET is_default=0,is_archived=1,
revision=revision+1,updated_at=?
WHERE address_id=? AND account_id=? AND is_archived=0
""",
(now, normalized_id, account_id),
)
if bool(target["is_default"]):
replacement = conn.execute(
"""
SELECT address_id FROM addresses
WHERE account_id=? AND is_archived=0
ORDER BY address_id LIMIT 1
""",
(account_id,),
).fetchone()
if replacement is not None:
conn.execute(
"""
UPDATE addresses SET is_default=1,revision=revision+1,updated_at=?
WHERE address_id=?
""",
(now, int(replacement["address_id"])),
)
conn.commit()
def _account_cart_snapshot(
self, conn: sqlite3.Connection, account_id: int
) -> tuple[list[dict[str, Any]], int, str, str]:
rows = conn.execute(
"""
SELECT offer.*,line.line_id,line.quantity,line.selection_json,
line.selection_key
FROM account_cart_lines AS line
JOIN commerce_offers AS offer ON offer.asin=line.asin
WHERE line.account_id=? AND line.line_state='ACTIVE'
ORDER BY offer.asin,line.selection_key,line.line_id
""",
(account_id,),
).fetchall()
return self._quoted_checkout_snapshot(rows)
def _buy_now_checkout_snapshot(
self, conn: sqlite3.Connection, checkout_id: int
) -> tuple[list[dict[str, Any]], int, str, str]:
rows = conn.execute(
"""
SELECT offer.*,line.quantity,line.selection_json
FROM checkout_lines AS line
JOIN commerce_offers AS offer ON offer.asin=line.asin
WHERE line.checkout_id=?
ORDER BY line.ordinal
""",
(checkout_id,),
).fetchall()
return self._quoted_checkout_snapshot(rows)
def _quoted_checkout_snapshot(
self, rows: list[sqlite3.Row]
) -> tuple[list[dict[str, Any]], int, str, str]:
"""Resolve current source-backed quotes for a cart or Buy Now line set."""
items: list[dict[str, Any]] = []
currencies: set[str] = set()
fingerprint_items: list[dict[str, Any]] = []
subtotal_minor = 0
for row in rows:
item = dict(row)
selected_options = self._stored_product_options(
str(item["asin"]), item.pop("selection_json", "{}")
)
self._apply_transaction_quote(item, selected_options)
quantity = int(item["quantity"])
price_minor = int(item["price_minor"])
line_total_minor = price_minor * quantity
item["line_total_minor"] = line_total_minor
items.append(item)
subtotal_minor += line_total_minor
currency = str(item["currency"])
currencies.add(currency)
fingerprint_items.append(
{
"asin": item["asin"],
"currency": currency,
"price_minor": price_minor,
"quantity": quantity,
"selection_key": item["selection_key"],
"selected_options": item["selected_options"],
}
)
if len(currencies) > 1:
raise ContractError("checkout cannot mix currencies")
currency = next(iter(currencies), "USD")
fingerprint = hashlib.sha256(
json.dumps(
fingerprint_items,
ensure_ascii=True,
sort_keys=True,
separators=(",", ":"),
).encode("ascii")
).hexdigest()
return items, subtotal_minor, currency, fingerprint
def _checkout_snapshot(
self,
conn: sqlite3.Connection,
checkout_row: sqlite3.Row,
account_id: int,
) -> tuple[list[dict[str, Any]], int, str, str]:
if str(checkout_row["checkout_mode"]) == CHECKOUT_MODE_BUY_NOW:
return self._buy_now_checkout_snapshot(
conn, int(checkout_row["checkout_id"])
)
return self._account_cart_snapshot(conn, account_id)
@staticmethod
def _open_checkout_row(
conn: sqlite3.Connection, account_id: int
) -> sqlite3.Row | None:
return conn.execute(
"""
SELECT * FROM checkout_sessions
WHERE account_id=? AND status<>'PLACED'
ORDER BY checkout_id DESC LIMIT 1
""",
(account_id,),
).fetchone()
@staticmethod
def _latest_checkout_row(
conn: sqlite3.Connection, account_id: int
) -> sqlite3.Row | None:
return conn.execute(
"""
SELECT * FROM checkout_sessions
WHERE account_id=?
ORDER BY (status<>'PLACED') DESC,checkout_id DESC
LIMIT 1
""",
(account_id,),
).fetchone()
def _supersede_checkout_payments(
self, conn: sqlite3.Connection, checkout_id: int
) -> None:
flow_ids = [
str(row["site_backend_flow_id"])
for row in conn.execute(
"""
SELECT DISTINCT site_backend_flow_id
FROM payment_attempts
WHERE checkout_id=? AND status='APPROVED'
AND site_backend_flow_id IS NOT NULL
""",
(checkout_id,),
)
]
conn.execute(
"""
UPDATE payment_attempts SET status='SUPERSEDED'
WHERE checkout_id=? AND status='APPROVED'
""",
(checkout_id,),
)
for flow_id in flow_ids:
conn.execute(
"""
UPDATE websitebench_payment_attempts SET status='SUPERSEDED'
WHERE site_id='amazon'
AND flow_id=? AND status='APPROVED'
""",
(flow_id,),
)
conn.execute(
"""
UPDATE websitebench_payment_flows SET status='OPEN',updated_at=?
WHERE site_id='amazon'
AND flow_id=? AND status='APPROVED'
""",
(self.now(conn), flow_id),
)
@classmethod
def _address_payload(
cls, conn: sqlite3.Connection, address_id: int | None, account_id: int
) -> dict[str, Any] | None:
if address_id is None:
return None
row = conn.execute(
"""
SELECT address_id,full_name,address_line1,address_line2,city,
state_region,postal_code,country_code,phone,is_default,
revision,created_at,updated_at
FROM addresses
WHERE address_id=? AND account_id=?
""",
(address_id, account_id),
).fetchone()
if row is None:
raise ContractError("checkout delivery address is unavailable")
return cls._address_row_payload(row)
@staticmethod
def _approved_payment_payload(
conn: sqlite3.Connection, checkout_id: int
) -> dict[str, Any] | None:
row = conn.execute(
"""
SELECT payment_attempt_id,method,status,amount_minor,currency,
cart_fingerprint,is_simulation,created_at
FROM payment_attempts
WHERE checkout_id=? AND status='APPROVED'
ORDER BY payment_attempt_id DESC LIMIT 1
""",
(checkout_id,),
).fetchone()
if row is None:
return None
payment = dict(row)
payment["is_simulation"] = bool(payment["is_simulation"])
payment["method_label"] = (
"Stripe test payment"
if str(payment["method"]) == STRIPE_TEST_PAYMENT_METHOD
else payment_method_label(str(payment["method"]))
)
payment["simulation_notice"] = SIMULATION_NOTICE
return payment
def _checkout_payload(
self,
conn: sqlite3.Connection,
row: sqlite3.Row,
account_id: int,
) -> dict[str, Any]:
if row["status"] == "PLACED":
order = conn.execute(
"SELECT * FROM orders WHERE checkout_id=? AND account_id=?",
(int(row["checkout_id"]), account_id),
).fetchone()
if order is None:
raise ContractError("placed checkout has no order")
payload = self._order_payload(conn, order)
payload["checkout_id"] = int(row["checkout_id"])
return payload
items, subtotal_minor, currency, fingerprint = self._checkout_snapshot(
conn, row, account_id
)
shipping_minor = (
int(row["shipping_minor"]) if row["shipping_minor"] is not None else 0
)
payment = self._approved_payment_payload(conn, int(row["checkout_id"]))
if payment is not None:
payment["cart_matches"] = bool(
payment["cart_fingerprint"] == fingerprint
and payment["currency"] == currency
and int(payment["amount_minor"]) == subtotal_minor + shipping_minor
)
return {
"checkout_id": int(row["checkout_id"]),
"idempotency_key": row["idempotency_key"],
"checkout_mode": str(row["checkout_mode"]),
"status": row["status"],
"items": items,
"address": self._address_payload(
conn,
int(row["address_id"]) if row["address_id"] is not None else None,
account_id,
),
"saved_addresses": [
self._address_row_payload(address_row)
for address_row in self._active_address_rows(conn, account_id)
if str(address_row["country_code"])
in SUPPORTED_DELIVERY_COUNTRY_CODES
],
"delivery_method": row["delivery_method"],
"items_subtotal_minor": subtotal_minor,
"shipping_minor": shipping_minor,
"total_minor": subtotal_minor + shipping_minor,
"currency": currency,
"payment": payment,
"is_simulation": True,
"simulation_notice": SIMULATION_NOTICE,
"created_at": row["created_at"],
"updated_at": row["updated_at"],
}
def _reconcile_open_checkout(
self,
conn: sqlite3.Connection,
row: sqlite3.Row,
account_id: int,
) -> tuple[sqlite3.Row, str | None]:
"""Demote an open checkout when address or approved totals are stale."""
checkout_id = int(row["checkout_id"])
now = self.now(conn)
if row["address_id"] is not None:
address = self._address_payload(
conn, int(row["address_id"]), account_id
)
if (
address is None
or str(address.get("country_code") or "").upper()
not in SUPPORTED_DELIVERY_COUNTRY_CODES
):
self._supersede_checkout_payments(conn, checkout_id)
conn.execute(
"""
UPDATE checkout_sessions SET
status='CART_READY',address_id=NULL,
delivery_method=NULL,shipping_minor=NULL,updated_at=?
WHERE checkout_id=?
""",
(now, checkout_id),
)
updated = self._open_checkout_row(conn, account_id)
assert updated is not None
return updated, "unsupported-delivery-country"
if row["status"] == "PAYMENT_SELECTED":
_, subtotal_minor, currency, fingerprint = self._checkout_snapshot(
conn, row, account_id
)
payment = self._approved_payment_payload(conn, checkout_id)
# The Stripe test profile uses PAYMENT_SELECTED as a review-only
# state before any provider payment exists. Its final POST freezes
# and re-quotes the cart, so an absent local payment is not stale
# approval and must not be demoted here.
if payment is None:
return row, None
shipping_minor = int(row["shipping_minor"] or 0)
payment_current = bool(
payment
and payment["cart_fingerprint"] == fingerprint
and payment["currency"] == currency
and int(payment["amount_minor"])
== subtotal_minor + shipping_minor
)
if not payment_current:
self._supersede_checkout_payments(conn, checkout_id)
conn.execute(
"""
UPDATE checkout_sessions SET
status='DELIVERY_SELECTED',currency=?,updated_at=?
WHERE checkout_id=?
""",
(currency, now, checkout_id),
)
updated = self._open_checkout_row(conn, account_id)
assert updated is not None
return updated, "cart-changed"
return row, None
def _replace_with_buy_now_checkout(
self,
conn: sqlite3.Connection,
account_id: int,
asin: str,
quantity: int,
selected_options: Mapping[str, Any] | None,
) -> dict[str, Any]:
if conn.execute(
"""
SELECT 1 FROM checkout_sessions
WHERE account_id=? AND status='PAYMENT_PENDING'
""",
(account_id,),
).fetchone():
raise CheckoutPaymentLocked(
"the checkout is locked while Stripe test payment is pending"
)
offer_row = conn.execute(
"SELECT * FROM commerce_offers WHERE asin=?", (asin,)
).fetchone()
if offer_row is None:
raise ContractError("product does not have a current commerce offer")
quote = self._transaction_quote(asin, selected_options, dict(offer_row))
selection_json = json.dumps(
quote["selected_options"],
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
)
conn.execute(
"DELETE FROM checkout_sessions WHERE account_id=? AND status<>'PLACED'",
(account_id,),
)
now = self.now(conn)
cursor = conn.execute(
"""
INSERT INTO checkout_sessions(
account_id,idempotency_key,checkout_mode,status,currency,
created_at,updated_at
) VALUES (?,?,'BUY_NOW','CART_READY',?,?,?)
""",
(
account_id,
secrets.token_urlsafe(24),
str(quote["currency"]),
now,
now,
),
)
checkout_id = int(cursor.lastrowid)
conn.execute(
"""
INSERT INTO checkout_lines(
checkout_id,ordinal,asin,quantity,selection_json
) VALUES (?,1,?,?,?)
""",
(checkout_id, asin, quantity, selection_json),
)
row = self._open_checkout_row(conn, account_id)
assert row is not None
return self._checkout_payload(conn, row, account_id)
def begin_buy_now(
self,
session_digest: str,
asin: str,
quantity: int | str,
selected_options: Mapping[str, Any] | None = None,
) -> dict[str, Any]:
"""Start an isolated Buy Now checkout or persist it across authentication."""
requested = self._quantity(quantity)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
offer_row = conn.execute(
"SELECT * FROM commerce_offers WHERE asin=?", (asin,)
).fetchone()
if offer_row is None:
raise ContractError("product does not have a current commerce offer")
quote = self._transaction_quote(
asin, selected_options, dict(offer_row)
)
normalized_options = dict(quote["selected_options"])
account_id = self._account_id_for_session(conn, session_digest)
if account_id is None:
conn.execute(
"""
INSERT INTO pending_buy_now(
session_digest,asin,quantity,selection_json,created_at
) VALUES (?,?,?,?,?)
ON CONFLICT(session_digest) DO UPDATE SET
asin=excluded.asin,
quantity=excluded.quantity,
selection_json=excluded.selection_json,
created_at=excluded.created_at
""",
(
session_digest,
asin,
requested,
json.dumps(
normalized_options,
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
),
self.now(conn),
),
)
conn.commit()
return {
"requires_authentication": True,
"asin": asin,
"quantity": requested,
"selected_options": normalized_options,
}
payload = self._replace_with_buy_now_checkout(
conn,
account_id,
asin,
requested,
normalized_options,
)
conn.execute(
"DELETE FROM pending_buy_now WHERE session_digest=?",
(session_digest,),
)
conn.commit()
payload["requires_authentication"] = False
return payload
def resume_buy_now(self, session_digest: str) -> dict[str, Any] | None:
"""Consume the authenticated session's one pending Buy Now intent."""
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
pending = conn.execute(
"""
SELECT asin,quantity,selection_json
FROM pending_buy_now WHERE session_digest=?
""",
(session_digest,),
).fetchone()
if pending is None:
conn.commit()
return None
selected_options = self._selection_payload(pending["selection_json"])
payload = self._replace_with_buy_now_checkout(
conn,
account_id,
str(pending["asin"]),
int(pending["quantity"]),
selected_options,
)
conn.execute(
"DELETE FROM pending_buy_now WHERE session_digest=?",
(session_digest,),
)
conn.commit()
payload["requires_authentication"] = False
return payload
def start_checkout(self, session_digest: str) -> dict[str, Any]:
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
items, _, currency, _ = self._account_cart_snapshot(
conn, account_id
)
if not items:
raise ContractError("checkout requires at least one active cart item")
row = self._open_checkout_row(conn, account_id)
now = self.now(conn)
reconciliation_reason: str | None = None
if row is not None and str(row["checkout_mode"]) != CHECKOUT_MODE_CART:
if row["status"] == "PAYMENT_PENDING":
raise CheckoutPaymentLocked(
"the checkout is locked while Stripe test payment is pending"
)
conn.execute(
"DELETE FROM checkout_sessions WHERE checkout_id=?",
(int(row["checkout_id"]),),
)
row = None
if row is None:
conn.execute(
"""
INSERT INTO checkout_sessions(
account_id,idempotency_key,checkout_mode,status,currency,
created_at,updated_at
) VALUES (?,?,'CART','CART_READY',?,?,?)
""",
(
account_id,
secrets.token_urlsafe(24),
currency,
now,
now,
),
)
row = self._open_checkout_row(conn, account_id)
elif row["currency"] != currency:
self._supersede_checkout_payments(conn, int(row["checkout_id"]))
conn.execute(
"""
UPDATE checkout_sessions SET
status='CART_READY',address_id=NULL,delivery_method=NULL,
shipping_minor=NULL,currency=?,updated_at=?
WHERE checkout_id=?
""",
(currency, now, int(row["checkout_id"])),
)
row = self._open_checkout_row(conn, account_id)
reconciliation_reason = "cart-changed"
assert row is not None
row, stale_reason = self._reconcile_open_checkout(
conn, row, account_id
)
reconciliation_reason = stale_reason or reconciliation_reason
payload = self._checkout_payload(conn, row, account_id)
if reconciliation_reason is not None:
payload["reconciliation_reason"] = reconciliation_reason
conn.commit()
return payload
def checkout(self, session_digest: str) -> dict[str, Any] | None:
self.ensure_session(session_digest)
with self.connect() as conn:
account_id = self._require_account_id(conn, session_digest)
row = self._latest_checkout_row(conn, account_id)
return self._checkout_payload(conn, row, account_id) if row else None
def reconcile_checkout(
self, session_digest: str
) -> dict[str, Any] | None:
"""Return the latest checkout after atomically invalidating stale state."""
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
row = self._latest_checkout_row(conn, account_id)
if row is None:
conn.commit()
return None
reason: str | None = None
if row["status"] != "PLACED":
row, reason = self._reconcile_open_checkout(
conn, row, account_id
)
payload = self._checkout_payload(conn, row, account_id)
if reason is not None:
payload["reconciliation_reason"] = reason
conn.commit()
return payload
def _apply_checkout_address(
self,
conn: sqlite3.Connection,
checkout_row: sqlite3.Row,
account_id: int,
address_id: int,
currency: str,
) -> dict[str, Any]:
if checkout_row["status"] == "PAYMENT_PENDING":
raise CheckoutPaymentLocked(
"the checkout is locked while Stripe test payment is pending"
)
now = self.now(conn)
self._supersede_checkout_payments(conn, int(checkout_row["checkout_id"]))
conn.execute(
"""
UPDATE checkout_sessions SET
status='ADDRESS_SELECTED',address_id=?,delivery_method=NULL,
shipping_minor=NULL,currency=?,updated_at=?
WHERE checkout_id=?
""",
(
address_id,
currency,
now,
int(checkout_row["checkout_id"]),
),
)
updated = self._open_checkout_row(conn, account_id)
assert updated is not None
return self._checkout_payload(conn, updated, account_id)
def save_checkout_address(
self,
session_digest: str,
fields: dict[str, Any],
*,
make_default: bool = False,
) -> dict[str, Any]:
address = self._validated_address_fields(fields)
make_default = self._validate_make_default(make_default)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
row = self._open_checkout_row(conn, account_id)
if row is None:
raise ContractError("start checkout before selecting an address")
items, _, currency, _ = self._checkout_snapshot(conn, row, account_id)
if not items:
raise ContractError("checkout requires at least one active cart item")
address_row = self._insert_account_address(
conn,
account_id,
address,
make_default=make_default,
)
payload = self._apply_checkout_address(
conn,
row,
account_id,
int(address_row["address_id"]),
currency,
)
conn.commit()
return payload
def select_checkout_address(
self,
session_digest: str,
address_id: int | str,
revision: int | str,
) -> dict[str, Any]:
normalized_id = self._normalized_address_number(address_id)
normalized_revision = self._normalized_address_number(revision)
if normalized_id is None:
raise AddressNotFound("address is unavailable")
if normalized_revision is None:
raise AddressRevisionConflict("address revision is invalid")
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
checkout_row = self._open_checkout_row(conn, account_id)
if checkout_row is None:
raise ContractError("start checkout before selecting an address")
items, _, currency, _ = self._checkout_snapshot(
conn, checkout_row, account_id
)
if not items:
raise ContractError("checkout requires at least one active cart item")
address_row = self._owned_active_address(
conn, account_id, normalized_id
)
self._require_address_revision(address_row, normalized_revision)
self._require_supported_delivery_address(dict(address_row))
payload = self._apply_checkout_address(
conn, checkout_row, account_id, normalized_id, currency
)
conn.commit()
return payload
def select_delivery(
self, session_digest: str, delivery_method: str
) -> dict[str, Any]:
if delivery_method not in DELIVERY_SHIPPING_MINOR:
raise ContractError("delivery method must be standard or expedited")
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
row = self._open_checkout_row(conn, account_id)
if row is None or row["status"] not in {
"ADDRESS_SELECTED",
"DELIVERY_SELECTED",
"PAYMENT_SELECTED",
}:
raise ContractError("select an address before choosing delivery")
items, _, currency, _ = self._checkout_snapshot(conn, row, account_id)
if not items:
raise ContractError("checkout requires at least one active cart item")
address = self._address_payload(
conn, int(row["address_id"]), account_id
)
self._require_supported_delivery_address(address)
self._supersede_checkout_payments(conn, int(row["checkout_id"]))
now = self.now(conn)
conn.execute(
"""
UPDATE checkout_sessions SET
status='DELIVERY_SELECTED',delivery_method=?,shipping_minor=?,
currency=?,updated_at=?
WHERE checkout_id=?
""",
(
delivery_method,
DELIVERY_SHIPPING_MINOR[delivery_method],
currency,
now,
int(row["checkout_id"]),
),
)
updated = self._open_checkout_row(conn, account_id)
assert updated is not None
payload = self._checkout_payload(conn, updated, account_id)
conn.commit()
return payload
def select_test_payment(
self, session_digest: str, method: str
) -> dict[str, Any]:
try:
scenario = payment_method(method)
except ValueError as exc:
raise ContractError("unsupported sandbox payment method") from exc
payment_status = scenario.outcome
decline_code = scenario.decline_code
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
row = self._open_checkout_row(conn, account_id)
if row is None or row["status"] not in {
"DELIVERY_SELECTED",
"PAYMENT_SELECTED",
}:
raise ContractError("select delivery before choosing payment")
items, subtotal_minor, currency, fingerprint = self._checkout_snapshot(
conn, row, account_id
)
if not items:
raise ContractError("checkout requires at least one active cart item")
address = self._address_payload(
conn, int(row["address_id"]), account_id
)
self._require_supported_delivery_address(address)
shipping_minor = int(row["shipping_minor"])
self._supersede_checkout_payments(conn, int(row["checkout_id"]))
now = self.now(conn)
owner = f"account:{account_id}"
amount_minor = subtotal_minor + shipping_minor
flow = self.site_backend.payments.create_intent(
owner=owner,
amount_minor=amount_minor,
currency=currency,
fingerprint=fingerprint,
idempotency_key=(
f"amazon-flow:{int(row['checkout_id'])}:"
f"{amount_minor}:{currency}:{fingerprint}"
),
adapter="local-sandbox",
connection=conn,
)
attempt_ordinal = int(
conn.execute(
"SELECT COUNT(*) FROM payment_attempts WHERE checkout_id=?",
(int(row["checkout_id"]),),
).fetchone()[0]
) + 1
generic_attempt = self.site_backend.payments.attempt(
flow_id=str(flow["flow_id"]),
owner=owner,
amount_minor=amount_minor,
currency=currency,
fingerprint=fingerprint,
scenario_id=method,
idempotency_key=(
f"amazon-attempt:{int(row['checkout_id'])}:"
f"{attempt_ordinal}:{method}"
),
connection=conn,
)
cursor = conn.execute(
"""
INSERT INTO payment_attempts(
checkout_id,account_id,method,status,amount_minor,currency,
cart_fingerprint,site_backend_flow_id,
site_backend_attempt_id,is_simulation,created_at
) VALUES (?,?,?,?,?,?,?,?,?,1,?)
""",
(
int(row["checkout_id"]),
account_id,
method,
payment_status,
amount_minor,
currency,
fingerprint,
str(flow["flow_id"]),
str(generic_attempt["attempt_id"]),
now,
),
)
conn.execute(
"""
UPDATE checkout_sessions SET
status=?,currency=?,updated_at=?
WHERE checkout_id=?
""",
(
"PAYMENT_SELECTED"
if payment_status == PAYMENT_APPROVED
else "DELIVERY_SELECTED",
currency,
now,
int(row["checkout_id"]),
),
)
updated = self._open_checkout_row(conn, account_id)
assert updated is not None
payload = self._checkout_payload(conn, updated, account_id)
payload["payment_attempt"] = {
"payment_attempt_id": int(cursor.lastrowid),
"method": method,
"method_label": payment_method_label(method),
"status": payment_status,
"decline_code": decline_code,
"is_simulation": True,
}
conn.commit()
return payload
def prepare_stripe_review(self, session_digest: str) -> dict[str, Any]:
"""Advance to review without claiming that hosted payment occurred."""
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
row = self._open_checkout_row(conn, account_id)
if row is None or row["status"] not in {
"DELIVERY_SELECTED",
"PAYMENT_SELECTED",
"PAYMENT_PENDING",
}:
raise ContractError("select delivery before reviewing payment")
if row["status"] != "PAYMENT_PENDING":
items, _, currency, _ = self._checkout_snapshot(
conn, row, account_id
)
if not items:
raise ContractError(
"checkout requires at least one active cart item"
)
address = self._address_payload(
conn, int(row["address_id"]), account_id
)
self._require_supported_delivery_address(address)
self._supersede_checkout_payments(
conn, int(row["checkout_id"])
)
conn.execute(
"""
UPDATE checkout_sessions
SET status='PAYMENT_SELECTED',currency=?,updated_at=?
WHERE checkout_id=?
""",
(currency, self.now(conn), int(row["checkout_id"])),
)
row = self._open_checkout_row(conn, account_id)
assert row is not None
payload = self._checkout_payload(conn, row, account_id)
payload["payment"] = {
"method": STRIPE_TEST_PAYMENT_METHOD,
"method_label": "Stripe test Checkout",
"status": (
"PENDING"
if row["status"] == "PAYMENT_PENDING"
else "NOT_STARTED"
),
"is_simulation": True,
}
conn.commit()
return payload
@staticmethod
def _stripe_snapshot_document(
items: list[dict[str, Any]],
*,
address: dict[str, Any],
delivery_method: str,
shipping_minor: int,
currency: str,
) -> dict[str, Any]:
return {
"address": {
key: address[key]
for key in (
"address_id",
"full_name",
"address_line1",
"address_line2",
"city",
"state_region",
"postal_code",
"country_code",
"phone",
)
},
"currency": currency,
"delivery_method": delivery_method,
"items": [
{
"asin": str(item["asin"]),
"currency": str(item["currency"]),
"image_path": str(item["image_path"]),
"line_total_minor": int(item["line_total_minor"]),
"price_minor": int(item["price_minor"]),
"quantity": int(item["quantity"]),
"selected_options": dict(
item.get("selected_options", {})
),
"title": str(item["title"]),
}
for item in items
],
"shipping_minor": shipping_minor,
}
@classmethod
def _stripe_snapshot_hash(cls, document: Mapping[str, Any]) -> str:
return hashlib.sha256(
json.dumps(
document,
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
).encode("utf-8")
).hexdigest()
@staticmethod
def _stripe_payment_row(
conn: sqlite3.Connection, checkout_id: int
) -> sqlite3.Row | None:
return conn.execute(
"""
SELECT * FROM stripe_payment_sessions
WHERE checkout_id=?
""",
(checkout_id,),
).fetchone()
@staticmethod
def _stripe_frozen_items(
conn: sqlite3.Connection, stripe_payment_session_id: int
) -> list[dict[str, Any]]:
rows = conn.execute(
"""
SELECT ordinal,asin,title,image_path,quantity,selection_json,
unit_price_minor,line_total_minor,currency
FROM stripe_checkout_lines
WHERE stripe_payment_session_id=?
ORDER BY ordinal
""",
(stripe_payment_session_id,),
).fetchall()
items: list[dict[str, Any]] = []
for row in rows:
try:
selected_options = json.loads(str(row["selection_json"]))
except json.JSONDecodeError as exc:
raise StripeCheckoutMismatch(
"frozen checkout options are corrupted"
) from exc
if not isinstance(selected_options, dict):
raise StripeCheckoutMismatch(
"frozen checkout options are corrupted"
)
items.append(
{
"asin": str(row["asin"]),
"title": str(row["title"]),
"image_path": str(row["image_path"]),
"quantity": int(row["quantity"]),
"selected_options": selected_options,
"price_minor": int(row["unit_price_minor"]),
"line_total_minor": int(row["line_total_minor"]),
"currency": str(row["currency"]),
}
)
return items
def _stripe_preparation_payload(
self, conn: sqlite3.Connection, row: sqlite3.Row
) -> dict[str, Any]:
items = self._stripe_frozen_items(
conn, int(row["stripe_payment_session_id"])
)
account = conn.execute(
"SELECT email_normalized FROM accounts WHERE account_id=?",
(int(row["account_id"]),),
).fetchone()
if account is None:
raise ContractError("checkout account is unavailable")
return {
"stripe_payment_session_id": int(
row["stripe_payment_session_id"]
),
"checkout_id": int(row["checkout_id"]),
"checkout_token": str(row["checkout_token"]),
"provider_session_id": row["provider_session_id"],
"provider_idempotency_key": str(
row["provider_idempotency_key"]
),
"flow_id": str(row["site_backend_flow_id"] or ""),
"owner": f"account:{int(row['account_id'])}",
"amount_minor": int(row["amount_minor"]),
"currency": str(row["currency"]),
"cart_fingerprint": str(row["cart_fingerprint"]),
"snapshot_hash": str(row["snapshot_hash"]),
"shipping_minor": int(row["shipping_minor"]),
"expires_at": int(row["expires_at"]),
"status": str(row["status"]),
"customer_email": str(account["email_normalized"]),
"items": items,
}
def _ensure_stripe_site_backend_flow(
self, conn: sqlite3.Connection, row: sqlite3.Row
) -> tuple[sqlite3.Row, str]:
"""Create or validate the shared flow for a legacy Stripe snapshot."""
flow = self.site_backend.payments.create_intent(
owner=f"account:{int(row['account_id'])}",
amount_minor=int(row["amount_minor"]),
currency=str(row["currency"]),
fingerprint=str(row["cart_fingerprint"]),
idempotency_key=(
f"amazon-stripe-flow:{int(row['checkout_id'])}:"
f"{int(row['amount_minor'])}:{str(row['currency'])}:"
f"{str(row['cart_fingerprint'])}"
),
adapter="stripe-test",
connection=conn,
)
flow_id = str(flow["flow_id"])
linked = str(row["site_backend_flow_id"] or "")
if linked and linked != flow_id:
raise StripeCheckoutMismatch(
"Stripe snapshot is linked to a different shared flow"
)
if not linked:
conn.execute(
"UPDATE stripe_payment_sessions SET site_backend_flow_id=? "
"WHERE stripe_payment_session_id=?",
(flow_id, int(row["stripe_payment_session_id"])),
)
refreshed = self._stripe_payment_row(
conn, int(row["checkout_id"])
)
assert refreshed is not None
row = refreshed
return row, flow_id
def prepare_stripe_checkout(
self, session_digest: str
) -> dict[str, Any]:
"""Freeze one authoritative quote before any provider request."""
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
checkout = self._open_checkout_row(conn, account_id)
if checkout is None or checkout["status"] not in {
"PAYMENT_SELECTED",
"PAYMENT_PENDING",
}:
raise ContractError(
"review the Stripe test payment before continuing"
)
checkout_id = int(checkout["checkout_id"])
existing = self._stripe_payment_row(conn, checkout_id)
current_time = int(time.time())
if existing is not None and str(existing["status"]) in {
"CREATING",
"OPEN",
}:
if int(existing["expires_at"]) > current_time:
existing, _ = self._ensure_stripe_site_backend_flow(
conn, existing
)
payload = self._stripe_preparation_payload(conn, existing)
conn.commit()
return payload
conn.execute(
"""
UPDATE stripe_payment_sessions
SET status='EXPIRED',updated_at=?
WHERE stripe_payment_session_id=?
""",
(
self.now(conn),
int(existing["stripe_payment_session_id"]),
),
)
conn.execute(
"""
UPDATE checkout_sessions
SET status='PAYMENT_SELECTED',updated_at=?
WHERE checkout_id=?
""",
(self.now(conn), checkout_id),
)
checkout = self._open_checkout_row(conn, account_id)
assert checkout is not None
if existing is not None:
if str(existing["status"]) == "PAID":
raise ContractError("Stripe test payment is already complete")
conn.execute(
"DELETE FROM stripe_payment_sessions "
"WHERE stripe_payment_session_id=?",
(int(existing["stripe_payment_session_id"]),),
)
items, subtotal_minor, currency, fingerprint = (
self._checkout_snapshot(conn, checkout, account_id)
)
if not items:
raise ContractError(
"checkout requires at least one active cart item"
)
if len(items) > STRIPE_MAX_PRODUCT_LINES:
raise ContractError(
"Stripe Checkout supports at most 99 product lines; "
"remove or combine cart lines before retrying"
)
address = self._address_payload(
conn, int(checkout["address_id"]), account_id
)
self._require_supported_delivery_address(address)
assert address is not None
delivery_method = str(checkout["delivery_method"])
shipping_minor = int(checkout["shipping_minor"])
amount_minor = subtotal_minor + shipping_minor
self._supersede_checkout_payments(conn, checkout_id)
flow = self.site_backend.payments.create_intent(
owner=f"account:{account_id}",
amount_minor=amount_minor,
currency=currency,
fingerprint=fingerprint,
idempotency_key=(
f"amazon-stripe-flow:{checkout_id}:"
f"{amount_minor}:{currency}:{fingerprint}"
),
adapter="stripe-test",
connection=conn,
)
document = self._stripe_snapshot_document(
items,
address=address,
delivery_method=delivery_method,
shipping_minor=shipping_minor,
currency=currency,
)
snapshot_hash = self._stripe_snapshot_hash(document)
checkout_token = secrets.token_urlsafe(32)
provider_key = (
"amazon-checkout-"
+ hashlib.sha256(
f"{checkout_id}:{checkout_token}".encode("ascii")
).hexdigest()
)
expires_at = current_time + STRIPE_SESSION_TTL_SECONDS
now = self.now(conn)
cursor = conn.execute(
"""
INSERT INTO stripe_payment_sessions(
checkout_id,account_id,checkout_token,provider_session_id,
provider_idempotency_key,site_backend_flow_id,
amount_minor,currency,
cart_fingerprint,snapshot_hash,shipping_address_json,
delivery_method,shipping_minor,status,
provider_payment_status,expires_at,created_at,updated_at
) VALUES (
?,?,?,NULL,?,?,?,?,?,?,?,?,?,
'CREATING',NULL,?,?,?
)
""",
(
checkout_id,
account_id,
checkout_token,
provider_key,
str(flow["flow_id"]),
amount_minor,
currency,
fingerprint,
snapshot_hash,
json.dumps(
document["address"],
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
),
delivery_method,
shipping_minor,
expires_at,
now,
now,
),
)
stripe_id = int(cursor.lastrowid)
conn.executemany(
"""
INSERT INTO stripe_checkout_lines(
stripe_payment_session_id,ordinal,asin,title,image_path,
quantity,selection_json,unit_price_minor,line_total_minor,
currency
) VALUES (?,?,?,?,?,?,?,?,?,?)
""",
[
(
stripe_id,
ordinal,
item["asin"],
item["title"],
item["image_path"],
int(item["quantity"]),
json.dumps(
item.get("selected_options", {}),
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
),
int(item["price_minor"]),
int(item["line_total_minor"]),
item["currency"],
)
for ordinal, item in enumerate(items, 1)
],
)
conn.execute(
"""
UPDATE checkout_sessions
SET status='PAYMENT_PENDING',currency=?,updated_at=?
WHERE checkout_id=?
""",
(currency, now, checkout_id),
)
row = self._stripe_payment_row(conn, checkout_id)
assert row is not None
payload = self._stripe_preparation_payload(conn, row)
conn.commit()
return payload
def attach_stripe_checkout_session(
self,
session_digest: str,
checkout_token: str,
provider_session: Mapping[str, Any],
) -> dict[str, Any]:
provider_id = str(provider_session.get("id") or "")
if STRIPE_PROVIDER_SESSION_PATTERN.fullmatch(provider_id) is None:
raise StripeCheckoutMismatch(
"Stripe returned an invalid Checkout Session"
)
if provider_session.get("livemode") is True:
raise StripeCheckoutMismatch(
"live Stripe Sessions are forbidden"
)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
row = conn.execute(
"""
SELECT * FROM stripe_payment_sessions
WHERE checkout_token=? AND account_id=?
""",
(checkout_token, account_id),
).fetchone()
if row is None or str(row["status"]) not in {"CREATING", "OPEN"}:
raise ContractError("Stripe checkout is unavailable")
existing_provider_id = str(row["provider_session_id"] or "")
if existing_provider_id and existing_provider_id != provider_id:
raise StripeCheckoutMismatch(
"Stripe returned a different Checkout Session"
)
if (
provider_session.get("amount_total") is not None
and int(provider_session["amount_total"])
!= int(row["amount_minor"])
):
raise StripeCheckoutMismatch(
"Stripe Checkout amount does not match"
)
if (
provider_session.get("currency") is not None
and str(provider_session["currency"]).upper()
!= str(row["currency"]).upper()
):
raise StripeCheckoutMismatch(
"Stripe Checkout currency does not match"
)
conn.execute(
"""
UPDATE stripe_payment_sessions
SET provider_session_id=?,status='OPEN',
provider_payment_status=?,updated_at=?
WHERE stripe_payment_session_id=?
""",
(
provider_id,
str(provider_session.get("payment_status") or "unpaid"),
self.now(conn),
int(row["stripe_payment_session_id"]),
),
)
updated = self._stripe_payment_row(
conn, int(row["checkout_id"])
)
assert updated is not None
payload = self._stripe_preparation_payload(conn, updated)
conn.commit()
return payload
def stripe_checkout_for_session(
self, session_digest: str, provider_session_id: str
) -> dict[str, Any] | None:
if (
STRIPE_PROVIDER_SESSION_PATTERN.fullmatch(provider_session_id)
is None
):
return None
self.ensure_session(session_digest)
with self.connect() as conn:
account_id = self._require_account_id(conn, session_digest)
row = conn.execute(
"""
SELECT * FROM stripe_payment_sessions
WHERE provider_session_id=? AND account_id=?
""",
(provider_session_id, account_id),
).fetchone()
return (
self._stripe_preparation_payload(conn, row)
if row is not None
else None
)
def cancel_stripe_checkout(
self,
session_digest: str,
provider_session_id: str,
provider_session: Mapping[str, Any],
) -> dict[str, Any]:
if str(provider_session.get("id") or "") != provider_session_id:
raise StripeCheckoutMismatch(
"Stripe returned a different Checkout Session"
)
if provider_session.get("livemode") is True:
raise StripeCheckoutMismatch("live Stripe Sessions are forbidden")
if str(provider_session.get("payment_status") or "") == "paid":
raise StripeCheckoutMismatch(
"a completed Stripe test payment cannot be cancelled"
)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
row = conn.execute(
"""
SELECT * FROM stripe_payment_sessions
WHERE provider_session_id=? AND account_id=?
""",
(provider_session_id, account_id),
).fetchone()
if row is None:
raise ContractError("Stripe checkout is unavailable")
if str(row["status"]) == "PAID":
raise StripeCheckoutMismatch(
"a completed Stripe test payment cannot be cancelled"
)
now = self.now(conn)
terminal = (
"EXPIRED"
if str(provider_session.get("status") or "") == "expired"
else "CANCELLED"
)
conn.execute(
"""
UPDATE stripe_payment_sessions
SET status=?,provider_payment_status=?,updated_at=?
WHERE stripe_payment_session_id=?
""",
(
terminal,
str(provider_session.get("payment_status") or "unpaid"),
now,
int(row["stripe_payment_session_id"]),
),
)
conn.execute(
"""
UPDATE checkout_sessions
SET status='PAYMENT_SELECTED',updated_at=?
WHERE checkout_id=? AND status='PAYMENT_PENDING'
""",
(now, int(row["checkout_id"])),
)
checkout = self._open_checkout_row(conn, account_id)
assert checkout is not None
payload = self._checkout_payload(conn, checkout, account_id)
conn.commit()
return payload
def _validated_stripe_provider_snapshot(
self,
conn: sqlite3.Connection,
row: sqlite3.Row,
provider_session: Mapping[str, Any],
) -> tuple[list[dict[str, Any]], dict[str, Any], int, str]:
provider_id = str(provider_session.get("id") or "")
metadata = provider_session.get("metadata")
if not isinstance(metadata, Mapping):
raise StripeCheckoutMismatch("Stripe metadata is unavailable")
if (
provider_id != str(row["provider_session_id"] or "")
or STRIPE_PROVIDER_SESSION_PATTERN.fullmatch(provider_id) is None
or provider_session.get("object") != "checkout.session"
or provider_session.get("livemode") is not False
or str(provider_session.get("client_reference_id") or "")
!= str(row["site_backend_flow_id"] or "")
or str(metadata.get("site_id") or "")
!= "amazon"
or str(metadata.get("flow_id") or "")
!= str(row["site_backend_flow_id"] or "")
or str(metadata.get("owner") or "")
!= f"account:{int(row['account_id'])}"
or str(metadata.get("fingerprint") or "")
!= str(row["cart_fingerprint"])
or str(metadata.get("amount_minor") or "")
!= str(row["amount_minor"])
or str(metadata.get("currency") or "").upper()
!= str(row["currency"]).upper()
or str(metadata.get("is_simulation") or "").casefold() != "true"
):
raise StripeCheckoutMismatch(
"Stripe Checkout ownership metadata does not match"
)
try:
amount_total = int(provider_session.get("amount_total"))
except (TypeError, ValueError) as exc:
raise StripeCheckoutMismatch(
"Stripe Checkout amount is unavailable"
) from exc
currency = str(provider_session.get("currency") or "").upper()
if (
amount_total != int(row["amount_minor"])
or currency != str(row["currency"]).upper()
):
raise StripeCheckoutMismatch(
"Stripe Checkout amount or currency does not match"
)
payment_status = str(provider_session.get("payment_status") or "")
if payment_status not in {
"paid",
"unpaid",
"no_payment_required",
}:
raise StripeCheckoutMismatch(
"Stripe Checkout payment status is invalid"
)
items = self._stripe_frozen_items(
conn, int(row["stripe_payment_session_id"])
)
if not items or len(items) > STRIPE_MAX_PRODUCT_LINES:
raise StripeCheckoutMismatch(
"frozen Stripe checkout items are invalid"
)
try:
address = json.loads(str(row["shipping_address_json"]))
except json.JSONDecodeError as exc:
raise StripeCheckoutMismatch(
"frozen shipping address is invalid"
) from exc
if not isinstance(address, dict):
raise StripeCheckoutMismatch(
"frozen shipping address is invalid"
)
subtotal_minor = sum(int(item["line_total_minor"]) for item in items)
if subtotal_minor + int(row["shipping_minor"]) != amount_total:
raise StripeCheckoutMismatch(
"frozen Stripe checkout total does not match"
)
document = self._stripe_snapshot_document(
items,
address=address,
delivery_method=str(row["delivery_method"]),
shipping_minor=int(row["shipping_minor"]),
currency=str(row["currency"]),
)
if not hmac.compare_digest(
self._stripe_snapshot_hash(document),
str(row["snapshot_hash"]),
):
raise StripeCheckoutMismatch(
"frozen Stripe checkout fingerprint does not match"
)
return items, address, subtotal_minor, payment_status
@staticmethod
def _unlock_rejected_stripe_checkout(
conn: sqlite3.Connection,
row: sqlite3.Row,
*,
stripe_status: str,
provider_payment_status: str,
now: str,
) -> None:
conn.execute(
"""
UPDATE stripe_payment_sessions
SET status=?,provider_payment_status=?,updated_at=?
WHERE stripe_payment_session_id=?
""",
(
stripe_status,
provider_payment_status,
now,
int(row["stripe_payment_session_id"]),
),
)
conn.execute(
"""
UPDATE checkout_sessions
SET status='PAYMENT_SELECTED',updated_at=?
WHERE checkout_id=? AND status='PAYMENT_PENDING'
""",
(now, int(row["checkout_id"])),
)
def _fulfill_stripe_payment(
self,
conn: sqlite3.Connection,
*,
row: sqlite3.Row,
provider_session: Mapping[str, Any],
mail_mode: str,
) -> sqlite3.Row:
existing = conn.execute(
"SELECT * FROM orders WHERE checkout_id=?",
(int(row["checkout_id"]),),
).fetchone()
if existing is not None:
return existing
items, address, subtotal_minor, payment_status = (
self._validated_stripe_provider_snapshot(
conn, row, provider_session
)
)
if payment_status != "paid":
raise StripeCheckoutMismatch(
"Stripe Checkout is not paid"
)
checkout = conn.execute(
"SELECT * FROM checkout_sessions WHERE checkout_id=?",
(int(row["checkout_id"]),),
).fetchone()
if checkout is None or checkout["status"] != "PAYMENT_PENDING":
raise StripeCheckoutMismatch(
"local checkout is not awaiting Stripe payment"
)
payment = conn.execute(
"""
SELECT * FROM payment_attempts
WHERE checkout_id=? AND method='stripe-test' AND status='APPROVED'
ORDER BY payment_attempt_id DESC LIMIT 1
""",
(int(row["checkout_id"]),),
).fetchone()
row, flow_id = self._ensure_stripe_site_backend_flow(conn, row)
provider_session_id = str(provider_session.get("id") or "")
generic_attempt = self.site_backend.payments.attempt_verified_stripe(
flow_id=flow_id,
owner=f"account:{int(row['account_id'])}",
amount_minor=int(row["amount_minor"]),
currency=str(row["currency"]),
fingerprint=str(row["cart_fingerprint"]),
provider_session_id=provider_session_id,
idempotency_key=(
"amazon-stripe-attempt:"
+ hashlib.sha256(provider_session_id.encode("ascii")).hexdigest()
),
provider_verifier=lambda requested_id: (
provider_session
if requested_id == provider_session_id
else {}
),
connection=conn,
)
try:
# Consume/validate before any Amazon order/payment compatibility
# mutation. A stale final state can then durably invalidate the
# approval without committing a partial business record.
self.site_backend.payments.consume_approval(
conn,
flow_id=flow_id,
owner=f"account:{int(row['account_id'])}",
amount_minor=int(row["amount_minor"]),
currency=str(row["currency"]),
fingerprint=str(row["cart_fingerprint"]),
)
except PaymentError as exc:
raise StripeCheckoutMismatch(
"Stripe test approval is missing or stale"
) from exc
if payment is None:
cursor = conn.execute(
"""
INSERT INTO payment_attempts(
checkout_id,account_id,method,status,amount_minor,currency,
cart_fingerprint,site_backend_flow_id,
site_backend_attempt_id,is_simulation,created_at
) VALUES (?,?,'stripe-test','APPROVED',?,?,?,?,?,1,?)
""",
(
int(row["checkout_id"]),
int(row["account_id"]),
int(row["amount_minor"]),
str(row["currency"]),
str(row["cart_fingerprint"]),
flow_id,
str(generic_attempt["attempt_id"]),
self.now(conn),
),
)
payment = conn.execute(
"SELECT * FROM payment_attempts WHERE payment_attempt_id=?",
(int(cursor.lastrowid),),
).fetchone()
assert payment is not None
elif (
str(payment["site_backend_flow_id"] or "") not in {"", flow_id}
or str(payment["site_backend_attempt_id"] or "")
not in {"", str(generic_attempt["attempt_id"])}
):
raise StripeCheckoutMismatch(
"Stripe compatibility payment links do not match"
)
else:
conn.execute(
"UPDATE payment_attempts SET site_backend_flow_id=?,"
"site_backend_attempt_id=? WHERE payment_attempt_id=?",
(
flow_id,
str(generic_attempt["attempt_id"]),
int(payment["payment_attempt_id"]),
),
)
payment = conn.execute(
"SELECT * FROM payment_attempts WHERE payment_attempt_id=?",
(int(payment["payment_attempt_id"]),),
).fetchone()
assert payment is not None
mail_status, mail_is_simulation = self._queued_mail_state(mail_mode)
order = self._create_order_record(
conn,
account_id=int(row["account_id"]),
checkout_row=checkout,
payment_row=payment,
idempotency_key=str(row["provider_idempotency_key"]),
items=items,
subtotal_minor=subtotal_minor,
shipping_minor=int(row["shipping_minor"]),
currency=str(row["currency"]),
address=address,
mail_status=mail_status,
mail_is_simulation=mail_is_simulation,
actor="SYSTEM",
payment_profile="stripe-test",
)
conn.execute(
"""
UPDATE stripe_payment_sessions
SET status='PAID',provider_payment_status='paid',updated_at=?
WHERE stripe_payment_session_id=?
""",
(self.now(conn), int(row["stripe_payment_session_id"])),
)
return order
def confirm_stripe_return(
self,
session_digest: str,
provider_session_id: str,
provider_session: Mapping[str, Any],
*,
mail_mode: str = MAIL_LOCAL_ONLY,
) -> dict[str, Any] | None:
"""Confirm a paid return only for the browser that owns the mapping."""
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
row = conn.execute(
"""
SELECT * FROM stripe_payment_sessions
WHERE provider_session_id=? AND account_id=?
""",
(provider_session_id, account_id),
).fetchone()
if row is None:
conn.commit()
return None
if str(provider_session.get("payment_status") or "") != "paid":
self._validated_stripe_provider_snapshot(
conn, row, provider_session
)
conn.execute(
"""
UPDATE stripe_payment_sessions
SET status='OPEN',provider_payment_status=?,updated_at=?
WHERE stripe_payment_session_id=?
""",
(
str(provider_session.get("payment_status") or "unpaid"),
self.now(conn),
int(row["stripe_payment_session_id"]),
),
)
conn.commit()
return None
order = self._fulfill_stripe_payment(
conn,
row=row,
provider_session=provider_session,
mail_mode=mail_mode,
)
payload = self._attach_order_action_tokens(
self._order_payload(conn, order), session_digest
)
conn.commit()
return payload
def process_stripe_event(
self,
event_id: str,
event_type: str,
provider_created_at: int,
provider_session: Mapping[str, Any],
*,
mail_mode: str = MAIL_LOCAL_ONLY,
) -> dict[str, Any]:
"""Apply a verified provider event exactly once and without order assumptions."""
if (
not isinstance(event_id, str)
or re.fullmatch(r"evt_[A-Za-z0-9_]{8,240}", event_id) is None
or event_type not in {
"checkout.session.completed",
"checkout.session.async_payment_succeeded",
"checkout.session.async_payment_failed",
"checkout.session.expired",
}
or isinstance(provider_created_at, bool)
or not isinstance(provider_created_at, int)
or provider_created_at < 0
):
raise ContractError("Stripe webhook event is invalid")
provider_id = str(provider_session.get("id") or "")
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
existing = conn.execute(
"SELECT * FROM stripe_webhook_events WHERE event_id=?",
(event_id,),
).fetchone()
if existing is not None:
order = conn.execute(
"""
SELECT orders.* FROM stripe_payment_sessions AS stripe
JOIN orders ON orders.checkout_id=stripe.checkout_id
WHERE stripe.stripe_payment_session_id=?
""",
(existing["stripe_payment_session_id"],),
).fetchone()
result = {
"duplicate": True,
"event_status": str(existing["status"]),
"order_id": int(order["order_id"]) if order else None,
}
conn.commit()
return result
row = conn.execute(
"""
SELECT * FROM stripe_payment_sessions
WHERE provider_session_id=?
""",
(provider_id,),
).fetchone()
now = self.now(conn)
if row is None:
conn.execute(
"""
INSERT INTO stripe_webhook_events(
event_id,stripe_payment_session_id,event_type,
provider_created_at,status,detail,created_at,processed_at
) VALUES (?,NULL,?,?,'REJECTED','unknown-session',?,?)
""",
(event_id, event_type, provider_created_at, now, now),
)
conn.commit()
return {
"duplicate": False,
"event_status": "REJECTED",
"order_id": None,
}
stripe_id = int(row["stripe_payment_session_id"])
conn.execute(
"""
INSERT INTO stripe_webhook_events(
event_id,stripe_payment_session_id,event_type,
provider_created_at,status,detail,created_at,processed_at
) VALUES (?,?,?,?,'PROCESSING','',?,NULL)
""",
(event_id, stripe_id, event_type, provider_created_at, now),
)
try:
_, _, _, payment_status = (
self._validated_stripe_provider_snapshot(
conn, row, provider_session
)
)
except StripeCheckoutMismatch:
self._unlock_rejected_stripe_checkout(
conn,
row,
stripe_status="INVALID",
provider_payment_status=str(
provider_session.get("payment_status") or "invalid"
),
now=now,
)
conn.execute(
"""
UPDATE stripe_webhook_events
SET status='REJECTED',detail='session-mismatch',
processed_at=?
WHERE event_id=?
""",
(now, event_id),
)
conn.commit()
return {
"duplicate": False,
"event_status": "REJECTED",
"order_id": None,
}
order: sqlite3.Row | None = None
event_status = "PROCESSED"
detail = "payment-pending"
if payment_status == "paid":
order = self._fulfill_stripe_payment(
conn,
row=row,
provider_session=provider_session,
mail_mode=mail_mode,
)
detail = "order-created"
elif event_type in {
"checkout.session.async_payment_failed",
"checkout.session.expired",
} or str(provider_session.get("status") or "") == "expired":
terminal = (
"EXPIRED"
if event_type == "checkout.session.expired"
or str(provider_session.get("status") or "") == "expired"
else "FAILED"
)
self._unlock_rejected_stripe_checkout(
conn,
row,
stripe_status=terminal,
provider_payment_status=payment_status,
now=now,
)
detail = terminal.casefold()
else:
conn.execute(
"""
UPDATE stripe_payment_sessions
SET status='OPEN',provider_payment_status=?,updated_at=?
WHERE stripe_payment_session_id=?
""",
(payment_status, now, stripe_id),
)
event_status = "IGNORED"
conn.execute(
"""
UPDATE stripe_webhook_events
SET status=?,detail=?,processed_at=?
WHERE event_id=?
""",
(event_status, detail, now, event_id),
)
result = {
"duplicate": False,
"event_status": event_status,
"order_id": int(order["order_id"]) if order else None,
}
conn.commit()
return result
@staticmethod
def _validated_idempotency_key(value: str) -> str:
if (
not isinstance(value, str)
or not value
or len(value) > 128
or value.strip() != value
or any(ord(character) < 33 or ord(character) == 127 for character in value)
):
raise ContractError("idempotency key must be 1 to 128 printable characters")
return value
@staticmethod
def _validated_action_idempotency_key(value: str) -> str:
if (
not isinstance(value, str)
or re.fullmatch(r"[A-Za-z0-9_-]{20,128}", value) is None
):
raise ContractError(
"order action idempotency key must use 20 to 128 safe characters"
)
return value
@staticmethod
def _order_action_token(
session_digest: str, action: str, order_id: int, *, purpose: str = "csrf"
) -> str:
if action not in {"cancel", "return"}:
raise ContractError("unsupported order action token")
message = f"{purpose}:{session_digest}:{action}:{order_id}".encode("utf-8")
return hmac.new(ORDER_ACTION_HMAC_KEY, message, hashlib.sha256).hexdigest()
@classmethod
def _attach_order_action_tokens(
cls, payload: dict[str, Any], session_digest: str
) -> dict[str, Any]:
order_id = int(payload["order_id"])
payload["action_tokens"] = {
action: cls._order_action_token(session_digest, action, order_id)
for action in ("cancel", "return")
}
payload["action_idempotency_keys"] = {
action: cls._order_action_token(
session_digest, action, order_id, purpose="idempotency"
)
for action in ("cancel", "return")
}
return payload
@classmethod
def _require_order_action_token(
cls,
session_digest: str,
action: str,
order_id: int,
candidate: str,
) -> None:
expected = cls._order_action_token(session_digest, action, order_id)
if not isinstance(candidate, str) or not hmac.compare_digest(
candidate, expected
):
raise OrderActionTokenInvalid("order action token is invalid")
def _order_payload(
self, conn: sqlite3.Connection, order_row: sqlite3.Row
) -> dict[str, Any]:
order_id = int(order_row["order_id"])
checkout_row = conn.execute(
"SELECT checkout_mode FROM checkout_sessions WHERE checkout_id=?",
(int(order_row["checkout_id"]),),
).fetchone()
if checkout_row is None:
raise ContractError("order checkout record is unavailable")
items = [
dict(row)
for row in conn.execute(
"""
SELECT order_item_id,asin,title,image_path,quantity,selection_json,
unit_price_minor AS price_minor,line_total_minor,currency
FROM order_items
WHERE order_id=?
ORDER BY ordinal
""",
(order_id,),
)
]
for item in items:
item["selected_options"] = self._stored_product_options(
str(item["asin"]), item.pop("selection_json", "{}")
)
payment_row = conn.execute(
"""
SELECT payment_attempt_id,method,status,amount_minor,currency,
is_simulation,created_at
FROM payment_attempts
WHERE payment_attempt_id=?
""",
(int(order_row["payment_attempt_id"]),),
).fetchone()
if payment_row is None:
raise ContractError("order payment record is unavailable")
payment = dict(payment_row)
payment["is_simulation"] = bool(payment["is_simulation"])
payment["method_label"] = (
"Stripe test payment"
if str(payment["method"]) == STRIPE_TEST_PAYMENT_METHOD
else payment_method_label(str(payment["method"]))
)
payment["simulation_notice"] = SIMULATION_NOTICE
shipment_row = conn.execute(
"""
SELECT shipment_id,status,lifecycle_status,revision,delivery_method,
shipping_minor,carrier,tracking_code,is_simulation,created_at,
updated_at,shipped_at,delivered_at,cancelled_at
FROM shipments WHERE order_id=?
""",
(order_id,),
).fetchone()
if shipment_row is None:
raise ContractError("order shipment record is unavailable")
shipment = dict(shipment_row)
shipment["is_simulation"] = bool(shipment["is_simulation"])
shipment["simulation_notice"] = SIMULATION_NOTICE
email_row = conn.execute(
"""
SELECT email_id,recipient,template,status,is_simulation,
delivery_attempts,attempted_at,sent_at,created_at
FROM email_outbox WHERE order_id=?
""",
(order_id,),
).fetchone()
email = dict(email_row) if email_row else None
if email is not None:
email["is_simulation"] = bool(email["is_simulation"])
email["can_retry"] = bool(
email["status"] == MAIL_SMTP_FAILED
and int(email["delivery_attempts"]) < MAIL_DELIVERY_MAX_ATTEMPTS
)
email["simulation_notice"] = SIMULATION_NOTICE
return_row = conn.execute(
"""
SELECT * FROM return_requests WHERE order_id=?
""",
(order_id,),
).fetchone()
return_request: dict[str, Any] | None = None
if return_row is not None:
return_request = dict(return_row)
return_request["is_simulation"] = bool(return_request["is_simulation"])
return_request["items"] = [
dict(row)
for row in conn.execute(
"""
SELECT item.order_item_id,item.quantity,order_item.asin,
order_item.title
FROM return_request_items AS item
JOIN order_items AS order_item
ON order_item.order_item_id=item.order_item_id
WHERE item.return_request_id=?
ORDER BY order_item.ordinal
""",
(int(return_row["return_request_id"]),),
)
]
return_request["simulation_notice"] = SIMULATION_NOTICE
refunds: list[dict[str, Any]] = []
for row in conn.execute(
"SELECT * FROM refunds WHERE order_id=? ORDER BY refund_id", (order_id,)
):
refund = dict(row)
refund["is_simulation"] = bool(refund["is_simulation"])
refund["simulation_notice"] = SIMULATION_NOTICE
refunds.append(refund)
events = [
{
**dict(row),
"detail": json.loads(str(row["detail_json"] or "{}")),
}
for row in conn.execute(
"""
SELECT order_event_id,event_type,actor,from_status,to_status,
idempotency_key,detail_json,created_at
FROM order_events WHERE order_id=? ORDER BY order_event_id
""",
(order_id,),
)
]
for event in events:
event.pop("detail_json", None)
lifecycle_status = str(shipment["lifecycle_status"])
if lifecycle_status == "CANCELLED":
display_status = "CANCELLED"
elif return_request is not None:
display_status = f"RETURN_{return_request['status']}"
else:
display_status = lifecycle_status
return {
"order_id": order_id,
"checkout_id": int(order_row["checkout_id"]),
"checkout_mode": str(checkout_row["checkout_mode"]),
"placement_status": order_row["status"],
"status": display_status,
"items": items,
"address": json.loads(order_row["shipping_address_json"]),
"delivery_method": order_row["delivery_method"],
"items_subtotal_minor": int(order_row["items_subtotal_minor"]),
"shipping_minor": int(order_row["shipping_minor"]),
"total_minor": int(order_row["total_minor"]),
"currency": order_row["currency"],
"payment": payment,
"shipment": shipment,
"return_request": return_request,
"refunds": refunds,
"events": events,
"can_cancel": lifecycle_status == "PREPARING",
"can_return": lifecycle_status == "DELIVERED" and return_request is None,
"email": email,
"idempotency_key": order_row["idempotency_key"],
"is_simulation": bool(order_row["is_simulation"]),
"simulation_notice": SIMULATION_NOTICE,
"created_at": order_row["created_at"],
}
def _create_order_record(
self,
conn: sqlite3.Connection,
*,
account_id: int,
checkout_row: sqlite3.Row,
payment_row: sqlite3.Row,
idempotency_key: str,
items: list[dict[str, Any]],
subtotal_minor: int,
shipping_minor: int,
currency: str,
address: Mapping[str, Any],
mail_status: str,
mail_is_simulation: int,
actor: str,
payment_profile: str,
) -> sqlite3.Row:
"""Create exactly one local simulated order inside the caller's lock."""
existing = conn.execute(
"SELECT * FROM orders WHERE checkout_id=?",
(int(checkout_row["checkout_id"]),),
).fetchone()
if existing is not None:
return existing
total_minor = subtotal_minor + shipping_minor
now = self.now(conn)
shipping_address = {
key: address[key]
for key in (
"address_id",
"full_name",
"address_line1",
"address_line2",
"city",
"state_region",
"postal_code",
"country_code",
"phone",
)
}
address_json = json.dumps(
shipping_address,
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
)
order_cursor = conn.execute(
"""
INSERT INTO orders(
account_id,checkout_id,payment_attempt_id,idempotency_key,status,
items_subtotal_minor,shipping_minor,total_minor,currency,
delivery_method,shipping_address_json,is_simulation,created_at
) VALUES (?,?,?,?,'PLACED',?,?,?,?,?,?,1,?)
""",
(
account_id,
int(checkout_row["checkout_id"]),
int(payment_row["payment_attempt_id"]),
idempotency_key,
subtotal_minor,
shipping_minor,
total_minor,
currency,
checkout_row["delivery_method"],
address_json,
now,
),
)
order_id = int(order_cursor.lastrowid)
conn.execute(
"""
INSERT INTO order_events(
order_id,account_id,event_type,actor,from_status,to_status,
idempotency_key,detail_json,created_at
) VALUES (?,?,'ORDER_PLACED',?,NULL,'PREPARING',?,?,?)
""",
(
order_id,
account_id,
actor,
idempotency_key,
json.dumps(
{
"checkout_mode": str(checkout_row["checkout_mode"]),
"payment_profile": payment_profile,
},
ensure_ascii=True,
sort_keys=True,
separators=(",", ":"),
),
now,
),
)
conn.executemany(
"""
INSERT INTO order_items(
order_id,ordinal,asin,title,image_path,quantity,selection_json,
unit_price_minor,line_total_minor,currency
) VALUES (?,?,?,?,?,?,?,?,?,?)
""",
[
(
order_id,
ordinal,
item["asin"],
item["title"],
item["image_path"],
int(item["quantity"]),
json.dumps(
item.get("selected_options", {}),
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
),
int(item["price_minor"]),
int(item["line_total_minor"]),
item["currency"],
)
for ordinal, item in enumerate(items, 1)
],
)
conn.execute(
"""
INSERT INTO shipments(
order_id,status,delivery_method,shipping_minor,carrier,
tracking_code,is_simulation,created_at,updated_at
) VALUES (?,'PREPARING',?,?,?,NULL,1,?,?)
""",
(
order_id,
checkout_row["delivery_method"],
shipping_minor,
"Amazon Clone Simulation",
now,
now,
),
)
account_row = conn.execute(
"SELECT email_normalized FROM accounts WHERE account_id=?",
(account_id,),
).fetchone()
if account_row is None:
raise ContractError("order account is unavailable")
email_payload = json.dumps(
{
"currency": currency,
"delivery_method": checkout_row["delivery_method"],
"item_count": sum(int(item["quantity"]) for item in items),
"items": [
{
"asin": item["asin"],
"quantity": int(item["quantity"]),
"selected_options": item.get("selected_options", {}),
}
for item in items
],
"order_id": order_id,
"total_minor": total_minor,
},
ensure_ascii=True,
sort_keys=True,
separators=(",", ":"),
)
common_mail = self.site_backend.mail.enqueue(
"order-receipt",
str(account_row["email_normalized"]),
{
"order_id": order_id,
"total": f"{currency} {total_minor / 100:.2f}",
},
idempotency_key=f"amazon-order-receipt:{order_id}",
# The legacy row remains a compatibility projection; its claim
# and final delivery transitions mirror this shared job.
simulation=bool(mail_is_simulation),
connection=conn,
)
conn.execute(
"""
INSERT INTO email_outbox(
account_id,order_id,recipient,template,subject,payload_json,
site_backend_mail_id,status,is_simulation,created_at
) VALUES (?,?,?,'order-confirmation',?,?,?,?,?,?)
""",
(
account_id,
order_id,
account_row["email_normalized"],
f"Amazon Clone simulated order #{order_id}",
email_payload,
str(common_mail["mail_id"]),
mail_status,
mail_is_simulation,
now,
),
)
conn.execute(
"""
UPDATE checkout_sessions SET status='PLACED',placed_at=?,updated_at=?
WHERE checkout_id=?
""",
(now, now, int(checkout_row["checkout_id"])),
)
if str(checkout_row["checkout_mode"]) == CHECKOUT_MODE_CART:
conn.execute(
"""
DELETE FROM account_cart_lines
WHERE account_id=? AND line_state='ACTIVE'
""",
(account_id,),
)
order_row = conn.execute(
"SELECT * FROM orders WHERE order_id=?", (order_id,)
).fetchone()
assert order_row is not None
return order_row
def place_order(
self,
session_digest: str,
idempotency_key: str,
*,
mail_mode: str = MAIL_LOCAL_ONLY,
) -> dict[str, Any]:
key = self._validated_idempotency_key(idempotency_key)
mail_status, mail_is_simulation = self._queued_mail_state(mail_mode)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
existing = conn.execute(
"""
SELECT * FROM orders
WHERE account_id=? AND idempotency_key=?
""",
(account_id, key),
).fetchone()
if existing is not None:
payload = self._order_payload(conn, existing)
conn.commit()
return self._attach_order_action_tokens(payload, session_digest)
checkout_row = self._open_checkout_row(conn, account_id)
if checkout_row is None:
raise ContractError("complete checkout payment before placing the order")
checkout_row, reconciliation_reason = self._reconcile_open_checkout(
conn, checkout_row, account_id
)
if reconciliation_reason is not None:
# Commit the demotion before surfacing the redirect instruction.
# BEGIN IMMEDIATE keeps a second cart write from racing between
# this final reconciliation and order snapshot creation.
conn.commit()
raise CheckoutReconciliationRequired(reconciliation_reason)
if checkout_row["status"] != "PAYMENT_SELECTED":
raise ContractError("complete checkout payment before placing the order")
items, subtotal_minor, currency, fingerprint = self._checkout_snapshot(
conn, checkout_row, account_id
)
if not items:
raise ContractError("checkout requires at least one active cart item")
address = self._address_payload(
conn, int(checkout_row["address_id"]), account_id
)
self._require_supported_delivery_address(address)
assert address is not None
shipping_minor = int(checkout_row["shipping_minor"])
total_minor = subtotal_minor + shipping_minor
payment_row = conn.execute(
"""
SELECT * FROM payment_attempts
WHERE checkout_id=? AND account_id=? AND status='APPROVED'
ORDER BY payment_attempt_id DESC LIMIT 1
""",
(int(checkout_row["checkout_id"]), account_id),
).fetchone()
payment_method_is_approved = False
if payment_row is not None:
persisted_method = str(payment_row["method"])
if persisted_method == LEGACY_TEST_CARD:
payment_method_is_approved = True
else:
try:
payment_method_is_approved = (
payment_method(persisted_method).outcome
== PAYMENT_APPROVED
)
except ValueError:
payment_method_is_approved = False
payment_valid = bool(
payment_row
and payment_method_is_approved
and int(payment_row["is_simulation"]) == 1
and payment_row["currency"] == currency
and int(payment_row["amount_minor"]) == total_minor
and payment_row["cart_fingerprint"] == fingerprint
)
if not payment_valid:
raise ContractError(
"the simulated payment is stale; select a sandbox payment method again"
)
assert payment_row is not None
try:
self.site_backend.payments.consume_approval(
conn,
flow_id=str(payment_row["site_backend_flow_id"] or ""),
owner=f"account:{account_id}",
amount_minor=total_minor,
currency=currency,
fingerprint=fingerprint,
)
except PaymentError as exc:
raise ContractError(
"the simulated payment approval is missing or stale"
) from exc
order_row = self._create_order_record(
conn,
account_id=account_id,
checkout_row=checkout_row,
payment_row=payment_row,
idempotency_key=key,
items=items,
subtotal_minor=subtotal_minor,
shipping_minor=shipping_minor,
currency=currency,
address=address,
mail_status=mail_status,
mail_is_simulation=mail_is_simulation,
actor="CUSTOMER",
payment_profile="local-sandbox",
)
payload = self._order_payload(conn, order_row)
conn.commit()
return self._attach_order_action_tokens(payload, session_digest)
@staticmethod
def _normalized_order_id(order_id: int | str) -> int | None:
if isinstance(order_id, bool):
return None
if isinstance(order_id, int):
return order_id if 0 < order_id <= SQLITE_INTEGER_MAX else None
if (
isinstance(order_id, str)
and 0 < len(order_id) <= 19
and order_id.isascii()
and order_id.isdecimal()
):
try:
normalized = int(order_id)
except ValueError:
return None
return (
normalized
if str(normalized) == order_id
and 0 < normalized <= SQLITE_INTEGER_MAX
else None
)
return None
def orders_for_session(self, session_digest: str) -> list[dict[str, Any]]:
self.ensure_session(session_digest)
with self.connect() as conn:
account_id = self._require_account_id(conn, session_digest)
rows = conn.execute(
"""
SELECT * FROM orders
WHERE account_id=? ORDER BY order_id DESC
""",
(account_id,),
).fetchall()
return [
self._attach_order_action_tokens(
self._order_payload(conn, row), session_digest
)
for row in rows
]
def order_for_session(
self, session_digest: str, order_id: int | str
) -> dict[str, Any] | None:
normalized_order_id = self._normalized_order_id(order_id)
if normalized_order_id is None:
return None
self.ensure_session(session_digest)
with self.connect() as conn:
account_id = self._require_account_id(conn, session_digest)
row = conn.execute(
"""
SELECT * FROM orders WHERE order_id=? AND account_id=?
""",
(normalized_order_id, account_id),
).fetchone()
return (
self._attach_order_action_tokens(
self._order_payload(conn, row), session_digest
)
if row
else None
)
@staticmethod
def _owned_order_row(
conn: sqlite3.Connection, account_id: int, order_id: int
) -> sqlite3.Row:
row = conn.execute(
"SELECT * FROM orders WHERE order_id=? AND account_id=?",
(order_id, account_id),
).fetchone()
if row is None:
raise OrderNotFound("order is unavailable")
return row
@staticmethod
def _order_shipment_row(
conn: sqlite3.Connection, order_id: int
) -> sqlite3.Row:
row = conn.execute(
"SELECT * FROM shipments WHERE order_id=?", (order_id,)
).fetchone()
if row is None:
raise OrderStateConflict("order shipment is unavailable")
return row
@staticmethod
def _insert_order_event(
conn: sqlite3.Connection,
*,
order_id: int,
account_id: int,
event_type: str,
actor: str,
from_status: str,
to_status: str,
now: str,
idempotency_key: str | None = None,
detail: dict[str, Any] | None = None,
) -> None:
conn.execute(
"""
INSERT INTO order_events(
order_id,account_id,event_type,actor,from_status,to_status,
idempotency_key,detail_json,created_at
) VALUES (?,?,?,?,?,?,?,?,?)
""",
(
order_id,
account_id,
event_type,
actor,
from_status,
to_status,
idempotency_key,
json.dumps(
detail or {},
ensure_ascii=True,
sort_keys=True,
separators=(",", ":"),
),
now,
),
)
def cancel_order(
self,
session_digest: str,
order_id: int | str,
idempotency_key: str,
action_token: str,
) -> dict[str, Any]:
normalized_id = self._normalized_order_id(order_id)
if normalized_id is None:
raise OrderNotFound("order is unavailable")
key = self._validated_action_idempotency_key(idempotency_key)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
order = self._owned_order_row(conn, account_id, normalized_id)
self._require_order_action_token(
session_digest, "cancel", normalized_id, action_token
)
key_owner = conn.execute(
"""
SELECT * FROM order_action_keys
WHERE account_id=? AND idempotency_key=?
""",
(account_id, key),
).fetchone()
if key_owner is not None and (
str(key_owner["action_type"]) != "CANCEL"
or int(key_owner["order_id"]) != normalized_id
):
raise OrderStateConflict(
"idempotency key belongs to another order action"
)
replay = key_owner
existing_action = conn.execute(
"""
SELECT * FROM order_action_keys
WHERE order_id=? AND action_type='CANCEL'
""",
(normalized_id,),
).fetchone()
shipment = self._order_shipment_row(conn, normalized_id)
if existing_action is not None or replay is not None:
if str(shipment["lifecycle_status"]) != "CANCELLED":
raise OrderStateConflict("cancel action record is inconsistent")
payload = self._order_payload(conn, order)
conn.commit()
return self._attach_order_action_tokens(payload, session_digest)
if str(shipment["lifecycle_status"]) != "PREPARING":
raise OrderStateConflict("only a preparing order can be cancelled")
now = self.now(conn)
action_cursor = conn.execute(
"""
INSERT INTO order_action_keys(
account_id,order_id,action_type,idempotency_key,created_at
) VALUES (?,?,'CANCEL',?,?)
""",
(account_id, normalized_id, key, now),
)
updated = conn.execute(
"""
UPDATE shipments SET lifecycle_status='CANCELLED',
revision=revision+1,tracking_code=NULL,cancelled_at=?,updated_at=?
WHERE shipment_id=? AND lifecycle_status='PREPARING' AND revision=?
""",
(
now,
now,
int(shipment["shipment_id"]),
int(shipment["revision"]),
),
)
if updated.rowcount != 1:
raise OrderStateConflict("shipment changed during cancellation")
refund_cursor = conn.execute(
"""
INSERT INTO refunds(
account_id,order_id,payment_attempt_id,return_request_id,
kind,status,amount_minor,currency,idempotency_key,
is_simulation,created_at
) VALUES (?,?,?,NULL,'CANCELLATION','COMPLETED',?,?,?,1,?)
""",
(
account_id,
normalized_id,
int(order["payment_attempt_id"]),
int(order["total_minor"]),
str(order["currency"]),
key,
now,
),
)
conn.execute(
"UPDATE order_action_keys SET result_reference=? WHERE order_action_key_id=?",
(int(refund_cursor.lastrowid), int(action_cursor.lastrowid)),
)
self._insert_order_event(
conn,
order_id=normalized_id,
account_id=account_id,
event_type="ORDER_CANCELLED",
actor="CUSTOMER",
from_status="PREPARING",
to_status="CANCELLED",
idempotency_key=key,
detail={"refund_kind": "CANCELLATION", "is_simulation": True},
now=now,
)
payload = self._order_payload(conn, order)
conn.commit()
return self._attach_order_action_tokens(payload, session_digest)
def advance_order_shipment(
self, order_id: int | str, target_status: str
) -> dict[str, Any]:
normalized_id = self._normalized_order_id(order_id)
if normalized_id is None:
raise OrderNotFound("order is unavailable")
if target_status not in {"SHIPPED", "DELIVERED"}:
raise ContractError("shipment target must be SHIPPED or DELIVERED")
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
order = conn.execute(
"SELECT * FROM orders WHERE order_id=?", (normalized_id,)
).fetchone()
if order is None:
raise OrderNotFound("order is unavailable")
shipment = self._order_shipment_row(conn, normalized_id)
current = str(shipment["lifecycle_status"])
if current == target_status:
payload = self._order_payload(conn, order)
conn.commit()
return payload
expected = "PREPARING" if target_status == "SHIPPED" else "SHIPPED"
if current != expected:
raise OrderStateConflict(
f"shipment cannot transition from {current} to {target_status}"
)
now = self.now(conn)
if target_status == "SHIPPED":
tracking_code = (
f"ACL-{normalized_id:08d}-{secrets.token_hex(5).upper()}"
)
event_type = "SHIPMENT_SHIPPED"
cursor = conn.execute(
"""
UPDATE shipments SET lifecycle_status='SHIPPED',
revision=revision+1,carrier=?,tracking_code=?,shipped_at=?,
updated_at=?
WHERE shipment_id=? AND lifecycle_status='PREPARING' AND revision=?
""",
(
LOCAL_SIMULATED_CARRIER,
tracking_code,
now,
now,
int(shipment["shipment_id"]),
int(shipment["revision"]),
),
)
else:
event_type = "SHIPMENT_DELIVERED"
cursor = conn.execute(
"""
UPDATE shipments SET lifecycle_status='DELIVERED',
revision=revision+1,delivered_at=?,updated_at=?
WHERE shipment_id=? AND lifecycle_status='SHIPPED' AND revision=?
""",
(
now,
now,
int(shipment["shipment_id"]),
int(shipment["revision"]),
),
)
if cursor.rowcount != 1:
raise OrderStateConflict("shipment changed during admin transition")
self._insert_order_event(
conn,
order_id=normalized_id,
account_id=int(order["account_id"]),
event_type=event_type,
actor="ADMIN",
from_status=current,
to_status=target_status,
detail={"is_simulation": True},
now=now,
)
payload = self._order_payload(conn, order)
conn.commit()
return payload
@staticmethod
def _validated_return_fields(
reason_code: str, customer_note: str
) -> tuple[str, str]:
if reason_code not in RETURN_REASON_CODES:
raise ContractError("return reason is unsupported")
if not isinstance(customer_note, str):
raise ContractError("return note must be text")
note = customer_note.replace("\r\n", "\n").replace("\r", "\n").strip()
if len(note) > RETURN_NOTE_MAX_LENGTH or any(
(ord(character) < 32 and character not in {"\n", "\t"})
or ord(character) == 127
for character in note
):
raise ContractError("return note is invalid")
return reason_code, note
def create_return_request(
self,
session_digest: str,
order_id: int | str,
reason_code: str,
customer_note: str,
idempotency_key: str,
action_token: str,
) -> dict[str, Any]:
normalized_id = self._normalized_order_id(order_id)
if normalized_id is None:
raise OrderNotFound("order is unavailable")
reason, note = self._validated_return_fields(reason_code, customer_note)
key = self._validated_action_idempotency_key(idempotency_key)
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
account_id = self._require_account_id(conn, session_digest)
order = self._owned_order_row(conn, account_id, normalized_id)
self._require_order_action_token(
session_digest, "return", normalized_id, action_token
)
key_owner = conn.execute(
"""
SELECT * FROM order_action_keys
WHERE account_id=? AND idempotency_key=?
""",
(account_id, key),
).fetchone()
if key_owner is not None and (
str(key_owner["action_type"]) != "RETURN_REQUEST"
or int(key_owner["order_id"]) != normalized_id
):
raise OrderStateConflict(
"idempotency key belongs to another order action"
)
replay = key_owner
existing = conn.execute(
"SELECT * FROM return_requests WHERE order_id=?",
(normalized_id,),
).fetchone()
if existing is not None:
if replay is None:
raise OrderStateConflict("this order already has a return request")
payload = self._order_payload(conn, order)
conn.commit()
return self._attach_order_action_tokens(payload, session_digest)
shipment = self._order_shipment_row(conn, normalized_id)
if str(shipment["lifecycle_status"]) != "DELIVERED":
raise OrderStateConflict("returns can be requested only after delivery")
item_rows = conn.execute(
"SELECT order_item_id,quantity FROM order_items WHERE order_id=? ORDER BY ordinal",
(normalized_id,),
).fetchall()
if not item_rows:
raise OrderStateConflict("order has no returnable items")
now = self.now(conn)
action_cursor = conn.execute(
"""
INSERT INTO order_action_keys(
account_id,order_id,action_type,idempotency_key,created_at
) VALUES (?,?,'RETURN_REQUEST',?,?)
""",
(account_id, normalized_id, key, now),
)
request_cursor = conn.execute(
"""
INSERT INTO return_requests(
account_id,order_id,idempotency_key,reason_code,customer_note,
status,revision,is_simulation,created_at,updated_at
) VALUES (?,?,?,?,?,'REQUESTED',1,1,?,?)
""",
(account_id, normalized_id, key, reason, note, now, now),
)
return_id = int(request_cursor.lastrowid)
conn.executemany(
"""
INSERT INTO return_request_items(
return_request_id,order_item_id,quantity
) VALUES (?,?,?)
""",
[
(return_id, int(row["order_item_id"]), int(row["quantity"]))
for row in item_rows
],
)
conn.execute(
"UPDATE order_action_keys SET result_reference=? WHERE order_action_key_id=?",
(return_id, int(action_cursor.lastrowid)),
)
self._insert_order_event(
conn,
order_id=normalized_id,
account_id=account_id,
event_type="RETURN_REQUESTED",
actor="CUSTOMER",
from_status="DELIVERED",
to_status="RETURN_REQUESTED",
idempotency_key=key,
detail={"reason_code": reason, "is_simulation": True},
now=now,
)
payload = self._order_payload(conn, order)
conn.commit()
return self._attach_order_action_tokens(payload, session_digest)
def return_for_session(
self, session_digest: str, return_request_id: int | str
) -> dict[str, Any] | None:
normalized_id = self._normalized_order_id(return_request_id)
if normalized_id is None:
return None
self.ensure_session(session_digest)
with self.connect() as conn:
account_id = self._require_account_id(conn, session_digest)
row = conn.execute(
"""
SELECT orders.* FROM return_requests AS request
JOIN orders ON orders.order_id=request.order_id
WHERE request.return_request_id=? AND request.account_id=?
""",
(normalized_id, account_id),
).fetchone()
return (
self._attach_order_action_tokens(
self._order_payload(conn, row), session_digest
)
if row
else None
)
def advance_return_request(
self, return_request_id: int | str, target_status: str
) -> dict[str, Any]:
normalized_id = self._normalized_order_id(return_request_id)
if normalized_id is None:
raise ReturnNotFound("return request is unavailable")
if target_status not in {"RECEIVED", "REFUNDED"}:
raise ContractError("return target must be RECEIVED or REFUNDED")
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
request = conn.execute(
"SELECT * FROM return_requests WHERE return_request_id=?",
(normalized_id,),
).fetchone()
if request is None:
raise ReturnNotFound("return request is unavailable")
order = conn.execute(
"SELECT * FROM orders WHERE order_id=?", (int(request["order_id"]),)
).fetchone()
if order is None:
raise OrderStateConflict("return order is unavailable")
shipment = self._order_shipment_row(conn, int(order["order_id"]))
if str(shipment["lifecycle_status"]) != "DELIVERED":
raise OrderStateConflict("return shipment is not delivered")
current = str(request["status"])
if current == target_status:
payload = self._order_payload(conn, order)
conn.commit()
return payload
expected = "REQUESTED" if target_status == "RECEIVED" else "RECEIVED"
if current != expected:
raise OrderStateConflict(
f"return cannot transition from {current} to {target_status}"
)
now = self.now(conn)
cursor = conn.execute(
"""
UPDATE return_requests SET status=?,revision=revision+1,updated_at=?
WHERE return_request_id=? AND status=? AND revision=?
""",
(
target_status,
now,
normalized_id,
current,
int(request["revision"]),
),
)
if cursor.rowcount != 1:
raise OrderStateConflict("return changed during admin transition")
event_type = (
"RETURN_RECEIVED" if target_status == "RECEIVED" else "RETURN_REFUNDED"
)
if target_status == "REFUNDED":
conn.execute(
"""
INSERT INTO refunds(
account_id,order_id,payment_attempt_id,return_request_id,
kind,status,amount_minor,currency,idempotency_key,
is_simulation,created_at
) VALUES (?,?,?,?,'RETURN','COMPLETED',?,?,?,1,?)
""",
(
int(order["account_id"]),
int(order["order_id"]),
int(order["payment_attempt_id"]),
normalized_id,
int(order["total_minor"]),
str(order["currency"]),
f"return-{normalized_id}-simulated-refund",
now,
),
)
self._insert_order_event(
conn,
order_id=int(order["order_id"]),
account_id=int(order["account_id"]),
event_type=event_type,
actor="ADMIN",
from_status=f"RETURN_{current}",
to_status=f"RETURN_{target_status}",
detail={"is_simulation": True},
now=now,
)
payload = self._order_payload(conn, order)
conn.commit()
return payload
def mail_outbox(self, account: int | None = None) -> list[dict[str, Any]]:
if account is not None and (
isinstance(account, bool) or not isinstance(account, int) or account <= 0
):
raise ContractError("mail outbox account filter must be an account id")
with self.connect() as conn:
if account is None:
rows = conn.execute(
"SELECT * FROM email_outbox ORDER BY email_id"
).fetchall()
else:
rows = conn.execute(
"""
SELECT * FROM email_outbox
WHERE account_id=? ORDER BY email_id
""",
(account,),
).fetchall()
messages: list[dict[str, Any]] = []
for row in rows:
message = dict(row)
message["payload"] = json.loads(message.pop("payload_json"))
message["is_simulation"] = bool(message["is_simulation"])
message["simulation_notice"] = SIMULATION_NOTICE
messages.append(message)
return messages
def products(self) -> list[dict[str, Any]]:
with self.connect() as conn:
rows = conn.execute(
"""
SELECT p.*, d.payload_json AS pdp_json
FROM catalog_products p
LEFT JOIN product_details d ON d.asin=p.asin
ORDER BY p.asin
"""
).fetchall()
return [self._product_row(row) for row in rows]
def product(self, asin: str) -> dict[str, Any] | None:
with self.connect() as conn:
row = conn.execute(
"""
SELECT p.*, d.payload_json AS pdp_json
FROM catalog_products p
LEFT JOIN product_details d ON d.asin=p.asin
WHERE p.asin=?
""",
(asin,),
).fetchone()
return self._product_row(row) if row else None
@staticmethod
def _product_row(row: sqlite3.Row) -> dict[str, Any]:
product = dict(row)
raw_detail = product.pop("pdp_json", None)
product["pdp"] = json.loads(raw_detail) if raw_detail else None
return product
def ranking(self, list_id: str = "external-ssd") -> list[dict[str, Any]]:
with self.connect() as conn:
rows = conn.execute(
"""
SELECT ri.rank, p.*, d.payload_json AS pdp_json
FROM ranking_items ri
JOIN catalog_products p ON p.asin=ri.asin
LEFT JOIN product_details d ON d.asin=p.asin
WHERE ri.list_id=?
ORDER BY ri.rank
""",
(list_id,),
).fetchall()
return [self._product_row(row) for row in rows]
def _record_navigation(
self,
conn: sqlite3.Connection,
session_digest: str,
method: str,
route_key: str,
path: str,
referer: str,
status: int,
asin: str | None = None,
rank: int | None = None,
) -> int:
sequence = conn.execute(
"SELECT COALESCE(MAX(sequence),0)+1 FROM navigation_events WHERE session_digest=?",
(session_digest,),
).fetchone()[0]
cursor = conn.execute(
"""
INSERT INTO navigation_events(
session_digest,sequence,method,route_key,path,referer,status,asin,rank,created_at
) VALUES (?,?,?,?,?,?,?,?,?,?)
""",
(session_digest, sequence, method, route_key, path, referer, status, asin, rank, self.now(conn)),
)
return int(cursor.lastrowid)
def record_best_sellers(self, session_digest: str, path: str, referer: str) -> None:
self.ensure_session(session_digest)
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
event_id = self._record_navigation(
conn, session_digest, "GET", "BEST_SELLERS", path, referer, 200, TARGET_ASIN, 2
)
epoch = int(conn.execute("SELECT value FROM meta WHERE key='reset_epoch'").fetchone()[0])
conn.execute(
"""
INSERT INTO task_progress(
session_digest,task_id,stage,best_sellers_event_id,reset_epoch,updated_at
) VALUES (?,?,?,?,?,?)
ON CONFLICT(session_digest) DO UPDATE SET
task_id=excluded.task_id,
stage='BEST_SELLERS_SEEN',
best_sellers_event_id=excluded.best_sellers_event_id,
pdp_event_id=NULL,
flow_capability_digest=NULL,
capability_consumed=0,
reset_epoch=excluded.reset_epoch,
updated_at=excluded.updated_at
""",
(session_digest, TASK_ID, "BEST_SELLERS_SEEN", event_id, epoch, self.now(conn)),
)
conn.commit()
def record_pdp(
self,
session_digest: str,
path: str,
referer: str,
capability_digest: str,
referer_is_canonical: bool | None = None,
) -> bool:
self.ensure_session(session_digest)
ref_path = urlparse(referer).path if referer else ""
canonical_source = ref_path == BEST_SELLERS_PATH if referer_is_canonical is None else referer_is_canonical
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
event_id = self._record_navigation(
conn, session_digest, "GET", "TARGET_PDP", path, referer, 200, TARGET_ASIN, None
)
progress = conn.execute(
"SELECT * FROM task_progress WHERE session_digest=?", (session_digest,)
).fetchone()
eligible = bool(
progress
and progress["stage"] == "BEST_SELLERS_SEEN"
and progress["capability_consumed"] == 0
and path == PDP_PATH
and canonical_source
)
if eligible:
conn.execute(
"""
UPDATE task_progress SET
stage='TARGET_PDP_SEEN',
pdp_event_id=?,
flow_capability_digest=?,
capability_consumed=0,
updated_at=?
WHERE session_digest=?
""",
(event_id, capability_digest, self.now(conn), session_digest),
)
conn.commit()
return eligible
def record_read_route(
self, session_digest: str, route_key: str, path: str, referer: str, status: int = 200
) -> None:
self.ensure_session(session_digest)
with self.connect() as conn:
# A page can issue several same-session reads concurrently (for
# example search suggestions while navigation is still loading).
# Reserve the writer before deriving the next sequence so the
# MAX(sequence)+1 read and insert remain one atomic operation.
conn.execute("BEGIN IMMEDIATE")
self._record_navigation(conn, session_digest, "GET", route_key, path, referer, status)
conn.commit()
def record_rejected_post(
self,
session_digest: str,
path: str,
media_type: str,
raw_body: bytes,
) -> None:
"""Journal a rejected boundary POST without retaining attacker data.
Rejected routes can carry passwords, one-time codes, or arbitrary
attacker-chosen bytes. Even hashing the original body would make a
six-digit code cheaply enumerable, so both persisted body fields use a
fixed sentinel. The route, media type, status, and outcome retain the
useful boundary audit signal.
"""
self.ensure_session(session_digest)
redacted = REDACTED_REJECTED_POST_BODY
with self.connect() as conn:
conn.execute(
"""
INSERT INTO request_journal(
session_digest,method,path,media_type,raw_body_sha256,
canonical_form,status,outcome,contract_id,created_at
) VALUES (?,?,?,?,?,?,?,?,?,?)
""",
(
session_digest,
"POST",
path,
media_type,
hashlib.sha256(redacted.encode("utf-8")).hexdigest(),
redacted,
404,
"rejected-nonterminal",
"amazon-public-boundary-v1",
self.now(conn),
),
)
def terminal_request(
self,
session_digest: str,
path: str,
media_type: str,
raw_body: bytes,
fields: list[tuple[str, str]],
capability_digest: str,
source_is_canonical: bool = True,
) -> tuple[int, str]:
self.ensure_session(session_digest)
expected_fields = [("ASIN", TARGET_ASIN), ("quantity", TARGET_QUANTITY)]
expected_body = (
f"ASIN={TARGET_ASIN}&quantity={TARGET_QUANTITY}".encode("ascii")
)
body_is_safe_terminal_contract = bool(
path in TERMINAL_PATHS
and media_type.lower() == "application/x-www-form-urlencoded"
and raw_body == expected_body
and fields == expected_fields
)
if body_is_safe_terminal_contract:
raw_sha = hashlib.sha256(raw_body).hexdigest()
canonical_form = (
f"ASIN={TARGET_ASIN}&quantity={TARGET_QUANTITY}"
)
else:
canonical_form = REDACTED_REJECTED_POST_BODY
raw_sha = hashlib.sha256(canonical_form.encode("utf-8")).hexdigest()
preliminary_error = None
if path not in TERMINAL_PATHS:
preliminary_error = "wrong-terminal-path"
elif media_type.lower() != "application/x-www-form-urlencoded":
preliminary_error = "wrong-media-type"
elif raw_body != expected_body:
preliminary_error = "wrong-form-body"
elif fields != expected_fields:
preliminary_error = "wrong-form-body"
elif not source_is_canonical:
preliminary_error = "invalid-terminal-source"
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
progress = conn.execute(
"SELECT * FROM task_progress WHERE session_digest=?", (session_digest,)
).fetchone()
latest_navigation = conn.execute(
"SELECT event_id FROM navigation_events WHERE session_digest=? ORDER BY sequence DESC LIMIT 1",
(session_digest,),
).fetchone()
error = preliminary_error
if error is None and not progress:
error = "missing-navigation-sequence"
elif error is None and progress["stage"] != "TARGET_PDP_SEEN":
error = "wrong-navigation-stage"
elif error is None and progress["capability_consumed"]:
error = "capability-already-consumed"
elif error is None and progress["flow_capability_digest"] != capability_digest:
error = "invalid-flow-capability"
elif error is None and (
latest_navigation is None or latest_navigation["event_id"] != progress["pdp_event_id"]
):
error = "stale-navigation-sequence"
cart_table, cart_owner_column, cart_owner_id = self._cart_line_owner(
conn, session_digest
)
target_options = self.default_product_options(TARGET_ASIN)
target_selection_key = canonical_selection_key(target_options)
existing = conn.execute(
f"SELECT quantity FROM {cart_table} "
f"WHERE {cart_owner_column}=? AND asin=? AND selection_key=?",
(cart_owner_id, TARGET_ASIN, target_selection_key),
).fetchone()
if error is None and existing:
error = "target-line-already-exists"
status = 303 if error is None else 409
outcome = "accepted" if error is None else error
cursor = conn.execute(
"""
INSERT INTO request_journal(
session_digest,method,path,media_type,raw_body_sha256,
canonical_form,status,outcome,contract_id,created_at
) VALUES (?,?,?,?,?,?,?,?,?,?)
""",
(
session_digest,
"POST",
path,
media_type,
raw_sha,
canonical_form,
status,
outcome,
"amazon-task-900136-terminal-v1",
self.now(conn),
),
)
request_id = int(cursor.lastrowid)
if error is None:
selection_json = json.dumps(
target_options,
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
)
conn.execute(
f"""
INSERT INTO {cart_table}(
line_id,{cart_owner_column},asin,quantity,selection_json,
selection_key,line_state
) VALUES (?,?,?,?,?,?,'ACTIVE')
""",
(
self._new_cart_line_id(),
cart_owner_id,
TARGET_ASIN,
int(TARGET_QUANTITY),
selection_json,
target_selection_key,
),
)
conn.execute(
"""
UPDATE task_progress SET
stage='COMPLETE', capability_consumed=1, updated_at=?
WHERE session_digest=?
""",
(self.now(conn), session_digest),
)
run_id = conn.execute("SELECT value FROM meta WHERE key='run_id'").fetchone()[0]
conn.execute(
"""
INSERT INTO task_completions(
run_id,session_digest,task_id,terminal_path,request_id,completed_at
) VALUES (?,?,?,?,?,?)
""",
(run_id, session_digest, TASK_ID, path, request_id, self.now(conn)),
)
conn.commit()
return status, outcome
def advance_clock(self, seconds: int) -> str:
if seconds < 0 or seconds > 31_536_000:
raise ContractError("clock advance is out of range")
from datetime import datetime, timedelta, timezone
with self.connect() as conn:
conn.execute("BEGIN IMMEDIATE")
current = self.now(conn).replace("Z", "+00:00")
value = datetime.fromisoformat(current).astimezone(timezone.utc) + timedelta(seconds=seconds)
result = value.isoformat().replace("+00:00", "Z")
conn.execute("UPDATE meta SET value=? WHERE key='controlled_now'", (result,))
conn.commit()
return result
def normalized_state(self) -> dict[str, Any]:
with self.connect() as conn:
meta = {row["key"]: row["value"] for row in conn.execute("SELECT key,value FROM meta")}
carts = [
dict(row)
for row in conn.execute(
"""
SELECT c.session_digest,p.asin,p.title,cl.quantity,
cl.selection_json,p.price_minor,p.currency,p.image_path
FROM carts c
JOIN cart_lines cl ON cl.cart_id=c.cart_id
JOIN commerce_offers p ON p.asin=cl.asin
WHERE cl.line_state='ACTIVE'
ORDER BY c.session_digest,p.asin,cl.selection_key,cl.line_id
"""
)
]
for cart in carts:
selected_options = self._stored_product_options(
str(cart["asin"]), cart.pop("selection_json", "{}")
)
self._apply_transaction_quote(cart, selected_options)
progress = [
dict(row)
for row in conn.execute(
"""
SELECT session_digest,task_id,stage,capability_consumed,reset_epoch
FROM task_progress ORDER BY session_digest
"""
)
]
completions = [
dict(row)
for row in conn.execute(
"""
SELECT run_id,session_digest,task_id,terminal_path,completed_at
FROM task_completions ORDER BY completion_id
"""
)
]
return {
"schema": "amazon-clone.state.v1",
"snapshot_id": meta.get("snapshot_id"),
"fixture_sha256": meta.get("fixture_sha256"),
"controlled_now": meta.get("controlled_now"),
"reset_epoch": int(meta.get("reset_epoch", "0")),
"carts": carts,
"task_progress": progress,
"task_completions": completions,
}
def journal(self) -> list[dict[str, Any]]:
with self.connect() as conn:
rows = conn.execute(
"""
SELECT request_id,session_digest,method,path,media_type,raw_body_sha256,
canonical_form,status,outcome,contract_id,created_at
FROM request_journal ORDER BY request_id
"""
).fetchall()
return [dict(row) for row in rows]