relay-knowledge 1.1.16

Graph-database-based knowledge graph project.
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use serde_json::Value;

use super::{
    DependencySeed, SeedInput, line_containing_json_key, npm_group,
    npm_lock::{npm_requirement_is_local, package_lock_entry_is_local, package_lock_package_name},
    push_seed,
};

pub(super) fn parse_package_json(content: &str, records: &mut Vec<DependencySeed>) {
    let Ok(value) = serde_json::from_str::<Value>(content) else {
        return;
    };
    for group in [
        "dependencies",
        "devDependencies",
        "peerDependencies",
        "optionalDependencies",
    ] {
        let Some(dependencies) = value.get(group).and_then(Value::as_object) else {
            continue;
        };
        for (name, requirement) in dependencies {
            let requirement = requirement.as_str().map(str::to_owned);
            if requirement.as_deref().is_some_and(npm_requirement_is_local) {
                continue;
            }
            let line = line_containing_json_key(content, name).unwrap_or(1);
            push_seed(
                records,
                SeedInput::new(
                    "npm",
                    "javascript",
                    name.to_owned(),
                    requirement,
                    npm_group(group),
                    "package.json",
                    false,
                )
                .line(line)
                .excerpt(format!("{name} {}", value_as_text(dependencies.get(name)))),
            );
        }
    }
}

pub(super) fn parse_package_lock(content: &str, records: &mut Vec<DependencySeed>) {
    let Ok(value) = serde_json::from_str::<Value>(content) else {
        return;
    };
    if let Some(packages) = value.get("packages").and_then(Value::as_object) {
        for (path, package) in packages {
            if package_lock_entry_is_local(package) {
                continue;
            }
            let Some(name) = package_lock_package_name(path, package) else {
                continue;
            };
            let version = package
                .get("version")
                .and_then(Value::as_str)
                .map(str::to_owned);
            let line = line_containing_json_key(content, &name).unwrap_or(1);
            push_seed(
                records,
                SeedInput::new(
                    "npm",
                    "javascript",
                    name.clone(),
                    None,
                    "locked",
                    "package-lock.json",
                    true,
                )
                .resolved(version)
                .line(line)
                .excerpt(name),
            );
        }
        return;
    }
    if let Some(dependencies) = value.get("dependencies").and_then(Value::as_object) {
        collect_package_lock_v1_dependencies(content, dependencies, records);
    }
}

fn collect_package_lock_v1_dependencies(
    content: &str,
    dependencies: &serde_json::Map<String, Value>,
    records: &mut Vec<DependencySeed>,
) {
    for (name, package) in dependencies {
        let version = package
            .get("version")
            .and_then(Value::as_str)
            .map(str::to_owned);
        let line = line_containing_json_key(content, name).unwrap_or(1);
        if !version.as_deref().is_some_and(npm_requirement_is_local) {
            push_seed(
                records,
                SeedInput::new(
                    "npm",
                    "javascript",
                    name.to_owned(),
                    None,
                    "locked",
                    "package-lock.json",
                    true,
                )
                .resolved(version)
                .line(line)
                .excerpt(name.as_str()),
            )
        }
        if let Some(nested) = package.get("dependencies").and_then(Value::as_object) {
            collect_package_lock_v1_dependencies(content, nested, records);
        }
    }
}

fn value_as_text(value: Option<&Value>) -> String {
    value.and_then(Value::as_str).unwrap_or_default().to_owned()
}