datacraft-core 0.2.0

Headless domain model, command bus and application state for DataCraft
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

//! Shipped-template materialization (phase 29, step 29.2, item H44) —
//! split from `database.rs` for the file-size gate.

use crate::core::failed;
use crate::event::Event;
use crate::failure::FailureCode;
use crate::port::DriverCapabilities;

impl crate::core::Core {
    /// Materializes a shipped template into a new file (phase 29, step
    /// 29.2, item H44). Creation plus the template's tables run through the
    /// port; any failure removes the partial file and reports a precise
    /// `Failed`. The new database is not opened. The command requires no
    /// open database: materialization opens the new file through the live
    /// port, so an open session must be closed first (M27).
    pub(crate) fn create_database_from_template(
        &mut self,
        path: std::path::PathBuf,
        template: String,
    ) -> Vec<Event> {
        if self.state.database.is_some() {
            return failed(
                FailureCode::Lifecycle,
                "close the open database before creating a database from a template",
            );
        }
        if !self.port.capabilities().create_database {
            return failed(
                FailureCode::Capability(crate::availability::DisabledReason::CreateDatabase),
                DriverCapabilities::unsupported(&self.port.driver_id(), "create database files"),
            );
        }
        let Some(template) = crate::templates::find_template(&template) else {
            let available: Vec<&str> = crate::templates::templates()
                .iter()
                .map(|entry| entry.name)
                .collect();
            return failed(
                FailureCode::NotFound,
                format!(
                    "unknown template {template:?} — available: {}",
                    available.join(", ")
                ),
            );
        };
        let format = template.format;
        // The same suffix/format agreement as the plain creation (step
        // 75.3, item L43), judged against the template-defined format.
        if let Some(foreign) = format.creation_suffix_conflict(&path) {
            return failed(
                FailureCode::InvalidInput,
                format!(
                    "the path {} ends in .{foreign}, which does not match the template's \
                     format {format} — rename the file or choose another template",
                    path.display()
                ),
            );
        }
        if let Err(e) = self.port.create_database(&path, format) {
            return failed(FailureCode::Port, e.to_string());
        }
        if let Err(e) = self.materialize_template_tables(&path, &template.tables) {
            let _ = std::fs::remove_file(&path);
            return failed(FailureCode::Port, e);
        }
        vec![Event::DatabaseCreated { path, format }]
    }

    /// Writes the template's tables through the port (open, create, insert,
    /// close). Returns the error text on the first failure.
    fn materialize_template_tables(
        &mut self,
        path: &std::path::Path,
        tables: &[crate::templates::TemplateTable],
    ) -> Result<(), String> {
        if tables.is_empty() {
            return Ok(());
        }
        if let Err(e) = self.port.open(path, None) {
            return Err(e.to_string());
        }
        for table in tables {
            if let Err(e) = self.port.create_table(&table.definition) {
                self.port.close();
                return Err(e.to_string());
            }
            for row in &table.rows {
                if let Err(e) = self.port.insert_row(&table.definition.name, row) {
                    self.port.close();
                    return Err(e.to_string());
                }
            }
        }
        self.port.close();
        Ok(())
    }
}