Struct Client 

pub struct Client { /* private fields */ }

An API client for the AWS Glue Schema Registry.

Client is cheap to clone — internally it wraps an aws_sdk_glue::Client, which is itself a clone-friendly handle backed by a shared connection pool.

Implementations

impl Client

pub fn from_sdk_client(inner: Client) -> Self

Wraps an existing SDK client.

Exists so tests can inject a mocked SDK client (e.g. via aws_smithy_mocks). Production callers construct clients through ClientConfig instead, which is why this is gated behind the test-util feature.

pub async fn get_registry( &self, name: &str, ) -> Result<Registry, GetRegistryError>

Look up a registry by name.

Returns GetRegistryError::NotFound if the registry does not exist in the configured account and region. Other errors (auth failures, throttling, transport) surface as GetRegistryError::Other.

pub async fn get_schema_version_by_id( &self, id: Uuid, ) -> Result<SchemaVersion, GetSchemaVersionError>

Fetch a schema version by its UUID.

This is the source-decode path: the UUID is read from the Glue wire-format header, and the returned SchemaVersion::definition carries the writer schema (Avro JSON, for our usage).

Glue schema-version UUIDs are globally unique within an AWS account and this call does not scope to any registry — it returns the matching version from anywhere the configured credentials can read. Returns GetSchemaVersionError::NotFound only when no schema version with this UUID exists in any visible registry. Callers that need to enforce a specific registry must check the returned SchemaArn themselves.

The AWS GetSchemaVersion API accepts either a SchemaVersionId (the UUID, registry-agnostic) or SchemaId + SchemaVersionNumber, never both — which is why looking up by name is a separate method, Client::get_schema_version_latest_by_name.

pub async fn get_schema_version_latest_by_name( &self, registry_name: &str, schema_name: &str, ) -> Result<SchemaVersion, GetSchemaVersionError>

Fetch the latest version of a schema by (registry_name, schema_name).

This is the DDL-planning path: at CREATE SOURCE time we don’t yet know any per-record UUIDs, so we pin the reader schema to whatever the registry currently calls “latest”. Runtime schema resolution for individual records still goes through Client::get_schema_version_by_id using the UUID in each Kafka payload’s Glue header.

pub async fn get_schema_by_definition( &self, registry_name: &str, schema_name: &str, definition: &str, ) -> Result<RegisteredSchemaVersion, GetSchemaByDefinitionError>

Look up the schema version whose definition byte-for-byte matches definition.

This is the sink reuse path: before registering a new version, callers check whether the exact definition is already registered so that a sink restart does not create a duplicate version. Returns GetSchemaByDefinitionError::NotFound if the schema does not exist or has no version matching definition.

The match is by definition only: Glue also matches versions whose lifecycle status is Failure or Deleting, so callers must check the returned status before reusing the version’s id.

pub async fn register_schema_version( &self, registry_name: &str, schema_name: &str, definition: &str, ) -> Result<RegisteredSchemaVersion, RegisterSchemaVersionError>

Register definition as a new version of an existing schema.

The schema (registry_name, schema_name) must already exist. Returns RegisterSchemaVersionError::SchemaNotFound if it does not, in which case the caller should create it with Client::create_schema. Registering a definition identical to an existing version is idempotent on Glue’s side and returns that version.

Glue runs the compatibility check asynchronously: a newly registered version comes back Pending and only later transitions to Available or Failure. Callers must not use the version’s id until they have observed it Available, polling via Client::get_schema_version_by_id.

pub async fn create_schema( &self, registry_name: &str, schema_name: &str, data_format: DataFormat, compatibility: Compatibility, definition: &str, ) -> Result<RegisteredSchemaVersion, CreateSchemaError>

Create a schema in registry_name with definition as its first version and compatibility as its evolution policy, returning that first version.

A first version has no prior version to be compatible with, so it is usually Available immediately, but callers should still confirm the returned status before using the version’s id.

Glue sets a schema’s compatibility only at creation. This crate exposes no way to change it afterward, matching the sink’s set-if-unset policy: an existing schema’s compatibility is read (via Client::get_schema) and warned on, never overwritten.

Returns CreateSchemaError::AlreadyExists if the schema already exists and CreateSchemaError::RegistryNotFound if the registry does not.

pub async fn get_schema( &self, registry_name: &str, schema_name: &str, ) -> Result<Schema, GetSchemaError>

Fetch a schema’s metadata by (registry_name, schema_name).

The sink uses this to read the current compatibility policy so it can warn on a mismatch without overwriting it, and to detect whether the schema already exists. Returns GetSchemaError::NotFound if the schema does not exist.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.