noth/surrealpatch
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add graphql config (#4704)

Browse source
This commit is contained in:
Raphael Darley 2024-09-17 10:29:16 +01:00 committed by GitHub
parent ebb6598c9e
commit c1443fe107
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
28 changed files with 918 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
core/src/err/mod.rs
View file

@ -371,6 +371,12 @@ pub enum Error {
value: String,
},
/// The requested config does not exist
#[error("The config for {value} does not exist")]
CgNotFound {
value: String,
},
/// The requested table does not exist
#[error("The table '{value}' does not exist")]
TbNotFound {
@ -895,6 +901,12 @@ pub enum Error {
value: String,
},
/// The requested config already exists
#[error("The config for {value} already exists")]
CgAlreadyExists {
value: String,
},
/// The requested table already exists
#[error("The table '{value}' already exists")]
TbAlreadyExists {

4
core/src/gql/cache.rs
View file

@ -82,8 +82,8 @@ impl<I: Invalidator> SchemaCache<I> {
}
}
pub async fn get_schema(&self, session: &Session) -> Result<Schema, GqlError> {
let ns = session.ns.as_ref().expect("missing ns should have been caught");
let db = session.db.as_ref().expect("missing db should have been caught");
let ns = session.ns.as_ref().ok_or(GqlError::UnpecifiedNamespace)?;
let db = session.db.as_ref().ok_or(GqlError::UnpecifiedDatabase)?;
{
let guard = self.inner.read().await;
if let Some(cand) = guard.get(&(ns.to_owned(), db.to_owned())) {

4
core/src/gql/error.rs
View file

@ -5,7 +5,7 @@ use thiserror::Error;
use crate::sql::Kind;
#[derive(Debug, Error)]
#[derive(Error, Debug)]
pub enum GqlError {
#[error("Database error: {0}")]
DbError(crate::err::Error),
@ -17,6 +17,8 @@ pub enum GqlError {
UnpecifiedNamespace,
#[error("No Database specified")]
UnpecifiedDatabase,
#[error("GraphQL has not been configured for this database")]
NotConfigured,
#[error("Internal Error: {0}")]
InternalError(String),
#[error("Error converting value: {val} to type: {target}")]

34
core/src/gql/ext.rs
View file

@ -1,3 +1,7 @@
use std::ops::Deref;
use crate::sql::statements::define::config::graphql::TableConfig;
use crate::sql::statements::DefineTableStatement;
use crate::sql::{
statements::UseStatement, Cond, Ident, Idiom, Limit, Order, Orders, Part, Start, Table, Value,
};
@ -157,3 +161,33 @@ impl TryAsExt for SqlValue {
}
}
}
pub trait Named {
fn name(&self) -> &str;
}
impl Named for DefineTableStatement {
fn name(&self) -> &str {
&self.name
}
}
impl Named for TableConfig {
fn name(&self) -> &str {
&self.name
}
}
pub trait NamedContainer {
fn contains_name(&self, name: &str) -> bool;
}
impl<I, N> NamedContainer for I
where
I: Deref<Target = [N]>,
N: Named,
{
fn contains_name(&self, name: &str) -> bool {
self.iter().any(|n| n.name() == name)
}
}

24
core/src/gql/schema.rs
View file

@ -5,6 +5,7 @@ use std::sync::Arc;
use crate::dbs::Session;
use crate::kvs::Datastore;
use crate::sql::kind::Literal;
use crate::sql::statements::define::config::graphql::TablesConfig;
use crate::sql::statements::{DefineFieldStatement, SelectStatement};
use crate::sql::{self, Table};
use crate::sql::{Cond, Fields};
@ -29,7 +30,7 @@ use super::ext::IntoExt;
#[cfg(debug_assertions)]
use super::ext::ValidatorExt;
use crate::gql::error::{internal_error, schema_error, type_error};
use crate::gql::ext::TryAsExt;
use crate::gql::ext::{NamedContainer, TryAsExt};
use crate::gql::utils::{GQLTx, GqlValueUtils};
use crate::kvs::LockType;
use crate::kvs::TransactionType;
@ -85,7 +86,28 @@ pub async fn generate_schema(
let tx = kvs.transaction(TransactionType::Read, LockType::Optimistic).await?;
let ns = session.ns.as_ref().ok_or(GqlError::UnpecifiedNamespace)?;
let db = session.db.as_ref().ok_or(GqlError::UnpecifiedDatabase)?;
let cg = tx.get_db_config(ns, db, "graphql").await.map_err(|e| match e {
crate::err::Error::CgNotFound {
..
} => GqlError::NotConfigured,
e => e.into(),
})?;
let config = cg.inner.clone().try_into_graphql()?;
let tbs = tx.all_tb(ns, db, None).await?;
let tbs = match config.tables {
TablesConfig::None => return Err(GqlError::NotConfigured),
TablesConfig::Auto => tbs,
TablesConfig::Include(inc) => {
tbs.iter().filter(|t| inc.contains_name(&t.name)).cloned().collect()
}
TablesConfig::Exclude(exc) => {
tbs.iter().filter(|t| !exc.contains_name(&t.name)).cloned().collect()
}
};
let mut query = Object::new("Query");
let mut types: Vec<Type> = Vec::new();

21
core/src/iam/entities/resources/resource.rs
View file

@ -9,7 +9,7 @@ use super::Level;
use cedar_policy::{Entity, EntityId, EntityTypeName, EntityUid, RestrictedExpression};
use serde::{Deserialize, Serialize};
#[revisioned(revision = 1)]
#[revisioned(revision = 2)]
#[derive(Clone, Default, Debug, Eq, PartialEq, PartialOrd, Hash, Serialize, Deserialize)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[non_exhaustive]
@ -30,11 +30,21 @@ pub enum ResourceKind {
Field,
Index,
Access,
#[revision(start = 2)]
Config(ConfigKind),
// IAM
Actor,
}
#[revisioned(revision = 1)]
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Hash, Serialize, Deserialize)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[non_exhaustive]
pub enum ConfigKind {
GraphQL,
}
impl std::fmt::Display for ResourceKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
@ -54,6 +64,15 @@ impl std::fmt::Display for ResourceKind {
ResourceKind::Index => write!(f, "Index"),
ResourceKind::Access => write!(f, "Access"),
ResourceKind::Actor => write!(f, "Actor"),
ResourceKind::Config(c) => write!(f, "Config::{c}"),
}
}
}
impl std::fmt::Display for ConfigKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ConfigKind::GraphQL => write!(f, "GraphQL"),
}
}
}

3
core/src/key/category.rs
View file

