Listing Printers

This example demonstrates how to query and paginate through available printers in the Helio Additive platform.

Tip

Before proceeding, ensure you have completed the Code Generation setup to generate the required types and documents for your language.

GraphQL Operations

Create the following GraphQL query file, then run your language’s codegen tool to generate the types.

Printers Query

queries/Printers.graphql

query Printers($page: Int, $pageSize: Int) {
  printers(page: $page, pageSize: $pageSize) {
    pages
    pageInfo {
      hasPreviousPage
      hasNextPage
    }
    objects {
      ... on Printer {
        id
        name
        heatedBed
        heatedChamber
        nozzleDiameter
        maxExtruderFlowRate
        minExtruderFlowRate
        maxHardwarePrintSpeed
        minHardwarePrintSpeed
        brand {
          id
          name
        }
      }
    }
  }
}

API Reference:

• Printer type - Full printer object structure
• PrinterFilter input - Available filter options

Code Example

1. Setup the client and configuration

   TypeScript

   index.ts

   import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
   import { PrintersDocument } from "./queries/__generated/Printers.generated";
   
   // Load PAT from environment
   const PAT = process.env.PAT;
   if (!PAT) {
     throw new Error("PAT environment variable is required");
   }
   
   // Create Apollo Client
   const client = new ApolloClient({
     cache: new InMemoryCache(),
     link: new HttpLink({
       uri: "https://api.helioadditive.com/graphql",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${PAT}`,
       },
     }),
   });

   Python

   main.py

   import asyncio
   import os
   import httpx
   from client.client import Client
   
   # Load PAT from environment
   PAT = os.environ.get("PAT")
   if not PAT:
       raise ValueError("PAT environment variable is required")
   
   # Create GraphQL client
   headers = {"Authorization": f"Bearer {PAT}"}
   graphql_client = Client(
       url="https://api.helioadditive.com/graphql",
       headers=headers,
       http_client=httpx.AsyncClient(headers=headers, timeout=60)
   )

   Rust

   src/main.rs

   use graphql_client::{GraphQLQuery, Response};
   use reqwest::header::{AUTHORIZATION, CONTENT_TYPE};
   
   #[derive(GraphQLQuery)]
   #[graphql(
       schema_path = "schema.graphqls",
       query_path = "queries/Printers.graphql",
       response_derives = "Debug"
   )]
   struct Printers;
   
   // Load from environment in main()
   let pat = std::env::var("PAT").expect("PAT environment variable must be set");

   C++

   src/main.cpp

   #include <iostream>
   #include <string>
   #include <vector>
   #include <cstdlib>
   
   #include <cpr/cpr.h>
   #include <boost/json.hpp>
   
   #include "PrintersClient.h"
   #include "graphqlservice/GraphQLResponse.h"
   #include "graphqlservice/JSONResponse.h"
   
   namespace Printers = graphql::client::query::Printers;
   
   // Helper function to send HTTP requests
   graphql::response::Value sendHttpRequest(
       const std::string& query,
       graphql::response::Value& variables,
       const std::string& pat
   ) {
       std::string body = boost::json::serialize(boost::json::object{
           {"query", query},
           {"variables", boost::json::parse(graphql::response::toJSON(std::move(variables))).as_object()}
       });
   
       auto response = cpr::Post(
           cpr::Url{"https://api.helioadditive.com/graphql"},
           cpr::Header{
               {"Content-Type", "application/json"},
               {"Authorization", "Bearer " + pat}
           },
           cpr::Body{body}
       );
   
       return graphql::response::parseJSON(boost::json::serialize(
           boost::json::parse(response.text).as_object()["data"].as_object()
       ));
   }
   
   // Load PAT from environment
   const char* pat_env = std::getenv("PAT");
   if (!pat_env) {
       std::cerr << "PAT environment variable is required" << std::endl;
       return 1;
   }
   std::string pat(pat_env);

2. Query and paginate through printers

   Fetch printers page by page until all printers have been retrieved.

   TypeScript

   async function listPrinters() {
     let page = 1;
     const pageSize = 50;
     const allPrinters: Array<{ id: string; name: string; brand: string }> = [];
   
     // Paginate through all printers
     while (true) {
       const { data } = await client.query({
         query: PrintersDocument,
         variables: { page, pageSize },
         fetchPolicy: "no-cache",
       });
   
       // Collect printers from this page
       for (const printer of data?.printers?.objects ?? []) {
         if (printer.__typename === "Printer") {
           allPrinters.push({
             id: printer.id,
             name: printer.name,
             brand: printer.brand?.name ?? "Unknown",
           });
           console.log(`Printer: ${printer.name} (${printer.brand?.name})`);
           console.log(`  - Heated Bed: ${printer.heatedBed}`);
           console.log(`  - Heated Chamber: ${printer.heatedChamber}`);
           console.log(`  - Nozzle Diameter: ${printer.nozzleDiameter}mm`);
         }
       }
   
       // Check if there are more pages
       if (!data?.printers?.pageInfo?.hasNextPage) {
         break;
       }
       page++;
     }
   
     return allPrinters;
   }

   Python

   async def list_printers():
       page = 1
       page_size = 50
       all_printers = []
   
       # Paginate through all printers
       while True:
           result = await graphql_client.printers(page=page, page_size=page_size)
   
           # Collect printers from this page
           for printer in result.objects:
               all_printers.append({
                   "id": printer.id,
                   "name": printer.name,
               })
               brand_name = printer.brand.name if printer.brand else "Unknown"
               print(f"Printer: {printer.name} ({brand_name})")
               print(f"  - Heated Bed: {printer.heated_bed}")
               print(f"  - Heated Chamber: {printer.heated_chamber}")
               print(f"  - Nozzle Diameter: {printer.nozzle_diameter}mm")
   
           # Check if there are more pages
           if not result.page_info.has_next_page:
               break
           page += 1
   
       return all_printers

   Rust

   async fn list_printers(pat: &str) -> Result<Vec<(String, String)>, Box<dyn std::error::Error>> {
       let client = reqwest::Client::new();
       let mut page = 1;
       let page_size = 50;
       let mut all_printers: Vec<(String, String)> = Vec::new();
   
       // Paginate through all printers
       loop {
           let variables = printers::Variables {
               page: Some(page as i64),
               page_size: Some(page_size),
           };
   
           let response = client
               .post("https://api.helioadditive.com/graphql")
               .header(CONTENT_TYPE, "application/json")
               .header(AUTHORIZATION, format!("Bearer {}", pat))
               .json(&Printers::build_query(variables))
               .send()
               .await?;
   
           let body: Response<printers::ResponseData> = response.json().await?;
   
           if let Some(errors) = body.errors {
               return Err(format!("GraphQL errors: {:?}", errors).into());
           }
   
           let data = body.data.expect("No data returned");
   
           // Collect printers from this page
           for printer in &data.printers.objects {
               let brand_name = printer
                   .brand
                   .as_ref()
                   .map(|b| b.name.as_str())
                   .unwrap_or("Unknown");
               println!("Printer: {} ({})", printer.name, brand_name);
               println!("  - Heated Bed: {}", printer.heated_bed);
               println!("  - Heated Chamber: {}", printer.heated_chamber);
               println!("  - Nozzle Diameter: {}mm", printer.nozzle_diameter);
               all_printers.push((printer.id.clone(), printer.name.clone()));
           }
   
           // Check if there are more pages
           if !data.printers.page_info.has_next_page {
               break;
           }
           page += 1;
       }
   
       Ok(all_printers)
   }

   C++

   struct PrinterInfo {
       std::string id;
       std::string name;
       std::string brand;
   };
   
   std::vector<PrinterInfo> listPrinters(const std::string& pat) {
       int page = 1;
       const int pageSize = 50;
       std::vector<PrinterInfo> allPrinters;
   
       // Paginate through all printers
       while (true) {
           const std::string query = Printers::GetRequestText();
           graphql::response::Value variables = Printers::serializeVariables(
               Printers::Variables{.page = page, .pageSize = pageSize}
           );
   
           auto response = Printers::parseResponse(sendHttpRequest(query, variables, pat));
   
           // Collect printers from this page
           for (const auto& printer : response.printers.objects) {
               std::string brandName = printer.brand ? printer.brand->name : "Unknown";
               allPrinters.push_back({printer.id, printer.name, brandName});
   
               std::cout << "Printer: " << printer.name << " (" << brandName << ")" << std::endl;
               std::cout << "  - Heated Bed: " << (printer.heatedBed ? "true" : "false") << std::endl;
               std::cout << "  - Heated Chamber: " << (printer.heatedChamber ? "true" : "false") << std::endl;
               std::cout << "  - Nozzle Diameter: " << printer.nozzleDiameter << "mm" << std::endl;
           }
   
           // Check if there are more pages
           if (!response.printers.pageInfo.hasNextPage) {
               break;
           }
           page++;
       }
   
       return allPrinters;
   }

3. Put it all together

   Run the function and display the results.

   TypeScript

   // Example usage
   listPrinters()
     .then((printers) => {
       console.log(`\nTotal printers found: ${printers.length}`);
     })
     .catch(console.error);

   Python

   if __name__ == "__main__":
       async def main():
           printers = await list_printers()
           print(f"\nTotal printers found: {len(printers)}")
   
       asyncio.run(main())

   Rust

   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       let pat = std::env::var("PAT").expect("PAT environment variable must be set");
   
       let printers = list_printers(&pat).await?;
       println!("\nTotal printers found: {}", printers.len());
   
       Ok(())
   }

   C++

   int main() {
       const char* pat_env = std::getenv("PAT");
       if (!pat_env) {
           std::cerr << "PAT environment variable is required" << std::endl;
           return 1;
       }
       std::string pat(pat_env);
   
       auto printers = listPrinters(pat);
       std::cout << "\nTotal printers found: " << printers.size() << std::endl;
   
       return 0;
   }

Running the Example

1. Create a .env.local file with your PAT:

   PAT="your-personal-access-token"

2. Run the example:

   TypeScript

   bun run index.ts

   Python

   uv run main.py

   Rust

   cargo run

   C++

   mkdir build && cd build
   cmake .. -DVCPKG_DIR=$(pwd)/../vcpkg/installed/arm64-osx
   make
   ./ExampleApp

Note

You can filter printers by specific criteria such as heated bed availability using the filters parameter.