npm 0.1.7

npm
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
93
94
95
96
97
98
99
100
101
102
103
104

use std::{collections::HashMap, fs::File, io::Read, path::Path};

use aok::Result;
use base64::prelude::{Engine, BASE64_STANDARD as B64};
use serde::{Deserialize, Serialize};
use sha1::{Digest, Sha1};

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct PackageJson {
  pub version: String,
  pub description: Option<String>,
  // Add other necessary fields here
}

#[derive(Serialize, Debug)]
pub struct Dist {
  pub tarball: String,
  pub shasum: String,
}

#[derive(Serialize, Debug)]
pub struct VersionData {
  pub name: String,
  pub version: String,
  pub dist: Dist,
}

#[derive(Serialize, Debug)]
pub struct Attachments {
  #[serde(rename = "content-type")]
  pub content_type: String,
  pub data: String,
  pub length: usize,
}

#[derive(Serialize, Debug)]
pub struct Payload {
  pub _id: String,
  pub name: String,
  pub access: String,
  #[serde(rename = "dist-tags")]
  pub dist_tags: HashMap<String, String>,
  pub versions: HashMap<String, VersionData>,
  pub _attachments: HashMap<String, Attachments>,
}

pub fn payload(pkg_name: &str, package_json: &Path, tgz: &Path) -> Result<Payload> {
  let json = std::fs::read(package_json)?;
  let package_json: PackageJson = sonic_rs::from_slice(&json)?;

  // Read the tarball file
  let mut file = File::open(tgz)?;
  let mut tarbuffer = Vec::new();
  file.read_to_end(&mut tarbuffer)?;

  // Base64 encode the tarball data
  let tar_data_base64 = B64.encode(&tarbuffer);
  let tar_length = tarbuffer.len();

  // Calculate SHA1 checksum
  let mut hasher = Sha1::new();
  hasher.update(&tarbuffer);
  let shasum = format!("{:x}", hasher.finalize());

  // Prepare package data
  let mut dist_tags = HashMap::new();
  dist_tags.insert("latest".to_string(), package_json.version.clone());

  let mut versions = HashMap::new();
  let dist = Dist {
    tarball: format!(
      "https://registry.npmjs.org/{}/-/{}-{}.tgz",
      pkg_name, pkg_name, package_json.version
    ),
    shasum,
  };
  let version_data = VersionData {
    name: pkg_name.into(),
    version: package_json.version.clone(),
    dist,
  };
  versions.insert(package_json.version.clone(), version_data);

  let mut attachments = HashMap::new();
  attachments.insert(
    format!("{}-{}.tgz", pkg_name, package_json.version),
    Attachments {
      content_type: "application/octet-stream".to_string(),
      data: tar_data_base64,
      length: tar_length,
    },
  );

  let package_data = Payload {
    _id: pkg_name.into(),
    access: "public".into(),
    name: pkg_name.into(),
    dist_tags,
    versions,
    _attachments: attachments,
  };

  Ok(package_data)
}