Function query_entities

libs/@local/graph/api/src/rest/entity.rs:433–489

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

    )
)]
async fn query_entities<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<Box<RawJsonvalue>>,
) -> Result<Json<QueryEntitiesResponse<'static>>, BoxedResponse>
where
    S: StorePool + Send + Sync,
{
    if let Some(query_logger) = &mut query_logger {
        query_logger.capture(actor_id, OpenApiQuery::GetEntities(&request));
    }

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

    let request = QueryEntitiesRequest::deserialize(&*request)
        .map_err(Report::from)
        .attach(hash_status::StatusCode::InvalidArgument)
        .map_err(report_to_response)?;

    let (query, options) = 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_params(filter, api_config)
        .attach(hash_status::StatusCode::InvalidArgument)
        .map_err(report_to_response)?;

    let response = store
        .query_entities(actor_id, params)
        .await
        .map(Json)
        .map_err(report_to_response);

    if let Some(query_logger) = &mut query_logger {
        query_logger.send().await.map_err(report_to_response)?;
    }
    response
}