Struct ApiExecutor 

pub struct ApiExecutor<C> { /* private fields */ }

A stateful executor for API operations that maintains context across multiple calls.

Implementations

impl<C> ApiExecutor<C>

pub fn new(context: C) -> Self

Creates a new ApiExecutor that owns the provided context.

Examples found in repository

examples/executor_pattern.rs (line 218)

fn main() {
    println!("🔧 ApiThing Executor Pattern Example");
    println!("====================================\n");

    // Create an executor that manages the context for us
    let mut executor = ApiExecutor::new(AppContext::new("production_db".to_string()));

    println!("🏗️  Created ApiExecutor with context");
    println!("📊 Connection: {}", executor.context().connection_pool());
    println!(
        "🔢 Initial transaction count: {}\n",
        executor.context().transaction_count()
    );

    // === User Operations ===
    println!("👥 USER OPERATIONS");
    println!("==================");

    // Create multiple users using the executor
    let users = vec![
        ("Alice Johnson", "alice@company.com"),
        ("Bob Smith", "bob@company.com"),
        ("Carol Davis", "carol@company.com"),
    ];

    let mut created_users = Vec::new();
    for (name, email) in users {
        match executor.execute(
            CreateUser,
            &CreateUserProps {
                name: name.to_string(),
                email: email.to_string(),
            },
        ) {
            Ok(user) => {
                println!("✅ Created user: {} (ID: {})", user.name, user.id);
                created_users.push(user);
            }
            Err(e) => {
                println!("❌ Failed to create user {}: {:?}", name, e);
                return;
            }
        }
    }

    println!(
        "🔢 Transaction count after user creation: {}\n",
        executor.context().transaction_count()
    );

    // === Product Operations (Same Context) ===
    println!("📦 PRODUCT OPERATIONS");
    println!("====================");

    // Create products using the same executor/context
    let products = vec![
        ("Laptop Pro", 1299.99, "Electronics"),
        ("Office Chair", 249.50, "Furniture"),
        ("Coffee Mug", 12.99, "Kitchen"),
    ];

    let mut created_products = Vec::new();
    for (name, price, category) in products {
        match executor.execute(
            CreateProduct,
            &CreateProductProps {
                name: name.to_string(),
                price,
                category: category.to_string(),
            },
        ) {
            Ok(product) => {
                println!(
                    "✅ Created product: {} (ID: {}, Price: ${:.2})",
                    product.name, product.id, product.price
                );
                created_products.push(product);
            }
            Err(e) => {
                println!("❌ Failed to create product {}: {:?}", name, e);
                return;
            }
        }
    }

    println!(
        "🔢 Transaction count after product creation: {}\n",
        executor.context().transaction_count()
    );

    // === Cross-Family Operations ===
    println!("🔄 CROSS-FAMILY LOOKUPS");
    println!("=======================");

    // Find users and products using the same context
    // This demonstrates how the cache works across different API families

    println!("🔍 Looking up created entities...");

    // Find first user
    if let Some(user) = created_users.first() {
        match executor.execute(FindUser, &FindUserProps { user_id: user.id }) {
            Ok(found_user) => println!("👤 Found user: {} ({})", found_user.name, found_user.email),
            Err(e) => println!("❌ Failed to find user: {:?}", e),
        }
    }

    // Find first product
    if let Some(product) = created_products.first() {
        match executor.execute(
            FindProduct,
            &FindProductProps {
                product_id: product.id,
            },
        ) {
            Ok(found_product) => println!(
                "📦 Found product: {} (${:.2})",
                found_product.name, found_product.price
            ),
            Err(e) => println!("❌ Failed to find product: {:?}", e),
        }
    }

    // === Context Inspection ===
    println!("\n📊 CONTEXT INSPECTION");
    println!("=====================");

    let context = executor.context();
    println!(
        "🔢 Final transaction count: {}",
        context.transaction_count()
    );
    println!("💾 Cache entries: {} items", context.cache().len());

    // Show cache contents
    println!("📋 Cached items:");
    for (key, value) in context.cache().iter() {
        // Truncate long values for display
        let display_value = if value.len() > 50 {
            format!("{}...", &value[..47])
        } else {
            value.clone()
        };
        println!("   • {}: {}", key, display_value);
    }

    // === Executor Benefits Demo ===
    println!("\n💡 EXECUTOR BENEFITS");
    println!("====================");

    // Show how we can access the context for debugging or inspection
    let final_context = executor.context();
    println!("✅ Centralized state management:");
    println!(
        "   • {} total operations executed",
        final_context.transaction_count()
    );
    println!("   • {} entities cached", final_context.cache().len());
    println!("   • Single context shared across {} API families", 2);

    println!("\n🎉 Executor pattern example completed successfully!");
    println!("💡 Key advantages of ApiExecutor:");
    println!("   • Ergonomic API: executor.execute(Operation, &parameters)");
    println!("   • Centralized context management with owned context");
    println!("   • Consistent patterns across different API families");
    println!("   • Easy context inspection and debugging");
    println!("   • Efficient state sharing (cache, connections, etc.)");
}

