deno_fetch 0.239.0

Fetch API implementation for Deno
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

// Copyright 2018-2025 the Deno authors. MIT license.

use std::borrow::Cow;
use std::rc::Rc;

use deno_core::CancelFuture;
use deno_core::OpState;
use deno_core::futures::FutureExt;
use deno_core::futures::TryFutureExt;
use deno_core::futures::TryStreamExt;
use deno_core::url::Url;
use deno_error::JsErrorBox;
use deno_fs::OpenOptions;
use deno_fs::open_options_for_checked_path;
use deno_permissions::OpenAccessKind;
use deno_permissions::PermissionsContainer;
use http::StatusCode;
use http_body_util::BodyExt;
use tokio_util::io::ReaderStream;

use crate::CancelHandle;
use crate::CancelableResponseFuture;
use crate::FetchHandler;

/// An implementation which tries to read file URLs from the file system via
/// tokio::fs.
#[derive(Clone)]
pub struct FsFetchHandler;

impl FetchHandler for FsFetchHandler {
  fn fetch_file(
    &self,
    state: &mut OpState,
    url: &Url,
  ) -> (CancelableResponseFuture, Option<Rc<CancelHandle>>) {
    let cancel_handle = CancelHandle::new_rc();
    let path = match url.to_file_path() {
      Ok(path) => path,
      Err(_) => {
        let fut = async move { Err::<_, _>(()) };
        return (
          fut
            .map_err(move |_| super::FetchError::NetworkError)
            .or_cancel(&cancel_handle)
            .boxed_local(),
          Some(cancel_handle),
        );
      }
    };
    let path_and_opts_result = {
      state
        .borrow::<PermissionsContainer>()
        .check_open(Cow::Owned(path), OpenAccessKind::Read, Some("fetch()"))
        .map(|path| {
          (
            open_options_for_checked_path(
              OpenOptions {
                read: true,
                ..Default::default()
              },
              &path,
            ),
            path.into_owned(),
          )
        })
    };
    let response_fut = async move {
      let (opts, path) = path_and_opts_result?;
      let file = tokio::fs::OpenOptions::from(opts)
        .open(path)
        .await
        .map_err(|_| super::FetchError::NetworkError)?;
      let stream = ReaderStream::new(file)
        .map_ok(hyper::body::Frame::data)
        .map_err(JsErrorBox::from_err);

      let body = http_body_util::StreamBody::new(stream).boxed();
      let response = http::Response::builder()
        .status(StatusCode::OK)
        .body(body)
        .map_err(move |_| super::FetchError::NetworkError)?;
      Ok::<_, _>(response)
    }
    .or_cancel(&cancel_handle)
    .boxed_local();

    (response_fut, Some(cancel_handle))
  }
}