| name | validation-patterns |
| description | Kailash Rust validation — parameter, DataFlow, connection, workflow, security. Use for code review. |
Kailash Validation Patterns
Comprehensive validation patterns and compliance checking for Kailash Rust SDK development.
Overview
Validation tools and patterns for:
- Parameter validation (ValueMap, ParamDef)
- DataFlow pattern compliance (ModelDefinition, sqlx)
- Connection validation (builder.connect 4-parameter format)
- Use statement checking (absolute paths, correct crate imports)
- Workflow structure validation (builder.build(®istry)?)
- Security validation (no unsafe, sqlx::query!, cargo audit)
Reference Documentation
Core Validations
Parameter Validation
- validate-parameters - Node parameter validation
- Required parameters via ParamDef
- Value type checking
- ValueMap construction
- Build-time validation
Connection Validation
- validate-connections - Connection validation
- 4-parameter
builder.connect() format
- Source/target node existence
- Parameter name validation
- Circular dependency detection via build
Workflow Structure
- validate-workflow-structure - Workflow validation
- Node ID uniqueness
- Connection validity
builder.build(®istry)? as validation boundary
- Registry completeness
Framework-Specific Validations
DataFlow Patterns
- validate-dataflow-patterns - DataFlow compliance
- ModelDefinition usage
- sqlx compile-time query checking
- Auto-generated node usage
- Transaction patterns
- Environment-based connection strings
Use Statements
- validate-absolute-imports - Use statement validation
- Correct crate paths (
use kailash_core::...)
- Feature-gated imports
- Re-export awareness
- Circular dependency avoidance
Security Validation
- validate-security - Security checks
- No unsafe blocks (application code)
sqlx::query! for compile-time SQL checking
cargo audit for dependency vulnerabilities
- Environment variables for secrets
- No hardcoded credentials
Validation Patterns
Parameter Validation Pattern
use kailash_core::value::{Value, ValueMap};
use kailash_core::node::ParamDef;
fn validate_node_params(params: &ValueMap, required: &[ParamDef]) -> Result<(), String> {
for param_def in required {
if param_def.required && !params.contains_key(param_def.name.as_ref()) {
return Err(format!("Missing required parameter: {}", param_def.name));
}
}
Ok(())
}
Connection Validation Pattern
use kailash_core::WorkflowBuilder;
use kailash_core::value::ValueMap;
let mut builder = WorkflowBuilder::new();
builder.add_node("LLMNode", "node1", ValueMap::new());
builder.add_node("JSONTransformNode", "node2", ValueMap::new());
builder.connect("node1", "result", "node2", "data");
let workflow = builder.build(®istry)?;
DataFlow Pattern Validation
use kailash_dataflow::{DataFlow, ModelDefinition, FieldType};
let user_model = ModelDefinition::new("User")
.field("id", FieldType::Integer, |f| f.primary_key())
.field("name", FieldType::String, |f| f.required())
.build()?;
Security Validation Pattern
dotenvy::dotenv().ok();
let api_key = std::env::var("OPENAI_API_KEY")
.map_err(|_| anyhow::anyhow!("OPENAI_API_KEY not set"))?;
let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", user_id)
.fetch_one(&pool)
.await?;
Validation Checklists
Pre-Execution Checklist
DataFlow Checklist
Security Checklist
Use Statement Checklist
Pre-Commit Validation
cargo test --workspace
cargo clippy --workspace -- -D warnings
cargo fmt --all --check
cargo audit
CI/CD Validation
steps:
- name: Validate
run: |
cargo test --workspace
cargo clippy --workspace -- -D warnings
cargo fmt --all --check
cargo audit
Critical Validation Rules
Must Validate
- All parameters before execution via
builder.build(®istry)?
- All connections before building
- Security risks before deployment
- Use statement correctness before commit
- DataFlow patterns in code review
Never Skip
- NEVER skip
builder.build(®istry)? -- it is the validation boundary
- NEVER skip security validation
- NEVER deploy without
cargo audit
- NEVER commit without
cargo clippy -- -D warnings
- NEVER use raw SQL strings when DataFlow or
sqlx::query! is available
When to Use This Skill
Use this skill when you need to:
- Validate workflow before execution
- Check parameter correctness
- Verify connection format
- Audit security issues
- Review DataFlow patterns
- Check use statement compliance
- Perform code review
- Ensure standards compliance
Related Skills
Support
For validation help, invoke:
reviewer - Code review (MANDATORY after changes)
security-reviewer - Security audit (MANDATORY before commit)
rust-architect - Cross-crate pattern validation
cargo-specialist - Dependency and workspace validation