nbi 0.1.9

TUI for checking package name availability across npm, crates.io, PyPI, .dev domains and registering via GitHub
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use axum::{
  http::StatusCode,
  response::{Html, IntoResponse},
  Json,
};
use serde::{Deserialize, Serialize};

use crate::config::{Config, RegistrySettings};
use crate::registry::{self, AvailabilityResult};

/// Index page with embedded React app
pub async fn index() -> Html<&'static str> {
  Html(include_str!("../../static/index.html"))
}

#[derive(Deserialize)]
pub struct CheckRequest {
  pub name: String,
  #[serde(default)]
  pub registries: Option<RegistrySettings>,
}

#[derive(Serialize)]
pub struct CheckResponse {
  pub name: String,
  pub results: Vec<AvailabilityResult>,
}

/// Check package name availability
pub async fn check_availability(Json(req): Json<CheckRequest>) -> impl IntoResponse {
  let settings = req.registries.unwrap_or_default();
  let results = registry::check_all(&req.name, &settings).await;

  Json(CheckResponse {
    name: req.name,
    results,
  })
}

#[derive(Deserialize)]
pub struct DomainRequest {
  pub name: String,
  pub tlds: Vec<String>,
}

#[derive(Serialize)]
pub struct DomainResponse {
  pub name: String,
  pub results: Vec<DomainResult>,
}

#[derive(Serialize)]
pub struct DomainResult {
  pub domain: String,
  pub available: Option<bool>,
  pub error: Option<String>,
}

/// Check domain availability across multiple TLDs
pub async fn check_domain(Json(req): Json<DomainRequest>) -> impl IntoResponse {
  use crate::registry::domain::check_tld;

  let mut results = Vec::new();

  for tld in &req.tlds {
    let domain = format!("{}.{}", req.name, tld);
    let result = check_tld(&req.name, tld).await;
    results.push(DomainResult {
      domain,
      available: result.available,
      error: result.error,
    });
  }

  Json(DomainResponse {
    name: req.name,
    results,
  })
}

#[derive(Deserialize)]
pub struct FullDomainRequest {
  pub domains: Vec<String>,
}

/// Check full domain availability (e.g., banana.wiki)
pub async fn check_full_domains(Json(req): Json<FullDomainRequest>) -> impl IntoResponse {
  use crate::registry::domain::check_full_domain;

  let mut results = Vec::new();

  for domain in &req.domains {
    let result = check_full_domain(domain).await;
    results.push(DomainResult {
      domain: domain.clone(),
      available: result.available,
      error: result.error,
    });
  }

  Json(DomainResponse {
    name: req.domains.join(", "),
    results,
  })
}

/// Get current config
pub async fn get_config() -> impl IntoResponse {
  match Config::load() {
    Ok(config) => match serde_json::to_value(config) {
      Ok(value) => (StatusCode::OK, Json(value)),
      Err(e) => (
        StatusCode::INTERNAL_SERVER_ERROR,
        Json(serde_json::json!({ "error": format!("Failed to serialize config: {}", e) })),
      ),
    },
    Err(e) => (
      StatusCode::INTERNAL_SERVER_ERROR,
      Json(serde_json::json!({ "error": e.to_string() })),
    ),
  }
}

#[derive(Deserialize)]
pub struct SaveConfigRequest {
  pub registries: RegistrySettings,
}

/// Save config
pub async fn save_config(Json(req): Json<SaveConfigRequest>) -> impl IntoResponse {
  let mut config = Config::load().unwrap_or_default();
  config.registries = req.registries;

  match config.save() {
    Ok(_) => (StatusCode::OK, Json(serde_json::json!({ "success": true }))),
    Err(e) => (
      StatusCode::INTERNAL_SERVER_ERROR,
      Json(serde_json::json!({ "error": e.to_string() })),
    ),
  }
}