api-def 0.12.0-alpha.39 → 0.12.0-alpha.40

package/cjs/ApiTypes.d.ts

@@ -32,7 +32,8 @@ export interface RetryOptions {
 }
 export interface BaseRequestConfig {
     debug?: boolean;
-    cache?: number | boolean;
+    clientCache?: number | boolean;
+    browserCache?: RequestCache;
     lock?: RequestLock;
     credentials?: "omit" | "same-origin" | "include";
     retry?: number | false | RetryOptions;

package/cjs/backend/AxiosRequestBackend.js

@@ -1,4 +1,15 @@
 "use strict";
+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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -79,6 +90,30 @@ var isAxiosError = function (error) {
     return "isAxiosError" in error;
 };
 exports.isAxiosError = isAxiosError;
+var getCacheHeaders = function (browserCache) {
+    switch (browserCache) {
+        case "no-store":
+            return {
+                "Cache-Control": "no-store",
+                Pragma: "no-cache",
+            };
+        case "no-cache":
+            return {
+                "Cache-Control": "no-cache",
+                Pragma: "no-cache",
+            };
+        case "force-cache":
+            return {
+                "Cache-Control": "max-age=31536000",
+            };
+        case "only-if-cached":
+            return {
+                "Cache-Control": "only-if-cached",
+            };
+        default:
+            return {};
+    }
+};
 var AxiosRequestBackend = /** @class */ (function () {
     function AxiosRequestBackend(axiosLibrary) {
         this.id = "axios";
@@ -162,7 +197,7 @@ var AxiosRequestBackend = /** @class */ (function () {
             method: context.method,
             url: url.href,
             data: context.getParsedBody(),
-            headers: requestConfig.headers || {},
+            headers: __assign(__assign({}, getCacheHeaders(requestConfig.browserCache)), requestConfig.headers),
             responseType: context.responseType,
             withCredentials: requestConfig.credentials === "include" || requestConfig.credentials === "same-origin",
             cancelToken: new axios.CancelToken(function (cancellerFunc) {

package/cjs/backend/FetchRequestBackend.js

@@ -173,12 +173,13 @@ var FetchRequestBackend = /** @class */ (function () {
             body: bodyJsonify ? JSON.stringify(body) : body,
             headers: parsedHeaders,
             signal: abortSignal,
+            cache: requestConfig.browserCache,
         };
         if ("mode" in Request.prototype) {
             fetchOptions.mode = "cors";
         }
         if ("credentials" in Request.prototype) {
-            fetchOptions.credentials = context.requestConfig.credentials ? "include" : undefined;
+            fetchOptions.credentials = requestConfig.credentials ? "include" : undefined;
         }
         if (requestConfig.debug) {
             console.log("[api-def] Fetching '".concat(url.href, "' with options"), JSON.stringify(fetchOptions, null, 2));

package/cjs/cache/ClientCacheBackend.d.ts

@@ -0,0 +1,6 @@
+export interface ClientCacheBackend {
+    getItem(key: string): Promise<any>;
+    setItem(key: string, value: any): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/cjs/cache/ClientCaching.d.ts

@@ -0,0 +1,10 @@
+import type { ClientCacheBackend } from "./ClientCacheBackend";
+export declare const setClientCacheBackend: (backend: ClientCacheBackend) => void;
+export declare const DEFAULT_CLIENT_CACHE_EXPIRY: number;
+export declare const clearClientCache: () => Promise<void>;
+export interface ClientCacheEntry {
+    data: any;
+    expiry: number | null;
+}
+export declare const setClientCachedItem: <T>(key: string, value: T, expiry?: number) => Promise<T>;
+export declare const getClientCachedItem: <T = any>(key: string) => Promise<T | undefined>;

package/cjs/cache/{Caching.js → ClientCaching.js}

@@ -36,19 +36,19 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCachedItem = exports.setCachedItem = exports.clearCache = exports.DEFAULT_CACHE_EXPIRY = exports.setCacheBackend = void 0;
-var LocalStorageCacheBackend_1 = require("./LocalStorageCacheBackend");
-var cacheBackend = new LocalStorageCacheBackend_1.default();
-var setCacheBackend = function (backend) {
-    cacheBackend = backend;
+exports.getClientCachedItem = exports.setClientCachedItem = exports.clearClientCache = exports.DEFAULT_CLIENT_CACHE_EXPIRY = exports.setClientCacheBackend = void 0;
+var LocalStorageClientCacheBackend_1 = require("./LocalStorageClientCacheBackend");
+var clientCacheBackend = new LocalStorageClientCacheBackend_1.default();
+var setClientCacheBackend = function (backend) {
+    clientCacheBackend = backend;
 };
-exports.setCacheBackend = setCacheBackend;
-exports.DEFAULT_CACHE_EXPIRY = 60 * 1000 * 15;
-var clearCache = function () {
-    return cacheBackend.clear();
+exports.setClientCacheBackend = setClientCacheBackend;
+exports.DEFAULT_CLIENT_CACHE_EXPIRY = 60 * 1000 * 15;
+var clearClientCache = function () {
+    return clientCacheBackend.clear();
 };
-exports.clearCache = clearCache;
-var setCachedItem = function (key, value, expiry) { return __awaiter(void 0, void 0, void 0, function () {
+exports.clearClientCache = clearClientCache;
+var setClientCachedItem = function (key, value, expiry) { return __awaiter(void 0, void 0, void 0, function () {
     var entry;
     return __generator(this, function (_a) {
         switch (_a.label) {
@@ -57,19 +57,19 @@ var setCachedItem = function (key, value, expiry) { return __awaiter(void 0, voi
                     data: value,
                     expiry: expiry === undefined || Number.isNaN(expiry) ? null : expiry,
                 };
-                return [4 /*yield*/, cacheBackend.setItem(key, entry)];
+                return [4 /*yield*/, clientCacheBackend.setItem(key, entry)];
             case 1:
                 _a.sent();
                 return [2 /*return*/, value];
         }
     });
 }); };
-exports.setCachedItem = setCachedItem;
-var getCachedItem = function (key) { return __awaiter(void 0, void 0, void 0, function () {
+exports.setClientCachedItem = setClientCachedItem;
+var getClientCachedItem = function (key) { return __awaiter(void 0, void 0, void 0, function () {
     var entry;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, cacheBackend.getItem(key)];
+            case 0: return [4 /*yield*/, clientCacheBackend.getItem(key)];
             case 1:
                 entry = _a.sent();
                 if (!entry) {
@@ -77,7 +77,7 @@ var getCachedItem = function (key) { return __awaiter(void 0, void 0, void 0, fu
                 }
                 if (!(typeof entry.expiry === "number")) return [3 /*break*/, 3];
                 if (!(Date.now() >= entry.expiry)) return [3 /*break*/, 3];
-                return [4 /*yield*/, cacheBackend.removeItem(key)];
+                return [4 /*yield*/, clientCacheBackend.removeItem(key)];
             case 2:
                 _a.sent();
                 return [2 /*return*/, undefined];
@@ -85,4 +85,4 @@ var getCachedItem = function (key) { return __awaiter(void 0, void 0, void 0, fu
         }
     });
 }); };
-exports.getCachedItem = getCachedItem;
+exports.getClientCachedItem = getClientCachedItem;

package/cjs/cache/LocalForageClientCacheBackend.d.ts

@@ -0,0 +1,9 @@
+import type { ClientCacheBackend } from "./ClientCacheBackend";
+export default class LocalForageClientCacheBackend implements ClientCacheBackend {
+    private store;
+    constructor(localforage: any);
+    getItem(key: string): Promise<any>;
+    setItem(key: string, value: any): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/cjs/{tests/state.test.js → cache/LocalForageClientCacheBackend.js}

@@ -36,55 +36,55 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var Api_1 = require("../Api");
-it("can provide extra state to a request that a middleware can use ", function () { return __awaiter(void 0, void 0, void 0, function () {
-    var api, cookiesEndpoint, cookies;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                api = new Api_1.Api({
-                    baseUrl: "httpstat.us",
-                    name: "Http Status API",
-                    mocking: {
-                        enabled: true,
-                    },
-                    middleware: [
-                        {
-                            beforeSend: function (context) {
-                                if (context.requestConfig.state.cookies) {
-                                    context.updateHeaders({
-                                        Cookie: context.requestConfig.state.cookies,
-                                    });
-                                }
-                            },
-                        },
-                    ],
-                });
-                cookiesEndpoint = api
-                    .endpoint()
-                    .stateOf()
-                    .responseOf()
-                    .build({
-                    id: "cookies",
-                    method: "get",
-                    path: "/200",
-                    mocking: {
-                        handler: function (req, res) {
-                            return res.status(200).send({
-                                cookies: req.headers.Cookie,
-                            });
-                        },
-                    },
-                });
-                return [4 /*yield*/, cookiesEndpoint.submit({
-                        state: {
-                            cookies: "test=123",
-                        },
-                    })];
-            case 1:
-                cookies = (_a.sent()).data.cookies;
-                expect(cookies).toBe("test=123");
-                return [2 /*return*/];
-        }
-    });
-}); });
+var LocalForageClientCacheBackend = /** @class */ (function () {
+    function LocalForageClientCacheBackend(localforage) {
+        this.store = localforage.createInstance({
+            name: "requestClientCache",
+        });
+    }
+    LocalForageClientCacheBackend.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.store.getItem(key)];
+            });
+        });
+    };
+    LocalForageClientCacheBackend.prototype.setItem = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.store.setItem(key, value)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LocalForageClientCacheBackend.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.store.removeItem(key)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LocalForageClientCacheBackend.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.store.clear()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return LocalForageClientCacheBackend;
+}());
+exports.default = LocalForageClientCacheBackend;

package/cjs/cache/LocalStorageClientCacheBackend.d.ts

@@ -0,0 +1,7 @@
+import type { ClientCacheBackend } from "./ClientCacheBackend";
+export default class LocalStorageClientCacheBackend implements ClientCacheBackend {
+    getItem(key: string): Promise<any>;
+    setItem(key: string, value: any): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/cjs/cache/{LocalStorageCacheBackend.js → LocalStorageClientCacheBackend.js}

@@ -36,27 +36,27 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var LocalStorageCacheBackend = /** @class */ (function () {
-    function LocalStorageCacheBackend() {
+var LocalStorageClientCacheBackend = /** @class */ (function () {
+    function LocalStorageClientCacheBackend() {
     }
-    LocalStorageCacheBackend.prototype.clear = function () {
+    LocalStorageClientCacheBackend.prototype.getItem = function (key) {
         return __awaiter(this, void 0, void 0, function () {
+            var item;
             return __generator(this, function (_a) {
-                localStorage.clear();
-                return [2 /*return*/];
+                item = localStorage.getItem(key);
+                return [2 /*return*/, item ? JSON.parse(item) : null];
             });
         });
     };
-    LocalStorageCacheBackend.prototype.getItem = function (key) {
+    LocalStorageClientCacheBackend.prototype.setItem = function (key, value) {
         return __awaiter(this, void 0, void 0, function () {
-            var value;
             return __generator(this, function (_a) {
-                value = localStorage.getItem(key);
-                return [2 /*return*/, value ? JSON.parse(value) : null];
+                localStorage.setItem(key, JSON.stringify(value));
+                return [2 /*return*/];
             });
         });
     };
-    LocalStorageCacheBackend.prototype.removeItem = function (key) {
+    LocalStorageClientCacheBackend.prototype.removeItem = function (key) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 localStorage.removeItem(key);
@@ -64,14 +64,14 @@ var LocalStorageCacheBackend = /** @class */ (function () {
             });
         });
     };
-    LocalStorageCacheBackend.prototype.setItem = function (key, value) {
+    LocalStorageClientCacheBackend.prototype.clear = function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                localStorage.setItem(key, JSON.stringify(value));
+                localStorage.clear();
                 return [2 /*return*/];
             });
         });
     };
-    return LocalStorageCacheBackend;
+    return LocalStorageClientCacheBackend;
 }());
-exports.default = LocalStorageCacheBackend;
+exports.default = LocalStorageClientCacheBackend;

package/cjs/index.d.ts

@@ -6,10 +6,10 @@ export { default as retry } from "./util/retry";
 export type { RetryOptions } from "./util/retry/interfaces";
 export { isRequestError, type RequestError } from "./RequestError";
 export { default as Endpoint, type EndpointConfig } from "./Endpoint";
-export { clearCache, setCacheBackend } from "./cache/Caching";
-export { default as LocalStorageCacheBackend } from "./cache/LocalStorageCacheBackend";
-export { default as LocaleForageCacheBackend } from "./cache/LocalForageCacheBackend";
+export { clearClientCache, setClientCacheBackend } from "./cache/ClientCaching";
+export { default as LocalStorageClientCacheBackend } from "./cache/LocalStorageClientCacheBackend";
+export { default as LocalForageClientCacheBackend } from "./cache/LocalForageClientCacheBackend";
 export { default as AxiosRequestBackend } from "./backend/AxiosRequestBackend";
 export { default as FetchRequestBackend } from "./backend/FetchRequestBackend";
-export { default as CacheMiddleware } from "./middleware/CacheMiddleware";
+export { default as ClientCacheMiddleware } from "./middleware/ClientCacheMiddleware";
 export { default as LoggingMiddleware } from "./middleware/LoggingMiddleware";

package/cjs/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggingMiddleware = exports.CacheMiddleware = exports.FetchRequestBackend = exports.AxiosRequestBackend = exports.LocaleForageCacheBackend = exports.LocalStorageCacheBackend = exports.setCacheBackend = exports.clearCache = exports.Endpoint = exports.isRequestError = exports.retry = void 0;
+exports.LoggingMiddleware = exports.ClientCacheMiddleware = exports.FetchRequestBackend = exports.AxiosRequestBackend = exports.LocalForageClientCacheBackend = exports.LocalStorageClientCacheBackend = exports.setClientCacheBackend = exports.clearClientCache = exports.Endpoint = exports.isRequestError = exports.retry = void 0;
 __exportStar(require("./Api"), exports);
 __exportStar(require("./ApiTypes"), exports);
 __exportStar(require("./UtilTypes"), exports);
@@ -26,18 +26,18 @@ var RequestError_1 = require("./RequestError");
 Object.defineProperty(exports, "isRequestError", { enumerable: true, get: function () { return RequestError_1.isRequestError; } });
 var Endpoint_1 = require("./Endpoint");
 Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return Endpoint_1.default; } });
-var Caching_1 = require("./cache/Caching");
-Object.defineProperty(exports, "clearCache", { enumerable: true, get: function () { return Caching_1.clearCache; } });
-Object.defineProperty(exports, "setCacheBackend", { enumerable: true, get: function () { return Caching_1.setCacheBackend; } });
-var LocalStorageCacheBackend_1 = require("./cache/LocalStorageCacheBackend");
-Object.defineProperty(exports, "LocalStorageCacheBackend", { enumerable: true, get: function () { return LocalStorageCacheBackend_1.default; } });
-var LocalForageCacheBackend_1 = require("./cache/LocalForageCacheBackend");
-Object.defineProperty(exports, "LocaleForageCacheBackend", { enumerable: true, get: function () { return LocalForageCacheBackend_1.default; } });
+var ClientCaching_1 = require("./cache/ClientCaching");
+Object.defineProperty(exports, "clearClientCache", { enumerable: true, get: function () { return ClientCaching_1.clearClientCache; } });
+Object.defineProperty(exports, "setClientCacheBackend", { enumerable: true, get: function () { return ClientCaching_1.setClientCacheBackend; } });
+var LocalStorageClientCacheBackend_1 = require("./cache/LocalStorageClientCacheBackend");
+Object.defineProperty(exports, "LocalStorageClientCacheBackend", { enumerable: true, get: function () { return LocalStorageClientCacheBackend_1.default; } });
+var LocalForageClientCacheBackend_1 = require("./cache/LocalForageClientCacheBackend");
+Object.defineProperty(exports, "LocalForageClientCacheBackend", { enumerable: true, get: function () { return LocalForageClientCacheBackend_1.default; } });
 var AxiosRequestBackend_1 = require("./backend/AxiosRequestBackend");
 Object.defineProperty(exports, "AxiosRequestBackend", { enumerable: true, get: function () { return AxiosRequestBackend_1.default; } });
 var FetchRequestBackend_1 = require("./backend/FetchRequestBackend");
 Object.defineProperty(exports, "FetchRequestBackend", { enumerable: true, get: function () { return FetchRequestBackend_1.default; } });
-var CacheMiddleware_1 = require("./middleware/CacheMiddleware");
-Object.defineProperty(exports, "CacheMiddleware", { enumerable: true, get: function () { return CacheMiddleware_1.default; } });
+var ClientCacheMiddleware_1 = require("./middleware/ClientCacheMiddleware");
+Object.defineProperty(exports, "ClientCacheMiddleware", { enumerable: true, get: function () { return ClientCacheMiddleware_1.default; } });
 var LoggingMiddleware_1 = require("./middleware/LoggingMiddleware");
 Object.defineProperty(exports, "LoggingMiddleware", { enumerable: true, get: function () { return LoggingMiddleware_1.default; } });

package/cjs/middleware/ClientCacheMiddleware.d.ts

@@ -0,0 +1,7 @@
+import type { RequestMiddleware } from "../ApiTypes";
+export interface ClientCacheMiddlewareOptions {
+    defaultExpiry?: number;
+    predicate?: () => boolean;
+}
+declare const ClientCacheMiddleware: (options?: ClientCacheMiddlewareOptions) => RequestMiddleware;
+export default ClientCacheMiddleware;

package/cjs/middleware/{CacheMiddleware.js → ClientCacheMiddleware.js}

@@ -37,23 +37,25 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var ApiConstants_1 = require("../ApiConstants");
-var Caching = require("../cache/Caching");
-var CacheMiddleware = function (options) {
+var ClientCaching = require("../cache/ClientCaching");
+var ClientCacheMiddleware = function (options) {
     var _a;
     if (options === void 0) { options = {}; }
     return _a = {},
         _a[ApiConstants_1.RequestEvent.SUCCESS] = function (context) { return __awaiter(void 0, void 0, void 0, function () {
-            var cache, shouldCache, expiry;
+            var clientCache, shouldCache, expiry;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (context.method !== ApiConstants_1.RequestMethod.GET)
                             return [2 /*return*/];
-                        cache = (context.requestConfig || {}).cache;
+                        clientCache = (context.requestConfig || {}).clientCache;
                         shouldCache = !options.predicate || options.predicate();
-                        if (!(cache && shouldCache)) return [3 /*break*/, 2];
-                        expiry = typeof cache === "number" ? cache : options.defaultExpiry || Caching.DEFAULT_CACHE_EXPIRY;
-                        return [4 /*yield*/, Caching.setCachedItem(context.key, context.response, expiry)];
+                        if (!(clientCache && shouldCache)) return [3 /*break*/, 2];
+                        expiry = typeof clientCache === "number"
+                            ? clientCache
+                            : options.defaultExpiry || ClientCaching.DEFAULT_CLIENT_CACHE_EXPIRY;
+                        return [4 /*yield*/, ClientCaching.setClientCachedItem(context.key, context.response, expiry)];
                     case 1:
                         _a.sent();
                         _a.label = 2;
@@ -62,17 +64,17 @@ var CacheMiddleware = function (options) {
             });
         }); },
         _a[ApiConstants_1.RequestEvent.BEFORE_SEND] = function (context) { return __awaiter(void 0, void 0, void 0, function () {
-            var cache, shouldCache, cachedValue;
+            var clientCache, shouldCache, cachedValue;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (context.method !== ApiConstants_1.RequestMethod.GET)
                             return [2 /*return*/];
-                        cache = (context.requestConfig || {}).cache;
+                        clientCache = (context.requestConfig || {}).clientCache;
                         shouldCache = !options.predicate || options.predicate();
-                        if (!(cache && shouldCache)) return [3 /*break*/, 2];
-                        if (!cache) return [3 /*break*/, 2];
-                        return [4 /*yield*/, Caching.getCachedItem(context.key)];
+                        if (!(clientCache && shouldCache)) return [3 /*break*/, 2];
+                        if (!clientCache) return [3 /*break*/, 2];
+                        return [4 /*yield*/, ClientCaching.getClientCachedItem(context.key)];
                     case 1:
                         cachedValue = _a.sent();
                         if (cachedValue) {
@@ -89,7 +91,7 @@ var CacheMiddleware = function (options) {
                         }
                         _a.label = 2;
                     case 2:
-                        if (cache === false) {
+                        if (clientCache === false) {
                             context.updateQuery({
                                 _bust: Math.floor(Math.random() * 9000) + 1000,
                             });
@@ -104,4 +106,4 @@ var CacheMiddleware = function (options) {
         }); },
         _a;
 };
-exports.default = CacheMiddleware;
+exports.default = ClientCacheMiddleware;

package/esm/ApiTypes.d.ts

@@ -32,7 +32,8 @@ export interface RetryOptions {
 }
 export interface BaseRequestConfig {
     debug?: boolean;
-    cache?: number | boolean;
+    clientCache?: number | boolean;
+    browserCache?: RequestCache;
     lock?: RequestLock;
     credentials?: "omit" | "same-origin" | "include";
     retry?: number | false | RetryOptions;

package/esm/backend/AxiosRequestBackend.js

@@ -37,6 +37,30 @@ let axios;
 export const isAxiosError = (error) => {
     return "isAxiosError" in error;
 };
+const getCacheHeaders = (browserCache) => {
+    switch (browserCache) {
+        case "no-store":
+            return {
+                "Cache-Control": "no-store",
+                Pragma: "no-cache",
+            };
+        case "no-cache":
+            return {
+                "Cache-Control": "no-cache",
+                Pragma: "no-cache",
+            };
+        case "force-cache":
+            return {
+                "Cache-Control": "max-age=31536000",
+            };
+        case "only-if-cached":
+            return {
+                "Cache-Control": "only-if-cached",
+            };
+        default:
+            return {};
+    }
+};
 export default class AxiosRequestBackend {
     constructor(axiosLibrary) {
         this.id = "axios";
@@ -100,7 +124,7 @@ export default class AxiosRequestBackend {
             method: context.method,
             url: url.href,
             data: context.getParsedBody(),
-            headers: requestConfig.headers || {},
+            headers: Object.assign(Object.assign({}, getCacheHeaders(requestConfig.browserCache)), requestConfig.headers),
             responseType: context.responseType,
             withCredentials: requestConfig.credentials === "include" || requestConfig.credentials === "same-origin",
             cancelToken: new axios.CancelToken((cancellerFunc) => {

package/esm/backend/FetchRequestBackend.js

@@ -107,12 +107,13 @@ export default class FetchRequestBackend {
             body: bodyJsonify ? JSON.stringify(body) : body,
             headers: parsedHeaders,
             signal: abortSignal,
+            cache: requestConfig.browserCache,
         };
         if ("mode" in Request.prototype) {
             fetchOptions.mode = "cors";
         }
         if ("credentials" in Request.prototype) {
-            fetchOptions.credentials = context.requestConfig.credentials ? "include" : undefined;
+            fetchOptions.credentials = requestConfig.credentials ? "include" : undefined;
         }
         if (requestConfig.debug) {
             console.log(`[api-def] Fetching '${url.href}' with options`, JSON.stringify(fetchOptions, null, 2));

package/esm/cache/ClientCacheBackend.d.ts

@@ -0,0 +1,6 @@
+export interface ClientCacheBackend {
+    getItem(key: string): Promise<any>;
+    setItem(key: string, value: any): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/esm/cache/ClientCaching.d.ts

@@ -0,0 +1,10 @@
+import type { ClientCacheBackend } from "./ClientCacheBackend";
+export declare const setClientCacheBackend: (backend: ClientCacheBackend) => void;
+export declare const DEFAULT_CLIENT_CACHE_EXPIRY: number;
+export declare const clearClientCache: () => Promise<void>;
+export interface ClientCacheEntry {
+    data: any;
+    expiry: number | null;
+}
+export declare const setClientCachedItem: <T>(key: string, value: T, expiry?: number) => Promise<T>;
+export declare const getClientCachedItem: <T = any>(key: string) => Promise<T | undefined>;

package/esm/cache/{Caching.js → ClientCaching.js}

@@ -7,31 +7,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import LocalStorageCacheBackend from "./LocalStorageCacheBackend";
-let cacheBackend = new LocalStorageCacheBackend();
-export const setCacheBackend = (backend) => {
-    cacheBackend = backend;
+import LocalStorageClientCacheBackend from "./LocalStorageClientCacheBackend";
+let clientCacheBackend = new LocalStorageClientCacheBackend();
+export const setClientCacheBackend = (backend) => {
+    clientCacheBackend = backend;
 };
-export const DEFAULT_CACHE_EXPIRY = /* 15 mins */ 60 * 1000 * 15;
-export const clearCache = () => {
-    return cacheBackend.clear();
+export const DEFAULT_CLIENT_CACHE_EXPIRY = /* 15 mins */ 60 * 1000 * 15;
+export const clearClientCache = () => {
+    return clientCacheBackend.clear();
 };
-export const setCachedItem = (key, value, expiry) => __awaiter(void 0, void 0, void 0, function* () {
+export const setClientCachedItem = (key, value, expiry) => __awaiter(void 0, void 0, void 0, function* () {
     const entry = {
         data: value,
         expiry: expiry === undefined || Number.isNaN(expiry) ? null : expiry,
     };
-    yield cacheBackend.setItem(key, entry);
+    yield clientCacheBackend.setItem(key, entry);
     return value;
 });
-export const getCachedItem = (key) => __awaiter(void 0, void 0, void 0, function* () {
-    const entry = yield cacheBackend.getItem(key);
+export const getClientCachedItem = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    const entry = yield clientCacheBackend.getItem(key);
     if (!entry) {
         return undefined;
     }
     if (typeof entry.expiry === "number") {
         if (Date.now() >= entry.expiry) {
-            yield cacheBackend.removeItem(key);
+            yield clientCacheBackend.removeItem(key);
             return undefined;
         }
     }

package/esm/cache/LocalForageClientCacheBackend.d.ts

@@ -0,0 +1,9 @@
+import type { ClientCacheBackend } from "./ClientCacheBackend";
+export default class LocalForageClientCacheBackend implements ClientCacheBackend {
+    private store;
+    constructor(localforage: any);
+    getItem(key: string): Promise<any>;
+    setItem(key: string, value: any): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}