@ -84,6 +84,8 @@ pub enum Category {
DatabaseUser,
/// crate::key::database::vs /*{ns}*{db}!vs
DatabaseVersionstamp,
/// crate::key::database::cg /*{ns}*{db}!cg{ty}
DatabaseConfig,
///
/// ------------------------------
///
@ -191,6 +193,7 @@ impl Display for Category {
Self::DatabaseTimestamp => "DatabaseTimestamp",
Self::DatabaseUser => "DatabaseUser",
Self::DatabaseVersionstamp => "DatabaseVersionstamp",
Self::DatabaseConfig => "DatabaseConfig",
Self::TableRoot => "TableRoot",
Self::TableEvent => "TableEvent",
Self::TableField => "TableField",

87
core/src/key/database/cg.rs Normal file
View file

@ -0,0 +1,87 @@
//! Stores a DEFINE CONFIG definition
use crate::key::category::Categorise;
use crate::key::category::Category;
use derive::Key;
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Key)]
#[non_exhaustive]
pub struct Cg<'a> {
__: u8,
_a: u8,
pub ns: &'a str,
_b: u8,
pub db: &'a str,
_c: u8,
_d: u8,
_e: u8,
pub ty: &'a str,
}
pub fn new<'a>(ns: &'a str, db: &'a str, ty: &'a str) -> Cg<'a> {
Cg::new(ns, db, ty)
}
pub fn prefix(ns: &str, db: &str) -> Vec<u8> {
let mut k = super::all::new(ns, db).encode().unwrap();
k.extend_from_slice(&[b'!', b'c', b'g', 0x00]);
k
}
pub fn suffix(ns: &str, db: &str) -> Vec<u8> {
let mut k = super::all::new(ns, db).encode().unwrap();
k.extend_from_slice(&[b'!', b'c', b'g', 0xff]);
k
}
impl Categorise for Cg<'_> {
fn categorise(&self) -> Category {
Category::DatabaseConfig
}
}
impl<'a> Cg<'a> {
pub fn new(ns: &'a str, db: &'a str, ty: &'a str) -> Self {
Self {
__: b'/',
_a: b'*',
ns,
_b: b'*',
db,
_c: b'!',
_d: b'c',
_e: b'g',
ty,
}
}
}
#[cfg(test)]
mod tests {
#[test]
fn key() {
use super::*;
#[rustfmt::skip]
let val = Cg::new(
"testns",
"testdb",
"testty",
);
let enc = Cg::encode(&val).unwrap();
assert_eq!(enc, b"/*testns\x00*testdb\x00!cgtestty\x00");
let dec = Cg::decode(&enc).unwrap();
assert_eq!(val, dec);
}
#[test]
fn test_prefix() {
let val = super::prefix("testns", "testdb");
assert_eq!(val, b"/*testns\0*testdb\0!cg\0");
}
#[test]
fn test_suffix() {
let val = super::suffix("testns", "testdb");
assert_eq!(val, b"/*testns\0*testdb\0!cg\xff");
}
}

1
core/src/key/database/mod.rs
View file

@ -2,6 +2,7 @@ pub mod ac;
pub mod access;
pub mod all;
pub mod az;
pub mod cg;
pub mod fc;
pub mod ml;
pub mod pa;

1
core/src/key/mod.rs
View file

@ -37,6 +37,7 @@
/// crate::key::database::ts /*{ns}*{db}!ts{ts}
/// crate::key::database::us /*{ns}*{db}!us{us}
/// crate::key::database::vs /*{ns}*{db}!vs
/// crate::key::database::cg /*{ns}*{db}!cg{ty}
///
/// crate::key::database::access::all /*{ns}*{db}&{ac}
/// crate::key::database::access::gr /*{ns}*{db}&{ac}!gr{gr}

11
core/src/kvs/cache.rs
View file

