Struct ODCSContract 

pub struct ODCSContract {

    pub api_version: String,
    pub kind: String,
    pub id: String,
    pub version: String,
    pub name: String,
    pub status: Option<String>,
    pub domain: Option<String>,
    pub data_product: Option<String>,
    pub tenant: Option<String>,
    pub description: Option<Description>,
    pub schema: Vec<SchemaObject>,
    pub servers: Vec<Server>,
    pub team: Option<Team>,
    pub support: Option<Support>,
    pub roles: Vec<Role>,
    pub service_levels: Vec<ServiceLevel>,
    pub quality: Vec<QualityRule>,
    pub price: Option<Price>,
    pub terms: Option<Terms>,
    pub links: Vec<Link>,
    pub authoritative_definitions: Vec<AuthoritativeDefinition>,
    pub tags: Vec<String>,
    pub custom_properties: Vec<CustomProperty>,
    pub contract_created_ts: Option<String>,
}

ODCSContract - the root data contract document (ODCS v3.1.0)

This is the top-level structure that represents an entire ODCS data contract. It contains all contract-level metadata plus one or more schema objects (tables).

Example

use data_modelling_core::models::odcs::{ODCSContract, SchemaObject, Property};

let contract = ODCSContract::new("customer-contract", "v1.0.0")
    .with_domain("retail")
    .with_status("active")
    .with_schema(
        SchemaObject::new("customers")
            .with_physical_type("table")
            .with_properties(vec![
                Property::new("id", "integer").with_primary_key(true),
                Property::new("name", "string").with_required(true),
            ])
    );

Fields

api_version: String

API version (e.g., “v3.1.0”)

kind: String

Kind identifier (always “DataContract”)

id: String

Unique contract ID (UUID or other identifier)

version: String

Contract version (semantic versioning recommended)

name: String

Contract name

status: Option<String>

Contract status: “draft”, “active”, “deprecated”, “retired”

domain: Option<String>

Domain this contract belongs to

data_product: Option<String>

Data product this contract belongs to

tenant: Option<String>

Tenant identifier for multi-tenant systems

description: Option<Description>

Contract description (can be simple string or structured object)

schema: Vec<SchemaObject>

Schema objects (tables, views, topics) in this contract

servers: Vec<Server>

Server configurations

team: Option<Team>

Team information

support: Option<Support>

Support information

roles: Vec<Role>

Role definitions

service_levels: Vec<ServiceLevel>

Service level agreements

quality: Vec<QualityRule>

Contract-level quality rules

price: Option<Price>

Price information

terms: Option<Terms>

Terms and conditions

links: Vec<Link>

External links

authoritative_definitions: Vec<AuthoritativeDefinition>

Authoritative definitions

tags: Vec<String>

Contract-level tags

custom_properties: Vec<CustomProperty>

Custom properties for format-specific metadata

contract_created_ts: Option<String>

Contract creation timestamp (ISO 8601)

Implementations

impl ODCSContract

pub fn new(name: impl Into<String>, version: impl Into<String>) -> Self

Create a new contract with the given name and version

pub fn new_with_id( id: impl Into<String>, name: impl Into<String>, version: impl Into<String>, ) -> Self

Create a new contract with a specific ID

pub fn with_api_version(self, api_version: impl Into<String>) -> Self

Set the API version

pub fn with_status(self, status: impl Into<String>) -> Self

Set the status

pub fn with_domain(self, domain: impl Into<String>) -> Self

Set the domain

pub fn with_data_product(self, data_product: impl Into<String>) -> Self

Set the data product

pub fn with_tenant(self, tenant: impl Into<String>) -> Self

Set the tenant

pub fn with_description(self, description: impl Into<String>) -> Self

Set the description (simple string)

pub fn with_structured_description(self, description: Description) -> Self

Set a structured description

pub fn with_schema(self, schema: SchemaObject) -> Self

Add a schema object

pub fn with_schemas(self, schemas: Vec<SchemaObject>) -> Self

Set all schema objects

pub fn with_server(self, server: Server) -> Self

Add a server configuration

pub fn with_team(self, team: Team) -> Self

Set the team information

pub fn with_support(self, support: Support) -> Self

Set the support information

pub fn with_role(self, role: Role) -> Self

Add a role

pub fn with_service_level(self, service_level: ServiceLevel) -> Self

Add a service level

pub fn with_quality_rule(self, rule: QualityRule) -> Self

Add a quality rule

pub fn with_price(self, price: Price) -> Self

Set the price

pub fn with_terms(self, terms: Terms) -> Self

Set the terms

pub fn with_link(self, link: Link) -> Self

Add a link

pub fn with_authoritative_definition( self, definition: AuthoritativeDefinition, ) -> Self

Add an authoritative definition

pub fn with_tag(self, tag: impl Into<String>) -> Self

Add a tag

pub fn with_tags(self, tags: Vec<String>) -> Self

Set all tags

pub fn with_custom_property(self, custom_property: CustomProperty) -> Self

Add a custom property

pub fn with_contract_created_ts(self, timestamp: impl Into<String>) -> Self

Set the contract creation timestamp

pub fn schema_count(&self) -> usize

Get the number of schema objects

pub fn get_schema(&self, name: &str) -> Option<&SchemaObject>

Get a schema object by name

pub fn get_schema_mut(&mut self, name: &str) -> Option<&mut SchemaObject>

Get a mutable schema object by name

pub fn schema_names(&self) -> Vec<&str>

Get all schema names

pub fn is_multi_table(&self) -> bool

Check if this is a multi-table contract

pub fn first_schema(&self) -> Option<&SchemaObject>

Get the first schema (for single-table contracts)

pub fn description_string(&self) -> Option<String>

Get the description as a simple string

impl ODCSContract

pub fn to_tables(&self) -> Vec<Table>

Convert the contract to a vector of Tables

Each SchemaObject becomes a Table, with contract-level metadata stored in each table’s odcl_metadata.

pub fn from_tables(tables: &[Table]) -> Self

Create a contract from a vector of Tables

Contract-level metadata is extracted from the first table’s odcl_metadata. Each table becomes a SchemaObject.

pub fn to_table_data(&self) -> Vec<TableData>

Convert contract to TableData for API responses

Trait Implementations

impl Clone for ODCSContract

fn clone(&self) -> ODCSContract

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ODCSContract

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

Formats the value using the given formatter.

impl Default for ODCSContract

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ODCSContract

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ODCSContract

fn eq(&self, other: &ODCSContract) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ODCSContract

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ODCSContract