GraphQL Resolvers

GraphQL Query → Resolver Function → REST API Call → Database → JSON Response → GraphQL Field

type OrganizationNode {
  accounts: [AccountNode!]!
}

query GetOrganizationAccounts {
  organization {
    id
    name
    accounts {
      id
      code
      name
      accountType
      balance {
        formatted
      }
    }
  }
}

type OrganizationNode {
  recentTransactions(limit: Int): [TransactionNode!]!
}

query GetRecentActivity {
  organization {
    recentTransactions(limit: 20) {
      id
      description
      amount
      date
      status
    }
  }
}

type OrganizationNode {
  contacts: [ContactNode!]!
}

type OrganizationNode {
  invoices: [InvoiceNode!]!
}

type OrganizationNode {
  bills: [BillNode!]!
}

type OrganizationNode {
  trialBalance: TrialBalanceReport!
}

query GetTrialBalance {
  organization {
    trialBalance {
      generatedAt
      totalDebits
      totalCredits
      accounts {
        accountCode
        accountName
        debitBalance
        creditBalance
        netBalance
      }
    }
  }
}

type OrganizationNode {
  balanceSheet: BalanceSheetReport!
}

type OrganizationNode {
  incomeStatement: IncomeStatementReport!
}

type OrganizationNode {
  creditBalance: CreditBalanceNode!  # Requires @auth guard
}

type OrganizationNode {
  creditPackages: [CreditPackageNode!]!
}

type AccountNode {
  balance: MoneyNode!
}

query GetAccountBalance {
  account(id: "act_123") {
    id
    code
    name
    balance {
      amount
      formatted
      currency {
        code
        symbol
      }
    }
  }
}

type AccountNode {
  transactions(limit: Int): [TransactionNode!]!
}

type ContactNode {
  transactions(limit: Int): [TransactionNode!]!
}

type ContactNode {
  invoices: [InvoiceNode!]!
}

type ContactNode {
  bills: [BillNode!]!
}

type InvoiceNode {
  payments: [PaymentNode!]!
}

type InvoiceNode {
  pdfUrl: String!
}

type BillNode {
  payments: [PaymentNode!]!
}

type BillNode {
  pdfUrl: String!
}

type Query {
  organization: OrganizationNode  # Requires @auth guard
}

type Query {
  organizationById(id: ID!): OrganizationNode  # Requires @auth guard
}

type Query {
  account(id: ID!): AccountNode  # Requires @auth guard
}

type Query {
  transaction(id: ID!): TransactionNode  # Requires @auth guard
}

type Query {
  contact(id: ID!): ContactNode  # Requires @auth guard
}

type Query {
  invoice(id: ID!): InvoiceNode  # Requires @auth guard
}

type Query {
  bill(id: ID!): BillNode  # Requires @auth guard
}

type Query {
  currencies: [CurrencyNode!]!  # Requires @auth guard
}

type Mutation {
  createAccount(
    code: String!
    name: String!
    accountType: AccountType!
    description: String
  ): AccountNode  # Requires @auth guard
}

type Mutation {
  updateAccount(
    id: ID!
    code: String
    name: String
    description: String
  ): AccountNode  # Requires @auth guard
}

type Mutation {
  deleteAccount(id: ID!): Boolean  # Requires @auth guard
}

type Mutation {
  createTransaction(
    description: String!
    date: DateTime!
    entries: [LedgerEntryInput!]!
  ): TransactionNode  # Requires @auth guard
}

type Mutation {
  createContact(
    name: String!
    contactType: ContactType!
    email: String
    phone: String
    taxId: String
  ): ContactNode  # Requires @auth guard
}

type Mutation {
  updateContact(
    id: ID!
    name: String
    email: String
    phone: String
    taxId: String
  ): ContactNode  # Requires @auth guard
}

type Mutation {
  deleteContact(id: ID!): Boolean  # Requires @auth guard
}

type Mutation {
  createInvoice(
    contactId: ID!
    invoiceDate: DateTime!
    dueDate: DateTime!
    items: [InvoiceItemInput!]!
    notes: String
  ): InvoiceNode  # Requires @auth guard
}

type Mutation {
  createBill(
    contactId: ID!
    billDate: DateTime!
    dueDate: DateTime!
    items: [BillItemInput!]!
    notes: String
  ): BillNode  # Requires @auth guard
}

type Mutation {
  recordInvoicePayment(
    invoiceId: ID!
    amount: Decimal!
    paymentDate: DateTime!
    paymentMethod: String!
    reference: String
    notes: String
  ): PaymentNode  # Requires @auth guard
}

type Mutation {
  recordBillPayment(
    billId: ID!
    amount: Decimal!
    paymentDate: DateTime!
    paymentMethod: String!
    reference: String
    notes: String
  ): PaymentNode  # Requires @auth guard
}

type Mutation {
  purchaseCredits(
    creditAmount: Int!
    successUrl: String
    cancelUrl: String
  ): CreditPurchaseNode  # Requires @auth guard
}

# ✅ Good - Limited resolver calls
query EfficientQuery {
  organization {
    accounts(limit: 10) {
      id
      name
      # No transactions resolver call
    }
  }
}

# ❌ Bad - Excessive resolver calls
query InefficientQuery {
  organization {
    accounts {
      id
      name
      transactions(limit: 100) {  # Calls resolver for EACH account
        id
        description
        entries {  # Calls more resolvers
          account {
            name  # Even more resolver calls
          }
        }
      }
    }
  }
}

fragment BasicAccount on AccountNode {
  id
  code
  name
  balance {
    formatted
  }
}

