Made Database the mtt engine.
This commit is contained in:
179
src/morethantext/graphql.rs
Normal file
179
src/morethantext/graphql.rs
Normal file
@ -0,0 +1,179 @@
|
||||
use async_graphql::{Context, EmptySubscription, Error, Object, Result, Schema};
|
||||
use async_std::sync::RwLock;
|
||||
use serde_json;
|
||||
|
||||
mod database;
|
||||
|
||||
#[derive(Clone)]
|
||||
struct Table {
|
||||
name: String,
|
||||
}
|
||||
|
||||
impl Table {
|
||||
async fn new(name: String) -> Self {
|
||||
Self { name: name }
|
||||
}
|
||||
}
|
||||
|
||||
#[Object]
|
||||
impl Table {
|
||||
async fn name(&self) -> String {
|
||||
self.name.to_string()
|
||||
}
|
||||
|
||||
async fn describe(&self) -> Vec<u64> {
|
||||
Vec::new()
|
||||
}
|
||||
}
|
||||
|
||||
struct Query;
|
||||
|
||||
#[Object]
|
||||
impl Query {
|
||||
async fn table(&self, ctx: &Context<'_>, name: String) -> Result<Option<Table>> {
|
||||
let tbls = ctx
|
||||
.data::<RwLock<Vec<Table>>>()
|
||||
.unwrap()
|
||||
.read()
|
||||
.await
|
||||
.to_vec();
|
||||
match tbls.binary_search_by(|t| t.name.cmp(&name)) {
|
||||
Ok(idx) => Ok(Some(tbls[idx].clone())),
|
||||
Err(_) => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
async fn tables(&self, ctx: &Context<'_>) -> Vec<Table> {
|
||||
ctx.data::<RwLock<Vec<Table>>>()
|
||||
.unwrap()
|
||||
.read()
|
||||
.await
|
||||
.to_vec()
|
||||
}
|
||||
}
|
||||
|
||||
struct Mutation;
|
||||
|
||||
#[Object]
|
||||
impl Mutation {
|
||||
async fn create_table(&self, ctx: &Context<'_>, name: String) -> Result<Option<Table>> {
|
||||
let mut tables = ctx.data::<RwLock<Vec<Table>>>().unwrap().write().await;
|
||||
match tables.binary_search_by(|t| t.name.cmp(&name)) {
|
||||
Ok(_) => Err(Error::new(format!("Table {} already exists.", &name))),
|
||||
Err(_) => {
|
||||
let output = Table::new(name).await;
|
||||
tables.push(output.clone());
|
||||
tables.sort_by_key(|k| k.name.clone());
|
||||
Ok(Some(output))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct MoreThanText {
|
||||
schema: Schema<Query, Mutation, EmptySubscription>,
|
||||
}
|
||||
|
||||
impl MoreThanText {
|
||||
pub fn new() -> Self {
|
||||
let tables: Vec<Table> = Vec::new();
|
||||
Self {
|
||||
schema: Schema::build(Query, Mutation, EmptySubscription)
|
||||
.data(RwLock::new(tables))
|
||||
.finish(),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn execute(&self, qry: &str) -> String {
|
||||
let res = self.schema.execute(qry).await;
|
||||
serde_json::to_string(&res).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod support {
|
||||
use super::*;
|
||||
|
||||
pub fn compare(db: &MoreThanText, output: &str, expected: &str) {
|
||||
assert!(
|
||||
output == expected,
|
||||
"\n\n{}\nGot: {}\nWant: {}\n\n",
|
||||
db.schema.sdl(),
|
||||
output,
|
||||
expected
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod queries {
|
||||
use super::*;
|
||||
|
||||
#[async_std::test]
|
||||
async fn list_table() {
|
||||
let db = MoreThanText::new();
|
||||
db.execute(r#"mutation {createTable(name: "wilma"){name}}"#)
|
||||
.await;
|
||||
db.execute(r#"mutation {createTable(name: "betty"){name}}"#)
|
||||
.await;
|
||||
let output = db.execute(r#"{table(name: "wilma"){name}}"#).await;
|
||||
let expected = r#"{"data":{"table":{"name":"wilma"}}}"#;
|
||||
support::compare(&db, &output, &expected);
|
||||
}
|
||||
|
||||
#[async_std::test]
|
||||
async fn list_no_table() {
|
||||
let db = MoreThanText::new();
|
||||
let output = db.execute(r#"{table(name: "slade"){name}}"#).await;
|
||||
let expected = r#"{"data":{"table":null}}"#;
|
||||
support::compare(&db, &output, &expected);
|
||||
}
|
||||
|
||||
#[async_std::test]
|
||||
async fn list_tables() {
|
||||
let db = MoreThanText::new();
|
||||
db.execute(r#"mutation {createTable(name: "fred"){name}}"#)
|
||||
.await;
|
||||
db.execute(r#"mutation {createTable(name: "barney"){name}}"#)
|
||||
.await;
|
||||
let output = db.execute(r#"{tables{name}}"#).await;
|
||||
let expected = r#"{"data":{"tables":[{"name":"barney"},{"name":"fred"}]}}"#;
|
||||
support::compare(&db, &output, &expected);
|
||||
}
|
||||
|
||||
#[async_std::test]
|
||||
async fn empty_table_description() {
|
||||
let db = MoreThanText::new();
|
||||
let output = db
|
||||
.execute(r#"mutation {createTable(name: "pebbles"){name describe}}"#)
|
||||
.await;
|
||||
let expected = r#"{"data":{"createTable":{"name":"pebbles","describe":[]}}}"#;
|
||||
support::compare(&db, &output, &expected);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod mutations {
|
||||
use super::*;
|
||||
|
||||
#[async_std::test]
|
||||
async fn add_table() {
|
||||
let db = MoreThanText::new();
|
||||
let output = db
|
||||
.execute(r#"mutation {createTable(name: "william"){name}}"#)
|
||||
.await;
|
||||
let expected = r#"{"data":{"createTable":{"name":"william"}}}"#;
|
||||
support::compare(&db, &output, &expected);
|
||||
}
|
||||
|
||||
#[async_std::test]
|
||||
async fn cannot_add_duplicate_table() {
|
||||
let db = MoreThanText::new();
|
||||
let qry = r#"mutation {createTable(name: "gadzoo"){name}}"#;
|
||||
db.execute(&qry).await;
|
||||
let output = db.execute(qry).await;
|
||||
let expected = r#"{"data":null,"errors":[{"message":"Table gadzoo already exists.","locations":[{"line":1,"column":11}],"path":["createTable"]}]}"#;
|
||||
support::compare(&db, &output, &expected);
|
||||
}
|
||||
}
|
||||
239
src/morethantext/mod.rs
Normal file
239
src/morethantext/mod.rs
Normal file
@ -0,0 +1,239 @@
|
||||
use async_std::sync::{Arc, RwLock};
|
||||
use std::{collections::HashMap, error::Error, fmt, str::FromStr};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct DBError {
|
||||
detail: String,
|
||||
source: Option<Box<DBError>>,
|
||||
}
|
||||
|
||||
impl DBError {
|
||||
fn new(detail: String) -> Self {
|
||||
Self {
|
||||
detail: detail.to_string(),
|
||||
source: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for DBError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "{}", &self.detail)
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for DBError {
|
||||
fn source(&self) -> Option<&(dyn Error + 'static)> {
|
||||
match &self.source {
|
||||
Some(err) => Some(err),
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq)]
|
||||
pub enum FieldType {
|
||||
Table,
|
||||
}
|
||||
|
||||
impl fmt::Display for FieldType {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match self {
|
||||
FieldType::Table => write!(f, "table"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for FieldType {
|
||||
type Err = DBError;
|
||||
|
||||
fn from_str(input: &str) -> Result<FieldType, Self::Err> {
|
||||
match input {
|
||||
"table" => Ok(FieldType::Table),
|
||||
_ => Err(DBError::new(format!("field type {} does not exist", input))),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Table {
|
||||
fields: Arc<RwLock<HashMap<String, FieldType>>>,
|
||||
}
|
||||
|
||||
impl Table {
|
||||
pub async fn new() -> Self {
|
||||
Self {
|
||||
fields: Arc::new(RwLock::new(HashMap::new())),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn add_field(&self, name: &str, ftype: &str) -> Result<(), Box<dyn Error>> {
|
||||
let ftype = match FieldType::from_str(ftype) {
|
||||
Ok(field) => field,
|
||||
Err(err) => {
|
||||
let mut error = DBError::new(format!("failed to add field {}", name));
|
||||
error.source = Some(Box::new(err));
|
||||
return Err(Box::new(error));
|
||||
}
|
||||
};
|
||||
let mut fmap = self.fields.write().await;
|
||||
match fmap.get(name) {
|
||||
Some(_) => Err(Box::new(DBError::new(format!(
|
||||
"field {} already exists",
|
||||
name
|
||||
)))),
|
||||
None => {
|
||||
fmap.insert(name.to_string(), ftype);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn fields(&self) -> HashMap<String, FieldType> {
|
||||
let fmap = self.fields.read().await;
|
||||
fmap.clone()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct MoreThanText;
|
||||
|
||||
impl MoreThanText {
|
||||
pub async fn new() -> Self {
|
||||
Self {}
|
||||
}
|
||||
|
||||
pub async fn add_table(&self, _name: String) -> Table {
|
||||
Table::new().await
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tables {
|
||||
use super::*;
|
||||
|
||||
#[async_std::test]
|
||||
async fn new_table() {
|
||||
Table::new().await;
|
||||
}
|
||||
|
||||
#[async_std::test]
|
||||
async fn add_field() {
|
||||
let table = Table::new().await;
|
||||
let mut expected: HashMap<String, FieldType> = HashMap::new();
|
||||
expected.insert("stan".to_string(), FieldType::Table);
|
||||
expected.insert("lee".to_string(), FieldType::Table);
|
||||
table.add_field("stan", "table").await.unwrap();
|
||||
table.add_field("lee", "table").await.unwrap();
|
||||
let output = table.fields().await;
|
||||
assert!(output == expected, "Table did not get the fields added.");
|
||||
}
|
||||
|
||||
#[async_std::test]
|
||||
async fn add_bad_field() -> Result<(), String> {
|
||||
let table = Table::new().await;
|
||||
let name = "failure";
|
||||
let bad_type = "ljksdbtt";
|
||||
let expected = format!("failed to add field {}", name);
|
||||
let source = format!("field type {} does not exist", bad_type);
|
||||
match table.add_field(name, bad_type).await {
|
||||
Ok(_) => Err("A bad field type should not return successfully".to_string()),
|
||||
Err(err) => {
|
||||
if format!("{}", err) != expected {
|
||||
Err(format!("Got: '{}' - Want: '{}'", err, expected))
|
||||
} else if format!("{}", err.source().unwrap()) != source {
|
||||
Err(format!(
|
||||
"Got: '{}' - Want: '{}'",
|
||||
err.source().unwrap(),
|
||||
source
|
||||
))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[async_std::test]
|
||||
async fn add_duplicate_field() -> Result<(), String> {
|
||||
let table = Table::new().await;
|
||||
let name = "twice";
|
||||
let expected = format!("field {} already exists", name);
|
||||
table.add_field(name, "table").await.unwrap();
|
||||
match table.add_field(name, "table").await {
|
||||
Ok(_) => Err(format!("Cannot have two fields with named '{}'", name)),
|
||||
Err(err) => {
|
||||
if format!("{}", err) == expected {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(format!("Got: '{}' - Want: '{}'", err, expected))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod databases {
|
||||
use super::*;
|
||||
|
||||
#[async_std::test]
|
||||
async fn new_database() {
|
||||
MoreThanText::new().await;
|
||||
}
|
||||
|
||||
#[async_std::test]
|
||||
async fn add_table() {
|
||||
let db = MoreThanText::new().await;
|
||||
db.add_table("fred".to_string()).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod fieldtypes {
|
||||
use super::*;
|
||||
|
||||
fn get_field_map() -> HashMap<String, FieldType> {
|
||||
let mut fields: HashMap<String, FieldType> = HashMap::new();
|
||||
fields.insert("table".to_string(), FieldType::Table);
|
||||
return fields;
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn convert_to_string() {
|
||||
for (key, value) in get_field_map().iter() {
|
||||
assert!(
|
||||
key == &value.to_string(),
|
||||
"\n\nGot: {}\nWant: {}\n\n",
|
||||
value.to_string(),
|
||||
key
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn convert_from_string() {
|
||||
for (key, value) in get_field_map().iter() {
|
||||
assert!(
|
||||
&FieldType::from_str(key).unwrap() == value,
|
||||
"\n\nDid not return a FieldType::{}",
|
||||
key
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn convert_from_string_error() -> Result<(), String> {
|
||||
let ftype = "lkjsdfh";
|
||||
let expected = format!("field type {} does not exist", ftype);
|
||||
match FieldType::from_str(ftype) {
|
||||
Ok(_) => Err(format!("Found field type {}", ftype)),
|
||||
Err(err) => {
|
||||
if format!("{}", err) == expected {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(format!("Got: '{}' - Want: '{}'", err, expected))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user