Saleor Core: the high performance, composable, headless commerce API.
Saleor
Deployment model (read this first)
Saleor is deployed for horizontal scale-out: many identical Kubernetes pods (web + Celery workers) run concurrently behind a load balancer, against a shared Postgres (with read replicas) and shared Redis/broker. Any given request or task may land on any pod, and the same code runs in many processes at once. Write code with that in mind:
- No in-process/local state as source of truth. Never rely on module globals, in-memory caches, or a value set by a previous request being present on the next one — the next call hits a different pod. Shared state lives in Postgres and Valkey or Redis.
- Assume every operation runs concurrently with itself. Use atomic DB operations
(
F(),update_or_create,select_for_update) instead of check-then-act — see Concurrency and Thread Safety below. - Never block a request/worker thread. No
time.sleep()and no unboundedwhile Trueretry loops in request-handling code — a blocked thread wastes a finite pod worker slot. Use bounded retries and background tasks. - Schedule background work after the transaction commits. Use
on_commit/call_event(not a bare.delay()inside an open transaction) so a task can't run on another pod before the row it needs is committed. - Protect the shared database. It is the scaling bottleneck: avoid N+1 queries and per-row writes
in loops (bulk instead), keep
select_for_updatetransactions short, fetch only the columns you need, and don't add per-request queries to hot paths — reuse dataloaders. - Make tasks idempotent and safe to retry — the broker may deliver a task more than once, and pods can be killed/rescheduled mid-run.
Multi-tenancy: never rely on settings.SITE_ID
A deployment may serve several sites from one process, and SITE_ID may be unset or differ from
what a dev environment has. Never read it directly to identify the current site, and never assume
there is only one.
- Resolve the site with
Site.objects.get_current()(or theget_site_promisedataloader in the GraphQL layer). Both pick the site bySITE_IDwhen it is configured and fall back to the request host when it is not —settings.SITE_IDalone silently collapses every tenant into one. - Key anything per-site by the resolved site, not by a constant. A cache key, module-level dict or query filter that bakes in a single site lets one tenant read another's data.
- Don't assume a single row.
Site.objects.get()breaks as soon as a second site exists; filter by the resolved site instead.
Site.objects.get_current() reads the patched process-global THREADED_SITE_CACHE
(saleor/site/patch_sites.py), which is never invalidated by Site/SiteSettings saves. So a value
read through it can be stale after a write in the same process — see Writing tests for what that
means for assertions.
Graphql
API versioning
Check last git tag to find what version we are branched from (e.g. 3.22 tag). Based on that, add description to new fields with ADDED_IN_{VERSION} clause. Use the version the change actually ships in — for a backport, that is the backport's version, not the one on
main.Import the constant from
saleor/graphql/core/descriptions.pyand concatenate it onto the description. Add a new constant there if the target version has none yet.For a new type, annotate only the type-level
Meta.description. Its fields are covered by the type's own annotation, so leave them unstamped:class TransactionEventFilterInput(BaseInputObjectType): created_at = DateTimeRangeInput( description="Filter transaction events by created at date.", ) class Meta: doc_category = DOC_CATEGORY_PAYMENTS description = "Filter input for transaction events data." + ADDED_IN_323Annotate an individual field only when it is added to a type that already exists. That is the case where the field's version genuinely differs from its type's.
Do not stamp a pre-existing field just because you changed its behavior. ADDED_IN marks new schema surface, not modifications.
Regenerate
saleor/graphql/schema.graphqlafterwards and commit it — the annotation is part of the public schema's description text, and a stale schema file fails CI.
GraphQL permissions
- Use PermissionsField to describe field restrictions
Architecture
- Do not use Django signals (e.g.
post_save,pre_delete,@receiver). Call the relevant logic explicitly from the code that triggers it instead of wiring it through signal handlers. (The one exception is thepost_migratesignal used to trigger data-migration tasks — see Data Migrations below.)
Code style
- Use global import statements. Place all imports at the top of the file rather than inside functions, methods, or other local scopes.
Testing
Running in a git worktree
When Saleor is checked out in a git worktree, prefer running operations (tests, management commands, etc.) inside that worktree's containers rather than on the host machine. The host's services may belong to a different worktree, so running directly on the host can hit the wrong database/cache or collide with another worktree's stack.
- Use the
.worktree-container/compose.shwrapper, which targets the current worktree's isolated stack. Run commands inside thesaleorservice, e.g.:.worktree-container/compose.sh up -d # start this worktree's stack .worktree-container/compose.sh exec saleor pytest --reuse-db saleor/path/to/test_file.py .worktree-container/compose.sh exec saleor python manage.py migrate - Do not run these operations directly on the host machine when working in a worktree.
Running tests
- Run tests using
pytest - Attach
--reuse-dbargument to speed up tests by reusing the test database - Select tests to run by passing test file path as an argument
- Inside the dev container, dependencies are installed system-wide, so run
pytestdirectly — no virtual environment to activate - On the host (outside the container), enter the virtual environment before executing tests
Writing tests
- Use given/when/then structure for clarity
- Use
pytestfixtures for setup and teardown - Declare test suites flat in file. Do not wrapp in classes
- Prefer using fixtures over mocking. Fixtures are usually within directory "tests/fixtures" and are functions decorated with
@pytest.fixture - When you create an object for testing and fixture for it doesn't exist, create new one. You can use factory to pass arguments to the fixture.
- When writing assertions, prefer assertion on actual returned value instead of checking if it's not none. For example:
assert email is "[email protected]instead ifassert email is not None - When asserting GraphQL errors, assert error message too
- When asserting to Enum, import enum in a test file and use
assert error.code == MyEnum.SOME_ERROR.nameinstead plain string comparison - Avoid assertion to plain values, if you already have references to existing value. For example, when you create entity in database and assert if entity is returned in response, compare response fields with entity fields, instead plain values.
- When building GraphQL query variables, use enum values instead of plain strings. For example:
{"field": TransactionSortField.CREATED_AT.name}instead of{"field": "CREATED_AT"} - Do not write unnecessary prefix to test names. If file name is
test_my_mutation.py, do not writetest_my_mutation_with_x_ybuttest_with_x_y - When testing graphQL cases with expected errors ALWAYS assert expected length of errors list
- When setting up test data, extract values into variables and reuse them in assertions. Do not repeat literal values between setup and assertion — use the variable instead.
- When comparing JSON payloads in tests, use
json.loads()to compare dicts instead of comparing serialized strings withjson.dumps(). String comparison breaks when key order changes. - When a test expects exactly one row, use
Model.objects.get()instead of.first()followed by anis not Noneassertion.get()both fetches the object and asserts that exactly one exists, so drop the separate not-None check. - For presence/absence checks prefer
qs.exists()overqs.count() == 0/!= 0.exists()is cheaper than aCOUNT. Example:assert checkout.lines.exists() is False. - Use
@pytest.mark.parametrizefor variations of the same scenario instead of copy/pasting near-identical test bodies. Label each case with a leading_casestring parameter rather than theids=argument — it keeps the description next to the data and is easier to read and edit:@pytest.mark.parametrize( ("_case", "value"), [ ("omitted", {}), ("empty_list", {"lines": []}), ], ) def test_something(_case, value): ... - When a mutation input is optional/nullable, test the explicit
nullvalue in addition to omitting the field — they are distinct inputs and can be handled differently. - Never assume a cache is cold — or warm. Caches are process-global and survive across tests, so
what warmed them depends on test ordering. To assert a write landed, read the row back
(
obj.refresh_from_db(fields=(...))) rather than through a cached accessor likeSite.objects.get_current(); to count queries, warm the cache first so the count is the steady state; otherwise bust it explicitly (Site.objects.clear_cache()). A test that passes only because a cache happened to be empty will fail as soon as an unrelated caller warms it.
Assert precisely (the #1 source of review comments)
- Assert exact values and counts, never bounds or mere absence. No
len(x) > 0,>= 1,assert not errors, orcall_count >= 1— assert the exact count, enum, or object so unexpected extra results are caught. When one error is expected, assert exactly one, its full message, and itspath/field. - On negative / permission-denied tests, also assert the side effect did NOT happen — balance
unchanged,
SomeEvent.objects.exists() is False, the object left unmutated. An error assertion alone doesn't prove the action was blocked. - Never assert a value the test itself just set and saved — that verifies the ORM, not the code under test. Set state or assert it, not both.
- Never assert a mutable input against itself after passing it to code that may mutate it — the
comparison can never fail. Design the test so the expected value is independent of the input (build
it from literals/a separate fixture). Reach for
copy.deepcopyonly as a last resort when there is a real mutation risk and no cleaner option — it is expensive (it pickles) and does not scale to a large suite. - Prefer real fixtures/tokens over mocking internals. Generate a genuinely valid/invalid token
(e.g. via the real
create_access_token*factories or pyjwt) rather than mockingget_decoded_tokento return a canned payload — otherwise real breakage isn't caught. - A fix must ship with a regression test that reproduces the actual reported bug end-to-end and targets the field/path that actually failed — not just the new helper's happy path.
- Encode preconditions as assertions, not comments (
assert flag is Truebefore exercising it), so the test fails fast if a default changes. - Use
Model.objects.get()when exactly one row is expected (it asserts uniqueness) instead of.first()+ a not-None check, andqs.exists()instead ofqs.count() == 0. - Don't hardcode a "nonexistent" primary key (e.g.
99999) —--reuse-dbcan reassign it. Use a negative id such as-1; Postgres has no unsigned integer types, so it can never match a real row (and it avoids the extramax(pk)query). - Use reserved test domains (
example.com,*.test) for any URL in a test, never a real one. - For IPs, use network addresses so they cannot reach an actual server, e.g.,
8.8.8.0or1.1.1.0 - Parametrize near-identical test bodies; keep each test minimal (drop unrelated setup); name tests for the exact behavior asserted (no double negatives).
GraphQL Authorization Tests
When should authorization tests be written?
- When adding a new restricted field
- When adding a new restricted type
- When adding a new restricted mutation or query
- When adding a new public mutation or query - this ensures we are explicit when we expect a new query or mutation to not require any authorization
When writing authorization tests do the ALL of the following:
Test against all client types:
- Unauthenticated
- Unprivileged user (non-staff user)
- Staff user with the missing permission(s)
- Staff user with the correct permission
Use parametrized tests, do not create separate tests
Never solely rely on the error message to determine whether access was denied as this could still have returned the restricted data or have performed the operations. Therefore:
- Always ensure the restricted data is not returned in the HTTP response
- Always ensure the data was not modified if it is GraphQL mutation
- Always ensure external calls (webhooks, API calls, emails, etc.) were not triggered if this is a GraphQL mutation.
Example:
@pytest.mark.parametrize(
("_case", "client_fixture", "permission_fixture", "is_allowed"),
[
(
"Unauthenticated user should be rejected",
"api_client",
None,
False,
),
(
"Authenticated unprivileged user (non-staff) should be rejected",
"user_api_client",
None,
False,
),
(
"Authenticated user w/o the permission should be rejected",
"staff_api_client",
None,
False,
),
(
"Authenticated user w/ the correct permission should be allowed",
"staff_api_client",
"permission_manage_settings",
True,
),
]
)
def test_authorization(
request, client_fixture: str, permission_fixture: str | None, is_allowed: bool,
):
client = request.getfixturevalue(client_fixture)
if permission_fixture:
perm = request.getfixturevalue(permission_fixture)
if client.app:
client.app.permissions.add(perm)
elif client.user:
client.user.user_permissions.add(perm)
else:
raise AssertionError("Couldn't add the permission") # shouldn't occur
response = client.post_graphql(query, variables)
if is_allowed:
content = get_graphql_content(response)
assert content["data"] == ...
else:
assert_no_permission(response)
content = get_graphql_content_from_response(response)
assert content["data"] == ...
Code structure and layering
Keep business logic in the domain layer; GraphQL mutations do input validation and orchestration only. How a token is built/stripped, how a balance changes, etc. belongs in the domain module, not in the mutation.
Non-GraphQL code must never import from the
graphqllayer. If a domain-layer task or model needs a helper, move that helper into the domain module and import it from the GraphQL layer — never the reverse.Validate at the point data is produced (fail-fast), and clean a sub-entity inside the same clean step that owns its parent — don't split one entity's cleaning across separate stages.
Pass the narrow value a function actually needs (a single flag or an already-fetched setting), not a broad
info/SiteSettingscontext object it has to dig into. A wide parameter hides the real dependency and forces callers to re-thread context.Prefer typed structures (
dataclass/NamedTuple) over ad-hocdictgrab-bags, and keep a function's return shape homogeneous (don't mix heterogeneous entities in one list).Extract branchy or long logic into a named helper instead of narrating a ~100-line function with comments. Run short-circuit / global checks first, before fetching data.
Remove code a refactor made dead (unused validators, unreachable guards added only to satisfy mypy). Fix the type at its source instead of adding a
cast()around a wrong upstream annotation.Never import
saleor.core.development.*module(s) outside tests, or outside non-development-only logics.This can only be used in such locations:
./manage.py populatedb(development only command, requiresuv sync --group dev)- pytest (
test_*.py,conftest.py,tests/**) - Any other development-only helpers or locations
Naming
- No cryptic abbreviations (
gc_brand→gift_card_brand); align a new field's name to the analogous existing field. - Use positive boolean names —
delivery_changed, notnot delivery_unchanged. - Prefix any flag or field that gates deprecated behavior with
legacy_so the deprecation is obvious from the name alone. - Name things for what they return/mean and the correct domain, not an incidental call site, and don't
bake a format assumption into a name (
last_digitswhen a code may contain letters →last_chars).
Error handling
- Catch the specific exception, never a bare
ExceptionorDatabaseError. Catch the whole provider family when needed (BotoCoreErrorandClientError;GoogleAPIErrorfor 4xx and 5xx) and the narrowest DB exception that fits (OperationalError, not the base class). - Distinguish retryable failures (network errors, HTTP 5xx) from terminal ones (4xx, bad data,
ValueError) — never retry what can't self-recover; return/abort terminal cases immediately so invalid work drains fast. Check an HTTP response's status code before reading its body, and always pass an explicit timeout to outbound network calls. - Error messages must state the actual cause ("not found" vs "wrong type"), be attributed to the specific line/field for list inputs, and use generic (non-field) errors for config/store-level failures. Propagate the original caught message rather than rewriting it.
- Validate referenced GraphQL IDs and return a clean error — don't let a bad/nonexistent id surface a cryptic "Cannot return null for non-nullable field" crash.
Webhooks and Events
Dispatching webhook events
When triggering plugin manager methods to dispatch webhook events, always use call_event from saleor.core.utils.events instead of calling the manager method directly.
Bad:
manager.product_variant_discounted_price_updated(price_info, webhooks=webhooks)
Good:
from saleor.core.utils.events import call_event
call_event(manager.product_variant_discounted_price_updated, price_info, webhooks=webhooks)
Concurrency and Thread Safety
Saleor runs across many Python services that execute concurrently. Follow these patterns to ensure thread-safe code.
Atomic Increment Pattern
Never use instance.count += 1; instance.save() - this is NOT atomic and causes lost updates.
Bad:
existing.count += 1
existing.save(update_fields=["count"])
Good - use F() expressions:
from django.db.models import F
Model.objects.filter(pk=existing.pk).update(count=F("count") + 1)
Avoid Check-Then-Act Race Conditions
Never check if a record exists and then create/update it in separate operations.
Bad:
existing = Model.objects.filter(app=app, key=key).first()
if not existing:
Model.objects.create(app=app, key=key, ...) # Race condition: duplicate may be created
else:
existing.update(...)
Good - use update_or_create with unique constraint:
obj, created = Model.objects.update_or_create(
app=app, key=key, # Lookup fields
defaults={"message": message, "updated_at": now} # Fields to update
)
Note: update_or_create requires a unique constraint on the lookup fields to be truly safe.
Row-Level Locking with select_for_update
For complex operations requiring multiple reads/writes on the same row, use select_for_update:
from saleor.core.tracing import traced_atomic_transaction
with traced_atomic_transaction():
obj = Model.objects.select_for_update().get(pk=pk)
# Perform operations - row is locked until transaction ends
obj.save()
Pattern: Create lock_objects.py modules (like saleor/payment/lock_objects.py):
def my_model_qs_select_for_update() -> QuerySet[MyModel]:
return MyModel.objects.order_by("pk").select_for_update(of=["self"])
select_for_update pitfalls
Querysets are lazy - an unevaluated lock queryset runs no SQL, so no lock is taken and it fails silently. Force evaluation inside the transaction with
list(...),.get()/.first(), or use it as an__insubquery of the write.with transaction.atomic(): # Bad: lazy - no lock _locked = model_qs_select_for_update().filter(pk__in=pks) # Good: rows locked, only pks fetched _locked = list( model_qs_select_for_update().filter(pk__in=pks).values_list("pk", flat=True) ) Model.objects.bulk_update(objs, ["field"])Test the lock with the
assert_locks_rows_before_writefixture (saleor/tests/fixtures.py) - it captures the block's queries and asserts an orderedFOR UPDATEquery is emitted before theUPDATE.
Database Transactions
Wrap related operations in transactions using traced_atomic_transaction:
from saleor.core.tracing import traced_atomic_transaction
with traced_atomic_transaction():
# All operations here are atomic
obj1.save()
obj2.save()
Schedule background work after commit
Never schedule a Celery task with a bare .delay() inside an open transaction — the task can start on
another pod before the transaction commits and fail on data it can't see yet. Schedule via on_commit
(or call_event, which does this for webhook events) so the task only fires after the commit:
from django.db.transaction import on_commit
with traced_atomic_transaction():
obj.save()
on_commit(lambda: my_task.delay(obj.pk))
Wrap multi-write / read-modify-write operations in a transaction so they are all-or-nothing, and emit a state-change event inside the same transaction as the change.
Never block a request/worker thread
No time.sleep() and no unbounded while True retry loops in request-handling or worker code — a
blocked thread wastes one of the pod's finite worker slots. Use bounded for attempt in range(n)
retries and offload waiting to background tasks.
Other concurrency rules
- Scope
allow_writer()to the exact statement that needs it (with allow_writer(): ...), not the whole task/function. - Re-establish the DB/writer context inside every Promise
.then()callback — it runs after the previous context has exited (like async), so a writer/context opened before.then()is gone inside it. - Never gate a blocking
Queue.get()on a separateempty()/non-empty check across threads — the last item can be drained between the check and the get, hanging the consumer. Use a non-blocking get or a sentinel. - Route heavyweight fan-out tasks (large downloads, thousands of objects) to a dedicated, bounded queue so a single bulk mutation can't starve workers or OOM a pod.
Summary of Patterns Used in Saleor
| Pattern | Module Example | When to Use |
|---|---|---|
F() atomic increment |
saleor/discount/utils/voucher.py:85 |
Counter updates |
select_for_update |
saleor/payment/lock_objects.py |
Complex read-modify-write |
update_or_create |
saleor/graphql/attribute/utils/type_handlers.py |
Upsert operations |
traced_atomic_transaction |
saleor/core/tracing.py |
Multi-operation atomicity |
on_commit task scheduling |
Any mutation that dispatches a task | Fire task only after commit |
Data Migrations
Marking search indexes as dirty
When adding or changing search vector indexing logic, create a data migration that marks all existing rows as dirty so they get re-indexed.
Structure
- Task file — place in
saleor/<app>/migrations/tasks/saleor<version>.py - Migration file — place in
saleor/<app>/migrations/<number>_<name>.py
Task rules
- Decorate with
@app.task(queue=settings.DATA_MIGRATIONS_TASKS_QUEUE_NAME)and@allow_writer() - Process in batches (e.g. 1000 rows) to avoid long-running transactions
- Use
select_for_updatevia the app'slock_objectsmodule to lock rows before updating - Use the subquery pattern: lock rows first, then filter+update in a separate query:
with transaction.atomic(): pks = ( model_qs_select_for_update() .filter(pk__in=batch_pks) .values_list("pk", flat=True) ) Model.objects.filter(pk__in=pks).update(search_index_dirty=True) - Self-chain with
.delay()at the end if there are more rows to process - Stop chaining when the batch returns no results
Migration rules
- Use
post_migratesignal to trigger the celery task after all migrations complete (not inline) - Connect to
post_migrateinside aRunPythonoperation - Use
registry.get_app_config("<app>")as the sender - Always provide
migrations.RunPython.noopas the reverse operation
Reference example
- Task:
saleor/giftcard/migrations/tasks/saleor3_22.py - Migration:
saleor/giftcard/migrations/0023_mark_gift_cards_search_vector_as_dirty.py
Adding indexes / unique constraints concurrently
Building an index synchronously (the default AddIndex / AddConstraint) takes
an ACCESS EXCLUSIVE lock on the whole table for the duration of the build,
blocking reads and writes. On a large table this can mean significant downtime.
Build the index CONCURRENTLY instead so it does not block concurrent traffic.
Rules
CREATE INDEX CONCURRENTLYcannot run inside a transaction, so the migration that creates it must setatomic = False.- Keep the concurrent index in its own migration. Fast, atomic schema
changes (
AddField,CheckConstraint, etc.) stay in a normalatomic = Truemigration; only the slow, non-atomic index build lives on its own. This keeps most schema changes transactional and limits the blast radius if the concurrent build fails and has to be retried. - To back a
UniqueConstraintwith a concurrently-built index, wrap the raw SQL inSeparateDatabaseAndState:database_operationscreate the indexCONCURRENTLYand attach it viaALTER TABLE ... ADD CONSTRAINT ... UNIQUE USING INDEX, whilestate_operationshold the matchingAddConstraint(UniqueConstraint(...))so Django's model state stays in sync. - Always provide
reverse_sql(useDROP INDEX CONCURRENTLY IF EXISTS/DROP CONSTRAINT IF EXISTS).
Reference example
saleor/page/migrations/0030_slug_translation_unique_constraint.pysaleor/app/migrations/0040_appextension_identifier_unique_constraint.py(split out of the atomic0039_appextension_identifier_and_more.py)
Code style
Correctness (Django): use pk instead of id
Don't use the id DB field in Django models, instead use pk when referencing the object ID
field from a model.
Don't:
book = Book.objects.get(id=1)
id = book.id
Do:
book = Book.objects.get(pk=1)
id = book.pk
Prefer docstrings over comments
When describing behavior prefer to use docstring over a comment:
Not:
def foo():
# Comment
# instead of
# docstring
Do:
def foo():
"""Doc string"""
Agent skills
Issue tracker
Issue tracking is opted out — skills must not create issues, PRDs, or triage records anywhere, and should treat "publish to the issue tracker" steps as not applicable. See docs/agents/issue-tracker.md.
Triage labels
Not applicable — there is no issue queue, so the triage state machine and label vocabulary are unused. See docs/agents/issue-tracker.md.
Domain docs
Single-context: one CONTEXT.md + docs/adr/ at the repo root. See docs/agents/domain.md.
Performance
Avoid unnecessarely broad
Model.save()calls and unnecessarely broadModel.refresh_from_db(). Instead, use tuples that select specific DB fields, e.g.,invoice.refresh_from_db(fields=("id",)), orinvoice.save(update_fields=("number",))Avoid iterating over the same objects multiple times (meaning multiple O(N) operations)
Don't:
assigned_ids = [giftcard.pk for giftcards in assigned_cards] deactivated_ids = [giftcard.pk for giftcards in assigned_cards if giftcard.active]Do:
assigned_ids = [] deactivated_ids = [] for giftcard in giftcards: assigned_ids.append(giftcard.pk) if giftcard.active is True: deactivated_ids.append(giftcard.pk)
Database access
The shared Postgres is the scaling bottleneck — every pod hits it. Keep queries cheap and few.
- No per-row query in a loop (N+1). Build a dict keyed by the join fields for O(1) lookups, or do a
single aggregate /
filter(...).exists()across all rows. - Bulk
queryset.update()/.delete()instead of saving/deleting per row, and.iterator()instead oflist()on an unbounded queryset. - Fetch only the columns you need (
.values(...)/.values_list("pk", flat=True)), not full model instances, when that's all you use. - Use
qs.exists()overqs.count() == 0. - Don't add per-request DB queries to hot paths (auth, resolvers) — reuse dataloaders. Don't bypass a dataloader to "get the latest" value; the data is replica-delayed anyway, so the extra query buys no real consistency.
- Keep
select_for_updatetransactions short (nolist()of unbounded sets or per-row queries while holding the lock). Don't persist rows purely for debugging/observability — log instead (writes replicate to every read replica).
Data minimization
- Don't denormalize user PII (email, etc.) into other tables or event params — store only the
reference id. Register any new user-referencing/PII field with the anonymizer app, and ensure PII is
deleted with the user (
on_delete=PROTECT+ deactivate, notSET_NULLthat leaves orphaned data).
File Uploads & File Downloads
- Treat any downloaded file or URL as untrusted:
Content-Typeheaders are spoofable (confirm the real type from magic bytes), enforce an allowed-format allowlist (reject SVG and other executable/vector formats), enforce a maximum size, and check the HTTP status before reading the body. - Verify the file extension matches the detected file type
See saleor/graphql/core/validators/file.py for how to properly validate files.