@an5/orm 1.0.9 → 1.1.1

package/dist/generator/src/rust-generator.js

@@ -0,0 +1,971 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RustGenerator = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const types_1 = require("./types");
+const type_kinds_1 = require("./type-kinds");
+class RustGenerator {
+    constructor(outputDir) {
+        this.outputDir = outputDir;
+        if (!fs_1.default.existsSync(this.outputDir)) {
+            fs_1.default.mkdirSync(this.outputDir, { recursive: true });
+        }
+        const srcDir = path_1.default.join(this.outputDir, 'src');
+        if (!fs_1.default.existsSync(srcDir)) {
+            fs_1.default.mkdirSync(srcDir, { recursive: true });
+        }
+    }
+    generate(models) {
+        this.provider = models[0]?.provider;
+        this.generateCargoToml();
+        this.generateLibRs(models);
+        this.generateFiltersRs();
+        this.generateModelsRs(models);
+        this.generateMetadataRs(models);
+        this.generateConfigRs();
+        this.generateClientRs(models);
+    }
+    // ─── Cargo.toml ────────────────────────────────────────────────────────────
+    generateCargoToml() {
+        const content = `[package]
+name = "an5-client"
+version = "0.1.0"
+edition = "2021"
+description = "Generated AN5 ORM client for Rust — typed models, filters and an adapter-backed ORM client."
+license = "MIT"
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+chrono = { version = "0.4", features = ["serde"] }
+an5-adapters = "0.1"
+`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'Cargo.toml'), content);
+    }
+    // ─── src/lib.rs ────────────────────────────────────────────────────────────
+    generateLibRs(models) {
+        const modList = ['filters', 'models', 'metadata', 'config', 'client'];
+        let content = `//! AN5 ORM generated Rust client.\n//! Code generated by an5ORM. DO NOT EDIT.\n\n`;
+        for (const m of modList) {
+            content += `pub mod ${m};\n`;
+        }
+        content += `\npub use filters::*;\n`;
+        content += `pub use models::*;\n`;
+        content += `pub use metadata::*;\n`;
+        content += `pub use config::*;\n`;
+        content += `pub use client::*;\n`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'src', 'lib.rs'), content);
+    }
+    // ─── src/filters.rs ────────────────────────────────────────────────────────
+    generateFiltersRs() {
+        const content = `//! Shared filter types for AN5 Rust client.
+//! Code generated by an5ORM. DO NOT EDIT.
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+/// Sort direction.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum SortOrder {
+    Asc,
+    Desc,
+}
+
+impl SortOrder {
+    pub fn as_sql(&self) -> &'static str {
+        match self {
+            SortOrder::Asc => "ASC",
+            SortOrder::Desc => "DESC",
+        }
+    }
+}
+
+/// Database dialect for identifier quoting / placeholders.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Dialect {
+    Mssql,
+    Postgres,
+    Sqlite,
+}
+
+impl Dialect {
+    pub fn detect(conn_str: &str) -> Self {
+        let l = conn_str.trim().to_lowercase();
+        if l.starts_with("postgres://")
+            || l.starts_with("postgresql://")
+            || l.contains("port=5432")
+        {
+            return Dialect::Postgres;
+        }
+        if l.starts_with("sqlite://")
+            || l.starts_with("sqlite:")
+            || l.starts_with("file:")
+            || l.ends_with(".db")
+            || l.ends_with(".sqlite")
+            || l.ends_with(".sqlite3")
+            || l == ":memory:"
+        {
+            return Dialect::Sqlite;
+        }
+        Dialect::Mssql
+    }
+
+    pub fn quote_ident(&self, name: &str) -> String {
+        match self {
+            Dialect::Postgres | Dialect::Sqlite => {
+                format!("\\"{}\\"", name.replace('"', "\\"\\""))
+            }
+            Dialect::Mssql => format!("[{}]", name.replace(']', "]]")),
+        }
+    }
+
+    pub fn placeholder(&self, n: usize) -> String {
+        match self {
+            Dialect::Postgres => format!("\${}", n),
+            _ => "?".to_string(),
+        }
+    }
+}
+
+/// A typed bind parameter produced by the query builders.
+///
+/// Values keep their Rust type so drivers can bind them natively (a Bool
+/// must not become the string "true" when the column is an integer).
+#[derive(Debug, Clone, PartialEq)]
+pub enum BindValue {
+    Text(String),
+    Int(i64),
+    Float(f64),
+    Bool(bool),
+    /// RFC 3339 timestamp.
+    DateTime(String),
+}
+
+impl BindValue {
+    /// Textual rendering, useful for logging or drivers that take strings.
+    pub fn as_str(&self) -> String {
+        match self {
+            BindValue::Text(v) => v.clone(),
+            BindValue::Int(v) => v.to_string(),
+            BindValue::Float(v) => v.to_string(),
+            BindValue::Bool(v) => v.to_string(),
+            BindValue::DateTime(v) => v.clone(),
+        }
+    }
+}
+
+impl std::fmt::Display for BindValue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl From<&str> for BindValue {
+    fn from(v: &str) -> Self {
+        BindValue::Text(v.to_string())
+    }
+}
+
+impl From<String> for BindValue {
+    fn from(v: String) -> Self {
+        BindValue::Text(v)
+    }
+}
+
+impl From<i64> for BindValue {
+    fn from(v: i64) -> Self {
+        BindValue::Int(v)
+    }
+}
+
+impl From<f64> for BindValue {
+    fn from(v: f64) -> Self {
+        BindValue::Float(v)
+    }
+}
+
+impl From<bool> for BindValue {
+    fn from(v: bool) -> Self {
+        BindValue::Bool(v)
+    }
+}
+
+/// Type-safe filter for string fields.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StringFilter {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub equals: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub not: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub contains: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub starts_with: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ends_with: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gt: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gte: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lt: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lte: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub in_list: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub not_in: Vec<String>,
+}
+
+/// Type-safe filter for integer fields.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IntFilter {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub equals: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub not: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gt: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gte: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lt: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lte: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub in_list: Vec<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub not_in: Vec<i64>,
+}
+
+/// Type-safe filter for float / decimal fields.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NumberFilter {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub equals: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub not: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gt: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gte: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lt: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lte: Option<f64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub in_list: Vec<f64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub not_in: Vec<f64>,
+}
+
+/// Deserializes a boolean that some engines store as 0/1 or "0"/"1"
+/// (SQLite, MySQL TINYINT, MSSQL BIT via JSON).
+pub fn deserialize_bool_flexible<'de, D>(deserializer: D) -> Result<bool, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    match serde_json::Value::deserialize(deserializer)? {
+        serde_json::Value::Bool(b) => Ok(b),
+        serde_json::Value::Number(n) => Ok(n.as_i64().unwrap_or(0) != 0),
+        serde_json::Value::String(s) => match s.trim().to_ascii_lowercase().as_str() {
+            "1" | "true" | "t" | "yes" | "y" => Ok(true),
+            "0" | "false" | "f" | "no" | "n" | "" => Ok(false),
+            _ => Err(serde::de::Error::custom(format!("cannot parse {s:?} as a boolean"))),
+        },
+        _ => Err(serde::de::Error::custom("expected a boolean value")),
+    }
+}
+
+/// Optional variant of deserialize_bool_flexible.
+pub fn deserialize_option_bool_flexible<'de, D>(deserializer: D) -> Result<Option<bool>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    match serde_json::Value::deserialize(deserializer)? {
+        serde_json::Value::Null => Ok(None),
+        other => {
+            let as_bool = match other {
+                serde_json::Value::Bool(b) => b,
+                serde_json::Value::Number(n) => n.as_i64().unwrap_or(0) != 0,
+                serde_json::Value::String(s) => match s.trim().to_ascii_lowercase().as_str() {
+                    "1" | "true" | "t" | "yes" | "y" => true,
+                    "0" | "false" | "f" | "no" | "n" | "" => false,
+                    _ => {
+                        return Err(serde::de::Error::custom(format!(
+                            "cannot parse {s:?} as a boolean"
+                        )))
+                    }
+                },
+                _ => return Err(serde::de::Error::custom("expected a boolean value")),
+            };
+            Ok(Some(as_bool))
+        }
+    }
+}
+
+/// Type-safe filter for boolean fields.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BoolFilter {
+    #[serde(
+        default,
+        deserialize_with = "deserialize_option_bool_flexible",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub equals: Option<bool>,
+}
+
+/// Type-safe filter for datetime fields.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DateTimeFilter {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub equals: Option<DateTime<Utc>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub not: Option<DateTime<Utc>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gt: Option<DateTime<Utc>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gte: Option<DateTime<Utc>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lt: Option<DateTime<Utc>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lte: Option<DateTime<Utc>>,
+}
+
+// ─── SQL fragment builders (shared) ─────────────────────────────────────────
+
+
+
+
+
+
+`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'src', 'filters.rs'), content);
+    }
+    // ─── src/models.rs ─────────────────────────────────────────────────────────
+    generateModelsRs(models) {
+        let content = `//! Entity structs + typed Where / OrderBy / Args.\n//! Code generated by an5ORM. DO NOT EDIT.\n\nuse chrono::{DateTime, Utc};\nuse serde::{Deserialize, Serialize};\nuse crate::filters::*;\n\n`;
+        let out = this.buildModelsBody(models);
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'src', 'models.rs'), content + out);
+    }
+    buildModelsBody(models) {
+        let s = [];
+        for (const model of models) {
+            const name = this.capitalize(model.name);
+            if (model.description) {
+                s.push(`/// ${model.description}`);
+            }
+            s.push(`#[derive(Debug, Clone, Serialize, Deserialize)]`);
+            s.push(`pub struct ${name} {`);
+            for (const f of model.fields) {
+                // A field with a schema default (`@default(now())`) may come back NULL
+                // when the caller never set it, so it is optional here just like in
+                // CreateInput. Matches the Python generator's required-field rule.
+                const isOptional = f.isOptional || f.hasDefault;
+                const rsType = this.mapRustType(f, isOptional);
+                const snake = this.toSnakeCase(f.name);
+                if (f.description) {
+                    s.push(`    /// ${f.description}`);
+                }
+                if (isOptional) {
+                    if (this.isBoolField(f)) {
+                        s.push(`    #[serde(default, deserialize_with = "deserialize_option_bool_flexible", skip_serializing_if = "Option::is_none")]`);
+                    }
+                    else {
+                        s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+                    }
+                }
+                else if (this.isBoolField(f)) {
+                    s.push(`    #[serde(deserialize_with = "deserialize_bool_flexible")]`);
+                }
+                s.push(`    pub ${snake}: ${rsType},`);
+            }
+            for (const rel of model.relations) {
+                const relSnake = this.toSnakeCase(rel.name);
+                const relType = rel.isArray
+                    ? `Vec<super::models::${this.capitalize(rel.type)}>`
+                    : `Option<Box<super::models::${this.capitalize(rel.type)}>>`;
+                s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+                // Optional relations are always Option-wrapped for ergonomics.
+                if (rel.isArray) {
+                    s.push(`    pub ${relSnake}: Option<${relType}>,`);
+                }
+                else {
+                    s.push(`    pub ${relSnake}: ${relType},`);
+                }
+            }
+            s.push(`}\n`);
+            // WhereInput
+            s.push(`/// Type-safe WHERE filter for ${name} queries.`);
+            s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
+            s.push(`pub struct ${name}WhereInput {`);
+            s.push(`    #[serde(default, rename = "AND", skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub and: Option<Vec<${name}WhereInput>>,`);
+            s.push(`    #[serde(default, rename = "OR", skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub or: Option<Vec<${name}WhereInput>>,`);
+            s.push(`    #[serde(default, rename = "NOT", skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub not: Option<Box<${name}WhereInput>>,`);
+            for (const f of model.fields) {
+                const ft = this.getRustFilterType(f);
+                const snake = this.toSnakeCase(f.name);
+                s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+                s.push(`    pub ${snake}: Option<${ft}>,`);
+            }
+            s.push(`}\n`);
+            // OrderByInput
+            s.push(`/// Type-safe ORDER BY for ${name} queries.`);
+            s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
+            s.push(`pub struct ${name}OrderByInput {`);
+            for (const f of model.fields) {
+                const snake = this.toSnakeCase(f.name);
+                s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+                s.push(`    pub ${snake}: Option<SortOrder>,`);
+            }
+            s.push(`}\n`);
+            // CreateInput (skip @id auto fields from required set via hasDefault)
+            s.push(`/// Typed data for creating a new ${name} record.`);
+            s.push(`#[derive(Debug, Clone, Serialize, Deserialize)]`);
+            s.push(`pub struct ${name}CreateInput {`);
+            for (const f of model.fields) {
+                if (f.isId && f.hasDefault)
+                    continue;
+                const snake = this.toSnakeCase(f.name);
+                const isOpt = f.isOptional || f.hasDefault;
+                const rsType = this.mapRustType(f, isOpt);
+                if (isOpt) {
+                    s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+                }
+                s.push(`    pub ${snake}: ${rsType},`);
+            }
+            s.push(`}\n`);
+            // UpdateInput (all non-id optional)
+            s.push(`/// Typed data for updating an existing ${name} record.`);
+            s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
+            s.push(`pub struct ${name}UpdateInput {`);
+            for (const f of model.fields) {
+                if (f.isId)
+                    continue;
+                const snake = this.toSnakeCase(f.name);
+                const rsType = this.mapRustType(f, true);
+                s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+                s.push(`    pub ${snake}: ${rsType},`);
+            }
+            s.push(`}\n`);
+            // FindManyArgs / FindFirstArgs / FindUniqueArgs / CountArgs
+            s.push(`/// ORM-style args for ${name}.find_many().`);
+            s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
+            s.push(`pub struct ${name}FindManyArgs {`);
+            s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub where_: Option<${name}WhereInput>,`);
+            s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub order_by: Option<${name}OrderByInput>,`);
+            s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub take: Option<i64>,`);
+            s.push(`    #[serde(default)]`);
+            s.push(`    pub skip: i64,`);
+            s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub select: Option<Vec<String>>,`);
+            s.push(`}\n`);
+            s.push(`/// ORM-style args for ${name}.find_first().`);
+            s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
+            s.push(`pub struct ${name}FindFirstArgs {`);
+            s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub where_: Option<${name}WhereInput>,`);
+            s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub order_by: Option<${name}OrderByInput>,`);
+            s.push(`}\n`);
+            s.push(`/// ORM-style args for ${name}.find_unique() / count() / delete().`);
+            s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
+            s.push(`pub struct ${name}FindUniqueArgs {`);
+            s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub where_: Option<${name}WhereInput>,`);
+            s.push(`}\n`);
+            // UpdateArgs carries the typed input alongside the where clause.
+            s.push(`/// ORM-style args for ${name}.update().`);
+            s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
+            s.push(`pub struct ${name}UpdateArgs {`);
+            s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+            s.push(`    pub where_: Option<${name}WhereInput>,`);
+            s.push(`    #[serde(default)]`);
+            s.push(`    pub data: ${name}UpdateInput,`);
+            s.push(`}\n`);
+        }
+        return s.join('\n') + '\n';
+    }
+    // ─── src/metadata.rs ───────────────────────────────────────────────────────
+    generateMetadataRs(models) {
+        let content = `//! Model → table mapping.\n//! Code generated by an5ORM. DO NOT EDIT.\n\n`;
+        content += `/// Resolve a model alias (User, user, users, …) to \`schema.table\`.\n`;
+        content += `pub fn model_to_table(model: &str) -> Option<&'static str> {\n    match model {\n`;
+        const seen = new Set();
+        for (const model of models) {
+            const full = (0, types_1.bracketedTableName)(model);
+            for (const prop of this.getAllPropertyVariations(model.name)) {
+                if (seen.has(prop))
+                    continue;
+                seen.add(prop);
+                content += `        "${prop}" => Some("${full}"),\n`;
+            }
+        }
+        content += `        _ => None,\n    }\n}\n\n`;
+        // Full alias → table map, handed to the adapter so `db.table("user")`
+        // resolves exactly like `db.user` does in the other languages.
+        content += `/// Every model alias mapped to its physical table, for adapter registration.\n`;
+        content += `pub fn model_to_table_map() -> Vec<(&'static str, &'static str)> {\n    vec![\n`;
+        const seenMap = new Set();
+        for (const model of models) {
+            const full = (0, types_1.bracketedTableName)(model);
+            for (const prop of this.getAllPropertyVariations(model.name)) {
+                if (seenMap.has(prop))
+                    continue;
+                seenMap.add(prop);
+                content += `        ("${prop}", "${full}"),\n`;
+            }
+        }
+        content += `    ]\n}\n\n`;
+        content += `/// Primary-key column (snake_case) for a model alias.\n`;
+        content += `pub fn model_primary_key(model: &str) -> Option<&'static str> {\n    match model {\n`;
+        const seenPk = new Set();
+        for (const model of models) {
+            const idField = model.fields.find((f) => f.isId) ?? model.fields[0];
+            const pkCol = idField ? this.toSnakeCase(idField.name) : 'id';
+            for (const prop of this.getAllPropertyVariations(model.name)) {
+                if (seenPk.has(prop))
+                    continue;
+                seenPk.add(prop);
+                content += `        "${prop}" => Some("${pkCol}"),\n`;
+            }
+        }
+        content += `        _ => None,\n    }\n}\n`;
+        // Field metadata, handed to the adapter so it can apply schema defaults
+        // (for example generating a UUID for a string @id marked @default(uuid())).
+        content += `/// Field metadata per model alias, for adapter registration.\n`;
+        content += `pub fn model_fields_map() -> Vec<(&'static str, serde_json::Value)> {\n    vec![\n`;
+        const seenFields = new Set();
+        for (const model of models) {
+            for (const prop of this.getAllPropertyVariations(model.name)) {
+                if (seenFields.has(prop))
+                    continue;
+                seenFields.add(prop);
+                const fieldEntries = model.fields.map((f) => {
+                    const parts = [
+                        `"ts": ${JSON.stringify(f.type + (f.isOptional ? '?' : ''))}`,
+                        `"sql": ${JSON.stringify(f.sqlType)}`,
+                        `"isId": ${f.isId}`,
+                        `"isOptional": ${f.isOptional}`,
+                        `"hasDefault": ${f.hasDefault}`,
+                    ];
+                    if (f.description)
+                        parts.push(`"description": ${JSON.stringify(f.description)}`);
+                    return `"${f.name}": { ${parts.join(', ')} }`;
+                });
+                content += '        ("' + prop + '", serde_json::json!({ ' + fieldEntries.join(', ') + ' })),\n';
+            }
+        }
+        content += "    ]\n}\n\n";
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'src', 'metadata.rs'), content);
+    }
+    // ─── src/config.rs ─────────────────────────────────────────────────────────
+    generateConfigRs() {
+        const content = `//! Connection-string helpers.\n//! Code generated by an5ORM. DO NOT EDIT.\n\n/// Read DATABASE_URL or fall back to a local MSSQL default.\npub fn get_default_connection_string() -> String {\n    std::env::var("DATABASE_URL").unwrap_or_else(|_| {\n        "Server=localhost;Database=master;Trusted_Connection=True;TrustServerCertificate=True;"\n            .to_string()\n    })\n}\n`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'src', 'config.rs'), content);
+    }
+    // ─── src/client.rs ─────────────────────────────────────────────────────────
+    generateClientRs(models) {
+        let content = `//! Typed model handles, SQL builders and vector math for the AN5 Rust client.
+//! Code generated by an5ORM. DO NOT EDIT.
+
+use an5_adapters::{
+    AdapterMetadata, An5Adapter, CountArgs, DeleteManyArgs, FindManyArgs, RowMap, TableClient,
+    UpdateArgs,
+};
+use serde::de::DeserializeOwned;
+
+use crate::filters::*;
+use crate::metadata::{model_fields_map, model_primary_key, model_to_table, model_to_table_map};
+use crate::models::*;
+
+/// Error type shared with the adapter runtime.
+pub type Result<T> = an5_adapters::Result<T>;
+
+/// Serializes an optional ORM input into the JSON shape the adapter expects.
+fn to_value<T: serde::Serialize>(input: &Option<T>) -> Result<Option<serde_json::Value>> {
+    match input {
+        Some(v) => Ok(Some(serde_json::to_value(v)?)),
+        None => Ok(None),
+    }
+}
+
+/// Serializes an input into the row map used for writes.
+fn to_map<T: serde::Serialize>(input: &T) -> Result<RowMap> {
+    Ok(serde_json::to_value(input)?
+        .as_object()
+        .cloned()
+        .unwrap_or_default())
+}
+
+/// Converts an adapter row into a generated model.
+fn deserialize_row<T: DeserializeOwned>(row: RowMap) -> Result<T> {
+    Ok(serde_json::from_value(serde_json::Value::Object(row))?)
+}
+
+/// Converts adapter rows into generated models.
+fn deserialize_rows<T: DeserializeOwned>(rows: Vec<RowMap>) -> Result<Vec<T>> {
+    rows.into_iter().map(deserialize_row).collect()
+}
+
+/// Main ORM context. Wraps the an5-adapters runtime.
+#[derive(Clone)]
+pub struct An5Client {
+    adapter: An5Adapter,
+}
+
+impl An5Client {
+    /// Connect and register this client's model to table mapping.
+    pub async fn connect(connection_string: &str) -> Result<Self> {
+        let adapter = An5Adapter::connect(connection_string).await?;
+        Ok(Self::from_adapter(adapter))
+    }
+
+    /// Wrap an existing adapter, registering this client's metadata.
+    pub fn from_adapter(adapter: An5Adapter) -> Self {
+        let mut map = std::collections::HashMap::new();
+        for (alias, table) in model_to_table_map() {
+            map.insert(alias.to_string(), table.to_string());
+        }
+        let mut fields = std::collections::HashMap::new();
+        for (alias, field_meta) in model_fields_map() {
+            fields.insert(alias.to_string(), field_meta);
+        }
+        adapter.set_metadata(AdapterMetadata {
+            model_to_table: map,
+            model_fields: fields,
+            ..Default::default()
+        });
+        Self { adapter }
+    }
+
+    /// The underlying adapter, for raw SQL, views and transactions.
+    pub fn adapter(&self) -> &An5Adapter {
+        &self.adapter
+    }
+
+    /// Dynamic access by model name, the equivalent of \`db.table("User")\`.
+    pub fn table(&self, name: &str) -> TableClient {
+        self.adapter.table(name)
+    }
+
+    /// Point a model at a different physical table (schema-less engines).
+    pub fn with_table(self, model: &str, table: &str) -> Self {
+        self.adapter.add_table_override(model, table);
+        self
+    }
+
+    /// Resolve the table for a model.
+    pub fn table_name(&self, model: &str) -> Option<String> {
+        model_to_table(model).map(|t| t.to_string())
+    }
+
+    pub fn primary_key(&self, model: &str) -> Option<&'static str> {
+        model_primary_key(model)
+    }
+}
+
+/// Cosine similarity in [0,1]-ish range; 1.0 == identical direction.
+pub fn cosine_similarity(a: &[f64], b: &[f64]) -> f64 {
+    if a.len() != b.len() || a.is_empty() {
+        return 0.0;
+    }
+    let mut dot = 0.0;
+    let mut m1 = 0.0;
+    let mut m2 = 0.0;
+    for i in 0..a.len() {
+        dot += a[i] * b[i];
+        m1 += a[i] * a[i];
+        m2 += b[i] * b[i];
+    }
+    if m1 == 0.0 || m2 == 0.0 {
+        return 0.0;
+    }
+    dot / (m1.sqrt() * m2.sqrt())
+}
+
+/// Euclidean distance between two vectors.
+pub fn euclidean_distance(a: &[f64], b: &[f64]) -> f64 {
+    a.iter()
+        .zip(b.iter())
+        .map(|(x, y)| (x - y) * (x - y))
+        .sum::<f64>()
+        .sqrt()
+}
+
+/// Dot product between two vectors.
+pub fn dot_product(a: &[f64], b: &[f64]) -> f64 {
+    a.iter().zip(b.iter()).map(|(x, y)| x * y).sum()
+}
+
+/// Distance honouring the AN5 metric names.
+pub fn vector_distance(a: &[f64], b: &[f64], metric: &str) -> f64 {
+    match metric.to_lowercase().as_str() {
+        "euclidean" => euclidean_distance(a, b),
+        "dot" => -dot_product(a, b),
+        _ => 1.0 - cosine_similarity(a, b),
+    }
+}
+
+/// Standalone SQL builder for callers that prefer to drive their own driver.
+#[derive(Clone)]
+pub struct SqlBuilder {
+    pub connection_string: String,
+    pub dialect: Dialect,
+}
+
+impl SqlBuilder {
+    pub fn new(connection_string: Option<String>) -> Self {
+        let cs = connection_string.unwrap_or_else(crate::config::get_default_connection_string);
+        let dialect = Dialect::detect(&cs);
+        Self {
+            connection_string: cs,
+            dialect,
+        }
+    }
+
+    pub fn table_name(&self, model: &str) -> Option<String> {
+        model_to_table(model).map(|t| t.to_string())
+    }
+
+    pub fn primary_key(&self, model: &str) -> Option<&'static str> {
+        model_primary_key(model)
+    }
+
+    pub fn quote_ident(&self, name: &str) -> String {
+        self.dialect.quote_ident(name)
+    }
+
+    pub fn placeholder(&self, n: usize) -> String {
+        self.dialect.placeholder(n)
+    }
+}
+
+`;
+        for (const model of models) {
+            content += this.buildModelRuntimeHandle(model);
+        }
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'src', 'client.rs'), content);
+    }
+    /**
+     * Typed, executing accessors for a model.
+     *
+     * Rust has no dynamic property access, so `db.user` cannot exist the way it
+     * does in TypeScript or Python. Following the Go generator (which emits a
+     * real `ctx.User` field), each model gets a generated method returning a
+     * typed handle whose queries run through the an5-adapters runtime.
+     */
+    buildModelRuntimeHandle(model) {
+        const name = this.capitalize(model.name);
+        const snake = this.toSnakeCase(model.name);
+        const lines = [];
+        lines.push(`/// Typed queries for ${name}. Obtained via \`An5Client::${snake}()\`.`);
+        lines.push(`#[derive(Clone)]`);
+        lines.push(`pub struct ${name}Table {`);
+        lines.push(`    db: An5Client,`);
+        lines.push(`}`);
+        lines.push(``);
+        lines.push(`impl An5Client {`);
+        lines.push(`    /// Typed handle for ${name}.`);
+        lines.push(`    pub fn ${snake}(&self) -> ${name}Table {`);
+        lines.push(`        ${name}Table { db: self.clone() }`);
+        lines.push(`    }`);
+        lines.push(`}`);
+        lines.push(``);
+        lines.push(`impl ${name}Table {`);
+        lines.push(`    /// The underlying adapter, for raw SQL or transactions.`);
+        lines.push(`    pub fn adapter(&self) -> &An5Adapter { self.db.adapter() }`);
+        lines.push(``);
+        lines.push(`    pub async fn find_many(&self, args: &${name}FindManyArgs) -> Result<Vec<${name}>> {`);
+        lines.push(`        let rows = self`);
+        lines.push(`            .db`);
+        lines.push(`            .table("${model.name}")`);
+        lines.push(`            .find_many(&FindManyArgs {`);
+        lines.push(`                r#where: to_value(&args.where_)?,`);
+        lines.push(`                order_by: to_value(&args.order_by)?,`);
+        lines.push(`                take: args.take.unwrap_or(0),`);
+        lines.push(`                skip: args.skip,`);
+        lines.push(`                select: args.select.as_ref().map(|s| serde_json::json!(s)),`);
+        lines.push(`                ..Default::default()`);
+        lines.push(`            })`);
+        lines.push(`            .await?;`);
+        lines.push(`        deserialize_rows(rows)`);
+        lines.push(`    }`);
+        lines.push(``);
+        lines.push(`    pub async fn find_first(&self, args: &${name}FindFirstArgs) -> Result<Option<${name}>> {`);
+        lines.push(`        let row = self`);
+        lines.push(`            .db`);
+        lines.push(`            .table("${model.name}")`);
+        lines.push(`            .find_first(&FindManyArgs {`);
+        lines.push(`                r#where: to_value(&args.where_)?,`);
+        lines.push(`                order_by: to_value(&args.order_by)?,`);
+        lines.push(`                ..Default::default()`);
+        lines.push(`            })`);
+        lines.push(`            .await?;`);
+        lines.push(`        match row {`);
+        lines.push(`            Some(r) => Ok(Some(deserialize_row(r)?)),`);
+        lines.push(`            None => Ok(None),`);
+        lines.push(`        }`);
+        lines.push(`    }`);
+        lines.push(``);
+        lines.push(`    pub async fn find_unique(&self, args: &${name}FindUniqueArgs) -> Result<Option<${name}>> {`);
+        lines.push(`        let row = self`);
+        lines.push(`            .db`);
+        lines.push(`            .table("${model.name}")`);
+        lines.push(`            .find_unique(&FindManyArgs {`);
+        lines.push(`                r#where: to_value(&args.where_)?,`);
+        lines.push(`                ..Default::default()`);
+        lines.push(`            })`);
+        lines.push(`            .await?;`);
+        lines.push(`        match row {`);
+        lines.push(`            Some(r) => Ok(Some(deserialize_row(r)?)),`);
+        lines.push(`            None => Ok(None),`);
+        lines.push(`        }`);
+        lines.push(`    }`);
+        lines.push(``);
+        lines.push(`    pub async fn count(&self, args: &${name}FindUniqueArgs) -> Result<i64> {`);
+        lines.push(`        self.db`);
+        lines.push(`            .table("${model.name}")`);
+        lines.push(`            .count(&CountArgs { r#where: to_value(&args.where_)? })`);
+        lines.push(`            .await`);
+        lines.push(`    }`);
+        lines.push(``);
+        lines.push(`    pub async fn create(&self, data: &${name}CreateInput) -> Result<${name}> {`);
+        lines.push(`        let row = self`);
+        lines.push(`            .db`);
+        lines.push(`            .table("${model.name}")`);
+        lines.push(`            .create(&to_map(data)?)`);
+        lines.push(`            .await?;`);
+        lines.push(`        deserialize_row(row)`);
+        lines.push(`    }`);
+        lines.push(``);
+        lines.push(`    pub async fn update(&self, args: &${name}UpdateArgs) -> Result<u64> {`);
+        lines.push(`        self.db`);
+        lines.push(`            .table("${model.name}")`);
+        lines.push(`            .update(&UpdateArgs {`);
+        lines.push(`                r#where: to_value(&args.where_)?,`);
+        lines.push(`                data: serde_json::to_value(&args.data)?,`);
+        lines.push(`            })`);
+        lines.push(`            .await`);
+        lines.push(`    }`);
+        lines.push(``);
+        lines.push(`    pub async fn delete(&self, args: &${name}FindUniqueArgs) -> Result<u64> {`);
+        lines.push(`        self.db`);
+        lines.push(`            .table("${model.name}")`);
+        lines.push(`            .delete_many(&DeleteManyArgs { r#where: to_value(&args.where_)? })`);
+        lines.push(`            .await`);
+        lines.push(`    }`);
+        lines.push(`}`);
+        lines.push(``);
+        return lines.join('\n') + '\n';
+    }
+    isBoolField(field) {
+        return ['bool', 'boolean', 'bit'].includes(field.type.toLowerCase());
+    }
+    /**
+     * The Rust type for a field.
+     *
+     * From the declared type, so `DECIMAL` is an `f64` and `BIGINT` an `i64`: both
+     * arrived as `number` and were written as `i64`.
+     */
+    mapRustType(field, isOptional) {
+        let t;
+        switch ((0, type_kinds_1.fieldKind)(field, this.provider)) {
+            case 'int':
+                t = 'i32';
+                break;
+            case 'bigint':
+                t = 'i64';
+                break;
+            case 'float':
+                t = 'f64';
+                break;
+            case 'bool':
+                t = 'bool';
+                break;
+            case 'date':
+                t = 'DateTime<Utc>';
+                break;
+            case 'bytes':
+                t = 'Vec<u8>';
+                break;
+            case 'json':
+                t = 'serde_json::Value';
+                break;
+            case 'vector':
+                t = 'Vec<f32>';
+                break;
+            default:
+                t = 'String';
+                break;
+        }
+        if (isOptional)
+            return `Option<${t}>`;
+        return t;
+    }
+    getRustFilterType(field) {
+        // From the declared type: both arrived as `number` and picked the integer filter.
+        switch ((0, type_kinds_1.fieldKind)(field, this.provider)) {
+            case 'date': return 'DateTimeFilter';
+            case 'bool': return 'BoolFilter';
+            case 'int':
+            case 'bigint': return 'IntFilter';
+            case 'float': return 'NumberFilter';
+            default: return 'StringFilter';
+        }
+    }
+    getAllPropertyVariations(modelName) {
+        const variations = new Set();
+        variations.add(modelName);
+        variations.add(this.toCamelCase(modelName));
+        variations.add(modelName + 's');
+        variations.add(this.toCamelCase(modelName) + 's');
+        variations.add(this.toSnakeCase(modelName));
+        variations.add(this.toSnakeCase(modelName) + 's');
+        const acronyms = ['LLM', 'AI', 'MCP', 'IT', 'QC', 'HR', 'MR', 'WH', 'SSIS', 'API', 'URL', 'ID', 'JSON'];
+        for (const acronym of acronyms) {
+            if (modelName.startsWith(acronym)) {
+                variations.add(acronym.toLowerCase() + modelName.slice(acronym.length));
+                variations.add(acronym[0].toLowerCase() + acronym.slice(1) + modelName.slice(acronym.length));
+                variations.add(acronym.toLowerCase() + modelName.slice(acronym.length) + 's');
+                variations.add(this.toSnakeCase(acronym.toLowerCase() + modelName.slice(acronym.length)));
+            }
+        }
+        return Array.from(variations);
+    }
+    capitalize(str) {
+        if (!str)
+            return '';
+        return str[0].toUpperCase() + str.slice(1);
+    }
+    toCamelCase(str) {
+        if (!str)
+            return '';
+        return str[0].toLowerCase() + str.slice(1);
+    }
+    toSnakeCase(str) {
+        if (!str)
+            return '';
+        return str
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+            .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+            .toLowerCase();
+    }
+}
+exports.RustGenerator = RustGenerator;