use scythe_backend::manifest::BackendManifest;
use scythe_backend::naming::{enum_type_name, fn_name, row_struct_name, to_camel_case, to_pascal_case};
use scythe_backend::types::resolve_type;
use std::fmt::Write;
use scythe_core::analyzer::{AnalyzedQuery, CompositeInfo, EnumInfo};
use scythe_core::errors::{ErrorCode, ScytheError};
use scythe_core::parser::QueryCommand;
use crate::backend_trait::{CodegenBackend, GroupedQueryFn, ResolvedColumn, ResolvedParam};
use crate::backends::typescript_common::{
TsRowType, escape_ts_template_literal, generate_grouped_interface_structs, generate_ts_grouped_fold_body,
generate_ts_interface_row_struct, generate_ts_union_row_struct, generate_zod_grouped_structs,
generate_zod_row_struct, generate_zod_union_row_struct, parse_bool_option,
};
use crate::singularize;
const DEFAULT_MANIFEST_TOML: &str = include_str!("../../manifests/typescript-snowflake.toml");
pub struct TypescriptSnowflakeBackend {
manifest: BackendManifest,
row_type: TsRowType,
outer_join_unions: bool,
structs_only: bool,
}
impl TypescriptSnowflakeBackend {
pub fn new(engine: &str) -> Result<Self, ScytheError> {
match engine {
"snowflake" => {}
_ => {
return Err(ScytheError::new(
ErrorCode::InternalError,
format!("typescript-snowflake only supports Snowflake, got engine '{}'", engine),
));
}
}
let manifest = super::parse_manifest(DEFAULT_MANIFEST_TOML)?;
Ok(Self {
manifest,
row_type: TsRowType::default(),
outer_join_unions: false,
structs_only: false,
})
}
}
impl CodegenBackend for TypescriptSnowflakeBackend {
fn name(&self) -> &str {
"typescript-snowflake"
}
fn manifest(&self) -> &scythe_backend::manifest::BackendManifest {
&self.manifest
}
fn supported_engines(&self) -> &[&str] {
&["snowflake"]
}
fn file_header(&self) -> String {
if self.structs_only {
let mut header = "/** Auto-generated by scythe. Do not edit. */\n".to_string();
if self.row_type == TsRowType::Zod {
header.push_str("\nimport { z } from \"zod\";\n");
}
return header;
}
let mut header = "/** Auto-generated by scythe. Do not edit. */\n\nimport type { Binds, Connection } from \"snowflake-sdk\";\n\nfunction normalizeRow(row: Record<string, unknown>): Record<string, unknown> {\n\treturn Object.fromEntries(\n\t\tObject.entries(row).map(([key, value]) => [key.toLowerCase(), value]),\n\t);\n}\n"
.to_string();
if self.row_type == TsRowType::Zod {
header.push_str("import { z } from \"zod\";\n");
}
header
}
fn generate_row_struct(&self, query_name: &str, columns: &[ResolvedColumn]) -> Result<String, ScytheError> {
let struct_name = row_struct_name(query_name, &self.manifest.naming);
if self.row_type == TsRowType::Zod {
if self.outer_join_unions {
return Ok(generate_zod_union_row_struct(&struct_name, query_name, columns));
}
return Ok(generate_zod_row_struct(&struct_name, query_name, columns));
}
if self.outer_join_unions {
return Ok(generate_ts_union_row_struct(&struct_name, query_name, columns, None));
}
Ok(generate_ts_interface_row_struct(&struct_name, query_name, columns))
}
fn generate_model_struct(&self, table_name: &str, columns: &[ResolvedColumn]) -> Result<String, ScytheError> {
let singular = singularize(table_name);
let name = to_pascal_case(&singular);
self.generate_row_struct(&name, columns)
}
fn generate_query_fn(
&self,
analyzed: &AnalyzedQuery,
struct_name: &str,
_columns: &[ResolvedColumn],
params: &[ResolvedParam],
) -> Result<String, ScytheError> {
if self.structs_only {
return Ok(String::new());
}
let func_name = fn_name(&analyzed.name, &self.manifest.naming);
let mut out = String::new();
let sql = escape_ts_template_literal(&super::rewrite_pg_placeholders(
&super::clean_sql_with_optional(&analyzed.sql, &analyzed.optional_params, &analyzed.params),
|_| "?".to_string(),
));
let write_fn_sig = |out: &mut String, name: &str, sig_params: &[(String, String)], ret: &str| {
let params_inline = sig_params
.iter()
.map(|(n, t)| format!("{n}: {t}"))
.collect::<Vec<_>>()
.join(", ");
let oneliner = format!("export async function {}({}): Promise<{}> {{", name, params_inline, ret);
if oneliner.len() <= 80 {
let _ = writeln!(out, "{}", oneliner);
} else {
let _ = writeln!(out, "export async function {}(", name);
for (n, t) in sig_params {
let _ = writeln!(out, "\t{}: {},", n, t);
}
let _ = writeln!(out, "): Promise<{}> {{", ret);
}
};
let query_sig_params: Vec<(String, String)> = std::iter::once(("conn".to_string(), "Connection".to_string()))
.chain(params.iter().map(|p| (p.field_name.clone(), p.full_type.clone())))
.collect();
let args: Vec<String> = params.iter().map(|p| p.field_name.clone()).collect();
let binds = format!("[{}] as unknown as Binds", args.join(", "));
let emit_execute = |out: &mut String, sql: &str, binds: &str, result_var: &str| {
let _ = writeln!(
out,
"\tconst {} = await new Promise<unknown[]>((resolve, reject) => {{",
result_var
);
let _ = writeln!(
out,
"\t\tconn.execute({{ sqlText: `{}`, binds: {}, complete: (err, _stmt, rows) => {{",
sql, binds
);
let _ = writeln!(out, "\t\t\tif (err) reject(err);");
let _ = writeln!(out, "\t\t\telse resolve((rows ?? []).map(normalizeRow));");
let _ = writeln!(out, "\t\t}}}});");
let _ = writeln!(out, "\t}});");
};
match &analyzed.command {
QueryCommand::One | QueryCommand::Opt => {
let _ = writeln!(out, "/** Fetch a single {} or null. */", struct_name);
let ret = format!("{} | null", struct_name);
write_fn_sig(&mut out, &func_name, &query_sig_params, &ret);
emit_execute(&mut out, &sql, &binds, "rows");
let _ = writeln!(out, "\treturn rows.length > 0 ? (rows[0] as {}) : null;", struct_name);
let _ = write!(out, "}}");
}
QueryCommand::Batch => {
let batch_fn_name = format!("{}Batch", func_name);
if params.len() > 1 {
let params_type_name = format!("{}BatchParams", struct_name);
let _ = writeln!(out, "/** Params for {} batch operation. */", struct_name);
let _ = writeln!(out, "export interface {} {{", params_type_name);
for p in params {
let _ = writeln!(out, "\t{}: {};", p.field_name, p.full_type);
}
let _ = writeln!(out, "}}");
let _ = writeln!(out);
let _ = writeln!(out, "/** Execute {} for each item in the batch. */", analyzed.name);
let batch_sig_params = vec![
("conn".to_string(), "Connection".to_string()),
("items".to_string(), format!("{}[]", params_type_name)),
];
write_fn_sig(&mut out, &batch_fn_name, &batch_sig_params, "void");
let _ = writeln!(out, "\tfor (const item of items) {{");
let _ = writeln!(out, "\t\tawait new Promise<void>((resolve, reject) => {{");
let args: Vec<String> = params.iter().map(|p| format!("item.{}", p.field_name)).collect();
let _ = writeln!(
out,
"\t\t\tconn.execute({{ sqlText: `{}`, binds: [{}] as unknown as Binds, complete: (err) => err ? reject(err) : resolve() }});",
sql,
args.join(", ")
);
let _ = writeln!(out, "\t\t}});");
let _ = writeln!(out, "\t}}");
let _ = write!(out, "}}");
} else if params.len() == 1 {
let _ = writeln!(out, "/** Execute {} for each item in the batch. */", analyzed.name);
let batch_sig_params = vec![
("conn".to_string(), "Connection".to_string()),
("items".to_string(), format!("{}[]", params[0].full_type)),
];
write_fn_sig(&mut out, &batch_fn_name, &batch_sig_params, "void");
let _ = writeln!(out, "\tfor (const item of items) {{");
let _ = writeln!(out, "\t\tawait new Promise<void>((resolve, reject) => {{");
let _ = writeln!(
out,
"\t\t\tconn.execute({{ sqlText: `{}`, binds: [item] as unknown as Binds, complete: (err) => err ? reject(err) : resolve() }});",
sql
);
let _ = writeln!(out, "\t\t}});");
let _ = writeln!(out, "\t}}");
let _ = write!(out, "}}");
} else {
let _ = writeln!(out, "/** Execute {} for each item in the batch. */", analyzed.name);
let batch_sig_params = vec![
("conn".to_string(), "Connection".to_string()),
("count".to_string(), "number".to_string()),
];
write_fn_sig(&mut out, &batch_fn_name, &batch_sig_params, "void");
let _ = writeln!(out, "\tfor (let i = 0; i < count; i++) {{");
let _ = writeln!(out, "\t\tawait new Promise<void>((resolve, reject) => {{");
let _ = writeln!(
out,
"\t\t\tconn.execute({{ sqlText: `{}`, complete: (err) => err ? reject(err) : resolve() }});",
sql
);
let _ = writeln!(out, "\t\t}});");
let _ = writeln!(out, "\t}}");
let _ = write!(out, "}}");
}
}
QueryCommand::Many => {
let _ = writeln!(out, "/** Fetch all {} rows. */", struct_name);
let ret = format!("{}[]", struct_name);
write_fn_sig(&mut out, &func_name, &query_sig_params, &ret);
emit_execute(&mut out, &sql, &binds, "rows");
let _ = writeln!(out, "\treturn rows as {}[];", struct_name);
let _ = write!(out, "}}");
}
QueryCommand::Exec => {
let _ = writeln!(out, "/** Execute a query returning no rows. */");
write_fn_sig(&mut out, &func_name, &query_sig_params, "void");
let _ = writeln!(out, "\tawait new Promise<void>((resolve, reject) => {{");
let _ = writeln!(
out,
"\t\tconn.execute({{ sqlText: `{}`, binds: {}, complete: (err) => err ? reject(err) : resolve() }});",
sql, binds
);
let _ = writeln!(out, "\t}});");
let _ = write!(out, "}}");
}
QueryCommand::Grouped => {
unreachable!("Grouped command is routed through generate_grouped_query_fn, not generate_query_fn")
}
QueryCommand::ExecResult | QueryCommand::ExecRows => {
let _ = writeln!(out, "/** Execute a query and return the number of affected rows. */");
write_fn_sig(&mut out, &func_name, &query_sig_params, "number");
let _ = writeln!(out, "\tconst count = await new Promise<number>((resolve, reject) => {{");
let _ = writeln!(
out,
"\t\tconn.execute({{ sqlText: `{}`, binds: {}, complete: (err, stmt) => {{",
sql, binds
);
let _ = writeln!(out, "\t\t\tif (err) reject(err);");
let _ = writeln!(out, "\t\t\telse resolve(stmt?.getNumUpdatedRows() ?? 0);");
let _ = writeln!(out, "\t\t}}}});");
let _ = writeln!(out, "\t}});");
let _ = writeln!(out, "\treturn count;");
let _ = write!(out, "}}");
}
}
Ok(out)
}
fn generate_grouped_structs(
&self,
parent_struct_name: &str,
child_struct_name: &str,
parent_columns: &[ResolvedColumn],
child_columns: &[ResolvedColumn],
_key_column: &str,
) -> Result<String, ScytheError> {
if self.row_type == TsRowType::Zod {
return Ok(generate_zod_grouped_structs(
child_struct_name,
parent_struct_name,
parent_columns,
child_columns,
));
}
Ok(generate_grouped_interface_structs(
child_struct_name,
parent_struct_name,
parent_columns,
child_columns,
))
}
fn generate_grouped_query_fn(&self, request: &GroupedQueryFn<'_>) -> Result<String, ScytheError> {
let analyzed = request.analyzed;
let parent_struct_name = request.parent_struct_name;
let child_struct_name = request.child_struct_name;
let parent_columns = request.parent_columns;
let child_columns = request.child_columns;
let params = request.params;
let key_column = request.key_column;
if self.structs_only {
return Ok(String::new());
}
let func_name = fn_name(&analyzed.name, &self.manifest.naming);
let sql_clean = super::clean_sql_with_optional(&analyzed.sql, &analyzed.optional_params, &analyzed.params);
let sql = escape_ts_template_literal(&super::rewrite_pg_placeholders(&sql_clean, |_n| "?".to_string()));
let param_list = params
.iter()
.map(|p| format!("{}: {}", p.field_name, p.full_type))
.collect::<Vec<_>>()
.join(", ");
let inline_params = if params.is_empty() {
"conn: Connection".to_string()
} else {
format!("conn: Connection, {}", param_list)
};
let ret = format!("Promise<{parent_struct_name}[]>");
let mut out = String::new();
let oneliner = format!("export async function {func_name}({inline_params}): {ret} {{");
if oneliner.len() <= 80 {
let _ = writeln!(out, "/** Fetch grouped {} rows. */", analyzed.name);
let _ = writeln!(out, "{oneliner}");
} else {
let _ = writeln!(out, "/** Fetch grouped {} rows. */", analyzed.name);
let _ = writeln!(out, "export async function {func_name}(");
let _ = writeln!(out, "\tconn: Connection,");
for p in params {
let _ = writeln!(out, "\t{}: {},", p.field_name, p.full_type);
}
let _ = writeln!(out, "): {ret} {{");
}
let binds_arg = if params.is_empty() {
String::new()
} else {
let args: Vec<String> = params.iter().map(|p| p.field_name.clone()).collect();
format!(", binds: [{}] as unknown as Binds", args.join(", "))
};
let _ = writeln!(
out,
"\tconst flatRows = await new Promise<Record<string, unknown>[]>((resolve, reject) => {{"
);
let _ = writeln!(out, "\t\tconn.execute({{");
let _ = writeln!(out, "\t\t\tsqlText: `{sql}`,");
if !binds_arg.is_empty() {
let _ = writeln!(out, "\t\t\t{},", &binds_arg[2..]);
}
let _ = writeln!(out, "\t\t\tcomplete: (err, _stmt, rows) => {{");
let _ = writeln!(out, "\t\t\t\tif (err) reject(err);");
let _ = writeln!(out, "\t\t\t\telse resolve((rows ?? []).map(normalizeRow));");
let _ = writeln!(out, "\t\t\t}},");
let _ = writeln!(out, "\t\t}});");
let _ = writeln!(out, "\t}});");
let fold = generate_ts_grouped_fold_body(
parent_struct_name,
child_struct_name,
parent_columns,
child_columns,
key_column,
|name, ty| format!("row['{name}'] as {ty}"),
);
out.push_str(&fold);
let _ = write!(out, "}}");
Ok(out)
}
fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
if self.row_type == TsRowType::Zod {
return Ok(super::typescript_common::generate_zod_enum(
&type_name,
&enum_info.values,
));
}
let mut out = String::new();
let variants: Vec<String> = enum_info.values.iter().map(|v| format!("\"{}\"", v)).collect();
let _ = write!(out, "export type {} = {};", type_name, variants.join(" | "));
Ok(out)
}
fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
let name = to_pascal_case(&composite.sql_name);
let mut out = String::new();
let _ = writeln!(out, "/** Composite type {}. */", composite.sql_name);
let _ = writeln!(out, "export interface {} {{", name);
for field in &composite.fields {
let ts_type = resolve_type(&field.neutral_type, &self.manifest, false)
.map(|t| t.into_owned())
.map_err(|e| {
ScytheError::new(ErrorCode::InternalError, format!("composite field type error: {}", e))
})?;
let _ = writeln!(out, "\t{}: {};", to_camel_case(&field.name), ts_type);
}
let _ = write!(out, "}}");
Ok(out)
}
fn apply_options(&mut self, options: &std::collections::HashMap<String, String>) -> Result<(), ScytheError> {
if let Some(value) = options.get("row_type") {
self.row_type = TsRowType::from_option(value)?;
}
if let Some(value) = options.get("outer_join_unions") {
self.outer_join_unions = parse_bool_option("outer_join_unions", value)?;
}
if let Some(value) = options.get("structs_only") {
self.structs_only = parse_bool_option("structs_only", value)?;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::TypescriptSnowflakeBackend;
use crate::backend_trait::CodegenBackend;
use scythe_core::analyzer::{AnalyzedColumn, AnalyzedParam, AnalyzedQuery, GroupByConfig};
use scythe_core::parser::QueryCommand;
fn discriminated_join_columns() -> Vec<crate::backend_trait::ResolvedColumn> {
use crate::backend_trait::ResolvedColumn;
vec![
ResolvedColumn {
name: "id".to_string(),
field_name: "id".to_string(),
lang_type: "number".to_string(),
full_type: "number".to_string(),
neutral_type: "int32".to_string(),
sql_type: "int4".to_string(),
nullable: false,
join_group: None,
nullable_before_join: false,
},
ResolvedColumn {
name: "total".to_string(),
field_name: "total".to_string(),
lang_type: "string".to_string(),
full_type: "string | null".to_string(),
neutral_type: "decimal".to_string(),
sql_type: "numeric".to_string(),
nullable: true,
join_group: Some("o".to_string()),
nullable_before_join: false,
},
]
}
#[test]
fn test_zod_row_type_combined_with_outer_join_unions_emits_a_real_union_schema() {
let mut backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
backend
.apply_options(&std::collections::HashMap::from([
("row_type".to_string(), "zod".to_string()),
("outer_join_unions".to_string(), "true".to_string()),
]))
.unwrap();
let row_struct = backend
.generate_row_struct("GetUserOrders", &discriminated_join_columns())
.unwrap();
assert!(
row_struct.contains(".and(z.union(["),
"must emit a real discriminated union; got:\n{row_struct}"
);
}
#[test]
fn test_zod_row_type_without_outer_join_unions_is_unchanged() {
let mut backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
backend
.apply_options(&std::collections::HashMap::from([(
"row_type".to_string(),
"zod".to_string(),
)]))
.unwrap();
let row_struct = backend
.generate_row_struct("GetUserOrders", &discriminated_join_columns())
.unwrap();
assert_eq!(
row_struct,
crate::backends::typescript_common::generate_zod_row_struct(
"GetUserOrdersRow",
"GetUserOrders",
&discriminated_join_columns()
)
);
}
fn make_one_query(sql: &str) -> AnalyzedQuery {
AnalyzedQuery {
name: "GetUserById".to_string(),
command: QueryCommand::One,
sql: sql.to_string(),
columns: vec![AnalyzedColumn {
name: "id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
..Default::default()
}],
params: vec![],
deprecated: None,
source_table: None,
composites: vec![],
enums: vec![],
optional_params: vec![],
group_by: None,
custom: vec![],
}
}
#[test]
fn test_query_fn_escapes_user_backtick_in_sql() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let query = make_one_query("SELECT id FROM users WHERE name = `oops`");
let result = crate::generate_with_backend(&query, &backend).unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(
query_fn.contains(r"WHERE name = \`oops\`"),
"user backtick must be escaped; got:\n{query_fn}"
);
}
#[test]
fn test_query_fn_escapes_user_dollar_brace_in_sql() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let query = make_one_query("SELECT id FROM users WHERE name = 'literal ${evil}'");
let result = crate::generate_with_backend(&query, &backend).unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(
query_fn.contains(r"'literal \${evil}'"),
"user's literal ${{}} must be escaped; got:\n{query_fn}"
);
}
#[test]
fn test_query_fn_escapes_user_backslash_in_sql() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let query = make_one_query(r"SELECT id FROM users WHERE name = 'a\\b'");
let result = crate::generate_with_backend(&query, &backend).unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(
query_fn.contains(r"'a\\\\b'"),
"user backslash must be doubled; got:\n{query_fn}"
);
}
fn make_grouped_query() -> AnalyzedQuery {
let parent_cols = vec![
AnalyzedColumn {
name: "id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
..Default::default()
},
AnalyzedColumn {
name: "name".to_string(),
neutral_type: "string".to_string(),
nullable: false,
..Default::default()
},
];
let child_cols = vec![
AnalyzedColumn {
name: "order_id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
..Default::default()
},
AnalyzedColumn {
name: "total".to_string(),
neutral_type: "decimal".to_string(),
nullable: true,
..Default::default()
},
];
let all_cols = [parent_cols.clone(), child_cols.clone()].concat();
AnalyzedQuery {
name: "GetUsersWithOrders".to_string(),
command: QueryCommand::Grouped,
sql: "SELECT u.id, u.name, o.id AS order_id, o.total FROM users u JOIN orders o ON o.user_id = u.id"
.to_string(),
columns: all_cols,
params: vec![],
deprecated: None,
source_table: None,
composites: vec![],
enums: vec![],
optional_params: vec![],
group_by: Some(GroupByConfig {
table: "users".to_string(),
key_column: "id".to_string(),
parent_columns: parent_cols,
child_columns: child_cols,
}),
custom: vec![],
}
}
#[test]
fn test_grouped_typescript_snowflake_structs() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let query = make_grouped_query();
let result = crate::generate_with_backend(&query, &backend).unwrap();
let row_struct = result.row_struct.as_deref().unwrap();
assert!(
row_struct.contains("interface GetUsersWithOrdersChildRow"),
"missing child; got:\n{row_struct}"
);
assert!(
row_struct.contains("interface GetUsersWithOrdersRow"),
"missing parent; got:\n{row_struct}"
);
assert!(
row_struct.contains("children: GetUsersWithOrdersChildRow[]"),
"missing children; got:\n{row_struct}"
);
let child_pos = row_struct.find("GetUsersWithOrdersChildRow").unwrap();
let parent_pos = row_struct.find("interface GetUsersWithOrdersRow").unwrap();
assert!(child_pos < parent_pos, "child must precede parent");
}
#[test]
fn test_grouped_typescript_snowflake_query_fn() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let query = make_grouped_query();
let result = crate::generate_with_backend(&query, &backend).unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(query_fn.contains("getUsersWithOrders"), "missing fn; got:\n{query_fn}");
assert!(
query_fn.contains("Promise<GetUsersWithOrdersRow[]>"),
"wrong return type; got:\n{query_fn}"
);
assert!(
query_fn.contains("new Promise<Record<string, unknown>[]>"),
"must wrap in Promise; got:\n{query_fn}"
);
assert!(!query_fn.contains("any["), "must not emit any[]; got:\n{query_fn}");
assert!(
query_fn.contains("(rows ?? []).map(normalizeRow)"),
"must normalize Snowflake's uppercase column names; got:\n{query_fn}"
);
assert!(
query_fn.contains("conn.execute"),
"must use conn.execute; got:\n{query_fn}"
);
assert!(
query_fn.contains("row['id']"),
"must use bracket access; got:\n{query_fn}"
);
assert!(
query_fn.contains("new Map<unknown, GetUsersWithOrdersRow>()"),
"must use Map; got:\n{query_fn}"
);
assert!(
query_fn.contains("parent.children.push"),
"must fold children; got:\n{query_fn}"
);
}
#[test]
fn test_typescript_snowflake_uses_scalar_binds_for_single_execution() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let query = AnalyzedQuery {
name: "DeleteUser".to_string(),
command: QueryCommand::Exec,
sql: "DELETE FROM users WHERE id = $1".to_string(),
columns: vec![],
params: vec![AnalyzedParam {
name: "id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
position: 1,
}],
deprecated: None,
source_table: None,
composites: vec![],
enums: vec![],
optional_params: vec![],
group_by: None,
custom: vec![],
};
let result = crate::generate_with_backend(&query, &backend).unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(
query_fn.contains("binds: [id] as unknown as Binds"),
"must use scalar binds; got:\n{query_fn}"
);
assert!(
!query_fn.contains("binds: [[id]]"),
"must not use array binds; got:\n{query_fn}"
);
}
#[test]
fn test_typescript_snowflake_normalizes_result_column_names() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let header = backend.file_header();
assert!(
header.contains("key.toLowerCase()"),
"must normalize Snowflake column names; got:\n{header}"
);
}
#[test]
fn test_structs_only_suppresses_query_fn_import_and_normalize_row_helper() {
let mut backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
backend
.apply_options(&std::collections::HashMap::from([(
"structs_only".to_string(),
"true".to_string(),
)]))
.unwrap();
let query = make_one_query("SELECT id FROM users WHERE id = $1");
let result = crate::generate_with_backend(&query, &backend).unwrap();
assert_eq!(
result.query_fn.as_deref(),
Some(""),
"structs_only must suppress the query function"
);
assert!(
result
.row_struct
.as_deref()
.unwrap()
.contains("interface GetUserByIdRow"),
"row struct must still be emitted"
);
let header = backend.file_header();
assert!(
!header.contains("snowflake-sdk"),
"the unused snowflake-sdk driver import must be dropped; got:\n{header}"
);
assert!(
!header.contains("normalizeRow"),
"the unused normalizeRow helper must be dropped; got:\n{header}"
);
}
#[test]
fn test_structs_only_unset_leaves_query_fn_present() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let query = make_one_query("SELECT id FROM users WHERE id = $1");
let result = crate::generate_with_backend(&query, &backend).unwrap();
assert!(
!result.query_fn.as_deref().unwrap().is_empty(),
"without structs_only the query function must still be generated"
);
let header = backend.file_header();
assert!(header.contains("snowflake-sdk"));
assert!(header.contains("normalizeRow"));
}
#[test]
fn test_structs_only_rejects_invalid_value() {
let mut backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let result = backend.apply_options(&std::collections::HashMap::from([(
"structs_only".to_string(),
"maybe".to_string(),
)]));
assert!(result.is_err(), "expected 'maybe' to be rejected");
}
#[test]
fn test_structs_only_combined_with_zod_row_type_keeps_zod_import_and_schema() {
let mut backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
backend
.apply_options(&std::collections::HashMap::from([
("structs_only".to_string(), "true".to_string()),
("row_type".to_string(), "zod".to_string()),
]))
.unwrap();
let query = make_one_query("SELECT id FROM users WHERE id = $1");
let result = crate::generate_with_backend(&query, &backend).unwrap();
assert_eq!(result.query_fn.as_deref(), Some(""));
assert!(
result.row_struct.as_deref().unwrap().contains("z.object({"),
"zod schema must still be emitted"
);
let header = backend.file_header();
assert!(header.contains("import { z } from \"zod\";"), "got:\n{header}");
assert!(!header.contains("snowflake-sdk"), "got:\n{header}");
}
fn make_batch_query(name: &str, sql: &str, params: Vec<AnalyzedParam>) -> AnalyzedQuery {
AnalyzedQuery {
name: name.to_string(),
command: QueryCommand::Batch,
sql: sql.to_string(),
columns: vec![],
params,
deprecated: None,
source_table: None,
composites: vec![],
enums: vec![],
optional_params: vec![],
group_by: None,
custom: vec![],
}
}
#[test]
fn test_batch_signature_wrap_declares_items_not_raw_columns() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let query = make_batch_query(
"CreateUserAccountRecord",
"INSERT INTO user_account_record (name, email) VALUES ($1, $2)",
vec![
AnalyzedParam {
name: "name".to_string(),
neutral_type: "string".to_string(),
nullable: false,
position: 1,
},
AnalyzedParam {
name: "email".to_string(),
neutral_type: "string".to_string(),
nullable: false,
position: 2,
},
],
);
let result = crate::generate_with_backend(&query, &backend).unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(
query_fn.contains("\titems: CreateUserAccountRecordRowBatchParams[],"),
"wrapped batch signature must declare items with the batch params type; got:\n{query_fn}"
);
assert!(
!query_fn.contains("\tname: string,") && !query_fn.contains("\temail: string,"),
"wrapped batch signature must not fall back to the raw per-column params; got:\n{query_fn}"
);
assert!(
query_fn.contains("for (const item of items)"),
"every identifier the body references (items) must be declared in the signature; got:\n{query_fn}"
);
}
#[test]
fn test_batch_signature_wrap_preserves_json_param_type_intact() {
let backend = TypescriptSnowflakeBackend::new("snowflake").unwrap();
let query = make_batch_query(
"CreateUserAccountRecordPayload",
"INSERT INTO user_account_record_payload (payload) VALUES ($1)",
vec![AnalyzedParam {
name: "payload".to_string(),
neutral_type: "json".to_string(),
nullable: false,
position: 1,
}],
);
let result = crate::generate_with_backend(&query, &backend).unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(
query_fn.contains("\titems: Record<string, unknown>[],"),
"the json param's type must survive intact on the items line, not be split \
on its internal ', '; got:\n{query_fn}"
);
assert!(
!query_fn.contains("Record<string,\n"),
"the json type must not be split at its internal comma; got:\n{query_fn}"
);
}
}