query GetAccountsEfficiently {
  organization {
    accounts {
      ...BasicAccount
      # No transaction resolvers called
    }
  }
}

# Instead of multiple queries
query GetMultipleEntities {
  account1: account(id: "act_1") { ...AccountFields }
  account2: account(id: "act_2") { ...AccountFields }
  account3: account(id: "act_3") { ...AccountFields }
}

// Client-side caching
const cache = new Map();

async function cachedResolver(key, resolver) {
  if (cache.has(key)) {
    return cache.get(key);
  }

  const result = await resolver();
  cache.set(key, result);
  return result;
}

// Authentication errors
#[error("Authentication required")]
Unauthorized,

// Permission errors
#[error("Access denied to organization")]
Forbidden,

// Not found errors
#[error("Account not found: {0}")]
AccountNotFound(String),

// Business logic errors
#[error("Transaction does not balance")]
TransactionUnbalanced,

// External API errors
#[error("REST API call failed: {0}")]
ApiCallError(String),

// GraphQL errors are properly formatted
{
  "errors": [
    {
      "message": "Account not found: act_invalid_id",
      "locations": [{ "line": 3, "column": 5 }],
      "path": ["account"],
      "extensions": {
        "code": "NOT_FOUND"
      }
    }
  ]
}

#[test]
fn test_account_balance_resolver() {
    let mock_api = MockApiClient::new();
    let resolvers = GraphQLResolvers::new(mock_api);

    // Test resolver logic
    let result = resolvers.get_account_balance(ctx, "act_123").await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_organization_accounts_resolver() {
    let app_state = setup_test_state().await;
    let resolvers = GraphQLResolvers::new(app_state);

    // Test full resolver chain
    let ctx = create_test_context("org_123");
    let result = resolvers.get_accounts(ctx).await;

    assert!(result.is_ok());
    assert!(!result.unwrap().is_empty());
}

// Track resolver performance
#[derive(Debug)]
struct ResolverMetrics {
    resolver_name: String,
    execution_time: Duration,
    credit_cost: Decimal,
    success: bool,
    error_type: Option<String>,
}

// Log resolver execution
async fn execute_resolver_with_metrics<F, T>(
    resolver_name: &str,
    credit_cost: Decimal,
    resolver: F,
) -> Result<T>
where
    F: Future<Output = Result<T>>,
{
    let start = Instant::now();
    let result = resolver.await;
    let duration = start.elapsed();

    log_resolver_metrics(ResolverMetrics {
        resolver_name: resolver_name.to_string(),
        execution_time: duration,
        credit_cost,
        success: result.is_ok(),
        error_type: result.as_ref().err().map(|e| e.to_string()),
    });

    result
}

// Track cumulative credit usage per resolver
#[derive(Default)]
struct CreditTracker {
    total_credits_used: Decimal,
    resolver_usage: HashMap<String, Decimal>,
}

impl CreditTracker {
    fn record_usage(&mut self, resolver_name: &str, credits: Decimal) {
        self.total_credits_used += credits;
        *self.resolver_usage.entry(resolver_name.to_string()).or_insert(Decimal::ZERO) += credits;
    }

    fn get_usage_report(&self) -> Value {
        json!({
            "total_credits_used": self.total_credits_used,
            "resolver_breakdown": self.resolver_usage
        })
    }
}

// ✅ Good - Single responsibility
async fn get_account_balance(&self, account_id: &str) -> Result<MoneyNode>

// ❌ Bad - Multiple responsibilities
async fn get_account_with_balance_and_transactions(&self, account_id: &str) -> Result<ComplexObject>

async fn safe_resolver_call(&self, operation: &str) -> Result<T> {
    match self.api_call(operation).await {
        Ok(result) => Ok(result),
        Err(err) => {
            tracing::error!("Resolver {} failed: {}", operation, err);
            Err(err.into())
        }
    }
}

// Cache static data
lazy_static! {
    static ref CURRENCY_CACHE: Mutex<HashMap<String, CurrencyNode>> = Mutex::new(HashMap::new());
}

async fn get_cached_currency(&self, code: &str) -> Result<CurrencyNode> {
    if let Some(currency) = CURRENCY_CACHE.lock().await.get(code) {
        return Ok(currency.clone());
    }

    let currency = self.api_get(&format!("/currencies/{}", code)).await?;
    CURRENCY_CACHE.lock().await.insert(code.to_string(), currency.clone());
    Ok(currency)
}

fn validate_account_id(account_id: &str) -> Result<()> {
    if !account_id.starts_with("act_") {
        return Err(Error::new("Invalid account ID format"));
    }
    Ok(())
}

// Instead of multiple individual calls
async fn get_multiple_balances(&self, account_ids: &[String]) -> Result<Vec<MoneyNode>> {
    let mut balances = Vec::new();

    for chunk in account_ids.chunks(10) {  // Batch in groups of 10
        let batch_result = self.api_post("/accounts/batch-balance", json!({ "ids": chunk })).await?;
        balances.extend(batch_result);
    }

    Ok(balances)
}

// Reuse HTTP connections
#[derive(Clone)]
pub struct GraphQLResolvers {
    pub http_client: Client,  // Connection pool
    pub base_url: String,
}

// Don't block on slow operations
async fn get_complex_report(&self, org_id: &str) -> Result<Report> {
    // Queue to background worker
    let job_id = self.worker_queue.queue_job("generate_report", json!({
        "organization_id": org_id
    })).await?;

    // Return job status immediately
    Ok(JobResult {
        job_id,
        status: "queued",
        estimated_completion: Utc::now() + Duration::minutes(5),
    })
}