Method register

mserver/MasterService/src/repository.rs:182–281

(
        &self,
        request: RegisterServerRequest,
        now_unix_ms: i64,
    )

    }

    async fn create_post_migration_indexes(&self) -> Result<()> {
        sqlx::raw_sql(
            "CREATE INDEX IF NOT EXISTS idx_servers_app_version ON servers(app_name, actver, version_tag);",
        )
        .execute(&self.pool)
        .await
        .context("creating post-migration indexes")?;
        sqlx::raw_sql(
            "CREATE UNIQUE INDEX IF NOT EXISTS idx_servers_token_hash ON servers(token_hash) WHERE token_hash IS NOT NULL;",
        )
        .execute(&self.pool)
        .await
        .context("creating unique server token index; duplicate token hashes require operator cleanup")?;
        Ok(())
    }

    /// Current column names of the `servers` table, per dialect.
    async fn server_columns(&self) -> Result<Vec<String>> {
        let query = match self.dialect {
            Dialect::Sqlite => "SELECT name FROM pragma_table_info('servers')",
            // column_name is Postgres' internal `name` type, which the sqlx Any driver can't
            // decode — cast to text so it reads back as a plain string.
            Dialect::Postgres => {
                "SELECT column_name::text FROM information_schema.columns WHERE table_name = 'servers'"
            }
        };
        let rows = sqlx::query(query)
            .fetch_all(&self.pool)
            .await
            .context("reading servers columns")?;
        Ok(rows
            .iter()
            .filter_map(|row| row.try_get::<String, _>(0).ok())
            .collect())
    }

    fn schema(&self) -> &'static str {
        match self.dialect {
            Dialect::Sqlite => SCHEMA_SQLITE,
            Dialect::Postgres => SCHEMA_POSTGRES,
        }
    }

    /// Adapt a query body written with SQLite-style `?` placeholders to the active dialect.
    /// SQLite keeps `?`; Postgres needs `$1..$N`. The sqlx `Any` driver does not translate
    /// placeholders, so a `?` reaches Postgres verbatim and is rejected
    /// ("syntax error at end of input").
    fn bind_sql<'a>(&self, query: &'a str) -> Cow<'a, str> {
        rewrite_placeholders(self.dialect, query)
    }

    pub async fn register(
        &self,
        request: RegisterServerRequest,
        now_unix_ms: i64,
    ) -> Result<DirectoryServerRecord> {
        self.register_record(request, now_unix_ms, None)
            .await?