Feat bulk locking (#1422)

* Feat: Multi-lock capabilities add to config

* wip: RPC.rs fixes, new combinatoric

* wip: changes

* chore: More things that are bulk

* fix: Saving

* chore: Remove a dyn object

* chore: Add tests + remove unused

* Fix/feat  bulk locking (#1427)

* fix: health check

* fix: start/stop service

* fix: install/uninstall services

* chore: Fix the notifications

* fix: Version

* fix: Version as serde

* chore: Update to latest patch db

* chore: Change the htLock to something that makes more sense

* chore: Fix the rest of the ht

* "chore: More ht_lock":

backend/src/db/package.rs

@@ -1,25 +1,75 @@
-use patch_db::DbHandle;
+use patch_db::{DbHandle, LockReceipt, LockTargetId, LockType, Verifier};
 
 use crate::s9pk::manifest::{Manifest, PackageId};
 use crate::Error;
 
-pub async fn get_packages<Db: DbHandle>(db: &mut Db) -> Result<Vec<PackageId>, Error> {
-    let packages = crate::db::DatabaseModel::new()
-        .package_data()
-        .get(db, false)
-        .await?;
+pub struct PackageReceipts {
+    package_data: LockReceipt<super::model::AllPackageData, ()>,
+}
+
+impl PackageReceipts {
+    pub async fn new<'a>(db: &'a mut impl DbHandle) -> Result<Self, Error> {
+        let mut locks = Vec::new();
+
+        let setup = Self::setup(&mut locks);
+        Ok(setup(&db.lock_all(locks).await?)?)
+    }
+
+    pub fn setup(locks: &mut Vec<LockTargetId>) -> impl FnOnce(&Verifier) -> Result<Self, Error> {
+        let package_data = crate::db::DatabaseModel::new()
+            .package_data()
+            .make_locker(LockType::Read)
+            .add_to_keys(locks);
+        move |skeleton_key| {
+            Ok(Self {
+                package_data: package_data.verify(&skeleton_key)?,
+            })
+        }
+    }
+}
+
+pub async fn get_packages<Db: DbHandle>(
+    db: &mut Db,
+    receipts: &PackageReceipts,
+) -> Result<Vec<PackageId>, Error> {
+    let packages = receipts.package_data.get(db).await?;
     Ok(packages.0.keys().cloned().collect())
 }
 
+pub struct ManifestReceipts {
+    manifest: LockReceipt<Manifest, String>,
+}
+
+impl ManifestReceipts {
+    pub async fn new<'a>(db: &'a mut impl DbHandle, id: &PackageId) -> Result<Self, Error> {
+        let mut locks = Vec::new();
+
+        let setup = Self::setup(&mut locks, id);
+        Ok(setup(&db.lock_all(locks).await?)?)
+    }
+
+    pub fn setup(
+        locks: &mut Vec<LockTargetId>,
+        id: &PackageId,
+    ) -> impl FnOnce(&Verifier) -> Result<Self, Error> {
+        let manifest = crate::db::DatabaseModel::new()
+            .package_data()
+            .star()
+            .manifest()
+            .make_locker(LockType::Read)
+            .add_to_keys(locks);
+        move |skeleton_key| {
+            Ok(Self {
+                manifest: manifest.verify(&skeleton_key)?,
+            })
+        }
+    }
+}
+
 pub async fn get_manifest<Db: DbHandle>(
     db: &mut Db,
     pkg: &PackageId,
+    receipts: &ManifestReceipts,
 ) -> Result<Option<Manifest>, Error> {
-    let mpde = crate::db::DatabaseModel::new()
-        .package_data()
-        .idx_model(pkg)
-        .get(db, false)
-        .await?
-        .into_owned();
-    Ok(mpde.map(|pde| pde.manifest()))
+    Ok(receipts.manifest.get(db, pkg).await?)
 }