Merge pull request #10 from bensherriff/develop

Updated version to 0.2.4

.env.TEMPLATE

@@ -1,6 +0,0 @@
-DISCORD_TOKEN=
-RUST_LOG=warn,siren=info
-POSTGRES_USER=siren
-POSTGRES_PASSWORD=
-POSTGRES_DB=siren
-OPENAI_API_KEY=

.gitignore

@@ -1,11 +1,7 @@
 .env
 target/
 .idea/
-.vscode/
 **/Cargo.lock
 
-audio/
 logs/
-settings.json
 app/
-data/

.version

@@ -1 +0,0 @@
-SIREN_VERSION=0.2.3

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "rust-analyzer.linkedProjects": [
+    "./service/Cargo.toml",
+    "./bot/Cargo.toml",
+  ]
+}

Makefile

@@ -1,34 +0,0 @@
-#!make
-SHELL := /bin/bash
-
-include .env
-include .version
-export $(shell sed 's/=.*//' .env)
-export $(shell sed 's/=.*//' .version)
-
-SIREN_IMAGES = $(shell docker images 'siren' -a -q)
-
-.PHONY: help build test up down exec clean
-
-help: ## Help command
-	@echo
-	@cat Makefile | grep -E '^[a-zA-Z\/_-]+:.*?## .*$$' | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
-	@echo
-
-build: ## Build the docker image
-	docker build -t siren:${SIREN_VERSION} .
-
-test: ## Run the docker app as a container
-	docker run --env-file .env -it --rm --name siren siren:${SIREN_VERSION}
-
-up: ## Start the app
-	docker compose up -d
-
-down: ## Stop the app
-	docker compose down
-
-exec: ## Enter running docker container
-	docker exec -it siren bash
-
-clean: ## Cleanup docker images
-	docker rmi $(SIREN_IMAGES)

bot/.env.TEMPLATE

@@ -0,0 +1,8 @@
+RUST_LOG=warn,bot=info
+COMPOSE_PROJECT_NAME=siren
+
+SERVICE_HOST=localhost
+SERVICE_PORT=5000
+
+DISCORD_TOKEN=
+OPENAI_API_KEY=

bot/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "siren"
+name = "bot"
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 authors = ["Ben Sherriff <hello@bensherriff.com>"]
 repository = "https://github.com/bensherriff/siren"
@@ -8,10 +8,12 @@ readme = "README.md"
 license = "GPL-3.0-or-later"
 
 [dependencies]
+chrono = { version = "0.4.31", features = ["serde"] }
 dotenv = "0.15.0"
-serde_json = "1.0"
+serde_json = "1.0.107"
-log = "0.4.19"
+log = "0.4.20"
 env_logger = "0.10.0"
+service = { path = "../service" }
 
 [dependencies.serenity]
 version = "0.11.6"
@@ -23,19 +25,18 @@ version = "0.3.2"
 features = ["builtin-queue", "yt-dlp"]
 
 [dependencies.tokio]
-version = "1.29.1"
+version = "1.32.0"
 features = ["macros", "rt-multi-thread"]
 
 [dependencies.serde]
-version = "1.0"
+version = "1.0.188"
 features = ["derive"]
 
 [dependencies.reqwest]
-version = "0.11.18"
+version = "0.11.22"
 default-features = false
 features = ["json", "rustls-tls"]
 
-[dependencies.diesel]
+[dependencies.pyo3]
-version = "2.1.0"
+version = "0.19.2"
-default-features = false
+features = ["auto-initialize"]
-features = ["postgres", "32-column-tables", "serde_json", "r2d2", "with-deprecated"]

bot/Dockerfile

@@ -1,12 +1,15 @@
-FROM rust:1.70.0 as builder
+# Builder
-WORKDIR /siren
+FROM rust:1.72.1-bookworm as builder
-ADD src ./src/
+WORKDIR /builder
-ADD Cargo.toml ./
-RUN apt-get update && apt-get install -y cmake && \
-  cargo build --release --bin siren
 
+COPY src ./src
+COPY Cargo.toml ./
+RUN cargo build --release
+
+# Packages
 FROM debian:bullseye-slim as packages
 WORKDIR /packages
+
 RUN apt-get update && apt-get install -y curl tar xz-utils && \
   curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp_linux > yt-dlp && \
   chmod +x yt-dlp && \
@@ -19,10 +22,11 @@ RUN apt-get update && apt-get install -y curl tar xz-utils && \
 #   curl -L https://download.pytorch.org/libtorch/cu117/libtorch-cxx11-abi-shared-with-deps-2.0.1%2Bcu117.zip > libtorch.zip && \
 #   unzip libtorch.zip && rm libtorch.zip
 
+# Runner
 FROM debian:bullseye-slim as runtime
-WORKDIR /siren
+WORKDIR /bot
 RUN apt-get update && apt-get install -y libopus-dev libpq5 libpq-dev && apt-get auto-remove -y
-COPY --from=builder /siren/target/release/siren /usr/local/bin/siren
+COPY --from=builder /builder/target/release/bot /usr/local/bin/bot
 COPY --from=packages /packages /usr/bin
 # COPY --from=libraries /libraries /usr/lib
 
@@ -30,4 +34,4 @@ COPY --from=packages /packages /usr/bin
 # ARG LD_LIBRARY_PATH=${LIBTORCH}/lib:${LD_LIBRARY_PATH}
 
 # ADD migrations ./
-CMD ["siren"]
+CMD ["bot"]

bot/Makefile

@@ -0,0 +1,27 @@
+#!make
+SHELL := /bin/bash
+
+include .env
+
+.PHONY: help build test up down exec clean
+
+help: ## Help command
+	@echo
+	@cat Makefile | grep -E '^[a-zA-Z\/_-]+:.*?## .*$$' | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+	@echo
+
+build: ## Build the docker image
+	docker compose build
+
+db: ## Start the docker database
+	docker compose up -d db
+
+up: ## Start the app
+	docker compose up -d
+
+down: ## Stop the app
+	docker compose down
+
+clean:
+	docker compose down && \
+	docker image rm siren-bot

bot/docker-compose.yml

@@ -0,0 +1,20 @@
+version: '3.8'
+
+services:
+  bot:
+    image: siren-bot:${BOT_VERSION:-latest}
+    container_name: siren-bot
+    build:
+      context: .
+      dockerfile: ./Dockerfile
+      args:
+        - VERSION=${BOT_VERSION:-latest}
+    env_file:
+      - .env
+    networks:
+      - frontend
+    restart: unless-stopped
+
+
+networks:
+  frontend:

bot/src/commands/oai.rs

@@ -1,9 +1,3 @@
-
-use std::error::Error;
-use std::fmt;
-
-use diesel::{prelude::*, PgConnection, insert_into};
-use diesel::r2d2::{Pool, ConnectionManager};
 use log::{error, debug, trace, warn};
 
 use serde::{Serialize, Deserialize};
@@ -12,14 +6,16 @@ use serenity::model::Permissions;
 use serenity::model::channel::Message;
 use serenity::model::prelude::{ChannelType, PermissionOverwrite, PermissionOverwriteType};
 use serenity::prelude::*;
-
+use siren::{GetResponse, ServiceError};
-use crate::database::models::{NewMessageDB, MessageDB};
 
 pub struct OAI {
   pub client: reqwest::Client,
   pub base_url: String,
+  pub service_url: String,
   pub max_attempts: i64,
   pub token: String,
+  pub max_tokens: i64,
+  pub default_model: GPTModel,
   pub max_context_questions: i64
 }
 
