Struct SinkRecord 

pub struct SinkRecord {
    pub data: Value,
    pub schema_id: String,
    pub source_url: String,
    pub fetched_at: DateTime<Utc>,
    pub metadata: HashMap<String, String>,
}

A single structured record to be published through a DataSinkPort.

Example

use stygian_graph::ports::data_sink::SinkRecord;
use serde_json::json;

let record = SinkRecord::new(
    "product-v1",
    "https://shop.example.com/items/42",
    json!({ "sku": "ABC-42", "price": 9.99 }),
);
assert_eq!(record.schema_id, "product-v1");

Fields

data: Value

The payload to publish. Any JSON value is accepted.

schema_id: String

Identifies the schema or data-contract version this record conforms to. Sinks may use this for routing, validation, or schema-registry lookups.

source_url: String

The canonical URL the record was scraped from. Used for provenance and deduplication. Stored as a String to avoid a url crate dependency in the port layer.

fetched_at: DateTime<Utc>

T108 mandatory — the wall-clock instant at which the source was fetched, as observed by the transport (HTTP Date header for HTTP-sourced records, browser Date.now() for browser-sourced records).

This field is required. Adapters and consumers cannot construct a SinkRecord without supplying it — use SinkRecord::with_fetched_at or SinkRecord::fetched_at_or_default to provide it.

The fetched_at value should be the transport-supplied timestamp, not Utc::now() computed post-extraction. The guard test in tests/sink_invariants.rs asserts every adapter uses a transport-level source.

metadata: HashMap<String, String>

Arbitrary string key-value metadata (content-type, run-id, tenant, …).

Implementations

impl SinkRecord

pub fn new( schema_id: impl Into<String>, source_url: impl Into<String>, data: Value, ) -> Self

Construct a new SinkRecord with empty metadata and fetched_at = chrono::Utc::now() as the fallback for callers that don’t have a transport-level timestamp.

Prefer SinkRecord::with_fetched_at — using Utc::now() here means the record carries the time of construction, not the time of the upstream fetch.

pub fn with_fetched_at( schema_id: impl Into<String>, source_url: impl Into<String>, data: Value, fetched_at: DateTime<Utc>, ) -> Self

Construct a SinkRecord with an explicit fetched_at timestamp. This is the preferred constructor — the caller is required to supply a transport-level timestamp.

Example

use stygian_graph::ports::data_sink::SinkRecord;
use chrono::{TimeZone, Utc};

let fetched_at = Utc.with_ymd_and_hms(2026, 8, 22, 12, 0, 0).unwrap();
let r = SinkRecord::with_fetched_at(
    "schema-v1",
    "https://example.com/page",
    serde_json::Value::Null,
    fetched_at,
);
assert_eq!(r.fetched_at, fetched_at);

pub fn fetched_at_or_default( schema_id: impl Into<String>, source_url: impl Into<String>, data: Value, default_fetched_at: DateTime<Utc>, ) -> Self

Construct a SinkRecord using default_fetched_at only when the caller does not have a transport-level timestamp. The default_fetched_at value is recorded verbatim — use chrono::Utc::now for a “now” fallback, or pass an HTTP Date header value parsed into a chrono::DateTime<Utc>.

pub fn with_meta(self, key: impl Into<String>, value: impl Into<String>) -> Self

Attach a metadata entry and return self for builder-style use.

Example

use stygian_graph::ports::data_sink::SinkRecord;
use chrono::Utc;

let r = SinkRecord::new("s", "https://x.com", serde_json::Value::Null)
    .with_meta("run_id", "abc123");
assert_eq!(r.metadata["run_id"], "abc123");

Trait Implementations

impl Clone for SinkRecord

fn clone(&self) -> SinkRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SinkRecord

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SinkRecord

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SinkRecord

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

where __S: Serializer,

Serialize this value into the given Serde serializer.