
وقتی کلمههای Stateful و Stateless رو میشنویم، ذهن خیلی از ما اول سمت Backend میره.
Stateless API.
Sticky Session.
Redis.
Horizontal Scaling.
اما همین مفهوم در Frontend هم خیلی مهمه؛ مخصوصاً وقتی محصول از چند صفحه و چند API Call ساده بزرگتر میشه.
فرض کنید یک اپلیکیشن سفارش غذا مثل اسنپفود رو باز کردید.
آدرس رو انتخاب میکنید. دنبال یک رستوران میگردید. Filter اعمال میکنید. منو رو باز میکنید. یک غذا به سبد خرید اضافه میکنید. تعدادش رو تغییر میدید. یادداشت سفارش مینویسید. وارد Checkout میشید و بعد دوباره به صفحه قبل برمیگردید.
هرکدوم از این Interactionها چیزی رو تغییر میدن.
سؤال سخت این نیست که آیا این اپلیکیشن State داره یا نه. مشخصه که داره.
سؤال سختتر اینه:
مالک هر State کیه، این State چقدر باید زنده بمونه و Source of Truth اون دقیقاً کجاست؟
اینجاست که Stateful و Stateless بودن از یک بحث ساده در React تبدیل میشه به یک تصمیم معماری.
در این مقاله میخوام یک معماری سادهشده برای Frontend یک محصول شبیه اسنپفود بسازم و این تصمیمها رو قدمبهقدم بگیریم.
این مثال کاملاً آموزشی است و معماری داخلی واقعی اسنپفود یا هیچ پیادهسازی اختصاصی دیگهای رو نمایش نمیده. هدف اینه که یک مدل واقعی و بهاندازه کافی پیچیده داشته باشیم تا Trade-offها دیده بشن.
یک سیستم Stateful است وقتی رفتار فعلیش به اطلاعاتی وابسته باشه که از Interactionهای قبلی نگه داشته شده.
یک سیستم Stateless است وقتی بتونه ورودی فعلی رو بدون اینکه چیزی از Interactionهای قبلی داخل خودش به خاطر سپرده باشه پردازش کنه.
این دو تابع رو در نظر بگیرید:
function calculateTotal(items: BasketItem[]) { return items.reduce( (total, item) => total + item.price * item.quantity, 0, ); }
و:
class BasketManager { private items: BasketItem[] = []; add(item: BasketItem) { this.items.push(item); } getTotal() { return calculateTotal(this.items); } }
تابع اول Stateless است.
اگر ورودی یکسانی بهش بدیم، خروجی یکسانی میگیریم. این تابع چیزی از Call قبلی به خاطر نمی سپره.
اما Object دوم Stateful است.
نتیجه getTotal به تمام اتفاق هایی وابسته است که قبل از صدا زدنش افتاده.
هیچکدوم از این دو مدل ذاتاً بهتر از اون یکی نیست.
دارن مسئله های متفاوتی رو حل میکنن.
خود HTTP یک پروتکل Stateless است. یک Request به شکل خودکار چیزی درباره Request قبلی نمیدونه.
برای همینه که معمولاً هر Request باید اطلاعات کافی برای پردازش مستقل رو همراه خودش داشته باشه:
POST /baskets/basket-42/items Authorization: Bearer <token> Content-Type: application/json { "foodId": "food-10", "quantity": 1 }
سرور میتونه Request رو Authenticate کنه، Basket رو پیدا کنه، Command رو Validate کنه و Response بده؛ بدون اینکه به اطلاعات باقی مونده در Memory یک Instance خاص وابسته باشه.
این موضوع Horizontal Scaling رو راحت تر میکنه:
Request 1 → API instance A Request 2 → API instance C Request 3 → API instance B
هر Instance سالمی باید بتونه Request بعدی رو پردازش کنه.
ولی اینجا یک تفاوت مهم وجود داره:
Stateless بودن API به معنی Stateless بودن Business Domain نیست.
سبد خرید قطعاً State داره.
Orderها State دارن.
Userها State دارن.
Payment Attemptها هم State دارن.
تفاوت در اینه که این State داخل یک Owner مشخص و پایدار مثل Database یا Redis ذخیره میشه؛ نه داخل Memory یک API Instance تصادفی.
Stateless API process → Stateful database
همین تفاوت وقتی وارد Frontend میشیم خیلی به کارمون میاد.
یک اپلیکیشن Frontend واقعی به اتفاقهایی که قبلاً افتاده واکنش نشون میده.
کاربر Modal رو باز کرده.
یک آدرس انتخاب کرده.
یک Search Query نوشته.
دو غذا به سبد خرید اضافه کرده.
اگر State نداشته باشیم، نتیجه هر Interaction بلافاصله از بین میره.
پس هدف ما حذف State از Frontend نیست.
هدف اینه که اجازه ندیم State همهجای سیستم پخش بشه.
خود State مشکل نیست؛ Stateای که Owner مشخص نداره مشکل است.
معماریای که من ترجیح میدم اینه که تا جای ممکن Rendering، Transformation، Validation و Transport رو Stateless نگه داریم و State رو داخل تعداد محدودی Owner مشخص قرار بدیم.