@ -1,6 +1,7 @@
use super::Key;
use crate::dbs::node::Node;
use crate::err::Error;
use crate::sql::statements::define::DefineConfigStatement;
use crate::sql::statements::AccessGrant;
use crate::sql::statements::DefineAccessStatement;
use crate::sql::statements::DefineAnalyzerStatement;
@ -81,6 +82,8 @@ pub(super) enum Entry {
Fts(Arc<[DefineTableStatement]>),
/// A slice of DefineModelStatement specified on a database.
Mls(Arc<[DefineModelStatement]>),
/// A slice of DefineConfigStatement specified on a database.
Cgs(Arc<[DefineConfigStatement]>),
/// A slice of DefineParamStatement specified on a database.
Pas(Arc<[DefineParamStatement]>),
/// A slice of DefineTableStatement specified on a database.
@ -234,6 +237,14 @@ impl Entry {
_ => Err(fail!("Unable to convert type into Entry::Mls")),
}
}
/// Converts this cache entry into a slice of [`DefineConfigStatement`].
/// This panics if called on a cache entry that is not an [`Entry::Cgs`].
pub(super) fn try_into_cgs(self) -> Result<Arc<[DefineConfigStatement]>, Error> {
match self {
Entry::Cgs(v) => Ok(v),
_ => Err(fail!("Unable to convert type into Entry::Cgs")),
}
}
/// Converts this cache entry into a slice of [`DefineTableStatement`].
/// This panics if called on a cache entry that is not an [`Entry::Tbs`].
pub(super) fn try_into_tbs(self) -> Result<Arc<[DefineTableStatement]>, Error> {

49
core/src/kvs/tx.rs
View file

@ -11,6 +11,7 @@ use crate::kvs::cache::Entry;
use crate::kvs::cache::EntryWeighter;
use crate::kvs::scanner::Scanner;
use crate::kvs::Transactor;
use crate::sql::statements::define::DefineConfigStatement;
use crate::sql::statements::AccessGrant;
use crate::sql::statements::DefineAccessStatement;
use crate::sql::statements::DefineAnalyzerStatement;
@ -669,6 +670,29 @@ impl Transaction {
.try_into_mls()
}
/// Retrieve all model definitions for a specific database.
#[instrument(level = "trace", target = "surrealdb::core::kvs::tx", skip(self))]
pub async fn all_db_configs(
&self,
ns: &str,
db: &str,
) -> Result<Arc<[DefineConfigStatement]>, Error> {
let key = crate::key::database::cg::prefix(ns, db);
let res = self.cache.get_value_or_guard_async(&key).await;
match res {
Ok(val) => val,
Err(cache) => {
let end = crate::key::database::cg::suffix(ns, db);
let val = self.getr(key..end, None).await?;
let val = val.convert().into();
let val = Entry::Cgs(Arc::clone(&val));
let _ = cache.insert(val.clone());
val
}
}
.try_into_cgs()
}
/// Retrieve all table definitions for a specific database.
#[instrument(level = "trace", target = "surrealdb::core::kvs::tx", skip(self))]
pub async fn all_tb(
@ -1199,6 +1223,31 @@ impl Transaction {
.try_into_type()
}
/// Retrieve a specific config definition from a database.
#[instrument(level = "trace", target = "surrealdb::core::kvs::tx", skip(self))]
pub async fn get_db_config(
&self,
ns: &str,
db: &str,
cg: &str,
) -> Result<Arc<DefineConfigStatement>, Error> {
let key = crate::key::database::cg::new(ns, db, cg).encode()?;
let res = self.cache.get_value_or_guard_async(&key).await;
match res {
Ok(val) => val,
Err(cache) => {
let val = self.get(key, None).await?.ok_or_else(|| Error::CgNotFound {
value: cg.to_owned(),
})?;
let val: DefineConfigStatement = val.into();
let val = Entry::Any(Arc::new(val));
let _ = cache.insert(val.clone());
val
}
}
.try_into_type()
}
/// Retrieve a specific table definition.
#[instrument(level = "trace", target = "surrealdb::core::kvs::tx", skip(self))]
pub async fn get_tb(

198
core/src/sql/statements/define/config/graphql.rs Normal file
View file

@ -0,0 +1,198 @@
use std::fmt::{self, Display, Write};
use crate::sql::fmt::{pretty_indent, Fmt, Pretty};
use crate::sql::statements::info::InfoStructure;
use crate::sql::{Ident, Part, Value};
use derive::Store;
use revision::revisioned;
use serde::{Deserialize, Serialize};
#[revisioned(revision = 1)]
#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Store, Hash)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[non_exhaustive]
pub struct GraphQLConfig {
pub tables: TablesConfig,
pub functions: FunctionsConfig,
}
#[revisioned(revision = 1)]
#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Store, Hash)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[non_exhaustive]
pub enum TablesConfig {
#[default]
None,
Auto,
Include(Vec<TableConfig>),
Exclude(Vec<TableConfig>),
}
#[revisioned(revision = 1)]
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Store, Hash)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[non_exhaustive]
pub struct TableConfig {
pub name: String,
}
#[revisioned(revision = 1)]
#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Store, Hash)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[non_exhaustive]
pub enum FunctionsConfig {
#[default]
None,
Auto,
Include(Vec<Ident>),
Exclude(Vec<Ident>),
}
impl Display for GraphQLConfig {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, " GRAPHQL")?;
write!(f, " TABLES {}", self.tables)?;
write!(f, " FUNCTIONS {}", self.functions)?;
Ok(())
}
}
impl Display for TablesConfig {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
TablesConfig::Auto => write!(f, "AUTO")?,
TablesConfig::None => write!(f, "NONE")?,
TablesConfig::Include(cs) => {
let mut f = Pretty::from(f);
write!(f, "INCLUDE ")?;
if !cs.is_empty() {
let indent = pretty_indent();
write!(f, "{}", Fmt::pretty_comma_separated(cs.as_slice()))?;
drop(indent);
}
}
TablesConfig::Exclude(_) => todo!(),
}
Ok(())
}
}
impl From<String> for TableConfig {
fn from(value: String) -> Self {
Self {
name: value,
}
}
}
pub fn val_to_ident(val: Value) -> Result<Ident, Value> {
match val {
Value::Strand(s) => Ok(s.0.into()),
Value::Table(n) => Ok(n.0.into()),
Value::Idiom(ref i) => match &i[..] {
[Part::Field(n)] => Ok(n.to_raw().into()),
_ => Err(val),
},
_ => Err(val),
}
}
impl TryFrom<Value> for TableConfig {
type Error = Value;
fn try_from(value: Value) -> Result<Self, Self::Error> {
match value {
v @ Value::Strand(_) | v @ Value::Table(_) | v @ Value::Idiom(_) => {
val_to_ident(v).map(|i| i.0.into())
}
_ => Err(value),
}
}
}
impl Display for TableConfig {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.name)?;
Ok(())
}
}
impl Display for FunctionsConfig {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
FunctionsConfig::Auto => write!(f, "AUTO")?,
FunctionsConfig::None => write!(f, "NONE")?,
FunctionsConfig::Include(cs) => {
let mut f = Pretty::from(f);
write!(f, "INCLUDE [")?;
if !cs.is_empty() {
let indent = pretty_indent();
write!(f, "{}", Fmt::pretty_comma_separated(cs.as_slice()))?;
drop(indent);
}
f.write_char(']')?;
}
FunctionsConfig::Exclude(cs) => {
let mut f = Pretty::from(f);
write!(f, "EXCLUDE [")?;
if !cs.is_empty() {
let indent = pretty_indent();
write!(f, "{}", Fmt::pretty_comma_separated(cs.as_slice()))?;
drop(indent);
}
f.write_char(']')?;
}
}
Ok(())
}
}
impl InfoStructure for GraphQLConfig {
fn structure(self) -> Value {
Value::from(map!(
"tables" => self.tables.structure(),
"functions" => self.functions.structure(),
))
}
}
impl InfoStructure for TablesConfig {
fn structure(self) -> Value {
match self {
TablesConfig::None => Value::None,
TablesConfig::Auto => Value::Strand("AUTO".into()),
TablesConfig::Include(ts) => Value::from(map!(
"include" => Value::Array(ts.into_iter().map(InfoStructure::structure).collect()),
)),
TablesConfig::Exclude(ts) => Value::from(map!(
"exclude" => Value::Array(ts.into_iter().map(InfoStructure::structure).collect()),
)),
}
}
}
impl InfoStructure for TableConfig {
fn structure(self) -> Value {
Value::from(map!(
"name" => Value::from(self.name),
))
}
}
impl InfoStructure for FunctionsConfig {
fn structure(self) -> Value {
match self {
FunctionsConfig::None => Value::None,
FunctionsConfig::Auto => Value::Strand("AUTO".into()),
FunctionsConfig::Include(fs) => Value::from(map!(
"include" => Value::Array(fs.into_iter().map(|i| Value::from(i.to_raw())).collect()),
)),
FunctionsConfig::Exclude(fs) => Value::from(map!(
"exclude" => Value::Array(fs.into_iter().map(|i| Value::from(i.to_raw())).collect()),
)),
}
}
}

130
core/src/sql/statements/define/config/mod.rs Normal file
View file

