Reusable Functions

​

What are Reusable Functions?

• Define the logic once in a reusable function
• Use the function in multiple processes through data mapping
• Automatically propagate updates to all instances when you modify the function

​

Key benefits

​

Before you begin

• Access to the FlowX.AI Designer
• Appropriate permissions to create and manage reusable resources
• A clear understanding of the business logic you want to implement

​

Create a reusable function

1

Access the Functions section

1. In FlowX.AI Designer, go to your project
2. Navigate to Reusable Resources > Functions
3. Click the + icon to create a new function

2

Configure basic settings

1. Enter a descriptive name for your function
2. Add an optional description explaining the function’s purpose
3. Click Save to create the function and open the editor

3

Define the data model

1. Go to the Model tab
2. Add attributes that your function will work with:
   • Click Add Attribute to create new fields
   • Set attribute types by selecting existing objects from your project
   • Define nested structures as needed

Functions support both primitive data types (string, number, boolean) and complex object data types for input and output parameters.

• Primitive data model
• Object data model

Simple data types for straightforward calculations:

Report incorrect code

Copy

Ask AI

{
  "monthlySalary": "number",
  "loanTerm": "number",
  "interestRate": "number"
}

4

Configure input parameters

1. Switch to the Input Parameters tab
2. Select the fields that your function needs as input
3. Expand objects to choose specific properties

Define clear input contracts to make your functions truly reusable across different contexts.

5

Set output parameters

1. Go to the Output Parameters tab
2. Choose what data the function returns
3. Select individual fields or entire objects as needed

6

Implement the business logic

1. Navigate to the Script tab
2. Choose your programming language (JavaScript or Python)
3. Write your business logic using the appropriate data format

• Primitive data example
• Object data example

Simple function that processes primitive data types:

calculateMaxLoanAmount

calculateMaxLoanAmount (Python)

Report incorrect code

Copy

Ask AI

// Function format: functions.projectName.functionName(input)
function functions.academy.calculateMaxLoanAmount(monthlySalary) {
    // Simple calculation
    output = input.monthlySalary * 48;
}

Always use input.attribute format to access function parameters and output.attribute to set return values.

7

Test your function

1. Go to the Test tab
2. Add sample data for your input parameters
3. Click Test to execute the function
4. Review the output to ensure your logic works correctly
5. Save your function when testing is successful

​

Use functions in processes

​

Where you can reference functions

• Business Rule actions within process nodes
• Other reusable functions to create composite logic

​

Function referencing syntax

functions.projectName.functionName(input.params)

• functions - Convention to reference any reusable function
• projectName - Name of the project/library where the function is defined
• functionName - Name of the reusable function
• input.params - Input parameters using local process variables

functions.academy.calculateMaxLoanAmount(input.monthlySalary)

​

Add a function to a process

1. Open your process definition in FlowX.AI Designer
2. Select the node where you want to add business logic
3. Create a new Business Rule action
4. Reference your reusable function using the syntax above
5. Configure data mapping between your process and the function

​

Configure data mapping

{
  "firstName": "processData.customer.firstName",
  "lastName": "processData.customer.lastName"
}

​

Use functions within functions

// Call another function and use its output
const maxLoan = functions.academy.calculateMaxLoanAmount(input.monthlySalary);

// Use the result in further calculations
const loanDetails = functions.loanLibrary.calculateLoan({
    principal: maxLoan,
    rate: input.interestRate,
    term: input.loanTerm
});

// Set the final output
output.integratedLoanData = loanDetails;

// Function that calculates loan based on salary using other functions
function functions.loanProject.integratedLoanCalculator(clientData) {
    // Calculate how much loan a person can get based on their salary
    const maxAmount = functions.academy.calculateMaxLoanAmount(input.clientData.monthlySalary);
    
    // Use that amount with calculateLoan function to compute detailed loan information
    const loanDetails = functions.loanLibrary.calculateLoan({
        principal: maxAmount,
        monthlyRate: input.clientData.monthlyRate,
        numberOfPayments: input.clientData.numberOfPayments,
        client: input.clientData
    });
    
    // The final computed result is passed into the output
    output.integratedLoanData = loanDetails;
}

​

Manage functions

​

View function usage

1. Select the function in Reusable Resources > Functions
2. Click the Usages tab
3. Review all processes and nodes that reference the function

​

Update functions

• Changes automatically propagate to all instances
• Existing process instances may need to restart to pick up updates
• The system preserves instance-specific configurations like data mapping

​

Change programming languages

1. Open the function editor
2. Go to the Script tab
3. Select a different language from the dropdown
4. Rewrite your logic in the new language
5. Test thoroughly before saving

​

Best practices

​

Design principles

​

Development workflow

1. Define data model first: Always establish your data structure before writing code
2. Specify parameters early: Define inputs and outputs before implementing logic
3. Use descriptive names: Choose clear, business-oriented function names
4. Test thoroughly: Validate functions with realistic data before deployment
5. Handle errors gracefully: Implement robust error handling in your business logic

​

Organization strategies

• Group related functions: Organize functions by business domain or use case
• Follow naming conventions: Establish consistent patterns for function names
• Document extensively: Include clear descriptions and usage examples
• Version carefully: Use project versioning to manage function changes safely

​

Troubleshooting

​

Common issues

​

Debugging strategies

1. Use the test environment: Always test functions thoroughly before deploying to production
2. Start simple: Build and test functions incrementally rather than implementing everything at once
3. Use realistic data: Test with data that matches your production scenarios
4. Verify outputs: Carefully check that function outputs match your expectations
5. Add logging: Include console output in your function logic to trace execution

​

Function execution context

​

Function format and syntax

function functions.projectName.functionName(parameterName) {
    // Function implementation
}

• Function declaration: functions.projectName.functionName(parameters)
• Input access: Always use input.attribute to access function parameters
• Output assignment: Use output.attribute to set return values
• Function calls: Reference other functions using functions.projectName.functionName(params)

​

Data access patterns

• Input parameters: Mapped from process data according to your configuration
• Output object: Used to return processed data back to the process
• Standard libraries: Built-in functions available in JavaScript or Python
• Error handling: Mechanisms to report execution problems back to the process

// Access input parameters
const salary = input.monthlySalary;
const client = input.client;

​

Frequently asked questions