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ನಾಶವಾದ ಸ್ಟೋರ್‌ಗೆ ಸಬ್‌ಸ್ಕ್ರೈಬ್ ಮಾಡಲಾಯಿತು ಅಥವಾ ಸ್ಟೋರೇಜ್ ಬಳಸಲು ಕೇಳಲಾಯಿತು.

ದಸ್ತಾವೇಜಿನಲ್ಲಿ ಹುಡುಕಿ

ಎಲ್ಲ ಮಾರ್ಗದರ್ಶಿಗಳ ಶೀರ್ಷಿಕೆ, ವಿವರಣೆ ಮತ್ತು ವಿಷಯದಲ್ಲಿ ಹುಡುಕಿ.