haste_operation_executor/providers/deno_embedded/

mod.rs

use deno_core::cppgc::GcCell;
use deno_core::error::ModuleLoaderError;

pub mod pool;

use deno_core::{
    Extension, GarbageCollected, ModuleLoadOptions, ModuleLoadReferrer, ModuleLoader, ModuleSource,
    ModuleType, OpState, op2, resolve_import, serde_json, v8,
};
// main.rs
use deno_core::error::AnyError;
use haste_fhir_client::FHIRClient;
use haste_fhir_model::r4::generated::resources::ResourceType;
use haste_fhir_operation_error::OperationOutcomeError;
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;
use tokio::sync::Mutex;

use deno_ast::{MediaType, ModuleSpecifier};
use deno_ast::{ParseParams, SourceMapOption};
use deno_core::ModuleLoadResponse;
use deno_core::ModuleSourceCode;
use deno_error::JsErrorBox;

pub use pool::DenoPool;

use crate::structs::PluginCodeType;

impl From<PluginCodeType> for MediaType {
    fn from(value: PluginCodeType) -> Self {
        match value {
            PluginCodeType::JavaScript => MediaType::JavaScript,
            PluginCodeType::TypeScript => MediaType::TypeScript,
        }
    }
}

// Load the snapshot generated by build.rs:
static RUNTIME_SNAPSHOT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/RUNJS_SNAPSHOT.bin"));

fn transpile_code_to_js(
    module_specifier: &ModuleSpecifier,
    media_type: MediaType,
    code: &str,
) -> Result<(ModuleType, String), JsErrorBox> {
    let (module_type, should_transpile) = match media_type {
        MediaType::JavaScript | MediaType::Mjs | MediaType::Cjs => (ModuleType::JavaScript, false),
        MediaType::Jsx => (ModuleType::JavaScript, true),
        MediaType::TypeScript
        | MediaType::Mts
        | MediaType::Cts
        | MediaType::Dts
        | MediaType::Dmts
        | MediaType::Dcts
        | MediaType::Tsx => (ModuleType::JavaScript, true),
        MediaType::Json => (ModuleType::Json, false),
        _ => {
            return Err(JsErrorBox::generic(format!(
                "Unknown extension {:?}",
                media_type
            )));
        }
    };
    if should_transpile {
        let parsed = deno_ast::parse_module(ParseParams {
            specifier: module_specifier.clone(),
            text: code.into(),
            media_type,
            capture_tokens: false,
            scope_analysis: false,
            maybe_syntax: None,
        })
        .map_err(JsErrorBox::from_err)?;
        let res = parsed
            .transpile(
                &deno_ast::TranspileOptions {
                    imports_not_used_as_values: deno_ast::ImportsNotUsedAsValues::Remove,
                    decorators: deno_ast::DecoratorsTranspileOption::Ecma,
                    ..Default::default()
                },
                &deno_ast::TranspileModuleOptions { module_kind: None },
                &deno_ast::EmitOptions {
                    source_map: SourceMapOption::Separate,
                    inline_sources: true,
                    ..Default::default()
                },
            )
            .map_err(JsErrorBox::from_err)?;
        let res = res.into_source();
        // let source_map = res.source_map.unwrap().into_bytes();

        Ok((module_type, res.text))
    } else {
        Ok((module_type, code.to_string()))
    }
}

struct TsModuleLoader;
impl ModuleLoader for TsModuleLoader {
    fn resolve(
        &self,
        specifier: &str,
        referrer: &str,
        _kind: deno_core::ResolutionKind,
    ) -> Result<deno_core::ModuleSpecifier, ModuleLoaderError> {
        resolve_import(specifier, referrer).map_err(JsErrorBox::from_err)
    }