محصول سادهشده ما این Flowها رو داره:
انتخاب آدرس تحویل؛
جستوجو و Filter کردن رستورانها؛
بازکردن منوی رستوران؛
اضافهکردن غذا به سبد خرید؛
جایگزینکردن سبد هنگام تغییر رستوران؛
تغییر تعداد آیتمها؛
و تکمیل Checkout.
در مثالها از React و TypeScript استفاده میکنیم. برای Server State سراغ TanStack Query میریم و فقط جایی که واقعاً یک Client State مشترک داریم از یک Store کوچک استفاده میکنیم.
خود Libraryها موضوع اصلی مقاله نیستن.
موضوع اصلی Boundaryهای Ownership است.
در سطح Repository میتونیم از یک ساختار شبیه این شروع کنیم:
apps/ customer-web/ vendor-panel/ support-panel/ packages/ features/ restaurant-search/ restaurant-menu/ basket/ checkout/ entities/ restaurant/ food/ basket/ order/ shared/ ui/ api/ validation/ formatting/ config/
این ساختار یک Modular Monorepo است؛ نه لزوماً یک معماری Microfrontend.
Packageها به ما Ownership و Dependency Boundary میدن، ولی مجبورمون نمیکنن هر Feature رو جداگانه Deploy کنیم.
این تفاوت مهمه، چون Organizational Boundary و Runtime Boundary یک تصمیم واحد نیستن.
از یک Food Card شروع کنیم:
type FoodCardProps = { name: string; imageUrl: string; price: number; available: boolean; quantityInBasket: number; onAdd: () => void; }; export function FoodCard({ name, imageUrl, price, available, quantityInBasket, onAdd, }: FoodCardProps) { return ( <article> <img src={imageUrl} alt="" /> <h3>{name}</h3> <Price value={price} /> {quantityInBasket > 0 && ( <span>{quantityInBasket} in basket</span> )} <button disabled={!available} ={onAdd}> Add </button> </article> ); }
کامپوننت FoodCard منو رو Fetch نمیکنه.
Basket Store رو Import نمیکنه.
نمیدونه کاربر Login کرده یا نه.
فقط Data میگیره و Event بیرون میده.
به شکل مفهومی:
UI = render(props)
این باعث میشه کامپوننت رو بتونیم در منوی رستوران، Search Result، Recommendation و بخشهای Promotional دوباره استفاده کنیم.
Test کردنش هم خیلی کوچکتر میشه:
it("disables Add when the food is unavailable", () => { render( <FoodCard name="Pizza" imageUrl="/pizza.jpg" price={250_000} available={false} quantityInBasket={0} onAdd={() => {}} />, ); expect(screen.getByRole("button", { name: "Add" })) .toBeDisabled(); });
Router نمیخوایم.
API Mock نمیخوایم.
لازم نیست برای هر Test کل Global Store رو Setup کنیم.
این یکی از مزیتهای عملی Stateless Design است: تعداد Historyهایی که برای بازسازی یک رفتار نیاز داریم کمتر میشه.
حالا باید با Basket Backend ارتباط بگیریم:
export type AddBasketItemCommand = { basketId: string; foodId: string; quantity: number; // Used only to build the temporary optimistic snapshot. optimisticPrice: number; }; export const basketApi = { get(basketId: string) { return http.get<Basket>(`/baskets/${basketId}`); }, addItem(command: AddBasketItemCommand) { return http.post<Basket>( `/baskets/${command.basketId}/items`, { foodId: command.foodId, quantity: command.quantity, }, ); }, };
این Module یک Command مشخص میگیره و Result برمیگردونه.
نباید Current Basket رو به شکل مخفی داخل خودش نگه داره:
// Avoid this mixed responsibility. class BasketService { currentBasket?: Basket; async load(basketId: string) { this.currentBasket = await http.get(`/baskets/${basketId}`); } }
مدل دوم حداقل سه مسئولیت رو با هم ترکیب کرده:
HTTP Transport؛
Cache؛
Client State Ownership.
حالا هر Consumer باید بدونه currentBasket چه زمانی Load شده، آیا Stale شده و چه کسی اجازه داره تغییرش بده.
اینکه اسم چیزی رو Service بذاریم باعث نمیشه مسئولیتهای مختلفش ناپدید بشن.
منوی رستوران، قیمت فعلی، موجودبودن غذا، سبد خرید و Orderها متعلق به Server هستن.
مرورگر فقط یک Snapshot موقت از اونها داره.
این Snapshot یک Lifecycle داره:
loading → fresh → stale → refetching → fresh ↘ error
این جنس از State با State سادهای مثل باز یا بسته بودن Dialog فرق داره.
برای Basket میتونیم Ownership رو شفاف کنیم:
export const basketKeys = { all: ["basket"] as const, detail: (basketId: string) => [...basketKeys.all, basketId] as const, }; export function useBasket(basketId: string) { return useQuery({ queryKey: basketKeys.detail(basketId), queryFn: () => basketApi.get(basketId), staleTime: 15_000, }); }
TanStack Query مالک Cache داخل Browser است.
اما Backend همچنان مالک Canonical Basket است.
این جمله مهمه، چون Cache خودش Stateful است؛ ولی لزوماً Source of Truth نیست.
اگر یک Tab دیگه، یک Device دیگه یا یک Process در Backend سبد رو تغییر بده، مقدار Cacheشده ما میتونه Stale بشه. معماری باید از اول انتظار این اتفاق رو داشته باشه.
فرض کنید Basket ما چنین شکلی داره:
type Basket = { id: string; vendorId: string; items: BasketItem[]; };
ممکنه وسوسه بشیم چند State دیگه هم به Store اضافه کنیم:
type BasketStore = { basket: Basket; totalItems: number; subtotal: number; };
اما totalItems و subtotal هر دو از basket.items قابل محاسبه هستن:
export function getBasketSummary(basket: Basket) { return basket.items.reduce( (summary, item) => ({ totalItems: summary.totalItems + item.quantity, subtotal: summary.subtotal + item.price * item.quantity, }), { totalItems: 0, subtotal: 0 }, ); }
اگر هر سه مقدار رو مستقل ذخیره کنیم، سه چیز داریم که باید همیشه همزمان تغییر کنن.
بالاخره در یکی از Update Pathها یکی از اونها فراموش میشه.
بعد Badge سبد عدد ۳ رو نشون میده، داخل Basket چهار آیتم داریم و Checkout عدد سومی رو حساب میکنه.
هر State تکراری، یک مشکل Synchronization میسازه که باید برای همیشه حلش کنیم.
مقادیر Derived بهتره Stateless Calculation باقی بمونن، مگر اینکه Profiling واقعاً نشون بده Memoization لازمه.
حتی در اون حالت هم Memoization یک Source of Truth دوم نیست؛ فقط یک Performance Detail است.
اضافهکردن غذا به Basket بیشتر از یک API Call ساده است.
میخوایم UI سریع واکنش نشون بده، Command ارسال بشه، Failure مدیریت بشه و در نهایت State فرانت با Response سرور Reconcile بشه.

قسمت Stateful این Flow میتونه داخل یک Feature-level Controller یا Hook قرار بگیره:
export function useAddBasketItem() { const queryClient = useQueryClient(); return useMutation({ mutationFn: basketApi.addItem, async onMutate(command) { const key = basketKeys.detail(command.basketId); await queryClient.cancelQueries({ queryKey: key }); const previous = queryClient.getQueryData<Basket>(key); queryClient.setQueryData<Basket>(key, (basket) => basket ? addItemOptimistically(basket, command) : basket, ); return { previous }; }, (_error, command, context) { queryClient.setQueryData( basketKeys.detail(command.basketId), context?.previous, ); }, onSuccess(serverBasket, command) { queryClient.setQueryData( basketKeys.detail(command.basketId), serverBasket, ); }, }); }
خود Optimistic Transformation رو Stateless نگه میداریم:
export function addItemOptimistically( basket: Basket, command: AddBasketItemCommand, ): Basket { const existing = basket.items.find( (item) => item.foodId === command.foodId, ); if (!existing) { return { ...basket, items: [ ...basket.items, { foodId: command.foodId, quantity: command.quantity, price: command.optimisticPrice, }, ], }; } return { ...basket, items: basket.items.map((item) => item.foodId === command.foodId ? { ...item, quantity: item.quantity + command.quantity, } : item, ), }; }
در نهایت به چنین ترکیبی میرسیم:
Stateless transformation + Stateful orchestration + Stateless transport
Orchestration ما Stateful است چون با زمان سروکار داره:
قبل از Request؛
هنگام Request؛
بعد از Success؛
و بعد از Failure.
اینکه تلاش کنیم چنین Workflowای رو کاملاً Stateless کنیم کمکی نمیکنه. خود Flow ذاتاً Temporal است.
هدف اینه که پیچیدگی زمانی اون رو داخل یک نقطه مشخص و قابلدیدن نگه داریم.
در یک اپ سفارش غذا، Basket معمولاً متعلق به یک رستورانه.
فرض کنید سبد فعلی از Vendor A آیتم داره و کاربر تلاش میکنه غذایی از Vendor B اضافه کنه.
حالا یک تصمیم Business داریم:
idle → checking basket → waiting for confirmation → replacing basket → adding item → completed
بهتره این Flow رو با مجموعهای از Booleanهای نامرتبط مدل نکنیم:
// Invalid combinations are possible. { isLoading: true, isConfirmModalOpen: true, isReplacingBasket: true, hasError: true, }
آیا Flow میتونه همزمان Loading باشه، منتظر Confirmation باشه، Basket رو Replace کنه و Fail شده باشه؟
احتمالاً نه.
یک Discriminated Union فقط Stateهای معتبر رو قابل نمایش میکنه:
type AddFoodFlow = | { status: "idle" } | { status: "awaiting-vendor-confirmation"; foodId: string; nextVendorId: string; } | { status: "submitting"; foodId: string } | { status: "failed"; message: string };
حالا UI نمیتونه بدون اینکه TypeScript مشکل رو Visible کنه، چند State متناقض رو با هم Render کنه.
این یکی از جاهاییه که Stateful Design فقط ضروری نیست؛ اگر State رو صادقانه مدل کنیم، سیستم امنتر هم میشه.
یک Rule مهم دیگه هم اینجا داریم:
Frontend میتونه برای UX بهتر یک Business Rule رو پیشبینی کنه؛ ولی Backend همچنان باید اون رو Validate کنه.
Basket داخل Cache ممکنه Stale باشه. شاید یک Tab دیگه اون رو Replace کرده باشه. شاید Mobile Client تغییرش داده باشه.
Check فرانت Interaction رو بهتر میکنه، ولی تبدیل به Authorization یا Canonical Validation نمیشه.
حالا صفحه Search رستورانها رو در نظر بگیرید:
/restaurants?q=pizza&sort=delivery-time&free-delivery=true
Search Query، Sort، Filter و Pagination همگی State هستن.
اما جنس اونها با State داخلی یک Component فرق داره.
کاربر انتظار داره:
با Refresh نتیجه از بین نره؛
بتونه URL رو برای شخص دیگهای بفرسته؛
Back و Forward مرورگر درست کار کنه؛
و بتونه همین View رو Bookmark کنه.
پس URL میتونه Owner طبیعی این State باشه:
export function useRestaurantFilters() { const [params, setParams] = useSearchParams(); const filters = { query: params.get("q") ?? "", sort: params.get("sort") ?? "recommended", freeDelivery: params.get("free-delivery") === "true", }; function updateFilter( key: string, value: string | undefined, ) { setParams((current) => { const next = new URLSearchParams(current); value ? next.set(key, value) : next.delete(key); return next; }); } return { filters, updateFilter }; }
مدل خطرناک اینه که همین Filterها رو هم در URL و هم به شکل مستقل در Global Store نگه داریم.
حالا به یک Synchronization دوطرفه نیاز داریم:
URL → Store Store → URL
بعد از Navigation کدوم برنده میشه؟
هنگام Hydration چه اتفاقی میفته؟
وقتی کاربر Back رو میزنه چی؟
گاهی سادهترین راه حل یک مشکل Synchronization اینه که از اول نسخه تکراری State رو نسازیم.
Checkout جنس دیگهای از State داره:
type CheckoutForm = { addressId: string; recipientName: string; phone: string; deliveryNote: string; paymentMethod: "online" | "cash"; };
این State زیاد تغییر میکنه، ممکنه Invalid باشه و معمولاً فقط تا زمان Submit اهمیت داره.
بهتره Owner اون خود Form باشه؛ نه اینکه با هر Keystroke یک نسخه ازش رو وارد Store کل اپلیکیشن کنیم.
function CheckoutForm() { const form = useForm<CheckoutForm>({ defaultValues: { addressId: "", recipientName: "", phone: "", deliveryNote: "", paymentMethod: "online", }, }); const submitOrder = useSubmitOrder(); return ( <form ={form.handleSubmit(submitOrder.mutate)}> {/* controlled checkout fields */} </form> ); }
در یک Checkout طولانی و چندمرحلهای ممکنه بخوایم Draft رو در sessionStorage یا Backend نگه داریم.
اما Persistence باید جواب یک نیاز واقعی Product باشه:
آیا Draft باید بعد از Navigation باقی بمونه؟ آیا باید Refresh رو زنده بمونه؟ آیا باید بعد از بستن Browser هم وجود داشته باشه؟ آیا باید روی Device دیگهای قابل دسترس باشه؟
هر جواب مثبت، State رو به سمت Ownerای با Lifetime طولانیتر میبره.
نباید فقط چون localStorage در دسترسه، انتخابش کنیم.
Storage یک تصمیم معماری درباره Lifetime، Privacy، Invalidation و Migration است.
همه Stateهای مشترک متعلق به Server یا URL نیستن.
مثلاً Basket Drawer ممکنه از Header، Food Card یا Recommendation باز بشه.
این میتونه یک UI Store کوچک و منطقی باشه:
type BasketUiStore = { isDrawerOpen: boolean; openDrawer: () => void; closeDrawer: () => void; }; export const useBasketUi = create<BasketUiStore>((set) => ({ isDrawerOpen: false, openDrawer: () => set({ isDrawerOpen: true }), closeDrawer: () => set({ isDrawerOpen: false }), }));
اما دقت کنید چه چیزهایی داخل این Store نیستن:
basketItems basketSubtotal restaurantMenu foodAvailability checkoutForm searchFilters
این Dataها از قبل Owner مناسبتری دارن.
اینکه چند Component به یک Data نیاز دارن، خودبهخود به این معنی نیست که Redux، Zustand یا Context باید مالک اون باشه.
Shared بودن، Storage Strategy نیست.
وقتی مطمئن نیستم یک State باید کجا قرار بگیره، این سؤالها رو بهترتیب میپرسم:

نسخه کوتاهش اینه:
قابل محاسبه است؟ → Derive it مالک واقعی Data سرور است؟ → Query cache View باید Shareable باشد؟ → URL Draft یک Form است؟ → Form state فقط یک Component نیازش دارد؟ → Local state چند Feature نیازش دارند؟ → Feature/App store باید بعد از Tab باقی بماند؟ → Browser or backend persistence
و سؤال نهایی همیشه اینه:
Single Source of Truth این State کجاست؟
Single Source of Truth به معنی ریختن تمام Stateهای اپلیکیشن داخل یک Object بزرگ نیست.
یعنی هر تکه State یک Owner مشخص داشته باشه.
برای اپ سفارش غذای ما، نتیجه تقریباً چنین شکلی داره:

این جدول از انتخاب Library مهمتره.
میتونیم Zustand رو با Redux جایگزین کنیم.
میتونیم TanStack Query رو با یک Server-state Solution دیگه عوض کنیم.
میتونیم React Router رو با Router یک Framework جایگزین کنیم.
اگر Ownership همچنان شفاف باقی بمونه، معماری هنوز شانس قابلفهم موندن داره.
Pure Functionها و Presentational Componentها به تمام Environment اپلیکیشن نیاز ندارن.
میتونیم Pricing Rule، Mapping، Validation و Rendering رو بدون بالا آوردن Router، Query Client و Global Store تست کنیم.
یک Fact یکسان رو همزمان در URL State، Component State، Query Cache و Global Store نگه نمیداریم.
Copy کمتر یعنی فرصت کمتر برای ناسازگار شدن.
Basket Package مالک Workflowهای Basket است.
API Layer مالک Transport است.
Query Cache مالک Snapshotهای Fetchشده است.
Backend مالک Canonical Business Data است.
وقتی چند Team داخل یک Monorepo کار میکنن، این مرزها اهمیت خیلی بیشتری پیدا میکنن.
UIهای Stateless بدون Import کردن Assumptionهای مخفی صفحه اصلی قابل استفاده مجدد هستن.
Boundaryهای شفاف کمک میکنن Bundleها رو Split کنیم، یک Feature رو جابهجا کنیم، SSR اضافه کنیم یا اگر Organization واقعاً نیاز داشت بعداً یک Microfrontend استخراج کنیم.
این معماری چنین تغییرهایی رو رایگان نمیکنه؛ ولی تعداد Dependencyهای مخفیای که وسط کار پیدا میکنیم کمتر میشه.
داشتن FoodCard، Feature Controller، API Module، Query Definition و Pure Transformation از یک Component که همه کارها رو خودش انجام میده قطعات بیشتری میسازه.
برای یک اپلیکیشن کوچک، این ساختار میتونه Ceremony اضافه باشه.
این Structure فقط وقتی مفیده که Engineerها اون رو حفظ کنن.
اگر هر Task فوری Feature Boundary رو دور بزنه و مستقیم Storeها رو Import کنه، معماری کمکم فقط روی کاغذ باقی میمونه.
Rollback، Duplicate Request، Race Condition و Server Reconciliation نیاز به Design دقیق دارن.
UI برای کاربر سریع به نظر میرسه چون پیچیدگی به داخل Workflow منتقل شده.
Browser Cache فقط یک Snapshot است. باید برای Freshness، Invalidation و Refetch Strategy تصمیم مشخص داشته باشیم.
پیچیدگی رو حذف نکردیم.
متمرکزش کردیم.
و پیچیدگی متمرکز فقط وقتی ارزشمنده که Boundary اون قابل فهم بمونه.
هیچ معماری واحد و همیشه درستی برای State در Frontend وجود نداره.
اگر محصول Offline-first باشه، Local Persistence اهمیت خیلی بیشتری پیدا میکنه.
اگر Order Tracking با Live Event کار کنه، Subscription State و رفتار Reconnection هم وارد معماری میشن.
اگر هر Feature مستقل Deploy بشه، Runtime Boundaryهای Microfrontend روی نحوه Share کردن State اثر میذارن.
اگر Backend در Mutation Response اطلاعات کامل Resource رو برنگردونه، Invalidation ممکنه از جایگزین کردن مستقیم Cache مطمئنتر باشه.
اگر اپلیکیشن کوچیک باشه، بعضی از Layerهایی که اینجا ساختیم Overengineering هستن.
هدف این معماری ارائه Templateای نیست که همه باید Copy کنن.
هدف Visible کردن یک ایده است:
معماری خوب State کمتر درباره انتخاب State Management Library است و بیشتر درباره انتخاب Owner، Lifetime و Source of Truth درست برای هر تکه از اطلاعات.
Libraryها میتونن ذخیره کردن State رو راحتتر کنن.
ولی نمیتونن تصمیم بگیرن که آیا اون State اصلاً باید وجود داشته باشه یا نه.
این تصمیم همچنان بخشی از Engineering Work ماست.
برای هر State جدید میشه این سؤالها رو پرسید:
۱. Owner این State کیه؟
۲. Canonical است یا فقط یک Cached Snapshot؟
۳. میشه از Dataای که داریم Deriveش کرد؟
۴. چقدر باید زنده بمونه؟
۵. باید Refresh، بستهشدن Tab یا تغییر Device رو زنده بمونه؟
۶. آیا جاش در URL است؟
۷. چه کسانی اجازه دارن تغییرش بدن؟
۸. اگر دو Update همزمان اتفاق بیفتن چی میشه؟
۹. چطور Stale میشه؟
۱۰. بعد از Failure چطور Recover میکنیم؟
اگر جواب این سؤالها روشن باشه، انتخاب Library معمولاً خیلی سادهتر میشه.
اگر جواب مشخصی نداریم، اضافه کردن یک Store دیگه احتمالاً مشکل واقعی رو حل نمیکنه.
یک Frontend بزرگ ذاتاً Stateful است.
کاربر در طول زمان حرکت میکنه، Network غیرهمزمانه و Server هم میتونه مستقل از ما تغییر کنه.
اما این به این معنی نیست که هر Component، Service و Package باید چیزی رو به خاطر بسپره.
Rendering رو تا جای ممکن Stateless نگه داریم.
Transformationها رو Pure نگه داریم.
Transport رو Explicit نگه داریم.
Workflowهای زمانی رو داخل Feature Boundaryهای مشخص قرار بدیم.
به هر تکه State فقط یک Owner بدیم.
هدف ساختن یک Frontend بدون State نیست.
هدف ساختن Frontendیه که State نتونه داخلش پنهان بشه.
دوست دارم تجربه شما رو هم بدونم:
Basket State در Frontend شما کجا زندگی میکنه؟
و کدوم تصمیم State Management فقط بعد از بزرگشدن محصول تبدیل به یک تصمیم گرون شد؟