Fuuz Platform Nodes

Fuuz Platform Nodes

Article Type: Node Reference Audience: Developers, App Admins Module: Data Flows / Node Designer Applies to Versions: Platform 3.0+ Prerequisites: Basic understanding of Data Flow concepts, familiarity with GraphQL

1. Overview

What are Fuuz Platform Nodes?

Fuuz Platform Nodes are specialized nodes that interact directly with core Fuuz platform capabilities. These nodes provide access to the GraphQL API, document generation, email services, calendar functions, and flow orchestration — enabling deep integration with the platform's data and services.

Why are they important?

These nodes eliminate the need for external API calls when working with Fuuz data and services. They provide optimized, secure access to query and modify data models, generate documents, send notifications, and orchestrate complex multi-flow processes.

The 8 Fuuz Platform Nodes

Node	Purpose
Query	Execute GraphQL queries against Fuuz API (system and custom models)
Mutate	Perform CRUD operations (Create, Update, Delete) on Fuuz Data Models
Aggregate	Execute MongoDB pipelines for grouping, aggregation, and analytics
Saved Query	Execute reusable saved queries with variable inputs
Execute Flow	Call deployed flows with Request/Response nodes
System Email	Send emails via Amazon SES for alerts, reports, and notifications
Render Document	Generate documents from Document Designs (PDF, Word, Excel, HTML) — Depends on the Stimulsoft Module (cloud only)
Get Calendar	Retrieve calendar data for event and availability functions — Deprecated functionality

2. Query Node

The Query node gives you access to the Fuuz GraphQL API including custom schema. The node supports both handwritten GraphQL statements as well as a query builder where you can build out what you want the query to return.

You provide the filtering parameters you require into the variables section. For better type hinting, you can use the API explorer to provide auto-completes for the structure of the variables based on your $variable definitions in the query.

Configuration Parameters

Parameter	Description
API	Application or System (select which API to query)
Query	GraphQL query statement
Variables	Payload to provide filtering parameters to the query

Example Query

query Query($where: CalendarWhereInput, $orderBy: [CalendarOrderByInput!]) {
  calendar(where: $where, orderBy: $orderBy, first: 10) {
    edges {
      node {
        id
      }
    }
  }
}

3. Mutate Node

The Mutate node provides the ability to perform CRUD (Create, Update, Delete) operations on Fuuz Data Models. This includes both System and Application models.

Configuration Parameters

Parameter	Description
Mutation	GraphQL Mutation statement
Variables	Payload to provide to the mutation

Upsert Mutation Example

Mutation:

mutation upsertCalendar($payload: [UpsertCalendarInput!]!) {
  upsertCalendar(payload: $payload) {
    id
    name
    description
  }
}

Variables:

{
  "payload": [
    {
      "where": { "name": "My Test Calendar" },
      "create": {
        "name": "My Test Calendar",
        "description": "New Calendar"
      },
      "update": {
        "name": "My Test Calendar",
        "description": "The Test Calendar"
      }
    }
  ]
}

4. Aggregate Node

The Aggregate node allows you to write MongoDB pipelines against the current tenant's data. This gives the ability to group, unique, and aggregate data.

Important: The Aggregate node should only be used as an extension of the GraphQL API and should never be used in place of it. Use Query/Mutate nodes for standard operations; use Aggregate only when you need MongoDB-specific capabilities like $group, $unwind, or complex aggregations.

Configuration Parameters

Parameter	Description
Collection Transform	Dynamic or hard-coded collection name. By default, collections are named the same as the data model with the first character lowercased.
Pipeline Transform	MongoDB pipeline stages. This is a transform to allow conditional logic to change your pipeline.
Explain Plan	Shows what indexes were used and how the database processed your request. Helpful for optimizing queries on large data sets.

5. Saved Query Node

The Saved Query Node allows you to select a saved query to run and provide the variables required to it. This node is useful if you are copying/pasting the same query in many different places — you only need to edit it in one place and all flows using it will be updated.

Important: You can easily break your Data Flows if you remove fields that were previously being passed and expected by a flow.

Configuration Parameters

Parameter	Description
Saved Query	The query you want to run (select from dropdown)
Variables	The filtering parameters/payload for the query

Saved Query Operation Types

Type	Description
Query	An operation which retrieves data from the system
Mutation	An operation which changes data in the system
Subscription	An operation which listens for changes in the system

6. Execute Flow Node

The Execute Flow node allows you to call a deployed flow that has Request and Response nodes. The node makes an HTTP POST request to the selected Data Flow. The Data Flow will receive the data you provide in the payload transform at its Request Node.

When the called Data Flow hits its Response Node, the result is returned through the output of this Execute Flow node. If the called Data Flow throws an error, it will be bubbled up to the Execute Flow node that called it.

Configuration Parameters

Parameter	Description
Flow	The flow you are requesting (must have Request/Response nodes)
Payload Transform	The data to send as payload to the corresponding Request Node