@@ -66,7 +62,7 @@ enum GPTRole {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-enum GPTModel {
+pub enum GPTModel {
   #[serde(rename = "gpt-3.5-turbo")]
   GPT35Turbo,
   #[serde(rename = "gpt-3.5-turbo-0613")]
@@ -111,26 +107,18 @@ struct Choice {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct ResponseError {
-  code: Option<i64>,
+  error: Option<ErrorDetails>,
   message: Option<String>,
   param: Option<String>,
   #[serde(rename = "type")]
   error_type: Option<String>
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
-struct OAIError {
+struct ErrorDetails {
-  pub message: String
+  code: Option<String>
 }
 
-impl fmt::Display for OAIError {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "OAIError: {}", self.message)
-  }
-}
-
-impl Error for OAIError {}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 enum ResponseEvent {
   ChatCompletionResponse(ChatCompletionResponse),
@@ -138,92 +126,81 @@ enum ResponseEvent {
 }
 
 impl OAI {
-  async fn get_request(&self, request: ChatCompletionRequest) -> Result<ChatCompletionResponse, OAIError> {
+  async fn get_request(&self, request: ChatCompletionRequest) -> Result<ChatCompletionResponse, ServiceError> {
     let uri = format!("{}/chat/completions", self.base_url);
     let body = serde_json::to_string(&request).unwrap();
     trace!("Sending request to {}: {}", uri, body);
 
-    let value = match match self.client
+    let value = self.client
       .post(&uri)
       .bearer_auth(&self.token)
       .header("Content-Type", "application/json".to_string())
       .body(body)
       .send()
-      .await {
+      .await?
-        Ok(r) => r,
-        Err(err) => return Err(OAIError {
-          message: format!("Could not send request to OpenAI: {}", err),
-        })
-      }
       .json::<Value>()
-      .await {
+      .await?;
-        Ok(r) => r,
-        Err(err) => return Err(OAIError {
-          message: format!("Could not read response from OpenAI: {}", err)
-        })
-      };
 
     trace!("Received response from OpenAI: {:?}", value);
     
-    // let response = match serde_json::from_value::<OAIResponseEvent>(value) {
+    // let response = match serde_json::from_value::<ResponseEvent>(value) {
     //   Ok(r) => {
     //     match r {
-    //       OAIResponseEvent::OAIResponse(r) => r,
+    //       ResponseEvent::ChatCompletionResponse(r) => r,
-    //       OAIResponseEvent::OAIError(e) => return Err(OAIError { message: e.message.unwrap_or("Unknown error".to_string()) })
+    //       ResponseEvent::ResponseError(e) => return Err(ServiceError { message: e.message.unwrap_or("Unknown error".to_string()), status: 500 }),
     //     }
     //   },
-    //   Err(err) => return Err(OAIError {
+    //   Err(err) => return Err(ServiceError {
-    //     message: format!("Could not parse response from OpenAI: {}", err)
+    //     message: format!("Could not parse response from OpenAI: {}", err),
+    //     status: 500
     //   })
     // };
-    let response = match serde_json::from_value::<ChatCompletionResponse>(value) {
+    let response = serde_json::from_value::<ChatCompletionResponse>(value)?;
-      Ok(r) => r,
-      Err(err) => return Err(OAIError {
-        message: format!("Could not parse response from OpenAI: {}", err)
-      })
-    };
 
     Ok(response)
   }
+
+  async fn get_messages(&self, guild_id: u64, channel_id: u64, author_id: u64) -> Result<GetResponse<Vec<siren::Message>>, ServiceError> {
+    let uri = format!("{}/messages?guild_id={}&channel_id={}&author_id={}&limit={}", self.service_url, guild_id, channel_id, author_id, self.max_context_questions);
+    let value = self.client
+      .get(&uri)
+      .send()
+      .await?
+      .json::<Value>()
+      .await?;
+
+    let response = serde_json::from_value::<GetResponse<Vec<siren::Message>>>(value)?;
+
+    Ok(response)
+  }
+
+  async fn store_message(&self, message: siren::Message) -> Result<siren::Message, ServiceError> {
+    let uri = format!("{}/messages", self.service_url);
+    trace!("Sending request to {}", uri);
+    let value = self.client
+      .post(&uri)
+      .json::<siren::Message>(&message)
+      .send()
+      .await?
+      .json::<Value>()
+      .await?;
+      trace!("Received response from Service: {:?}", value);
+      let response = serde_json::from_value::<siren::Message>(value)?;
+      Ok(response)
+  }
 }
 
-pub async fn generate_response(ctx: &Context, msg: &Message, oai: &OAI, pool: &Pool<ConnectionManager<PgConnection>>) {
+pub async fn generate_response(ctx: &Context, msg: &Message, oai: &OAI) {
   debug!("Generating response for message: {}", msg.content);
 
   let guild_id = msg.guild_id.unwrap();
   let channel_id = msg.channel_id;
   let author_id = msg.author.id;
-  let mut connection = pool.get().unwrap();
 
   // Parse out the bot mention from the message
   let bot_mention: String = format!("<@{}>", ctx.cache.current_user_id().0);
   let parsed_content = msg.content.replace(bot_mention.as_str(), "");
 
-  // Setup the request messages
-  let result: Result<Vec<MessageDB>, diesel::result::Error> = crate::database::schema::messages::table
-    .select(MessageDB::as_select())
-    .filter((crate::database::schema::messages::guild_id.eq(guild_id.0 as i64))
-      .and(crate::database::schema::messages::channel_id.eq(channel_id.0  as i64))
-      .and(crate::database::schema::messages::user_id.eq(author_id.0  as i64))
-    )
-    .order(crate::database::schema::messages::created.asc())
-    .limit(oai.max_context_questions)
-    .load(&mut connection);
-  
-  let previous_messages = match result {
-    Ok(r) => {
-      let mut previous_message = "".to_string();
-      for message in r {
-        previous_message = format!("{}You: {}\n Siren: {}\n", previous_message, message.request, message.response);
-      }
-      Some(ChatCompletionMessage { role: GPTRole::User, content: previous_message })
-    }
-    Err(err) => {
-      error!("Could not load previous messages: {}", err);
-      None
-    }
-  };
-
   let mut messages = vec![
     ChatCompletionMessage {
       role: GPTRole::System,
@@ -231,25 +208,35 @@ pub async fn generate_response(ctx: &Context, msg: &Message, oai: &OAI, pool: &P
     },
   ];
   
-  if let Some(mut previous) = previous_messages {
+  let previous_messages = oai.get_messages(guild_id.0, channel_id.0, author_id.0).await;
-    previous.content = format!("{}You: {}\nSiren: ", previous.content, parsed_content);
+  match previous_messages {
-    messages.push(previous);
+    Ok(m) => {
-  } else {
+      for message in m.data {
-    messages.push(ChatCompletionMessage {
+        messages.push(
+          ChatCompletionMessage {
             role: GPTRole::User,
-      content: format!("You: {}, Siren: ", parsed_content)
+            content: format!("{}", message.request)
-    });
           }
-
+        );
-  let model = "gpt-3.5-turbo".to_string();
+        messages.push(
+          ChatCompletionMessage {
+            role: GPTRole::Assistant,
+            content: format!("{}", message.response)
+          }
+        );
+      }
+    },
+    Err(err) => warn!("Could not load previous messages: {}", err)
+  };
+  messages.push(ChatCompletionMessage { role: GPTRole::User, content: parsed_content.clone() });
 
   let request = ChatCompletionRequest {
-    model: GPTModel::GPT35Turbo,
+    model: oai.default_model.clone(),
     messages,
     temperature: Some(0.5),
     top_p: None,
     n: None,
-    max_tokens: Some(1000),
+    max_tokens: Some(oai.max_tokens),
     presence_penalty: Some(0.6),
     frequency_penalty: Some(0.0),
     user: Some(msg.author.name.clone())
@@ -283,20 +270,19 @@ pub async fn generate_response(ctx: &Context, msg: &Message, oai: &OAI, pool: &P
       debug!("Processing response received from OpenAI");
       if !r.choices.is_empty() {
         let res = r.choices[0].message.content.clone();
-        // Insert the message into the messages database table
+        if let Err(err) = oai.store_message(siren::Message {
-        if let Err(err) = insert_into(crate::database::schema::messages::table).values(NewMessageDB {
+          id: r.id,
-          id: &r.id,
           guild_id: guild_id.0 as i64,
           channel_id: response_channel.0 as i64,
           user_id: author_id.0 as i64,
           created: r.created,
-          model: &model,
+          model: serde_json::to_string(&r.model).unwrap(),
-          request: &parsed_content,
+          request: parsed_content,
-          response: &res,
+          response: res.clone(),
           request_tags: vec![],
           response_tags: vec![],
-        }).execute(&mut connection) {
+        }).await {
-          error!("Could not insert message into database: {}", err);
+          warn!("{}", err);
         }
         res
       } else {
@@ -306,7 +292,7 @@ pub async fn generate_response(ctx: &Context, msg: &Message, oai: &OAI, pool: &P
     }
     Err(err) => {
       error!("Could not get response from OpenAI: {}", err.message);
-      err.message
+      "There was an error processing your message. Please try again later.".to_string()
     }
   };
   debug!("Writing response: \"{}\"", response);

bot/src/main.rs

@@ -3,8 +3,6 @@ use std::env;
 use std::sync::Arc;
 
 use commands::audio::{create_response, AudioConfig, AudioConfigs};
-use diesel::r2d2::{Pool, ConnectionManager};
-use diesel::pg::PgConnection;
 
 use dotenv::dotenv;
 use log::{error, warn, info};
@@ -17,12 +15,13 @@ use serenity::http::Http;
 use serenity::prelude::*;
 use songbird::SerenityInit;
 
+use crate::commands::oai::GPTModel;
+
 mod commands;
-mod database;
+
 struct Handler {
   // Open AI Config
-  oai: Option<commands::oai::OAI>,
+  oai: Option<commands::oai::OAI>
-  pool: Pool<ConnectionManager<PgConnection>>
 }
 
 #[async_trait]
@@ -45,9 +44,8 @@ impl EventHandler for Handler {
               }
               Err(_) => false
             };
-            // let has_bot = msg.channel_id.get_thread_members(&ctx.http).await.unwrap().contains(ctx.cache.current_user_id().0);
             if mentioned || bot_in_thread {
-              commands::oai::generate_response(&ctx, &msg, oai, &self.pool).await;
+              commands::oai::generate_response(&ctx, &msg, oai).await;
             }
           }
           Err(why) => warn!("Could not check mentions: {:?}", why)
@@ -135,20 +133,25 @@ async fn main() {
     Err(why) => panic!("Could not access application info: {:?}", why)
   };
   
-  let pool = database::establish_connection();
-  database::run_migrations(&pool);
-  
   let handler = match env::var("OPENAI_API_KEY") {
     Ok(token) => {
       info!("Loaded OpenAI token");
       Handler {
-        oai: Some(commands::oai::OAI { client: reqwest::Client::new(), base_url: "https://api.openai.com/v1".to_string(), max_attempts: 5, token , max_context_questions: 15 }),
+        oai: Some(commands::oai::OAI {
-        pool
+          client: reqwest::Client::new(),
+          base_url: "https://api.openai.com/v1".to_string(),
+          service_url: "http://localhost:5000".to_string(),
+          max_attempts: 5,
+          token,
+          max_context_questions: 30,
+          max_tokens: 2048,
+          default_model: GPTModel::GPT35Turbo,
+        })
       }
     }
     Err(err) => {
       warn!("Could not load OpenAI token: {}", err);
-      Handler { oai: None, pool }
+      Handler { oai: None }
     }
   };
 

docker-compose.yml

@@ -1,40 +0,0 @@
-version: '3'
-
-services:
-  siren:
-    image: siren:${SIREN_VERSION:-latest}
-    container_name: siren
-    build:
-      context: .
-      dockerfile: ./Dockerfile
-      args:
-        - VERSION=${SIREN_VERSION:-latest}
-    volumes:
-     - ./app:/siren
-    env_file:
-      - .env
-    environment:
-      DISCORD_TOKEN: ${DISCORD_TOKEN}
-      RUST_LOG: ${RUST_LOG}
-      OPENAI_API_KEY: ${OPENAI_API_KEY}
-      POSTGRES_USER: ${POSTGRES_USER}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
-      POSTGRES_DB: ${POSTGRES_DB}
-      POSTGRES_HOST: db
-    depends_on:
-      - db
-    restart: unless-stopped
-  db:
-    image: postgres:latest
-    container_name: siren_db
-    env_file:
-      - .env
-    environment:
-      POSTGRES_USER: ${POSTGRES_USER}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
-      POSTGRES_DB: ${POSTGRES_DB}
-    volumes:
-     - ./data:/var/lib/postgresql/data
-    ports:
-      - "5432:5432"
-    restart: unless-stopped

migrations/create_messages/down.sql

@@ -1 +0,0 @@
-DROP TABLE messages

service/.env.TEMPLATE

@@ -0,0 +1,14 @@
+RUST_LOG=warn,service=info
+COMPOSE_PROJECT_NAME=siren
+
+DATABASE_USER=siren
+DATABASE_PASSWORD=
+DATABASE_NAME=siren
+DATABASE_HOST=localhost
+DATABASE_PORT=5432
+
+SERVICE_HOST=localhost
+SERVICE_PORT=5000
+
+DISCORD_TOKEN=
+OPENAI_API_KEY=

service/.version

@@ -0,0 +1 @@
+SIREN_VERSION=0.2.4

service/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+name = "service"
+version = "0.2.4"
+edition = "2021"
+authors = ["Ben Sherriff <hello@bensherriff.com>"]
+repository = "https://github.com/bensherriff/siren"
+readme = "README.md"
+license = "GPL-3.0-or-later"
+
+[lib]
+name = "siren"
+path = "src/lib.rs"
+
+[dependencies]
+actix-web = "4.4.0"
+actix-rt = "2.9.0"
+actix-web-httpauth = "0.8.1"
+chrono = { version = "0.4.31", features = ["serde"] }
+dotenv = "0.15.0"
+serde_json = "1.0.107"
+log = "0.4.20"
+env_logger = "0.10.0"
+diesel_migrations = { version = "2.1.0", features = ["postgres"] }
+r2d2 = "0.8.10"
+lazy_static = "1.4.0"
+uuid = { version = "1.4.1", features = ["serde", "v4"] }
+
+[dependencies.tokio]
+version = "1.32.0"
+features = ["macros", "rt-multi-thread"]
+
+[dependencies.serde]
+version = "1.0.188"
+features = ["derive"]
+
+[dependencies.reqwest]
+version = "0.11.22"
+default-features = false
+features = ["json", "rustls-tls"]
+
+[dependencies.diesel]
+version = "2.1.2"
+default-features = false
+features = ["postgres", "32-column-tables", "serde_json", "r2d2", "with-deprecated"]

service/Dockerfile

@@ -0,0 +1,12 @@
+FROM rust:1.72.1-bookworm as builder
+
+WORKDIR /service
+USER root
+
+COPY migrations ./migrations
+COPY data ./data
+COPY src ./src
+COPY Cargo.toml ./
+
+RUN cargo build --release
+CMD ["./target/release/service"]

service/Makefile

@@ -0,0 +1,29 @@
+#!make
+SHELL := /bin/bash
+
+include .env
+
+.PHONY: help build test up down exec clean
+
+help: ## Help command
+	@echo
+	@cat Makefile | grep -E '^[a-zA-Z\/_-]+:.*?## .*$$' | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+	@echo
+
+build: ## Build the docker image
+	docker compose build
+
+db: ## Start the docker database
+	docker compose up -d db
+
+up: ## Start the app
+	docker compose up -d
+
+down: ## Stop the app
+	docker compose down
+
+clean:
+	docker compose down && \
+	docker image rm siren-service || \
+	docker network rm siren_frontend || \
+	docker network rm siren-backend

service/docker-compose.yml

@@ -0,0 +1,51 @@
+version: '3.8'
+
+services:
+  service:
+    image: siren-service:${SIREN_VERSION:-latest}
+    container_name: siren-service
+    build:
+      context: .
+      dockerfile: ./Dockerfile
+      args:
+        - VERSION=${SIREN_VERSION:-latest}
+    env_file:
+      - .env
+    environment:
+      DATABASE_HOST: db
+      DATABASE_PORT: 5432
+      SERVICE_HOST: siren
+      SERVICE_PORT: 5000
+    ports:
+      - ${SERVICE_PORT:-5000}:5000
+    depends_on:
+      - db
+    networks:
+      - frontend
+      - backend
+    restart: unless-stopped
+  db:
+    image: postgres:latest
+    container_name: siren-db
+    env_file:
+      - .env
+    environment:
+      POSTGRES_USER: ${DATABASE_USER}
+      POSTGRES_PASSWORD: ${DATABASE_PASSWORD}
+      POSTGRES_DB: ${DATABASE_NAME}
+    volumes:
+      - db:/var/lib/postgresql/data
+      - db_logs:/var/log
+    ports:
+      - ${DATABASE_PORT:-5432}:5432
+    networks:
+      - backend
+    restart: unless-stopped
+
+volumes:
+  db:
+  db_logs:
+
+networks:
+  frontend:
+  backend:

service/migrations/000000_create_messages/down.sql

@@ -0,0 +1 @@
+DROP TABLE messages;

service/migrations/000000_create_messages/up.sql

@@ -9,4 +9,4 @@ CREATE TABLE IF NOT EXISTS messages (
   response TEXT NOT NULL,
   request_tags TEXT[] NOT NULL,
   response_tags TEXT[] NOT NULL
-)
+);

service/migrations/000001_create_races/down.sql

@@ -0,0 +1 @@
+DROP TABLE races;

service/migrations/000001_create_races/up.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS races (
+  id INTEGER GENERATED ALWAYS AS IDENTITY,
+  name TEXT NOT NULL,
+  size TEXT NOT NULL,
+  source TEXT NOT NULL,
+  data JSON NOT NULL
+);

service/migrations/000002_create_classes/down.sql

@@ -0,0 +1 @@
+DROP TABLE classes;

service/migrations/000002_create_classes/up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE IF NOT EXISTS classes (
+  id INTEGER GENERATED ALWAYS AS IDENTITY
+);

service/migrations/000003_create_feats/down.sql

@@ -0,0 +1 @@
+DROP TABLE feats;

service/migrations/000003_create_feats/up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE IF NOT EXISTS feats (
+  id INTEGER GENERATED ALWAYS AS IDENTITY
+);

service/migrations/000004_create_options_features/down.sql

@@ -0,0 +1 @@
+DROP TABLE options_features;

service/migrations/000004_create_options_features/up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE IF NOT EXISTS options_features (
+  id INTEGER GENERATED ALWAYS AS IDENTITY
+);

service/migrations/000005_create_backgrounds/down.sql

@@ -0,0 +1 @@
+DROP TABLE backgrounds;

service/migrations/000005_create_backgrounds/up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE IF NOT EXISTS backgrounds (
+  id INTEGER GENERATED ALWAYS AS IDENTITY
+);

service/migrations/000006_create_items/down.sql

@@ -0,0 +1 @@
+DROP TABLE items;

service/migrations/000006_create_items/up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE IF NOT EXISTS items (
+  id INTEGER GENERATED ALWAYS AS IDENTITY
+);

service/migrations/000007_create_spells/down.sql

@@ -0,0 +1 @@
+DROP TABLE spells;

service/migrations/000007_create_spells/up.sql

@@ -0,0 +1,15 @@
+CREATE TABLE IF NOT EXISTS spells (
+  id INTEGER GENERATED ALWAYS AS IDENTITY,
+  name TEXT NOT NULL,
+  school TEXT NOT NULL,
+  level INTEGER NOT NULL,
+  ritual BOOLEAN DEFAULT FALSE,
+  concentration BOOLEAN DEFAULT FALSE,
+  classes TEXT[] NOT NULL,
+  damage_inflict TEXT[] NOT NULL,
+  damage_resist TEXT[] NOT NULL,
+  conditions TEXT[] NOT NULL,
+  saving_throw TEXT[] NOT NULL,
+  attack_type TEXT,
+  data JSONB NOT NULL
+);

service/migrations/000008_create_conditions/down.sql

@@ -0,0 +1 @@
+DROP TABLE conditions;

service/migrations/000008_create_conditions/up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE IF NOT EXISTS conditions (
+  id INTEGER GENERATED ALWAYS AS IDENTITY
+);

service/migrations/000009_create_bestiary/down.sql

@@ -0,0 +1 @@
+DROP TABLE bestiary;

service/migrations/000009_create_bestiary/up.sql

@@ -0,0 +1,3 @@
+CREATE TABLE IF NOT EXISTS bestiary (
+  id INTEGER GENERATED ALWAYS AS IDENTITY
+);

service/src/db/classes/mod.rs

@@ -0,0 +1,3 @@
+mod model;
+
+pub use model::*;

service/src/db/classes/model.rs

@@ -0,0 +1,46 @@
+use std::str::FromStr;
+use serde::{Serialize, Deserialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum AbilityType {
+  #[serde(rename = "strength")]
+  Strength,
+  #[serde(rename = "dexterity")]
+  Dexterity,
+  #[serde(rename = "constitution")]
+  Constitution,
+  #[serde(rename = "intelligence")]
+  Intelligence,
+  #[serde(rename = "wisdom")]
+  Wisdom,
+  #[serde(rename = "charisma")]
+  Charisma
+}
+
+impl AbilityType {
+  pub fn to_string(&self) -> String {
+    match self {
+      AbilityType::Strength => "Strength".to_string(),
+      AbilityType::Dexterity => "Dexterity".to_string(),
+      AbilityType::Constitution => "Constitution".to_string(),
+      AbilityType::Intelligence => "Intelligence".to_string(),
+      AbilityType::Wisdom => "Wisdom".to_string(),
+      AbilityType::Charisma => "Charisma".to_string()
+    }
+  }
+}
+
+impl FromStr for AbilityType {
+  type Err = ();
+  fn from_str(s: &str) -> Result<Self, Self::Err> {
+    match s {
+      "Strength" => Ok(AbilityType::Strength),
+      "Dexterity" => Ok(AbilityType::Dexterity),
+      "Constitution" => Ok(AbilityType::Constitution),
+      "Intelligence" => Ok(AbilityType::Intelligence),
+      "Wisdom" => Ok(AbilityType::Wisdom),
+      "Charisma" => Ok(AbilityType::Charisma),
+      _ => Err(())
+    }
+  }
+}

service/src/db/conditions/mod.rs

@@ -0,0 +1,83 @@
+use std::str::FromStr;
+use serde::{Deserialize, Serialize};
+
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum ConditionType {
+  #[serde(rename = "blinded")]
+  Blinded,
+  #[serde(rename = "charmed")]
+  Charmed,
+  #[serde(rename = "deafened")]
+  Deafened,
+  #[serde(rename = "exhaustion")]
+  Exhaustion,
+  #[serde(rename = "frightened")]
+  Frightened,
+  #[serde(rename = "grappled")]
+  Grappled,
+  #[serde(rename = "incapacitated")]
+  Incapacitated,
+  #[serde(rename = "invisible")]
+  Invisible,
+  #[serde(rename = "paralyzed")]
+  Paralyzed,
+  #[serde(rename = "petrified")]
+  Petrified,
+  #[serde(rename = "poisoned")]
+  Poisoned,
+  #[serde(rename = "prone")]
+  Prone,
+  #[serde(rename = "restrained")]
+  Restrained,
+  #[serde(rename = "stunned")]
+  Stunned,
+  #[serde(rename = "unconscious")]
+  Unconscious
+}
+
+impl ConditionType {
+  pub fn to_string(&self) -> String {
+    match self {
+      ConditionType::Blinded => "Blinded".to_string(),
+      ConditionType::Charmed => "Charmed".to_string(),
+      ConditionType::Deafened => "Deafened".to_string(),
+      ConditionType::Exhaustion => "Exhaustion".to_string(),
+      ConditionType::Frightened => "Frightened".to_string(),
+      ConditionType::Grappled => "Grappled".to_string(),
+      ConditionType::Incapacitated => "Incapacitated".to_string(),
+      ConditionType::Invisible => "Invisible".to_string(),
+      ConditionType::Paralyzed => "Paralyzed".to_string(),
+      ConditionType::Petrified => "Petrified".to_string(),
+      ConditionType::Poisoned => "Poisoned".to_string(),
+      ConditionType::Prone => "Prone".to_string(),
+      ConditionType::Restrained => "Restrained".to_string(),
+      ConditionType::Stunned => "Stunned".to_string(),
+      ConditionType::Unconscious => "Unconscious".to_string()
+    }
+  }
+}
+
+impl FromStr for ConditionType {
+  type Err = ();
+  fn from_str(s: &str) -> Result<Self, Self::Err> {
+    match s {
+      "Blinded" => Ok(ConditionType::Blinded),
+      "Charmed" => Ok(ConditionType::Charmed),
+      "Deafened" => Ok(ConditionType::Deafened),
+      "Exhaustion" => Ok(ConditionType::Exhaustion),
+      "Frightened" => Ok(ConditionType::Frightened),
+      "Grappled" => Ok(ConditionType::Grappled),
+      "Incapacitated" => Ok(ConditionType::Incapacitated),
+      "Invisible" => Ok(ConditionType::Invisible),
+      "Paralyzed" => Ok(ConditionType::Paralyzed),
+      "Petrified" => Ok(ConditionType::Petrified),
+      "Poisoned" => Ok(ConditionType::Poisoned),
+      "Prone" => Ok(ConditionType::Prone),
+      "Restrained" => Ok(ConditionType::Restrained),
+      "Stunned" => Ok(ConditionType::Stunned),
+      "Unconscious" => Ok(ConditionType::Unconscious),
+      _ => Err(())
+    }
+  }
+}

service/src/db/messages/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod routes;
+
+pub use model::*;
+pub use routes::init_routes;

service/src/db/messages/model.rs

@@ -0,0 +1,150 @@
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+use siren::ServiceError;
+
+use crate::db::schema::messages::{self};
+
+#[derive(Queryable, Selectable, Serialize, Deserialize)]
+#[diesel(table_name = messages)]
+pub struct QueryMessage {
+  pub id: String,
+  pub guild_id: i64,
+  pub channel_id: i64,
+  pub user_id: i64,
+  pub created: i64,
+  pub model: String,
+  pub request: String,
+  pub response: String,
+  pub request_tags: Vec<String>,
+  pub response_tags: Vec<String>,
+}
+
+pub struct QueryFilters {
+  pub by_id: Option<String>,
+  pub by_guild_id: Option<i64>,
+  pub by_channel_id: Option<i64>,
+  pub by_user_id: Option<i64>,
+  pub by_model: Option<String>,
+  pub by_request: Option<String>,
+  pub by_response: Option<String>,
+  pub by_request_tags: Option<Vec<String>>,
+  pub by_response_tags: Option<Vec<String>>
+}
+
+impl Default for QueryFilters {
+  fn default() -> Self {
+    QueryFilters {
+      by_id: None,
+      by_guild_id: None,
+      by_channel_id: None,
+      by_user_id: None,
+      by_model: None,
+      by_request: None,
+      by_response: None,
+      by_request_tags: None,
+      by_response_tags: None
+    }
+  }
+}
+
+impl QueryMessage {
+  pub fn get_all(filters: &QueryFilters, limit: i32, page: i32) -> Result<Vec<Self>, ServiceError> {
+    let mut conn = crate::db::connection()?;
+    let mut query = messages::table.limit(limit as i64).order(messages::created.asc()).into_boxed();
+    // Limit query to page and limit
+    let offset = (page - 1) * limit;
+    query = query.offset(offset as i64);
+    // Apply filters
+    if let Some(id) = &filters.by_id {
+      query = query.filter(messages::id.eq(id));
+    }
+    if let Some(guild_id) = &filters.by_guild_id {
+      query = query.filter(messages::guild_id.eq(guild_id));
+    }
+    if let Some(channel_id) = &filters.by_channel_id {
+      query = query.filter(messages::channel_id.eq(channel_id));
+    }
+    if let Some(user_id) = &filters.by_user_id {
+      query = query.filter(messages::user_id.eq(user_id));
+    }
+    if let Some(model) = &filters.by_model {
+      query = query.filter(messages::model.eq(model));
+    }
+    if let Some(request) = &filters.by_request {
+      query = query.filter(messages::request.eq(request));
+    }
+    if let Some(response) = &filters.by_response {
+      query = query.filter(messages::response.eq(response));
+    }
+    if let Some(request_tags) = &filters.by_request_tags {
+      query = query.filter(messages::request_tags.eq(request_tags));
+    }
+    if let Some(response_tags) = &filters.by_response_tags {
+      query = query.filter(messages::response_tags.eq(response_tags));
+    }
+    // Execute query
+    let messages = query.load::<Self>(&mut conn)?;
+    Ok(messages)
+  }
+
+  pub fn get_count(fitlers: &QueryFilters) -> Result<i64, ServiceError> {
+    let mut conn = crate::db::connection()?;
+    let mut query = messages::table.into_boxed();
+    // Apply filters
+    if let Some(id) = &fitlers.by_id {
+      query = query.filter(messages::id.eq(id));
+    }
+    if let Some(guild_id) = &fitlers.by_guild_id {
+      query = query.filter(messages::guild_id.eq(guild_id));
+    }
+    if let Some(channel_id) = &fitlers.by_channel_id {
+      query = query.filter(messages::channel_id.eq(channel_id));
+    }
+    if let Some(user_id) = &fitlers.by_user_id {
+      query = query.filter(messages::user_id.eq(user_id));
+    }
+    if let Some(model) = &fitlers.by_model {
+      query = query.filter(messages::model.eq(model));
+    }
+    if let Some(request) = &fitlers.by_request {
+      query = query.filter(messages::request.eq(request));
+    }
+    if let Some(response) = &fitlers.by_response {
+      query = query.filter(messages::response.eq(response));
+    }
+    if let Some(request_tags) = &fitlers.by_request_tags {
+      query = query.filter(messages::request_tags.eq(request_tags));
+    }
+    if let Some(response_tags) = &fitlers.by_response_tags {
+      query = query.filter(messages::response_tags.eq(response_tags));
+    }
+    // Execute query
+    let count = query.count().get_result::<i64>(&mut conn)?;
+    Ok(count)
+  }
+}
+
+#[derive(Insertable, AsChangeset, Serialize, Deserialize)]
+#[diesel(table_name = messages)]
+pub struct InsertMessage {
+  pub id: String,
+  pub guild_id: i64,
+  pub channel_id: i64,
+  pub user_id: i64,
+  pub created: i64,
+  pub model: String,
+  pub request: String,
+  pub response: String,
+  pub request_tags: Vec<String>,
+  pub response_tags: Vec<String>,
+}
+
+impl InsertMessage {
+  pub fn insert(message: Self) -> Result<QueryMessage, ServiceError> {
+    let mut conn = crate::db::connection()?;
+    let message = diesel::insert_into(messages::table)
+      .values(message)
+      .get_result(&mut conn)?;
+    Ok(message)
+  }
+}

service/src/db/messages/routes.rs

@@ -0,0 +1,80 @@
+use actix_web::{get, post, web, HttpResponse, HttpRequest, ResponseError};
+use log::error;
+use serde::{Serialize, Deserialize};
+use siren::{GetResponse, Metadata, ServiceError};
+
+use crate::db::messages::{QueryMessage, QueryFilters, InsertMessage};
+
+#[derive(Serialize, Deserialize)]
+struct GetAllParams {
+  id: Option<String>,
+  guild_id: Option<i64>,
+  channel_id: Option<i64>,
+  user_id: Option<i64>,
+  model: Option<String>,
+  request: Option<String>,
+  response: Option<String>,
+  request_tags: Option<Vec<String>>,
+  response_tags: Option<Vec<String>>,
+  limit: Option<i32>,
+  page: Option<i32>,
+}
+
+#[get("/messages")]
+async fn get_all(req: HttpRequest) -> HttpResponse {
+  let params = match web::Query::<GetAllParams>::from_query(req.query_string()) {
+    Ok(params) => params,
+    Err(err) => return ResponseError::error_response(&ServiceError {
+      status: 422,
+      message: err.to_string()
+    })
+  };
+  let mut filters = QueryFilters::default();
+  filters.by_id = params.id.clone();
+  filters.by_guild_id = params.guild_id;
+  filters.by_channel_id = params.channel_id;
+  filters.by_user_id = params.user_id;
+  filters.by_model = params.model.clone();
+  filters.by_request = params.request.clone();
+  filters.by_response = params.response.clone();
+  filters.by_request_tags = params.request_tags.clone();
+  filters.by_response_tags = params.response_tags.clone();
+  let limit = params.limit.unwrap_or(100);
+  let total_count = QueryMessage::get_count(&filters).unwrap();
+  let max_page = std::cmp::max((total_count as f64 / limit as f64).ceil() as i32, 1);
+  let page = std::cmp::min(std::cmp::max(params.page.unwrap_or(1), 1), max_page);
+  
+  match QueryMessage::get_all(&filters, limit, page) {
+    Ok(messages) => {
+      HttpResponse::Ok().json(GetResponse {
+        data: messages,
+        metadata: Some(Metadata {
+          total: total_count as i32,
+          limit,
+          page,
+          pages: max_page
+        })
+      })
+    },
+    Err(err) => {
+      error!("{:?}", err.message);
+      ResponseError::error_response(&err)
+    }
+  }
+}
+
+#[post("/messages")]
+async fn create(message: web::Json<InsertMessage>) -> HttpResponse {
+  match InsertMessage::insert(message.into_inner()) {
+    Ok(message) => HttpResponse::Created().json(message),
+    Err(err) => {
+      error!("{:?}", err.message);
+      ResponseError::error_response(&err)
+    }
+  }
+}
+
+pub fn init_routes(config: &mut web::ServiceConfig) {
+  config.service(get_all);
+  config.service(create);
+}

service/src/db/mod.rs

@@ -0,0 +1,56 @@
+use diesel::{r2d2::ConnectionManager, PgConnection};
+use siren::ServiceError;
+use crate::diesel_migrations::MigrationHarness;
+use lazy_static::lazy_static;
+use log::{error, info};
+use r2d2;
+use std::env;
+
+pub mod backgrounds;
+pub mod bestiary;
+pub mod classes;
+pub mod conditions;
+pub mod feats;
+pub mod items;
+pub mod messages;
+pub mod options;
+pub mod races;
+pub mod spells;
+pub mod users;
+pub mod schema;
+
+type Pool = r2d2::Pool<ConnectionManager<PgConnection>>;
+pub type DbConnection = r2d2::PooledConnection<ConnectionManager<PgConnection>>;
+
+pub const MIGRATIONS: diesel_migrations::EmbeddedMigrations = embed_migrations!();
+
+lazy_static! {
+  static ref POOL: Pool = {
+    let username = env::var("DATABASE_USER").expect("DATABASE_USERNAME is not set");
+    let password = env::var("DATABASE_PASSWORD").expect("DATABASE_PASSWORD is not set");
+    let host = env::var("DATABASE_HOST").unwrap_or("localhost".to_string());
+    let name = env::var("DATABASE_NAME").expect("DATABASE_NAME is not set");
+    let port = env::var("DATABASE_PORT").unwrap_or("5432".to_string());
+    let url = format!("postgres://{}:{}@{}:{}/{}", username, password, host, port, name);
+    let manager = ConnectionManager::<PgConnection>::new(url);
+    Pool::builder().test_on_check_out(true).build(manager).expect("Failed to create db pool")
+  };
+}
+
+pub fn init() {
+  lazy_static::initialize(&POOL);
+  let mut pool: DbConnection = connection().expect("Failed to get db connection");
+  match pool.run_pending_migrations(MIGRATIONS) {
+    Ok(_) => info!("Database initialized"),
+    Err(err) => error!("Failed to initialize database; {}", err)
+  };
+}
+
+pub fn connection() -> Result<DbConnection, ServiceError> {
+  POOL.get()
+    .map_err(|e| ServiceError::new(500, format!("Failed getting db connection: {}", e)))
+}
+
+pub fn load_data() {
+  spells::load_data();
+}

service/src/db/schema.rs

@@ -0,0 +1,32 @@
+diesel::table! {
+  messages (id) {
+    id -> Text,
+    guild_id -> BigInt,
+    channel_id -> BigInt,
+    user_id -> BigInt,
+    created -> BigInt,
+    model -> Text,
+    request -> Text,
+    response -> Text,
+    request_tags -> Array<Text>,
+    response_tags -> Array<Text>,
+  }
+}
+
+diesel::table! {
+  spells (id) {
+    id -> Integer,
+    name -> Text,
+    school -> Text,
+    level -> Integer,
+    ritual -> Bool,
+    concentration -> Bool,
+    classes -> Array<Text>,
+    damage_inflict -> Array<Text>,
+    damage_resist -> Array<Text>,
+    conditions -> Array<Text>,
+    saving_throw -> Array<Text>,
+    attack_type -> Nullable<Text>,
+    data -> Jsonb
+  }
+}

service/src/db/spells/mod.rs

@@ -0,0 +1,47 @@
+mod model;
+mod routes;
+mod types;
+
+pub use model::*;
+pub use types::*;
+pub use routes::init_routes;
+
+pub fn load_data() {
+  let root_path = std::env::current_dir().unwrap();
+  let files = [
+    "cantrips.json", "level_1.json", "level_2.json", "level_3.json", "level_4.json", "level_5.json", "level_6.json", "level_7.json", "level_8.json", "level_9.json"
+  ];
+  let mut spells: Vec<Spell> = vec![];
+  for file in files {
+    let mut data_path = std::path::PathBuf::from(&root_path);
+    data_path.push(format!("data/spells/{}", file));
+    let path = data_path.to_str().unwrap();
+    match std::fs::read_to_string(path) {
+      Ok(data) => {
+        log::debug!("Loading spells from {}", path);
+        match serde_json::from_str::<serde_json::Value>(&data) {
+          Ok(json) => {
+            match serde_json::from_value::<Vec<Spell>>(json) {
+              Ok(mut new_spells) => spells.append(&mut new_spells),
+              Err(err) => log::error!("Failed to parse spells data: {}", err)
+            }
+          },
+          Err(err) => log::error!("Failed to parse spells data to value: {}", err)
+        };
+      },
+      Err(err) => log::error!("Failed to read from {}: {}", file, err)
+    };
+  }
+  let count = QuerySpell::get_count(&QueryFilters::default()).unwrap();
+  if count >= spells.len() as i64 {
+    log::warn!("Spell data is already loaded");
+    return;
+  }
+  for spell in spells {
+    let spell_name = spell.name.clone();
+    match InsertSpell::insert(spell.into()) {
+      Ok(_) => {},
+      Err(err) => log::error!("Failed to insert '{}' spell: {}", spell_name, err)
+    }
+  }
+}

service/src/db/spells/model.rs

@@ -0,0 +1,291 @@
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+use siren::ServiceError;
+
+use crate::db::{schema::spells::{self}, classes::AbilityType, conditions::ConditionType};
+
+use super::{SchoolType, CastingTime, CastingType, SpellAttackType, SpellDamageType, Range, Area, Components, Duration, Source, Description, DurationType};
+
+#[derive(Queryable, QueryableByName)]
+#[diesel(table_name = spells)]
+pub struct QuerySpell {
+  pub id: i32,
+  pub name: String,
+  pub school: String,
+  pub level: i32,
+  pub ritual: bool,
+  pub concentration: bool,
+  pub classes: Vec<String>,
+  pub damage_inflict: Vec<String>,
+  pub damage_resist: Vec<String>,
+  pub conditions: Vec<String>,
+  pub saving_throw: Vec<String>,
+  pub attack_type: Option<String>,
+  pub data: serde_json::Value,
+}
+
+#[derive(Debug)]
+pub struct QueryFilters {
+  pub by_name: Option<String>,
+  pub by_schools: Option<Vec<String>>,
+  pub by_levels: Option<Vec<i32>>,
+  pub by_ritual: Option<bool>,
+  pub by_concentration: Option<bool>,
+  pub by_classes: Option<Vec<String>>,
+  pub by_damage_inflict: Option<Vec<String>>,
+  pub by_damage_resist: Option<Vec<String>>,
+  pub by_conditions: Option<Vec<String>>,
+  pub by_saving_throw: Option<Vec<String>>,
+  pub by_attack_type: Option<String>,
+}
+
+impl Default for QueryFilters {
+  fn default() -> Self {
+    Self {
+      by_name: None,
+      by_schools: None,
+      by_levels: None,
+      by_ritual: None,
+      by_concentration: None,
+      by_classes: None,
+      by_damage_inflict: None,
+      by_damage_resist: None,
+      by_conditions: None,
+      by_saving_throw: None,
+      by_attack_type: None,
+    }
+  }
+}
+
+impl QuerySpell {
+  pub fn get_all(filters: &QueryFilters, limit: i32, page: i32) -> Result<Vec<Self>, ServiceError> {
+    let mut conn = crate::db::connection()?;
+    let mut query = spells::table.limit(limit as i64).into_boxed();
+    // Limit query to page and limit
+    let offset = (page - 1) * limit;
+    query = query.offset(offset as i64);
+    if let Some(name) = &filters.by_name {
+      query = query.filter(spells::name.ilike(format!("%{}%", name)));
+    }
+    if let Some(schools) = &filters.by_schools {
+      query = query.filter(spells::school.eq_any(schools.iter().map(|school| school.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(levels) = &filters.by_levels {
+      query = query.filter(spells::level.eq_any(levels));
+    }
+    if let Some(ritual) = filters.by_ritual {
+      query = query.filter(spells::ritual.eq(ritual));
+    }
+    if let Some(concentration) = filters.by_concentration {
+      query = query.filter(spells::concentration.eq(concentration));
+    }
+    if let Some(classes) = &filters.by_classes {
+      query = query.filter(spells::classes.overlaps_with(classes));
+    }
+    if let Some(damage_inflict) = &filters.by_damage_inflict {
+      query = query.filter(spells::damage_inflict.overlaps_with(damage_inflict.iter().map(|damage_inflict| damage_inflict.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(damage_resist) = &filters.by_damage_resist {
+      query = query.filter(spells::damage_resist.overlaps_with(damage_resist.iter().map(|damage_resist| damage_resist.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(conditions) = &filters.by_conditions {
+      query = query.filter(spells::conditions.overlaps_with(conditions.iter().map(|condition| condition.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(saving_throw) = &filters.by_saving_throw {
+      query = query.filter(spells::saving_throw.overlaps_with(saving_throw.iter().map(|saving_throw| saving_throw.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(attack_type) = &filters.by_attack_type {
+      query = query.filter(spells::attack_type.eq(attack_type.to_string()));
+    }
+
+    let spells = query.load::<QuerySpell>(&mut conn)?;
+    Ok(spells)
+  }
+
+  pub fn get_count(filters: &QueryFilters) -> Result<i64, ServiceError> {
+    let mut conn = crate::db::connection()?;
+    let mut query = spells::table.count().into_boxed();
+    if let Some(name) = &filters.by_name {
+      query = query.filter(spells::name.ilike(format!("%{}%", name)));
+    }
+    if let Some(schools) = &filters.by_schools {
+      query = query.filter(spells::school.eq_any(schools.iter().map(|school| school.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(levels) = &filters.by_levels {
+      query = query.filter(spells::level.eq_any(levels));
+    }
+    if let Some(ritual) = filters.by_ritual {
+      query = query.filter(spells::ritual.eq(ritual));
+    }
+    if let Some(concentration) = filters.by_concentration {
+      query = query.filter(spells::concentration.eq(concentration));
+    }
+    if let Some(classes) = &filters.by_classes {
+      query = query.filter(spells::classes.overlaps_with(classes));
+    }
+    if let Some(damage_inflict) = &filters.by_damage_inflict {
+      query = query.filter(spells::damage_inflict.overlaps_with(damage_inflict.iter().map(|damage_inflict| damage_inflict.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(damage_resist) = &filters.by_damage_resist {
+      query = query.filter(spells::damage_resist.overlaps_with(damage_resist.iter().map(|damage_resist| damage_resist.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(conditions) = &filters.by_conditions {
+      query = query.filter(spells::conditions.overlaps_with(conditions.iter().map(|condition| condition.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(saving_throw) = &filters.by_saving_throw {
+      query = query.filter(spells::saving_throw.overlaps_with(saving_throw.iter().map(|saving_throw| saving_throw.to_string()).collect::<Vec<String>>()));
+    }
+    if let Some(attack_type) = &filters.by_attack_type {
+      query = query.filter(spells::attack_type.eq(attack_type.to_string()));
+    }
+    
+    let count = query.get_result(&mut conn)?;
+    Ok(count)
+  }
+
+  pub fn get_by_id(id: i32) -> Result<Self, ServiceError> {
+    let mut conn = crate::db::connection()?;
+    let spell = spells::table
+      .filter(spells::id.eq(id))
+      .first::<QuerySpell>(&mut conn)?;
+    Ok(spell)
+  }
+
+  pub fn delete(id: i32) -> Result<Self, ServiceError> {
+    let mut conn = crate::db::connection()?;
+    let spell = diesel::delete(spells::table.filter(spells::id.eq(id))).get_result(&mut conn)?;
+    Ok(spell)
+  }
+}
+
+#[derive(Insertable, AsChangeset)]
+#[diesel(table_name = spells)]
+pub struct InsertSpell {
+  pub name: String,
+  pub school: String,
+  pub level: i32,
+  pub ritual: bool,
+  pub concentration: bool,
+  pub classes: Vec<String>,
+  pub damage_inflict: Vec<String>,
+  pub damage_resist: Vec<String>,
+  pub conditions: Vec<String>,
+  pub saving_throw: Vec<String>,
+  pub attack_type: Option<String>,
+  pub data: serde_json::Value
+}
+
+impl InsertSpell {
+  pub fn insert(spell: Self) -> Result<QuerySpell, ServiceError> {
+    let mut conn = crate::db::connection()?;
+    let spell = diesel::insert_into(spells::table).values(spell).get_result(&mut conn)?;
+    Ok(spell)
+  }
+
+  pub fn update(id: i32, spell: Self) -> Result<QuerySpell, ServiceError> {
+    let mut conn = crate::db::connection()?;
+    let spell = diesel::update(spells::table.filter(spells::id.eq(id))).set(spell).get_result(&mut conn)?;
+    Ok(spell)
+  }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Spell {
+  pub name: String,
+  pub school: SchoolType,
+  pub level: i32,
+  pub ritual: bool,
+  pub casting_time: CastingTime,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub saving_throw: Option<Vec<AbilityType>>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub attack_type: Option<SpellAttackType>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub damage_inflict: Option<Vec<SpellDamageType>>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub damage_resist: Option<Vec<SpellDamageType>>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub conditions: Option<Vec<ConditionType>>,
+  pub range: Range,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub area: Option<Area>,
+  pub components: Components,
+  pub durations: Vec<Duration>,
+  pub classes: Vec<String>,
+  pub sources: Vec<Source>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub tags: Option<Vec<String>>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub description: Option<Description>
+}
+
+impl From<QuerySpell> for Spell {
+  fn from(query: QuerySpell) -> Self {
+    return match serde_json::from_value(query.data) {
+      Ok(data) => data,
+      Err(err) => {
+        log::error!("Failed to parse spell: {}", err);
+        Self {
+            name: "".to_string(),
+            school: SchoolType::Abjuration,
+            level: 0,
+            ritual: false,
+            casting_time: CastingTime { amount: 0, casting_type: CastingType::Action },
+            saving_throw: None,
+            attack_type: None,
+            damage_inflict: None,
+            damage_resist: None,
+            conditions: None,
+            range: Range { range_type: "".to_string(), amount: None, unit: None },
+            area: None,
+            components: Components { verbal: false, somatic: false, material: false, materials_needed: None, materials_cost: None, materials_consumed: None },
+            durations: vec![],
+            classes: vec![],
+            sources: vec![],
+            tags: None,
+            description: None,
+        }
+      }
+    }
+  }
+}
+
+impl Into<InsertSpell> for Spell {
+  fn into(self) -> InsertSpell {
+    return InsertSpell {
+      name: self.name.to_string(),
+      school: self.school.to_string(),
+      level: self.level,
+      ritual: self.ritual,
+      concentration: self.durations.iter().any(|duration| match duration.duration_type {
+        DurationType::Concentration => true,
+        _ => false
+      }),
+      classes: self.classes.iter().map(|class| class.to_string()).collect::<Vec<String>>(),
+      damage_inflict: match &self.damage_inflict {
+        Some(damage_inflict) => damage_inflict.iter().map(|damage_inflict| damage_inflict.to_string()).collect(),
+        None => vec![]
+      },
+      damage_resist: match &self.damage_resist {
+        Some(damage_resist) => damage_resist.iter().map(|damage_resist| damage_resist.to_string()).collect(),
+        None => vec![]
+      },
+      conditions: match &self.conditions {
+        Some(conditions) => conditions.iter().map(|condition| condition.to_string()).collect(),
+        None => vec![]
+      },
+      saving_throw: match &self.saving_throw {
+        Some(saving_throw) => saving_throw.iter().map(|saving_throw| saving_throw.to_string()).collect(),
+        None => vec![]
+      },
+      attack_type: self.attack_type.as_ref().map(|attack_type| attack_type.to_string()),
+      data: match serde_json::to_value(&self) {
+        Ok(data) => data,
+        Err(err) => {
+          log::error!("Failed to serialize spell: {}", err);
+          serde_json::Value::Null
+        }
+      }
+    }
+  }
+}

service/src/db/spells/routes.rs

@@ -0,0 +1,178 @@
+use actix_web::{get, post, put, delete, web, HttpResponse, HttpRequest, ResponseError};
+use log::error;
+use serde::{Serialize, Deserialize};
+use siren::{GetResponse, Metadata, ServiceError};
+
+use crate::db::spells::{QuerySpell, QueryFilters};
+
+use super::{Spell, InsertSpell};
+
+#[derive(Serialize, Deserialize)]
+struct GetAllParams {
+  name: Option<String>,
+  schools: Option<String>,
+  levels: Option<String>,
+  ritual: Option<bool>,
+  concentration: Option<bool>,
+  classes: Option<String>,
+  damage_inflict: Option<String>,
+  damage_resist: Option<String>,
+  conditions: Option<String>,
+  saving_throw: Option<String>,
+  attack_type: Option<String>,
+  limit: Option<i32>,
+  page: Option<i32>,
+}
+
+#[get("/spells")]
+async fn get_all(req: HttpRequest) -> HttpResponse {
+  let params = match web::Query::<GetAllParams>::from_query(req.query_string()) {
+    Ok(params) => params,
+    Err(err) => return ResponseError::error_response(&ServiceError {
+      status: 422,
+      message: err.to_string()
+    })
+  };
+  let mut filters = QueryFilters::default();
+  filters.by_name = params.name.clone();
+  filters.by_schools = match &params.schools {
+    Some(schools) => Some(schools.split(",").map(|s| s.to_string()).collect()),
+    None => None
+  };
+  filters.by_levels = match &params.levels {
+    Some(levels) => Some(levels.split(",").map(|s| match s.to_string().parse::<i32>() {
+      Ok(level) => level,
+      Err(_) => 0
+    }).collect()),
+    None => None
+  };
+  filters.by_ritual = params.ritual;
+  filters.by_concentration = params.concentration;
+  filters.by_classes = match &params.classes {
+    Some(classes) => Some(classes.split(",").map(|s| s.to_string()).collect()),
+    None => None
+  };
+  filters.by_damage_inflict = match &params.damage_inflict {
+    Some(damage_inflict) => Some(damage_inflict.split(",").map(|s| s.to_string()).collect()),
+    None => None
+  };
+  filters.by_damage_resist = match &params.damage_resist {
+    Some(damage_resist) => Some(damage_resist.split(",").map(|s| s.to_string()).collect()),
+    None => None
+  };
+  filters.by_conditions = match &params.conditions {
+    Some(conditions) => Some(conditions.split(",").map(|s| s.to_string()).collect()),
+    None => None
+  };
+  filters.by_saving_throw = match &params.saving_throw {
+    Some(saving_throw) => Some(saving_throw.split(",").map(|s| s.to_string()).collect()),
+    None => None
+  };
+  filters.by_attack_type = match &params.attack_type {
+    Some(attack_type) => Some(attack_type.split(",").map(|s| s.to_string()).collect()),
+    None => None
+  };
+  // Limit must be between 1 and 100
+  let limit = std::cmp::min(std::cmp::max(params.limit.unwrap_or(20), 1), 100);
+  let total_count = QuerySpell::get_count(&filters).unwrap();
+  let max_page = std::cmp::max((total_count as f64 / limit as f64).ceil() as i32, 1);
+  // Page must be between 1 and max_page
+  let page = std::cmp::min(std::cmp::max(params.page.unwrap_or(1), 1), max_page);
+
+  match web::block(move || QuerySpell::get_all(&filters, limit, page)).await.unwrap() {
+    Ok(spells) => {
+      let mut response: Vec<Spell> = Vec::new();
+      for spell in spells {
+        response.push(Spell::from(spell));
+      }
+      HttpResponse::Ok().json(GetResponse {
+        data: response,
+        metadata: Some(Metadata {
+          total: total_count as i32,
+          limit,
+          page,
+          pages: max_page
+        })
+      })
+    },
+    Err(err) => {
+      error!("{:?}", err.message);
+      ResponseError::error_response(&err)
+    }
+  }
+}
+
+#[get("/spells/{id}")]
+async fn get_by_id(id: web::Path<String>) -> HttpResponse {
+  let id = match id.parse::<i32>() {
+    Ok(id) => id,
+    Err(err) => return ResponseError::error_response(&ServiceError {
+      status: 422,
+      message: err.to_string()
+    })
+  };
+  match web::block(move || QuerySpell::get_by_id(id)).await.unwrap() {
+    Ok(spell) => HttpResponse::Ok().json(GetResponse {
+      data: Spell::from(spell),
+      metadata: None
+    }),
+    Err(err) => {
+      error!("{:?}", err.message);
+      ResponseError::error_response(&err)
+    }
+  }
+}
+
+#[post("/spells")]
+async fn create(spell: web::Json<Spell>) -> HttpResponse {
+  match InsertSpell::insert(spell.into_inner().into()) {
+    Ok(spell) => HttpResponse::Created().json(Spell::from(spell)),
+    Err(err) => {
+      error!("{:?}", err.message);
+      ResponseError::error_response(&err)
+    }
+  }
+}
+
+#[put("/spells/{id}")]
+async fn update(id: web::Path<String>, spell: web::Json<Spell>) -> HttpResponse {
+  let id = match id.parse::<i32>() {
+    Ok(id) => id,
+    Err(err) => return ResponseError::error_response(&ServiceError {
+      status: 422,
+      message: err.to_string()
+    })
+  };
+  match web::block(move || InsertSpell::update(id, spell.into_inner().into())).await.unwrap() {
+    Ok(spell) => HttpResponse::Ok().json(Spell::from(spell)),
+    Err(err) => {
+      error!("{:?}", err.message);
+      ResponseError::error_response(&err)
+    }
+  }
+}
+
+#[delete("/spells/{id}")]
+async fn delete(id: web::Path<String>) -> HttpResponse {
+  let id = match id.parse::<i32>() {
+    Ok(id) => id,
+    Err(err) => return ResponseError::error_response(&ServiceError {
+      status: 422,
+      message: err.to_string()
+    })
+  };
+  match web::block(move || QuerySpell::delete(id)).await.unwrap() {
+    Ok(spell) => HttpResponse::Ok().json(Spell::from(spell)),
+    Err(err) => {
+      error!("{:?}", err.message);
+      ResponseError::error_response(&err)
+    }
+  }
+}
+
+pub fn init_routes(config: &mut web::ServiceConfig) {
+  config.service(get_all);
+  config.service(get_by_id);
+  config.service(create);
+  config.service(delete);
+}

service/src/db/spells/types.rs

@@ -0,0 +1,377 @@
+use std::str::FromStr;
+use serde::{Deserialize, Serialize, ser::SerializeMap};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum SchoolType {
+  #[serde(rename = "abjuration")]
+  Abjuration,
+  #[serde(rename = "conjuration")]
+  Conjuration,
+  #[serde(rename = "divination")]
+  Divination,
+  #[serde(rename = "enchantment")]
+  Enchantment,
+  #[serde(rename = "evocation")]
+  Evocation,
+  #[serde(rename = "illusion")]
+  Illusion,
+  #[serde(rename = "necromancy")]
+  Necromancy,
+  #[serde(rename = "transmutation")]
+  Transmutation
+}
+
+impl SchoolType {
+  pub fn to_string(&self) -> String {
+    match self {
+      SchoolType::Abjuration => "abjuration".to_string(),
+      SchoolType::Conjuration => "conjuration".to_string(),
+      SchoolType::Divination => "divination".to_string(),
+      SchoolType::Enchantment => "enchantment".to_string(),
+      SchoolType::Evocation => "evocation".to_string(),
+      SchoolType::Illusion => "illusion".to_string(),
+      SchoolType::Necromancy => "necromancy".to_string(),
+      SchoolType::Transmutation => "transmutation".to_string()
+    }
+  }
+}
+
+impl FromStr for SchoolType {
+  type Err = ();
+
+  fn from_str(s: &str) -> Result<Self, Self::Err> {
+    match s {
+      "abjuration" => Ok(SchoolType::Abjuration),
+      "conjuration" => Ok(SchoolType::Conjuration),
+      "divination" => Ok(SchoolType::Divination),
+      "enchantment" => Ok(SchoolType::Enchantment),
+      "evocation" => Ok(SchoolType::Evocation),
+      "illusion" => Ok(SchoolType::Illusion),
+      "necromancy" => Ok(SchoolType::Necromancy),
+      "transmutation" => Ok(SchoolType::Transmutation),
+      _ => Err(())
+    }
+  }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CastingTime {
+  pub amount: i32,
+  #[serde(rename = "unit")]
+  pub casting_type: CastingType
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CastingType {
+  #[serde(rename = "action")]
+  Action,
+  #[serde(rename = "bonus")]
+  BonusAction,
+  #[serde(rename = "reaction")]
+  Reaction,
+  #[serde(rename = "minutes")]
+  Minutes,
+  #[serde(rename = "hours")]
+  Hours
+}
+
+// impl CastingType {
+//   pub fn to_string(&self) -> String {
+//     match self {
+//       CastingType::Action => "action".to_string(),
+//       CastingType::BonusAction => "bonus".to_string(),
+//       CastingType::Reaction => "reaction".to_string(),
+//       CastingType::Minutes => "minutes".to_string(),
+//       CastingType::Hours => "hours".to_string()
+//     }
+//   }
+// }
+
+// impl FromStr for CastingType {
+//   type Err = ();
+
+//   fn from_str(s: &str) -> Result<Self, Self::Err> {
+//     match s {
+//       "action" => Ok(CastingType::Action),
+//       "bonus" => Ok(CastingType::BonusAction),
+//       "reaction" => Ok(CastingType::Reaction),
+//       "minutes" => Ok(CastingType::Minutes),
+//       "hours" => Ok(CastingType::Hours),
+//       _ => Err(())
+//     }
+//   }
+// }
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum SpellAttackType {
+  #[serde(rename = "melee")]
+  Melee,
+  #[serde(rename = "ranged")]
+  Ranged,
+}
+
+impl SpellAttackType {
+  pub fn to_string(&self) -> String {
+    match self {
+      SpellAttackType::Melee => "melee".to_string(),
+      SpellAttackType::Ranged => "ranged".to_string()
+    }
+  }
+}
+
+impl FromStr for SpellAttackType {
+  type Err = ();
+
+  fn from_str(s: &str) -> Result<Self, Self::Err> {
+    match s {
+      "melee" => Ok(SpellAttackType::Melee),
+      "ranged" => Ok(SpellAttackType::Ranged),
+      _ => Err(())
+    }
+  }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum SpellDamageType {
+  #[serde(rename = "acid")]
+  Acid,
+  #[serde(rename = "bludgeoning")]
+  Bludgeoning,
+  #[serde(rename = "cold")]
+  Cold,
+  #[serde(rename = "fire")]
+  Fire,
+  #[serde(rename = "force")]
+  Force,
+  #[serde(rename = "lightning")]
+  Lightning,
+  #[serde(rename = "necrotic")]
+  Necrotic,
+  #[serde(rename = "piercing")]
+  Piercing,
+  #[serde(rename = "poison")]
+  Poison,
+  #[serde(rename = "psychic")]
+  Psychic,
+  #[serde(rename = "radiant")]
+  Radiant,
+  #[serde(rename = "slashing")]
+  Slashing,
+  #[serde(rename = "thunder")]
+  Thunder
+}
+
+impl SpellDamageType {
+  pub fn to_string(&self) -> String {
+    match self {
+      SpellDamageType::Acid => "acid".to_string(),
+      SpellDamageType::Bludgeoning => "bludgeoning".to_string(),
+      SpellDamageType::Cold => "cold".to_string(),
+      SpellDamageType::Fire => "fire".to_string(),
+      SpellDamageType::Force => "force".to_string(),
+      SpellDamageType::Lightning => "lightning".to_string(),
+      SpellDamageType::Necrotic => "necrotic".to_string(),
+      SpellDamageType::Piercing => "piercing".to_string(),
+      SpellDamageType::Poison => "poison".to_string(),
+      SpellDamageType::Psychic => "psychic".to_string(),
+      SpellDamageType::Radiant => "radiant".to_string(),
+      SpellDamageType::Slashing => "slashing".to_string(),
+      SpellDamageType::Thunder => "thunder".to_string()
+    }
+  }
+}
+
+impl FromStr for SpellDamageType {
+  type Err = ();
+
+  fn from_str(s: &str) -> Result<Self, Self::Err> {
+    match s {
+      "acid" => Ok(SpellDamageType::Acid),
+      "bludgeoning" => Ok(SpellDamageType::Bludgeoning),
+      "cold" => Ok(SpellDamageType::Cold),
+      "fire" => Ok(SpellDamageType::Fire),
+      "force" => Ok(SpellDamageType::Force),
+      "lightning" => Ok(SpellDamageType::Lightning),
+      "necrotic" => Ok(SpellDamageType::Necrotic),
+      "piercing" => Ok(SpellDamageType::Piercing),
+      "poison" => Ok(SpellDamageType::Poison),
+      "psychic" => Ok(SpellDamageType::Psychic),
+      "radiant" => Ok(SpellDamageType::Radiant),
+      "slashing" => Ok(SpellDamageType::Slashing),
+      "thunder" => Ok(SpellDamageType::Thunder),
+      _ => Err(())
+    }
+  }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Range {
+  #[serde(rename = "type")]
+  pub range_type: String,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub amount: Option<i32>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub unit: Option<String>
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Area {
+  #[serde(rename = "type")]
+  pub area_type: AreaType,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub amount: Option<i32>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub unit: Option<String>
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum AreaType {
+  #[serde(rename = "cone")]
+  Cone,
+  #[serde(rename = "cube")]
+  Cube,
+  #[serde(rename = "cylinder")]
+  Cylinder,
+  #[serde(rename = "line")]
+  Line,
+  #[serde(rename = "sphere")]
+  Sphere
+}
+
+// impl AreaType {
+//   pub fn to_string(&self) -> String {
+//     match self {
+//       AreaType::Cone => "cone".to_string(),
+//       AreaType::Cube => "cube".to_string(),
+//       AreaType::Cylinder => "cylinder".to_string(),
+//       AreaType::Line => "line".to_string(),
+//       AreaType::Sphere => "sphere".to_string()
+//     }
+//   }
+// }
+
+// impl FromStr for AreaType {
+//   type Err = ();
+
+//   fn from_str(s: &str) -> Result<Self, Self::Err> {
+//     match s {
+//       "cone" => Ok(AreaType::Cone),
+//       "cube" => Ok(AreaType::Cube),
+//       "cylinder" => Ok(AreaType::Cylinder),
+//       "line" => Ok(AreaType::Line),
+//       "sphere" => Ok(AreaType::Sphere),
+//       _ => Err(())
+//     }
+//   }
+// }
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Duration {
+  #[serde(rename = "type")]
+  pub duration_type: DurationType,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub amount: Option<i32>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub unit: Option<String>
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum DurationType {
+  #[serde(rename = "concentration")]
+  Concentration,
+  #[serde(rename = "instantaneous")]
+  Instantaneous,
+  #[serde(rename = "timed")]
+  Timed,
+  #[serde(rename = "dispelled")]
+  UntilDispelled,
+  #[serde(rename = "special")]
+  Special
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Source {
+  pub source: String,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub page: Option<i32>
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Description {
+  pub entries: Vec<Entry>
+}
+
+#[derive(Debug)]
+pub struct Entry {
+  pub entry_type: String,
+  pub items: Vec<String>
+}
+
+impl<'de> Deserialize<'de> for Entry {
+  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
+    let value = serde_json::Value::deserialize(deserializer)?;
+    match value {
+      serde_json::Value::String(s) => Ok(Entry {
+        entry_type: "string".to_string(),
+        items: vec![s]
+      }),
+      serde_json::Value::Object(o) => {
+        let entry_type = match o.get("type") {
+          Some(t) => match t.as_str() {
+            Some(s) => s.to_string(),
+            None => return Err(serde::de::Error::custom("Invalid entry type"))
+          },
+          None => return Err(serde::de::Error::custom("Missing entry type"))
+        };
+        let items = match o.get("items") {
+          Some(i) => match i.as_array() {
+            Some(a) => {
+              let mut items = Vec::new();
+              for item in a {
+                match item.as_str() {
+                  Some(s) => items.push(s.to_string()),
+                  None => return Err(serde::de::Error::custom("Invalid entry item"))
+                }
+              }
+              items
+            },
+            None => return Err(serde::de::Error::custom("Invalid entry items"))
+          },
+          None => return Err(serde::de::Error::custom("Missing entry items"))
+        };
+        Ok(Entry {
+          entry_type,
+          items
+        })
+      },
+      _ => Err(serde::de::Error::custom("Invalid entry"))
+    }
+  }
+}
+
+impl Serialize for Entry {
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
+    match self.entry_type.as_str() {
+      "string" => serializer.serialize_str(&self.items[0]),
+      _ => {
+        let mut map = serializer.serialize_map(Some(2))?;
+        map.serialize_entry("type", &self.entry_type)?;
+        map.serialize_entry("items", &self.items)?;
+        map.end()
+      }
+    }
+  }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Components {
+  pub verbal: bool,
+  pub somatic: bool,
+  pub material: bool,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub materials_needed: Option<String>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub materials_cost: Option<i32>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub materials_consumed: Option<bool>
+}

service/src/db/users/mod.rs

@@ -0,0 +1,3 @@
+mod model;
+
+pub use model::*;

service/src/db/users/model.rs

@@ -0,0 +1,3 @@
+pub struct User {
+  pub id: i32
+}

service/src/lib.rs

@@ -0,0 +1,98 @@
+use actix_web::{ResponseError, HttpResponse};
+use diesel::result::Error as DieselError;
+use reqwest::StatusCode;
+use serde::{Serialize, Deserialize};
+use std::fmt;
+
+#[derive(Serialize, Deserialize)]
+pub struct Message {
+  pub id: String,
+  pub guild_id: i64,
+  pub channel_id: i64,
+  pub user_id: i64,
+  pub created: i64,
+  pub model: String,
+  pub request: String,
+  pub response: String,
+  pub request_tags: Vec<String>,
+  pub response_tags: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct GetResponse<T> {
+  pub data: T,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub metadata: Option<Metadata>
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Metadata {
+  pub total: i32,
+  pub limit: i32,
+  pub page: i32,
+  pub pages: i32
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ServiceError {
+    pub status: u16,
+    pub message: String,
+}
+
+impl ServiceError {
+  pub fn new(error_status_code: u16, error_message: String) -> ServiceError {
+    ServiceError {
+      status: error_status_code,
+      message: error_message,
+    }
+  }
+}
+
+impl fmt::Display for ServiceError {
+  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    f.write_str(self.message.as_str())
+  }
+}
+
+impl From<DieselError> for ServiceError {
+  fn from(error: DieselError) -> ServiceError {
+    match error {
+      DieselError::DatabaseError(_, err) => ServiceError::new(409, err.message().to_string()),
+      DieselError::NotFound => {
+        ServiceError::new(404, "The record was not found".to_string())
+      },
+      DieselError::SerializationError(err) => {
+        ServiceError::new(422, err.to_string())
+      },
+      err => ServiceError::new(500, format!("Unknown database error: {}", err)),
+    }
+  }
+}
+
+impl From<reqwest::Error> for ServiceError {
+  fn from(error: reqwest::Error) -> ServiceError {
+    ServiceError::new(500, format!("Unknown reqwest error: {}", error))
+  }
+}
+
+impl From<serde_json::Error> for ServiceError {
+  fn from(error: serde_json::Error) -> ServiceError {
+    ServiceError::new(500, format!("Unknown serde_json error: {}", error))
+  }
+}
+
+impl ResponseError for ServiceError {
+  fn error_response(&self) -> HttpResponse {
+      let status_code = match StatusCode::from_u16(self.status) {
+          Ok(status_code) => status_code,
+          Err(_) => StatusCode::INTERNAL_SERVER_ERROR,
+      };
+
+      let error_message = match status_code.as_u16() < 500 {
+          true => self.message.clone(),
+          false => "Internal server error".to_string(),
+      };
+
+      HttpResponse::build(status_code).json(serde_json::json!({ "status": status_code.as_u16(), "message": error_message }))
+  }
+}

service/src/main.rs

@@ -0,0 +1,41 @@
+extern crate diesel;
+#[macro_use]
+extern crate diesel_migrations;
+
+use std::env;
+
+use actix_web::{HttpServer, App};
+
+use dotenv::dotenv;
+use log::{error, info};
+
+mod db;
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+  dotenv().ok();
+  env_logger::init_from_env(env_logger::Env::default().filter_or("RUST_LOG", "warn,siren=info"));
+  db::init();
+  db::load_data();
+
+  let host = env::var("SERVICE_HOST").unwrap_or("localhost".to_string());
+  let port = env::var("SERVICE_PORT").unwrap_or("5000".to_string());
+
+  match HttpServer::new(|| {
+    App::new()
+      .configure(db::messages::init_routes)
+      .configure(db::spells::init_routes)
+  })
+  .bind(format!("{}:{}", host, port)) {
+    Ok(b) => {
+      info!("Binding server to {}:{}", host, port);
+      b
+    },
+    Err(err) => {
+      error!("Could not bind server: {}", err);
+      return Err(err);
+    }
+  }
+  .run()
+  .await
+}

src/database/mod.rs

@@ -1,61 +0,0 @@
-use std::env;
-// use std::path::Path;
-
-use diesel::RunQueryDsl;
-use diesel::r2d2::{Pool, ConnectionManager};
-use diesel::pg::PgConnection;
-use log::{error, info};
-
-pub mod models;
-pub mod schema;
-
-pub fn run_migrations(pool: &Pool<ConnectionManager<PgConnection>>) {
-  let mut connection = pool.get().unwrap();
-  if let Err(err) = diesel::sql_query("CREATE TABLE IF NOT EXISTS messages (
-    id TEXT PRIMARY KEY NOT NULL,
-    guild_id BIGINT NOT NULL,
-    channel_id BIGINT NOT NULL,
-    user_id BIGINT NOT NULL,
-    created BIGINT NOT NULL,
-    model TEXT NOT NULL,
-    request TEXT NOT NULL,
-    response TEXT NOT NULL,
-    request_tags TEXT[] NOT NULL,
-    response_tags TEXT[] NOT NULL
-  )").execute(&mut connection) {
-    error!("Could not create messages table: {}", err);
-  } else {
-    info!("Successfully created messages table");
-  }
-  // let migrations_dir = Path::new("./migrations");
-  // let migrations = std::fs::read_dir(&migrations_dir).unwrap();
-  
-  // for migration in migrations {
-  //   if migration.as_ref().unwrap().file_type().unwrap().is_dir() {
-  //     let migration_paths = std::fs::read_dir(&migration.unwrap().path()).unwrap();
-
-  //     for migration_path in migration_paths {
-  //       if migration_path.as_ref().unwrap().file_name().eq_ignore_ascii_case("up.sql") {
-  //         let path = &migration_path.unwrap().path();
-  //         let contents = std::fs::read_to_string(path).expect("Unable to read from file");
-  //         if let Err(err) = diesel::sql_query(&contents).execute(&mut connection) {
-  //           error!("Could not run migration: {}", err);
-  //         } else {
-  //           info!("Successfully ran migration: {}", path.display());
-  //         }
-  //       }
-  //     }
-  //   }
-  // }
-}
-
-pub fn establish_connection() -> Pool<ConnectionManager<PgConnection>> {
-  let database_user = env::var("POSTGRES_USER").expect("Expected a user in the environment");
-  let database_password = env::var("POSTGRES_PASSWORD").expect("Expected a password in the environment");
-  let database_name = env::var("POSTGRES_DB").expect("Expected a database name in the environment");
-  let database_host = env::var("POSTGRES_HOST").unwrap_or("localhost".to_string());
-
-  let database_url = format!("postgres://{}:{}@{}/{}", database_user, database_password, database_host, database_name);
-  let manager = ConnectionManager::<PgConnection>::new(database_url);
-  Pool::builder().build(manager).expect("Failed to create pool.")
-}

src/database/models.rs

@@ -1,33 +0,0 @@
-use diesel::prelude::*;
-
-use super::schema::messages;
-
-#[derive(Queryable, Selectable)]
-#[diesel(table_name = messages)]
-pub struct MessageDB {
-  pub id: String,
-  pub guild_id: i64,
-  pub channel_id: i64,
-  pub user_id: i64,
-  pub created: i64,
-  pub model: String,
-  pub request: String,
-  pub response: String,
-  pub request_tags: Vec<String>,
-  pub response_tags: Vec<String>,
-}
-
-#[derive(Insertable)]
-#[diesel(table_name = messages)]
-pub struct NewMessageDB<'a> {
-  pub id: &'a str,
-  pub guild_id: i64,
-  pub channel_id: i64,
-  pub user_id: i64,
-  pub created: i64,
-  pub model: &'a str,
-  pub request: &'a str,
-  pub response: &'a str,
-  pub request_tags: Vec<&'a str>,
-  pub response_tags: Vec<&'a str>,
-}

src/database/schema.rs

@@ -1,14 +0,0 @@
-diesel::table! {
-  messages (id) {
-    id -> Text,
-    guild_id -> BigInt,
-    channel_id -> BigInt,
-    user_id -> BigInt,
-    created -> BigInt,
-    model -> Text,
-    request -> Text,
-    response -> Text,
-    request_tags -> Array<Text>,
-    response_tags -> Array<Text>,
-  }
-}