fetchache 0.1.4 → 0.1.5-alpha-20230320124321-e6b82e7

package/README.md

@@ -0,0 +1,38 @@
+# Fetchache
+
+A fetch wrapper that allows you to respect HTTP caching strategies on non-browser environments with
+a key-value cache implementation. It follows the [HTTP Caching](https://tools.ietf.org/html/rfc7234)
+and [Conditional Requests](https://tools.ietf.org/html/rfc7232) standards.
+
+## Installation
+
+```bash
+yarn add fetchache
+```
+
+## Usage
+
+```ts
+import { fetchFactory } from 'fetchache'
+import { fetch, Response } from 'some-fetch-impl'
+
+// We recommend using `@whatwg-node/fetch`
+
+const someCacheImpl = {
+  get: async key => {
+    // Get the cached value from your cache implementation
+  },
+  set: async (key, value) => {
+    // Set the cached value to your cache implementation
+  }
+}
+
+const fetchWithCache = fetchFactory({
+  fetch,
+  Response,
+  cache
+})
+
+// Then you can use it like a normal fetch
+const response = await fetchWithCache('https://example.com')
+```

package/{index.js → cjs/index.js}

@@ -1,11 +1,8 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-const CachePolicy = _interopDefault(require('http-cache-semantics'));
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchFactory = void 0;
+const tslib_1 = require("tslib");
+const http_cache_semantics_1 = tslib_1.__importDefault(require("http-cache-semantics"));
 function fetchFactory({ fetch, Response, cache }) {
     return async (input, init, ...rest) => {
         let url;
@@ -28,11 +25,11 @@ function fetchFactory({ fetch, Response, cache }) {
         const policyRequest = policyRequestFrom(url, method, headers);
         if (!entry) {
             const response = await fetch(input, init, ...rest);
-            const policy = new CachePolicy(policyRequest, policyResponseFrom(response));
+            const policy = new http_cache_semantics_1.default(policyRequest, policyResponseFrom(response));
             return storeResponseAndReturnClone(cache, response, policy, cacheKey);
         }
         const { policy: policyRaw, bytes } = typeof entry === 'string' ? JSON.parse(entry) : entry;
-        const policy = CachePolicy.fromObject(policyRaw);
+        const policy = http_cache_semantics_1.default.fromObject(policyRaw);
         // Remove url from the policy, because otherwise it would never match a request with a custom cache key
         policy._url = undefined;
         const bodyInit = new Uint8Array(bytes);
@@ -90,6 +87,7 @@ function fetchFactory({ fetch, Response, cache }) {
         return new Response(uint8array, response);
     }
 }
+exports.fetchFactory = fetchFactory;
 function canBeRevalidated(response) {
     return response.headers.has('ETag');
 }
@@ -120,5 +118,3 @@ function headersToObject(headers) {
     }
     return object;
 }
-
-exports.fetchFactory = fetchFactory;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/{index.mjs → esm/index.js}

@@ -1,6 +1,5 @@
 import CachePolicy from 'http-cache-semantics';
-
-function fetchFactory({ fetch, Response, cache }) {
+export function fetchFactory({ fetch, Response, cache }) {
     return async (input, init, ...rest) => {
         let url;
         let method = 'GET';
@@ -114,5 +113,3 @@ function headersToObject(headers) {
     }
     return object;
 }
-
-export { fetchFactory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fetchache",
-  "version": "0.1.4",
+  "version": "0.1.5-alpha-20230320124321-e6b82e7",
   "description": "Cross Platform Fetch Wrapper with Key Value Cache support",
   "sideEffects": false,
   "dependencies": {
@@ -14,21 +14,28 @@
   },
   "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/index.d.cts

@@ -0,0 +1,26 @@
+import CachePolicy from 'http-cache-semantics';
+export interface FetchacheCacheEntry {
+    policy: CachePolicy.CachePolicyObject;
+    body: string;
+}
+type FetchFn = (input: URL | RequestInfo, init: RequestInit, ...rest: any[]) => Promise<Response>;
+export interface FetchacheOptions {
+    fetch: FetchFn;
+    Request: typeof Request;
+    Response: typeof Response;
+    cache: KeyValueCache<FetchacheCacheEntry>;
+}
+export declare function fetchFactory({ fetch, Response, cache }: FetchacheOptions): FetchFn;
+export interface KeyValueCacheSetOptions {
+    /**
+     * Specified in **seconds**, the time-to-live (TTL) value limits the lifespan
+     * of the data being stored in the cache.
+     */
+    ttl?: number | null;
+}
+export interface KeyValueCache<V = any> {
+    get(key: string): Promise<V | undefined>;
+    set(key: string, value: V, options?: KeyValueCacheSetOptions): Promise<void>;
+    delete(key: string): Promise<boolean | void>;
+}
+export {};

package/{index.d.ts → typings/index.d.ts}

@@ -3,7 +3,7 @@ export interface FetchacheCacheEntry {
     policy: CachePolicy.CachePolicyObject;
     body: string;
 }
-declare type FetchFn = (input: URL | RequestInfo, init: RequestInit, ...rest: any[]) => Promise<Response>;
+type FetchFn = (input: URL | RequestInfo, init: RequestInit, ...rest: any[]) => Promise<Response>;
 export interface FetchacheOptions {
     fetch: FetchFn;
     Request: typeof Request;