use std::{
collections::BTreeMap,
path::{Path, PathBuf},
};
use serde::{Deserialize, Serialize};
use super::{ContextEntry, Metadata, MetadataContext};
use crate::RenderCtx;
mod source;
#[derive(Debug)]
pub(crate) struct Domain;
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct Config {
manifests: crate::config::Patterns,
#[serde(default, rename = "source-documentation")]
source_documentation: bool,
}
#[derive(Clone, Debug, Serialize)]
struct Script {
name: String,
command: String,
}
#[derive(Clone, Debug, Serialize)]
struct Dependency {
name: String,
version: String,
}
#[derive(Debug, Default)]
pub(crate) struct Package {
node_version: Option<String>,
scripts: Vec<Script>,
dependencies: Vec<Dependency>,
}
#[derive(Debug, Serialize)]
struct TemplateContext<'a> {
node_version: &'a Option<String>,
scripts: &'a [Script],
dependencies: &'a [Dependency],
}
impl crate::domain::registry::Domain for Domain {
type Config = Config;
type State = ();
const NAME: &'static str = "node";
fn manifests(
config: &Self::Config,
_state: &Self::State,
root: &Path,
files: &crate::domain::IndexedFiles,
) -> Result<Vec<PathBuf>, crate::domain::Error> {
Ok(crate::config::matching_files(
root,
files,
&config.manifests,
))
}
fn metadata(
_config: &Self::Config,
_state: &Self::State,
context: &MetadataContext<'_>,
) -> Result<Option<Metadata>, super::Error> {
let path = context.manifest_path;
let manifest: Manifest = serde_json::from_str(context.manifest_source)
.map_err(|error| super::Error::parse(path, "package.json", error))?;
let scripts = manifest
.scripts
.into_iter()
.map(|(name, command)| Script { name, command })
.collect();
let dependencies = manifest
.dependencies
.into_iter()
.map(|(name, version)| Dependency { name, version })
.collect();
let mut metadata = Metadata {
name: manifest.name,
description: manifest.description,
version: manifest.version,
kind: "package",
..Metadata::default()
};
metadata.insert_data(
Self::NAME,
Package {
node_version: manifest.engines.and_then(|engines| engines.node),
scripts,
dependencies,
},
);
Ok(Some(metadata))
}
fn context(
_config: &Self::Config,
_state: &Self::State,
context: &RenderCtx<'_>,
) -> Result<Vec<ContextEntry>, super::Error> {
let Some(package) = context.metadata.data::<Package>(Self::NAME) else {
return Ok(Vec::new());
};
let value = TemplateContext {
node_version: &package.node_version,
scripts: &package.scripts,
dependencies: &package.dependencies,
};
Ok(vec![("node".into(), super::to_value(&value))])
}
fn source_description(
config: &Self::Config,
_state: &Self::State,
path: &Path,
source: &str,
) -> Option<String> {
config
.source_documentation
.then(|| source::extract(path, source))
.flatten()
}
fn namespaces(_config: &Self::Config) -> Vec<Box<str>> {
vec![Self::NAME.into()]
}
}
crate::domain::registry::register_domain!(Domain);
#[derive(Deserialize)]
struct Manifest {
name: Option<String>,
description: Option<String>,
version: Option<String>,
engines: Option<Engines>,
#[serde(default)]
scripts: BTreeMap<String, String>,
#[serde(default)]
dependencies: BTreeMap<String, String>,
}
#[derive(Deserialize)]
struct Engines {
node: Option<String>,
}
#[cfg(test)]
mod tests {
use googletest::prelude::*;
use std::path::Path;
use super::Package;
use crate::{WorkspaceFile, WorkspaceIndex};
#[gtest]
fn parses_node_metadata() -> Result<()> {
let root = Path::new("/ws");
let workspace = WorkspaceIndex::new_domain(
root.to_path_buf(),
vec![WorkspaceFile {
path: root.join("package.json"),
contents: Some(
r#"{"name":"web","version":"1.0.0","engines":{"node":">=24"},"scripts":{"test":"vitest"}}"#
.into(),
),
}],
"node",
toml::Value::Table(toml::toml! { manifests = ["package.json"] }),
);
let metadata = workspace.metadata(root).or_fail()?;
let package = metadata.data::<Package>("node").or_fail()?;
verify_eq!(metadata.name.as_deref(), Some("web"))?;
verify_eq!(package.node_version.as_deref(), Some(">=24"))?;
verify_that!(&package.scripts, len(eq(1)))
}
}