restate / v1.0.0
రూపకల్పనలోనే విశ్వసనీయం
స్టోరేజ్ నెమ్మదిగా ఉన్నప్పుడు, విఫలమైనప్పుడు లేదా లేనప్పుడు restate దేనికి హామీ ఇస్తుంది, అది నివేదించే లోపాలను ఎలా చదవాలి.
ఈ పేజీలో
హామీలువరుస సేవ్లుప్రయత్నించండిలోడ్ విఫలమైనప్పుడుసేవ్ చేసి మూసివేయండిస్టోరేజ్ అందుబాటులో లేదుసేవ్ చేసిన డేటాను ధ్రువీకరించడం, మార్చడంమీ సొంత స్టోరేజ్పరిమితులు, సమయ పరిమితులులోపం కోడ్లుహామీలు
ఈ ప్రవర్తన 1.0 ఒప్పందంలో భాగం; ప్యాకేజీ టెస్టులు దీన్ని కవర్ చేస్తాయి.
| పరిస్థితి | restate చేసేది |
|---|---|
వరుసగా అనేక సేవ్లు | ప్రతి స్టోర్కు వరుసగా నడుపుతుంది; క్యూలోని సేవ్ తాజా విలువను రాస్తుంది. |
ఒక రికార్డు లోడ్ కాలేదు | autoSave, బల్క్ సేవ్లు LOAD_FAILEDతో దాన్ని దాటవేస్తాయి; స్పష్టమైన save() మాత్రమే దాన్ని మారుస్తుంది. |
సేవ్ సమయంలో కాంపోనెంట్ అన్మౌంట్ అవుతుంది | అభ్యర్థించిన సేవ్ పూర్తవుతుంది; నాశనమైన స్టోర్పై తర్వాత వచ్చే రాతలు విస్మరించబడతాయి. |
స్టోరేజ్ అందుబాటులో లేదు | స్టోర్ మెమరీలో పనిచేస్తుంది, status().available false అవుతుంది, సేవ్లు తిరస్కరించబడతాయి. |
అడాప్టర్ ఇరుక్కుపోతుంది | operationTimeoutMs తర్వాత ఆపరేషన్ సమయం మించిపోతుంది; తదుపరి పని అడాప్టర్ పూర్తయ్యే వరకు వేచి ఉంటుంది. |
చాలా ఎక్కువ పెండింగ్ పని | కొత్త ఆపరేషన్లు అపరిమితంగా పెరగకుండా QUEUE_FULLతో తిరస్కరించబడతాయి. |
వరుస సేవ్లు
ఒక స్టోర్ ఆపరేషన్లు ఎప్పుడూ ఒకదానిపై ఒకటి జరగవు. మరొకటి వేచి ఉండగా ప్రారంభమయ్యే సేవ్ తాజా విలువను తీసుకుంటుంది; అందువల్ల ప్రతి మార్పుకు సేవ్ చేయడం క్యూను నింపకుండా చివరి స్థితిని రాస్తుంది.
useDraft.set('A');
const first = useDraft.save(); // writes "A"
useDraft.set('B');
const second = useDraft.save(); // waits in the queue
useDraft.set('C');
const third = useDraft.save(); // joins the waiting save
await Promise.all([first, second, third]); // ['A', 'C', 'C'] — two writesప్రయత్నించండి
స్టోరేజ్ను నెమ్మదిగా చేయండి, రాతలను విఫలం చేయండి, లేదా స్టోరేజ్ను పూర్తిగా తీసివేయండి.
ఉదాహరణ సిద్ధమవుతోంది…
లోడ్ విఫలమైనప్పుడు
restateManager.ready BULK_OPERATION_FAILEDతో తిరస్కరించబడి, విఫలమైన ప్రతి స్టోర్ను జాబితా చేస్తుంది. ఆ రికార్డు లోడ్ అయ్యే వరకు autoSave, saveAll దాన్ని మార్చకుండా LOAD_FAILED నివేదిస్తాయి.
మార్పులను ఉంచుకుని సేవ్ చేయడానికి initialize()తో మళ్లీ ప్రయత్నించండి, వాటిని వదిలేయడానికి restore() కాల్ చేయండి, లేదా రికార్డును ఉద్దేశపూర్వకంగా తిరగరాయడానికి save() వాడండి.
try {
await restateManager.ready;
} catch (error) {
// BULK_OPERATION_FAILED: one entry per store that could not load.
for (const { store, error: cause } of error.failures) {
console.error(store.key, cause.code);
}
}సేవ్ చేసి మూసివేయండి
అన్మౌంట్కు ముందు అభ్యర్థించిన సేవ్ అయినా పూర్తవుతుంది; అందువల్ల "సేవ్ చేసి మూసివేయండి" హ్యాండ్లర్ వేచి ఉండాల్సిన అవసరం లేదు.
function Document({ onClose }) {
const useDraft = useRestateScope((scope) => persistedRestate('', { scope, key: 'draft' }));
const saveAndClose = () => {
useDraft.save(); // finishes even after this component unmounts
onClose();
};
// …
}సేవ్ చేసిన డేటాను ధ్రువీకరించడం, మార్చడం
version, migrate, validate పాత లేదా పాడైన రికార్డుల నుండి మిమ్మల్ని కాపాడతాయి. validate సేవ్కు ముందు, పునరుద్ధరణ లేదా మార్పిడి తర్వాత నడుస్తుంది.
import { persistedRestate } from '@kkwaenggwari/restate';
const useSettings = persistedRestate(
{ theme: 'system' },
{
key: 'settings',
version: 2,
migrate(value, from, to) {
if (from === 1 && to === 2 && typeof value?.darkMode === 'boolean') {
return { theme: value.darkMode ? 'dark' : 'light' };
}
throw new Error('Unsupported stored version');
},
validate: (value) => ['system', 'light', 'dark'].includes(value?.theme),
},
);మీ సొంత స్టోరేజ్
getItem, setItem, removeItem కలిగిన ఏ ఆబ్జెక్ట్ అయినా సరిపోతుంది. మెథడ్లు విలువలను లేదా Promise-లను ఇవ్వవచ్చు; isAvailable ఐచ్ఛికం.
import { persistedRestate } from '@kkwaenggwari/restate';
const sessionStorageAdapter = {
isAvailable: () => typeof sessionStorage !== 'undefined',
getItem: (key) => sessionStorage.getItem(key),
setItem: (key, value) => sessionStorage.setItem(key, value),
removeItem: (key) => sessionStorage.removeItem(key),
};
export const useFilters = persistedRestate(
{ query: '' },
{
key: 'filters',
storage: sessionStorageAdapter,
},
);పరిమితులు, సమయ పరిమితులు
ఒక ఆపరేషన్ ఎంత సేపు పట్టవచ్చు, ఎన్ని వేచి ఉండవచ్చు, ఒక విలువ ఎంత పెద్దది కావచ్చు అని సెట్ చేయండి.
persistedRestate(value, {
key: 'draft',
operationTimeoutMs: 10_000, // default 30000
maxPendingOperations: 64, // default 256
maxStorageCharacters: 1_000_000,
});లోపం కోడ్లు
restate సృష్టించే లోపాలకు name RestateError, code, సేవ్ అయ్యే స్టోర్లకు key ఉంటాయి. స్టోరేజ్ అడాప్టర్లు, మీ callback-లు తమ సొంత లోపాలతో తిరస్కరించవచ్చు.
| కోడ్ | అర్థం |
|---|---|
BULK_OPERATION_FAILED | restateManager.ready లేదా saveAll వంటి బల్క్ కాల్లో వైఫల్యాలు ఉన్నాయి; error.failures చూడండి. |
INDEXEDDB_ABORTED | ఒక IndexedDB లావాదేవీ రద్దు అయింది. |
INDEXEDDB_BLOCKED | డేటాబేస్ తెరవడాన్ని మరో ట్యాబ్లోని కనెక్షన్ అడ్డుకుంది. |
INDEXEDDB_CONNECTION_CLOSING | అభ్యర్థన ప్రారంభమైనప్పుడు డేటాబేస్ కనెక్షన్ మూసుకుంటోంది. |
INDEXEDDB_OPEN_FAILED | డేటాబేస్ను తెరవలేకపోయాం. |
INDEXEDDB_REQUEST_FAILED | ఒక IndexedDB అభ్యర్థన విఫలమైంది. |
INDEXEDDB_STORE_MISSING | ఇప్పటికే ఉన్న డేటాబేస్లో object store లేదు. |
INVALID_STORAGE_RECORD | సేవ్ చేసిన రికార్డు చెల్లుబాటయ్యే restate రికార్డు కాదు. |
INVALID_STORED_VALUE | విలువ validate-ను దాటలేదు. |
LIFECYCLE_LIMIT | ఒక updater పదే పదే ప్రారంభమై ఆగింది. |
LOAD_FAILED | రికార్డును లోడ్ చేయలేకపోయాం; అందువల్ల ఆటో లేదా బల్క్ సేవ్ దాన్ని మార్చలేదు. |
MMKV_UNAVAILABLE | react-native-mmkv లోడ్ కాలేదు. |
MULTIPLE_ERRORS | ఒకే ఆపరేషన్లో అనేక callback-లు విఫలమయ్యాయి; error.errors చూడండి. |
NOTIFICATION_LIMIT | పరిశీలకులు ఒక లూప్లో మార్పులను షెడ్యూల్ చేస్తూనే ఉన్నారు. |
OBSERVER_ERROR | ఒక listener లేదా lifecycle callback లోపాన్ని విసిరింది. |
OPERATION_ABORTED | ఒక స్టోరేజ్ ఆపరేషన్ రద్దు చేయబడింది. |
QUEUE_FULL | maxPendingOperations అనుమతించే దానికంటే ఎక్కువ ఆపరేషన్లు వేచి ఉన్నాయి. |
REENTRANT_SETTER | ఒక స్టేట్ updater నడుస్తుండగానే అదే స్టోర్ను మార్చడానికి ప్రయత్నించింది. |
SCOPE_DESTROYED | స్టోర్లను సృష్టించడానికి నాశనమైన scope వాడబడింది. |
SEQUENCE_EXHAUSTED | ఒక అంతర్గత క్రమానికి ఐడెంటిఫైయర్లు అయిపోయాయి. |
STORAGE_BLOCKED | సమయ పరిమితి లేదా రద్దు తర్వాత కూడా మునుపటి అడాప్టర్ కాల్ పూర్తి కాలేదు. |
STORAGE_TIMEOUT | ఒక ఆపరేషన్ operationTimeoutMs కంటే ఎక్కువ సమయం తీసుకుంది. |
STORAGE_UNAVAILABLE | ఇక్కడ స్టోరేజ్ వాడలేము; స్టోర్ మెమరీలో పనిచేస్తూనే ఉంటుంది. |
STORAGE_VALUE_TOO_LARGE | ఎన్కోడ్ చేసిన విలువ maxStorageCharacters-ను మించింది. |
STORAGE_VERSION_MISMATCH | రికార్డు వెర్షన్ భిన్నంగా ఉంది; ఏ migrate ఫంక్షన్ కూడా దాన్ని నిర్వహించలేదు. |
STORE_DESTROYED | నాశనమైన స్టోర్కు సబ్స్క్రైబ్ చేయబడింది లేదా స్టోరేజ్ వాడమని అడగబడింది. |