Personal Catalogue: React & Firebase — Chapter 6, Exercise 3
=====================================================================

TASK
Explain why this course's own search implementation is structurally
immune to both real crashes the MongoDB sibling's own Chapter 6 found
and fixed — the route-ordering bug and the unescaped-regex
SyntaxError — tying your answer directly back to the architecture
decision made in Chapter 3.

SOLUTION

Both of the MongoDB sibling's own crashes depended on two specific
ingredients this course simply doesn't have, precisely because of the
real architecture decision made in Chapter 3: no backend server of
this course's own at all, with React talking to Firestore directly.

The route-ordering bug needed an Express router with registered path
segments — /search being shadowed by an earlier /:id registration is a
problem that can only exist where URL paths are matched against a
list of route definitions in a specific order. This course has no such
router. searchItems() is a plain JavaScript function called directly
from a React component; there's no URL path for it at all, and
therefore no ordering for one route registration to accidentally
shadow another.

The unescaped-regex crash needed a raw RegExp being constructed from
user input, where a stray character like an unmatched parenthesis is
invalid regex syntax. searchItems() never constructs a RegExp
anywhere — it compares strings with the plain .toLowerCase().includes()
method, which treats every character in the search term as ordinary
text with no special meaning at all. A parenthesis, a plus sign, a
dollar sign — none of them mean anything different to .includes() than
any other character, so there's no possible input that could make it
throw a syntax error.

Both bugs, in other words, aren't bugs that got fixed in this course —
they're bugs that never had anywhere to happen, because the specific
mechanisms that caused them (a path-based router, a hand-built regex)
were never part of this course's own design in the first place. That's
a genuine, structural difference in what kind of code exists here, not
luck or extra care taken while writing it.

WHY THIS WORKS AS AN ANSWER
----------------------------
It traces both bugs back to their real, specific root mechanism (route
registration order; regex syntax validity) and shows precisely why
neither mechanism exists in this course's own code, rather than a
vague "Firestore doesn't have that problem" claim — and it correctly
frames the immunity as structural, following directly from Chapter 3's
own architecture decision, rather than as a fix applied after the fact.