How to load a module not from the file system?

[Aworldc]

I'm using a SimpleModuleLoader. It loads modules from the file system without issue, but I want to also load a module from a string.

Say I have an entry point being loaded at runtime, like

import { do_something } from 'internal-module'

do_something()

and somewhere in the rust code I have a string containing

export let do_something = () => {}

how do I get boa to load internal-module from that string and not just try to read a file called internal-module?

[nekevss]

Hi there! You should be able to use Module::parse to load a rust string as a module.

For a full example of loading, linking and evaluating a module, you can see the docs on Module::load_link_evaluate, which shows the full cycle of creating a module from a Rust &str and loading, linking, and evaluating the module's source code.

[Aworldc]

Sorry for the code dump, but the issue is, that with the following code, whilst it loads main.js fine, it tries to read a module from a file called internal instead of using the module I inserted in main.rs, giving

TypeError: could not open file `internal`

instead.

src/main.rs:

use {
    boa_engine::{
        Context, JsResult, JsValue, Module, NativeFunction, Source,
        builtins::promise::PromiseState, js_string, module::SimpleModuleLoader,
    },
    std::{env::current_dir, error::Error, path::PathBuf, rc::Rc},
};

fn main() -> Result<(), Box<dyn Error>> {
    let file_path = current_dir()?.join("main.js");

    let loader = Rc::new(SimpleModuleLoader::new(file_path.parent().unwrap())?);
    let mut context = Context::builder().module_loader(loader.clone()).build()?;

    let source = Source::from_bytes("export let output_sum = (a, b) => print(a + b)");
    let module = Module::parse(source, None, &mut context)?;
    loader.insert(PathBuf::from("internal"), module);

    let source = Source::from_filepath(&file_path)?;
    let module = Module::parse(source, None, &mut context)?;
    loader.insert(file_path, module.clone());

    context.register_global_callable(
        js_string!("print"),
        0,
        NativeFunction::from_fn_ptr(|_, args: &[JsValue], _| -> JsResult<JsValue> {
            println!(
                "{}",
                args.iter()
                    .map(|val| match val {
                        JsValue::String(js_string) => js_string.to_std_string().unwrap(),
                        _ => val.display_obj(false),
                    })
                    .reduce(|a, b| a + &b)
                    .unwrap_or("".to_owned())
            );

            Ok(JsValue::undefined())
        }),
    )?;

    let promise = module.load_link_evaluate(&mut context);

    context.run_jobs();

    match promise.state() {
        PromiseState::Pending => Err("Engine exited early".into()),
        PromiseState::Fulfilled(_) => Ok(()),
        PromiseState::Rejected(js_value) => Err(js_value.display().to_string().into()),
    }
}

main.js:

import { output_sum } from 'internal'

output_sum(2, 4)

[nekevss]

Oh, sweet! Thanks, its a bit easier with the example.

So the primary issue is that you are not loading the source file with a path. If you use Source::from_reader, you should be able to set the path on the source text. Then you just load the module, and you should be good to go.

The below should run (at least it did for me 😄):

use {
    boa_engine::{
        Context, JsResult, JsValue, Module, NativeFunction, Source,
        builtins::promise::PromiseState, js_string, module::SimpleModuleLoader,
    },
    std::{env::current_dir, error::Error, rc::Rc},
};

fn main() -> Result<(), Box<dyn Error>> {
    let dir = current_dir()?; // Changed for personal preference
    let file_path = dir.join("main.js");

    let loader = Rc::new(SimpleModuleLoader::new(&dir)?);
    let mut context = Context::builder().module_loader(loader.clone()).build()?;

    // NOTE: We supply the source with the module path
    let module_path = dir.join("internal"); // Declare module path
    let source = Source::from_reader("export let output_sum = (a, b) => print(a + b)".as_bytes(), Some(&module_path)); // Read source text with path
    let module = Module::parse(source, None, &mut context)?;
    loader.insert(module_path, module); // insert module

    let source = Source::from_filepath(&file_path)?;
    let module = Module::parse(source, None, &mut context)?;
    loader.insert(file_path, module.clone());

    context.register_global_callable(
        js_string!("print"),
        0,
        NativeFunction::from_fn_ptr(|_, args: &[JsValue], _| -> JsResult<JsValue> {
            println!(
                "{}",
                args.iter()
                    .map(|val| match val {
                        JsValue::String(js_string) => js_string.to_std_string().unwrap(),
                        _ => val.display_obj(false),
                    })
                    .reduce(|a, b| a + &b)
                    .unwrap_or("".to_owned())
            );

            Ok(JsValue::undefined())
        }),
    )?;

    let promise = module.load_link_evaluate(&mut context);

    context.run_jobs();

    match promise.state() {
        PromiseState::Pending => Err("Engine exited early".into()),
        PromiseState::Fulfilled(_) => Ok(()),
        PromiseState::Rejected(js_value) => Err(js_value.display().to_string().into()),
    }
}

Also, important to note that the file name must match your import, so if you name the filename "internal.mjs" then the import needs to be from "internal.mjs", not "internal".

[Aworldc]

Don't know why, but that ain't working. Got it working by writing a custom ModuleLoader that takes in a function that maps paths to strings of js:

use {
    boa_engine::{
        Context, JsError, JsResult, JsString, Module, Source,
        module::{ModuleLoader, resolve_module_specifier},
    },
    std::{env::current_dir, error::Error},
};

type MyResult<T> = Result<T, Box<dyn Error>>;

struct ModuleResolver(fn(written_path: String, resolved_path: String) -> MyResult<String>);

impl ModuleLoader for ModuleResolver {
    fn load_imported_module(
        &self,
        referrer: boa_engine::module::Referrer,
        specifier: JsString,
        finish_load: Box<dyn FnOnce(JsResult<Module>, &mut Context)>,
        context: &mut Context,
    ) {
        finish_load(
            (|| {
                let cwd = current_dir()?;

                let relative_path = specifier.to_std_string()?;
                let absolute_path =
                    resolve_module_specifier(Some(&cwd), &specifier, referrer.path(), context)?
                        .strip_prefix(cwd)?
                        .to_str()
                        .ok_or("A module path is not valid unicode")?
                        .to_string();

                let code = self.0(relative_path, absolute_path)?;

                let source = Source::from_bytes(code.as_bytes());
                let module = Module::parse(source, None, context)?;

                Ok(module)
            })()
            .map_err(|err: Box<dyn Error>| JsError::from_rust(err.as_ref())),
            context,
        );
    }
}