    fn load(
        &self,
        module_specifier: &ModuleSpecifier,
        _maybe_referrer: Option<&ModuleLoadReferrer>,
        _options: ModuleLoadOptions,
    ) -> ModuleLoadResponse {
        fn load(module_specifier: &ModuleSpecifier) -> Result<ModuleSource, ModuleLoaderError> {
            let path = module_specifier
                .to_file_path()
                .map_err(|_| JsErrorBox::generic("Only file:// URLs are supported."))?;

            let code = std::fs::read_to_string(&path).map_err(JsErrorBox::from_err)?;
            let path = module_specifier
                .to_file_path()
                .map_err(|_| JsErrorBox::generic("Only file:// URLs are supported."))?;
            let media_type = MediaType::from_path(&path);
            let (module_type, code) = transpile_code_to_js(module_specifier, media_type, &code)?;

            Ok(ModuleSource::new(
                module_type,
                ModuleSourceCode::String(code.into()),
                module_specifier,
                None,
            ))
        }

        ModuleLoadResponse::Sync(load(module_specifier))
    }
}

struct JSRuntimeState<CTX, Client: FHIRClient<CTX, OperationOutcomeError>> {
    fhir_client: Arc<Client>,
    ctx: CTX,
    return_value: Option<serde_json::Value>,
    input: Rc<serde_json::Value>,
}

#[repr(C)]
pub struct InteropObject {
    value: GcCell<f64>,
}

unsafe impl GarbageCollected for InteropObject {
    fn trace(&self, _visitor: &mut v8::cppgc::Visitor) {}
    fn get_name(&self) -> &'static std::ffi::CStr {
        c"InteropObject"
    }
}

#[op2]
impl InteropObject {
    #[constructor]
    #[cppgc]
    fn new(value: f64) -> InteropObject {
        InteropObject {
            value: GcCell::new(value),
        }
    }

    #[getter]
    fn value(&self, isolate: &v8::Isolate) -> f64 {
        *self.value.get(isolate)
    }

    #[setter]
    fn value(&self, isolate: &mut v8::Isolate, value: f64) {
        self.value.set(isolate, value);
    }

    // #[fast]
    // fn double_value(&self, isolate: &v8::Isolate) -> f64 {
    //     *self.value.get(isolate) * 2.0
    // }

    #[static_method]
    #[cppgc]
    fn create(value: f64) -> InteropObject {
        InteropObject {
            value: GcCell::new(value),
        }
    }
}

#[op2]
#[serde]
pub async fn fhir_read_resource<
    CTX: Clone + 'static,
    Client: FHIRClient<CTX, OperationOutcomeError> + 'static,
>(
    state: Rc<RefCell<OpState>>,
    #[string] resource_type: String,
    #[string] id: String,
) -> Result<serde_json::Value, deno_error::JsErrorBox> {
    let app_state = {
        let state = state.borrow();
        // Use the state

        state
            .borrow::<Arc<Mutex<JSRuntimeState<CTX, Client>>>>()
            .clone()
    };

    let app_state = app_state.lock().await;

    let resource = app_state
        .fhir_client
        .read(
            app_state.ctx.clone(),
            ResourceType::try_from(resource_type)
                .map_err(|_| deno_error::JsErrorBox::type_error("Invalid resource type"))?,
            id,
        )
        .await
        .map_err(|e| {
            println!("Error reading resource: {:?}", e);
            deno_error::JsErrorBox::type_error("Failed to read resource")
        })?;

    if let Some(resource) = resource {
        serde_json::to_value(&resource)
            .map_err(|_| deno_error::JsErrorBox::type_error("Failed to serialize resource"))
    } else {
        Ok(serde_json::Value::Null)
    }
}

#[op2]
#[serde]
pub async fn set_return_value<
    CTX: Clone + 'static,
    Client: FHIRClient<CTX, OperationOutcomeError> + 'static,
