Function seed

tests/graph/benches/util.rs:289–403

(
    store: &mut PostgresStore<C>,
    account_id: ActorEntityUuid,
    data_types: D,
    property_types: P,
    entity_types: E,
)

}

pub async fn seed<D, P, E, C>(
    store: &mut PostgresStore<C>,
    account_id: ActorEntityUuid,
    data_types: D,
    property_types: P,
    entity_types: E,
) where
    D: IntoIterator<Item = &'static str, IntoIter: Send> + Send,
    P: IntoIterator<Item = &'static str, IntoIter: Send> + Send,
    E: IntoIterator<Item = &'static str, IntoIter: Send> + Send,
    C: AsClient,
{
    let domain_regex = Regex::new(
        &std::env::var("HASH_GRAPH_ALLOWED_URL_DOMAIN_PATTERN")
            .expect("HASH_GRAPH_ALLOWED_URL_DOMAIN_PATTERN must be set"),
    )
    .expect("HASH_GRAPH_ALLOWED_URL_DOMAIN_PATTERN must be a valid regex");

    store
        .create_data_types(
            account_id,
            data_types.into_iter().map(|data_type_str| {
                let schema: DataType =
                    serde_json::from_str(data_type_str).expect("could not parse data type");

                let ownership = if domain_regex.is_match(schema.id.base_url.as_str()) {
                    OntologyOwnership::Local {
                        web_id: WebId::new(account_id),
                    }
                } else {
                    OntologyOwnership::Remote {
                        fetched_at: OffsetDateTime::now_utc(),
                    }
                };

                CreateDataTypeParams {
                    schema,
                    ownership,
                    conflict_behavior: ConflictBehavior::Skip,
                    provenance: ProvidedOntologyEditionProvenance {
                        actor_type: ActorType::User,
                        origin: OriginProvenance::from_empty_type(OriginType::Api),
                        sources: Vec::new(),
                    },
                    conversions: HashMap::new(),
                }
            }),
        )
        .await
        .expect("should be able to create data types");

    store
        .create_property_types(
            account_id,
            property_types.into_iter().map(|property_type_str| {
                let schema: PropertyType =
                    serde_json::from_str(property_type_str).expect("could not parse property type");