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

वापरून पाहा

स्टोरेज मंद करा, लेखन अयशस्वी करा, किंवा स्टोरेज पूर्णपणे काढून टाका.

कंट्रोलरउदाहरण कोडचा भाग नाही. मूल्ये props म्हणून उदाहरणाकडे जातात.

विलंबlatency
अयशस्वी लेखनfailWrites
स्टोरेज अनुपलब्धunavailable

<Example
  latency={700}
  failWrites={false}
  unavailable={false}
/>

उदाहरण तयार होत आहे…

थेट उदाहरणांसाठी JavaScript आवश्यक आहे. खालील कोड जसा आहे तसा वाचता येतो.

App.jsx

import { useEffect, useState } from 'react';
import { persistedRestate } from '@kkwaenggwari/restate';
import { flakyStorage, settings } from './storage.js';
import './styles.css';

const useNote = persistedRestate('', { key: 'lab-note', storage: flakyStorage });

export default function Example({ latency = 700, failWrites = false, unavailable = false }) {
  useEffect(() => {
    Object.assign(settings, { latency, failWrites, unavailable });
  }, [latency, failWrites, unavailable]);

  const note = useNote();
  const { dirty, operation, pending, error } = useNote.useStatus();
  const [results, setResults] = useState([]);

  const save = () =>
    useNote.save().then(
      (value) => setResults((list) => [`सेव्ह झाले: ${JSON.stringify(value)}`, ...list]),
      (reason) => setResults((list) => [`अयशस्वी: ${reason.code ?? reason.message}`, ...list]),
    );

  return (
    <main>
      <label>
        टीप
        <input value={note} onChange={(event) => useNote.set(event.target.value)} />
      </label>
      <div className="actions">
        <button onClick={save}>सेव्ह करा</button>
        <button
          onClick={() => {
            save();
            save();
            save();
          }}
        >
          तीन वेळा सेव्ह करा
        </button>
      </div>
      <dl className="status">
        <dt>dirty</dt>
        <dd className={dirty ? 'warn' : 'ok'}>{String(dirty)}</dd>
        <dt>operation</dt>
        <dd>{operation ?? '-'}</dd>
        <dt>pending</dt>
        <dd>{pending}</dd>
        <dt>error</dt>
        <dd className={error ? 'bad' : ''}>{error ? (error.code ?? error.message) : '-'}</dd>
      </dl>
      <h2>परिणाम</h2>
      <ol className="log">
        {results.length ? (
          results.map((result, index) => <li key={results.length - index}>{result}</li>)
        ) : (
          <li>-</li>
        )}
      </ol>
    </main>
  );
}

storage.js

// A storage adapter whose speed and failures you can change.
const records = new Map();
export const settings = { latency: 0, failWrites: false, unavailable: false };
const wait = () => new Promise((resolve) => setTimeout(resolve, settings.latency));

export const flakyStorage = {
  isAvailable: () => !settings.unavailable,
  async getItem(key) {
    await wait();
    return records.get(key) ?? null;
  },
  async setItem(key, value) {
    await wait();
    if (settings.failWrites) throw new Error('डिस्क भरली');
    records.set(key, value);
  },
  async removeItem(key) {
    await wait();
    records.delete(key);
  },
};

लोड अयशस्वी झाल्यावर

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();
  };
  // …
}

स्टोरेज अनुपलब्ध

सर्व्हर रेंडरिंग आणि ब्राउझरने अवरोधित केलेले स्टोरेज या प्रारंभ त्रुटी नाहीत. बदल फक्त मेमरीमध्ये आहेत हे वापरकर्त्यांना सांगण्यासाठी available तपासा.

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 सेव्हपूर्वी आणि पुनर्संचयन किंवा रूपांतरानंतर चालते.

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`	नष्ट झालेल्या स्टोअरला सबस्क्राइब केले किंवा स्टोरेज वापरण्यास सांगितले.

restate 1.0 API साठी लिहिलेले