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