mod.rs

use std::sync::Arc;

use deno_core::{extension, Extension};

use super::ExtensionTrait;

mod options;
pub use options::WebOptions;

mod permissions;
pub(crate) use permissions::PermissionsContainer;
pub use permissions::{
    to_permissions_options, AllowlistWebPermissions, CheckedPath, DefaultWebPermissions,
    PermissionCheckError, PermissionDeniedError, PermissionsOptions, SystemsPermissionKind,
    WebPermissions,
};

/// Stub for a node op deno_net expects to find
/// We return None to show no cert available
#[cfg(not(feature = "node_experimental"))]
#[deno_core::op2]
#[serde]
pub fn op_tls_peer_certificate(
    #[smi] _rid: u32,
    _detailed: bool,
) -> Option<deno_core::serde_json::Value> {
    None
}

extension!(
    init_fetch,
    deps = [rustyscript],
    esm_entry_point = "ext:init_fetch/init_fetch.js",
    esm = [ dir "src/ext/web", "init_fetch.js" ],
);
impl ExtensionTrait<WebOptions> for init_fetch {
    fn init(options: WebOptions) -> Extension {
        init_fetch::init()
    }
}
impl ExtensionTrait<WebOptions> for deno_fetch::deno_fetch {
    fn init(options: WebOptions) -> Extension {
        let options = deno_fetch::Options {
            user_agent: options.user_agent.clone(),
            root_cert_store_provider: options.root_cert_store_provider.clone(),
            proxy: options.proxy.clone(),
            request_builder_hook: options.request_builder_hook,
            unsafely_ignore_certificate_errors: options.unsafely_ignore_certificate_errors.clone(),
            client_cert_chain_and_key: options.client_cert_chain_and_key.clone(),
            file_fetch_handler: options.file_fetch_handler.clone(),
            client_builder_hook: options.client_builder_hook,
            resolver: options.resolver.clone(),
        };

        deno_fetch::deno_fetch::init(options)
    }
}

#[cfg(not(feature = "node_experimental"))]
extension!(
    init_net,
    deps = [rustyscript],
    ops = [op_tls_peer_certificate],
    esm_entry_point = "ext:init_net/init_net.js",
    esm = [ dir "src/ext/web", "init_net.js" ],
);

#[cfg(feature = "node_experimental")]
extension!(
    init_net,
    deps = [rustyscript],
    esm_entry_point = "ext:init_net/init_net.js",
    esm = [ dir "src/ext/web", "init_net.js" ],
);

impl ExtensionTrait<WebOptions> for init_net {
    fn init(options: WebOptions) -> Extension {
        let provider = rustls::crypto::aws_lc_rs::default_provider();
        let _ = rustls::crypto::CryptoProvider::install_default(provider); // Failure means already done for us
        init_net::init()
    }
}
impl ExtensionTrait<WebOptions> for deno_net::deno_net {
    fn init(options: WebOptions) -> Extension {
        deno_net::deno_net::init(
            options.root_cert_store_provider.clone(),
            options.unsafely_ignore_certificate_errors.clone(),
        )
    }
}

extension!(
    init_telemetry,
    deps = [rustyscript],
    esm_entry_point = "ext:init_telemetry/init_telemetry.js",
    esm = [ dir "src/ext/web", "init_telemetry.js" ],
);
impl ExtensionTrait<()> for init_telemetry {
    fn init((): ()) -> Extension {
        init_telemetry::init()
    }
}

impl ExtensionTrait<()> for deno_telemetry::deno_telemetry {
    fn init((): ()) -> Extension {
        deno_telemetry::deno_telemetry::init()
    }
}

extension!(
    init_web,
    deps = [rustyscript],
    esm_entry_point = "ext:init_web/init_web.js",
    esm = [ dir "src/ext/web", "init_web.js", "init_errors.js" ],
    options = {
        permissions: Arc<dyn WebPermissions>
    },
    state = |state, config| {
        state.put(PermissionsContainer(config.permissions.clone()));
        if !state.has::<deno_permissions::PermissionsContainer>() {
            let parser = Arc::new(deno_permissions::RuntimePermissionDescriptorParser::new(sys_traits::impls::RealSys));
            let opts = permissions::to_permissions_options(config.permissions.as_ref());
            let permissions = match deno_permissions::Permissions::from_options(&*parser, &opts) {
                Ok(p) => deno_permissions::PermissionsContainer::new(parser, p),
                Err(_) => deno_permissions::PermissionsContainer::allow_all(parser),
            };
            state.put(permissions);
        }
    },
);
impl ExtensionTrait<WebOptions> for init_web {
    fn init(options: WebOptions) -> Extension {
        init_web::init(options.permissions)
    }
}

impl ExtensionTrait<WebOptions> for deno_web::deno_web {
    fn init(options: WebOptions) -> Extension {
        deno_web::deno_web::init(
            options.blob_store,
            options.base_url,
            options.broadcast_channel,
        )
    }
}

impl ExtensionTrait<()> for deno_tls::deno_tls {
    fn init((): ()) -> Extension {
        deno_tls::deno_tls::init()
    }
}

pub fn extensions(options: WebOptions, is_snapshot: bool) -> Vec<Extension> {
    vec![
        deno_web::deno_web::build(options.clone(), is_snapshot),
        deno_telemetry::deno_telemetry::build((), is_snapshot),
        deno_net::deno_net::build(options.clone(), is_snapshot),
        deno_fetch::deno_fetch::build(options.clone(), is_snapshot),
        deno_tls::deno_tls::build((), is_snapshot),
        init_web::build(options.clone(), is_snapshot),
        init_telemetry::build((), is_snapshot),
        init_net::build(options.clone(), is_snapshot),
        init_fetch::build(options, is_snapshot),
    ]
}