restate / v1.0.0

రూపకల్పనలోనే విశ్వసనీయం

స్టోరేజ్ నెమ్మదిగా ఉన్నప్పుడు, విఫలమైనప్పుడు లేదా లేనప్పుడు restate దేనికి హామీ ఇస్తుంది, అది నివేదించే లోపాలను ఎలా చదవాలి.

ఈ పేజీలోహామీలువరుస సేవ్‌లుప్రయత్నించండిలోడ్ విఫలమైనప్పుడుసేవ్ చేసి మూసివేయండిస్టోరేజ్ అందుబాటులో లేదుసేవ్ చేసిన డేటాను ధ్రువీకరించడం, మార్చడంమీ సొంత స్టోరేజ్పరిమితులు, సమయ పరిమితులులోపం కోడ్‌లు

హామీలు

ఈ ప్రవర్తన 1.0 ఒప్పందంలో భాగం; ప్యాకేజీ టెస్టులు దీన్ని కవర్ చేస్తాయి.

పరిస్థితిrestate చేసేది
వరుసగా అనేక సేవ్‌లుప్రతి స్టోర్‌కు వరుసగా నడుపుతుంది; క్యూలోని సేవ్ తాజా విలువను రాస్తుంది.
ఒక రికార్డు లోడ్ కాలేదుautoSave, బల్క్ సేవ్‌లు LOAD_FAILED‌తో దాన్ని దాటవేస్తాయి; స్పష్టమైన save() మాత్రమే దాన్ని మారుస్తుంది.
సేవ్ సమయంలో కాంపోనెంట్ అన్‌మౌంట్ అవుతుందిఅభ్యర్థించిన సేవ్ పూర్తవుతుంది; నాశనమైన స్టోర్‌పై తర్వాత వచ్చే రాతలు విస్మరించబడతాయి.
స్టోరేజ్ అందుబాటులో లేదుస్టోర్ మెమరీలో పనిచేస్తుంది, status().available false అవుతుంది, సేవ్‌లు తిరస్కరించబడతాయి.
అడాప్టర్ ఇరుక్కుపోతుందిoperationTimeoutMs తర్వాత ఆపరేషన్ సమయం మించిపోతుంది; తదుపరి పని అడాప్టర్ పూర్తయ్యే వరకు వేచి ఉంటుంది.
చాలా ఎక్కువ పెండింగ్ పనికొత్త ఆపరేషన్లు అపరిమితంగా పెరగకుండా QUEUE_FULL‌తో తిరస్కరించబడతాయి.

వరుస సేవ్‌లు

ఒక స్టోర్ ఆపరేషన్లు ఎప్పుడూ ఒకదానిపై ఒకటి జరగవు. మరొకటి వేచి ఉండగా ప్రారంభమయ్యే సేవ్ తాజా విలువను తీసుకుంటుంది; అందువల్ల ప్రతి మార్పుకు సేవ్ చేయడం క్యూను నింపకుండా చివరి స్థితిని రాస్తుంది.

JavaScript / JSX
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() వాడండి.

JavaScript / JSX
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);
  }
}

సేవ్ చేసి మూసివేయండి

అన్‌మౌంట్‌కు ముందు అభ్యర్థించిన సేవ్ అయినా పూర్తవుతుంది; అందువల్ల "సేవ్ చేసి మూసివేయండి" హ్యాండ్లర్ వేచి ఉండాల్సిన అవసరం లేదు.

JavaScript / JSX
function Document({ onClose }) {
  const useDraft = useRestateScope((scope) => persistedRestate('', { scope, key: 'draft' }));

  const saveAndClose = () => {
    useDraft.save(); // finishes even after this component unmounts
    onClose();
  };
  // …
}

స్టోరేజ్ అందుబాటులో లేదు

సర్వర్ రెండరింగ్, బ్రౌజర్ బ్లాక్ చేసిన స్టోరేజ్ ప్రారంభ లోపాలు కావు. మార్పులు మెమరీలో మాత్రమే ఉన్నాయని వినియోగదారులకు చెప్పడానికి available తనిఖీ చేయండి.

JavaScript / JSX
const { available } = useDraft.status();

if (!available) {
  // Server rendering or blocked browser storage: the store works in memory
  // and save() rejects with STORAGE_UNAVAILABLE.
  showNotice('Changes are kept until you close this tab.');
}

సేవ్ చేసిన డేటాను ధ్రువీకరించడం, మార్చడం

version, migrate, validate పాత లేదా పాడైన రికార్డుల నుండి మిమ్మల్ని కాపాడతాయి. validate సేవ్‌కు ముందు, పునరుద్ధరణ లేదా మార్పిడి తర్వాత నడుస్తుంది.

JavaScript / JSX
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 ఐచ్ఛికం.

JavaScript / JSX
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,
  },
);

పరిమితులు, సమయ పరిమితులు

ఒక ఆపరేషన్ ఎంత సేపు పట్టవచ్చు, ఎన్ని వేచి ఉండవచ్చు, ఒక విలువ ఎంత పెద్దది కావచ్చు అని సెట్ చేయండి.

JavaScript / JSX
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_FAILEDrestateManager.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_UNAVAILABLEreact-native-mmkv లోడ్ కాలేదు.
MULTIPLE_ERRORSఒకే ఆపరేషన్‌లో అనేక callback-లు విఫలమయ్యాయి; error.errors చూడండి.
NOTIFICATION_LIMITపరిశీలకులు ఒక లూప్‌లో మార్పులను షెడ్యూల్ చేస్తూనే ఉన్నారు.
OBSERVER_ERRORఒక listener లేదా lifecycle callback లోపాన్ని విసిరింది.
OPERATION_ABORTEDఒక స్టోరేజ్ ఆపరేషన్ రద్దు చేయబడింది.
QUEUE_FULLmaxPendingOperations అనుమతించే దానికంటే ఎక్కువ ఆపరేషన్లు వేచి ఉన్నాయి.
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నాశనమైన స్టోర్‌కు సబ్‌స్క్రైబ్ చేయబడింది లేదా స్టోరేజ్ వాడమని అడగబడింది.

డాక్యుమెంటేషన్‌లో వెతకండి

అన్ని గైడ్‌ల శీర్షికలు, వివరణలు, విషయంలో వెతకండి.