@ -0,0 +1,130 @@
pub mod graphql;
use crate::ctx::Context;
use crate::dbs::Options;
use crate::doc::CursorDoc;
use crate::err::Error;
use crate::iam::{Action, ConfigKind, ResourceKind};
use crate::sql::statements::info::InfoStructure;
use crate::sql::{Base, Value};
use derive::Store;
use graphql::GraphQLConfig;
use revision::revisioned;
use serde::{Deserialize, Serialize};
use std::fmt::{self, Display};
#[revisioned(revision = 1)]
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Store, Hash)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[non_exhaustive]
pub struct DefineConfigStatement {
pub inner: ConfigInner,
pub if_not_exists: bool,
pub overwrite: bool,
}
#[revisioned(revision = 1)]
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Store, Hash)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[non_exhaustive]
pub enum ConfigInner {
GraphQL(GraphQLConfig),
}
impl DefineConfigStatement {
/// Process this type returning a computed simple Value
pub(crate) async fn compute(
&self,
ctx: &Context,
opt: &Options,
_doc: Option<&CursorDoc>,
) -> Result<Value, Error> {
// Allowed to run?
opt.is_allowed(Action::Edit, ResourceKind::Config(ConfigKind::GraphQL), &Base::Db)?;
// get transaction
let txn = ctx.tx();
// check if already defined
if txn.get_db_config(opt.ns()?, opt.db()?, "graphql").await.is_ok() {
if self.if_not_exists {
return Ok(Value::None);
} else if !self.overwrite {
return Err(Error::CgAlreadyExists {
value: "graphql".to_string(),
});
}
}
let key = crate::key::database::cg::new(opt.ns()?, opt.db()?, "graphql");
txn.get_or_add_ns(opt.ns()?, opt.strict).await?;
txn.get_or_add_db(opt.ns()?, opt.db()?, opt.strict).await?;
txn.set(key, self.clone(), None).await?;
// Clear the cache
txn.clear();
// Ok all good
Ok(Value::None)
}
}
impl ConfigInner {
pub fn name(&self) -> String {
ConfigKind::from(self).to_string()
}
pub fn try_into_graphql(self) -> Result<GraphQLConfig, Error> {
match self {
ConfigInner::GraphQL(g) => Ok(g),
#[allow(unreachable_patterns)]
c => Err(fail!("found {c} when a graphql config was expected")),
}
}
}
impl From<ConfigInner> for ConfigKind {
fn from(value: ConfigInner) -> Self {
(&value).into()
}
}
impl From<&ConfigInner> for ConfigKind {
fn from(value: &ConfigInner) -> Self {
match value {
ConfigInner::GraphQL(_) => ConfigKind::GraphQL,
}
}
}
impl InfoStructure for DefineConfigStatement {
fn structure(self) -> Value {
match self.inner {
ConfigInner::GraphQL(v) => Value::from(map!(
"graphql" => v.structure()
)),
}
}
}
impl Display for DefineConfigStatement {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "DEFINE CONFIG")?;
if self.if_not_exists {
write!(f, " IF NOT EXISTS")?
}
if self.overwrite {
write!(f, " OVERWRITE")?
}
write!(f, "{}", self.inner)?;
Ok(())
}
}
impl Display for ConfigInner {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self {
ConfigInner::GraphQL(v) => Display::fmt(v, f),
}
}
}

5
core/src/sql/statements/define/mod.rs
View file

@ -1,5 +1,6 @@
mod access;
mod analyzer;
pub mod config;
mod database;
mod deprecated;
mod event;
@ -14,6 +15,7 @@ mod user;
pub use access::DefineAccessStatement;
pub use analyzer::DefineAnalyzerStatement;
pub use config::DefineConfigStatement;
pub use database::DefineDatabaseStatement;
pub use event::DefineEventStatement;
pub use field::DefineFieldStatement;
@ -71,6 +73,7 @@ pub enum DefineStatement {
Model(DefineModelStatement),
#[revision(start = 2)]
Access(DefineAccessStatement),
Config(DefineConfigStatement),
}
// Revision implementations
@ -116,6 +119,7 @@ impl DefineStatement {
Self::User(ref v) => v.compute(ctx, opt, doc).await,
Self::Model(ref v) => v.compute(ctx, opt, doc).await,
Self::Access(ref v) => v.compute(ctx, opt, doc).await,
Self::Config(ref v) => v.compute(ctx, opt, doc).await,
}
}
}
@ -135,6 +139,7 @@ impl Display for DefineStatement {
Self::Analyzer(v) => Display::fmt(v, f),
Self::Model(v) => Display::fmt(v, f),
Self::Access(v) => Display::fmt(v, f),
Self::Config(v) => Display::fmt(v, f),
}
}
}

8
core/src/sql/statements/info.rs
View file

@ -151,6 +151,7 @@ impl InfoStatement {
"params".to_string() => process(txn.all_db_params(ns, db).await?),
"tables".to_string() => process(txn.all_tb(ns, db, version).await?),
"users".to_string() => process(txn.all_db_users(ns, db).await?),
"configs".to_string() => process(txn.all_db_configs(ns, db).await?),
}),
false => Value::from(map! {
"accesses".to_string() => {
@ -202,6 +203,13 @@ impl InfoStatement {
}
out.into()
},
"configs".to_string() => {
let mut out = Object::default();
for v in txn.all_db_configs(ns, db).await?.iter() {
out.insert(v.inner.name(), v.to_string().into());
}
out.into()
},
}),
})
}

6
core/src/syn/lexer/keywords.rs
View file

