use std::{borrow::Cow, collections::HashMap, sync::Arc};
use super::{COMPOSED_DOCUMENT_KEY as COMPOSED_DOCUMENT, COMPOSED_EMBEDS_KEY as COMPOSED_EMBEDS};
#[cfg(test)]
mod tests;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DecimalNode {
Decimal,
Object(String),
Abstract(Option<String>),
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct DecimalFields(HashMap<String, DecimalNode>);
impl DecimalFields {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn insert(&mut self, key: impl Into<String>, node: DecimalNode) {
self.0.insert(key.into(), node);
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
fn get(&self, key: &str) -> Option<&DecimalNode> {
self.0.get(key)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DecimalShape {
root: DecimalNode,
types: Arc<HashMap<String, DecimalFields>>,
}
impl DecimalShape {
#[must_use]
pub const fn new(root: DecimalNode, types: Arc<HashMap<String, DecimalFields>>) -> Self {
Self { root, types }
}
#[must_use]
pub const fn root(&self) -> &DecimalNode {
&self.root
}
#[must_use]
pub fn at_field(&self, key: &str) -> Option<Self> {
let DecimalNode::Object(type_name) = &self.root else {
return None;
};
let node = self.fields(type_name)?.get(key)?;
Some(Self::new(node.clone(), Arc::clone(&self.types)))
}
fn fields(&self, type_name: &str) -> Option<&DecimalFields> {
self.types.get(type_name)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct WriteDecimals {
types: Arc<HashMap<String, DecimalFields>>,
entity: Option<DecimalNode>,
error: Option<DecimalNode>,
result: Option<DecimalNode>,
}
impl WriteDecimals {
#[must_use]
pub const fn new(types: Arc<HashMap<String, DecimalFields>>) -> Self {
Self {
types,
entity: None,
error: None,
result: None,
}
}
#[must_use]
pub fn with_entity(mut self, node: Option<DecimalNode>) -> Self {
self.entity = node;
self
}
#[must_use]
pub fn with_error(mut self, node: Option<DecimalNode>) -> Self {
self.error = node;
self
}
#[must_use]
pub fn with_result(mut self, node: Option<DecimalNode>) -> Self {
self.result = node;
self
}
#[must_use]
pub fn column(&self, column: &str, stamp: Option<&str>) -> Option<WriteColumn> {
let stamped = |fallback: &Option<DecimalNode>| {
stamp
.map(|name| DecimalNode::Object(name.to_string()))
.or_else(|| fallback.clone())
};
let (root, cascade) = match column {
WRITE_ENTITY => (stamped(&self.entity)?, false),
WRITE_ERROR => (stamped(&self.error)?, false),
WRITE_RESULT => (self.result.clone()?, false),
WRITE_CASCADE => (DecimalNode::Abstract(None), true),
_ => return None,
};
let shape = DecimalShape::new(root, Arc::clone(&self.types));
Some(if cascade {
WriteColumn::Cascade(shape)
} else {
WriteColumn::Document(shape)
})
}
#[must_use]
pub fn document(&self, type_name: &str) -> DecimalShape {
DecimalShape::new(DecimalNode::Object(type_name.to_string()), Arc::clone(&self.types))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum WriteColumn {
Document(DecimalShape),
Cascade(DecimalShape),
}
const WRITE_ENTITY: &str = "entity";
const WRITE_ERROR: &str = "error_detail";
const WRITE_RESULT: &str = "result";
const WRITE_CASCADE: &str = "cascade";
const CASCADE_UPDATED: &str = "updated";
const CASCADE_ENTITY: &str = "entity";
const MAX_OBJECT_DEPTH: usize = 128;
const MAX_LIST_DEPTH: usize = 32;
pub fn quote_decimals(src: &[u8], shape: &DecimalShape, out: &mut Vec<u8>) {
out.reserve(src.len() + 16);
let end = Scan {
src,
out,
shape,
objects: 0,
}
.value(skip_ws(src, 0), Some(&shape.root), 0);
out.extend_from_slice(src.get(end..).unwrap_or_default());
}
pub fn quote_composed_decimals(src: &[u8], shape: &DecimalShape, out: &mut Vec<u8>) {
out.reserve(src.len() + 16);
let end = Scan {
src,
out,
shape,
objects: 0,
}
.composed(skip_ws(src, 0), Some(&shape.root));
out.extend_from_slice(src.get(end..).unwrap_or_default());
}
pub fn quote_cascade_decimals(src: &[u8], shape: &DecimalShape, out: &mut Vec<u8>) {
out.reserve(src.len() + 16);
let end = Scan {
src,
out,
shape,
objects: 0,
}
.cascade(skip_ws(src, 0));
out.extend_from_slice(src.get(end..).unwrap_or_default());
}
struct Scan<'s, 'o> {
src: &'s [u8],
out: &'o mut Vec<u8>,
shape: &'s DecimalShape,
objects: usize,
}
impl<'s> Scan<'s, '_> {
fn value(&mut self, at: usize, node: Option<&DecimalNode>, lists: usize) -> usize {
match (self.src.get(at), node) {
(Some(_), Some(DecimalNode::Decimal)) => self.decimal(at),
(Some(b'['), Some(node)) if lists < MAX_LIST_DEPTH => self.list(at, node, lists + 1),
(Some(b'{'), Some(DecimalNode::Object(type_name))) => {
self.object(at, self.shape.fields(type_name))
},
(Some(b'{'), Some(DecimalNode::Abstract(fallback))) => {
let fields = match concrete_type(self.src, at) {
Some(name) => self.shape.fields(&name),
None => fallback.as_deref().and_then(|name| self.shape.fields(name)),
};
self.object(at, fields)
},
_ => self.copy(at),
}
}
fn copy(&mut self, at: usize) -> usize {
let end = end_of_value(self.src, at);
self.out.extend_from_slice(&self.src[at..end]);
end
}
fn decimal(&mut self, at: usize) -> usize {
let end = end_of_value(self.src, at);
let mut i = at;
while i < end {
match self.src[i] {
b'"' => {
let close = end_of_string(self.src, i);
self.out.extend_from_slice(&self.src[i..close]);
i = close;
},
b'-' | b'0'..=b'9' => {
let close = end_of_scalar(self.src, i);
self.out.push(b'"');
self.out.extend_from_slice(&self.src[i..close]);
self.out.push(b'"');
i = close;
},
b => {
self.out.push(b);
i += 1;
},
}
}
end
}
fn list(&mut self, at: usize, node: &DecimalNode, lists: usize) -> usize {
self.each_item(at, |scan, i| scan.value(i, Some(node), lists))
}
fn object(&mut self, at: usize, fields: Option<&'s DecimalFields>) -> usize {
let Some(fields) = fields.filter(|_| self.objects < MAX_OBJECT_DEPTH) else {
return self.copy(at);
};
self.objects += 1;
let end = self.members(at, fields);
self.objects -= 1;
end
}
fn members(&mut self, at: usize, fields: &'s DecimalFields) -> usize {
self.each_member(at, |scan, key, i| scan.value(i, key.and_then(|k| fields.get(k)), 0))
}
fn composed(&mut self, at: usize, node: Option<&'s DecimalNode>) -> usize {
if self.src.get(at) != Some(&b'{') || self.objects >= MAX_OBJECT_DEPTH {
return self.copy(at);
}
let parent = self.embedding_fields(at, node);
self.objects += 1;
let end = self.each_member(at, |scan, key, i| match key {
Some(COMPOSED_DOCUMENT) => scan.value(i, node, 0),
Some(COMPOSED_EMBEDS) => scan.embeds(i, parent),
_ => scan.copy(i),
});
self.objects -= 1;
end
}
fn embeds(&mut self, at: usize, parent: Option<&'s DecimalFields>) -> usize {
let Some(parent) = parent.filter(|_| self.src.get(at) == Some(&b'{')) else {
return self.copy(at);
};
self.each_member(at, |scan, key, i| {
let child = key.and_then(|k| parent.get(k));
match scan.src.get(i) {
Some(b'[') if child.is_some() => scan.composed_list(i, child),
Some(b'{') if child.is_some() => scan.composed(i, child),
_ => scan.copy(i),
}
})
}
fn composed_list(&mut self, at: usize, node: Option<&'s DecimalNode>) -> usize {
self.each_item(at, |scan, i| scan.composed(i, node))
}
fn cascade(&mut self, at: usize) -> usize {
if self.src.get(at) != Some(&b'{') {
return self.copy(at);
}
self.each_member(at, |scan, key, i| match (key, scan.src.get(i)) {
(Some(CASCADE_UPDATED), Some(b'[')) => {
scan.each_item(i, |scan, i| scan.cascade_entry(i))
},
_ => scan.copy(i),
})
}
fn cascade_entry(&mut self, at: usize) -> usize {
let shape: &'s DecimalShape = self.shape;
let fields = concrete_type(self.src, at).and_then(|name| shape.fields(&name));
if fields.is_none() {
return self.copy(at);
}
self.each_member(at, |scan, key, i| match (key, scan.src.get(i)) {
(Some(CASCADE_ENTITY), Some(b'{')) => scan.object(i, fields),
_ => scan.copy(i),
})
}
fn each_item(
&mut self,
at: usize,
mut on_item: impl FnMut(&mut Self, usize) -> usize,
) -> usize {
self.out.push(b'[');
let mut i = at + 1;
loop {
i = self.whitespace(i);
match self.src.get(i) {
Some(b']') => {
self.out.push(b']');
return i + 1;
},
Some(b',') => {
self.out.push(b',');
i += 1;
},
Some(_) => i = on_item(self, i),
None => return i,
}
}
}
fn embedding_fields(&self, at: usize, node: Option<&DecimalNode>) -> Option<&'s DecimalFields> {
let shape: &'s DecimalShape = self.shape;
match node? {
DecimalNode::Object(name) => shape.fields(name),
DecimalNode::Abstract(fallback) => {
let named = member_value(self.src, at, COMPOSED_DOCUMENT)
.and_then(|document| concrete_type(self.src, document));
match named {
Some(name) => shape.fields(&name),
None => shape.fields(fallback.as_deref()?),
}
},
DecimalNode::Decimal => None,
}
}
fn each_member(
&mut self,
at: usize,
mut on_value: impl FnMut(&mut Self, Option<&str>, usize) -> usize,
) -> usize {
self.out.push(b'{');
let mut i = at + 1;
loop {
i = self.whitespace(i);
match self.src.get(i) {
Some(b'}') => {
self.out.push(b'}');
return i + 1;
},
Some(b',') => {
self.out.push(b',');
i += 1;
},
Some(b'"') => {
let close = end_of_string(self.src, i);
self.out.extend_from_slice(&self.src[i..close]);
let key = string_text(&self.src[i..close]);
i = self.whitespace(close);
if self.src.get(i) == Some(&b':') {
self.out.push(b':');
i = self.whitespace(i + 1);
}
i = on_value(self, key.as_deref(), i);
},
Some(_) => return self.copy_rest(i),
None => return i,
}
}
}
fn whitespace(&mut self, at: usize) -> usize {
let end = skip_ws(self.src, at);
self.out.extend_from_slice(&self.src[at..end]);
end
}
fn copy_rest(&mut self, at: usize) -> usize {
self.out.extend_from_slice(&self.src[at..]);
self.src.len()
}
}
fn concrete_type(src: &[u8], at: usize) -> Option<Cow<'_, str>> {
let value = member_value(src, at, "__typename")?;
string_text(&src[value..end_of_value(src, value)])
}
fn member_value(src: &[u8], at: usize, key: &str) -> Option<usize> {
if src.get(at) != Some(&b'{') {
return None;
}
let mut i = at + 1;
loop {
i = skip_ws(src, i);
match src.get(i)? {
b',' => i += 1,
b'"' => {
let close = end_of_string(src, i);
let found = string_text(&src[i..close]).as_deref() == Some(key);
i = skip_ws(src, close);
if src.get(i) == Some(&b':') {
i = skip_ws(src, i + 1);
}
if found {
return Some(i);
}
i = end_of_value(src, i);
},
_ => return None,
}
}
}
fn string_text(token: &[u8]) -> Option<Cow<'_, str>> {
let inner = token.strip_prefix(b"\"").and_then(|t| t.strip_suffix(b"\""))?;
if inner.contains(&b'\\') {
serde_json::from_slice::<String>(token).ok().map(Cow::Owned)
} else {
std::str::from_utf8(inner).ok().map(Cow::Borrowed)
}
}
fn skip_ws(src: &[u8], mut i: usize) -> usize {
while matches!(src.get(i), Some(b' ' | b'\n' | b'\r' | b'\t')) {
i += 1;
}
i
}
fn end_of_string(src: &[u8], at: usize) -> usize {
let mut i = at + 1;
while let Some(&b) = src.get(i) {
match b {
b'\\' => i += 2,
b'"' => return i + 1,
_ => i += 1,
}
}
src.len()
}
fn end_of_scalar(src: &[u8], at: usize) -> usize {
let mut i = at;
while matches!(src.get(i), Some(b'0'..=b'9' | b'-' | b'+' | b'.' | b'e' | b'E' | b'a'..=b'z')) {
i += 1;
}
i.max(at + 1).min(src.len())
}
fn end_of_value(src: &[u8], at: usize) -> usize {
match src.get(at) {
Some(b'"') => end_of_string(src, at),
Some(b'{' | b'[') => {
let mut depth = 0_usize;
let mut i = at;
while let Some(&b) = src.get(i) {
match b {
b'"' => {
i = end_of_string(src, i);
continue;
},
b'{' | b'[' => depth += 1,
b'}' | b']' => {
depth -= 1;
if depth == 0 {
return i + 1;
}
},
_ => {},
}
i += 1;
}
src.len()
},
Some(_) => end_of_scalar(src, at),
None => at,
}
}