refactor: Plugins are now providers mostly everywhere

Author: 06Games

backend/Cargo.lock

@@ -5,8 +5,8 @@ edition = "2021"
 
 [dependencies]
 geneagrab-providers = { path = "../providers/common" }
-geneagrab-plugin-ad06 = { path = "../providers/ad06" }
-geneagrab-plugin-geneanet = { path = "../providers/geneanet" }
+geneagrab-provider-ad06 = { path = "../providers/ad06" }
+geneagrab-provider-geneanet = { path = "../providers/geneanet" }
 dates = { path = "../dates" }
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "2.0.18"

backend/core/Cargo.toml

@@ -17,8 +17,8 @@ pub enum CoreError {
     #[error("Lock error: {0}")]
     LockError(String),
 
-    #[error("Plugin error: {0}")]
-    PluginError(String),
+    #[error("Provider error: {0}")]
+    ProviderError(String),
 
     #[error("Number error: {0}")]
     NumberError(#[from] std::num::TryFromIntError),
@@ -29,6 +29,6 @@ pub enum CoreError {
 
 impl From<geneagrab_providers::errors::ProviderError> for CoreError {
     fn from(err: geneagrab_providers::errors::ProviderError) -> Self {
-        CoreError::PluginError(err.to_string())
+        CoreError::ProviderError(err.to_string())
     }
 }

backend/core/src/errors.rs

@@ -3,5 +3,5 @@
 pub mod comm_models;
 pub mod db_entries;
 pub mod errors;
-pub mod plugins;
+pub mod providers;
 pub mod services;

backend/core/src/lib.rs

@@ -3,10 +3,10 @@ use sea_orm::DbConn;
 use wreq::Client;
 use wreq_util::Emulation;
 use geneagrab_providers::traits::{ArchiveProvider, Fetcher};
-use geneagrab_plugin_ad06::Ad06Provider;
-use geneagrab_plugin_geneanet::GeneanetProvider;
+use geneagrab_provider_ad06::Ad06Provider;
+use geneagrab_provider_geneanet::GeneanetProvider;
 use crate::errors::CoreError;
-use crate::services::plugin::get_plugin_config;
+use crate::services::provider::get_provider_config;
 
 pub struct CoreFetcher {
     pub client: Client,
@@ -54,19 +54,19 @@ pub fn get_providers(flaresolverr_url: &str, fetcher: Arc<dyn Fetcher>) -> Vec<A
     ]
 }
 
-pub fn get_provider_without_config(plugin_id: &str) -> Result<Arc<dyn ArchiveProvider>, CoreError> {
+pub fn get_provider_without_config(provider_id: &str) -> Result<Arc<dyn ArchiveProvider>, CoreError> {
     let fetcher = get_fetcher()?;
     get_providers("", fetcher)
         .into_iter()
-        .find(|p| p.metadata().id == plugin_id)
-        .ok_or_else(|| CoreError::NotFound(format!("Plugin {plugin_id} not found")))
+        .find(|p| p.metadata().id == provider_id)
+        .ok_or_else(|| CoreError::NotFound(format!("Provider {provider_id} not found")))
 }
 
 pub async fn get_provider(
     db: &DbConn,
-    plugin_id: &str,
+    provider_id: &str,
 ) -> Result<Arc<dyn ArchiveProvider>, CoreError> {
-    let config = get_plugin_config(db, plugin_id).await?;
+    let config = get_provider_config(db, provider_id).await?;
     let flaresolverr_url = config
         .get("flaresolverr_url")
         .cloned()
@@ -75,8 +75,8 @@ pub async fn get_provider(
     let fetcher = get_fetcher()?;
     get_providers(&flaresolverr_url, fetcher)
         .into_iter()
-        .find(|p| p.metadata().id == plugin_id)
-        .ok_or_else(|| CoreError::NotFound(format!("Plugin {plugin_id} not found")))
+        .find(|p| p.metadata().id == provider_id)
+        .ok_or_else(|| CoreError::NotFound(format!("Provider {provider_id} not found")))
 }
 
 pub fn get_fetcher() -> Result<Arc<dyn Fetcher>, CoreError> {

backend/core/src/plugins/mod.rs backend/core/src/providers/mod.rsbackend/core/src/plugins/mod.rs renamed to backend/core/src/providers/mod.rs

@@ -137,17 +137,17 @@ pub async fn prepare_image(
         image: image.clone().into(),
     };
 
-    let provider = crate::plugins::get_provider(db, &registry.source_id).await?;
+    let provider = crate::providers::get_provider(db, &registry.source_id).await?;
     let missing_data = provider
         .is_image_missing_data(&extract_req)
-        .map_err(|e| CoreError::PluginError(e.to_string()))?;
+        .map_err(|e| CoreError::ProviderError(e.to_string()))?;
 
     if let Some(field) = missing_data {
         tracing::info!("Image {image_id} is missing data ({field}), extracting...");
         let res = provider
             .extract_image(extract_req)
             .await
-            .map_err(|e| CoreError::PluginError(e.to_string()))?;
+            .map_err(|e| CoreError::ProviderError(e.to_string()))?;
 
         let mut image_model: image_entry::ActiveModel = image.into();
         let mut has_updates = false;
@@ -197,11 +197,11 @@ pub async fn fetch_image_tile(
         y,
     };
 
-    let provider = crate::plugins::get_provider(db, &registry.source_id).await?;
+    let provider = crate::providers::get_provider(db, &registry.source_id).await?;
     let image_data = provider
         .fetch_tile(req)
         .await
-        .map_err(|e| CoreError::PluginError(e.to_string()))?;
+        .map_err(|e| CoreError::ProviderError(e.to_string()))?;
 
     Ok(image_data)
 }
@@ -307,11 +307,11 @@ where
         image: image.clone().into(),
     };
 
-    let provider = crate::plugins::get_provider(db, &registry.source_id).await?;
+    let provider = crate::providers::get_provider(db, &registry.source_id).await?;
     let image_data = provider
         .download_image(req)
         .await
-        .map_err(|e| CoreError::PluginError(e.to_string()))?;
+        .map_err(|e| CoreError::ProviderError(e.to_string()))?;
 
     if let Some(res) = image_data {
         progress_callback(1, 1);

backend/core/src/plugins/providers.rs backend/core/src/providers/providers.rsbackend/core/src/plugins/providers.rs renamed to backend/core/src/providers/providers.rs

@@ -1,4 +1,4 @@
 pub mod event;
 pub mod image;
-pub mod plugin;
+pub mod provider;
 pub mod registry;

backend/core/src/services/image.rs

@@ -2,12 +2,12 @@ use std::collections::HashMap;
 use sea_orm::{ColumnTrait, DbConn, EntityTrait, QueryFilter, Select};
 use crate::{db_entries::plugin_settings, errors::CoreError};
 
-pub async fn get_plugin_config(
+pub async fn get_provider_config(
     db: &DbConn,
-    plugin_id: &str,
+    provider_id: &str,
 ) -> Result<HashMap<String, String>, CoreError> {
     let query: Select<plugin_settings::Entity> =
-        plugin_settings::Entity::find().filter(plugin_settings::Column::PluginId.eq(plugin_id));
+        plugin_settings::Entity::find().filter(plugin_settings::Column::PluginId.eq(provider_id));
     Ok(query
         .all(db)
         .await

backend/core/src/services/mod.rs

@@ -10,7 +10,7 @@ use crate::{
 };
 use dates::HistoricalDate;
 use geneagrab_providers::com_structs::{IdentifyRequest, IdentifyResponse, ExtractRequest};
-use geneagrab_providers::data::PluginMetadata;
+use geneagrab_providers::data::ProviderMetadata;
 use sea_orm::QueryOrder;
 use sea_orm::{
     ActiveModelTrait, ActiveValue::NotSet, ColumnTrait, DbConn, EntityTrait, FromQueryResult,
@@ -229,16 +229,16 @@ pub async fn get_registry_meta(db: &DbConn, id: u32) -> Result<RegistryMeta, Cor
 pub async fn add_registry(
     db: &DbConn,
     url: String,
-    plugin_id: String,
+    provider_id: String,
 ) -> Result<RegistryMeta, CoreError> {
-    tracing::info!("add_registry called with url: {url}, plugin_id: {plugin_id}");
+    tracing::info!("add_registry called with url: {url}, provider_id: {provider_id}");
 
-    let provider = crate::plugins::get_provider(db, &plugin_id).await?;
-    let identified = provider.identify(IdentifyRequest { url: url.clone() }).map_err(|e| CoreError::PluginError(e.to_string()))?;
+    let provider = crate::providers::get_provider(db, &provider_id).await?;
+    let identified = provider.identify(IdentifyRequest { url: url.clone() }).map_err(|e| CoreError::ProviderError(e.to_string()))?;
     let res = provider
         .extract_registry(ExtractRequest { url, identified })
         .await
-        .map_err(|e| CoreError::PluginError(e.to_string()))?;
+        .map_err(|e| CoreError::ProviderError(e.to_string()))?;
 
     let txn = db
         .begin()
@@ -281,30 +281,30 @@ pub async fn add_registry(
     Ok(meta)
 }
 
-pub async fn get_plugins_for_url(
+pub async fn get_providers_for_url(
     url: &str,
-) -> Result<Vec<(PluginMetadata, IdentifyResponse)>, CoreError> {
-    let fetcher = crate::plugins::get_fetcher()?;
-    let providers = crate::plugins::get_providers("", fetcher);
-    let mut compatible_plugins = Vec::new();
+) -> Result<Vec<(ProviderMetadata, IdentifyResponse)>, CoreError> {
+    let fetcher = crate::providers::get_fetcher()?;
+    let providers = crate::providers::get_providers("", fetcher);
+    let mut compatible_providers = Vec::new();
 
     for provider in providers {
         let meta = provider.metadata();
         if let Ok(identified) = provider.identify(IdentifyRequest {
             url: url.to_string(),
         }) {
-            compatible_plugins.push((meta, identified));
+            compatible_providers.push((meta, identified));
         }
     }
 
-    // Prioritize plugins that explicitly list the website as compatible
-    compatible_plugins.sort_by_key(|(meta, _)| {
+    // Prioritize providers that explicitly list the website as compatible
+    compatible_providers.sort_by_key(|(meta, _)| {
         Reverse(
             meta.suggested_websites
                 .iter()
                 .any(|site| url.starts_with(site.as_ref())),
         )
     });
 
-    Ok(compatible_plugins)
+    Ok(compatible_providers)
 }