@ -71,6 +71,7 @@ pub(crate) static KEYWORDS: phf::Map<UniCase<&'static str>, TokenKind> = phf_map
UniCase::ascii("ASSERT") => TokenKind::Keyword(Keyword::Assert),
UniCase::ascii("AT") => TokenKind::Keyword(Keyword::At),
UniCase::ascii("AUTHENTICATE") => TokenKind::Keyword(Keyword::Authenticate),
UniCase::ascii("AUTO") => TokenKind::Keyword(Keyword::Auto),
UniCase::ascii("BEARER") => TokenKind::Keyword(Keyword::Bearer),
UniCase::ascii("BEFORE") => TokenKind::Keyword(Keyword::Before),
UniCase::ascii("BEGIN") => TokenKind::Keyword(Keyword::Begin),
@ -87,6 +88,7 @@ pub(crate) static KEYWORDS: phf::Map<UniCase<&'static str>, TokenKind> = phf_map
UniCase::ascii("COMMENT") => TokenKind::Keyword(Keyword::Comment),
UniCase::ascii("COMMIT") => TokenKind::Keyword(Keyword::Commit),
UniCase::ascii("CONCURRENTLY") => TokenKind::Keyword(Keyword::Concurrently),
UniCase::ascii("CONFIG") => TokenKind::Keyword(Keyword::Config),
UniCase::ascii("CONTENT") => TokenKind::Keyword(Keyword::Content),
UniCase::ascii("CONTINUE") => TokenKind::Keyword(Keyword::Continue),
UniCase::ascii("CREATE") => TokenKind::Keyword(Keyword::Create),
@ -113,6 +115,7 @@ pub(crate) static KEYWORDS: phf::Map<UniCase<&'static str>, TokenKind> = phf_map
UniCase::ascii("ELSE") => TokenKind::Keyword(Keyword::Else),
UniCase::ascii("END") => TokenKind::Keyword(Keyword::End),
UniCase::ascii("ENFORCED") => TokenKind::Keyword(Keyword::Enforced),
UniCase::ascii("EXCLUDE") => TokenKind::Keyword(Keyword::Exclude),
UniCase::ascii("EXISTS") => TokenKind::Keyword(Keyword::Exists),
UniCase::ascii("EXPLAIN") => TokenKind::Keyword(Keyword::Explain),
UniCase::ascii("EXTEND_CANDIDATES") => TokenKind::Keyword(Keyword::ExtendCandidates),
@ -129,7 +132,9 @@ pub(crate) static KEYWORDS: phf::Map<UniCase<&'static str>, TokenKind> = phf_map
UniCase::ascii("FROM") => TokenKind::Keyword(Keyword::From),
UniCase::ascii("FULL") => TokenKind::Keyword(Keyword::Full),
UniCase::ascii("FUNCTION") => TokenKind::Keyword(Keyword::Function),
UniCase::ascii("FUNCTIONS") => TokenKind::Keyword(Keyword::Functions),
UniCase::ascii("GRANT") => TokenKind::Keyword(Keyword::Grant),
UniCase::ascii("GRAPHQL") => TokenKind::Keyword(Keyword::Graphql),
UniCase::ascii("GROUP") => TokenKind::Keyword(Keyword::Group),
UniCase::ascii("HIGHLIGHTS") => TokenKind::Keyword(Keyword::Highlights),
UniCase::ascii("HNSW") => TokenKind::Keyword(Keyword::Hnsw),
@ -216,6 +221,7 @@ pub(crate) static KEYWORDS: phf::Map<UniCase<&'static str>, TokenKind> = phf_map
UniCase::ascii("START") => TokenKind::Keyword(Keyword::Start),
UniCase::ascii("STRUCTURE") => TokenKind::Keyword(Keyword::Structure),
UniCase::ascii("TABLE") => TokenKind::Keyword(Keyword::Table),
UniCase::ascii("TABLES") => TokenKind::Keyword(Keyword::Tables),
UniCase::ascii("TB") => TokenKind::Keyword(Keyword::Table),
UniCase::ascii("TEMPFILES") => TokenKind::Keyword(Keyword::TempFiles),
UniCase::ascii("TERMS_CACHE") => TokenKind::Keyword(Keyword::TermsCache),

119
core/src/syn/parser/stmt/define.rs
View file

@ -3,6 +3,9 @@ use reblessive::Stk;
use crate::cnf::EXPERIMENTAL_BEARER_ACCESS;
use crate::sql::access_type::JwtAccessVerify;
use crate::sql::index::HnswParams;
use crate::sql::statements::define::config::graphql::{GraphQLConfig, TableConfig};
use crate::sql::statements::define::config::ConfigInner;
use crate::sql::statements::define::DefineConfigStatement;
use crate::sql::Value;
use crate::{
sql::{
@ -11,10 +14,10 @@ use crate::{
filter::Filter,
index::{Distance, VectorType},
statements::{
DefineAccessStatement, DefineAnalyzerStatement, DefineDatabaseStatement,
DefineEventStatement, DefineFieldStatement, DefineFunctionStatement,
DefineIndexStatement, DefineNamespaceStatement, DefineParamStatement, DefineStatement,
DefineTableStatement, DefineUserStatement,
define::config::graphql, DefineAccessStatement, DefineAnalyzerStatement,
DefineDatabaseStatement, DefineEventStatement, DefineFieldStatement,
DefineFunctionStatement, DefineIndexStatement, DefineNamespaceStatement,
DefineParamStatement, DefineStatement, DefineTableStatement, DefineUserStatement,
},
table_type,
tokenizer::Tokenizer,
@ -56,6 +59,7 @@ impl Parser<'_> {
}
t!("ANALYZER") => self.parse_define_analyzer().map(DefineStatement::Analyzer),
t!("ACCESS") => self.parse_define_access(ctx).await.map(DefineStatement::Access),
t!("CONFIG") => self.parse_define_config().map(DefineStatement::Config),
_ => unexpected!(self, next, "a define statement keyword"),
}
}
@ -1213,6 +1217,113 @@ impl Parser<'_> {
Ok(res)
}
pub fn parse_define_config(&mut self) -> ParseResult<DefineConfigStatement> {
let (if_not_exists, overwrite) = if self.eat(t!("IF")) {
expected!(self, t!("NOT"));
expected!(self, t!("EXISTS"));
(true, false)
} else if self.eat(t!("OVERWRITE")) {
(false, true)
} else {
(false, false)
};
let next = self.next();
let inner = match next.kind {
t!("GRAPHQL") => self.parse_graphql_config().map(ConfigInner::GraphQL)?,
_ => unexpected!(self, next, "a type of config"),
};
Ok(DefineConfigStatement {
inner,
if_not_exists,
overwrite,
})
}
fn parse_graphql_config(&mut self) -> ParseResult<GraphQLConfig> {
use graphql::{FunctionsConfig, TablesConfig};
let mut tmp_tables = Option::<TablesConfig>::None;
let mut tmp_fncs = Option::<FunctionsConfig>::None;
loop {
match self.peek_kind() {
t!("NONE") => {
self.pop_peek();
tmp_tables = Some(TablesConfig::None);
tmp_fncs = Some(FunctionsConfig::None);
}
t!("AUTO") => {
self.pop_peek();
tmp_tables = Some(TablesConfig::Auto);
tmp_fncs = Some(FunctionsConfig::Auto);
}
t!("TABLES") => {
self.pop_peek();
let next = self.next();
match next.kind {
t!("INCLUDE") => {
tmp_tables =
Some(TablesConfig::Include(self.parse_graphql_table_configs()?))
}
t!("EXCLUDE") => {
tmp_tables =
Some(TablesConfig::Include(self.parse_graphql_table_configs()?))
}
t!("NONE") => {
tmp_tables = Some(TablesConfig::None);
}
t!("AUTO") => {
tmp_tables = Some(TablesConfig::Auto);
}
_ => unexpected!(self, next, "`NONE`, `AUTO`, `INCLUDE` or `EXCLUDE`"),
}
}
t!("FUNCTIONS") => {
self.pop_peek();
let next = self.next();
match next.kind {
t!("INCLUDE") => {}
t!("EXCLUDE") => {}
t!("NONE") => {
tmp_fncs = Some(FunctionsConfig::None);
}
t!("AUTO") => {
tmp_fncs = Some(FunctionsConfig::Auto);
}
_ => unexpected!(self, next, "`NONE`, `AUTO`, `INCLUDE` or `EXCLUDE`"),
}
}
_ => break,
}
}
Ok(GraphQLConfig {
tables: tmp_tables.unwrap_or_default(),
functions: tmp_fncs.unwrap_or_default(),
})
}
fn parse_graphql_table_configs(&mut self) -> ParseResult<Vec<graphql::TableConfig>> {
let mut acc = vec![];
loop {
match self.peek_kind() {
x if Self::kind_is_identifier(x) => {
let name: Ident = self.next_token_value()?;
acc.push(TableConfig {
name: name.0,
});
}
_ => unexpected!(self, self.next(), "a table config"),
}
if !self.eat(t!(",")) {
break;
}
}
Ok(acc)
}
pub fn parse_relation_schema(&mut self) -> ParseResult<table_type::Relation> {
let mut res = table_type::Relation {
from: None,

1
core/src/syn/parser/stmt/remove.rs
View file

@ -199,6 +199,7 @@ impl Parser<'_> {
if_exists,
})
}
// TODO(raphaeldarley): add Config here
_ => unexpected!(self, next, "a remove statement keyword"),
};
Ok(res)