>(
    state: Rc<RefCell<OpState>>,
    #[serde] value: serde_json::Value,
) -> Result<(), deno_error::JsErrorBox> {
    let app_state = {
        let state = state.borrow();
        // Use the state
        state
            .borrow::<Arc<Mutex<JSRuntimeState<CTX, Client>>>>()
            .clone()
    };
    let mut mutable_state = app_state.lock().await;

    mutable_state.return_value = Some(value);
    Ok(())
}

#[op2]
#[serde]
pub async fn get_input_value<
    CTX: Clone + 'static,
    Client: FHIRClient<CTX, OperationOutcomeError> + 'static,
>(
    state: Rc<RefCell<OpState>>,
) -> Result<serde_json::Value, deno_error::JsErrorBox> {
    let app_state = {
        let state = state.borrow();
        // Use the state
        state
            .borrow::<Arc<Mutex<JSRuntimeState<CTX, Client>>>>()
            .clone()
    };

    let state = app_state.lock().await;

    Ok(serde_json::json!({
        "request": state.input.clone(),
    }))
}

async fn run_code<
    CTX: Clone + 'static,
    Client: FHIRClient<CTX, OperationOutcomeError> + 'static,
>(
    ctx: CTX,
    client: Arc<Client>,
    media_type: PluginCodeType,
    code: &str,
    input: serde_json::Value,
) -> Result<Option<serde_json::Value>, AnyError> {
    // let main_module = deno_core::resolve_path(file_path, &std::env::current_dir()?)?;

    let runjs = Extension {
        name: "runjs",
        ops: std::borrow::Cow::Owned(vec![
            fhir_read_resource::<CTX, Client>(),
            set_return_value::<CTX, Client>(),
            get_input_value::<CTX, Client>(),
        ]),
        ..Default::default()
    };

    let mut deno_runtime = deno_core::JsRuntime::new(deno_core::RuntimeOptions {
        module_loader: Some(Rc::new(TsModuleLoader)),
        extensions: vec![runjs],
        startup_snapshot: Some(RUNTIME_SNAPSHOT),
        // startup_snapshot: Some(RUNTIME_SNAPSHOT),
        ..Default::default()
    });

    let js_runtime_state = Arc::new(Mutex::new(JSRuntimeState {
        fhir_client: client,
        ctx,
        return_value: None,
        input: Rc::new(input),
    }));

    {
        let op_state = deno_runtime.op_state();
        let mut op_state = op_state.borrow_mut();
        op_state.put(js_runtime_state.clone());
    }

    let user_module_specifier = ModuleSpecifier::parse("memo://user.ts").unwrap();

    let (_module_type, js_code) =
        transpile_code_to_js(&user_module_specifier, media_type.into(), &code).unwrap();

    let user_mod_id = deno_runtime
        .load_side_es_module_from_code(&user_module_specifier, js_code)
        .await?;

    let main_mod_id = deno_runtime
        .load_main_es_module_from_code(
            &ModuleSpecifier::parse("memo://main.ts").unwrap(),
            "import userFunction from 'memo://user.ts'; _internal_.setReturnValue(await userFunction(await _internal_.getInputValue()));"
                .to_string(),
        )
        .await?;

    // let mod_id = deno_runtime.load_main_es_module(&main_module).await?;
    let user_module_load = deno_runtime.mod_evaluate(user_mod_id);
    let main_module_load = deno_runtime.mod_evaluate(main_mod_id);

    deno_runtime.run_event_loop(Default::default()).await?;

    user_module_load.await?;
    main_module_load.await?;
    // Clean up the JSRuntimeState from the op state
    // Allows unwrapping RC in next call to have owned_values.
    {
        let op_state = deno_runtime.op_state();
        let mut op_state = op_state.borrow_mut();

        op_state.take::<Arc<Mutex<JSRuntimeState<CTX, Client>>>>();
    }

    let owned_runetime_state = Arc::try_unwrap(js_runtime_state)
        .map_err(|_| deno_error::JsErrorBox::type_error("Failed to unwrap JSRuntimeState"))?
        .into_inner();

    Ok(owned_runetime_state.return_value)
}