pub fn execute<P, Op>( &mut self, _op: Op, parameters: &P, ) -> Result<Op::Output, Op::Error>

where Op: ApiOperation<C, P>,

Executes an API operation using this executor’s context.

Examples found in repository

examples/executor_pattern.rs (lines 240-246)

fn main() {
    println!("🔧 ApiThing Executor Pattern Example");
    println!("====================================\n");

    // Create an executor that manages the context for us
    let mut executor = ApiExecutor::new(AppContext::new("production_db".to_string()));

    println!("🏗️  Created ApiExecutor with context");
    println!("📊 Connection: {}", executor.context().connection_pool());
    println!(
        "🔢 Initial transaction count: {}\n",
        executor.context().transaction_count()
    );

    // === User Operations ===
    println!("👥 USER OPERATIONS");
    println!("==================");

    // Create multiple users using the executor
    let users = vec![
        ("Alice Johnson", "alice@company.com"),
        ("Bob Smith", "bob@company.com"),
        ("Carol Davis", "carol@company.com"),
    ];

    let mut created_users = Vec::new();
    for (name, email) in users {
        match executor.execute(
            CreateUser,
            &CreateUserProps {
                name: name.to_string(),
                email: email.to_string(),
            },
        ) {
            Ok(user) => {
                println!("✅ Created user: {} (ID: {})", user.name, user.id);
                created_users.push(user);
            }
            Err(e) => {
                println!("❌ Failed to create user {}: {:?}", name, e);
                return;
            }
        }
    }

    println!(
        "🔢 Transaction count after user creation: {}\n",
        executor.context().transaction_count()
    );

    // === Product Operations (Same Context) ===
    println!("📦 PRODUCT OPERATIONS");
    println!("====================");

    // Create products using the same executor/context
    let products = vec![
        ("Laptop Pro", 1299.99, "Electronics"),
        ("Office Chair", 249.50, "Furniture"),
        ("Coffee Mug", 12.99, "Kitchen"),
    ];

    let mut created_products = Vec::new();
    for (name, price, category) in products {
        match executor.execute(
            CreateProduct,
            &CreateProductProps {
                name: name.to_string(),
                price,
                category: category.to_string(),
            },
        ) {
            Ok(product) => {
                println!(
                    "✅ Created product: {} (ID: {}, Price: ${:.2})",
                    product.name, product.id, product.price
                );
                created_products.push(product);
            }
            Err(e) => {
                println!("❌ Failed to create product {}: {:?}", name, e);
                return;
            }
        }
    }

    println!(
        "🔢 Transaction count after product creation: {}\n",
        executor.context().transaction_count()
    );

    // === Cross-Family Operations ===
    println!("🔄 CROSS-FAMILY LOOKUPS");
    println!("=======================");

    // Find users and products using the same context
    // This demonstrates how the cache works across different API families

    println!("🔍 Looking up created entities...");

    // Find first user
    if let Some(user) = created_users.first() {
        match executor.execute(FindUser, &FindUserProps { user_id: user.id }) {
            Ok(found_user) => println!("👤 Found user: {} ({})", found_user.name, found_user.email),
            Err(e) => println!("❌ Failed to find user: {:?}", e),
        }
    }

    // Find first product
    if let Some(product) = created_products.first() {
        match executor.execute(
            FindProduct,
            &FindProductProps {
                product_id: product.id,
            },
        ) {
            Ok(found_product) => println!(
                "📦 Found product: {} (${:.2})",
                found_product.name, found_product.price
            ),
            Err(e) => println!("❌ Failed to find product: {:?}", e),
        }
    }

    // === Context Inspection ===
    println!("\n📊 CONTEXT INSPECTION");
    println!("=====================");

    let context = executor.context();
    println!(
        "🔢 Final transaction count: {}",
        context.transaction_count()
    );
    println!("💾 Cache entries: {} items", context.cache().len());

    // Show cache contents
    println!("📋 Cached items:");
    for (key, value) in context.cache().iter() {
        // Truncate long values for display
        let display_value = if value.len() > 50 {
            format!("{}...", &value[..47])
        } else {
            value.clone()
        };
        println!("   • {}: {}", key, display_value);
    }

    // === Executor Benefits Demo ===
    println!("\n💡 EXECUTOR BENEFITS");
    println!("====================");

    // Show how we can access the context for debugging or inspection
    let final_context = executor.context();
    println!("✅ Centralized state management:");
    println!(
        "   • {} total operations executed",
        final_context.transaction_count()
    );
    println!("   • {} entities cached", final_context.cache().len());
    println!("   • Single context shared across {} API families", 2);

    println!("\n🎉 Executor pattern example completed successfully!");
    println!("💡 Key advantages of ApiExecutor:");
    println!("   • Ergonomic API: executor.execute(Operation, &parameters)");
    println!("   • Centralized context management with owned context");
    println!("   • Consistent patterns across different API families");
    println!("   • Easy context inspection and debugging");
    println!("   • Efficient state sharing (cache, connections, etc.)");
}

pub fn context(&self) -> &C

Returns an immutable reference to the executor’s context.

