This repository has been archived on 2023-10-27. You can view files and clone it, but cannot push or open issues or pull requests.
node-fetch-cache/index.js

116 lines
3.3 KiB
JavaScript
Raw Normal View History

2020-04-17 20:31:22 +00:00
const fetch = require('node-fetch');
const fs = require('fs');
const { URLSearchParams } = require('url');
2020-04-17 20:31:22 +00:00
const crypto = require('crypto');
const path = require('path');
2020-11-28 04:28:00 +00:00
const Response = require('./classes/response.js');
2021-06-11 15:25:24 +00:00
const MemoryCache = require('./classes/caching/memory_cache.js');
2020-11-28 04:28:00 +00:00
const CACHE_VERSION = 2;
2020-04-17 20:31:22 +00:00
function md5(str) {
return crypto.createHash('md5').update(str).digest('hex');
}
// Since the bounday in FormData is random,
// we ignore it for purposes of calculating
// the cache key.
2020-11-28 16:43:50 +00:00
function getFormDataCacheKey(formData) {
const cacheKey = { ...formData };
if (typeof formData.getBoundary === 'function') {
const boundary = formData.getBoundary();
// eslint-disable-next-line no-underscore-dangle
delete cacheKey._boundary;
// eslint-disable-next-line no-underscore-dangle
if (Array.isArray(cacheKey._streams)) {
const boundaryReplaceRegex = new RegExp(boundary, 'g');
// eslint-disable-next-line no-underscore-dangle
cacheKey._streams = cacheKey._streams.map((s) => {
if (typeof s === 'string') {
return s.replace(boundaryReplaceRegex, '');
}
return s;
});
}
}
return cacheKey;
}
function getBodyCacheKeyJson(body) {
2020-11-28 16:25:23 +00:00
if (!body) {
return body;
} if (typeof body === 'string') {
return body;
} if (body instanceof URLSearchParams) {
return body.toString();
2020-11-28 16:25:23 +00:00
} if (body instanceof fs.ReadStream) {
return body.path;
2020-11-28 16:43:50 +00:00
} if (body.toString && body.toString() === '[object FormData]') {
return getFormDataCacheKey(body);
}
2020-11-28 16:25:23 +00:00
throw new Error('Unsupported body type');
}
function getCacheKey(requestArguments) {
const resource = requestArguments[0];
const init = requestArguments[1] || {};
const resourceCacheKeyJson = typeof resource === 'string' ? { url: resource } : { ...resource };
const initCacheKeyJson = { ...init };
resourceCacheKeyJson.body = getBodyCacheKeyJson(resourceCacheKeyJson.body);
initCacheKeyJson.body = getBodyCacheKeyJson(initCacheKeyJson.body);
return md5(JSON.stringify([resourceCacheKeyJson, initCacheKeyJson, CACHE_VERSION]));
}
async function createRawResponse(fetchRes) {
const buffer = await fetchRes.buffer();
2020-11-28 03:26:31 +00:00
const rawHeaders = Array.from(fetchRes.headers.entries())
.reduce((aggregate, entry) => ({ ...aggregate, [entry[0]]: entry[1] }), {});
return {
status: fetchRes.status,
statusText: fetchRes.statusText,
type: fetchRes.type,
url: fetchRes.url,
ok: fetchRes.ok,
2020-11-28 03:26:31 +00:00
headers: rawHeaders,
redirected: fetchRes.redirected,
bodyBuffer: buffer,
};
}
2021-06-11 15:25:24 +00:00
async function getResponse(cache, requestArguments) {
const cacheKey = getCacheKey(requestArguments);
2021-06-11 15:25:24 +00:00
const cachedValue = await cache.get(cacheKey);
2021-06-11 15:25:24 +00:00
const ejectSelfFromCache = () => cache.remove(cacheKey);
if (cachedValue) {
return new Response(cachedValue, ejectSelfFromCache, true);
} else {
const fetchResponse = await fetch(...requestArguments);
2020-11-28 03:26:31 +00:00
const rawResponse = await createRawResponse(fetchResponse);
2021-06-11 15:25:24 +00:00
await cache.set(cacheKey, rawResponse);
return new Response(rawResponse, ejectSelfFromCache, false);
2020-04-17 20:31:22 +00:00
}
}
2021-06-11 15:25:24 +00:00
function createFetchWithCache(cache) {
const fetch = (...args) => getResponse(cache, args);
fetch.withCache = createFetchWithCache;
2020-04-17 20:31:22 +00:00
2021-06-11 15:25:24 +00:00
return fetch;
2020-04-17 20:31:22 +00:00
}
2021-06-11 15:25:24 +00:00
module.exports = createFetchWithCache(new MemoryCache());