oss/starmelon
oss/starmelon
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: upgrade starmelon dependencies

Browse source 
Upgrade deno_core 0.65 -> 0.127
This commit is contained in:
nobody 2023-09-22 20:41:34 +00:00
commit bdccb9cb88
Signed by: GrocerPublishAgent
GPG key ID: D460CD54A9E3AB86
6 changed files with 47 additions and 125 deletions
Download patch file Download diff file Expand all files Collapse all files

18
src/exec/astrid_pages.rs
View file

@ -5,6 +5,7 @@ use deno_core::{v8, Extension, OpState};
use elm_project_utils::{setup_generator_project, ElmPostProcessor, ElmResult};
use os_pipe::dup_stderr;
use sqlx::sqlite::SqlitePool;
use std::borrow::Cow;
use std::cell::RefCell;
use std::convert::TryFrom;
use std::fs;
@ -258,18 +259,17 @@ pub(crate) fn run(
let mailbox: Arc<RefCell<Option<Result<Vec<u8>, ScriptError>>>> = Arc::new(RefCell::new(None));
let mailbox_clone = Arc::clone(&mailbox);
let mut extensions = vec![Extension::builder()
.ops(vec![
let mut extensions = vec![Extension {
ops: Cow::Owned(vec![
op_starmelon_bytes_output::decl(),
op_starmelon_string_output::decl(),
op_starmelon_problem::decl(),
])
.state(move |state| {
]),
op_state_fn: Some(Box::new(move |state| {
state.put(Arc::clone(&mailbox_clone));
Ok(())
})
.build()];
})),
..Default::default()
}];
let sql_background_thread_handle = if let Some(database_url) = sqlite_path {
// I want to construct the connection in the initial thread so I can tell if the connection
@ -358,7 +358,7 @@ fn op_starmelon_problem(
#[deno_core::op]
fn op_starmelon_bytes_output(
state: &mut OpState,
msg: ElmResult<deno_core::ZeroCopyBuf, ScriptError>,
msg: ElmResult<deno_core::JsBuffer, ScriptError>,
) -> Result<(), deno_core::error::AnyError> {
let mailbox_clone = state.borrow::<OutputMailbox>();
if let Ok(mut mailbox) = mailbox_clone.try_borrow_mut() {

14
src/exec/css_in_elm.rs
View file

@ -4,6 +4,7 @@ use deno_core::{Extension, OpState};
use elm_project_utils::{setup_generator_project, ElmPostProcessor};
use os_pipe::dup_stderr;
use serde::Deserialize;
use std::borrow::Cow;
use std::cell::RefCell;
use std::fs;
use std::io::Write;
@ -174,14 +175,13 @@ pub(crate) fn run(
let mailbox: Arc<RefCell<Option<Vec<FileDefinition>>>> = Arc::new(RefCell::new(None));
let mailbox_clone = Arc::clone(&mailbox);
let extensions = vec![Extension::builder()
.ops(vec![op_starmelon_elm_css_files_output::decl()])
.state(move |state| {
let extensions = vec![Extension {
ops: Cow::Owned(vec![op_starmelon_elm_css_files_output::decl()]),
op_state_fn: Some(Box::new(move |state| {
state.put(Arc::clone(&mailbox_clone));
Ok(())
})
.build()];
})),
..Default::default()
}];
drop(timing_guard);

16
src/exec/fixtures/sqlite.rs
View file

@ -1,9 +1,10 @@
use deno_core::futures::StreamExt;
use deno_core::{Extension, OpState};
use deno_core::{Extension, Op, OpState};
use elm_project_utils::ElmResult;
use serde::{Deserialize, Serialize};
use serde_json::{value::Map, value::Number, Value};
use sqlx::{sqlite::SqlitePool, Column, Row, TypeInfo, ValueRef};
use std::borrow::Cow;
use std::thread::JoinHandle;
use std::time::Instant;
use tokio;
@ -111,14 +112,13 @@ pub(crate) fn init(db_pool: SqlitePool) -> Result<(Extension, JoinHandle<()>), (
}
});
let worker_mailbox_clone = worker_mailbox.clone();
let extension = Extension::builder()
.ops(vec![op_starmelon_batch_queries::decl()])
.state(move |state| {
let extension = Extension {
ops: Cow::Owned(vec![op_starmelon_batch_queries::DECL]),
op_state_fn: Some(Box::new(move |state| {
state.put(worker_mailbox_clone.clone());
Ok(())
})
.build();
})),
..Default::default()
};
Ok((extension, sql_worker_thread))
}

94
src/exec/mod.rs
View file

@ -175,7 +175,7 @@ mod runtime {
use deno_core::futures::FutureExt;
use deno_core::{resolve_url, Extension, FsModuleLoader, ModuleLoader, ModuleSpecifier};
use deno_runtime::deno_broadcast_channel::InMemoryBroadcastChannel;
use deno_runtime::permissions::Permissions;
use deno_runtime::permissions::PermissionsContainer;
use deno_runtime::worker::MainWorker;
use deno_runtime::worker::WorkerOptions;
use deno_runtime::BootstrapOptions;
@ -193,53 +193,29 @@ mod runtime {
extensions: Vec<Extension>,
path_str: &str,
) -> Result<(MainWorker, ModuleSpecifier), AnyError> {
//let module_loader = Rc::new(EmbeddedModuleLoader("void".to_owned()));
let module_loader = Rc::new(FsModuleLoader);
let create_web_worker_cb = Arc::new(|_| {
todo!("Web workers are not supported in the example");
});
let web_worker_preload_module_cb = Arc::new(|_| {
todo!("Web workers are not supported in the example");
});
let options = WorkerOptions {
bootstrap: BootstrapOptions {
args: vec![],
cpu_count: 1,
debug_flag: false,
enable_testing_features: false,
location: None,
no_color: false,
is_tty: false,
runtime_version: "0.50.0".to_string(),
runtime_version: "0.127.0".to_string(),
ts_version: "2.0.0".to_string(),
unstable: false,
user_agent: "starmelon".to_string(),
..Default::default()
},
extensions: extensions,
unsafely_ignore_certificate_errors: None,
root_cert_store: None,
seed: None,
module_loader,
create_web_worker_cb,
web_worker_preload_module_cb,
format_js_error_fn: None,
source_map_getter: None,
maybe_inspector_server: None,
should_break_on_first_statement: false,
get_error_class_fn: Some(&get_error_class_name),
origin_storage_dir: None,
blob_store: BlobStore::default(),
broadcast_channel: InMemoryBroadcastChannel::default(),
shared_array_buffer_store: None,
compiled_wasm_module_store: None,
stdio: deno_runtime::ops::io::Stdio::default(),
extensions,
..Default::default()
};
let main_module = deno_core::resolve_path(path_str)?;
// note: resolve_url is just calling url::Url::parse and mapping the error type
// let main_module = resolve_url(SPECIFIER)?;
let permissions = Permissions::allow_all();
let main_module = ModuleSpecifier::from_file_path(path_str)
.map_err(|_| AnyError::msg("path is not absolute"))?;
let permissions = PermissionsContainer::allow_all();
let worker = MainWorker::from_options(main_module.clone(), permissions, options);
//worker.bootstrap(&options);
@ -277,58 +253,4 @@ mod runtime {
Ok(())
}
const SPECIFIER: &str = "file://$deno$/bundle.js";
struct EmbeddedModuleLoader(String);
impl ModuleLoader for EmbeddedModuleLoader {
fn resolve(
&self,
specifier: &str,
_referrer: &str,
_is_main: bool,
) -> Result<ModuleSpecifier, AnyError> {
if let Ok(module_specifier) = resolve_url(specifier) {
//if get_source_from_data_url(&module_specifier).is_ok()
// || specifier == SPECIFIER
//{
return Ok(module_specifier);
//}
}
Err(type_error(
"Self-contained binaries don't support module loading",
))
}
fn load(
&self,
module_specifier: &ModuleSpecifier,
_maybe_referrer: Option<ModuleSpecifier>,
_is_dyn_import: bool,
) -> Pin<Box<deno_core::ModuleSourceFuture>> {
let module_specifier = module_specifier.clone();
//let is_data_uri = get_source_from_data_url(&module_specifier).ok();
//let code = if let Some((ref source, _)) = is_data_uri {
// source.to_string()
//} else {
let code: Box<[u8]> = self.0.as_bytes().into();
//};
async move {
//if is_data_uri.is_none() && module_specifier.to_string() != SPECIFIER {
// return Err(type_error(
// "Self-contained binaries don't support module loading",
// ));
//}
Ok(deno_core::ModuleSource {
code,
module_type: deno_core::ModuleType::JavaScript,
module_url_specified: module_specifier.to_string(),
module_url_found: module_specifier.to_string(),
})
}
.boxed_local()
}
}
}

18
src/exec/scripting.rs
View file

@ -4,6 +4,7 @@ use deno_core::{Extension, OpState};
use elm_project_utils::{setup_generator_project, ElmResult};
use os_pipe::dup_stderr;
use sqlx::sqlite::SqlitePool;
use std::borrow::Cow;
use std::cell::RefCell;
use std::convert::TryFrom;
use std::fs;
@ -284,18 +285,17 @@ pub(crate) fn run(
let mailbox: Arc<RefCell<Option<Result<Vec<u8>, String>>>> = Arc::new(RefCell::new(None));
let mailbox_clone = Arc::clone(&mailbox);
let mut extensions = vec![Extension::builder()
.ops(vec![
let mut extensions = vec![Extension {
ops: Cow::Owned(vec![
op_starmelon_bytes_output::decl(),
op_starmelon_string_output::decl(),
op_starmelon_problem::decl(),
])
.state(move |state| {
]),
op_state_fn: Some(Box::new(move |state| {
state.put(Arc::clone(&mailbox_clone));
Ok(())
})
.build()];
})),
..Default::default()
}];
let span = info_span!("register private api");
let timing_guard = span.enter();
@ -483,7 +483,7 @@ fn op_starmelon_problem(
#[deno_core::op]
fn op_starmelon_bytes_output(
state: &mut OpState,
msg: ElmResult<deno_core::ZeroCopyBuf, String>,
msg: ElmResult<deno_core::JsBuffer, String>,
) -> Result<(), deno_core::error::AnyError> {
let mailbox_clone = state.borrow::<OutputMailbox>();
if let Ok(mut mailbox) = mailbox_clone.try_borrow_mut() {