Merge pull request #262 from supabase/bump-d-version

feat: Upgrade to Deno 1.40.3

Author: andreespirela

Cargo.lock

@@ -18,39 +18,41 @@ resolver = "2"
 
 [workspace.dependencies]
 url = { version = "2.3.1" }
-eszip = "0.56.0"
+eszip = "0.60.0"
 log = "0.4.20"
 anyhow = { version = "1.0.57" }
 libc = { version = "0.2.144" }
-deno_ast = { version = "0.31.6", features = ["transpiling"] }
-deno_broadcast_channel = { version = "0.124.0" }
-deno_core = { version = "0.243.0" }
-deno_console = { version = "0.130.0" }
-deno_crypto =  { version = "0.144.0" }
-deno_fetch = { version = "0.154.0" }
-deno_fs = { version = "0.40.0", features = ["sync_fs"] }
-deno_config = "=0.3.1"
-deno_io = "0.40.0"
-deno_graph = "=0.62.2"
-deno_http =  { version = "0.127.0" }
+deno_ast = { version = "0.32.0", features = ["transpiling"] }
+deno_broadcast_channel = { version = "0.130.0" }
+deno_core = { version = "0.256.0" }
+deno_console = { version = "0.136.0" }
+deno_crypto =  { version = "0.150.0" }
+deno_fetch = { version = "0.160.0" }
+deno_fs = { version = "0.46.0", features = ["sync_fs"] }
+deno_config = "=0.9.1"
+deno_io = "0.46.0"
+deno_webgpu = "0.103.0"
+deno_canvas = "0.5.0"
+deno_graph = "=0.64.1"
+deno_http =  { version = "0.133.0" }
 deno_media_type = { version = "0.1.1", features = ["module_specifier"] }
-deno_net = { version = "0.122.0" }
-deno_npm = "0.15.3"
-deno_url = { version = "0.130.0" }
-deno_semver = "0.5.1"
-deno_tls = { version = "0.117.0"}
-deno_webidl = { version = "0.130.0" }
-deno_web = { version = "0.161.0" }
-deno_websocket = { version = "0.135.0" }
-deno_webstorage = { version = "0.125.0" }
+deno_net = { version = "0.128.0" }
+deno_npm = "0.16.0"
+deno_url = { version = "0.136.0" }
+deno_semver = "0.5.4"
+deno_tls = { version = "0.123.0"}
+deno_webidl = { version = "0.136.0" }
+deno_web = { version = "0.167.0" }
+deno_websocket = { version = "0.141.0" }
+deno_webstorage = { version = "0.131.0" }
 enum-as-inner = "0.6.0"
 serde = { version = "1.0.149", features = ["derive"] }
 hyper = "0.14.26"
 tokio = { version = "1.28.1", features = ["full"] }
 bytes = { version = "1.4.0" }
 once_cell = "1.17.1"
 thiserror = "1.0.40"
-deno_lockfile = "0.17.2"
+deno_lockfile = "0.18.0"
 async-trait = "0.1.73"
 indexmap = { version = "2.0.0", features = ["serde"] }
 flate2 = "=1.0.26"

Cargo.toml

@@ -60,6 +60,8 @@ urlencoding.workspace = true
 scopeguard.workspace = true
 pin-project = { version = "1.1.3" }
 ctor = { workspace = true }
+deno_canvas.workspace = true
+deno_webgpu.workspace = true
 
 [dev-dependencies]
 flaky_test = { version = "0.1.0", path = "../flaky_test" }
@@ -98,4 +100,6 @@ tokio.workspace = true
 url.workspace = true
 event_worker ={ version = "0.1.0", path = "../event_worker" }
 deno_broadcast_channel.workspace = true
-deno_core.workspace = true
+deno_core.workspace = true
+deno_canvas.workspace = true
+deno_webgpu.workspace = true

crates/base/Cargo.toml

