Rename repository -> database

Author: LucasPickering

src/cli.rs

@@ -1,6 +1,7 @@
 use crate::{
     collection::{ProfileId, RequestCollection, RequestRecipeId},
-    http::{HttpEngine, Repository, RequestBuilder},
+    db::Database,
+    http::{HttpEngine, RequestBuilder},
     template::{Prompt, Prompter, TemplateContext},
     util::{Directory, ResultExt},
 };
@@ -91,15 +92,15 @@ impl Subcommand {
                     )?;
 
                 // Build the request
-                let repository = Repository::load(&collection.id)?;
+                let database = Database::load(&collection.id)?;
                 let overrides: IndexMap<_, _> = overrides.into_iter().collect();
                 let request = RequestBuilder::new(
                     recipe,
                     TemplateContext {
                         profile: profile_data,
                         overrides,
                         chains: collection.chains,
-                        repository: repository.clone(),
+                        database: database.clone(),
                         prompter: Box::new(CliPrompter),
                     },
                 )
@@ -110,7 +111,7 @@ impl Subcommand {
                     println!("{:#?}", request);
                 } else {
                     // Run the request
-                    let http_engine = HttpEngine::new(repository);
+                    let http_engine = HttpEngine::new(database);
                     let record = http_engine.send(request).await?;
 
                     // Print response

src/collection.rs

@@ -55,8 +55,8 @@ pub struct RequestCollection<S = PathBuf> {
     pub recipes: IndexMap<RequestRecipeId, RequestRecipe>,
 }
 
-/// A unique ID for a collection. This is necessary to differentiate between
-/// responses from different collections in the repository.
+/// A unique ID for a collection. This is necessary to give each collection its
+/// own database.
 #[derive(
     Clone, Debug, Default, Deref, Display, From, Serialize, Deserialize,
 )]

src/http/repository.rs renamed to src/db.rs

@@ -1,6 +1,5 @@
-//! The repository persists all requests and responses. It consists of a SQLite
-//! database to persist all request history and an in-memory layer to provide
-//! caching and other ephemeral data (e.g. prettified content).
+//! The database is responsible for persisting data, including requests and
+//! responses.
 
 use crate::{
     collection::{CollectionId, RequestRecipeId},
@@ -18,78 +17,74 @@ use tokio::sync::Mutex;
 use tracing::debug;
 use uuid::Uuid;
 
-/// A record of all HTTP history, which is persisted on disk. This is also used
-/// to populate chained values. This uses a sqlite DB underneath, which means
-/// all operations are internally fallible. Generally speaking, any error that
+/// A SQLite database for persisting data. Generally speaking, any error that
 /// occurs *after* opening the DB connection should be an internal bug, but
-/// should be shown to the user whenever possible. All operations are also
-/// async because of the database and the locking nature of the interior cache.
-/// They generally will be fast though, so it's safe to block on them in the
-/// main loop. Do not call this from the draw phase though; instead, cache the
-/// results in UI state for as long as they're needed.
+/// should be shown to the user whenever possible. All operations are async
+/// to enable concurrent accesses to yield. Do not call block on thisfrom the
+/// draw phase; instead, cache the results in UI state for as long as they're
+/// needed.
 ///
-/// Only requests that received a valid HTTP response should be stored.
-/// In-flight requests, invalid requests, and requests that failed to complete
-/// (e.g. because of a network error) should not (and cannot) be stored.
+/// This uses an `Arc` internally, so it's safe and cheap to clone.
 ///
 /// Note: Despite all the operations being async, the actual database isn't
 /// async. Each operation will asynchronously wait for the connection mutex,
 /// then block while performing the operation. This is just a shortcut, if it
 /// becomes a bottleneck we can change that.
 #[derive(Clone, Debug)]
-pub struct Repository {
-    /// History is stored in a sqlite DB. Mutex is needed for multi-threaded
+pub struct Database {
+    /// Data is stored in a sqlite DB. Mutex is needed for multi-threaded
     /// access. This is a bottleneck but the access rate should be so low that
     /// it doesn't matter.
     connection: Arc<Mutex<Connection>>,
 }
 
-impl Repository {
-    /// Load the repository database. This will perform first-time setup, so
-    /// this should only be called at the main session entrypoint.
+impl Database {
+    /// Load the database. This will perform first-time setup, so this should
+    /// only be called at the main session entrypoint.
     pub fn load(collection_id: &CollectionId) -> anyhow::Result<Self> {
         let mut connection = Connection::open(Self::path(collection_id)?)?;
         // Use WAL for concurrency
         connection.pragma_update(None, "journal_mode", "WAL")?;
-        Self::setup(&mut connection)?;
+        Self::migrate(&mut connection)?;
         Ok(Self {
             connection: Arc::new(Mutex::new(connection)),
         })
     }
 
-    /// Path to the repository database file. This will create the directory if
-    /// it doesn't exist
+    /// Path to the database file. This will create the directory if it doesn't
+    /// exist
     fn path(collection_id: &CollectionId) -> anyhow::Result<PathBuf> {
         Ok(Directory::data(collection_id)
             .create()?
             .join("state.sqlite"))
     }
 
-    /// Apply first-time setup
-    fn setup(connection: &mut Connection) -> anyhow::Result<()> {
+    /// Apply database migrations
+    fn migrate(connection: &mut Connection) -> anyhow::Result<()> {
         let migrations = Migrations::new(vec![M::up(
             // The request state kind is a bit hard to map to tabular data.
-            // Everything that we need to query on (success/error kind, HTTP
-            // status code, end_time, etc.) is in its own column. The
-            // request/repsonse and response will be serialized
-            // into messagepack bytes
+            // Everything that we need to query on (HTTP status code,
+            // end_time, etc.) is in its own column. The
+            // request/repsonse and response will be serialized into
+            // msgpack bytes
             "CREATE TABLE requests (
-                id              UUID PRIMARY KEY,
-                recipe_id       TEXT,
-                start_time      TEXT,
-                end_time        TEXT,
-                request         BLOB,
-                response        BLOB,
-                status_code     INTEGER
-            )",
-        )]);
+                    id              UUID PRIMARY KEY,
+                    recipe_id       TEXT,
+                    start_time      TEXT,
+                    end_time        TEXT,
+                    request         BLOB,
+                    response        BLOB,
+                    status_code     INTEGER
+                )",
+        )
+        .down("DROP TABLE requests")]);
         migrations.to_latest(connection)?;
         Ok(())
     }
 
     /// Get the most recent request+response for a recipe, or `None` if there
     /// has never been one received.
