#moonrockz/partiql-value

#Installation and imports

moon add moonrockz/partiql-value

import {
  "moonrockz/partiql-value" @value,
  "moonrockz/partiql-value/ion" @partiql_ion,
  "moonrockz/ion/ion" @ion_core,
}

import { "moonrockz/expect" } for "test"

#Constructing values

test "construct values" {
  let list = @value.Value([1, 2, 3])
  @expect.expect(list).to_equal(@value.Value::from_list([@value.Value::from_int(1), @value.Value::from_int(2), @value.Value::from_int(3)]))
}

test "typed bag and date conversions" {
  let bag = @value.Value::from_bag(@value.Bag([@value.Value(1), @value.Value(2)]))
  let date = @value.Value::from_date(@value.Date(year=2024, month=2, day=29))
  @expect.expect_all(soft => {
    soft.expect(bag is @value.Value::Bag(b) && b.length() == 2).to_be_true()
    soft.expect(date is @value.Value::Date(d) && d.day == 29).to_be_true()
  })
}

test "build and wrap a tuple" {
  let value = @value.Value::from_tuple(@value.Tuple([
    ("a", @value.Value(1)), ("a", @value.Value(2)),
  ]))
  guard value is @value.Value::Tuple(tuple) else {
    fail("expected a tuple value")
  }
  @expect.expect(tuple.get_all("a")).to_equal([@value.Value(1), @value.Value(2)])
}

struct CustomerId(Int)

impl @value.ToValue for CustomerId with fn to_value(self) {
  @value.Value(self.0)
}

test "domain conversion" {
  @expect.expect(@value.Value(CustomerId(7))).to_equal(@value.Value::from_int(7))
}

#Datetimes and intervals

test "datetime and interval constructors" {
  let date : @value.Date = @value.Date(year=2024, month=2, day=29)
  let time : @value.Time = @value.Time(
    hour=12, minute=30, second=0, nanos=125000000, precision=3, offset=Some(60),
  )
  let timestamp : @value.Timestamp = @value.Timestamp(date, time)
  let interval : @value.IntervalDT = @value.IntervalDT(0, -250000000)
  @expect.expect((timestamp.time.precision, interval.is_negative(), interval.nanos_part())).to_equal((3, true, 250000000L))
}

#Maps and graphs

test "map and graph constructors" {
  let map = @value.MapValue(
    key_type=@value.MapType::String, value_type=@value.MapType::Dynamic,
    [(@value.Value("a"), @value.Value(1))],
  )
  let node = @value.GraphNode(id="n", labels=["person", "person"])
  let edge = @value.GraphEdge(id="e", ends=@value.Ends::Directed(from="n", to="n"))
  let graph = @value.GraphValue([node], [edge])
  @expect.expect((map.length(), graph.nodes()[0].labels().length(), graph.edges().length())).to_equal((1, 1, 1))
}

#Choosing a relation

test "boxed Ion equality" {
  let symbol = @value.Value(@ion_core.IonValue::symbol("hello"))
  @expect.expect(@value.sql_equals(symbol, @value.Value("hello"))).to_equal(@value.Value::from_bool(true))
}

#Ion codecs and datagrams

test "binary datagram round trip" {
  let values = @partiql_ion.read_text("1 $missing::null $bag::[2, 3] $ion::foo")
  let bytes = @partiql_ion.write_bytes(values)
  @expect.expect(@partiql_ion.read_bytes(bytes)).to_equal(values)
}

test "validate raw Ion" {
  let schema = @partiql_ion.load_schema_bytes(
    b"$ion_schema_2_0 schema_header::{} type::{name: row, type: struct} schema_footer::{}",
  )
  let validation = @partiql_ion.Validation::elements(schema, "row")
  let values = @partiql_ion.read_text("{a: 1} {a: 2}", validation~)
  @expect.expect(values.length()).to_equal(2)
}

#Property tests