6
core/src/syn/token/keyword.rs
View file

@ -37,6 +37,7 @@ keyword! {
Assert => "ASSERT",
At => "AT",
Authenticate => "AUTHENTICATE",
Auto => "AUTO",
Bearer => "BEARER",
Before => "BEFORE",
Begin => "BEGIN",
@ -53,6 +54,7 @@ keyword! {
Comment => "COMMENT",
Commit => "COMMIT",
Concurrently => "CONCURRENTLY",
Config => "CONFIG",
Content => "CONTENT",
Continue => "CONTINUE",
Create => "CREATE",
@ -76,6 +78,7 @@ keyword! {
Else => "ELSE",
End => "END",
Enforced => "ENFORCED",
Exclude => "EXCLUDE",
Exists => "EXISTS",
Explain => "EXPLAIN",
ExtendCandidates => "EXTEND_CANDIDATES",
@ -89,7 +92,9 @@ keyword! {
From => "FROM",
Full => "FULL",
Function => "FUNCTION",
Functions => "FUNCTIONS",
Grant => "GRANT",
Graphql => "GRAPHQL",
Group => "GROUP",
Highlights => "HIGHLIGHTS",
Hnsw => "HNSW",
@ -171,6 +176,7 @@ keyword! {
Start => "START",
Structure => "STRUCTURE",
Table => "TABLE",
Tables => "TABLES",
TempFiles => "TEMPFILES",
TermsCache => "TERMS_CACHE",
TermsOrder => "TERMS_ORDER",

4
sdk/tests/alter.rs
View file

@ -45,6 +45,7 @@ async fn define_alter_table() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -62,6 +63,7 @@ async fn define_alter_table() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -79,6 +81,7 @@ async fn define_alter_table() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -117,6 +120,7 @@ async fn define_alter_table_if_exists() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},

40
sdk/tests/define.rs
View file

@ -92,6 +92,7 @@ async fn define_statement_function() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: { test: 'DEFINE FUNCTION fn::test($first: string, $last: string) { RETURN $first + $last; } PERMISSIONS FULL' },
models: {},
params: {},
@ -123,6 +124,7 @@ async fn define_statement_table_drop() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -154,6 +156,7 @@ async fn define_statement_table_schemaless() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -180,6 +183,7 @@ async fn define_statement_table_schemafull() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -209,6 +213,7 @@ async fn define_statement_table_schemaful() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -248,6 +253,7 @@ async fn define_statement_table_foreigntable() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -280,6 +286,7 @@ async fn define_statement_table_foreigntable() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -1724,6 +1731,7 @@ async fn define_statement_analyzer() -> Result<(), Error> {
english: 'DEFINE ANALYZER english TOKENIZERS BLANK,CLASS FILTERS LOWERCASE,SNOWBALL(ENGLISH)',
htmlAnalyzer: 'DEFINE ANALYZER htmlAnalyzer FUNCTION fn::stripHtml TOKENIZERS BLANK,CLASS'
},
configs: {},
functions: {
stripHtml: "DEFINE FUNCTION fn::stripHtml($html: string) { RETURN string::replace($html, /<[^>]*>/, ''); } PERMISSIONS FULL"
},
@ -2049,8 +2057,8 @@ async fn permissions_checks_define_function() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { greet: \"DEFINE FUNCTION fn::greet() { RETURN 'Hello'; } PERMISSIONS FULL\" }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { greet: \"DEFINE FUNCTION fn::greet() { RETURN 'Hello'; } PERMISSIONS FULL\" }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
];
let test_cases = [
@ -2091,8 +2099,8 @@ async fn permissions_checks_define_analyzer() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { analyzer: 'DEFINE ANALYZER analyzer TOKENIZERS BLANK' }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
vec!["{ accesses: { }, analyzers: { analyzer: 'DEFINE ANALYZER analyzer TOKENIZERS BLANK' }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
];
let test_cases = [
@ -2217,8 +2225,8 @@ async fn permissions_checks_define_access_db() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { access: \"DEFINE ACCESS access ON DATABASE TYPE JWT ALGORITHM HS512 KEY '[REDACTED]' WITH ISSUER KEY '[REDACTED]' DURATION FOR TOKEN 1h, FOR SESSION NONE\" }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
vec!["{ accesses: { access: \"DEFINE ACCESS access ON DATABASE TYPE JWT ALGORITHM HS512 KEY '[REDACTED]' WITH ISSUER KEY '[REDACTED]' DURATION FOR TOKEN 1h, FOR SESSION NONE\" }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
];
let test_cases = [
@ -2343,8 +2351,8 @@ async fn permissions_checks_define_user_db() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { user: \"DEFINE USER user ON DATABASE PASSHASH 'secret' ROLES VIEWER DURATION FOR TOKEN 15m, FOR SESSION 6h\" } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { user: \"DEFINE USER user ON DATABASE PASSHASH 'secret' ROLES VIEWER DURATION FOR TOKEN 15m, FOR SESSION 6h\" } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
];
let test_cases = [
@ -2385,8 +2393,8 @@ async fn permissions_checks_define_access_record() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { account: \"DEFINE ACCESS account ON DATABASE TYPE RECORD WITH JWT ALGORITHM HS512 KEY '[REDACTED]' WITH ISSUER KEY '[REDACTED]' DURATION FOR TOKEN 15m, FOR SESSION 12h\" }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
vec!["{ accesses: { account: \"DEFINE ACCESS account ON DATABASE TYPE RECORD WITH JWT ALGORITHM HS512 KEY '[REDACTED]' WITH ISSUER KEY '[REDACTED]' DURATION FOR TOKEN 15m, FOR SESSION 12h\" }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
];
let test_cases = [
@ -2427,8 +2435,8 @@ async fn permissions_checks_define_param() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { param: \"DEFINE PARAM $param VALUE 'foo' PERMISSIONS FULL\" }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { param: \"DEFINE PARAM $param VALUE 'foo' PERMISSIONS FULL\" }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
];
let test_cases = [
@ -2466,8 +2474,8 @@ async fn permissions_checks_define_table() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { TB: 'DEFINE TABLE TB TYPE ANY SCHEMALESS PERMISSIONS NONE' }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { TB: 'DEFINE TABLE TB TYPE ANY SCHEMALESS PERMISSIONS NONE' }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"]
];
let test_cases = [
@ -2653,6 +2661,7 @@ async fn define_statement_table_permissions() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -3057,6 +3066,7 @@ async fn define_table_relation_redefinition_info() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -3078,6 +3088,7 @@ async fn define_table_relation_redefinition_info() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -3099,6 +3110,7 @@ async fn define_table_relation_redefinition_info() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},

10
sdk/tests/info.rs
View file

@ -290,8 +290,8 @@ async fn permissions_checks_info_db() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
];
let test_cases = [
@ -554,7 +554,7 @@ async fn access_info_redacted() {
assert!(out.is_ok(), "Unexpected error: {:?}", out);
let out_expected =
r#"{ accesses: { access: "DEFINE ACCESS access ON DATABASE TYPE RECORD WITH JWT ALGORITHM HS512 KEY '[REDACTED]' WITH ISSUER KEY '[REDACTED]' DURATION FOR TOKEN 1h, FOR SESSION NONE" }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"#.to_string();
r#"{ accesses: { access: "DEFINE ACCESS access ON DATABASE TYPE RECORD WITH JWT ALGORITHM HS512 KEY '[REDACTED]' WITH ISSUER KEY '[REDACTED]' DURATION FOR TOKEN 1h, FOR SESSION NONE" }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"#.to_string();
let out_str = out.unwrap().to_string();
assert_eq!(
out_str, out_expected,
@ -627,7 +627,7 @@ async fn access_info_redacted_structure() {
assert!(out.is_ok(), "Unexpected error: {:?}", out);
let out_expected =
r#"{ accesses: [{ base: 'DATABASE', duration: { session: 6h, token: 15m }, kind: { jwt: { issuer: { alg: 'HS512', key: '[REDACTED]' }, verify: { alg: 'HS512', key: '[REDACTED]' } }, kind: 'RECORD' }, name: 'access' }], analyzers: [], functions: [], models: [], params: [], tables: [], users: [] }"#.to_string();
r#"{ accesses: [{ base: 'DATABASE', duration: { session: 6h, token: 15m }, kind: { jwt: { issuer: { alg: 'HS512', key: '[REDACTED]' }, verify: { alg: 'HS512', key: '[REDACTED]' } }, kind: 'RECORD' }, name: 'access' }], analyzers: [], configs: [], functions: [], models: [], params: [], tables: [], users: [] }"#.to_string();
let out_str = out.unwrap().to_string();
assert_eq!(
out_str, out_expected,
@ -652,7 +652,7 @@ async fn function_info_structure() {
assert!(out.is_ok(), "Unexpected error: {:?}", out);
let out_expected =
r#"{ accesses: [], analyzers: [], functions: [{ args: [['name', 'string']], block: "{ RETURN 'Hello, ' + $name + '!'; }", name: 'example', permissions: true, returns: 'string' }], models: [], params: [], tables: [], users: [] }"#.to_string();
r#"{ accesses: [], analyzers: [], configs: [], functions: [{ args: [['name', 'string']], block: "{ RETURN 'Hello, ' + $name + '!'; }", name: 'example', permissions: true, returns: 'string' }], models: [], params: [], tables: [], users: [] }"#.to_string();
let out_str = out.unwrap().to_string();
assert_eq!(
out_str, out_expected,

1
sdk/tests/param.rs
View file

@ -28,6 +28,7 @@ async fn define_global_param() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: { test: 'DEFINE PARAM $test VALUE 12345 PERMISSIONS FULL' },

1
sdk/tests/relate.rs
View file

@ -282,6 +282,7 @@ async fn relate_enforced() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},

26
sdk/tests/remove.rs
View file

@ -37,6 +37,7 @@ async fn remove_statement_table() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -167,6 +168,7 @@ async fn remove_statement_analyzer() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},
@ -666,8 +668,8 @@ async fn permissions_checks_remove_function() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { greet: \"DEFINE FUNCTION fn::greet() { RETURN 'Hello'; } PERMISSIONS FULL\" }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { greet: \"DEFINE FUNCTION fn::greet() { RETURN 'Hello'; } PERMISSIONS FULL\" }, models: { }, params: { }, tables: { }, users: { } }"],
];
let test_cases = [
@ -708,8 +710,8 @@ async fn permissions_checks_remove_analyzer() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { analyzer: 'DEFINE ANALYZER analyzer TOKENIZERS BLANK' }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { analyzer: 'DEFINE ANALYZER analyzer TOKENIZERS BLANK' }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
];
let test_cases = [
@ -834,8 +836,8 @@ async fn permissions_checks_remove_db_access() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { access: \"DEFINE ACCESS access ON DATABASE TYPE JWT ALGORITHM HS512 KEY '[REDACTED]' WITH ISSUER KEY '[REDACTED]' DURATION FOR TOKEN 1h, FOR SESSION NONE\" }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { access: \"DEFINE ACCESS access ON DATABASE TYPE JWT ALGORITHM HS512 KEY '[REDACTED]' WITH ISSUER KEY '[REDACTED]' DURATION FOR TOKEN 1h, FOR SESSION NONE\" }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
];
let test_cases = [
@ -960,8 +962,8 @@ async fn permissions_checks_remove_db_user() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { user: \"DEFINE USER user ON DATABASE PASSHASH 'secret' ROLES VIEWER DURATION FOR TOKEN 1h, FOR SESSION NONE\" } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { user: \"DEFINE USER user ON DATABASE PASSHASH 'secret' ROLES VIEWER DURATION FOR TOKEN 1h, FOR SESSION NONE\" } }"],
];
let test_cases = [
@ -1002,8 +1004,8 @@ async fn permissions_checks_remove_param() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { param: \"DEFINE PARAM $param VALUE 'foo' PERMISSIONS FULL\" }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { param: \"DEFINE PARAM $param VALUE 'foo' PERMISSIONS FULL\" }, tables: { }, users: { } }"],
];
let test_cases = [
@ -1044,8 +1046,8 @@ async fn permissions_checks_remove_table() {
// Define the expected results for the check statement when the test statement succeeded and when it failed
let check_results = [
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, functions: { }, models: { }, params: { }, tables: { TB: 'DEFINE TABLE TB TYPE ANY SCHEMALESS PERMISSIONS NONE' }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { }, users: { } }"],
vec!["{ accesses: { }, analyzers: { }, configs: { }, functions: { }, models: { }, params: { }, tables: { TB: 'DEFINE TABLE TB TYPE ANY SCHEMALESS PERMISSIONS NONE' }, users: { } }"],
];
let test_cases = [

1
sdk/tests/strict.rs
View file

@ -256,6 +256,7 @@ async fn loose_mode_all_ok() -> Result<(), Error> {
"{
accesses: {},
analyzers: {},
configs: {},
functions: {},
models: {},
params: {},

156
tests/graphql_integration.rs
View file

@ -2,13 +2,20 @@ mod common;
#[cfg(surrealdb_unstable)]
mod graphql_integration {
use std::time::Duration;
use std::{str::FromStr, time::Duration};
macro_rules! assert_equal_arrs {
($lhs: expr, $rhs: expr) => {
let lhs = $lhs.as_array().unwrap().iter().collect::<std::collections::HashSet<_>>();
let rhs = $rhs.as_array().unwrap().iter().collect::<std::collections::HashSet<_>>();
assert_eq!(lhs, rhs)
};
}
use http::header;
use reqwest::Client;
use serde_json::json;
use test_log::test;
use tracing::debug;
use ulid::Ulid;
use crate::common::{PASS, USER};
@ -32,6 +39,28 @@ mod graphql_integration {
.default_headers(headers)
.build()?;
// check errors with no config
{
let res = client.post(gql_url).body("").send().await?;
assert_eq!(res.status(), 400);
let body = res.text().await?;
assert!(body.contains("NotConfigured"), "body: {body}")
}
// add schema and data
{
let res = client
.post(sql_url)
.body(
r#"
DEFINE CONFIG GRAPHQL AUTO;
"#,
)
.send()
.await?;
assert_eq!(res.status(), 200);
}
// check errors with no tables
{
let res = client.post(gql_url).body("").send().await?;
@ -209,6 +238,7 @@ mod graphql_integration {
.basic_auth(USER, Some(PASS))
.body(
r#"
DEFINE CONFIG GRAPHQL AUTO;
DEFINE ACCESS user ON DATABASE TYPE RECORD
SIGNUP ( CREATE user SET email = $email, pass = crypto::argon2::generate($pass) )
SIGNIN ( SELECT * FROM user WHERE email = $email AND crypto::argon2::compare(pass, $pass) )
@ -223,9 +253,9 @@ mod graphql_integration {
)
.send()
.await?;
assert_eq!(res.status(), 200);
// assert_eq!(res.status(), 200);
let body = res.text().await?;
debug!(?body);
eprintln!("\n\n\n\n\n{body}\n\n\n\n\n\n");
}
// check works with root
@ -236,7 +266,7 @@ mod graphql_integration {
.body(json!({"query": r#"query{foo{id, val}}"#}).to_string())
.send()
.await?;
assert_eq!(res.status(), 200);
// assert_eq!(res.status(), 200);
let body = res.text().await?;
let expected =
json!({"data":{"foo":[{"id":"foo:1","val":42},{"id":"foo:2","val":43}]}});
@ -276,4 +306,120 @@ mod graphql_integration {
}
Ok(())
}
#[test(tokio::test)]
async fn config() -> Result<(), Box<dyn std::error::Error>> {
let (addr, _server) = common::start_server_gql_without_auth().await.unwrap();
let gql_url = &format!("http://{addr}/graphql");
let sql_url = &format!("http://{addr}/sql");
let mut headers = reqwest::header::HeaderMap::new();
let ns = Ulid::new().to_string();
let db = Ulid::new().to_string();
headers.insert("surreal-ns", ns.parse()?);
headers.insert("surreal-db", db.parse()?);
headers.insert(header::ACCEPT, "application/json".parse()?);
let client = reqwest::Client::builder()
.connect_timeout(Duration::from_millis(10))
.default_headers(headers)
.build()?;
{
let res = client.post(gql_url).body("").send().await?;
assert_eq!(res.status(), 400);
let body = res.text().await?;
assert!(body.contains("NotConfigured"));
}
// add schema and data
{
let res = client
.post(sql_url)
.body(
r#"
DEFINE CONFIG GRAPHQL AUTO;
DEFINE TABLE foo;
DEFINE FIELD val ON foo TYPE string;
DEFINE TABLE bar;
DEFINE FIELD val ON bar TYPE string;
"#,
)
.send()
.await?;
assert_eq!(res.status(), 200);
}
{
let res = client
.post(gql_url)
.body(json!({ "query": r#"{__schema {queryType {fields {name}}}}"# }).to_string())
.send()
.await?;
assert_eq!(res.status(), 200);
let body = res.text().await?;
let res_obj = serde_json::Value::from_str(&body).unwrap();
let fields = &res_obj["data"]["__schema"]["queryType"]["fields"];
let expected_fields = json!(
[
{
"name": "foo"
},
{
"name": "bar"
},
{
"name": "_get_foo"
},
{
"name": "_get_bar"
},
{
"name": "_get"
}
]
);
assert_equal_arrs!(fields, &expected_fields);
}
{
let res = client
.post(sql_url)
.body(
r#"
DEFINE CONFIG OVERWRITE GRAPHQL TABLES INCLUDE foo;
"#,
)
.send()
.await?;
assert_eq!(res.status(), 200);
}
{
let res = client
.post(gql_url)
.body(json!({ "query": r#"{__schema {queryType {fields {name}}}}"# }).to_string())
.send()
.await?;
assert_eq!(res.status(), 200);
let body = res.text().await?;
let res_obj = serde_json::Value::from_str(&body).unwrap();
let fields = &res_obj["data"]["__schema"]["queryType"]["fields"];
let expected_fields = json!(
[
{
"name": "foo"
},
{
"name": "_get_foo"
},
{
"name": "_get"
}
]
);
assert_equal_arrs!(fields, &expected_fields);
}
Ok(())
}
}