core_crypto_macros/entity_derive/
mod.rsmod derive_impl;
mod parse;
use proc_macro2::Ident;
pub(super) struct KeyStoreEntity {
struct_name: Ident,
collection_name: String,
id: IdColumn,
columns: Columns,
no_upsert: bool,
}
impl KeyStoreEntity {
pub(super) fn flatten(self) -> KeyStoreEntityFlattened {
let all_columns = self
.columns
.0
.iter()
.map(|column| column.name.clone())
.collect::<Vec<_>>();
let blob_columns = self
.columns
.0
.iter()
.filter(|column| column.column_type == ColumnType::Bytes)
.map(|column| column.name.clone())
.collect::<Vec<_>>();
let optional_blob_columns = self
.columns
.0
.iter()
.filter(|column| column.column_type == ColumnType::OptionalBytes)
.map(|column| column.name.clone())
.collect::<Vec<_>>();
let all_column_names = all_columns.iter().map(ToString::to_string).collect();
let blob_column_names = blob_columns.iter().map(ToString::to_string).collect();
let optional_blob_column_names = optional_blob_columns.iter().map(ToString::to_string).collect();
let id = self.id.name;
let id_name = self.id.column_name.unwrap_or_else(|| id.to_string());
let id_type = self.id.column_type;
KeyStoreEntityFlattened {
struct_name: self.struct_name,
collection_name: self.collection_name,
no_upsert: self.no_upsert,
id,
id_type,
id_name,
id_transformation: self.id.transformation,
all_columns,
all_column_names,
blob_columns,
blob_column_names,
optional_blob_columns,
optional_blob_column_names,
}
}
}
pub(super) struct KeyStoreEntityFlattened {
struct_name: Ident,
collection_name: String,
id: Ident,
id_name: String,
id_type: IdColumnType,
id_transformation: Option<IdTransformation>,
all_columns: Vec<Ident>,
all_column_names: Vec<String>,
blob_columns: Vec<Ident>,
blob_column_names: Vec<String>,
optional_blob_columns: Vec<Ident>,
optional_blob_column_names: Vec<String>,
no_upsert: bool,
}
#[derive(PartialEq, Eq)]
enum IdColumnType {
String,
Bytes,
}
struct IdColumn {
name: Ident,
column_type: IdColumnType,
column_name: Option<String>,
transformation: Option<IdTransformation>,
}
enum IdTransformation {
Hex,
#[expect(dead_code)]
Sha256,
}
struct Columns(Vec<Column>);
struct Column {
name: Ident,
column_type: ColumnType,
}
#[derive(PartialEq, Eq)]
enum ColumnType {
String,
Bytes,
OptionalBytes,
}