Working named template registration/retrieval

Still can't do anything with the templates though.
And they're not validated

Author: tpoliaw

…19c75504c917b65e59ae7f396508251079b.json …379f45ec83a36351fc19353f8f48262c79e.json.sqlx/query-f3b05af5405d08d1577c12fbc483d19c75504c917b65e59ae7f396508251079b.json renamed to .sqlx/query-15bdb26777072892c7feb712ae373379f45ec83a36351fc19353f8f48262c79e.json .sqlx/query-f3b05af5405d08d1577c12fbc483d19c75504c917b65e59ae7f396508251079b.json renamed to .sqlx/query-15bdb26777072892c7feb712ae373379f45ec83a36351fc19353f8f48262c79e.json

@@ -1 +1,2 @@
-DROP TABLE templates;
+DROP VIEW beamline_template;
+DROP TABLE template;

.sqlx/query-74ddd4d18b2b3529839b609905af032ed741abbd5f26fb9dd0c3079a313ef958.json

@@ -1,7 +1,19 @@
 -- Add new table for additional templates
-CREATE TABLE templates (
+CREATE TABLE template (
     id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    name TEXT NOT NULL CHECK (length(name) > 0),
-    template TEXT NOT NULL CHECK (length(name) > 0),
-    beamline INTEGER NOT NULL REFERENCES beamline(id) ON DELETE CASCADE ON UPDATE CASCADE
-)
+    name TEXT NOT NULL,
+    template TEXT NOT NULL,
+    beamline INTEGER NOT NULL REFERENCES beamline(id) ON DELETE CASCADE ON UPDATE CASCADE,
+
+    CONSTRAINT duplicate_names UNIQUE (name, beamline) ON CONFLICT REPLACE,
+
+    CONSTRAINT empty_template CHECK (length(template) > 0),
+    CONSTRAINT empty_name CHECK (length(name) > 0)
+);
+
+CREATE VIEW beamline_template (beamline, name, template) AS
+    SELECT
+        beamline.name, template.name, template.template
+    FROM beamline
+        JOIN template
+        ON beamline.id = template.beamline;

.sqlx/query-b09ef7bc16a56728acaf3b4a9e899bf4d9e2893f77b02765f9c9712f74b0e56b.json

@@ -16,10 +16,10 @@ use std::fmt;
 use std::marker::PhantomData;
 use std::path::Path;
 
-pub use error::ConfigurationError;
 use error::NewConfigurationError;
+pub use error::{ConfigurationError, NamedTemplateError};
 use sqlx::sqlite::{SqliteConnectOptions, SqliteRow};
