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 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 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(&analyzed.sql);
108 let mut out = String::new();
109
110 let param_list = params
112 .iter()
113 .map(|p| p.field_name.clone())
114 .collect::<Vec<_>>()
115 .join(", ");
116 let sep = if param_list.is_empty() { "" } else { ", " };
117
118 let param_args = if params.is_empty() {
120 "[]".to_string()
121 } else {
122 format!(
123 "[{}]",
124 params
125 .iter()
126 .map(|p| p.field_name.clone())
127 .collect::<Vec<_>>()
128 .join(", ")
129 )
130 };
131
132 let param_specs = if params.is_empty() {
134 String::new()
135 } else {
136 let specs: Vec<String> = params.iter().map(|p| p.full_type.clone()).collect();
137 format!(", {}", specs.join(", "))
138 };
139 match &analyzed.command {
140 QueryCommand::One => {
141 let _ = writeln!(
142 out,
143 "@spec {}(Exqlite.Sqlite3.db(){}) :: {{:ok, %{}{{}}}} | {{:error, term()}}",
144 func_name, param_specs, struct_name
145 );
146 }
147 QueryCommand::Many | QueryCommand::Batch => {
148 let _ = writeln!(
149 out,
150 "@spec {}(Exqlite.Sqlite3.db(){}) :: {{:ok, [%{}{{}}]}} | {{:error, term()}}",
151 func_name, param_specs, struct_name
152 );
153 }
154 QueryCommand::Exec => {
155 let _ = writeln!(
156 out,
157 "@spec {}(Exqlite.Sqlite3.db(){}) :: :ok | {{:error, term()}}",
158 func_name, param_specs
159 );
160 }
161 QueryCommand::ExecResult | QueryCommand::ExecRows => {
162 let _ = writeln!(
163 out,
164 "@spec {}(Exqlite.Sqlite3.db(){}) :: {{:ok, non_neg_integer()}} | {{:error, term()}}",
165 func_name, param_specs
166 );
167 }
168 }
169 let _ = writeln!(out, "def {}(conn{}{}) do", func_name, sep, param_list);
170
171 match &analyzed.command {
172 QueryCommand::One => {
173 let _ = writeln!(out, " sql = \"{}\"", sql);
174 let _ = writeln!(
175 out,
176 " case Exqlite.Sqlite3.execute(conn, sql, {}) do",
177 param_args
178 );
179 let _ = writeln!(out, " {{:ok, [[_|_] = row]}} ->");
180
181 let field_vars = columns
182 .iter()
183 .map(|c| c.field_name.clone())
184 .collect::<Vec<_>>()
185 .join(", ");
186 let _ = writeln!(out, " [{}] = row", field_vars);
187
188 let struct_fields = columns
189 .iter()
190 .map(|c| format!("{}: {}", c.field_name, c.field_name))
191 .collect::<Vec<_>>()
192 .join(", ");
193 let _ = writeln!(out, " {{:ok, %{}{{{}}}}}", struct_name, struct_fields);
194 let _ = writeln!(out, " {{:ok, []}} -> {{:error, :not_found}}");
195 let _ = writeln!(out, " {{:error, err}} -> {{:error, err}}");
196 let _ = writeln!(out, " end");
197 }
198 QueryCommand::Many | QueryCommand::Batch => {
199 let _ = writeln!(out, " sql = \"{}\"", sql);
200 let _ = writeln!(
201 out,
202 " case Exqlite.Sqlite3.execute(conn, sql, {}) do",
203 param_args
204 );
205 let _ = writeln!(out, " {{:ok, rows}} ->");
206
207 let field_vars = columns
208 .iter()
209 .map(|c| c.field_name.clone())
210 .collect::<Vec<_>>()
211 .join(", ");
212 let struct_fields = columns
213 .iter()
214 .map(|c| format!("{}: {}", c.field_name, c.field_name))
215 .collect::<Vec<_>>()
216 .join(", ");
217
218 let _ = writeln!(out, " results = Enum.map(rows, fn row ->");
219 let _ = writeln!(out, " [{}] = row", field_vars);
220 let _ = writeln!(out, " %{}{{{}}}", struct_name, struct_fields);
221 let _ = writeln!(out, " end)");
222 let _ = writeln!(out, " {{:ok, results}}");
223 let _ = writeln!(out, " {{:error, err}} -> {{:error, err}}");
224 let _ = writeln!(out, " end");
225 }
226 QueryCommand::Exec => {
227 let _ = writeln!(out, " sql = \"{}\"", sql);
228 let _ = writeln!(
229 out,
230 " case Exqlite.Sqlite3.execute(conn, sql, {}) do",
231 param_args
232 );
233 let _ = writeln!(out, " {{:ok, _}} -> :ok");
234 let _ = writeln!(out, " {{:error, err}} -> {{:error, err}}");
235 let _ = writeln!(out, " end");
236 }
237 QueryCommand::ExecResult | QueryCommand::ExecRows => {
238 let _ = writeln!(out, " sql = \"{}\"", sql);
239 let _ = writeln!(
240 out,
241 " case Exqlite.Sqlite3.execute(conn, sql, {}) do",
242 param_args
243 );
244 let _ = writeln!(out, " {{:ok, _}} ->");
245 let _ = writeln!(out, " {{:ok, Exqlite.Sqlite3.changes(conn)}}");
246 let _ = writeln!(out, " {{:error, err}} -> {{:error, err}}");
247 let _ = writeln!(out, " end");
248 }
249 }
250
251 let _ = write!(out, "end");
252 Ok(out)
253 }
254
255 fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
256 let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
257 let mut out = String::new();
258 let _ = writeln!(out, "defmodule {} do", type_name);
259 let _ = writeln!(
260 out,
261 " @moduledoc \"Enum type for {}.\"",
262 enum_info.sql_name
263 );
264 let _ = writeln!(out);
265 let _ = writeln!(out, " @type t :: String.t()");
266 for value in &enum_info.values {
267 let variant = enum_variant_name(value, &self.manifest.naming);
268 let _ = writeln!(
269 out,
270 " def {}(), do: \"{}\"",
271 to_snake_case(&variant),
272 value
273 );
274 }
275 let values_list = enum_info
276 .values
277 .iter()
278 .map(|v| format!("\"{}\"", v))
279 .collect::<Vec<_>>()
280 .join(", ");
281 let _ = writeln!(out, " def values, do: [{}]", values_list);
282 let _ = write!(out, "end");
283 Ok(out)
284 }
285
286 fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
287 let name = to_pascal_case(&composite.sql_name);
288 let mut out = String::new();
289 let _ = writeln!(out, "defmodule {} do", name);
290 let _ = writeln!(
291 out,
292 " @moduledoc \"Composite type for {}.\"",
293 composite.sql_name
294 );
295 let _ = writeln!(out);
296 if composite.fields.is_empty() {
297 let _ = writeln!(out, " defstruct []");
298 } else {
299 let fields = composite
300 .fields
301 .iter()
302 .map(|f| format!(":{}", to_snake_case(&f.name)))
303 .collect::<Vec<_>>()
304 .join(", ");
305 let _ = writeln!(out, " defstruct [{}]", fields);
306 }
307 let _ = write!(out, "end");
308 Ok(out)
309 }
310}