lux_lib/operations/
update.rs

1use std::io;
2
3use crate::{
4    config::Config,
5    lockfile::{
6        LocalPackage, LocalPackageLockType, Lockfile, PinnedState, ReadOnly, ReadWrite,
7        WorkspaceLockfile,
8    },
9    lua_version::{LuaVersion, LuaVersionUnset},
10    package::{PackageReq, RockConstraintUnsatisfied},
11    remote_package_db::{RemotePackageDB, RemotePackageDBError},
12    remote_package_source::RemotePackageSource,
13    tree::{self, InstallTree, Tree, TreeError},
14    workspace::{Workspace, WorkspaceError, WorkspaceTreeError},
15};
16use bon::Builder;
17use itertools::Itertools;
18use miette::Diagnostic;
19use thiserror::Error;
20
21use super::{Install, InstallError, PackageInstallSpec, RemoveError, SyncError, Uninstall};
22
23#[derive(Error, Debug, Diagnostic)]
24pub enum UpdateError {
25    #[error(transparent)]
26    #[diagnostic(transparent)]
27    RockConstraintUnsatisfied(#[from] RockConstraintUnsatisfied),
28    #[error("failed to update rock")]
29    #[diagnostic(forward(0))]
30    Install(#[from] InstallError),
31    #[error("failed to remove old rock")]
32    #[diagnostic(forward(0))]
33    Remove(#[from] RemoveError),
34    #[error("error initialising remote package DB")]
35    #[diagnostic(forward(0))]
36    RemotePackageDB(#[from] RemotePackageDBError),
37    #[error("error loading the workspace")]
38    #[diagnostic(forward(0))]
39    Workspace(#[from] WorkspaceError),
40    #[error(transparent)]
41    #[diagnostic(transparent)]
42    LuaVersionUnset(#[from] LuaVersionUnset),
43    #[error(transparent)]
44    Io(#[from] io::Error),
45    #[error(transparent)]
46    #[diagnostic(transparent)]
47    Tree(#[from] TreeError),
48    #[error("error initialising the workspace install tree")]
49    #[diagnostic(forward(0))]
50    WorkspaceTree(#[from] WorkspaceTreeError),
51    #[error("error syncing the workspace install tree")]
52    #[diagnostic(forward(0))]
53    Sync(#[from] SyncError),
54}
55
56/// A rocks package updater, providing fine-grained control
57/// over how packages should be updated.
58/// Can update multiple packages in parallel.
59#[derive(Builder)]
60#[builder(start_fn = new, finish_fn(name = _update, vis = ""))]
61pub struct Update<'a> {
62    #[builder(start_fn)]
63    config: &'a Config,
64
65    /// Packages to update.
66    #[builder(field)]
67    packages: Option<Vec<PackageReq>>,
68
69    /// Test dependencies to update.
70    #[builder(field)]
71    test_dependencies: Option<Vec<PackageReq>>,
72
73    /// Build dependencies to update.
74    #[builder(field)]
75    build_dependencies: Option<Vec<PackageReq>>,
76
77    /// Workspace to use for resolving the dependency tree.
78    /// Uses the current workspace if None.
79    workspace: Option<Workspace>,
80
81    /// Whether to validate the integrity when syncing the project lockfile.
82    validate_integrity: Option<bool>,
83
84    package_db: Option<RemotePackageDB>,
85}
86
87impl<State: update_builder::State> UpdateBuilder<'_, State> {
88    pub fn packages(mut self, packages: Option<Vec<PackageReq>>) -> Self {
89        self.packages = packages;
90        self
91    }
92    pub fn build_dependencies(mut self, packages: Option<Vec<PackageReq>>) -> Self {
93        self.build_dependencies = packages;
94        self
95    }
96    pub fn test_dependencies(mut self, packages: Option<Vec<PackageReq>>) -> Self {
97        self.test_dependencies = packages;
98        self
99    }
100}
101
102impl<State: update_builder::State> UpdateBuilder<'_, State> {
103    #[tracing::instrument(name = "Updating packages", skip_all)]
104
105    /// Returns the packages that were installed or removed
106    pub async fn update(self) -> Result<Vec<LocalPackage>, UpdateError>
107    where
108        State: update_builder::IsComplete,
109    {
110        let args = self._update();
111
112        if args
113            .packages
114            .as_ref()
115            .is_some_and(|packages| packages.is_empty())
116        {
117            return Ok(Vec::default());
118        }
119
120        let package_db = match &args.package_db {
121            Some(db) => db.clone(),
122            None => {
123                let db = RemotePackageDB::from_config(args.config).await?;
124                db
125            }
126        };
127
128        let workspace = match args.workspace.clone() {
129            Some(ws) => Some(ws),
130            None => Workspace::current()?,
131        };
132
133        match workspace {
134            Some(workspace) => update_workspace(workspace, args, package_db).await,
135            None => update_install_tree(args, package_db).await,
136        }
137    }
138}
139
140async fn update_workspace(
141    workspace: Workspace,
142    args: Update<'_>,
143    package_db: RemotePackageDB,
144) -> Result<Vec<LocalPackage>, UpdateError> {
145    let mut project_lockfile = workspace.lockfile()?.write_guard();
146    let tree = workspace.tree(args.config)?;
147
148    let sync_report = super::Sync::new(&workspace, args.config)
149        .validate_integrity(args.validate_integrity.unwrap_or(false))
150        .test(true)
151        .sync()
152        .await?;
153
154    let updated_dependencies = update_dependency_tree(
155        tree,
156        &mut project_lockfile,
157        LocalPackageLockType::Regular,
158        package_db.clone(),
159        args.config,
160        &args.packages,
161    )
162    .await?;
163
164    let test_tree = workspace.test_tree(args.config)?;
165
166    let updated_test_dependencies = update_dependency_tree(
167        test_tree,
168        &mut project_lockfile,
169        LocalPackageLockType::Test,
170        package_db.clone(),
171        args.config,
172        &args.test_dependencies,
173    )
174    .await?;
175
176    let build_tree = workspace.build_tree(args.config)?;
177
178    let updated_build_dependencies = update_dependency_tree(
179        build_tree,
180        &mut project_lockfile,
181        LocalPackageLockType::Build,
182        package_db.clone(),
183        args.config,
184        &args.build_dependencies,
185    )
186    .await?;
187
188    Ok(updated_dependencies
189        .into_iter()
190        .chain(sync_report.added)
191        .chain(sync_report.removed)
192        .chain(updated_build_dependencies)
193        .chain(updated_test_dependencies)
194        .collect_vec())
195}
196
197async fn update_dependency_tree(
198    tree: Tree,
199    project_lockfile: &mut WorkspaceLockfile<ReadWrite>,
200    lock_type: LocalPackageLockType,
201    package_db: RemotePackageDB,
202    config: &Config,
203    packages: &Option<Vec<PackageReq>>,
204) -> Result<Vec<LocalPackage>, UpdateError> {
205    let lockfile = tree.lockfile()?;
206    let dependencies = updatable_packages(&lockfile)
207        .into_iter()
208        .filter(|pkg| is_included(pkg, packages))
209        .collect_vec();
210    let updated_lockfile = tree.lockfile()?;
211    let updated_dependencies = update(dependencies, package_db, tree, &lockfile, config).await?;
212    if !updated_dependencies.is_empty() {
213        project_lockfile.sync(updated_lockfile.local_pkg_lock(), &lock_type);
214    }
215    Ok(updated_dependencies)
216}
217
218fn is_included(
219    (pkg, _): &(LocalPackage, PackageReq),
220    package_reqs: &Option<Vec<PackageReq>>,
221) -> bool {
222    package_reqs.is_none()
223        || package_reqs.as_ref().is_some_and(|packages| {
224            packages
225                .iter()
226                .any(|req| req.matches(&pkg.as_package_spec()))
227        })
228}
229
230async fn update_install_tree(
231    args: Update<'_>,
232    package_db: RemotePackageDB,
233) -> Result<Vec<LocalPackage>, UpdateError> {
234    let tree = args
235        .config
236        .user_tree(LuaVersion::from(args.config)?.clone())?;
237    let lockfile = tree.lockfile()?;
238    let packages = updatable_packages(&lockfile)
239        .into_iter()
240        .filter(|pkg| is_included(pkg, &args.packages))
241        .collect_vec();
242    update(packages, package_db, tree, &lockfile, args.config).await
243}
244
245async fn update(
246    packages: Vec<(LocalPackage, PackageReq)>,
247    package_db: RemotePackageDB,
248    tree: Tree,
249    lockfile: &Lockfile<ReadOnly>,
250    config: &Config,
251) -> Result<Vec<LocalPackage>, UpdateError> {
252    let updatable = packages
253        .clone()
254        .into_iter()
255        .filter_map(|(package, constraint)| {
256            match package
257                .to_package()
258                .has_update_with(&constraint, &package_db)
259            {
260                Ok(Some(_)) if package.pinned() == PinnedState::Unpinned => {
261                    Some((package, constraint))
262                }
263                _ => None,
264            }
265        })
266        .collect_vec();
267    if updatable.is_empty() {
268        Ok(Vec::new())
269    } else {
270        Uninstall::new()
271            .config(config)
272            .packages(updatable.iter().map(|(package, _)| package.id()))
273            .remove()
274            .await?;
275        let updated_packages = Install::new(config)
276            .packages(
277                updatable
278                    .iter()
279                    .map(|updatable| mk_install_spec(updatable, lockfile))
280                    .collect(),
281            )
282            .tree(tree)
283            .package_db(package_db)
284            .install()
285            .await?;
286        Ok(updated_packages)
287    }
288}
289
290fn updatable_packages(lockfile: &Lockfile<ReadOnly>) -> Vec<(LocalPackage, PackageReq)> {
291    lockfile
292        .rocks()
293        .values()
294        .filter(|package| {
295            package.pinned() == PinnedState::Unpinned
296                && match package.source() {
297                    RemotePackageSource::LuarocksRockspec(_) => true,
298                    RemotePackageSource::LuarocksSrcRock(_) => true,
299                    RemotePackageSource::LuarocksBinaryRock(_) => true,
300                    // We don't support updating git sources or local packages
301                    // Git sources can be updated with the --toml flag
302                    RemotePackageSource::RockspecContent(_) => false,
303                    RemotePackageSource::Local => false,
304                    #[cfg(test)]
305                    RemotePackageSource::Test => false,
306                }
307        })
308        .map(|package| (package.clone(), package.to_package().into_package_req()))
309        .collect_vec()
310}
311
312fn mk_install_spec(
313    (package, req): &(LocalPackage, PackageReq),
314    lockfile: &Lockfile<ReadOnly>,
315) -> PackageInstallSpec {
316    let entry_type = if lockfile.is_entrypoint(&package.id()) {
317        tree::EntryType::Entrypoint
318    } else {
319        tree::EntryType::DependencyOnly
320    };
321    PackageInstallSpec::new(req.clone(), entry_type)
322        .pin(PinnedState::Unpinned)
323        .opt(package.opt())
324        .build()
325}
lux_lib/operations/update.rs

lux_lib/operations/
update.rs
