feat: block package removal in trans_prepare when dependents are

installed

Author: AnmiTaliDev

include/apg/transaction.h

@@ -51,6 +51,7 @@ typedef enum
     TRANS_ERR_ALREADY_COMMITTED, /**< trans_commit() called more than once. */
     TRANS_ERR_INSTALL_FAILED,    /**< One or more packages failed to install. */
     TRANS_ERR_UNSIGNED,          /**< Package rejected by signature policy. */
+    TRANS_ERR_HAS_DEPENDENTS, /**< Removal blocked by installed dependents. */
 } trans_error_t;
 
 /**
@@ -77,6 +78,18 @@ struct trans_conflict
     char *conflicts_with; /**< Existing package that conflicts with it. */
 };
 
+/**
+ * @brief A removal blocked by installed dependents.
+ *
+ * The array is owned by the transaction and valid until trans_free().
+ */
+struct trans_blocked_remove
+{
+    char *pkg_name;    /**< Package that cannot be removed. */
+    char **dependents; /**< Names of packages that depend on it. */
+    int dependent_count;
+};
+
 /**
  * @brief Opaque transaction handle.
  */
@@ -185,6 +198,20 @@ const struct trans_step *trans_get_plan(const struct apg_trans *trans,
 const struct trans_conflict *trans_get_conflicts(const struct apg_trans *trans,
                                                  size_t *count);
 
+/**
+ * @brief Retrieve removals blocked by installed dependents.
+ *
+ * Valid after a trans_prepare() call that returned
+ * @ref TRANS_ERR_HAS_DEPENDENTS. The returned array is owned by the
+ * transaction and valid until trans_free().
+ *
+ * @param trans Transaction after trans_prepare().
+ * @param count Output parameter set to the number of blocked removes.
+ * @return Pointer to the first entry, or NULL if none.
+ */
+const struct trans_blocked_remove *
+trans_get_blocked_removes(const struct apg_trans *trans, size_t *count);
+
 /**
  * @brief Execute the prepared plan.
  *

src/transaction/prepare.c

@@ -255,16 +255,65 @@ trans_prepare(struct apg_trans *trans)
 
     for (size_t i = 0; i < trans->remove_count; i++)
     {
-        trans_error_t perr = plan_push(
-            trans, TRANS_OP_REMOVE, trans->remove_names[i], NULL, true, NULL);
+        const char *name = trans->remove_names[i];
+
+        int dep_count = 0;
+        char **deps = db_get_dependents(trans->db, name, &dep_count);
+        if (deps && dep_count > 0)
+        {
+            if (!trans->blocked_removes)
+            {
+                trans->blocked_removes =
+                    malloc(4 * sizeof(*trans->blocked_removes));
+                if (!trans->blocked_removes)
+                {
+                    free(deps);
+                    ret = TRANS_ERR_NOMEM;
+                    goto cleanup;
+                }
+                trans->blocked_remove_cap = 4;
+            }
+            else if (trans->blocked_remove_count == trans->blocked_remove_cap)
+            {
+                size_t new_cap = trans->blocked_remove_cap * 2;
+                struct trans_blocked_remove *tmp =
+                    realloc(trans->blocked_removes, new_cap * sizeof(*tmp));
+                if (!tmp)
+                {
+                    free(deps);
+                    ret = TRANS_ERR_NOMEM;
+                    goto cleanup;
+                }
+                trans->blocked_removes = tmp;
+                trans->blocked_remove_cap = new_cap;
+            }
+
+            struct trans_blocked_remove *br =
+                &trans->blocked_removes[trans->blocked_remove_count++];
+            br->pkg_name = strdup(name);
+            br->dependents = deps;
+            br->dependent_count = dep_count;
+            if (!br->pkg_name)
+            {
+                ret = TRANS_ERR_NOMEM;
+                goto cleanup;
+            }
+            continue;
+        }
+        free(deps);
+
+        trans_error_t perr =
+            plan_push(trans, TRANS_OP_REMOVE, name, NULL, true, NULL);
         if (perr != TRANS_OK)
         {
             ret = perr;
             goto cleanup;
         }
     }
 
-    if (trans->conflict_count > 0)
+    if (trans->blocked_remove_count > 0)
+        ret = TRANS_ERR_HAS_DEPENDENTS;
+    else if (trans->conflict_count > 0)
         ret = TRANS_ERR_CONFLICT;
     else
         trans->prepared = true;

src/transaction/trans_priv.h

@@ -33,6 +33,10 @@ struct apg_trans
     size_t conflict_count;
     size_t conflict_cap;
 
+    struct trans_blocked_remove *blocked_removes;
+    size_t blocked_remove_count;
+    size_t blocked_remove_cap;
+
     bool prepared;
     bool committed;
 

src/transaction/transaction.c

@@ -93,6 +93,15 @@ trans_free(struct apg_trans *trans)
     }
     free(trans->conflicts);
 
+    for (size_t i = 0; i < trans->blocked_remove_count; i++)
+    {
+        free(trans->blocked_removes[i].pkg_name);
+        for (int j = 0; j < trans->blocked_removes[i].dependent_count; j++)
+            free(trans->blocked_removes[i].dependents[j]);
+        free(trans->blocked_removes[i].dependents);
+    }
+    free(trans->blocked_removes);
+
     free(trans);
 }
 
@@ -170,6 +179,15 @@ trans_get_plan(const struct apg_trans *trans, size_t *count)
     return trans->plan;
 }
 
+const struct trans_blocked_remove *
+trans_get_blocked_removes(const struct apg_trans *trans, size_t *count)
+{
+    if (!trans || !count)
+        return NULL;
+    *count = trans->blocked_remove_count;
+    return trans->blocked_removes;
+}
+
 const struct trans_conflict *
 trans_get_conflicts(const struct apg_trans *trans, size_t *count)
 {