Method build_start_stop_range

api/src/server.rs:821–866

(
        &self,
        sep_key: &str,
        sep_value: &[u8],
        controller: Option<String>,
        stream_id: Option<String>,
    )

    }

    fn build_start_stop_range(
        &self,
        sep_key: &str,
        sep_value: &[u8],
        controller: Option<String>,
        stream_id: Option<String>,
    ) -> Result<(EventId, EventId), ErrorResponse> {
        let start_builder = EventId::builder()
            .with_network(&self.network)
            .with_sep(sep_key, sep_value);
        let stop_builder = EventId::builder()
            .with_network(&self.network)
            .with_sep(sep_key, sep_value);

        let (start_builder, stop_builder) = match (controller, stream_id) {
            (Some(controller), Some(stream_id)) => {
                let stream_id = StreamId::from_str(&stream_id)
                    .map_err(|err| ErrorResponse::new(format!("stream_id: {err}")))?;
                (
                    start_builder
                        .with_controller(&controller)
                        .with_init(&stream_id.cid),
                    stop_builder
                        .with_controller(&controller)
                        .with_init(&stream_id.cid),
                )
            }
            (Some(controller), None) => (
                start_builder.with_controller(&controller).with_min_init(),
                stop_builder.with_controller(&controller).with_max_init(),
            ),
            (None, Some(_)) => {
                return Err(ErrorResponse::new(
                    "controller is required if stream_id is specified".to_owned(),
                ))
            }
            (None, None) => (
                start_builder.with_min_controller().with_min_init(),
                stop_builder.with_max_controller().with_max_init(),
            ),
        };

        let start = start_builder.with_min_event().build_fencepost();
        let stop = stop_builder.with_max_event().build_fencepost();
        Ok((start, stop))
    }

    async fn get_stream_state(
        &self,