Examples found in repository

examples/executor_pattern.rs (line 221)

fn main() {
    println!("🔧 ApiThing Executor Pattern Example");
    println!("====================================\n");

    // Create an executor that manages the context for us
    let mut executor = ApiExecutor::new(AppContext::new("production_db".to_string()));

    println!("🏗️  Created ApiExecutor with context");
    println!("📊 Connection: {}", executor.context().connection_pool());
    println!(
        "🔢 Initial transaction count: {}\n",
        executor.context().transaction_count()
    );

    // === User Operations ===
    println!("👥 USER OPERATIONS");
    println!("==================");

    // Create multiple users using the executor
    let users = vec![
        ("Alice Johnson", "alice@company.com"),
        ("Bob Smith", "bob@company.com"),
        ("Carol Davis", "carol@company.com"),
    ];

    let mut created_users = Vec::new();
    for (name, email) in users {
        match executor.execute(
            CreateUser,
            &CreateUserProps {
                name: name.to_string(),
                email: email.to_string(),
            },
        ) {
            Ok(user) => {
                println!("✅ Created user: {} (ID: {})", user.name, user.id);
                created_users.push(user);
            }
            Err(e) => {
                println!("❌ Failed to create user {}: {:?}", name, e);
                return;
            }
        }
    }

    println!(
        "🔢 Transaction count after user creation: {}\n",
        executor.context().transaction_count()
    );

    // === Product Operations (Same Context) ===
    println!("📦 PRODUCT OPERATIONS");
    println!("====================");

    // Create products using the same executor/context
    let products = vec![
        ("Laptop Pro", 1299.99, "Electronics"),
        ("Office Chair", 249.50, "Furniture"),
        ("Coffee Mug", 12.99, "Kitchen"),
    ];

    let mut created_products = Vec::new();
    for (name, price, category) in products {
        match executor.execute(
            CreateProduct,
            &CreateProductProps {
                name: name.to_string(),
                price,
                category: category.to_string(),
            },
        ) {
            Ok(product) => {
                println!(
                    "✅ Created product: {} (ID: {}, Price: ${:.2})",
                    product.name, product.id, product.price
                );
                created_products.push(product);
            }
            Err(e) => {
                println!("❌ Failed to create product {}: {:?}", name, e);
                return;
            }
        }
    }

    println!(
        "🔢 Transaction count after product creation: {}\n",
        executor.context().transaction_count()
    );

    // === Cross-Family Operations ===
    println!("🔄 CROSS-FAMILY LOOKUPS");
    println!("=======================");

    // Find users and products using the same context
    // This demonstrates how the cache works across different API families

    println!("🔍 Looking up created entities...");

    // Find first user
    if let Some(user) = created_users.first() {
        match executor.execute(FindUser, &FindUserProps { user_id: user.id }) {
            Ok(found_user) => println!("👤 Found user: {} ({})", found_user.name, found_user.email),
            Err(e) => println!("❌ Failed to find user: {:?}", e),
        }
    }

    // Find first product
    if let Some(product) = created_products.first() {
        match executor.execute(
            FindProduct,
            &FindProductProps {
                product_id: product.id,
            },
        ) {
            Ok(found_product) => println!(
                "📦 Found product: {} (${:.2})",
                found_product.name, found_product.price
            ),
            Err(e) => println!("❌ Failed to find product: {:?}", e),
        }
    }

    // === Context Inspection ===
    println!("\n📊 CONTEXT INSPECTION");
    println!("=====================");

    let context = executor.context();
    println!(
        "🔢 Final transaction count: {}",
        context.transaction_count()
    );
    println!("💾 Cache entries: {} items", context.cache().len());

    // Show cache contents
    println!("📋 Cached items:");
    for (key, value) in context.cache().iter() {
        // Truncate long values for display
        let display_value = if value.len() > 50 {
            format!("{}...", &value[..47])
        } else {
            value.clone()
        };
        println!("   • {}: {}", key, display_value);
    }

    // === Executor Benefits Demo ===
    println!("\n💡 EXECUTOR BENEFITS");
    println!("====================");

    // Show how we can access the context for debugging or inspection
    let final_context = executor.context();
    println!("✅ Centralized state management:");
    println!(
        "   • {} total operations executed",
        final_context.transaction_count()
    );
    println!("   • {} entities cached", final_context.cache().len());
    println!("   • Single context shared across {} API families", 2);

    println!("\n🎉 Executor pattern example completed successfully!");
    println!("💡 Key advantages of ApiExecutor:");
    println!("   • Ergonomic API: executor.execute(Operation, &parameters)");
    println!("   • Centralized context management with owned context");
    println!("   • Consistent patterns across different API families");
    println!("   • Easy context inspection and debugging");
    println!("   • Efficient state sharing (cache, connections, etc.)");
}

pub fn context_mut(&mut self) -> &mut C

Returns a mutable reference to the executor’s context.

Trait Implementations

impl<C: Clone> Clone for ApiExecutor<C>

fn clone(&self) -> ApiExecutor<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug> Debug for ApiExecutor<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.