Note: Context is NOT passed to the called flow. If you need to pass your context, you must add it to your payload transform.

Use Case Example

There is a need for a common way to format a payload to create a document in the same format. Rather than copying and pasting the same chain of nodes to each data flow, you could create a single flow that formats the data. Other flows can then execute the formatting flow through an Execute Flow node for consistent formatting.

7. System Email Node

The System Email node utilizes Amazon SES (Simple Email Service) to send emails. This node is useful for automated error emails and reports. Emails are sent from mail@{enterprise_name}.fuuz.app.

Configuration Parameters

Parameter	Description
To	Email address(es) to send to. Can be provided as a transform for lists stored in context.
CC	Email address(es) to copy on the email
BCC	Email address(es) to blind copy. Useful for QA monitoring without appearing as recipient.
Reply To	Email address for replies. Useful for routing customer replies to IT personnel.
Subject	Email subject. Be specific so you can identify resources at a glance (e.g., "Purchase Order 1234 failed upload" not "Purchase Order failed upload").
Body	Email body — can be sent as Text or HTML. You can use HTML to create tables instead of attachments.
Attachments	Files to send with the email (PDF, CSV, XLS, etc.)

Note: Attachment Encoding — Be sure to select encoding Base64 for PDFs and UTF8 for CSV/Text Documents.

8. Render Document Node (Requires Stimulsoft Module - Cloud Only)

The Render Document Node is used to generate document designs within a Data Flow. Documents are generally emailed out or written to an FTP after generation.

Configuration Parameters

Parameter	Description
Document Design	The document design template to use
Payload Transform	The data to send to the document for rendering
File Name	How the document should be named
Format	Output format: PDF, Microsoft Word, Plain Text, HTML, Legacy HTML, or Microsoft Excel
Culture	Culture code for multilingual documents. Changes formatting of dates, times, words to match the culture.

9. Get Calendar Node (Deprecated)

The Get Calendar Node allows you to retrieve a calendar formatted for the JSONata bindings to find events within the calendar. This can be done by selecting a static calendar from the Combobox picker or through a transform for dynamic evaluation.

Configuration Parameters

Parameter	Description
Calendar	Selected calendar or dynamic transform referencing the calendar's name

Calendar JSONata Bindings

The calendar data retrieved can be used with the following JSONata bindings:

Function	Description
$eventsBetween()	Get events between two dates
$getEventEnd()	Get the end time of an event
$getEventsAt()	Get events at a specific time
$getAvailabilityBetween()	Get availability windows between two dates
$availableAt()	Check availability at a specific time

10. Best Practices

Query & Mutate Best Practices

• Use the API Explorer for auto-complete and type hinting when building queries
• Prefer Query/Mutate nodes over Aggregate for standard CRUD operations
• Use Saved Queries for frequently reused queries across multiple flows
• Be careful when modifying Saved Queries — changes affect all flows using them

Integration Standards (from Design Guidelines)

• Use of $integrate() in transforms is highly discouraged (may be deprecated)
• Intent is to make all outbound calls pink in color for easier reference
• Use native nodes over HTTP node when available (e.g., use Plex node instead of HTTP for Plex calls)

Email Best Practices

• Be specific in subjects for easy identification (include IDs, names)
• Use HTML body for formatted tables rather than CSV attachments when practical
• Set Reply To for integrations where customers might respond
• Use BCC for QA monitoring without appearing as a recipient
• Use Notification Channels to manage recipients outside the flow

11. Troubleshooting

Symptom	Likely Cause	Resolution
Query returns empty	Incorrect where clause or variables	Test query in API Explorer with same variables
Execute Flow timeout	Called flow missing Response node	Ensure all branches terminate with Response node
Email attachment corrupted	Wrong encoding selected	Use Base64 for PDFs/images, UTF8 for text files
Saved Query broken	Fields removed that flows expect	Review all flows using the query before modifying
Document dates wrong format	Culture not specified	Set Culture parameter on Render Document node
Context not in called flow	Execute Flow doesn't pass context	Include needed context in payload transform

12. Related Resources

• Custom Fuuz Only JSONata Library — Platform-specific bindings including $query, $mutate, $document
• Script & Validation Nodes — Custom scripting capabilities
• Data Flow Design Standards — Development guidelines and best practices
• Document Designer User Manual — Creating document templates
• GraphQL API Explorer — Interactive query builder and tester
• Platform Website: fuuz.com

13. Revision History

Version	Date	Author	Description
1.0	2025-01-01	Fuuz Documentation Team	Initial release - Complete guide covering 8 Fuuz Platform nodes: Query, Mutate, Aggregate, Saved Query, Execute Flow, System Email, Render Document, and Get Calendar.

See Also

• Data-Flow-Nodes-Reference
• Custom-Fuuz-Only-JSONata-Library
• Script-and-Validation-Nodes
• Integration-Nodes
• Flow-Control-Nodes
• Data-Flow-Design-Standards-Design-Standards

---

Source: support.fuuz.com