use generated::*;
use type_bridge::__codegen::{
CanonicalDouble, Date, DateTime, DateTimeTz, Decimal, Duration, HydratedPlayer, HydratedRow,
IntoEncodedScalar, materialize_model_for_test,
};
#[derive(type_bridge::SelectedRow)]
struct PersonEventRow {
person: Person,
event: Event,
}
#[derive(type_bridge::SelectedRow)]
struct PersonGraph {
person: Person,
events: Vec<Event>,
}
struct GeneratedLifecycleHook;
impl type_bridge::LifecycleHook for GeneratedLifecycleHook {
fn name(&self) -> &str {
"generated-lifecycle"
}
fn before_operation<'a>(
&'a self,
context: &'a mut type_bridge::HookContext<'_>,
) -> type_bridge::HookFuture<
'a,
std::result::Result<type_bridge::PreHookResult, type_bridge::HookError>,
> {
Box::pin(async move {
let _ = context.type_id_json();
let _ = context.type_name();
let _ = context.model_kind();
let _ = context.operation();
let _ = context.iid();
let _ = context.timestamp();
if let Some(input) = context.input() {
let _ = input.fields();
let _ = input.roles();
}
context.set_metadata("accepted", true);
Ok(type_bridge::PreHookResult::Continue)
})
}
fn after_operation<'a>(
&'a self,
context: &'a type_bridge::HookContext<'_>,
) -> type_bridge::HookFuture<'a, std::result::Result<(), type_bridge::HookError>> {
Box::pin(async move {
let _ = context.metadata().get("accepted");
Ok(())
})
}
}
async fn generated_manager_mutation_parity_compiles(
database: &type_bridge::Database<AppSchema>,
person_iid: String,
person_input: PersonCreate,
employment_iid: String,
employment_input: EmploymentCreate,
) -> type_bridge::Result<()> {
let mut people = database.entities::<Person>();
people.add_hook(std::sync::Arc::new(GeneratedLifecycleHook));
let _ = people
.update_many(vec![(person_iid.clone(), person_input)])
.await?;
people
.delete_many(std::slice::from_ref(&person_iid))
.await?;
let mut employments = database.relations::<Employment>();
employments.add_hook(std::sync::Arc::new(GeneratedLifecycleHook));
let _ = employments
.update_many(vec![(employment_iid.clone(), employment_input)])
.await?;
employments
.delete_many(std::slice::from_ref(&employment_iid))
.await
}
fn selected_shapes_compile(
session: &type_bridge::QuerySession<'_, AppSchema>,
person: type_bridge::Binding<AppSchema, Person>,
event: type_bridge::Binding<AppSchema, Event>,
) -> type_bridge::Result<()> {
let tuple = session.query((person, event))?;
let _ = tuple.allow_cross_join(person, event)?;
let _ = tuple.count_by(person);
let named = PersonEventRow::select(person, event)?;
let named_query = session.query(named)?;
let _ = named_query.exists_by(event);
let graph = PersonGraph::select(person, event.collect().distinct())?;
let graph_query = session.query(graph)?;
let _ = graph_query.page_by(person, type_bridge::PageOptions::new(10));
let sixteen = session.query((
person, event, person, event, person, event, person, event, person, event, person, event,
person, event, person, event,
))?;
let _ = sixteen.count_by(person);
Ok(())
}
fn bounded_reachability_compiles(
session: &type_bridge::QuerySession<'_, AppSchema>,
source: type_bridge::Binding<AppSchema, Person>,
target: type_bridge::Binding<AppSchema, Person>,
) -> type_bridge::Result<()> {
let reachable = session.reachable(
NetworkLinkType::TOKEN,
NetworkLinkType::origin,
NetworkLinkType::destination,
source,
target,
1,
2,
)?;
let _ = session.query((source, target))?.where_(reachable)?;
Ok(())
}
fn projected_function_call_compiles(
session: &type_bridge::QuerySession<'_, AppSchema>,
person: type_bridge::Binding<AppSchema, Person>,
minimum_value: &Score,
) -> type_bridge::Result<()> {
let minimum: IntegerInput = integer_input(session, minimum_value)?;
let score: IntegerCall = qualifying_score(session, person, &minimum)?;
let predicate = score.ge_field(person.field(PersonType::score));
let _ = session.query(person)?.where_(predicate)?;
let nested = qualifying_score(session, person, &score)?;
let _ = score.ge_call(&nested)?;
Ok(())
}
fn polymorphic_role_binding_modes_compile(
database: &type_bridge::Database<AppSchema>,
) -> type_bridge::Result<()> {
let mut session = database.query()?;
let actor = session.subtypes::<Actor>()?;
let interaction = session.exact::<Interaction>()?;
let predicate = interaction.role(InteractionType::actor).connects(actor)
& actor.field(ActorType::nickname).is_present();
let _ = session
.query(interaction)?
.match_(actor)?
.where_(predicate)?;
Ok(())
}
async fn reusable_read_context_compiles(
database: &type_bridge::Database<AppSchema>,
) -> type_bridge::Result<()> {
let read = database.read().await?;
let mut session = read.query();
let person = session.exact::<Person>()?;
let _ = session
.query(person)?
.where_(person.field(PersonType::score).is_present())?;
let _ = session.query(person)?.where_(person.iid("0x1"))?;
let _ = session
.query(person)?
.where_(person.iid_in(["0x1", "0x2"]))?;
let query = session.query(person)?;
let tuple_field_grouped = query.group_by_fields((
person.field(PersonType::val_bool),
person.field(PersonType::score),
))?;
let _: Vec<((ValBool, Score), (u64,))> = tuple_field_grouped
.aggregate((type_bridge::aggregate::count(),))
.await?;
let _ = query.count().await?;
let _ = query.exists().await?;
let _ = query.count().await?;
drop(query);
drop(session);
read.close().await
}
async fn canonical_manager_filters_compile(
database: &type_bridge::Database<AppSchema>,
) -> type_bridge::Result<()> {
let seven = FooBar::new(7).unwrap();
let forty = Score::new(40).unwrap();
let ada = Identifier::new("data-ada").unwrap();
let base = database.entities::<Person>().where_(
PersonType::foo__bar,
type_bridge::ProjectedManagerComparison::Gte,
&seven,
)?;
let sibling = base.where_(
PersonType::score,
type_bridge::ProjectedManagerComparison::Gt,
&forty,
)?;
let _: Vec<Person> = base.all().await?;
let _: u64 = sibling.count().await?;
let _: bool = sibling.exists().await?;
let _: Option<Person> = database
.entities::<Person>()
.where_(
PersonType::identifier,
type_bridge::ProjectedManagerComparison::Eq,
&ada,
)?
.first()
.await?;
let read = database.read().await?;
let borrowed = read.entities::<Person>().where_(
PersonType::foo__bar,
type_bridge::ProjectedManagerComparison::Eq,
&seven,
)?;
let _: Vec<Person> = borrowed.all().await?;
let _: u64 = borrowed.count().await?;
let _: bool = borrowed.exists().await?;
let _: Option<Person> = read
.entities::<Person>()
.where_(
PersonType::identifier,
type_bridge::ProjectedManagerComparison::Eq,
&ada,
)?
.first()
.await?;
let _: u64 = read.relations::<Interaction>().filter()?.count().await?;
drop(borrowed);
read.close().await
}
struct RemoteTransport;
impl type_bridge::RemoteQueryTransport for RemoteTransport {
fn capabilities(
&self,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = type_bridge::Result<Vec<u8>>> + Send + '_>,
> {
Box::pin(async {
Err(type_bridge::Error::Other {
message: "compile-only transport".into(),
source: None,
})
})
}
fn exchange<'a>(
&'a self,
_request: &'a [u8],
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = type_bridge::Result<Vec<u8>>> + Send + 'a>,
> {
Box::pin(async {
Err(type_bridge::Error::Other {
message: "compile-only transport".into(),
source: None,
})
})
}
}
async fn remote_generated_outputs_compile() -> type_bridge::Result<()> {
let options = type_bridge::RemoteConnectionOptions::generated(
type_bridge::RemoteQueryLimits::new(100, 1 << 20, 100, 1000, 1000, 1000),
RemoteTransport,
);
let remote: type_bridge::RemoteDatabase<AppSchema> =
type_bridge::RemoteDatabase::connect(options)
.await?
.with_schema(SCHEMA)?;
let mut session = remote.query()?;
let person = session.exact::<Person>()?;
let event = session.exact::<Event>()?;
let tuple = session.query((person, event))?;
let tuple = tuple.allow_cross_join(person, event)?;
let _rows: Vec<(Person, Event)> = tuple.rows(type_bridge::RowsOptions::new(10)).await?;
let graph = PersonGraph::select(person, event.collect())?;
let page: type_bridge::Page<PersonGraph> = session
.query(graph)?
.page_by(person, type_bridge::PageOptions::new(10))
.await?;
let _ = page.items();
Ok(())
}
fn assert_nominal_upcast<T: NominalUpcast<Membership>>() {}
fn assert_role_upcast<T: RoleUpcast<EmploymentEmployeePlayer, MembershipMemberPlayer>>() {}
fn main() -> Result<(), Box<dyn std::error::Error>> {
assert_nominal_upcast::<Employment>();
assert_role_upcast::<Employment>();
let neg_zero = CanonicalDouble::try_new(-0.0)?;
let pos_zero = CanonicalDouble::try_new(0.0)?;
assert_ne!(neg_zero.to_bits(), pos_zero.to_bits());
let identifier = Identifier::new("person-1")?;
let nickname = Nickname::new("Ada")?;
let alias = Aliases::new("engineer")?;
let score = Score::new(42i64)?;
let score_bytes = SCHEMA.encode_attribute(score.clone())?;
let decoded_score: Score = SCHEMA.decode_attribute(&score_bytes)?;
assert_eq!(decoded_score.value(), &42);
assert!(
SCHEMA
.decode_attribute::<CounterValue>(&score_bytes)
.is_err()
);
let v_double = ValDouble::new(CanonicalDouble::try_new(3.14)?)?;
let v_decimal = ValDecimal::new(Decimal::try_new("123.45")?)?;
let v_bool = ValBool::new(true)?;
let v_date = ValDate::new(Date::try_new("2026-07-28")?)?;
let v_datetime = ValDatetime::new(DateTime::try_new("2026-07-28T03:55:00")?)?;
let v_datetimetz = ValDatetimeTz::new(DateTimeTz::try_new("2026-07-28T03:55:00Z")?)?;
let v_duration = ValDuration::new(Duration::try_new("P1D")?)?;
let v_constrained = ValConstrained::new(50i64)?;
let person_create = PersonCreate::new(
vec![alias.clone(), alias.clone()],
None,
identifier.clone(),
Some(nickname),
score.clone(),
None,
v_bool.clone(),
v_constrained.clone(),
v_date.clone(),
v_datetime.clone(),
v_datetimetz.clone(),
v_decimal.clone(),
v_double.clone(),
v_duration.clone(),
)?;
assert_eq!(person_create.aliases().len(), 2);
use type_bridge::__codegen::{
DecodedCreate, IntoEncodedCreate, MaterializeCreate, ValidationPath,
};
let encoded = person_create.clone().into_encoded_create()?;
let fields: Vec<_> = encoded
.fields()
.iter()
.map(|(token, values)| ((*token).to_owned(), values.clone()))
.collect();
let valid = DecodedCreate::new(Person::TYPE_ID_JSON.to_owned(), fields.clone(), vec![]);
let materialized = PersonCreate::materialize_create(&valid, &ValidationPath::root())?;
assert_eq!(materialized.identifier().value(), "person-1");
let mut duplicates = fields.clone();
duplicates.push(fields[0].clone());
let duplicate = DecodedCreate::new(Person::TYPE_ID_JSON.to_owned(), duplicates, vec![]);
assert_eq!(
PersonCreate::materialize_create(&duplicate, &ValidationPath::root())
.unwrap_err()
.code(),
"duplicate_scalar_evidence"
);
let mut unexpected = fields;
unexpected.push(("unexpected".to_owned(), vec![]));
let unexpected = DecodedCreate::new(Person::TYPE_ID_JSON.to_owned(), unexpected, vec![]);
assert_eq!(
PersonCreate::materialize_create(&unexpected, &ValidationPath::root())
.unwrap_err()
.code(),
"unexpected_field_evidence"
);
let role = ContainerType::item.role_id_json().to_owned();
let duplicate = DecodedCreate::new(
Container::TYPE_ID_JSON.to_owned(),
vec![],
vec![(role.clone(), vec![]), (role.clone(), vec![])],
);
assert_eq!(
ContainerCreate::materialize_create(&duplicate, &ValidationPath::root())
.unwrap_err()
.code(),
"duplicate_role_evidence"
);
let unexpected = DecodedCreate::new(
Container::TYPE_ID_JSON.to_owned(),
vec![],
vec![("unexpected".to_owned(), vec![])],
);
assert_eq!(
ContainerCreate::materialize_create(&unexpected, &ValidationPath::root())
.unwrap_err()
.code(),
"unexpected_role_evidence"
);
let valid = DecodedCreate::new(
Container::TYPE_ID_JSON.to_owned(),
vec![],
vec![(role, vec![])],
);
ContainerCreate::materialize_create(&valid, &ValidationPath::root())?;
let person_create_bytes = SCHEMA.encode_create(person_create.clone())?;
let decoded_person_create: PersonCreate = SCHEMA.decode_create(&person_create_bytes)?;
assert_eq!(decoded_person_create.identifier().value(), "person-1");
assert_eq!(decoded_person_create.aliases().len(), 2);
assert!(decoded_person_create.nickname().is_some());
assert!(
SCHEMA
.decode_create::<CounterCreate>(&person_create_bytes)
.is_err()
);
let id_scalar = identifier.value().into_encoded_scalar();
let score_scalar = score.value().into_encoded_scalar();
let double_scalar = v_double.value().into_encoded_scalar();
let decimal_scalar = v_decimal.value().into_encoded_scalar();
let bool_scalar = v_bool.value().into_encoded_scalar();
let date_scalar = v_date.value().into_encoded_scalar();
let datetime_scalar = v_datetime.value().into_encoded_scalar();
let datetimetz_scalar = v_datetimetz.value().into_encoded_scalar();
let duration_scalar = v_duration.value().into_encoded_scalar();
let constrained_scalar = v_constrained.value().into_encoded_scalar();
let person_row = HydratedRow::new(
Person::TYPE_ID_JSON,
"0x1".to_owned(),
vec![
(
PersonType::identifier.owns_id_json(),
vec![id_scalar.clone()],
),
(PersonType::score.owns_id_json(), vec![score_scalar]),
(PersonType::val_double.owns_id_json(), vec![double_scalar]),
(PersonType::val_decimal.owns_id_json(), vec![decimal_scalar]),
(PersonType::val_bool.owns_id_json(), vec![bool_scalar]),
(PersonType::val_date.owns_id_json(), vec![date_scalar]),
(
PersonType::val_datetime.owns_id_json(),
vec![datetime_scalar],
),
(
PersonType::val_datetime_tz.owns_id_json(),
vec![datetimetz_scalar],
),
(
PersonType::val_duration.owns_id_json(),
vec![duration_scalar],
),
(
PersonType::val_constrained.owns_id_json(),
vec![constrained_scalar],
),
],
vec![],
);
let person: Person = materialize_model_for_test(&person_row)?;
assert_eq!(person.iid(), "0x1");
let person_debug = format!("{person:?}");
assert!(person_debug.starts_with("Person { iid:"));
assert!(!person_debug.contains("__tb_origin"));
assert!(!person_debug.contains("ReferenceOrigin"));
let person_snapshot_bytes = SCHEMA.encode_snapshot(person.clone())?;
let decoded_person: Person = SCHEMA.decode_snapshot(&person_snapshot_bytes)?;
assert_eq!(decoded_person.iid(), "0x1");
assert_eq!(decoded_person.identifier().value(), "person-1");
assert!(
SCHEMA
.decode_snapshot::<Event>(&person_snapshot_bytes)
.is_err()
);
let person_ref = person.reference();
assert_eq!(person_ref.iid(), Some("0x1"));
let person_ref_debug = format!("{person_ref:?}");
assert!(person_ref_debug.starts_with("PersonRef { iid:"));
assert!(!person_ref_debug.contains("__tb_origin"));
assert!(!person_ref_debug.contains("ReferenceOrigin"));
let key_ref = PersonRef::from_key(identifier)?;
assert_eq!(key_ref.iid(), None);
assert_eq!(key_ref.identifier().unwrap().value(), "person-1");
let key_ref_bytes = SCHEMA.encode_reference(key_ref.clone())?;
let decoded_key_ref: PersonRef = SCHEMA.decode_reference(&key_ref_bytes)?;
assert_eq!(decoded_key_ref.iid(), None);
assert_eq!(decoded_key_ref.identifier().unwrap().value(), "person-1");
assert!(SCHEMA.decode_reference::<EventRef>(&key_ref_bytes).is_err());
let person_player_evidence = HydratedPlayer::from_complete_row(person_row);
let event_row = HydratedRow::new(
Event::TYPE_ID_JSON,
"event-iid-1".to_owned(),
vec![],
vec![(
EventType::subject.role_id_json(),
vec![person_player_evidence.clone()],
)],
);
let event: Event = materialize_model_for_test(&event_row)?;
assert_eq!(event.iid(), "event-iid-1");
let event_reference = EventRef::from_iid("event-iid")?;
let container = ContainerCreate::new(vec![event_reference])?;
assert_eq!(container.item().len(), 1);
let employment = EmploymentCreate::new(person_ref)?;
assert_eq!(
employment.employee().identifier().unwrap().value(),
"person-1"
);
let plain_activity = PlainActivityCreate::new(person.reference())?;
assert_eq!(
plain_activity.participant().identifier().unwrap().value(),
"person-1"
);
let counter = CounterCreate::new(CounterValue::new(1)?)?;
assert_eq!(counter.counter_value().value(), &1);
let emp_row = HydratedRow::new(
Employment::TYPE_ID_JSON,
"emp-iid-1".to_owned(),
vec![],
vec![(
EmploymentType::employee.role_id_json(),
vec![person_player_evidence],
)],
);
let emp_read: Employment = materialize_model_for_test(&emp_row)?;
let family = MembershipFamily::Employment(emp_read);
assert_eq!(family.iid(), "emp-iid-1");
assert!(family.as_employment().is_some());
let role: RoleToken<Container, ContainerItemPlayer> = ContainerType::item;
assert!(role.role_id_json().contains("item"));
let _: PlaysToken<Event, Container, ContainerItemPlayer> = plays_event_container_item;
let _: FunctionToken<AppSchema, (Event,), Stream<Event>> = find_events;
let stats = PlayerStats::try_new(Some("stable".to_owned()), 3);
assert_eq!(*stats.wins(), 3);
let stats_bytes = SCHEMA.encode_struct(stats)?;
let decoded_stats: PlayerStats = SCHEMA.decode_struct(&stats_bytes)?;
assert_eq!(decoded_stats.nickname().map(String::as_str), Some("stable"));
assert_eq!(*decoded_stats.wins(), 3);
assert!(
SCHEMA
.decode_struct::<PlayerStats>(&person_snapshot_bytes)
.is_err()
);
let archive_bytes = SCHEMA.encode_archive([
score_bytes.as_slice(),
person_create_bytes.as_slice(),
key_ref_bytes.as_slice(),
person_snapshot_bytes.as_slice(),
stats_bytes.as_slice(),
])?;
let archive_records = SCHEMA.decode_archive(&archive_bytes)?;
assert_eq!(
archive_records,
vec![
score_bytes,
person_create_bytes,
key_ref_bytes,
person_snapshot_bytes,
stats_bytes,
]
);
let _: Score = SCHEMA.decode_attribute(&archive_records[0])?;
let _: PersonCreate = SCHEMA.decode_create(&archive_records[1])?;
let _: PersonRef = SCHEMA.decode_reference(&archive_records[2])?;
let _: Person = SCHEMA.decode_snapshot(&archive_records[3])?;
let _: PlayerStats = SCHEMA.decode_struct(&archive_records[4])?;
assert_eq!(PLAYING_FACTS.len(), 12);
assert!(RUNTIME_PROJECTION_JSON.contains("validated-create-input"));
assert!(
MODEL_LINK_COMPONENTS
.iter()
.any(|component| component.len() > 1)
);
Ok(())
}