graphql-norm-stale
Version:
Staleness tracking for normalized GraphQL responses
137 lines • 5.8 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
/**
* Checks if any of the provided fields are stale
*/
function isStale(staleMap, fields) {
var e_1, _a, e_2, _b;
try {
for (var _c = __values(Object.keys(fields)), _d = _c.next(); !_d.done; _d = _c.next()) {
var key = _d.value;
try {
for (var _e = (e_2 = void 0, __values(fields[key])), _f = _e.next(); !_f.done; _f = _e.next()) {
var field = _f.value;
var staleObj = staleMap[key];
if (staleObj && staleObj.has(field)) {
return true;
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
}
finally { if (e_2) throw e_2.error; }
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
}
finally { if (e_1) throw e_1.error; }
}
return false;
}
exports.isStale = isStale;
/**
* Removes the stale flag for fields that are present in the normalized result.
* Returns tupe of new map of stale fields with the cleared fields removed and
* map of the cleared fields
*/
function clearStale(normMap, staleMap) {
var e_3, _a, e_4, _b, e_5, _c;
// Make a shallow copy to enable shallow mutation
var newStaleMap = __assign({}, staleMap);
var clearedMap = {};
try {
// Check all stale fields against the normalized map
for (var _d = __values(Object.keys(newStaleMap)), _e = _d.next(); !_e.done; _e = _d.next()) {
var staleKey = _e.value;
var normObj = normMap[staleKey];
if (normObj !== undefined) {
var staleFields = newStaleMap[staleKey];
var staleFieldKeyCount = staleFields.size;
// Check all fields of the stale set against the corresponding normalized object fields
// If a field exists in the normalized map, then it should not be stale anymore
var staleFieldsSetCopy = undefined;
var clearedFields = undefined;
try {
for (var staleFields_1 = (e_4 = void 0, __values(staleFields)), staleFields_1_1 = staleFields_1.next(); !staleFields_1_1.done; staleFields_1_1 = staleFields_1.next()) {
var staleField = staleFields_1_1.value;
try {
for (var _f = (e_5 = void 0, __values(Object.keys(normObj))), _g = _f.next(); !_g.done; _g = _f.next()) {
var normField = _g.value;
if (normField === staleField) {
if (!staleFieldsSetCopy) {
staleFieldsSetCopy = new Set(staleFields);
newStaleMap[staleKey] = staleFieldsSetCopy;
}
if (!clearedFields) {
clearedFields = new Set();
clearedMap[staleKey] = clearedFields;
}
staleFieldsSetCopy.delete(staleField);
staleFieldKeyCount--;
clearedFields.add(staleField);
}
}
}
catch (e_5_1) { e_5 = { error: e_5_1 }; }
finally {
try {
if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
}
finally { if (e_5) throw e_5.error; }
}
}
}
catch (e_4_1) { e_4 = { error: e_4_1 }; }
finally {
try {
if (staleFields_1_1 && !staleFields_1_1.done && (_b = staleFields_1.return)) _b.call(staleFields_1);
}
finally { if (e_4) throw e_4.error; }
}
// If the normalized object has no stale fields then remove it from stale
if (staleFieldKeyCount === 0) {
delete newStaleMap[staleKey];
}
}
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
}
finally { if (e_3) throw e_3.error; }
}
return [newStaleMap, clearedMap];
}
exports.clearStale = clearStale;
//# sourceMappingURL=stale.js.map