-use sqlx::{query, query_as, FromRow, QueryBuilder, Row, Sqlite, SqlitePool};
+use sqlx::{query_as, FromRow, QueryBuilder, Row, Sqlite, SqlitePool};
 use tracing::{info, instrument, trace};
 
 use crate::paths::{
@@ -41,6 +41,15 @@ pub struct NamedTemplate {
     pub template: String,
 }
 
+impl<'r> FromRow<'r, SqliteRow> for NamedTemplate {
+    fn from_row(row: &'r SqliteRow) -> Result<Self, sqlx::Error> {
+        Ok(Self {
+            name: row.try_get("name")?,
+            template: row.try_get("template")?,
+        })
+    }
+}
+
 #[derive(Debug, PartialEq, Eq)]
 struct RawPathTemplate<F>(String, PhantomData<F>);
 
@@ -347,37 +356,52 @@ impl SqliteScanPathService {
         .ok_or(ConfigurationError::MissingInstrument(instrument.into()))
     }
 
-    pub async fn additional_templates(
+    pub async fn all_additional_templates(
         &self,
         beamline: &str,
     ) -> Result<Vec<NamedTemplate>, ConfigurationError> {
         Ok(query_as!(
             NamedTemplate,
-            "SELECT templates.name, templates.template
-                FROM beamline JOIN templates ON beamline.id = templates.beamline
-                WHERE beamline.name = ?",
+            "SELECT name, template FROM beamline_template WHERE beamline = ?",
             beamline
         )
         .fetch_all(&self.pool)
         .await?)
     }
+    pub async fn additional_templates(
+        &self,
+        beamline: &str,
+        names: Vec<String>,
+    ) -> Result<Vec<NamedTemplate>, ConfigurationError> {
+        let mut q =
+            QueryBuilder::new("SELECT name, template FROM beamline_template WHERE beamline = ");
+        q.push_bind(beamline);
+        q.push(" AND name IN (");
+        let mut name_query = q.separated(", ");
+        for name in names {
+            name_query.push_bind(name);
+        }
+        q.push(")");
+        let query = q.build_query_as();
+        Ok(query.fetch_all(&self.pool).await?)
+    }
 
     pub async fn register_template(
         &self,
         beamline: &str,
         name: String,
         template: String,
-    ) -> Result<(), ConfigurationError> {
-        query!(
-            "INSERT INTO templates (name, template, beamline)
-                VALUES (?, ?, (SELECT id FROM beamline WHERE name = ?));",
+    ) -> Result<NamedTemplate, NamedTemplateError> {
+        Ok(query_as!(
+            NamedTemplate,
+            "INSERT INTO template (name, template, beamline)
+                VALUES (?, ?, (SELECT id FROM beamline WHERE name = ?)) RETURNING name, template;",
             name,
             template,
             beamline
         )
-        .execute(&self.pool)
-        .await?;
-        Ok(())
+        .fetch_one(&self.pool)
+        .await?)
     }
 
     /// Create a db service from a new empty/schema-less DB
@@ -407,7 +431,9 @@ impl fmt::Debug for SqliteScanPathService {
 }
 
 mod error {
+
     use derive_more::{Display, Error, From};
+    use sqlx::error::ErrorKind;
 
     #[derive(Debug, Display, Error, From)]
     pub enum ConfigurationError {
@@ -431,6 +457,46 @@ mod error {
             Self::MissingField(value.into())
         }
     }
+
+    #[derive(Debug, Display, Error)]
+    pub enum NamedTemplateError {
+        #[display("No configuration for beamline")]
+        MissingBeamline,
+        #[display("Template name was empty")]
+        EmptyName,
+        #[display("Template was empty")]
+        EmptyTemplate,
+        #[display("Error accessing named template: {_0}")]
+        DbError(sqlx::Error),
+    }
+
+    impl From<sqlx::Error> for NamedTemplateError {
+        fn from(value: sqlx::Error) -> Self {
+            match value {
+                sqlx::Error::Database(err) => match (err.kind(), err.message().split_once(": ")) {
+                    (ErrorKind::NotNullViolation, Some((_, "template.beamline"))) => {
+                        NamedTemplateError::MissingBeamline
+                    }
+                    // pretty sure these two are not possible as strings can't be null
+                    (ErrorKind::NotNullViolation, Some((_, "template.name"))) => {
+                        NamedTemplateError::EmptyName
+                    }
+                    (ErrorKind::NotNullViolation, Some((_, "template.template"))) => {
+                        NamedTemplateError::EmptyTemplate
+                    }
+                    // Values are empty - these rely on the named checks in the schema
+                    (ErrorKind::CheckViolation, Some((_, "empty_name"))) => {
+                        NamedTemplateError::EmptyName
+                    }
+                    (ErrorKind::CheckViolation, Some((_, "empty_template"))) => {
+                        NamedTemplateError::EmptyTemplate
+                    }
+                    (_, _) => NamedTemplateError::DbError(sqlx::Error::Database(err)),
+                },
+                err => err.into(),
+            }
+        }
+    }
 }
 
 #[cfg(test)]

migrations/0003_template_table.down.sql

@@ -41,7 +41,7 @@ use tracing::{debug, info, instrument, trace, warn};
 use crate::build_info::ServerStatus;
 use crate::cli::ServeOptions;
 use crate::db_service::{
-    InstrumentConfiguration, InstrumentConfigurationUpdate, SqliteScanPathService,
+    InstrumentConfiguration, InstrumentConfigurationUpdate, NamedTemplate, SqliteScanPathService,
 };
 use crate::numtracker::NumTracker;
 use crate::paths::{
@@ -302,6 +302,23 @@ impl CurrentConfiguration {
     }
 }
 
+#[derive(Debug, InputObject)]
+struct TemplateInput {
+    name: String,
+    template: String,
+}
+
+#[Object]
+impl NamedTemplate {
+    async fn name(&self) -> &str {
+        &self.name
+    }
+
+    async fn template(&self) -> &str {
+        &self.template
+    }
+}
+
 impl FieldSource<ScanField> for ScanPaths {
     fn resolve(&self, field: &ScanField) -> Cow<'_, str> {
         match field {
@@ -384,6 +401,24 @@ impl Query {
         .into_iter()
         .collect()
     }
+
+    #[instrument(skip(self, ctx))]
+    async fn named_templates<'ctx>(
+        &self,
+        ctx: &Context<'ctx>,
+        beamline: String,
+        names: Option<Vec<String>>,
+    ) -> async_graphql::Result<Vec<NamedTemplate>> {
+        check_auth(ctx, |policy, token| {
+            policy.check_beamline_admin(token, &beamline)
+        })
+        .await?;
+        let db = ctx.data::<SqliteScanPathService>()?;
+        match names {
+            Some(names) => Ok(db.additional_templates(&beamline, names).await?),
+            None => Ok(db.all_additional_templates(&beamline).await?),
+        }
+    }
 }
 
 #[Object]
@@ -451,6 +486,20 @@ impl Mutation {
         };
         CurrentConfiguration::for_config(db_config, nt).await
     }
+
+    #[instrument(skip(self, ctx))]
+    async fn register_template<'ctx>(
+        &self,
+        ctx: &Context<'ctx>,
+        beamline: String,
+        template: TemplateInput,
+    ) -> async_graphql::Result<NamedTemplate> {
+        check_auth(ctx, |pc, token| pc.check_beamline_admin(token, &beamline)).await?;
+        let db = ctx.data::<SqliteScanPathService>()?;
+        Ok(db
+            .register_template(&beamline, template.name, template.template)
+            .await?)
+    }
 }
 
 async fn check_auth<'ctx, Check, R>(ctx: &Context<'ctx>, check: Check) -> async_graphql::Result<()>