-    pub async fn get_last(
+    pub async fn get_last_request(
         &self,
         recipe_id: &RequestRecipeId,
     ) -> anyhow::Result<Option<RequestRecord>> {
@@ -107,13 +102,12 @@ impl Repository {
             .traced()
     }
 
-    /// Add a new request to history. This should be called immediately before
-    /// or after the request is sent, so the generated start_time timestamp
-    /// is accurate.
-    ///
-    /// The HTTP engine is responsible for inserting its requests, so this isn't
-    /// exposed outside the `http` module.
-    pub(super) async fn insert(
+    /// Add a new request to history. The HTTP engine is responsible for
+    /// inserting its own requests. Only requests that received a valid HTTP
+    /// response should be stored. In-flight requests, invalid requests, and
+    /// requests that failed to complete (e.g. because of a network error)
+    /// should not (and cannot) be stored.
+    pub async fn insert_request(
         &self,
         record: &RequestRecord,
     ) -> anyhow::Result<()> {
@@ -155,23 +149,15 @@ impl Repository {
 
 /// Test-only helpers
 #[cfg(test)]
-impl Repository {
+impl Database {
     /// Create an in-memory DB, only for testing
     pub fn testing() -> Self {
         let mut connection = Connection::open_in_memory().unwrap();
-        Self::setup(&mut connection).unwrap();
+        Self::migrate(&mut connection).unwrap();
         Self {
             connection: Arc::new(Mutex::new(connection)),
         }
     }
-
-    /// Public insert function, only for tests
-    pub async fn insert_test(
-        &self,
-        record: &RequestRecord,
-    ) -> anyhow::Result<()> {
-        self.insert(record).await
-    }
 }
 
 impl ToSql for RequestId {

src/factory.rs

@@ -1,6 +1,7 @@
 use crate::{
     collection::{Chain, ChainSource, RequestRecipeId},
-    http::{Body, Repository, Request, RequestId, RequestRecord, Response},
+    db::Database,
+    http::{Body, Request, RequestId, RequestRecord, Response},
     template::{Prompt, Prompter, Template, TemplateContext},
 };
 use chrono::Utc;
@@ -61,7 +62,7 @@ factori!(TemplateContext, {
         profile = Default::default()
         chains = Default::default()
         prompter = Box::<TestPrompter>::default(),
-        repository = Repository::testing()
+        database = Database::testing()
         overrides = Default::default()
     }
 });

src/http.rs

@@ -35,14 +35,13 @@
 
 mod parse;
 mod record;
-mod repository;
 
 pub use parse::*;
 pub use record::*;
-pub use repository::*;
 
 use crate::{
     collection::RequestRecipe,
+    db::Database,
     template::{Template, TemplateContext},
     util::ResultExt,
 };
@@ -70,24 +69,24 @@ const USER_AGENT: &str =
 #[derive(Clone, Debug)]
 pub struct HttpEngine {
     client: Client,
-    repository: Repository,
+    database: Database,
 }
 
 impl HttpEngine {
     /// Build a new HTTP engine, which can be used for the entire program life
-    pub fn new(repository: Repository) -> Self {
+    pub fn new(database: Database) -> Self {
         Self {
             client: Client::builder()
                 .user_agent(USER_AGENT)
                 .build()
                 // This should be infallible
                 .expect("Error building reqwest client"),
-            repository,
+            database,
         }
     }
 
     /// Launch an HTTP request. Upon completion, it will automatically be
-    /// registered in the repository for posterity.
+    /// registered in the database for posterity.
     ///
     /// This consumes the HTTP engine so that the future can outlive the scope
     /// that created the future. This allows the future to be created outside
@@ -131,7 +130,7 @@ impl HttpEngine {
                     };
 
                     // Error here should *not* kill the request
-                    let _ = self.repository.insert(&record).await;
+                    let _ = self.database.insert_request(&record).await;
                     Ok(record)
                 }
                 Err(error) => Err(RequestError {

src/http/record.rs

@@ -58,10 +58,7 @@ pub struct RequestError {
     Serialize,
     Deserialize,
 )]
-pub struct RequestId(
-    /// Private to enforce construction via deserialization or [Self::new]
-    pub(super) Uuid,
-);
+pub struct RequestId(pub Uuid);
 
 impl RequestId {
     pub fn new() -> Self {

src/main.rs

@@ -3,6 +3,7 @@
 
 mod cli;
 mod collection;
+mod db;
 #[cfg(test)]
 mod factory;
 mod http;

src/template.rs

@@ -9,7 +9,7 @@ pub use prompt::{Prompt, Prompter};
 
 use crate::{
     collection::{Chain, ChainId, ProfileValue},
-    http::Repository,
+    db::Database,
     template::{
         error::TemplateParseError,
         parse::{TemplateInputChunk, CHAIN_PREFIX, ENV_PREFIX},
@@ -30,7 +30,7 @@ pub struct TemplateContext {
     /// Chained values from dynamic sources
     pub chains: IndexMap<ChainId, Chain>,
     /// Needed for accessing response bodies for chaining
-    pub repository: Repository,
+    pub database: Database,
     /// Additional key=value overrides passed directly from the user
     pub overrides: IndexMap<String, String>,
     /// A conduit to ask the user questions
@@ -266,7 +266,7 @@ mod tests {
         #[case] expected_value: &str,
     ) {
         let recipe_id: RequestRecipeId = "recipe1".into();
-        let repository = Repository::testing();
+        let database = Database::testing();
         let response_body = json!({
             "string": "Hello World!",
             "number": 6,
@@ -277,8 +277,8 @@ mod tests {
         let request = create!(Request, recipe_id: recipe_id.clone());
         let response =
             create!(Response, body: response_body.to_string().into());
-        repository
-            .insert_test(
+        database
+            .insert_request(
                 &create!(RequestRecord, request: request, response: response),
             )
             .await
@@ -290,7 +290,7 @@ mod tests {
             selector: selector,
         )};
         let context = create!(
-            TemplateContext, repository: repository, chains: chains,
+            TemplateContext, database: database, chains: chains,
         );
 
         assert_eq!(
@@ -339,21 +339,21 @@ mod tests {
     async fn test_chain_request_error(
         #[case] chain_id: impl Into<ChainId>,
         #[case] chain: Chain,
-        // Optional request data to store in the repository
+        // Optional request data to store in the database
         #[case] request_response: Option<(Request, Response)>,
         #[case] expected_error: &str,
     ) {
-        let repository = Repository::testing();
+        let database = Database::testing();
         if let Some((request, response)) = request_response {
-            repository
-                .insert_test(&create!(
+            database
+                .insert_request(&create!(
                 RequestRecord, request: request, response: response))
                 .await
                 .unwrap();
         }
         let chains = indexmap! {chain_id.into() => chain};
         let context = create!(
-            TemplateContext, repository: repository, chains: chains
+            TemplateContext, database: database, chains: chains
         );
 
         assert_err!(render!("{{chains.chain1}}", context), expected_error);

src/template/error.rs

@@ -63,10 +63,10 @@ pub enum ChainError {
     /// Reference to a chain that doesn't exist
     #[error("Unknown chain")]
     Unknown,
-    /// An error occurred accessing the request repository. This error is
+    /// An error occurred accessing the persistence database. This error is
     /// generated by our code so we don't need any extra context.
     #[error(transparent)]
-    Repository(anyhow::Error),
+    Database(anyhow::Error),
     /// The chain ID is valid, but the corresponding recipe has no successful
     /// response
     #[error("No response available")]