feat: Upgrade to Deno 1.40.3

Author: andreespirela

crates/node/polyfills/_fs/_fs_cp.js

@@ -0,0 +1,39 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+// deno-lint-ignore-file prefer-primordials
+
+import { op_node_cp, op_node_cp_sync } from "ext:core/ops";
+
+import {
+  getValidatedPath,
+  validateCpOptions,
+} from "ext:deno_node/internal/fs/utils.mjs";
+import { promisify } from "ext:deno_node/internal/util.mjs";
+
+export function cpSync(src, dest, options) {
+  validateCpOptions(options);
+  const srcPath = getValidatedPath(src, "src");
+  const destPath = getValidatedPath(dest, "dest");
+
+  op_node_cp_sync(srcPath, destPath);
+}
+
+export function cp(src, dest, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = {};
+  }
+  validateCpOptions(options);
+  const srcPath = getValidatedPath(src, "src");
+  const destPath = getValidatedPath(dest, "dest");
+
+  op_node_cp(
+    srcPath,
+    destPath,
+  ).then(
+    (res) => callback(null, res),
+    (err) => callback(err, null),
+  );
+}
+
+export const cpPromise = promisify(cp);

crates/sb_core/cache/module_info.rs

@@ -0,0 +1,337 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+use std::sync::Arc;
+
+use deno_ast::MediaType;
+use deno_ast::ModuleSpecifier;
+use deno_core::error::AnyError;
+use deno_core::serde_json;
+use deno_graph::DefaultModuleAnalyzer;
+use deno_graph::ModuleInfo;
+use deno_graph::ModuleParser;
+use deno_runtime::deno_webstorage::rusqlite::params;
+
+use super::cache_db::CacheDB;
+use super::cache_db::CacheDBConfiguration;
+use super::cache_db::CacheFailure;
+use super::FastInsecureHasher;
+
+const SELECT_MODULE_INFO: &str = "
+SELECT
+  module_info
+FROM
+  moduleinfocache
+WHERE
+  specifier=?1
+  AND media_type=?2
+  AND source_hash=?3
+LIMIT 1";
+
+pub static MODULE_INFO_CACHE_DB: CacheDBConfiguration = CacheDBConfiguration {
+  table_initializer: "CREATE TABLE IF NOT EXISTS moduleinfocache (
+      specifier TEXT PRIMARY KEY,
+      media_type TEXT NOT NULL,
+      source_hash TEXT NOT NULL,
+      module_info TEXT NOT NULL
+    );",
+  on_version_change: "DELETE FROM moduleinfocache;",
+  preheat_queries: &[SELECT_MODULE_INFO],
+  on_failure: CacheFailure::InMemory,
+};
+
+pub struct ModuleInfoCacheSourceHash(String);
+
+impl ModuleInfoCacheSourceHash {
+  pub fn new(hash: u64) -> Self {
+    Self(hash.to_string())
+  }
+
+  pub fn from_source(source: &[u8]) -> Self {
+    Self::new(FastInsecureHasher::hash(source))
+  }
+
+  pub fn as_str(&self) -> &str {
+    &self.0
+  }
+}
+
+/// A cache of `deno_graph::ModuleInfo` objects. Using this leads to a considerable
+/// performance improvement because when it exists we can skip parsing a module for
+/// deno_graph.
+pub struct ModuleInfoCache {
+  conn: CacheDB,
+}
+
+impl ModuleInfoCache {
+  #[cfg(test)]
+  pub fn new_in_memory(version: &'static str) -> Self {
+    Self::new(CacheDB::in_memory(&MODULE_INFO_CACHE_DB, version))
+  }
+
+  pub fn new(conn: CacheDB) -> Self {
+    Self { conn }
+  }
+
+  /// Useful for testing: re-create this cache DB with a different current version.
+  #[cfg(test)]
+  pub(crate) fn recreate_with_version(self, version: &'static str) -> Self {
+    Self {
+      conn: self.conn.recreate_with_version(version),
+    }
+  }
+
+  pub fn get_module_info(
+    &self,
+    specifier: &ModuleSpecifier,
+    media_type: MediaType,
+    expected_source_hash: &ModuleInfoCacheSourceHash,
+  ) -> Result<Option<ModuleInfo>, AnyError> {
+    let query = SELECT_MODULE_INFO;
+    let res = self.conn.query_row(
+      query,
+      params![
+        &specifier.as_str(),
+        serialize_media_type(media_type),
+        expected_source_hash.as_str(),
+      ],
+      |row| {
+        let module_info: String = row.get(0)?;
+        let module_info = serde_json::from_str(&module_info)?;
+        Ok(module_info)
+      },
+    )?;
+    Ok(res)
+  }
+
+  pub fn set_module_info(
+    &self,
+    specifier: &ModuleSpecifier,
+    media_type: MediaType,
+    source_hash: &ModuleInfoCacheSourceHash,
+    module_info: &ModuleInfo,
+  ) -> Result<(), AnyError> {
+    let sql = "
+      INSERT OR REPLACE INTO
+        moduleinfocache (specifier, media_type, source_hash, module_info)
+      VALUES
+        (?1, ?2, ?3, ?4)";
+    self.conn.execute(
+      sql,
+      params![
+        specifier.as_str(),
+        serialize_media_type(media_type),
+        source_hash.as_str(),
+        &serde_json::to_string(&module_info)?,
+      ],
+    )?;
+    Ok(())
+  }
+
+  pub fn as_module_analyzer<'a>(
+    &'a self,
+    parser: &'a dyn ModuleParser,
+  ) -> ModuleInfoCacheModuleAnalyzer<'a> {
+    ModuleInfoCacheModuleAnalyzer {
+      module_info_cache: self,
+      parser,
+    }
+  }
+}
+
+pub struct ModuleInfoCacheModuleAnalyzer<'a> {
+  module_info_cache: &'a ModuleInfoCache,
+  parser: &'a dyn ModuleParser,
+}
+
+impl<'a> deno_graph::ModuleAnalyzer for ModuleInfoCacheModuleAnalyzer<'a> {
+  fn analyze(
+    &self,
+    specifier: &ModuleSpecifier,
+    source: Arc<str>,
+    media_type: MediaType,
+  ) -> Result<ModuleInfo, deno_ast::Diagnostic> {
+    // attempt to load from the cache
+    let source_hash = ModuleInfoCacheSourceHash::from_source(source.as_bytes());
+    match self.module_info_cache.get_module_info(
+      specifier,
+      media_type,
+      &source_hash,
+    ) {
+      Ok(Some(info)) => return Ok(info),
+      Ok(None) => {}
+      Err(err) => {
+        log::debug!(
+          "Error loading module cache info for {}. {:#}",
+          specifier,
+          err
+        );
+      }
+    }
+
+    // otherwise, get the module info from the parsed source cache
+    let analyzer = DefaultModuleAnalyzer::new(self.parser);
+    let module_info = analyzer.analyze(specifier, source, media_type)?;
+
+    // then attempt to cache it
+    if let Err(err) = self.module_info_cache.set_module_info(
+      specifier,
+      media_type,
+      &source_hash,
+      &module_info,
+    ) {
+      log::debug!(
+        "Error saving module cache info for {}. {:#}",
+        specifier,
+        err
+      );
+    }
+
+    Ok(module_info)
+  }
+}
+
+// todo(dsherret): change this to be stored as an integer next time
+// the cache version is bumped
+fn serialize_media_type(media_type: MediaType) -> &'static str {
+  use MediaType::*;
+  match media_type {
+    JavaScript => "1",
+    Jsx => "2",
+    Mjs => "3",
+    Cjs => "4",
+    TypeScript => "5",
+    Mts => "6",
+    Cts => "7",
+    Dts => "8",
+    Dmts => "9",
+    Dcts => "10",
+    Tsx => "11",
+    Json => "12",
+    Wasm => "13",
+    TsBuildInfo => "14",
+    SourceMap => "15",
+    Unknown => "16",
+  }
+}
+
+#[cfg(test)]
+mod test {
+  use deno_graph::PositionRange;
+  use deno_graph::SpecifierWithRange;
+
+  use super::*;
+
+  #[test]
+  pub fn module_info_cache_general_use() {
+    let cache = ModuleInfoCache::new_in_memory("1.0.0");
+    let specifier1 =
+      ModuleSpecifier::parse("https://localhost/mod.ts").unwrap();
+    let specifier2 =
+      ModuleSpecifier::parse("https://localhost/mod2.ts").unwrap();
+    assert_eq!(
+      cache
+        .get_module_info(
+          &specifier1,
+          MediaType::JavaScript,
+          &ModuleInfoCacheSourceHash::new(1)
+        )
+        .unwrap(),
+      None
+    );
+
+    let mut module_info = ModuleInfo::default();
+    module_info.jsdoc_imports.push(SpecifierWithRange {
+      range: PositionRange {
+        start: deno_graph::Position {
+          line: 0,
+          character: 3,
+        },
+        end: deno_graph::Position {
+          line: 1,
+          character: 2,
+        },
+      },
+      text: "test".to_string(),
+    });
+    cache
+      .set_module_info(
+        &specifier1,
+        MediaType::JavaScript,
+        &ModuleInfoCacheSourceHash::new(1),
+        &module_info,
+      )
+      .unwrap();
+    assert_eq!(
+      cache
+        .get_module_info(
+          &specifier1,
+          MediaType::JavaScript,
+          &ModuleInfoCacheSourceHash::new(1)
+        )
+        .unwrap(),
+      Some(module_info.clone())
+    );
+    assert_eq!(
+      cache
+        .get_module_info(
+          &specifier2,
+          MediaType::JavaScript,
+          &ModuleInfoCacheSourceHash::new(1)
+        )
+        .unwrap(),
+      None,
+    );
+    // different media type
+    assert_eq!(
+      cache
+        .get_module_info(
+          &specifier1,
+          MediaType::TypeScript,
+          &ModuleInfoCacheSourceHash::new(1)
+        )
+        .unwrap(),
+      None,
+    );
+    // different source hash
+    assert_eq!(
+      cache
+        .get_module_info(
+          &specifier1,
+          MediaType::JavaScript,
+          &ModuleInfoCacheSourceHash::new(2)
+        )
+        .unwrap(),
+      None,
+    );
+
+    // try recreating with the same version
+    let cache = cache.recreate_with_version("1.0.0");
+
+    // should get it
+    assert_eq!(
+      cache
+        .get_module_info(
+          &specifier1,
+          MediaType::JavaScript,
+          &ModuleInfoCacheSourceHash::new(1)
+        )
+        .unwrap(),
+      Some(module_info)
+    );
+
+    // try recreating with a different version
+    let cache = cache.recreate_with_version("1.0.1");
+
+    // should no longer exist
+    assert_eq!(
+      cache
+        .get_module_info(
+          &specifier1,
+          MediaType::JavaScript,
+          &ModuleInfoCacheSourceHash::new(1)
+        )
+        .unwrap(),
+      None,
+    );
+  }
+}