@netlify/cache 1.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2022 Netlify <team@netlify.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+[![Build](https://github.com/netlify/cache/workflows/Build/badge.svg)](https://github.com/netlify/cache/actions)
+[![Node](https://img.shields.io/node/v/@netlify/cache.svg?logo=node.js)](https://www.npmjs.com/package/@netlify/cache)
+
+# @netlify/cache
+
+TypeScript utilities for interacting with the Netlify cache.
+
+## Installation
+
+You can install `@netlify/cache` via npm:
+
+```shell
+npm install @netlify/cache
+```

package/dist/bootstrap/main.cjs

@@ -0,0 +1,225 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// src/bootstrap/main.ts
+var main_exports = {};
+__export(main_exports, {
+  NetlifyCache: () => NetlifyCache,
+  NetlifyCacheStorage: () => NetlifyCacheStorage
+});
+module.exports = __toCommonJS(main_exports);
+
+// src/bootstrap/cache.ts
+var import_node_buffer = require("buffer");
+var HEADERS_HEADER = "Netlify-Programmable-Headers";
+var STATUS_HEADER = "Netlify-Programmable-Status";
+var STORE_HEADER = "Netlify-Programmable-Store";
+var allowedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
+var discardedHeaders = /* @__PURE__ */ new Set(["cookie", "content-encoding", "content-length"]);
+var _getToken, _getURL, _name;
+var NetlifyCache = class {
+  constructor({ getToken, getURL, name }) {
+    __privateAdd(this, _getToken, void 0);
+    __privateAdd(this, _getURL, void 0);
+    __privateAdd(this, _name, void 0);
+    __privateSet(this, _getToken, getToken);
+    __privateSet(this, _getURL, getURL);
+    __privateSet(this, _name, name);
+  }
+  async add(request) {
+    await this.put(new Request(request), await fetch(request));
+  }
+  async addAll(requests) {
+    await Promise.allSettled(requests.map((request) => this.add(request)));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async matchAll(request, _options) {
+    if (!request) {
+      return [];
+    }
+    const res = await this.match(request);
+    return res ? [res] : [];
+  }
+  async put(request, response) {
+    if (!response.ok) {
+      throw new TypeError(`Cannot cache response with status ${response.status}.`);
+    }
+    if (request instanceof Request && request.method !== "GET") {
+      throw new TypeError(`Cannot cache response to ${request.method} request.`);
+    }
+    if (response.status === 206) {
+      throw new TypeError("Cannot cache response to a range request (206 Partial Content).");
+    }
+    if (response.headers.get("vary")?.includes("*")) {
+      throw new TypeError("Cannot cache response with 'Vary: *' header.");
+    }
+    const resourceURL = extractAndValidateURL(request);
+    await fetch(`${__privateGet(this, _getURL).call(this)}/${toCacheKey(resourceURL)}`, {
+      body: response.body,
+      headers: {
+        Authorization: `Bearer ${__privateGet(this, _getToken).call(this)}`,
+        [HEADERS_HEADER]: getEncodedHeaders(response.headers),
+        [STATUS_HEADER]: response.status.toString(),
+        [STORE_HEADER]: __privateGet(this, _name)
+      },
+      // @ts-expect-error https://github.com/whatwg/fetch/pull/1457
+      duplex: "half",
+      method: "POST"
+    });
+  }
+  async match(request) {
+    try {
+      const resourceURL = extractAndValidateURL(request);
+      const cacheURL = `${__privateGet(this, _getURL).call(this)}/${toCacheKey(resourceURL)}`;
+      const response = await fetch(cacheURL, {
+        headers: {
+          Authorization: `Bearer ${__privateGet(this, _getToken).call(this)}`
+        },
+        method: "GET"
+      });
+      if (!response.ok) {
+        return;
+      }
+      return response;
+    } catch {
+    }
+  }
+  // eslint-disable-next-line class-methods-use-this, require-await, @typescript-eslint/no-unused-vars
+  async delete(request) {
+    const resourceURL = extractAndValidateURL(request);
+    await fetch(`${__privateGet(this, _getURL).call(this)}/${toCacheKey(resourceURL)}`, {
+      headers: {
+        Authorization: `Bearer ${__privateGet(this, _getToken).call(this)}`,
+        [STORE_HEADER]: __privateGet(this, _name)
+      },
+      method: "DELETE"
+    });
+    return true;
+  }
+  // eslint-disable-next-line class-methods-use-this, require-await, @typescript-eslint/no-unused-vars
+  async keys(_request) {
+    return [];
+  }
+};
+_getToken = new WeakMap();
+_getURL = new WeakMap();
+_name = new WeakMap();
+var getEncodedHeaders = (headers) => {
+  const headersMap = {};
+  headers.forEach((value, key) => {
+    if (discardedHeaders.has(key)) {
+      return;
+    }
+    if (key === "set-cookie") {
+      headersMap[key] = headersMap[key] || [];
+      headersMap[key].push(value);
+    } else {
+      headersMap[key] = value.split(",");
+    }
+  });
+  return import_node_buffer.Buffer.from(JSON.stringify(headersMap), "utf8").toString("base64");
+};
+var extractAndValidateURL = (input) => {
+  let url;
+  if (input instanceof Request) {
+    url = new URL(input.url);
+  } else {
+    try {
+      url = new URL(String(input));
+    } catch {
+      throw new TypeError(`${input} is not a valid URL.`);
+    }
+  }
+  if (!allowedProtocols.has(url.protocol)) {
+    throw new TypeError(
+      `Cannot cache response for URL with unsupported protocol (${url.protocol}). Supported protocols are ${[
+        ...allowedProtocols
+      ].join(", ")}.`
+    );
+  }
+  return url;
+};
+var toCacheKey = (url) => encodeURIComponent(url.toString());
+
+// src/bootstrap/cachestorage.ts
+var _getToken2, _getURL2, _stores;
+var NetlifyCacheStorage = class {
+  constructor({ getToken, getURL }) {
+    __privateAdd(this, _getToken2, void 0);
+    __privateAdd(this, _getURL2, void 0);
+    __privateAdd(this, _stores, void 0);
+    __privateSet(this, _getToken2, getToken);
+    __privateSet(this, _getURL2, getURL);
+    __privateSet(this, _stores, /* @__PURE__ */ new Map());
+  }
+  open(name) {
+    let store = __privateGet(this, _stores).get(name);
+    if (!store) {
+      store = new NetlifyCache({ getToken: __privateGet(this, _getToken2), getURL: __privateGet(this, _getURL2), name });
+      __privateGet(this, _stores).set(name, store);
+    }
+    return Promise.resolve(store);
+  }
+  has(name) {
+    return Promise.resolve(__privateGet(this, _stores).has(name));
+  }
+  delete(name) {
+    return Promise.resolve(__privateGet(this, _stores).delete(name));
+  }
+  keys() {
+    return Promise.resolve([...__privateGet(this, _stores).keys()]);
+  }
+  async match(request, options) {
+    if (options?.cacheName) {
+      return __privateGet(this, _stores).get(options.cacheName)?.match(request);
+    }
+    for (const store of __privateGet(this, _stores).values()) {
+      const response = await store.match(request);
+      if (response === void 0) {
+        return;
+      }
+    }
+  }
+};
+_getToken2 = new WeakMap();
+_getURL2 = new WeakMap();
+_stores = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NetlifyCache,
+  NetlifyCacheStorage
+});

package/dist/bootstrap/main.d.cts

@@ -0,0 +1,37 @@
+type Factory<T> = () => T;
+
+interface NetlifyCacheOptions {
+    getToken: Factory<string>;
+    getURL: Factory<string>;
+    name: string;
+}
+declare class NetlifyCache implements Cache {
+    #private;
+    constructor({ getToken, getURL, name }: NetlifyCacheOptions);
+    add(request: RequestInfo): Promise<void>;
+    addAll(requests: RequestInfo[]): Promise<void>;
+    matchAll(request?: RequestInfo, _options?: CacheQueryOptions): Promise<readonly Response[]>;
+    put(request: RequestInfo | URL | string, response: Response): Promise<void>;
+    match(request: RequestInfo): Promise<Response | undefined>;
+    delete(request: RequestInfo): Promise<boolean>;
+    keys(_request?: Request): Promise<never[]>;
+}
+
+interface NetlifyCacheStorageOptions {
+    getToken: Factory<string>;
+    getURL: Factory<string>;
+}
+declare class NetlifyCacheStorage {
+    #private;
+    constructor({ getToken, getURL }: NetlifyCacheStorageOptions);
+    open(name: string): Promise<Cache>;
+    has(name: string): Promise<boolean>;
+    delete(name: string): Promise<boolean>;
+    keys(): Promise<string[]>;
+    match(request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>;
+}
+
+type TokenFactory = Factory<string>;
+type URLFactory = Factory<string>;
+
+export { NetlifyCache, NetlifyCacheStorage, TokenFactory, URLFactory };

package/dist/bootstrap/main.d.ts

@@ -0,0 +1,37 @@
+type Factory<T> = () => T;
+
+interface NetlifyCacheOptions {
+    getToken: Factory<string>;
+    getURL: Factory<string>;
+    name: string;
+}
+declare class NetlifyCache implements Cache {
+    #private;
+    constructor({ getToken, getURL, name }: NetlifyCacheOptions);
+    add(request: RequestInfo): Promise<void>;
+    addAll(requests: RequestInfo[]): Promise<void>;
+    matchAll(request?: RequestInfo, _options?: CacheQueryOptions): Promise<readonly Response[]>;
+    put(request: RequestInfo | URL | string, response: Response): Promise<void>;
+    match(request: RequestInfo): Promise<Response | undefined>;
+    delete(request: RequestInfo): Promise<boolean>;
+    keys(_request?: Request): Promise<never[]>;
+}
+
+interface NetlifyCacheStorageOptions {
+    getToken: Factory<string>;
+    getURL: Factory<string>;
+}
+declare class NetlifyCacheStorage {
+    #private;
+    constructor({ getToken, getURL }: NetlifyCacheStorageOptions);
+    open(name: string): Promise<Cache>;
+    has(name: string): Promise<boolean>;
+    delete(name: string): Promise<boolean>;
+    keys(): Promise<string[]>;
+    match(request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>;
+}
+
+type TokenFactory = Factory<string>;
+type URLFactory = Factory<string>;
+
+export { NetlifyCache, NetlifyCacheStorage, TokenFactory, URLFactory };

package/dist/bootstrap/main.js

@@ -0,0 +1,198 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// src/bootstrap/cache.ts
+import { Buffer as Buffer2 } from "buffer";
+var HEADERS_HEADER = "Netlify-Programmable-Headers";
+var STATUS_HEADER = "Netlify-Programmable-Status";
+var STORE_HEADER = "Netlify-Programmable-Store";
+var allowedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
+var discardedHeaders = /* @__PURE__ */ new Set(["cookie", "content-encoding", "content-length"]);
+var _getToken, _getURL, _name;
+var NetlifyCache = class {
+  constructor({ getToken, getURL, name }) {
+    __privateAdd(this, _getToken, void 0);
+    __privateAdd(this, _getURL, void 0);
+    __privateAdd(this, _name, void 0);
+    __privateSet(this, _getToken, getToken);
+    __privateSet(this, _getURL, getURL);
+    __privateSet(this, _name, name);
+  }
+  async add(request) {
+    await this.put(new Request(request), await fetch(request));
+  }
+  async addAll(requests) {
+    await Promise.allSettled(requests.map((request) => this.add(request)));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async matchAll(request, _options) {
+    if (!request) {
+      return [];
+    }
+    const res = await this.match(request);
+    return res ? [res] : [];
+  }
+  async put(request, response) {
+    if (!response.ok) {
+      throw new TypeError(`Cannot cache response with status ${response.status}.`);
+    }
+    if (request instanceof Request && request.method !== "GET") {
+      throw new TypeError(`Cannot cache response to ${request.method} request.`);
+    }
+    if (response.status === 206) {
+      throw new TypeError("Cannot cache response to a range request (206 Partial Content).");
+    }
+    if (response.headers.get("vary")?.includes("*")) {
+      throw new TypeError("Cannot cache response with 'Vary: *' header.");
+    }
+    const resourceURL = extractAndValidateURL(request);
+    await fetch(`${__privateGet(this, _getURL).call(this)}/${toCacheKey(resourceURL)}`, {
+      body: response.body,
+      headers: {
+        Authorization: `Bearer ${__privateGet(this, _getToken).call(this)}`,
+        [HEADERS_HEADER]: getEncodedHeaders(response.headers),
+        [STATUS_HEADER]: response.status.toString(),
+        [STORE_HEADER]: __privateGet(this, _name)
+      },
+      // @ts-expect-error https://github.com/whatwg/fetch/pull/1457
+      duplex: "half",
+      method: "POST"
+    });
+  }
+  async match(request) {
+    try {
+      const resourceURL = extractAndValidateURL(request);
+      const cacheURL = `${__privateGet(this, _getURL).call(this)}/${toCacheKey(resourceURL)}`;
+      const response = await fetch(cacheURL, {
+        headers: {
+          Authorization: `Bearer ${__privateGet(this, _getToken).call(this)}`
+        },
+        method: "GET"
+      });
+      if (!response.ok) {
+        return;
+      }
+      return response;
+    } catch {
+    }
+  }
+  // eslint-disable-next-line class-methods-use-this, require-await, @typescript-eslint/no-unused-vars
+  async delete(request) {
+    const resourceURL = extractAndValidateURL(request);
+    await fetch(`${__privateGet(this, _getURL).call(this)}/${toCacheKey(resourceURL)}`, {
+      headers: {
+        Authorization: `Bearer ${__privateGet(this, _getToken).call(this)}`,
+        [STORE_HEADER]: __privateGet(this, _name)
+      },
+      method: "DELETE"
+    });
+    return true;
+  }
+  // eslint-disable-next-line class-methods-use-this, require-await, @typescript-eslint/no-unused-vars
+  async keys(_request) {
+    return [];
+  }
+};
+_getToken = new WeakMap();
+_getURL = new WeakMap();
+_name = new WeakMap();
+var getEncodedHeaders = (headers) => {
+  const headersMap = {};
+  headers.forEach((value, key) => {
+    if (discardedHeaders.has(key)) {
+      return;
+    }
+    if (key === "set-cookie") {
+      headersMap[key] = headersMap[key] || [];
+      headersMap[key].push(value);
+    } else {
+      headersMap[key] = value.split(",");
+    }
+  });
+  return Buffer2.from(JSON.stringify(headersMap), "utf8").toString("base64");
+};
+var extractAndValidateURL = (input) => {
+  let url;
+  if (input instanceof Request) {
+    url = new URL(input.url);
+  } else {
+    try {
+      url = new URL(String(input));
+    } catch {
+      throw new TypeError(`${input} is not a valid URL.`);
+    }
+  }
+  if (!allowedProtocols.has(url.protocol)) {
+    throw new TypeError(
+      `Cannot cache response for URL with unsupported protocol (${url.protocol}). Supported protocols are ${[
+        ...allowedProtocols
+      ].join(", ")}.`
+    );
+  }
+  return url;
+};
+var toCacheKey = (url) => encodeURIComponent(url.toString());
+
+// src/bootstrap/cachestorage.ts
+var _getToken2, _getURL2, _stores;
+var NetlifyCacheStorage = class {
+  constructor({ getToken, getURL }) {
+    __privateAdd(this, _getToken2, void 0);
+    __privateAdd(this, _getURL2, void 0);
+    __privateAdd(this, _stores, void 0);
+    __privateSet(this, _getToken2, getToken);
+    __privateSet(this, _getURL2, getURL);
+    __privateSet(this, _stores, /* @__PURE__ */ new Map());
+  }
+  open(name) {
+    let store = __privateGet(this, _stores).get(name);
+    if (!store) {
+      store = new NetlifyCache({ getToken: __privateGet(this, _getToken2), getURL: __privateGet(this, _getURL2), name });
+      __privateGet(this, _stores).set(name, store);
+    }
+    return Promise.resolve(store);
+  }
+  has(name) {
+    return Promise.resolve(__privateGet(this, _stores).has(name));
+  }
+  delete(name) {
+    return Promise.resolve(__privateGet(this, _stores).delete(name));
+  }
+  keys() {
+    return Promise.resolve([...__privateGet(this, _stores).keys()]);
+  }
+  async match(request, options) {
+    if (options?.cacheName) {
+      return __privateGet(this, _stores).get(options.cacheName)?.match(request);
+    }
+    for (const store of __privateGet(this, _stores).values()) {
+      const response = await store.match(request);
+      if (response === void 0) {
+        return;
+      }
+    }
+  }
+};
+_getToken2 = new WeakMap();
+_getURL2 = new WeakMap();
+_stores = new WeakMap();
+export {
+  NetlifyCache,
+  NetlifyCacheStorage
+};

package/dist/main.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/main.ts
+var main_exports = {};
+module.exports = __toCommonJS(main_exports);

package/dist/main.d.cts

@@ -0,0 +1,2 @@
+
+export { }

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+
+export { }

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@netlify/cache",
+  "version": "1.1.0",
+  "description": "TypeScript utilities for interacting with the Netlify cache",
+  "type": "module",
+  "engines": {
+    "node": "^14.16.0 || >=16.0.0"
+  },
+  "main": "./dist/main.cjs",
+  "module": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/main.d.cts",
+        "default": "./dist/main.cjs"
+      },
+      "import": {
+        "types": "./dist/main.d.ts",
+        "default": "./dist/main.js"
+      },
+      "default": {
+        "types": "./dist/main.d.ts",
+        "default": "./dist/main.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./bootstrap": {
+      "require": {
+        "types": "./dist/bootstrap/main.d.cts",
+        "default": "./dist/bootstrap/main.cjs"
+      },
+      "import": {
+        "types": "./dist/bootstrap/main.d.ts",
+        "default": "./dist/bootstrap/main.js"
+      },
+      "default": {
+        "types": "./dist/bootstrap/main.d.ts",
+        "default": "./dist/bootstrap/main.js"
+      }
+    }
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "run-s build:*",
+    "build:check": "tsc",
+    "build:transpile": "node build.mjs",
+    "dev": "node build.mjs --watch",
+    "prepack": "npm run build",
+    "test": "run-s build test:dev",
+    "test:dev": "run-s build test:dev:*",
+    "test:ci": "run-s build test:ci:*",
+    "test:dev:vitest": "vitest run",
+    "test:dev:vitest:watch": "vitest watch",
+    "test:ci:vitest": "vitest run"
+  },
+  "keywords": [],
+  "license": "MIT",
+  "repository": "netlify/cache",
+  "bugs": {
+    "url": "https://github.com/netlify/cache/issues"
+  },
+  "author": "Netlify Inc.",
+  "directories": {
+    "test": "test"
+  },
+  "devDependencies": {
+    "npm-run-all2": "^7.0.2",
+    "semver": "^7.5.3",
+    "tmp-promise": "^3.0.3",
+    "tsup": "^7.2.0",
+    "typescript": "^5.0.0",
+    "vitest": "^0.34.0"
+  }
+}