SUBSTRATEDB

import {
  defineModule, entity, relation,
  ref, optionalProperty, s
} from "./sdk/typescript/schema.js";

const fitness = defineModule({
  namespace: "fitness",
  version: 1,
  imports: { core: 1 },
  entities: {
    Workout: entity({
      durationMinutes: s.int64()
    })
  },
  relations: {
    Performed: relation({
      athlete: ref("core.Person"),
      workout: ref("fitness.Workout")
    }),
    // Extend the existing Person.
    TrainingGoal: optionalProperty(
      "core.Person", s.string()
    )
  }
});

import { Person, TrainingGoal } from "./generated/schema.js";
import { table, select, eq } from "./sdk/typescript/query.js";

// Give an existing person new, typed memory.
await client.insert(TrainingGoal, {
  person: alice.id,
  value: "Run my first 10K"
});

// Read it back together with their shared identity.
const person = table(Person, "p");
const goal = table(TrainingGoal, "g");

const memory = await select({
  name: person.c.name,
  goal: goal.c.value
})
  .from(person)
  .innerJoin(goal, eq(goal.c.person, person.c.id))
  .where(eq(person.c.id, alice.id))
  .execute(client);

// [{ name: "Alice", goal: "Run my first 10K" }]

-- Combine identity, agent memory and activity.
SELECT p.name, g.value AS goal, w.durationMinutes
FROM core.Person p
JOIN fitness.TrainingGoal g ON g.person = p.id
JOIN fitness.Performed f ON f.athlete = p.id
JOIN fitness.Workout w ON w.id = f.workout
WHERE p.id = ?;

-- Bind Alice's existing UUID as the parameter.

use substrate_liquid::{DataType::*, Module, Relation, Role};

let workout = Relation::new("fitness.Workout", vec![
    Role::new("durationMinutes", Int),
]);

let performed = Relation::new("fitness.Performed", vec![
    Role::new("athlete", Ref("core.Person".into())),
    Role::new("workout", Ref("fitness.Workout".into())),
]);

let goal = Relation::new("fitness.TrainingGoal", vec![
    Role::new("person", Ref("core.Person".into())),
    Role::new("value", Text),
]).unique(&["person"]);

let fitness = Module::new(
    "fitness", 1,
    vec![("core".into(), 1)],
    vec![workout, performed, goal],
);

use substrate_liquid::{Result, RetryPolicy, Session, TypedId};
use generated::{core::Person, fitness::{Workout, Performed}};

fn log_workout(
    fitness: &Session, alice: TypedId<Person>,
) -> Result<Option<Workout>> {
    // The workout and its link commit together.
    let workout = fitness.transact(RetryPolicy::default(), |tx| {
        let workout = tx.insert_record(Workout {
            durationMinutes: 45,
        })?;
        tx.insert_record(Performed {
            athlete: alice,
            workout,
        })?;
        Ok(workout)
    })?;

    // TypedId<Workout> selects the generated decoder.
    fitness.snapshot().get_record(workout)
}