lix 0.17.1

Embeddable version control for apps and AI agents.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use super::{PublicColumn, SurfaceCapabilities};

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct PublicSurfaceContract {
    pub(crate) name: String,
    pub(crate) class: PublicSurfaceClass,
    pub(crate) kind: PublicSurfaceKind,
    pub(crate) columns: Vec<PublicColumn>,
    pub(crate) capabilities: SurfaceCapabilities,
    /// What the surface means, for catalogs and tools; None when undocumented.
    pub(crate) description: Option<String>,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum PublicRelationKind {
    Base,
    View,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum PublicSurfaceClass {
    Relation(PublicRelationKind),
    TableFunction,
    CommandSink,
    ScalarFunction,
}

impl PublicSurfaceClass {
    pub(crate) fn sql_name(self) -> &'static str {
        match self {
            Self::Relation(_) => "RELATION",
            Self::TableFunction => "TABLE_FUNCTION",
            Self::CommandSink => "COMMAND_SINK",
            Self::ScalarFunction => "SCALAR_FUNCTION",
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct PublicScalarFunctionContract {
    pub(crate) name: String,
    pub(crate) class: PublicSurfaceClass,
}

pub(crate) const PUBLIC_SCALAR_FUNCTION_NAMES: [&str; 7] = [
    "lix_active_account_id",
    "lix_active_branch_commit_id",
    "lix_active_branch_id",
    "lix_root_commit_id",
    "lix_row_ref",
    "lix_order_between",
    "uuidv7",
];

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct PublicHistoryContract {
    pub(crate) relation_name: String,
    pub(crate) columns: Vec<PublicColumn>,
}

impl PublicSurfaceContract {
    pub(crate) fn with_description(mut self, description: Option<String>) -> Self {
        self.description = description;
        self
    }

    pub(crate) fn public_column(&self, column_name: &str) -> Option<&PublicColumn> {
        self.columns
            .iter()
            .find(|column| column.name == column_name && column.is_public())
    }

    pub(crate) fn column(&self, column_name: &str) -> Option<&PublicColumn> {
        self.columns
            .iter()
            .find(|column| column.name == column_name)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum PublicSurfaceKind {
    SchemaBase { schema_key: String },
    File,
    Directory,
    Branch,
    LogFunction,
    HistoryFunction,
    DiffFunction,
    CheckpointFunction,
    StateAtFunction,
    CommitAncestryFunction,
    Revert,
    Apply,
    Restore,
    Change,
}

impl PublicSurfaceKind {
    pub(crate) fn accepts_class(&self, class: PublicSurfaceClass) -> bool {
        match self {
            Self::SchemaBase { .. }
            | Self::File
            | Self::Directory
            | Self::Branch
            | Self::Change => matches!(class, PublicSurfaceClass::Relation(_)),
            Self::LogFunction
            | Self::HistoryFunction
            | Self::DiffFunction
            | Self::CheckpointFunction
            | Self::StateAtFunction
            | Self::CommitAncestryFunction => class == PublicSurfaceClass::TableFunction,
            Self::Revert | Self::Apply | Self::Restore => class == PublicSurfaceClass::CommandSink,
        }
    }
}