ඇප්ලිකේෂන් එකක async function එකක් පණිවිඩයක් පවා අසාර්ථක වුවහොත්, එය නැවත උත්සාහ කිරීම, කාලය සීමා කිරීම හෝ සේවාව බිඳ වැටී ඇති බව හඳුනා ගන්නා circuit‑breaker වැනි රිසිලිං නීති අවශ්ය වේ. නමුත් බොහොමයක් ලයිබ්රරීන් HTTP client‑වලට සීමා කර තිබීම හේතුවෙන්, සාමාන්ය async ක්රියාකාරකම් සඳහා ඒවා භාවිතා කිරීම අපහසුය.
මෙම අවශ්යතාවයට පිළිතුරක් ලෙස houhou නමැති නව TypeScript ලයිබ්රරිය එළිදැක්වී ඇත. මෙය සම්පූර්ණයෙන්ම dependency‑free (ලයිබ්රරීන් 500 පේළි පමණ) වන අතර, ඔබේ async function එකක් එහි task විධියෙන් වටාගෙන, retry, timeout, fallback, circuit‑breaker, delay වැනි නීති එකතු කළ හැක. මුල් function එකේ signature එක වෙනස් නොවීම නිසා, එය පළමු ආකාරයටම කැඳවිය හැක.
උදාහරණයක් ලෙස, credit card එකක් ගාස්තු ගණනය කරන chargeCard function එකක් ගැන සිතන්න. task(chargeCard).retry(3).timeout(10000).fallback(() => ({status: 'pending'})) ලෙස ලියන විට, 3 වරක් පළමුවන අසාර්ථකතාවයට පසු නැවත උත්සාහ කරයි, 10 සෙකන්ඩ් ඉක්මවා ගියොත් timeout සිදු වේ, අන්තිමට fallback function එක ක්රියාත්මක වේ. එමෙන්ම, task(fetchUser).retry({attempts:5, backoff:'exponential', jitter:true, delay:500}) වැනි විකල්පවත් ලබා දිය හැක.
- Retry – අසාර්ථක වීමේදී නියමිත වාර ගණනක් පුරා නැවත උත්සාහ කිරීම (fixed හෝ exponential backoff).
- Timeout – නියමිත කාලය තුළ function එක නිම නොවුවහොත් පරිතාපයක් නිකුත් කිරීම.
- Fallback – අසාර්ථකත්වය සිදුවූ විට වෙනත් function එකක් ක්රියාත්මක කිරීම.
- Circuit Breaker – සේවාව අසාර්ථක වීමක් පෙන්වන විට, තවත් අමතර ඇමතුම් තහනම් කර, සෞඛ්යය පරීක්ෂා කිරීම සඳහා reset timeout එකක් සකස් කිරීම.
- Delay – function එක ඇරඹීමට පෙර නියමිත කාලයක් රැඳී සිටීම.
නීති සැකසීමේ අනුක්රමය වැදගත්ය. නවතම නීතිය පළමු වරට function එකට වටාගෙන, පසුගිය නීති පසුපසට අඩංගු වේ. උදාහරණයක්: task(fn).retry(3).timeout(1000) යන විට, timeout එක retry නීතියේ පිටතින් ක්රියා කරයි; එමනිසා timeout එක සිදුවුවහොත් retry නොකෙරේ. එයට විරුද්ධව task(fn).timeout(1000).retry(3) නම්, timeout එක retry නීතිය තුළින් පාලනය කරයි, ඒ අනුව timeout සිදුවීමත් සමඟ retry පවා නැවත පුරා ගනී.
TypeScript හි type‑lock යන්ත්රණය මඟින් එකම නීතිය දෙවරක් සකස් කිරීම compile‑time දෝෂයක් ලෙස පෙන්වයි. එසේම, runtime වල Set guard එකක් මගින් ඒක තවත් වැරදි වැළැක්වීමේ උපකාරී වේ.
Timeout හෝ බාහිර abort signal එකක් භාවිතා කිරීමට AbortController භාවිතා කරයි. ඔබගේ function එකට AbortSignal පරාමිතිය අවසාන argument ලෙස ලබා දිය හැක; timeout එකක් සිදුවූ විට controller.abort() ක්රියාත්මක වේ, එමඟින් fetch වැනි async operation එක නවත්වයි.
අවසන් උදාහරණයක් ලෙස, task(callApi).retry({attempts:3, backoff:'exponential'}).timeout(5000).fallback(loadFromCache).circuitBreaker({failureThreshold:5, successThreshold:2, resetTimeout:30000}).delay(100) ලෙස නීති සියල්ල එකට එකතු කර, ඔබේ API ඇමතුම වඩාත් විශ්වාසනීය කරගත හැක.
ශ්රී ලංකාවට ඇති වැදගත්කම
- සැමියාන්ට – සිසුන් සහ නවකයින්ට async programming එකේ රිසිලිං නීති ක්රියාත්මක කිරීමේ පදනම ඉගෙන ගැනීමට පහසු වේ.
- ඩෙවලපර්ස් – බර නොවන ලයිබ්රරිය නිසා, ලොකු dependency ගණනක් එකතු නොකර, කාර්ය සාධනය තවත් වේගවත් කරයි. ඒමගින් micro‑service, serverless, IoT වැනි ව්යාපෘති වලට ඉතා සුදුසු වේ.
- ව්යාපාර – සේවා අස්ථිරතාවය හෝ දත්ත ගබඩා අසාර්ථකත්වය නිසා පාරිභෝගික අත්දැකීමේ අඩුපාඩු සිදුවීම අවම කරයි, ඉතින් ROI වැඩි වේ.
ඉදිරියට, houhou වැනි ලයිබ්රරීන් අපේ දේශීය තාක්ෂණික පරිසරය තවත් ශක්තිමත් කර, ගෝලීය තත්ත්වයේ කේත ලේඛන ක්රමවේදයන් අපගේ සංවර්ධන ක්රමයට එක්කරයි.
