feat: implement Web Cache API (#15829)

6 files changed, 1122 insertions, 0 deletions

diff --git a/ext/cache/01_cache.js b/ext/cache/01_cache.js
new file mode 100644
index 000000000..9c624b5d7
--- /dev/null
+++ b/ext/cache/01_cache.js
@@ -0,0 +1,287 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+"use strict";
+
+((window) => {
+  const core = window.__bootstrap.core;
+  const webidl = window.__bootstrap.webidl;
+  const {
+    Symbol,
+    TypeError,
+    ObjectPrototypeIsPrototypeOf,
+  } = window.__bootstrap.primordials;
+  const {
+    Request,
+    toInnerResponse,
+    toInnerRequest,
+  } = window.__bootstrap.fetch;
+  const { URLPrototype } = window.__bootstrap.url;
+  const RequestPrototype = Request.prototype;
+  const { getHeader } = window.__bootstrap.headers;
+  const { readableStreamForRid } = window.__bootstrap.streams;
+
+  class CacheStorage {
+    constructor() {
+      webidl.illegalConstructor();
+    }
+
+    async open(cacheName) {
+      webidl.assertBranded(this, CacheStoragePrototype);
+      const prefix = "Failed to execute 'open' on 'CacheStorage'";
+      webidl.requiredArguments(arguments.length, 1, { prefix });
+      cacheName = webidl.converters["DOMString"](cacheName, {
+        prefix,
+        context: "Argument 1",
+      });
+      const cacheId = await core.opAsync("op_cache_storage_open", cacheName);
+      return new Cache(cacheId);
+    }
+
+    async has(cacheName) {
+      webidl.assertBranded(this, CacheStoragePrototype);
+      const prefix = "Failed to execute 'has' on 'CacheStorage'";
+      webidl.requiredArguments(arguments.length, 1, { prefix });
+      cacheName = webidl.converters["DOMString"](cacheName, {
+        prefix,
+        context: "Argument 1",
+      });
+      return await core.opAsync("op_cache_storage_has", cacheName);
+    }
+
+    async delete(cacheName) {
+      webidl.assertBranded(this, CacheStoragePrototype);
+      const prefix = "Failed to execute 'delete' on 'CacheStorage'";
+      webidl.requiredArguments(arguments.length, 1, { prefix });
+      cacheName = webidl.converters["DOMString"](cacheName, {
+        prefix,
+        context: "Argument 1",
+      });
+      return await core.opAsync("op_cache_storage_delete", cacheName);
+    }
+  }
+
+  const _id = Symbol("id");
+
+  class Cache {
+    /** @type {number} */
+    [_id];
+
+    constructor(cacheId) {
+      this[_id] = cacheId;
+    }
+
+    /** See https://w3c.github.io/ServiceWorker/#dom-cache-put */
+    async put(request, response) {
+      const prefix = "Failed to execute 'put' on 'Cache'";
+      webidl.requiredArguments(arguments.length, 2, { prefix });
+      request = webidl.converters["RequestInfo_DOMString"](request, {
+        prefix,
+        context: "Argument 1",
+      });
+      response = webidl.converters["Response"](response, {
+        prefix,
+        context: "Argument 2",
+      });
+      // Step 1.
+      let innerRequest = null;
+      // Step 2.
+      if (ObjectPrototypeIsPrototypeOf(RequestPrototype, request)) {
+        innerRequest = toInnerRequest(request);
+      } else {
+        // Step 3.
+        innerRequest = toInnerRequest(new Request(request));
+      }
+      // Step 4.
+      const reqUrl = new URL(innerRequest.url());
+      if (reqUrl.protocol !== "http:" && reqUrl.protocol !== "https:") {
+        throw new TypeError(
+          "Request url protocol must be 'http:' or 'https:'",
+        );
+      }
+      if (innerRequest.method !== "GET") {
+        throw new TypeError("Request method must be GET");
+      }
+      // Step 5.
+      const innerResponse = toInnerResponse(response);
+      // Step 6.
+      if (innerResponse.status === 206) {
+        throw new TypeError("Response status must not be 206");
+      }
+      // Step 7.
+      const varyHeader = getHeader(innerResponse.headerList, "vary");
+      if (varyHeader) {
+        const fieldValues = varyHeader.split(",").map((field) => field.trim());
+        for (const fieldValue of fieldValues) {
+          if (
+            fieldValue === "*"
+          ) {
+            throw new TypeError("Vary header must not contain '*'");
+          }
+        }
+      }
+
+      // Step 8.
+      if (innerResponse.body !== null && innerResponse.body.unusable()) {
+        throw new TypeError("Response body must not already used");
+      }
+
+      // Remove fragment from request URL before put.
+      reqUrl.hash = "";
+
+      // Step 9-11.
+      const rid = await core.opAsync(
+        "op_cache_put",
+        {
+          cacheId: this[_id],
+          requestUrl: reqUrl.toString(),
+          responseHeaders: innerResponse.headerList,
+          requestHeaders: innerRequest.headerList,
+          responseHasBody: innerResponse.body !== null,
+          responseStatus: innerResponse.status,
+          responseStatusText: innerResponse.statusMessage,
+        },
+      );
+      if (innerResponse.body) {
+        const reader = innerResponse.body.stream.getReader();
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            await core.shutdown(rid);
+            core.close(rid);
+            break;
+          } else {
+            await core.write(rid, value);
+          }
+        }
+      }
+      // Step 12-19: TODO(@satyarohith): do the insertion in background.
+    }
+
+    /** See https://w3c.github.io/ServiceWorker/#cache-match */
+    async match(request, options) {
+      const prefix = "Failed to execute 'match' on 'Cache'";
+      webidl.requiredArguments(arguments.length, 1, { prefix });
+      request = webidl.converters["RequestInfo_DOMString"](request, {
+        prefix,
+        context: "Argument 1",
+      });
+      const p = await this.#matchAll(request, options);
+      if (p.length > 0) {
+        return p[0];
+      } else {
+        return undefined;
+      }
+    }
+
+    /** See https://w3c.github.io/ServiceWorker/#cache-delete */
+    async delete(request, _options) {
+      const prefix = "Failed to execute 'delete' on 'Cache'";
+      webidl.requiredArguments(arguments.length, 1, { prefix });
+      request = webidl.converters["RequestInfo_DOMString"](request, {
+        prefix,
+        context: "Argument 1",
+      });
+      // Step 1.
+      let r = null;
+      // Step 2.
+      if (ObjectPrototypeIsPrototypeOf(RequestPrototype, request)) {
+        r = request;
+        if (request.method !== "GET") {
+          return false;
+        }
+      } else if (
+        typeof request === "string" ||
+        ObjectPrototypeIsPrototypeOf(URLPrototype, request)
+      ) {
+        r = new Request(request);
+      }
+      return await core.opAsync("op_cache_delete", {
+        cacheId: this[_id],
+        requestUrl: r.url,
+      });
+    }
+
+    /** See https://w3c.github.io/ServiceWorker/#cache-matchall
+     *
+     * Note: the function is private as we don't want to expose
+     * this API to the public yet.
+     *
+     * The function will return an array of responses.
+     */
+    async #matchAll(request, _options) {
+      // Step 1.
+      let r = null;
+      // Step 2.
+      if (ObjectPrototypeIsPrototypeOf(RequestPrototype, request)) {
+        r = request;
+        if (request.method !== "GET") {
+          return [];
+        }
+      } else if (
+        typeof request === "string" ||
+        ObjectPrototypeIsPrototypeOf(URLPrototype, request)
+      ) {
+        r = new Request(request);
+      }
+
+      // Step 5.
+      const responses = [];
+      // Step 5.2
+      if (r === null) {
+        // Step 5.3
+        // Note: we have to return all responses in the cache when
+        // the request is null.
+        // We deviate from the spec here and return an empty array
+        // as we don't expose matchAll() API.
+        return responses;
+      } else {
+        // Remove the fragment from the request URL.
+        const url = new URL(r.url);
+        url.hash = "";
+        const innerRequest = toInnerRequest(r);
+        const matchResult = await core.opAsync(
+          "op_cache_match",
+          {
+            cacheId: this[_id],
+            requestUrl: url.toString(),
+            requestHeaders: innerRequest.headerList,
+          },
+        );
+        if (matchResult) {
+          const [meta, responseBodyRid] = matchResult;
+          let body = null;
+          if (responseBodyRid !== null) {
+            body = readableStreamForRid(responseBodyRid);
+          }
+          const response = new Response(
+            body,
+            {
+              headers: meta.responseHeaders,
+              status: meta.responseStatus,
+              statusText: meta.responseStatusText,
+            },
+          );
+          responses.push(response);
+        }
+      }
+      // Step 5.4-5.5: don't apply in this context.
+
+      return responses;
+    }
+  }
+
+  webidl.configurePrototype(CacheStorage);
+  webidl.configurePrototype(Cache);
+  const CacheStoragePrototype = CacheStorage.prototype;
+
+  let cacheStorage;
+  window.__bootstrap.caches = {
+    CacheStorage,
+    Cache,
+    cacheStorage() {
+      if (!cacheStorage) {
+        cacheStorage = webidl.createBranded(CacheStorage);
+      }
+      return cacheStorage;
+    },
+  };
+})(this);
diff --git a/ext/cache/Cargo.toml b/ext/cache/Cargo.toml
new file mode 100644
index 000000000..6f6808fe7
--- /dev/null
+++ b/ext/cache/Cargo.toml
@@ -0,0 +1,22 @@
+# Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+[package]
+name = "deno_cache"
+version = "0.1.0"
+authors = ["the Deno authors"]
+edition = "2021"
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/denoland/deno"
+description = "Implementation of Cache API for Deno"
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+async-trait = "0.1"
+deno_core = { version = "0.152.0", path = "../../core" }
+rusqlite = { version = "0.28.0", features = ["unlock_notify", "bundled"] }
+serde = { version = "1.0.129", features = ["derive"] }
+sha2 = "0.10.2"
+tokio = { version = "1.19", features = ["full"] }
diff --git a/ext/cache/README.md b/ext/cache/README.md
new file mode 100644
index 000000000..7e58f6e4e
--- /dev/null
+++ b/ext/cache/README.md
@@ -0,0 +1,24 @@
+# deno_cache
+
+This crate implements the Cache API for Deno.
+
+The following APIs are implemented:
+
+- [`CacheStorage::open()`][cache_storage_open]
+- [`CacheStorage::has()`][cache_storage_has]
+- [`CacheStorage::delete()`][cache_storage_delete]
+- [`Cache::match()`][cache_match]
+- [`Cache::put()`][cache_put]
+- [`Cache::delete()`][cache_delete]
+
+Cache APIs don't support the [query options][query_options] yet.
+
+Spec: https://w3c.github.io/ServiceWorker/#cache-interface
+
+[query_options]: https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions
+[cache_storage_open]: https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage/open
+[cache_storage_has]: https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage/has
+[cache_storage_delete]: https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage/delete
+[cache_match]: https://developer.mozilla.org/en-US/docs/Web/API/Cache/match
+[cache_put]: https://developer.mozilla.org/en-US/docs/Web/API/Cache/put
+[cache_delete]: https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete
diff --git a/ext/cache/lib.deno_cache.d.ts b/ext/cache/lib.deno_cache.d.ts
new file mode 100644
index 000000000..3b03512fc
--- /dev/null
+++ b/ext/cache/lib.deno_cache.d.ts
@@ -0,0 +1,72 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+// deno-lint-ignore-file no-var
+
+/// <reference no-default-lib="true" />
+/// <reference lib="esnext" />
+
+/** @category Cache API */
+declare var caches: CacheStorage;
+
+/** @category Cache API */
+declare interface CacheStorage {
+  /** Open a cache storage for the provided name. */
+  open(cacheName: string): Promise<Cache>;
+  /** Check if cache already exists for the provided name. */
+  has(cacheName: string): Promise<boolean>;
+  /** Delete cache storage for the provided name. */
+  delete(cacheName: string): Promise<boolean>;
+}
+
+/** @category Cache API */
+declare interface Cache {
+  /**
+   * Put the provided request/response into the cache.
+   *
+   * How is the API different from browsers?
+   * 1. You cannot match cache objects using by relative paths.
+   * 2. You cannot pass options like `ignoreVary`, `ignoreMethod`, `ignoreSearch`.
+   */
+  put(request: RequestInfo | URL, response: Response): Promise<void>;
+  /**
+   * Return cache object matching the provided request.
+   *
+   * How is the API different from browsers?
+   * 1. You cannot match cache objects using by relative paths.
+   * 2. You cannot pass options like `ignoreVary`, `ignoreMethod`, `ignoreSearch`.
+   */
+  match(
+    request: RequestInfo | URL,
+    options?: CacheQueryOptions,
+  ): Promise<Response | undefined>;
+  /**
+   * Delete cache object matching the provided request.
+   *
+   * How is the API different from browsers?
+   * 1. You cannot delete cache objects using by relative paths.
+   * 2. You cannot pass options like `ignoreVary`, `ignoreMethod`, `ignoreSearch`.
+   */
+  delete(
+    request: RequestInfo | URL,
+    options?: CacheQueryOptions,
+  ): Promise<boolean>;
+}
+
+/** @category Cache API */
+declare var Cache: {
+  prototype: Cache;
+  new (name: string): Cache;
+};
+
+/** @category Cache API */
+declare var CacheStorage: {
+  prototype: CacheStorage;
+  new (): CacheStorage;
+};
+
+/** @category Cache API */
+interface CacheQueryOptions {
+  ignoreMethod?: boolean;
+  ignoreSearch?: boolean;
+  ignoreVary?: boolean;
+}
diff --git a/ext/cache/lib.rs b/ext/cache/lib.rs
new file mode 100644
index 000000000..350efbc38
--- /dev/null
+++ b/ext/cache/lib.rs
@@ -0,0 +1,214 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+mod sqlite;
+use deno_core::ByteString;
+pub use sqlite::SqliteBackedCache;
+
+use async_trait::async_trait;
+use deno_core::error::AnyError;
+use deno_core::include_js_files;
+use deno_core::op;
+use deno_core::serde::Deserialize;
+use deno_core::serde::Serialize;
+use deno_core::Extension;
+use deno_core::OpState;
+use deno_core::Resource;
+use deno_core::ResourceId;
+
+use std::cell::RefCell;
+use std::path::PathBuf;
+use std::rc::Rc;
+use std::sync::Arc;
+
+#[derive(Deserialize, Serialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct CachePutRequest {
+  pub cache_id: i64,
+  pub request_url: String,
+  pub request_headers: Vec<(ByteString, ByteString)>,
+  pub response_headers: Vec<(ByteString, ByteString)>,
+  pub response_has_body: bool,
+  pub response_status: u16,
+  pub response_status_text: String,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CacheMatchRequest {
+  pub cache_id: i64,
+  pub request_url: String,
+  pub request_headers: Vec<(ByteString, ByteString)>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CacheMatchResponse(CacheMatchResponseMeta, Option<ResourceId>);
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CacheMatchResponseMeta {
+  pub response_status: u16,
+  pub response_status_text: String,
+  pub request_headers: Vec<(ByteString, ByteString)>,
+  pub response_headers: Vec<(ByteString, ByteString)>,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CacheDeleteRequest {
+  pub cache_id: i64,
+  pub request_url: String,
+}
+
+#[async_trait]
+pub trait Cache: Clone {
+  async fn storage_open(&self, cache_name: String) -> Result<i64, AnyError>;
+  async fn storage_has(&self, cache_name: String) -> Result<bool, AnyError>;
+  async fn storage_delete(&self, cache_name: String) -> Result<bool, AnyError>;
+
+  async fn put(
+    &self,
+    request_response: CachePutRequest,
+  ) -> Result<Option<Rc<dyn Resource>>, AnyError>;
+  async fn r#match(
+    &self,
+    request: CacheMatchRequest,
+  ) -> Result<
+    Option<(CacheMatchResponseMeta, Option<Rc<dyn Resource>>)>,
+    AnyError,
+  >;
+  async fn delete(&self, request: CacheDeleteRequest)
+    -> Result<bool, AnyError>;
+}
+
+#[op]
+pub async fn op_cache_storage_open<CA>(
+  state: Rc<RefCell<OpState>>,
+  cache_name: String,
+) -> Result<i64, AnyError>
+where
+  CA: Cache + 'static,
+{
+  let cache = get_cache::<CA>(&state)?;
+  cache.storage_open(cache_name).await
+}
+
+#[op]
+pub async fn op_cache_storage_has<CA>(
+  state: Rc<RefCell<OpState>>,
+  cache_name: String,
+) -> Result<bool, AnyError>
+where
+  CA: Cache + 'static,
+{
+  let cache = get_cache::<CA>(&state)?;
+  cache.storage_has(cache_name).await
+}
+
+#[op]
+pub async fn op_cache_storage_delete<CA>(
+  state: Rc<RefCell<OpState>>,
+  cache_name: String,
+) -> Result<bool, AnyError>
+where
+  CA: Cache + 'static,
+{
+  let cache = get_cache::<CA>(&state)?;
+  cache.storage_delete(cache_name).await
+}
+
+#[op]
+pub async fn op_cache_put<CA>(
+  state: Rc<RefCell<OpState>>,
+  request_response: CachePutRequest,
+) -> Result<Option<ResourceId>, AnyError>
+where
+  CA: Cache + 'static,
+{
+  let cache = get_cache::<CA>(&state)?;
+  match cache.put(request_response).await? {
+    Some(resource) => {
+      let rid = state.borrow_mut().resource_table.add_rc_dyn(resource);
+      Ok(Some(rid))
+    }
+    None => Ok(None),
+  }
+}
+
+#[op]
+pub async fn op_cache_match<CA>(
+  state: Rc<RefCell<OpState>>,
+  request: CacheMatchRequest,
+) -> Result<Option<CacheMatchResponse>, AnyError>
+where
+  CA: Cache + 'static,
+{
+  let cache = get_cache::<CA>(&state)?;
+  match cache.r#match(request).await? {
+    Some((meta, None)) => Ok(Some(CacheMatchResponse(meta, None))),
+    Some((meta, Some(resource))) => {
+      let rid = state.borrow_mut().resource_table.add_rc_dyn(resource);
+      Ok(Some(CacheMatchResponse(meta, Some(rid))))
+    }
+    None => Ok(None),
+  }
+}
+
+#[op]
+pub async fn op_cache_delete<CA>(
+  state: Rc<RefCell<OpState>>,
+  request: CacheDeleteRequest,
+) -> Result<bool, AnyError>
+where
+  CA: Cache + 'static,
+{
+  let cache = get_cache::<CA>(&state)?;
+  cache.delete(request).await
+}
+
+pub fn get_cache<CA>(state: &Rc<RefCell<OpState>>) -> Result<CA, AnyError>
+where
+  CA: Cache + 'static,
+{
+  let mut state = state.borrow_mut();
+  if let Some(cache) = state.try_borrow::<CA>() {
+    Ok(cache.clone())
+  } else {
+    let create_cache = state.borrow::<CreateCache<CA>>().clone();
+    let cache = create_cache.0();
+    state.put(cache);
+    Ok(state.borrow::<CA>().clone())
+  }
+}
+
+#[derive(Clone)]
+pub struct CreateCache<C: Cache + 'static>(pub Arc<dyn Fn() -> C>);
+
+pub fn init<CA: Cache + 'static>(
+  maybe_create_cache: Option<CreateCache<CA>>,
+) -> Extension {
+  Extension::builder()
+    .js(include_js_files!(
+      prefix "deno:ext/cache",
+      "01_cache.js",
+    ))
+    .ops(vec![
+      op_cache_storage_open::decl::<CA>(),
+      op_cache_storage_has::decl::<CA>(),
+      op_cache_storage_delete::decl::<CA>(),
+      op_cache_put::decl::<CA>(),
+      op_cache_match::decl::<CA>(),
+      op_cache_delete::decl::<CA>(),
+    ])
+    .state(move |state| {
+      if let Some(create_cache) = maybe_create_cache.clone() {
+        state.put(create_cache);
+      }
+      Ok(())
+    })
+    .build()
+}
+
+pub fn get_declaration() -> PathBuf {
+  PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_cache.d.ts")
+}
diff --git a/ext/cache/sqlite.rs b/ext/cache/sqlite.rs
new file mode 100644
index 000000000..1e5591839
--- /dev/null
+++ b/ext/cache/sqlite.rs
@@ -0,0 +1,503 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+use async_trait::async_trait;
+use deno_core::error::AnyError;
+use deno_core::parking_lot::Mutex;
+use deno_core::AsyncRefCell;
+use deno_core::AsyncResult;
+use deno_core::ByteString;
+use deno_core::Resource;
+use deno_core::ZeroCopyBuf;
+use rusqlite::params;
+use rusqlite::Connection;
+use rusqlite::OptionalExtension;
+use tokio::io::AsyncReadExt;
+use tokio::io::AsyncWriteExt;
+
+use std::borrow::Cow;
+use std::path::PathBuf;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::SystemTime;
+use std::time::UNIX_EPOCH;
+
+use crate::Cache;
+use crate::CacheDeleteRequest;
+use crate::CacheMatchRequest;
+use crate::CacheMatchResponseMeta;
+use crate::CachePutRequest;
+
+#[derive(Clone)]
+pub struct SqliteBackedCache {
+  pub connection: Arc<Mutex<Connection>>,
+  pub cache_storage_dir: PathBuf,
+}
+
+impl SqliteBackedCache {
+  pub fn new(cache_storage_dir: PathBuf) -> Self {
+    {
+      std::fs::create_dir_all(&cache_storage_dir)
+        .expect("failed to create cache dir");
+      let path = cache_storage_dir.join("cache_metadata.db");
+      let connection = rusqlite::Connection::open(&path).unwrap_or_else(|_| {
+        panic!("failed to open cache db at {}", path.display())
+      });
+      connection
+        .execute(
+          "CREATE TABLE IF NOT EXISTS cache_storage (
+                    id              INTEGER PRIMARY KEY,
+                    cache_name      TEXT NOT NULL UNIQUE
+                )",
+          (),
+        )
+        .expect("failed to create cache_storage table");
+      connection
+        .execute(
+          "CREATE TABLE IF NOT EXISTS request_response_list (
+                    id                     INTEGER PRIMARY KEY,
+                    cache_id               INTEGER NOT NULL,
+                    request_url            TEXT NOT NULL,
+                    request_headers        BLOB NOT NULL,
+                    response_headers       BLOB NOT NULL,
+                    response_status        INTEGER NOT NULL,
+                    response_status_text   TEXT,
+                    response_body_key      TEXT,
+                    last_inserted_at       INTEGER UNSIGNED NOT NULL,
+                    FOREIGN KEY (cache_id) REFERENCES cache_storage(id) ON DELETE CASCADE,
+
+                    UNIQUE (cache_id, request_url)
+                )",
+          (),
+        )
+        .expect("failed to create request_response_list table");
+      SqliteBackedCache {
+        connection: Arc::new(Mutex::new(connection)),
+        cache_storage_dir,
+      }
+    }
+  }
+}
+
+#[async_trait]
+impl Cache for SqliteBackedCache {
+  /// Open a cache storage. Internally, this creates a row in the
+  /// sqlite db if the cache doesn't exist and returns the internal id
+  /// of the cache.
+  async fn storage_open(&self, cache_name: String) -> Result<i64, AnyError> {
+    let db = self.connection.clone();
+    let cache_storage_dir = self.cache_storage_dir.clone();
+    tokio::task::spawn_blocking(move || {
+      let db = db.lock();
+      db.execute(
+        "INSERT OR IGNORE INTO cache_storage (cache_name) VALUES (?1)",
+        params![cache_name],
+      )?;
+      let cache_id = db.query_row(
+        "SELECT id FROM cache_storage WHERE cache_name = ?1",
+        params![cache_name],
+        |row| {
+          let id: i64 = row.get(0)?;
+          Ok(id)
+        },
+      )?;
+      let responses_dir = get_responses_dir(cache_storage_dir, cache_id);
+      std::fs::create_dir_all(&responses_dir)?;
+      Ok::<i64, AnyError>(cache_id)
+    })
+    .await?
+  }
+
+  /// Check if a cache with the provided name exists.
+  /// Note: this doesn't check the disk, it only checks the sqlite db.
+  async fn storage_has(&self, cache_name: String) -> Result<bool, AnyError> {
+    let db = self.connection.clone();
+    tokio::task::spawn_blocking(move || {
+      let db = db.lock();
+      let cache_exists = db.query_row(
+        "SELECT count(cache_name) FROM cache_storage WHERE cache_name = ?1",
+        params![cache_name],
+        |row| {
+          let count: i64 = row.get(0)?;
+          Ok(count > 0)
+        },
+      )?;
+      Ok::<bool, AnyError>(cache_exists)
+    })
+    .await?
+  }
+
+  /// Delete a cache storage. Internally, this deletes the row in the sqlite db.
+  async fn storage_delete(&self, cache_name: String) -> Result<bool, AnyError> {
+    let db = self.connection.clone();
+    let cache_storage_dir = self.cache_storage_dir.clone();
+    tokio::task::spawn_blocking(move || {
+      let db = db.lock();
+      let maybe_cache_id = db
+        .query_row(
+          "DELETE FROM cache_storage WHERE cache_name = ?1 RETURNING id",
+          params![cache_name],
+          |row| {
+            let id: i64 = row.get(0)?;
+            Ok(id)
+          },
+        )
+        .optional()?;
+      if let Some(cache_id) = maybe_cache_id {
+        let cache_dir = cache_storage_dir.join(cache_id.to_string());
+        if cache_dir.exists() {
+          std::fs::remove_dir_all(cache_dir)?;
+        }
+      }
+      Ok::<bool, AnyError>(maybe_cache_id.is_some())
+    })
+    .await?
+  }
+
+  async fn put(
+    &self,
+    request_response: CachePutRequest,
+  ) -> Result<Option<Rc<dyn Resource>>, AnyError> {
+    let db = self.connection.clone();
+    let cache_storage_dir = self.cache_storage_dir.clone();
+    let now = SystemTime::now().duration_since(UNIX_EPOCH)?;
+    let response_body_key = if request_response.response_has_body {
+      Some(hash(&format!(
+        "{}_{}",
+        &request_response.request_url,
+        now.as_nanos()
+      )))
+    } else {
+      None
+    };
+
+    if let Some(body_key) = response_body_key {
+      let responses_dir =
+        get_responses_dir(cache_storage_dir, request_response.cache_id);
+      let response_path = responses_dir.join(&body_key);
+      let file = tokio::fs::File::create(response_path).await?;
+      Ok(Some(Rc::new(CachePutResource {
+        file: AsyncRefCell::new(file),
+        db,
+        put_request: request_response,
+        response_body_key: body_key,
+        start_time: now.as_secs(),
+      })))
+    } else {
+      insert_cache_asset(db, request_response, None).await?;
+      Ok(None)
+    }
+  }
+
+  async fn r#match(
+    &self,
+    request: CacheMatchRequest,
+  ) -> Result<
+    Option<(CacheMatchResponseMeta, Option<Rc<dyn Resource>>)>,
+    AnyError,
+  > {
+    let db = self.connection.clone();
+    let cache_storage_dir = self.cache_storage_dir.clone();
+    let query_result = tokio::task::spawn_blocking(move || {
+      let db = db.lock();
+      let result = db.query_row(
+        "SELECT response_body_key, response_headers, response_status, response_status_text, request_headers
+             FROM request_response_list
+             WHERE cache_id = ?1 AND request_url = ?2",
+        (request.cache_id, &request.request_url),
+        |row| {
+          let response_body_key: Option<String> = row.get(0)?;
+          let response_headers: Vec<u8> = row.get(1)?;
+          let response_status: u16 = row.get(2)?;
+          let response_status_text: String = row.get(3)?;
+          let request_headers: Vec<u8> = row.get(4)?;
+          let response_headers: Vec<(ByteString, ByteString)> = deserialize_headers(&response_headers);
+          let request_headers: Vec<(ByteString, ByteString)> = deserialize_headers(&request_headers);
+          Ok((CacheMatchResponseMeta {request_headers, response_headers,response_status,response_status_text}, response_body_key))
+        },
+      );
+      result.optional()
+    })
+    .await??;
+
+    match query_result {
+      Some((cache_meta, Some(response_body_key))) => {
+        // From https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm
+        // If there's Vary header in the response, ensure all the
+        // headers of the cached request match the query request.
+        if let Some(vary_header) =
+          get_header("vary", &cache_meta.response_headers)
+        {
+          if !vary_header_matches(
+            &vary_header,
+            &request.request_headers,
+            &cache_meta.request_headers,
+          ) {
+            return Ok(None);
+          }
+        }
+        let response_path =
+          get_responses_dir(cache_storage_dir, request.cache_id)
+            .join(response_body_key);
+        let file = tokio::fs::File::open(response_path).await?;
+        return Ok(Some((
+          cache_meta,
+          Some(Rc::new(CacheResponseResource::new(file))),
+        )));
+      }
+      Some((cache_meta, None)) => {
+        return Ok(Some((cache_meta, None)));
+      }
+      None => return Ok(None),
+    }
+  }
+
+  async fn delete(
+    &self,
+    request: CacheDeleteRequest,
+  ) -> Result<bool, AnyError> {
+    let db = self.connection.clone();
+    tokio::task::spawn_blocking(move || {
+      // TODO(@satyarohith): remove the response body from disk if one exists
+      let db = db.lock();
+      let rows_effected = db.execute(
+        "DELETE FROM request_response_list WHERE cache_id = ?1 AND request_url = ?2",
+        (request.cache_id, &request.request_url),
+      )?;
+      Ok::<bool, AnyError>(rows_effected > 0)
+    })
+    .await?
+  }
+}
+
+async fn insert_cache_asset(
+  db: Arc<Mutex<rusqlite::Connection>>,
+  put: CachePutRequest,
+  body_key_start_time: Option<(String, u64)>,
+) -> Result<Option<String>, deno_core::anyhow::Error> {
+  tokio::task::spawn_blocking(move || {
+    let maybe_response_body = {
+      let db = db.lock();
+      let mut response_body_key = None;
+      if let Some((body_key, start_time)) = body_key_start_time {
+        response_body_key = Some(body_key);
+          let last_inserted_at = db.query_row("
+          SELECT last_inserted_at FROM request_response_list
+          WHERE cache_id = ?1 AND request_url = ?2",
+          (put.cache_id, &put.request_url), |row| {
+            let last_inserted_at: i64 = row.get(0)?;
+            Ok(last_inserted_at)
+          }).optional()?;
+          if let Some(last_inserted) = last_inserted_at {
+            // Some other worker has already inserted this resource into the cache.
+            // Note: okay to unwrap() as it is always present when response_body_key is present.
+            if start_time > (last_inserted as u64) {
+              return Ok(None);
+            }
+          }
+      }
+      db.query_row(
+        "INSERT OR REPLACE INTO request_response_list
+             (cache_id, request_url, request_headers, response_headers,
+              response_body_key, response_status, response_status_text, last_inserted_at)
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)
+             RETURNING response_body_key",
+        (
+          put.cache_id,
+          put.request_url,
+          serialize_headers(&put.request_headers),
+          serialize_headers(&put.response_headers),
+          response_body_key,
+          put.response_status,
+          put.response_status_text,
+          SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs(),
+        ),
+        |row| {
+          let response_body_key: Option<String> = row.get(0)?;
+          Ok(response_body_key)
+        },
+      )?
+    };
+      Ok::<Option<String>, AnyError>(maybe_response_body)
+  }).await?
+}
+
+#[inline]
+fn get_responses_dir(cache_storage_dir: PathBuf, cache_id: i64) -> PathBuf {
+  cache_storage_dir
+    .join(cache_id.to_string())
+    .join("responses")
+}
+
+/// Check if the headers provided in the vary_header match
+/// the query request headers and the cached request headers.
+fn vary_header_matches(
+  vary_header: &ByteString,
+  query_request_headers: &[(ByteString, ByteString)],
+  cached_request_headers: &[(ByteString, ByteString)],
+) -> bool {
+  let vary_header = match std::str::from_utf8(vary_header) {
+    Ok(vary_header) => vary_header,
+    Err(_) => return false,
+  };
+  let headers = get_headers_from_vary_header(vary_header);
+  for header in headers {
+    let query_header = get_header(&header, query_request_headers);
+    let cached_header = get_header(&header, cached_request_headers);
+    if query_header != cached_header {
+      return false;
+    }
+  }
+  true
+}
+
+fn get_headers_from_vary_header(vary_header: &str) -> Vec<String> {
+  vary_header
+    .split(',')
+    .map(|s| s.trim().to_lowercase())
+    .collect()
+}
+
+fn get_header(
+  name: &str,
+  headers: &[(ByteString, ByteString)],
+) -> Option<ByteString> {
+  headers
+    .iter()
+    .find(|(k, _)| {
+      if let Ok(k) = std::str::from_utf8(k) {
+        k.eq_ignore_ascii_case(name)
+      } else {
+        false
+      }
+    })
+    .map(|(_, v)| v.to_owned())
+}
+
+impl deno_core::Resource for SqliteBackedCache {
+  fn name(&self) -> std::borrow::Cow<str> {
+    "SqliteBackedCache".into()
+  }
+}
+
+pub struct CachePutResource {
+  pub db: Arc<Mutex<rusqlite::Connection>>,
+  pub put_request: CachePutRequest,
+  pub response_body_key: String,
+  pub file: AsyncRefCell<tokio::fs::File>,
+  pub start_time: u64,
+}
+
+impl CachePutResource {
+  async fn write(self: Rc<Self>, data: ZeroCopyBuf) -> Result<usize, AnyError> {
+    let resource = deno_core::RcRef::map(&self, |r| &r.file);
+    let mut file = resource.borrow_mut().await;
+    file.write_all(&data).await?;
+    Ok(data.len())
+  }
+
+  async fn shutdown(self: Rc<Self>) -> Result<(), AnyError> {
+    let resource = deno_core::RcRef::map(&self, |r| &r.file);
+    let mut file = resource.borrow_mut().await;
+    file.flush().await?;
+    file.sync_all().await?;
+    insert_cache_asset(
+      self.db.clone(),
+      self.put_request.clone(),
+      Some((self.response_body_key.clone(), self.start_time)),
+    )
+    .await?;
+    Ok(())
+  }
+}
+
+impl Resource for CachePutResource {
+  fn name(&self) -> Cow<str> {
+    "CachePutResource".into()
+  }
+
+  fn write(self: Rc<Self>, buf: ZeroCopyBuf) -> AsyncResult<usize> {
+    Box::pin(self.write(buf))
+  }
+
+  fn shutdown(self: Rc<Self>) -> AsyncResult<()> {
+    Box::pin(self.shutdown())
+  }
+}
+
+pub struct CacheResponseResource {
+  file: AsyncRefCell<tokio::fs::File>,
+}
+
+impl CacheResponseResource {
+  fn new(file: tokio::fs::File) -> Self {
+    Self {
+      file: AsyncRefCell::new(file),
+    }
+  }
+
+  async fn read(
+    self: Rc<Self>,
+    mut buf: ZeroCopyBuf,
+  ) -> Result<(usize, ZeroCopyBuf), AnyError> {
+    let resource = deno_core::RcRef::map(&self, |r| &r.file);
+    let mut file = resource.borrow_mut().await;
+    let nread = file.read(&mut buf).await?;
+    Ok((nread, buf))
+  }
+}
+
+impl Resource for CacheResponseResource {
+  fn name(&self) -> Cow<str> {
+    "CacheResponseResource".into()
+  }
+
+  fn read_return(
+    self: Rc<Self>,
+    buf: ZeroCopyBuf,
+  ) -> AsyncResult<(usize, ZeroCopyBuf)> {
+    Box::pin(self.read(buf))
+  }
+}
+
+pub fn hash(token: &str) -> String {
+  use sha2::Digest;
+  format!("{:x}", sha2::Sha256::digest(token.as_bytes()))
+}
+
+fn serialize_headers(headers: &[(ByteString, ByteString)]) -> Vec<u8> {
+  let mut serialized_headers = Vec::new();
+  for (name, value) in headers {
+    serialized_headers.extend_from_slice(name);
+    serialized_headers.extend_from_slice(b"\r\n");
+    serialized_headers.extend_from_slice(value);
+    serialized_headers.extend_from_slice(b"\r\n");
+  }
+  serialized_headers
+}
+
+fn deserialize_headers(
+  serialized_headers: &[u8],
+) -> Vec<(ByteString, ByteString)> {
+  let mut headers = Vec::new();
+  let mut piece = None;
+  let mut start = 0;
+  for (i, byte) in serialized_headers.iter().enumerate() {
+    if byte == &b'\r' && serialized_headers.get(i + 1) == Some(&b'\n') {
+      if piece.is_none() {
+        piece = Some(start..i);
+      } else {
+        let name = piece.unwrap();
+        let value = start..i;
+        headers.push((
+          ByteString::from(&serialized_headers[name]),
+          ByteString::from(&serialized_headers[value]),
+        ));
+        piece = None;
+      }
+      start = i + 2;
+    }
+  }
+  assert!(piece.is_none());
+  assert_eq!(start, serialized_headers.len());
+  headers
+}