@@ -156,6 +156,14 @@ mod supabase_startup_snapshot {
         fn check_sys(&self, _kind: &str, _api_name: &str) -> Result<(), AnyError> {
             unreachable!("snapshotting!")
         }
+
+        fn check_write_with_api_name(
+            &self,
+            _path: &Path,
+            _api_name: Option<&str>,
+        ) -> Result<(), AnyError> {
+            unreachable!("snapshotting!")
+        }
     }
 
     pub fn create_runtime_snapshot(snapshot_path: PathBuf) {
@@ -170,6 +178,8 @@ mod supabase_startup_snapshot {
                 Arc::new(deno_web::BlobStore::default()),
                 None,
             ),
+            deno_webgpu::deno_webgpu::init_ops_and_esm(),
+            deno_canvas::deno_canvas::init_ops_and_esm(),
             deno_fetch::deno_fetch::init_ops_and_esm::<Permissions>(deno_fetch::Options {
                 user_agent: user_agent.clone(),
                 root_cert_store_provider: None,

crates/base/build.rs

@@ -8,7 +8,7 @@ use ctor::ctor;
 use deno_core::error::AnyError;
 use deno_core::url::Url;
 use deno_core::{
-    located_script_name, serde_v8, JsRuntime, ModuleCode, ModuleId, PollEventLoopOptions,
+    located_script_name, serde_v8, JsRuntime, ModuleCodeString, ModuleId, PollEventLoopOptions,
     RuntimeOptions,
 };
 use deno_http::DefaultHttpPropertyExtractor;
@@ -247,6 +247,8 @@ impl DenoRuntime {
                 Arc::new(deno_web::BlobStore::default()),
                 None,
             ),
+            deno_webgpu::deno_webgpu::init_ops(),
+            deno_canvas::deno_canvas::init_ops(),
             deno_fetch::deno_fetch::init_ops::<Permissions>(deno_fetch::Options {
                 user_agent: user_agent.clone(),
                 root_cert_store_provider: Some(root_cert_store_provider.clone()),
@@ -319,7 +321,7 @@ impl DenoRuntime {
         );
 
         js_runtime
-            .execute_script(located_script_name!(), ModuleCode::from(script))
+            .execute_script(located_script_name!(), ModuleCodeString::from(script))
             .expect("Failed to execute bootstrap script");
 
         {
@@ -539,7 +541,7 @@ fn set_v8_flags() {
 mod test {
     use crate::deno_runtime::DenoRuntime;
     use crate::rt_worker::worker::UnixStreamEntry;
-    use deno_core::{FastString, ModuleCode, PollEventLoopOptions};
+    use deno_core::{FastString, ModuleCodeString, PollEventLoopOptions};
     use sb_graph::emitter::EmitterFactory;
     use sb_graph::{generate_binary_eszip, EszipPayloadKind};
     use sb_workers::context::{
@@ -634,7 +636,7 @@ mod test {
             .js_runtime
             .execute_script(
                 "<anon>",
-                ModuleCode::from(
+                ModuleCodeString::from(
                     r#"
             globalThis.isTenEven;
         "#
@@ -695,7 +697,7 @@ mod test {
             .js_runtime
             .execute_script(
                 "<anon>",
-                ModuleCode::from(
+                ModuleCodeString::from(
                     r#"
             globalThis.isTenEven;
         "#
@@ -798,7 +800,7 @@ mod test {
             .js_runtime
             .execute_script(
                 "<anon>",
-                ModuleCode::from(
+                ModuleCodeString::from(
                     r#"
             Deno.readTextFileSync("./test_cases/readFile/hello_world.json");
         "#
@@ -853,7 +855,7 @@ mod test {
             .js_runtime
             .execute_script(
                 "<anon>",
-                ModuleCode::from(
+                ModuleCodeString::from(
                     r#"
             // Should not be able to set
             const data = {
@@ -947,7 +949,7 @@ mod test {
 
         let user_rt_execute_scripts = user_rt.js_runtime.execute_script(
             "<anon>",
-            ModuleCode::from(
+            ModuleCodeString::from(
                 r#"
             let cmd = new Deno.Command("", {});
             cmd.outputSync();
@@ -980,7 +982,7 @@ mod test {
             .js_runtime
             .execute_script(
                 "<anon>",
-                ModuleCode::from(
+                ModuleCodeString::from(
                     r#"
             // Should not be able to set
             Deno.env.set("Supa_Test", "Supa_Value");
@@ -998,7 +1000,7 @@ mod test {
             .js_runtime
             .execute_script(
                 "<anon>",
-                ModuleCode::from(
+                ModuleCodeString::from(
                     r#"
             // Should not be able to set
             Deno.env.get("Supa_Test");
@@ -1017,7 +1019,7 @@ mod test {
             .js_runtime
             .execute_script(
                 "<anon>",
-                ModuleCode::from(
+                ModuleCodeString::from(
                     r#"
             // Should not be able to set
             Deno.env.get("Supa_Test");

crates/base/src/deno_runtime.rs

@@ -1 +1 @@
-DENO_VERSION="1.39.2"
+DENO_VERSION="1.40.3"

crates/cli/.env.build

@@ -379,6 +379,16 @@ static RESERVED_WORDS: Lazy<HashSet<&str>> = Lazy::new(|| {
 fn add_export(source: &mut Vec<String>, name: &str, initializer: &str, temp_var_count: &mut usize) {
     fn is_valid_var_decl(name: &str) -> bool {
         // it's ok to be super strict here
+        if name.is_empty() {
+            return false;
+        }
+
+        if let Some(first) = name.chars().next() {
+            if !first.is_ascii_alphabetic() && first != '_' && first != '$' {
+                return false;
+            }
+        }
+
         name.chars()
             .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '$')
     }
@@ -465,7 +475,7 @@ mod tests {
         let mut temp_var_count = 0;
         let mut source = vec![];
 
-        let exports = vec!["static", "server", "app", "dashed-export"];
+        let exports = vec!["static", "server", "app", "dashed-export", "3d"];
         for export in exports {
             add_export(&mut source, export, "init", &mut temp_var_count);
         }
@@ -478,6 +488,8 @@ mod tests {
                 "export const app = init;".to_string(),
                 "const __deno_export_2__ = init;".to_string(),
                 "export { __deno_export_2__ as \"dashed-export\" };".to_string(),
+                "const __deno_export_3__ = init;".to_string(),
+                "export { __deno_export_3__ as \"3d\" };".to_string(),
             ]
         )
     }

crates/node/analyze.rs

@@ -57,6 +57,11 @@ pub trait NodePermissions {
     fn check_read_with_api_name(&self, path: &Path, api_name: Option<&str>)
         -> Result<(), AnyError>;
     fn check_sys(&self, kind: &str, api_name: &str) -> Result<(), AnyError>;
+    fn check_write_with_api_name(
+        &self,
+        path: &Path,
+        api_name: Option<&str>,
+    ) -> Result<(), AnyError>;
 }
 
 pub(crate) struct AllowAllNodePermissions;
@@ -72,6 +77,13 @@ impl NodePermissions for AllowAllNodePermissions {
     ) -> Result<(), AnyError> {
         Ok(())
     }
+    fn check_write_with_api_name(
+        &self,
+        _path: &Path,
+        _api_name: Option<&str>,
+    ) -> Result<(), AnyError> {
+        Ok(())
+    }
     fn check_sys(&self, _kind: &str, _api_name: &str) -> Result<(), AnyError> {
         Ok(())
     }
@@ -226,6 +238,8 @@ deno_core::extension!(deno_node,
     ops::crypto::x509::op_node_x509_get_serial_number,
     ops::crypto::x509::op_node_x509_key_usage,
     ops::fs::op_node_fs_exists_sync<P>,
+    ops::fs::op_node_cp_sync<P>,
+    ops::fs::op_node_cp<P>,
     ops::winerror::op_node_sys_to_uv_error,
     ops::v8::op_v8_cached_data_version_tag,
     ops::v8::op_v8_get_heap_statistics,
@@ -317,6 +331,7 @@ deno_core::extension!(deno_node,
     "_fs/_fs_common.ts",
     "_fs/_fs_constants.ts",
     "_fs/_fs_copy.ts",
+    "_fs/_fs_cp.js",
     "_fs/_fs_dir.ts",
     "_fs/_fs_dirent.ts",
     "_fs/_fs_exists.ts",
@@ -359,7 +374,7 @@ deno_core::extension!(deno_node,
     "_stream.mjs",
     "_tls_common.ts",
     "_tls_wrap.ts",
-    "_util/_util_callbackify.ts",
+    "_util/_util_callbackify.js",
     "_util/asserts.ts",
     "_util/async.ts",
     "_util/os.ts",

crates/node/lib.rs

@@ -25,7 +25,8 @@ enum Cipher {
     Aes256Ecb(Box<ecb::Encryptor<aes::Aes256>>),
     Aes128Gcm(Box<Aes128Gcm>),
     Aes256Gcm(Box<Aes256Gcm>),
-    // TODO(kt3k): add more algorithms Aes192Cbc, Aes256Cbc, etc.
+    Aes256Cbc(Box<cbc::Encryptor<aes::Aes256>>),
+    // TODO(kt3k): add more algorithms Aes192Cbc, etc.
 }
 
 enum Decipher {
@@ -35,7 +36,8 @@ enum Decipher {
     Aes256Ecb(Box<ecb::Decryptor<aes::Aes256>>),
     Aes128Gcm(Box<Aes128Gcm>),
     Aes256Gcm(Box<Aes256Gcm>),
-    // TODO(kt3k): add more algorithms Aes192Cbc, Aes256Cbc, Aes128GCM, etc.
+    Aes256Cbc(Box<cbc::Decryptor<aes::Aes256>>),
+    // TODO(kt3k): add more algorithms Aes192Cbc, Aes128GCM, etc.
 }
 
 pub struct CipherContext {
@@ -124,6 +126,9 @@ impl Cipher {
 
                 Aes256Gcm(Box::new(cipher))
             }
+            "aes256" | "aes-256-cbc" => {
+                Aes256Cbc(Box::new(cbc::Encryptor::new(key.into(), iv.into())))
+            }
             _ => return Err(type_error(format!("Unknown cipher {algorithm_name}"))),
         })
     }
@@ -177,6 +182,12 @@ impl Cipher {
                 output[..input.len()].copy_from_slice(input);
                 cipher.encrypt(output);
             }
+            Aes256Cbc(encryptor) => {
+                assert!(input.len() % 16 == 0);
+                for (input, output) in input.chunks(16).zip(output.chunks_mut(16)) {
+                    encryptor.encrypt_block_b2b_mut(input.into(), output.into());
+                }
+            }
         }
     }
 
@@ -211,6 +222,12 @@ impl Cipher {
             }
             Aes128Gcm(cipher) => Ok(Some(cipher.finish().to_vec())),
             Aes256Gcm(cipher) => Ok(Some(cipher.finish().to_vec())),
+            Aes256Cbc(encryptor) => {
+                let _ = (*encryptor)
+                    .encrypt_padded_b2b_mut::<Pkcs7>(input, output)
+                    .map_err(|_| type_error("Cannot pad the input data"))?;
+                Ok(None)
+            }
         }
     }
 }
@@ -235,6 +252,9 @@ impl Decipher {
 
                 Aes256Gcm(Box::new(decipher))
             }
+            "aes256" | "aes-256-cbc" => {
+                Aes256Cbc(Box::new(cbc::Decryptor::new(key.into(), iv.into())))
+            }
             _ => return Err(type_error(format!("Unknown cipher {algorithm_name}"))),
         })
     }
@@ -288,6 +308,12 @@ impl Decipher {
                 output[..input.len()].copy_from_slice(input);
                 decipher.decrypt(output);
             }
+            Aes256Cbc(decryptor) => {
+                assert!(input.len() % 16 == 0);
+                for (input, output) in input.chunks(16).zip(output.chunks_mut(16)) {
+                    decryptor.decrypt_block_b2b_mut(input.into(), output.into());
+                }
+            }
         }
     }
 
@@ -339,6 +365,13 @@ impl Decipher {
                     Err(type_error("Failed to authenticate data"))
                 }
             }
+            Aes256Cbc(decryptor) => {
+                assert!(input.len() == 16);
+                let _ = (*decryptor)
+                    .decrypt_padded_b2b_mut::<Pkcs7>(input, output)
+                    .map_err(|_| type_error("Cannot unpad the input data"))?;
+                Ok(())
+            }
         }
     }
 }