Кэширование ответа на POST-запрос с использованием сервисных работников

Question

Я использую вызов /api/v1 для извлечения данных из серверной части.Метод API - POST, и я передаю параметры следующим образом:

{
  "act":"get",
  "nm":"dataset1",
  "lk":0
}

Ответ содержит строку JSON.

Я собираюсь сделать свое приложение доступным в автономном режиме, поэтому янеобходимо кэшировать этот запрос API с помощью сервисного работника.Вот мой сервисный работник:

'use strict';

const VERSION = 'v1';
const PRECACHE = `precache-${VERSION}`;
const RUNTIME = `runtime-${VERSION}`;
const enableRuntimeCache = true;
const mode = 'cache-update';

const PRECACHE_URLS = [
    '/'
];

let NetworkOnline = true;


self.addEventListener('install', event => {
    event.waitUntil(
        caches.open(PRECACHE).then(cache => {
            cache.addAll(PRECACHE_URLS);
        }).then(self.skipWaiting())
    );
});

self.addEventListener('activate', event => {

    const currentCaches = [PRECACHE, RUNTIME];
    event.waitUntil(
        caches.keys().then(cacheNames => {
            return cacheNames.filter(cacheName => !currentCaches.includes(cacheName));
        }).then(cachesToDelete => {
            return Promise.all(cachesToDelete.map(cacheToDelete => {
                return caches.delete(cacheToDelete);
            }));
        }).then(() => {
            self.clients.claim();
        })
    );

});


self.addEventListener('fetch', event => {

    if (event.request.url.startsWith(self.location.origin)) {
        event.respondWith(fromCache(event.request));

        if (isOnline()) {
            if (mode === 'cache-update') {
                if (event.request.method !== 'POST') {
                    event.waitUntil(
                            update(event.request)
                                 /*.then(refresh)*/
                            .catch(errorHandler)
                    );
                }
            }
        }
    }

});

/*function setFromCache(request) {

    console.log(self);
    updateFromCache(true);
}*/

function fromCache(request) {
    return caches.match(request).then(cachedResponse => {
        if (cachedResponse) {
            return cachedResponse;
        }

        if (isOnline()) {
            if (enableRuntimeCache) {
                 if (request.method !== 'POST') {
                    return caches.open(RUNTIME).then(cache => {
                        return fetch(request).then(response => {
                            return cache.put(request, response.clone()).then(() => {
                                return response;
                            });
                        }).catch(errorHandler);
                    });
                } else {
                    return fetch(request).then(response => {
                        console.log(response);
                        return response;
                    });
                }
            } else {
                return fetch(request).then(response => {
                    return response;
                });
            }
        }

    });
}

function update(request) {

        let asset = request.url.substr(request.url.lastIndexOf('/') + 1);
        let openCache = (PRECACHE_URLS.some(val => val.indexOf(asset) >= 0)) ? PRECACHE : RUNTIME;

        return caches.open(openCache).then(cache => {
            return fetch(`${request.url }?${new Date().valueOf()}`).then(response => {
                return cache.put(request, response.clone()).then(() => {
                    return response;
                });
            }).catch(errorHandler);
        });

}


function refresh(response) {
    return self.clients.matchAll().then(clients => {
        clients.forEach(client => {
            var message = {
                type: 'refresh',
                url: response.url,
                eTag: response.headers.get('ETag')
            };

            client.postMessage(JSON.stringify(message));
        });
    });
}

function isOnline() {
    return self.navigator.onLine;
}

function errorHandler(error) {
    if (error instanceof TypeError) {
        if (error.message.includes('Failed to fetch')) {
            console.error('(FtF) Error caught:', error);
        } else {
            console.error('Error caught:', error);
        }
    }
}

Мне нужно кэшировать ответ POST-запроса на indexDB, и он должен вести себя так же, как сервисный работник.

Не могли бы вы, пожалуйстапомогите мне?