Function publish

crates/client-api/src/routes/database.rs:928–1095

(
    State(ctx): State<S>,
    Path(PublishDatabaseParams { name_or_identity }): Path<PublishDatabaseParams>,
    Query(PublishDatabaseQueryParams {
        clear,
        num_replicas,
        token

const MAX_UPDATE_CONFIRMATION_TIMEOUT: Duration = Duration::from_secs(5 * 60);

pub async fn publish<S: NodeDelegate + ControlStateDelegate + Authorization>(
    State(ctx): State<S>,
    Path(PublishDatabaseParams { name_or_identity }): Path<PublishDatabaseParams>,
    Query(PublishDatabaseQueryParams {
        clear,
        num_replicas,
        token,
        policy,
        host_type,
        parent,
        organization,
        update_confirmation_timeout: confirmation_timeout,
    }): Query<PublishDatabaseQueryParams>,
    Extension(auth): Extension<SpacetimeAuth>,
    program_bytes: Bytes,
) -> axum::response::Result<axum::Json<PublishResult>> {
    // If `clear`, check that the database exists and delegate to `reset`.
    // If it doesn't exist, ignore the `clear` parameter.
    // TODO: Replace with actual redirect at the next possible version bump.
    if clear {
        let name_or_identity = name_or_identity
            .as_ref()
            .ok_or_else(|| bad_request("Clear database requires database name or identity".into()))?;
        let database_identity = name_or_identity.try_resolve(&ctx).await.map_err(log_and_500)?;
        if let Ok(identity) = database_identity {
            let exists = ctx
                .get_database_by_identity(&identity)
                .await
                .map_err(log_and_500)?
                .is_some();
            if exists {
                if parent.is_some() {
                    return Err(bad_request(
                        "Setting the parent of an existing database is not supported".into(),
                    ));
                }

                return self::reset(
                    State(ctx),
                    Path(ResetDatabaseParams {
                        name_or_identity: name_or_identity.clone(),
                    }),
                    Query(ResetDatabaseQueryParams {
                        num_replicas,
                        host_type,
                    }),
                    Extension(auth),
                    Some(program_bytes),
                )
                .await;
            }
        }
    }

    let (database_identity, db_name) = get_or_create_identity_and_name(&ctx, &auth, name_or_identity.as_ref()).await?;
    let maybe_parent_database_identity = match parent.as_ref() {
        None => None,
        Some(parent) => parent.resolve(&ctx).await.map(Some)?,