scythe_codegen/backends/
elixir_exqlite.rs

1use std::fmt::Write;
2use std::path::Path;
3
4use scythe_backend::manifest::{BackendManifest, load_manifest};
5use scythe_backend::naming::{
6    enum_type_name, enum_variant_name, fn_name, row_struct_name, to_pascal_case, to_snake_case,
7};
8
9use scythe_core::analyzer::{AnalyzedQuery, CompositeInfo, EnumInfo};
10use scythe_core::errors::{ErrorCode, ScytheError};
11use scythe_core::parser::QueryCommand;
12
13use crate::backend_trait::{CodegenBackend, ResolvedColumn, ResolvedParam};
14
15const DEFAULT_MANIFEST_TOML: &str = include_str!("../../manifests/elixir-exqlite.toml");
16
17pub struct ElixirExqliteBackend {
18    manifest: BackendManifest,
19}
20
21impl ElixirExqliteBackend {
22    pub fn new(engine: &str) -> Result<Self, ScytheError> {
23        match engine {
24            "sqlite" | "sqlite3" => {}
25            _ => {
26                return Err(ScytheError::new(
27                    ErrorCode::InternalError,
28                    format!(
29                        "elixir-exqlite only supports SQLite, got engine '{}'",
30                        engine
31                    ),
32                ));
33            }
34        }
35        let manifest_path = Path::new("backends/elixir-exqlite/manifest.toml");
36        let manifest = if manifest_path.exists() {
37            load_manifest(manifest_path)
38                .map_err(|e| ScytheError::new(ErrorCode::InternalError, format!("manifest: {e}")))?
39        } else {
40            toml::from_str(DEFAULT_MANIFEST_TOML)
41                .map_err(|e| ScytheError::new(ErrorCode::InternalError, format!("manifest: {e}")))?
42        };
43        Ok(Self { manifest })
44    }
45}
46
47impl CodegenBackend for ElixirExqliteBackend {
48    fn name(&self) -> &str {
49        "elixir-exqlite"
50    }
51
52    fn manifest(&self) -> &scythe_backend::manifest::BackendManifest {
53        &self.manifest
54    }
55
56    fn supported_engines(&self) -> &[&str] {
57        &["sqlite"]
58    }
59
60    fn generate_row_struct(
61        &self,
62        query_name: &str,
63        columns: &[ResolvedColumn],
64    ) -> Result<String, ScytheError> {
65        let struct_name = row_struct_name(query_name, &self.manifest.naming);
66        let mut out = String::new();
67        let _ = writeln!(out, "defmodule {} do", struct_name);
68        let _ = writeln!(out, "  @moduledoc \"Row type for {} queries.\"", query_name);
69        let _ = writeln!(out);
70
71        // Generate typespec
72        let _ = writeln!(out, "  @type t :: %__MODULE__{{");
73        for (i, c) in columns.iter().enumerate() {
74            let sep = if i + 1 < columns.len() { "," } else { "" };
75            let _ = writeln!(out, "    {}: {}{}", c.field_name, c.full_type, sep);
76        }
77        let _ = writeln!(out, "  }}");
78
79        // Generate defstruct
80        let fields = columns
81            .iter()
82            .map(|c| format!(":{}", c.field_name))
83            .collect::<Vec<_>>()
84            .join(", ");
85        let _ = writeln!(out, "  defstruct [{}]", fields);
86        let _ = write!(out, "end");
87        Ok(out)
88    }
89
90    fn generate_model_struct(
91        &self,
92        table_name: &str,
93        columns: &[ResolvedColumn],
94    ) -> Result<String, ScytheError> {
95        let name = to_pascal_case(table_name);
96        self.generate_row_struct(&name, columns)
97    }
98
99    fn generate_query_fn(
100        &self,
101        analyzed: &AnalyzedQuery,
102        struct_name: &str,
103        columns: &[ResolvedColumn],
104        params: &[ResolvedParam],
105    ) -> Result<String, ScytheError> {
106        let func_name = fn_name(&analyzed.name, &self.manifest.naming);
107        let sql = super::clean_sql_with_optional(
108            &analyzed.sql,
109            &analyzed.optional_params,
110            &analyzed.params,
111        );
112        let mut out = String::new();
113
114        // Parameter list
115        let param_list = params
116            .iter()
117            .map(|p| p.field_name.clone())
118            .collect::<Vec<_>>()
119            .join(", ");
120        let sep = if param_list.is_empty() { "" } else { ", " };
121
122        // Build the params list for Exqlite
123        let param_args = if params.is_empty() {
124            "[]".to_string()
125        } else {
126            format!(
127                "[{}]",
128                params
129                    .iter()
130                    .map(|p| p.field_name.clone())
131                    .collect::<Vec<_>>()
132                    .join(", ")
133            )
134        };
135
136        // Build @spec
137        let param_specs = if params.is_empty() {
138            String::new()
139        } else {
140            let specs: Vec<String> = params.iter().map(|p| p.full_type.clone()).collect();
141            format!(", {}", specs.join(", "))
142        };
143        match &analyzed.command {
144            QueryCommand::One => {
145                let _ = writeln!(
146                    out,
147                    "@spec {}(Exqlite.Sqlite3.db(){}) :: {{:ok, %{}{{}}}} | {{:error, term()}}",
148                    func_name, param_specs, struct_name
149                );
150            }
151            QueryCommand::Many => {
152                let _ = writeln!(
153                    out,
154                    "@spec {}(Exqlite.Sqlite3.db(){}) :: {{:ok, [%{}{{}}]}} | {{:error, term()}}",
155                    func_name, param_specs, struct_name
156                );
157            }
158            QueryCommand::Batch => {
159                let batch_fn_name = format!("{}_batch", func_name);
160                let _ = writeln!(
161                    out,
162                    "@spec {}(Exqlite.Sqlite3.db(), list()) :: :ok | {{:error, term()}}",
163                    batch_fn_name
164                );
165                let _ = writeln!(out, "def {}(conn, items) do", batch_fn_name);
166                let _ = writeln!(out, "  sql = \"{}\"", sql);
167                let _ = writeln!(out, "  Enum.reduce_while(items, :ok, fn item, :ok ->");
168                if params.len() > 1 {
169                    let _ = writeln!(
170                        out,
171                        "    case Exqlite.Sqlite3.execute(conn, sql, Tuple.to_list(item)) do"
172                    );
173                } else if params.len() == 1 {
174                    let _ = writeln!(
175                        out,
176                        "    case Exqlite.Sqlite3.execute(conn, sql, [item]) do"
177                    );
178                } else {
179                    let _ = writeln!(out, "    case Exqlite.Sqlite3.execute(conn, sql, []) do");
180                }
181                let _ = writeln!(out, "      {{:ok, _}} -> {{:cont, :ok}}");
182                let _ = writeln!(out, "      {{:error, err}} -> {{:halt, {{:error, err}}}}");
183                let _ = writeln!(out, "    end");
184                let _ = writeln!(out, "  end)");
185                let _ = write!(out, "end");
186                return Ok(out);
187            }
188            QueryCommand::Exec => {
189                let _ = writeln!(
190                    out,
191                    "@spec {}(Exqlite.Sqlite3.db(){}) :: :ok | {{:error, term()}}",
192                    func_name, param_specs
193                );
194            }
195            QueryCommand::ExecResult | QueryCommand::ExecRows => {
196                let _ = writeln!(
197                    out,
198                    "@spec {}(Exqlite.Sqlite3.db(){}) :: {{:ok, non_neg_integer()}} | {{:error, term()}}",
199                    func_name, param_specs
200                );
201            }
202        }
203        let _ = writeln!(out, "def {}(conn{}{}) do", func_name, sep, param_list);
204
205        match &analyzed.command {
206            QueryCommand::One => {
207                let _ = writeln!(out, "  sql = \"{}\"", sql);
208                let _ = writeln!(
209                    out,
210                    "  case Exqlite.Sqlite3.execute(conn, sql, {}) do",
211                    param_args
212                );
213                let _ = writeln!(out, "    {{:ok, [[_|_] = row]}} ->");
214
215                let field_vars = columns
216                    .iter()
217                    .map(|c| c.field_name.clone())
218                    .collect::<Vec<_>>()
219                    .join(", ");
220                let _ = writeln!(out, "      [{}] = row", field_vars);
221
222                let struct_fields = columns
223                    .iter()
224                    .map(|c| format!("{}: {}", c.field_name, c.field_name))
225                    .collect::<Vec<_>>()
226                    .join(", ");
227                let _ = writeln!(out, "      {{:ok, %{}{{{}}}}}", struct_name, struct_fields);
228                let _ = writeln!(out, "    {{:ok, []}} -> {{:error, :not_found}}");
229                let _ = writeln!(out, "    {{:error, err}} -> {{:error, err}}");
230                let _ = writeln!(out, "  end");
231            }
232            QueryCommand::Many => {
233                let _ = writeln!(out, "  sql = \"{}\"", sql);
234                let _ = writeln!(
235                    out,
236                    "  case Exqlite.Sqlite3.execute(conn, sql, {}) do",
237                    param_args
238                );
239                let _ = writeln!(out, "    {{:ok, rows}} ->");
240
241                let field_vars = columns
242                    .iter()
243                    .map(|c| c.field_name.clone())
244                    .collect::<Vec<_>>()
245                    .join(", ");
246                let struct_fields = columns
247                    .iter()
248                    .map(|c| format!("{}: {}", c.field_name, c.field_name))
249                    .collect::<Vec<_>>()
250                    .join(", ");
251
252                let _ = writeln!(out, "      results = Enum.map(rows, fn row ->");
253                let _ = writeln!(out, "        [{}] = row", field_vars);
254                let _ = writeln!(out, "        %{}{{{}}}", struct_name, struct_fields);
255                let _ = writeln!(out, "      end)");
256                let _ = writeln!(out, "      {{:ok, results}}");
257                let _ = writeln!(out, "    {{:error, err}} -> {{:error, err}}");
258                let _ = writeln!(out, "  end");
259            }
260            QueryCommand::Exec => {
261                let _ = writeln!(out, "  sql = \"{}\"", sql);
262                let _ = writeln!(
263                    out,
264                    "  case Exqlite.Sqlite3.execute(conn, sql, {}) do",
265                    param_args
266                );
267                let _ = writeln!(out, "    {{:ok, _}} -> :ok");
268                let _ = writeln!(out, "    {{:error, err}} -> {{:error, err}}");
269                let _ = writeln!(out, "  end");
270            }
271            QueryCommand::ExecResult | QueryCommand::ExecRows => {
272                let _ = writeln!(out, "  sql = \"{}\"", sql);
273                let _ = writeln!(
274                    out,
275                    "  case Exqlite.Sqlite3.execute(conn, sql, {}) do",
276                    param_args
277                );
278                let _ = writeln!(out, "    {{:ok, _}} ->");
279                let _ = writeln!(out, "      {{:ok, Exqlite.Sqlite3.changes(conn)}}");
280                let _ = writeln!(out, "    {{:error, err}} -> {{:error, err}}");
281                let _ = writeln!(out, "  end");
282            }
283            QueryCommand::Batch => unreachable!(),
284        }
285
286        let _ = write!(out, "end");
287        Ok(out)
288    }
289
290    fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
291        let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
292        let mut out = String::new();
293        let _ = writeln!(out, "defmodule {} do", type_name);
294        let _ = writeln!(
295            out,
296            "  @moduledoc \"Enum type for {}.\"",
297            enum_info.sql_name
298        );
299        let _ = writeln!(out);
300        let _ = writeln!(out, "  @type t :: String.t()");
301        for value in &enum_info.values {
302            let variant = enum_variant_name(value, &self.manifest.naming);
303            let _ = writeln!(
304                out,
305                "  def {}(), do: \"{}\"",
306                to_snake_case(&variant),
307                value
308            );
309        }
310        let values_list = enum_info
311            .values
312            .iter()
313            .map(|v| format!("\"{}\"", v))
314            .collect::<Vec<_>>()
315            .join(", ");
316        let _ = writeln!(out, "  def values, do: [{}]", values_list);
317        let _ = write!(out, "end");
318        Ok(out)
319    }
320
321    fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
322        let name = to_pascal_case(&composite.sql_name);
323        let mut out = String::new();
324        let _ = writeln!(out, "defmodule {} do", name);
325        let _ = writeln!(
326            out,
327            "  @moduledoc \"Composite type for {}.\"",
328            composite.sql_name
329        );
330        let _ = writeln!(out);
331        if composite.fields.is_empty() {
332            let _ = writeln!(out, "  defstruct []");
333        } else {
334            let fields = composite
335                .fields
336                .iter()
337                .map(|f| format!(":{}", to_snake_case(&f.name)))
338                .collect::<Vec<_>>()
339                .join(", ");
340            let _ = writeln!(out, "  defstruct [{}]", fields);
341        }
342        let _ = write!(out, "end");
343        Ok(out)
344    }
345}
scythe_codegen/backends/elixir_exqlite.rs

scythe_codegen/backends/
elixir_exqlite.rs
