Method query_analytics_events

src/global_db.rs:2299–2357

(
        &self,
        query: &AnalyticsEventQuery,
    )

    }

    pub async fn query_analytics_events(
        &self,
        query: &AnalyticsEventQuery,
    ) -> Result<Vec<AnalyticsEventRecord>, String> {
        if query.limit == 0 {
            return Ok(Vec::new());
        }

        let mut sql = String::from(
            "SELECT id, provider, project_id, session_id, timestamp, event_kind,
                    hook_name, tool_name, tool_category, skill_name, hint_category,
                    hint_id, outcome, metadata_json
             FROM analytics_events",
        );
        let mut clauses = Vec::new();
        let mut values = Vec::new();
        for (column, value) in [
            ("provider", query.provider.as_deref()),
            ("project_id", query.project_id.as_deref()),
            ("session_id", query.session_id.as_deref()),
            ("event_kind", query.event_kind.as_deref()),
        ] {
            push_optional_analytics_filter(&mut clauses, &mut values, column, value);
        }
        if let Some(since) = query.since {
            values.push(Value::Integer(since));
            clauses.push(format!("timestamp >= ?{}", values.len()));
        }
        if !clauses.is_empty() {
            sql.push_str(" WHERE ");
            sql.push_str(&clauses.join(" AND "));
        }
        values.push(Value::Integer(
            i64::try_from(query.limit).unwrap_or(i64::MAX),
        ));
        let limit_param = values.len();
        let _ = write!(
            sql,
            " ORDER BY timestamp DESC, id DESC LIMIT ?{limit_param}"
        );

        let mut rows = self
            .conn
            .query(&sql, libsql::params_from_iter(values))
            .await
            .map_err(|e| format!("failed to query analytics events: {e}"))?;
        let mut events = Vec::new();
        while let Some(row) = rows
            .next()
            .await
            .map_err(|e| format!("failed to read analytics events: {e}"))?
        {
            let event = row_to_analytics_event(&row)
                .ok_or_else(|| "failed to decode analytics event row".to_string())?;
            events.push(event);
        }
        events.reverse();
        Ok(events)