turntable 0.0.1

Turntable is unpkg copy
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
90
91
92

use node_semver::{Range, Version};
use poem::{
  http::header, Endpoint, FromRequest, IntoResponse, Middleware, Request, Response, Result,
};

use crate::{
  errors::AppError,
  models::PackagePathname,
  utils::{
    npm::{get_package_config, get_versions_and_tags, VersionsAndTags},
    redirect,
    url::create_pkg_url,
  },
};

#[inline]
fn max_satisfies(versions: Vec<String>, range: Range) -> anyhow::Result<Option<String>> {
  let mut max = None;
  let mut max_version = None;
  for v in versions.iter() {
    let vs = Version::parse(v)?;
    if range.satisfies(&vs) && (max.is_none() || max_version.as_ref().is_some_and(|max| *max < vs))
    {
      max = Some(v.to_owned());
      max_version = Some(Version::parse(v)?);
    }
  }
  Ok(max)
}

async fn resolve_version(
  package_name: impl AsRef<str>,
  package_version: impl Into<String>,
) -> anyhow::Result<Option<String>> {
  let package_version = package_version.into();
  let VersionsAndTags { versions, tags } = get_versions_and_tags(package_name).await?;
  let package_version = tags.get(&package_version).unwrap_or(&package_version);

  match versions.contains(package_version) {
    true => Ok(Some(package_version.to_owned())),
    false => max_satisfies(versions, Range::parse(package_version)?),
  }
}

pub struct ValidatePackageVersion;

impl<E: Endpoint> Middleware<E> for ValidatePackageVersion {
  type Output = ValidatePackageVersionEndpoint<E>;

  fn transform(&self, ep: E) -> Self::Output {
    ValidatePackageVersionEndpoint { ep }
  }
}

pub struct ValidatePackageVersionEndpoint<E> {
  ep: E,
}

#[poem::async_trait]
impl<E: Endpoint> Endpoint for ValidatePackageVersionEndpoint<E> {
  type Output = Response;

  async fn call(&self, mut req: Request) -> Result<Self::Output> {
    let pkg = <&PackagePathname>::from_request_without_body(&req).await?;

    let version = resolve_version(&pkg.package_name, &pkg.package_version).await?;

    let Some(version) = version else{
                return Err(AppError::NotFoundPackage(pkg.package_spec.to_owned())).map_err(Into::into);
            };

    if version != pkg.package_version {
      let path = create_pkg_url(&pkg.package_name, version, &pkg.filename, req.uri().query());
      let resp = redirect(path)
        .with_header(header::CACHE_CONTROL, "public, s-maxage=600, max-age=60")
        .with_header("Cache-Tag", "redirect, semver-redirect")
        .into_response();
      return Ok(resp);
    }

    let Some(config) =  get_package_config(&pkg.package_name, &pkg.package_version).await else {
                return Err(AppError::UnableGetConfigForPackage(
                    pkg.package_spec.to_owned(),
                ))
                .map_err(Into::<poem::Error>::into);
            };

    req.extensions_mut().insert(config);

    Ok(self.ep.call(req).await?.into_response())
  }
}