Function query_entity_subgraph

libs/@local/graph/api/src/rest/entity.rs:576–638

(
    AuthenticatedUserHeader(actor_id): AuthenticatedUserHeader,
    InteractiveHeader(interactive): InteractiveHeader,
    store_pool: Extension<Arc<S>>,
    temporal_client: Extension<Option<Arc<Te

    )
)]
async fn query_entity_subgraph<S>(
    AuthenticatedUserHeader(actor_id): AuthenticatedUserHeader,
    InteractiveHeader(interactive): InteractiveHeader,
    store_pool: Extension<Arc<S>>,
    temporal_client: Extension<Option<Arc<TemporalClient>>>,
    Extension(api_config): Extension<ApiConfig>,
    mut query_logger: Option<Extension<QueryLogger>>,
    Json(request): Json<serde_json::Value>,
) -> Result<Json<QueryEntitySubgraphResponse<'static>>, BoxedResponse>
where
    S: StorePool + Send + Sync,
{
    if let Some(query_logger) = &mut query_logger {
        query_logger.capture(actor_id, OpenApiQuery::GetEntitySubgraph(&request));
    }

    let store = store_pool
        .acquire(temporal_client.0)
        .await
        .map_err(report_to_response)?;

    let request = QueryEntitySubgraphRequest::deserialize(&request)
        .map_err(Report::from)
        .attach(hash_status::StatusCode::InvalidArgument)
        .map_err(report_to_response)?;
    let (query, options, traversal) = request.into_parts();

    // TODO: https://linear.app/hash/issue/H-5351/reuse-parts-between-compilation-units
    let mut heap = Heap::uninitialized();

    if matches!(query, EntityQuery::Query { .. }) {
        // The heap is going to be used in the compilation of the query and therefore needs to be
        // primed.
        // Doing this in a separate step allows us to be allocation free when not using HashQL
        // queries.
        heap.prime();
    }

    let filter = query.compile(&heap, CompilationOptions { interactive })?;

    let params = options
        .into_traversal_params(filter, traversal, api_config)
        .attach(hash_status::StatusCode::InvalidArgument)
        .map_err(report_to_response)?;

    let response = store
        .query_entity_subgraph(actor_id, params)
        .await
        .map(|response| {
            Json(QueryEntitySubgraphResponse {
                subgraph: response.subgraph.into(),
                cursor: response.cursor.map(EntityQueryCursor::into_owned),
                closed_multi_entity_types: response.closed_multi_entity_types,
                definitions: response.definitions,
                entity_permissions: response.entity_permissions,
            })
        })
        .map_err(report_to_response);