Fluent Commerce Logo
Docs
Help & Feedback

Frameworks

User Interface Framework (WebApps, Manifest Configuration, Fragments, Components, and their Elements.), Orchestration Framework (Workflow, Actions, Rules, Entities, Contracts, Settings, Triggers, Status, and Variables), Developer Tooling (Modules, Templates, Connectors, and SDKs.)

(ongoing release)Configuring Wildcard Search with a Two-Layer Model

Essential knowledgeThis article describes the two-layer configuration model for controlling wildcard behavior in string-based search filters.The new model introduces:
  • An account-level wildcard configuration (the `fc.mystique.filters.string` setting) that defines the default wildcard behavior for all string filters
  • A field-level override (`wildcardFilter`) inside the `fc.filter.string` component, which allows customizing wildcard behavior for specific fields.
Both layers work together to enhance search performance and flexibility, while providing teams with control over how partial or exact matching should be implemented.
  • Wildcard search can be controlled at two levels: an account-level default that applies to all filters unless overridden, and a field-level configuration that takes highest priority.
  • The account-level setting defines the default wildcard behavior across the UI.
  • Individual filters can override this default using the wildcardFilter property.
  • Wildcard behavior is controlled by two simple options: Leading wildcard and Trailing wildcard.
  • Field-level overrides always take priority over account-level settings.
  • If no configuration is present, the system falls back to the legacy default: full wildcard search.
  • Leaving an option undefined means that the wildcard type is turned off.
  • Exact matching is supported by turning both wildcards off.

UX Configuration - Common Concepts

Essential knowledgeSome common types and conventions are used across many component definitions. These items are not directly configurable in the manifest but will often be referenced in other component definitions that use them.
  • The Mystique manifest configures icons, cards, and template strings. Icons come from React Icons. 
  • Cards have common fields, and template strings allow dynamic values. Dynamic attributes (standard, image, component) offer flexibility based on conditions. 
  • A selection of helper functions are also available to control and transform these values as required, for example, number, logic, i18n, array, date, and string functions.
  • Additional options like TextOptions and ImageOptions provide styling choices.

Setup and Configuration Labs

Essential knowledgeThe Setup and Configuration lab covers the step by step guide to setup a Retailer from scratch
  • Stick to the following sequence while creating different entities

Introduction to the Component Library

Essential knowledgeThe OMX Component Library is a suite of UI Components, ready to be configured and used in Fluent Web Apps.Unlike a standard UI Component, Fluent Components are built to natively interact with the Fluent Platform.The Library contains a number of different types of Components, including:
  • Foundation Components, such as Page Components which form the base of a screen
  • Content Components for displaying data and media
  • Layout Components for structuring pages
  • Interaction Components for capturing user input
  • Foundation Components, such as Page Components which form the base of a screen
  • Content Components for displaying data and media
  • Layout Components for structuring pages
  • Interaction Components for capturing user input

Dynamic Queries and Utils

Essential knowledge`DynamicEntityQuery`, with the help of the `DynamicUtils` class, automatically derives the correct GraphQL query operation for the primary Entity from the `RulesetContext`. It dynamically retrieves fields related to that Entity, removing the need for pre-compiled queries while preserving type safety and performance.
  • Runtime Query Generation: Automatically builds GraphQL queries at runtime based on entity context, eliminating pre-compiled queries.
  • Dual Usage Patterns: Type-based mapping with POJO classes for strong typing, or path-based queries for maximum flexibility.
  • Universal & Validated: Works across different entity types with automatic schema validation and connection pattern handling.
  • Flexible Access: Results accessible as typed objects, JsonNode, or flattened maps with Lombok integration.
  • Connection Handling: Built-in support for paginated connections with automatic pagination handling via `queryList()` methods.
  • Dynamic Mutations: Update entity properties dynamically using key-value pairs without pre-compiled mutation queries.
  • Unified Data Access: `getJsonPath()` method provides unified access to both event and entity data using consistent path syntax.

Dynamic Utilities Overview

Essential knowledgeThe `util-dynamic` library is a collection of utility functions that allow you to generate GraphQL queries and mutations at runtime. This enables the creation of highly configurable and reusable rules that can adapt to different needs without requiring code changes.PrerequisitesThese articles assumes you're familiar with:
  • Java
  • Maven
  • JUnit
  • Dynamic Queries: Fetch any field from an entity at runtime by providing a POJO class that defines the desired data structure, eliminating the need for pre-compiled queries.
  • Dynamic Mutations: Update any field on an entity by passing a simple `Map` of key-value pairs, allowing for the creation of generic "field setter" rules.
  • Dynamic Connections: Easily query and iterate over paginated one-to-many relationships (like `order.items`), as the utility handles all the pagination logic for you.
  • Advanced JSON Path: A powerful `getJsonPath` method that can retrieve data from either the event or the entity itself, automatically determining the correct source.
  • Enhanced JSON Utilities: This bundle includes a more advanced `JsonUtils` with powerful methods for navigating and transforming complex JSON structures.

Introduction to the Events API

Essential knowledgeThe Events API is a core component of the Fluent Platform, enabling the creation and management of events that drive workflow logic and system activity tracking. It supports asynchronous operations for optimized performance and integrates with systems for inventory updates, product data transfer, fulfillment, and carrier tracking.
  • Events are fundamental to the Fluent Platform, representing actions or occurrences within the system.
  • The Events API enables viewing and creating events, supporting workflow logic and system activity tracking.
  • `ORCHESTRATION` events trigger workflows, while `ORCHESTRATION_AUDIT` events log workflow execution details.
  • Common Event API operations include retrieving events by ID, filtering events, and creating new events asynchronously.
  • Event Contracts are defined by Rulesets in workflows, combining event attributes to handle specific processes.
  • Recommended practice: Use asynchronous integration for non-real-time actions to optimize performance.
  • Common integrations include inventory updates, product master data transfer, fulfillment updates, and carrier tracking.

Dashboard Interface

Essential knowledgeThe Fluent OMS Web App's dashboard interface serves as a central hub for monitoring and managing order activity and alerts.
It provides real-time visibility into key operational metrics — such as orders received, escalations, returns, cancellations, and pending actions — enabling quick responses to exceptions.The dashboard is fully configurable to match business requirements. The numbers displayed represent the total records returned by these queries.
  • The OMS Dashboard provides real-time visibility into orders and alerts, supporting exception management.
  • Data is sourced from configurable GraphQL queries defined in the manifest.
  • Tiles are grouped into two sections: Orders and Alerts, each showing counts for specific timeframes or statuses.
  • Tile colors (Green, Orange, Red) change based on the Dashboard Threshold component configuration.
  • The maximum count displayed per tile defaults to 50; higher values show as 50+.
  • Clicking a tile applies a preconfigured search filter and navigates to the relevant list view.
  • Counts are based on the timestamp of the last dashboard load or refresh.

Users, Roles, and Permissions

Essential knowledgeThe Fluent platform provides a comprehensive user role management system, allowing for the assignment of diverse permissions via roles to regulate platform access and functionalities. Custom roles can be created and fine-tuned, ensuring users only have access to appropriate functionality and data. The system provides flexibility to specify the scope for a role at different context levels, such as Accounts, Retailers, and Locations.
  • A role can be assigned to multiple users, and a user can be assigned multiple roles.
  • Permissions are granular access controls and protect every GraphQL or REST API operations. GraphQL permissions follow specific naming conventions.
  • Context plays a pivotal role in access levels, allowing users to have role-based access to data for specific Accounts, Retailers, or Locations.

Responsive Sourcing Framework Overview

Essential knowledgeThe Responsive Sourcing Framework is a configurable, scalable alternative to custom Workflows and Rules for managing sourcing strategies. You’ll learn how to define and optimize sourcing logic using Sourcing Profiles, Strategies, Conditions, and Criteria. The Framework empowers both technical and business users with faster implementation, greater control, and transparency into how sourcing decisions are made and why.
  • Prerequisites: You should have knowledge of Order Management and Order lifecycle, Order Reference Module, and GraphQL API
  • The Responsive Sourcing Framework is designed for both technical and business users - logic is transparent and comes with a configurable User Experience (UX)
  • Enables faster implementation by reusing modular sourcing logic building blocks such as Sourcing Profiles, Strategies, Conditions, and Criteria
  • Sourcing Profile GraphQL API is required to correctly set up your sourcing logic
  • Supports custom Sourcing Conditions and Criteria through externally developed extensions for advanced or domain-specific logic

Sourcing Profiles Interface

Essential knowledgeThe Sourcing Profiles functionality in the Fluent OMS Admin interface enables retailers to configure, manage, and optimize sourcing rules. Profiles group strategies with defined priorities, catalogs, and networks, while strategies use flexible conditions (IF) and criteria (THEN) to refine fulfillment logic. New profiles are created via API, while profile versions can be generated either through the Admin UI or API. The UI provides capabilities to view, edit, reorder, activate, and track versions.
  • Part of Admin UI: Sourcing Profiles are managed in the Admin interface for Fluent OMS.
  • Profile Versions: Editing a profile in the Admin UI triggers the creation of a new draft version via the `updateProfile` mutation.
  • Centralized Management: View all active profiles with key details such as version, status, last updated, default catalog, networks, and max split.
  • Sourcing Strategies: Create new strategies (including fallback) and edit existing ones. Strategies within profiles are assigned priorities, ensuring that the most critical business rules are applied first.
  • Conditions & Criteria: Define or adjust fulfillment logic using configurable IF conditions and THEN criteria.
  • Intuitive Editing Experience: Users can easily add or configure conditions, set maximum splits, and apply catalogs or networks through guided forms.

Sourcing Criteria Overview

Essential knowledgeSourcing Criteria determine which eligible Locations are best once a Strategy applies. You’ll learn how to configure, sequence, and extend Criteria so your prioritization is predictable and explainable across business scenarios.
  • Define prioritization with configurable Sourcing Criteria that score and order candidate Locations
  • Reference Sourcing Criteria schema is global and can be extended or overridden with customer-specific definitions for tailored Strategies
  • Criterion Utilities provide reference functions, normalization, and a registry/annotations model for custom extensions
  • Configure all Criteria with clear names, parameters, and evaluation order to ensure accurate and predictable ranking

Sourcing Conditions Overview

Essential knowledgeSourcing Conditions let you control how Sourcing Strategies are applied within the Responsive Sourcing Framework. After reading, you will understand how to configure and extend them to adapt sourcing logic for specific Sourcing Requests.
  • Define your sourcing logic with configurable Sourcing Conditions that evaluate Sourcing Requests and return true/false outcomes
  • Reference Sourcing Conditions schema is global but can be extended or overridden with customer-specific definitions for tailored Strategies
  • Condition Utilities provide reference function, default operators (equality, comparison, membership, existence), and support custom extensions
  • All Conditions should be configured with clear naming and parameters to ensure accurate and predictable evaluation

Order Orchestration Module Overview

Essential knowledgeThe 'Order Orchestration' module is integral to Fluent Order Management. It handles the end-to-end management of orders from creation to fulfillment. It optimizes the fulfillment process, allowing flexibility and control over sourcing and fulfillment strategies.
  • Dynamic Sourcing: Selects the best location based on inventory and business rules.
  • Split Fulfillment: Supports fulfilling orders from multiple locations.
  • Custom Workflows: Allows tailoring workflows for Home Delivery, Click & Collect, and more.
  • Fulfillment Management: Tracks multiple fulfillments and manages SLAs and exceptions.
  • Retailer Benefits: Reduces costs, optimizes sourcing, and ensures operational flexibility.

Admin Interface

Essential knowledgeThe Admin interface in the Fluent Web Apps provides comprehensive administrative capabilities to manage the entire system efficiently.
  • The Admin interface helps in managing users, retailers, settings, etc.
  • Depending on the configuration, it can contain any combination of the following: Retailers, Carriers, Users, Roles and Permissions, and Settings.

Sourcing Utilities Overview

Essential knowledgeThe `util-sourcing` library is a comprehensive collection of utility functions designed to minimize the overhead and complexity of writing sourcing logic in your Fluent Commerce rules.PrerequisitesThese articles assumes you're familiar with:
  • Java
  • Maven
  • JUnit
  • Sourcing Orchestration (`SourcingUtils`): Orchestrates the sourcing process and provides helper methods to load a Sourcing Profile
  • Context Management (`SourcingContextUtils`): Loads and manages Sourcing Context 
  • Order Helper (`OrderUtils`): Performs order-specific operations such as fulfillment creation
  • Location-Based Optimization (`LocationUtils`): Provides location-based helpers including distance calculations and caching
  • Sourcing Conditions and Criteria Management: Provides functions, registration, and execution logic for tailoring Sourcing Strategies to the specific needs of customers

Sourcing Utils

Essential knowledgeThe `SourcingUtils` class in the `util-sourcing` bundle is the main utility class that orchestrates the entire sourcing process within a Rule. It provides core helper methods such as loading a Sourcing Profile, initialise the Sourcing Context, and trigger the execution of the sourcing logic configured in the profile. Each stage supports multiple customisation points throughout the process.
  • Main Orchestrator: Central utility class that coordinates all sourcing operations from a Rule.
  • Strategy Evaluation: Evaluates and applies sourcing strategies based on business rules.
  • Plan Generation: Creates optimal sourcing plans for order fulfillment

Order Utils

Essential knowledgeThe `OrderUtils` class in the `util-sourcing` is a utility class that provides order-specific utilities for sourcing operations. It handles order-related sourcing operations including fulfillment creation, fulfillment type determination, and order item management.
  • Order-Specific Operations: Handles order-related sourcing operations.
  • Fulfillment Creation: Creates fulfillment records based on sourcing plans.
  • Fulfillment Type Management: Sets fulfillment types based on business rules.
  • Order Item Management: Manages order items and their allocation to fulfillments.

Sourcing Context Utils

Essential knowledge`SourcingContextUtils` in the `util-sourcing` is a utility class for managing sourcing context and data loading operations. It provides methods to create and populate sourcing contexts with order details, unfulfilled items, and supporting data required for sourcing decisions.
  • Context Management: Creates and manages Sourcing Context for the sourcing process.
  • Data Loading: Handles loading of order, item and required information.

Location Utils

Essential knowledgeThe `LocationUtils` class in the `util-sourcing` is a utility class that provides utilities for location-based sourcing decisions. It handles location-specific sourcing logic including distance calculations, location availability checks, and provide location-based caching optimization.
  • Location-Based Decisions: Handles location-specific sourcing logic.
  • Distance Calculations: Calculates distances between locations for proximity-based sourcing.
  • Location Availability: Checks if locations are active and available for sourcing.
  • Caching Optimization: Provides location-based caching optimization.

Product Description - Fluent Commerce OMS

Essential knowledgeFluent Order Management components are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure. These components operate within the framework to enable the order management experience on the platform.
  • The main components that comprise the platform architecture are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure.
  • Each Module represents a particular business domain and its associated rules and workflows. Core, Inventory, Order and fulfilment are the four Fluent modules.
  • These are the web and in-store interfaces used to access module functionality.

Product Description - Fluent Commerce OMS

Essential knowledgeFluent Order Management components are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure. These components operate within the framework to enable the order management experience on the platform.
  • The main components that comprise the platform architecture are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure.
  • Each Module represents a particular business domain and its associated rules and workflows. Core, Inventory, Order and fulfilment are the four Fluent modules.
  • These are the web and in-store interfaces used to access module functionality.

Exception Management in writing Rules

Essential knowledgeThe Workflow Framework Engine ensures that all Exceptions thrown out of Rules are recorded within the Orchestration Audit Events, accessible via the Event API. This is important for providing detailed information about what went wrong.
  • To ensure that the Orchestration Audit Events contain as much useful information as possible, it is important to consider the Exception Strategy used by your Rules.
  • Don't swallow exceptions inside Rules, and always allow a caught exception to be re-thrown, or added as a cause to a new exception to ensure the cause is included in the Audit Events.
  • The Workflow Framework provides a special exception type called RuleExecutionException which provides special handling of exceptions differently from all others.

Orchestration Webhooks

Essential knowledgeFluent workflows use webhooks for real-time communication with external systems, triggered at specific workflow points. Webhooks provide timely updates for order status, shipping, payments, and inventory movements. The standard SendWebhook rule simplifies outbound communication by sending basic data, allowing external systems to retrieve additional information as needed.
  • Webhooks enable real-time communication between Fluent workflows and external systems, eliminating the need for frequent API polling.
  • The `sendWebhook` rule simplifies outbound communication by passing essential data that external systems can use to fetch additional details.
  • Typical use cases include order status updates, shipping notifications, payment captures, and stock transfers.
  • Webhooks should not be used for Inventory domain operations due to scalability concerns, performance impacts, and stability risks, so use Inventory Feeds instead.
  • In rare cases where inventory-related webhooks are required (e.g., conditional stock change notifications), contact our team to discuss alternatives before implementation.

Workflow Framework Labs

Essential knowledgeThis module will guide you through a hands-on lab where you can put all of the theory to practice and implement a simple Fraud Check solution.  This will cover adding new business logic to your workflow, including configuring some user actions to enable business users to approve or cancel orders that have been flagged as potentially fraudulent.
  • For this lab you will need:
    • Postman application installed
    • A Fluent Commerce training account
    • A Postman environment file corresponding to your your Fluent Commerce account
  • This Lab uses the fc_sports_admin retailer, please make sure to use this retailer when logging into your Fluent Commerce training account

Fluent Store Web App Overview

Essential knowledgeFluent Store is an in-store responsive web application that provides store staff with end-to-end order management capabilities.
  • Key features of Fluent Store
  • Benefits to Retailers
  • Module dependencies
  • Technical Information (Browser, Device, and Language support)
  • Data model
  • Further Reading

Rule Context Generator

Essential knowledgeThe `RuleContextGenerator` is the underlying class that the `RuleExecutor` and `WorkflowExecutor` use to construct a mock `Context` for your tests. While you will most often interact with it through the executors, you can also use it directly to manually create a `Context` object.This is particularly useful when you are unit testing a helper or utility class that requires a `Context` object as a parameter, but you don't need to execute a full rule.
  • Core Context Builder: `RuleContextGenerator` is the fundamental builder class that the `RuleExecutor` and `WorkflowExecutor` use to create the mock `Context` for your tests.
  • Direct Instantiation: You can use it directly (`RuleContextGenerator.of(...)`) when you need a `Context` object for testing a helper class or utility method, but don't need to execute a full rule.
  • Action Tracking: It automatically captures and tracks all actions (events, mutations, logs) performed during execution, providing methods like `getActionsOfType()` and `getLastActionOfType()` for verification.
  • Foundation of Testing: It is the foundational component of the test utilities, providing the mock environment that makes isolated unit and integration testing possible.

Rule Executor

Essential knowledgeThe `RuleExecutor` is the primary tool in the `util-test` library for unit testing a single rule in isolation. It provides a builder-style interface for setting up a mock `Context`, executing your rule's `run` method, and asserting the results.
  • Unit Testing Focus: `RuleExecutor` is the main tool for testing a single rule in isolation.
  • Arrange-Act-Assert: It's designed to follow the clean Arrange-Act-Assert pattern. You use the constructor to arrange the context, call `execute()` to act, and use `getActions()` to assert the outcome.
  • Rule Properties Configuration: Rule properties are passed as a `Map` in the `RuleExecutor.of(Class, Map)` constructor.
  • Event Configuration: Custom events can be passed to the `execute(Event)` method.
  • GraphQL Mocking: The `.mockNamedQuery()` method is a critical feature that allows you to provide predefined JSON responses for any GraphQL query your rule executes, enabling you to test different data scenarios without making live API calls.

Rule Actions

Essential knowledgeRule Actions are the single output of a Rule.Rules do not perform actions directly. Rather, they inform the Workflow Engine what it should do as a result of the rule execution. The Workflow Engine interprets the specific Action produced by the Rule and handles it appropriately.Most Actions are queued internally within the Workflow Engine and executed at the end of the current process.
  • There are 4 types of Actions available to produce from a Rule:
    • `SendEventAction`
    • `MutateAction`
    • `WebhookAction`
    • `LogAction`

Sample Rules

Essential knowledgeThe Rules SDK Maven archetype will generate 2 sample Rules into the Plugin Project.
  • DemoSendArbitraryEvent
  • DemoAddAttributeToOrder
  • DemoSendArbitraryEvent
  • DemoAddAttributeToOrder

What are Fluent OMS Entities? (Entity)

Essential knowledgeA detailed explanation of Fluent OMS entities and how they can be used throughout the order journey.
  • Entities in Fluent OMS are data objects that store and process information throughout the order journey, such as orders, fulfilments, and financial transactions.
  • Entities are managed via GraphQL, with mutations and queries used to create, update, and retrieve entity data.
  • Entities should not be deleted but controlled using status fields, although some "remove" mutations can disconnect entities.
  • Orchestrated Entities trigger a CREATE event upon successful creation, enabling workflow automation.
  • Entities in Fluent OMS serve unique purposes to enable an end-end digital commerce journey and their statuses determine at what stage they sit.
  • Entities have types and subtypes, types are rigidly defined, subtypes are more flexible.

Orchestration & Audit Events

Essential knowledgeThis article describes the details of the different events in the Fluent platform and provides the required base knowledge for troubleshooting. This article expects that you have a good understanding of the Fluent Event Execution process and how Events are matched before the corresponding business logic is executed.
  • There are two types of Orchestration Events and the corresponding subtypes:
    • External  Events
    • Internal Events
  • There are multiple types of Audit events: snapshot, ruleSet, rule, ACTION, CUSTOM, Exception
  • All events follow the same structure.

Workflow Executor

Essential knowledgeWhile the `RuleExecutor` is perfect for unit testing a single Rule, the `WorkflowExecutor` is the tool of choice for integration testing an entire Workflow or parts of it. It reads a Workflow definition from a JSON file and simulates the Fluent Orchestration Engine by executing the sequence of Rules and Rulesets.
  • Integration Testing Focus: `WorkflowExecutor` is the primary tool for integration testing an entire or parts of a Workflow.
  • Workflow Simulation: It mimics the Fluent Commerce Orchestration Engine by processing an initial Event and then passing the resulting Event to the next Ruleset in the chain.
  • Rule Mocking: The `.mockRule()` method is a powerful feature that allows you to replace a real Rule in the Workflow with a mock implementation. This is crucial for isolating the part of the Workflow you want to test.
  • Targeted API Mocking: The `.mockNamedQuery()` method lets you mock a GraphQL query only when it is called by a specific Rule, giving you fine-grained control over test data for different stages of the Workflow.
  • Consolidated Assertions: The `execute` method returns a single Context containing a consolidated list of all Actions from all Rules, allowing you to assert the final state.

Order management - Orchestration Engine and Cloud Infrastructure

Essential knowledgeThis topic describes the cloud native nature of the Fluent platform
  • Scalable
  • Secure
  • Versionless software
  • Zero downtime

Understanding Event Execution

Essential knowledgeThis page describes how Event Execution works.
  • When an Orchestration Event is received by the Rubix Orchestration Engine, it initiates the Execution Context. The Execution Context includes the event and the entity specified by the event.
  • Rubix will locate the Ruleset within the workflow that matches the signature of the event.

Order Orchestration - Reference solution on how OMS selects the next best location for fulfilment

Essential knowledgeThis article provides an example of how OMS selects the next best location for fulfilment
  • The below example demonstrate the reference solution on how OMS selects the next best location for fulfilment.

Overview of the Fulfilment Choice entity

Essential knowledgeThe Fulfilment Choice Entity is used to store the shipment specific information:
  • Delivery method
  • Delivery or pickup address
  • Delivery dates
  • A Delivery method is determined for a Fulfilment Choice with a Fulfilment Choice type
  • The Fulfilment Choice is an Orchestrateable Entity that allows to update and configure its sub-workflow to fit your specific requirements
  • The Fulfilment Choice is an Order child entity that used to have one-to-one relations to it

Designing Rules

Essential knowledgeThis page provides all the information needed to design best practice Rules for your workflows. There are some important things to be aware of, so we highly recommend you thoroughly read through this page, and refer back to it regularly during development.
  • providing a guideline of designing your Rule within Fluent
  • It is important to keep the best practices and design principles in mind when designing your rules.
  • understand types of analogies when come to building rules

Designing Workflows

Essential knowledgeYou will learn how to design workflows, what they consist off and what are the best practices. 
  • The following topic covered when comes to designing workflows:
    • Workflow Boundaries
    • Workflow Patterns
    • Flow Control
    • Cross-Retailer
    • Cross-Workflow
    • Workflow Versioning
    • Defining Rulesets
    • Workflow Settings

General Principles for Rules

Essential knowledgeUnderstand what are some general Rule principles.
  • Fluent uses jsonPath, which is a period-separated string that describes a "path" between the entity being processed and a field on it or a related entity.
  • In essence, this category of rules understands how to generate dynamic queries. 
  • There are some helpers for traversing connection types, edges, and node fields, which will be automatically skipped, for example, `items.0.currency`  is equivalent to `items.edges.0.node.currency` 

Managing Workflow States

Essential knowledgeLearn about managing state in a workflow and the recommended best practices to follow.
  • Do not change the status of an entity until all conditions of that state have been confirmed.
  • Avoid duplicating logic within the workflow to maintain simplicity and readability.
  • Always use the SetState rule to change the state of an entity.
  • Handle all state change logic within a single execution thread where possible.
  • Utilize ruleset triggers to guard against illegal actions on states.

Workflow Framework Overview and Key Concepts

Essential knowledge.
  • .

Workflow Framework Overview

Essential knowledgeThe Workflow Engine (aka Rubix) is the engine that drives the Fluent platform. The Workflow Engine enables business process orchestration, workflow automation, and underpins the specific feature sets and functionality for each of the Fluent apps. Additionally, the Workflow Engine is built to be highly scalable, and provide high-performance workflow execution across any domain.
  • Cloud-native, high availability, scale-on-demand workflow execution.
  • Pre-built, customizable workflows delivering capabilities across each of the Fluent App domains.
  • Rich Rule Library containing reusable rules across each of the Fluent Apps.
  • Software Development Kit (SDK) and Developer Tooling, enabling the implementation of custom rules and integrations.
  • Business Tools to manage, configure, and implement workflow and process automation.

Workflow Event Execution

Essential knowledgeIn this module you'll learn about how events are executed on the Fluent platform.
  • A workflow represents the journey of a root entity, and related sub-entities, through various stages in its lifecycle.  These stages are represented by statuses.
  • Rulesets are collections of rules forming tasks within a process, dictating movement from one state to another based on business logic.
  • When an orchestration event is received, the Workflow Engine loads the associated workflow and searches for a matching ruleset based on event name, entity type, subtype, and status.  Matched rulesets are executed, and may produce additional events to trigger further rulesets in sequence.

Workflow API

Essential knowledgeA workflow defines the orchestrated business logic to be applied to an entity on a given event. A workflow consists of Workflow States and Workflow Rule Sets for an Entity. The Workflow States specify the states that the entity could be in at any given point in time. The Workflow Rule Sets specify the business rules behind the progression of these states.
  • This API method supports the creation or update of a Workflow within the Fluent Platform. 
  • This API method validates the body of the request to ensure that the structure of the Workflow is correct. 
  • Requests containing invalid Workflows will respond with an error.

Working with Workflows and Workflow Fragments

Essential knowledgeIn this document we will describe how to work with workflows and workflow fragments using the Fluent CLI. Then delve into how the tool is tracking the installed workflows, fragments in the workflow log.
  • Use the Fluent CLI command `workflowlog` to manage the workflow and fragment lifecycle
  • For background on workflows and fragments, read the page On Workflows and Workflow Fragments.

On Workflows and Workflow Fragments

Essential knowledgeWorkflows are the backbone of the Fluent platform as they describe the lifecycle of an entity. Defining subsections or sub-processes within a workflow allows to manage and evolve them independently. Thus fostering loosely coupled and self-contained fragments with no duplication of shared or unchanged behavior of a baseline workflow.On this page we will look at the different ways of structuring workflows into fragments and then how to optimally merge them into a final workflow that is used to orchestrate entities. Finally how to package both workflows and fragments into a module.
  • A Workflow defines behavior of an entity, such as order, fulfillment, or an inventory position.
  • A Workflow Fragment is a sub-process within a larger workflow, managed separately from the rest of the workflow.
  • Keeping workflow customizations in a workflow fragment and applying one or more fragments on top of a reference workflow reduces the duplication of rulesets and minimizes future maintenance.
  • At module deployment time, the Fluent CLI will combine multiple fragments into a final workflow and upload to the target retailer. More details on the CLI commands are in Working with Workflows and Fragments.
  • Asset execution order: `workflows` before `workflow-fragments`.

Retailer Settings

Essential knowledgeThis section explains the settings used in Retailer context.
  • This article lists retailer-level settings

Overview of Pick and Pack

Essential knowledgeThe Pick and Pack feature suiteof the Store Fulfilment app allows stores to pick and pack online orders that are allocated to the store based on store inventory at the time of order creation. The Fluent Store’s interface is used to access the capabilities of the Pick and Pack feature suite.
  • Adaptability: The process is responsive, ensuring a seamless experience on screens of varying sizes. Customization options are available through UI configuration or creating new components.
  • Process Stages: The wave process involves creating a wave, picking order items, packing them, and booking carriers.Prioritization logic is applied based on factors such as expiration dates, order types, or delivery types.
  • Efficient Picking: Picking orders is initiated by creating a wave, followed by selecting orders and using a user-friendly PICK component.Confirmation of picked items involves a final review, confirmation, and automatic rejection of unpicked items.
  • Completion Process: The wave-picking process leads to the completion of fulfilling online orders in-store, providing a streamlined approach to order fulfillment.

Pick, Pack, & Dispatch

Essential knowledgeOne of the main capabilities provided by Fluent Store is the capability to manage Wave creation, Pick, Pack and Dispatch operations. This article covers these notions, and provides multiple use cases in which they are used.
  • Wave creation allows the grouping of a set of fulfillments so that they can be batch-processed for Pick, Pack, and Dispatch.
  • The Pick step allows you to pick or reject items and provides a picklist that summarizes the output of the process. 
  • The Pack step links the articles and the fulfillments and provides a packing slip as a summary. 

Fluent Big Inventory Web App Overview

Essential knowledgeThe Fluent Big Inventory Web App is a powerful tool for managing products, inventory, feeds, and sources. Key features include:
  • Feeds: View inventory feed details.
  • Sources: Track inventory update integrations.
  • Products: Manage catalogs and product data.
  • Unifies View of Inventory: Gain real-time inventory insights across locations and channels for optimal stock management.
  • Inventory: Monitor allocation, Stock On-Hand (SOH), real-time updates, and buffers.
  • Stores: Oversee individual and network locations.
  • Insights: Track system events.
  • Admin: Configure user access and settings.
  • The Fluent Big Inventory Web App offers a comprehensive suite of functionality.
  • With dedicated interfaces for Sources, Products, Inventory, Stores, Insights, and Admin, the web-based interface provides users with a holistic toolset, allowing them to observe and track integrated sources, manage product catalogues, exercise precise control over inventory, oversee individual and networked store locations, monitor system events comprehensively, and efficiently administer the entire inventory availability system for a seamless and valuable user experience.

Unified View of Inventory Interface

Essential knowledgeThe Unified View of Inventory (UVOI) interface consolidates data from multiple locations and channels into a single, real-time interface. It provides centralized inventory search, advanced filtering, and customizable views. It enables you to monitor, analyze, and act on inventory data.
  • Centralized Inventory Management: The Unified View of Inventory (UVOI) consolidates data from multiple locations and channels into a single, real-time interface, simplifying inventory management and improving decision-making.
  • Advanced Filtering Capabilities: UVOI offers flexible filters for refining search results, including catalog, stock status, on-hand quantities, and product or location-specific criteria.
  • Comprehensive and Customizable Views: The Inventory Search page provides a detailed overview of inventory, with drill-down capabilities for stock levels, available-to-sell quantities, and update histories. Users can navigate to location-specific or product-specific views and customize filters and criteria to tailor the experience to their operational needs.

Inventory Batch Pre-Processing

Essential knowledgeThis page describes how Inventory Batch Pre-Processing (BPP) works, the opportunities available for configuration, and the implementation improvements enabled by using Inventory Batch Pre-Processing.
  • Inventory Batch Pre-Processing optimises the performance of inventory ingestion using Inventory Batches
  • This optimization can reduce the processing time for Inventory Batches, depending on the volume and data redundancy ratio.
  • Inventory Batch Pre-Processing can be enabled per Account and Retailer as needed

Inventory Interface

Essential knowledgeThe Inventory interface of the Fluent Web app provides comprehensive inventory management capabilities:
  • Inventory visibility
  • Inventory allocation
  • The total quantity of stock for a specific item (stock on hand(SOH)) and the status of that inventory
  • Available to promise inventory levels
  • Inventory buffers to reduce overselling of products
  • The Fluent Web app's Inventory interface offers a comprehensive suite of capabilities, including inventory visibility, allocation, total stock quantity (stock on hand), inventory status, available-to-promise levels, and strategically implemented buffers to prevent product overselling.
  • The interface is equipped with various configurations, such as Inventory Catalogues, Control Groups, Virtual Catalogues, Cross-Catalogue Views, and Location Inventory Views, providing users with versatile tools to tailor their inventory management approach according to specific business needs and scenarios.

Getting Started Configuring Fluent Store

Essential knowledgeThe Fluent Store web app is a preconfigured baseline web app which can be used as a starting point for your projects.The default UX templates are hosted on the platform, so there is no need to create the manifest settings yourself, unless you need to customize the existing baseline configuration.
  • Instructions on how to override the default manifest document
  • Details on where to find baseline manifests and configuration guides
  • Recommendations for text editors to use when editing manifest documents
  • Guidance on saving manifest documents to your account
  • Information on adding new fragments to your web app

Fulfilment Options Page

Essential knowledge
  • Fulfilment Options page
  • Further Reading
  • Fulfilment Options page
  • Further Reading

Collections

Essential knowledgeCollections configuration contains:
  • Collections List page
  • Article Details page
  • Collections List page
  • Article Details page

Waves

Essential knowledgeWaves configuration contains:
  • Waves List page
  • Wave Details page
  • Waves List page
  • Wave Details page

Pick by Expiry Template

Essential knowledgeThe Pick by Expiry Template is a preconfigured UX Template used within the Fluent Store Web App.
  • Key Features on how to configure the Pick Screen
  • Lis of common Use Cases
  • Template Configuration details

Understanding Dispatch Process

Essential knowledgeThis topic explains the dispatch process for Home Delivery (HD) and Click and Collect (CC) fulfilments using the ServicePoint console.
  • Customer Collections

Pack for Multi-Parcel Shipments

Essential knowledgeThe Pack feature of the Fluent Store empowers Store Associates to efficiently manage the packing process for multi-parcel shipments. It allows them to allocate items to specific parcels, add new parcels as needed, set parcel dimensions and weight, remove parcels, and reject items that don't meet requirements. This feature ensures that each parcel is properly organized and labeled, giving Store Associates complete control over the packing process.
  • Store Associates can choose which fulfillment to pack next, optimizing the packing process based on operational needs.
  • Fulfillments are organized into two tabs—Awaiting Pack and Packed Fulfillments—providing a clear overview of the packing stages.
  • A badge displays the number of fulfillments awaiting packing, helping Associates manage their tasks efficiently.
  • Store Associates can allocate items to specific parcels, add or remove parcels, set dimensions and weight, and reject items.
  • The integrated barcode scanner speeds up the packing process by quickly and accurately identifying parcels and items.

Wave Dashboard Template

Essential knowledgeThe Wave Dashboard Template is a preconfigured UX Template used within the Fluent Store Web App.
  • Provides an overview of Store Waves, including orders awaiting pick, in-progress orders, and completed waves.
  • Configurable dashboard tiles and tabs for real-time store performance and bottleneck visibility.
  • Supports configuring Pick & Pack SLAs, collection reminders, and exception management.

Uncollected Articles

Essential knowledgeThe UNCOLLECTED Articles feature of the Fluent Store module provides a capability for the retailers to set a collection SLA for the customers.
  • This feature enables the retailers to set clear in-store processes and drive positive customer experience for the click-and-collect orders, in the scenarios where the customer fails to pick up the order.
  • This also then enables the retailers to reuse the inventory after a certain period of time rather than waiting for the customer for longer periods.
  • Having this extra tab of Uncollected articles in Fluent Store, allows the store users to differentiate between the articles awaiting collection for a longer time, and enables the store associate to help out the customers in case they fail to pick up in-store, which in turn drives positive customer experience.

Customer Click and Collect Journey

Essential knowledgeFluent supports various fulfillment options like Click and Collect, Ship-from-Store, and Ship-from-Warehouse. The process involves checking inventory, reserving stock, and notifying relevant parties at each stage. Orders are managed through the Fluent platform, allowing customers to collect from stores or receive deliveries at home, with real-time updates on order status.
  • Click and Collect: Customers order online, collect from selected stores.
  • Inventory Check: Verifies stock availability before fulfillment.
  • Store Fulfillment: Store staff pick, pack, and notify customers for collection.
  • Ship-from-Store: Orders shipped from stores with integrated courier booking.
  • Warehouse Fulfillment: Uses webhook communication for real-time updates.
  • Order Status Updates: Real-time tracking through Fluent workflows.

Carrier Collections

Essential knowledgeThis article covers how articles are marked as Collected in the Fluent Store app. 
  •  Fluent Store covers customer and carrier collections. When the OMS user needs to take action, a notification will pop up in the Store app menu. 
  • Upon taking action, the article status will be updated. Subsequently, depending on how the order workflow is set up, the fulfillment and order status entities might also be updated. 

How to enable Returns in Fluent OMS and Fluent Store

Essential knowledgeThe Returns feature is available for any OMX web apps. The following guide will step through the areas of configuration to enable the Returns reference solution.
  • A step-by-step guide to enable reference return functionality.
    • Settings setup
    • Create & Assign the Instore Return Role
    • Workflow Configuration (Order, returnOrder and Billing)
    • Manifest Changes for Fluent Store and Fluent OMS

Order management - Ship from Store Customer Journey

Essential knowledgeThis topic describes an example "Ship from Store" Customer Journey
  • Items purchased online
  • Most appropriate stock to ship to customer is located in a store, based on business rules such as closest to customer address thus reducing shipping costs
  •  Items are shipped from store to customers home address

Introduction to Store Fulfillment

Essential knowledgeThis course covers the basics of the Store module, helping you get acquainted with essential terminology and offering an overview of its high-level implementation in Fluent OMS.
  • Fluent Store is a Fluent web app responsible for managing all store operations.
  • Fluent Store's reference features include pick/pack/dispatch, managing arrivals, and customer collection operations.
  • In addition to the reference features, Fluent Store can be customized via Software Development Kits.

Fluent Store Dispatch Template

Essential knowledgeThe Dispatch Template is a preconfigured UX Template used within the Fluent Store Web App.
  • Pack and Dispatch Orders: This template facilitates the packing of items into boxes or satchels and allows for printing of packing slips and carrier labels.
  • Multiple Order Types: It supports packing for various order types including Home Delivery, Click & Collect, and Store Transfers.
  • Configurable Workflow: The template relies on the Location Store Workflow with a Wave Dispatch User Action to streamline the dispatch process.
  • Wizard Page Integration: Utilizes the fc.page.wizard component from the Component Library for step-by-step guidance through the packing process.

Store Arrivals

Essential knowledgeThis article covers how Store arrivals are handled in Fluent OMS.
  • When the article arrives at the store, a notification appears in the menu to alert the store associate.
  • When the article is marked as arrived, the article status is updated subsequently. 

Store Interface

Essential knowledgeThe Store interface empowers retailers to enhance their operational efficiency by transforming stores into fulfillment centers and optimizing inventory management. This ultimately delivers a superior customer experience through streamlined order fulfillment and improved inventory control. The app contains the following configurations:
  • All Locations
  • Stores
  • Warehouses
  • Networks
  • Stores are transformed into efficient fulfillment centers, ensuring a seamless customer experience through optimized order fulfillment and superior inventory control.
  • With configurations for all Locations, Stores, Warehouses, and Networks, the app provides a comprehensive toolkit, enabling retailers to manage their entire ecosystem.

Location - Stores

Essential knowledgeStores configuration contains:
  • Stores page
  • Store Details page
  • Location Ref
  • Created On
  • Updated On
  • Stores page
  • Store Details page
  • Location Ref
  • Created On
  • Updated On

Deploy your Rule

Essential knowledgeIn this lesson, you will learn how to deploy and run a custom rule.
  •  Access to Fluent Training account is required

Order Management Interface

Essential knowledgeThe Order Management interface is the central workspace for managing the order lifecycle. It brings together orders, customers, billing accounts, returns, and escalated fulfilments in one view. Orders provide access to details and fulfilments. Customers show records including accounts and order history. Billing Accounts manage financial operations such as invoices, memos, and payments. Returns track customer or system-initiated cases with refund details. Escalated Fulfilments highlight exceptions requiring action.
  • The Order Management interface brings together orders, customers, billing accounts, returns, and escalated fulfilments in one place.
  • It enables visibility and control over the entire order lifecycle, from creation through fulfilment, return, or escalation.

Availability Interface

Essential knowledgeThe Availability interface provides visibility into fulfilment options generated by the system when evaluating how an order can be completed. Availability ensures that orders are processed in line with business rules, inventory availability, and delivery or collection methods.The interface contains one submenu: Fulfilment Options. This section provides access to all generated fulfilment options and their related fulfilment plans.
  • The Availability interface contains one submenu: Fulfilment Options.
  • Fulfilment Options represent possible ways to complete an order, while Fulfilment Plans define the strategy behind each option.
  • Together, these views provide oversight of how orders are fulfilled according to rules and inventory.

Test Utilities Overview

Essential knowledgeThe `util-test` library is a comprehensive collection of utility functions, mock objects, and executors designed to minimize the overhead and complexity of testing your Fluent Commerce rules.PrerequisitesThese articles assumes you're familiar with:
  • Java
  • Maven
  • JUnit
  • `RuleExecutor`: The primary tool for unit testing a single rule in isolation.
  • `WorkflowExecutor`: An advanced executor for integration testing an entire workflow from a JSON definition.
  • `RuleContextGenerator`: The underlying builder for creating the mock `Context`, allowing you to define the event, entity, properties, and mock API responses for your test.
  • `MockApiClient`: A critical component for providing predefined GraphQL responses, enabling you to test how your rule handles different API outcomes without making live calls.
  • `TestActions`: A helper object that captures all actions your rule performs and provides fluent assertions (e.g., `sendEvent().assertCount(1)`) to easily verify the results.

Product Description - Fluent Commerce OMS [Superseded - Document Version 1.0]

Essential knowledgeFluent Order Management components are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure. These components operate within the framework to enable the order management experience on the platform.
  • The main components that comprise the platform architecture are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure.
  • Each Module represents a particular business domain and its associated rules and workflows.  Core, Inventory, Order and fulfilment are the four Fluent modules.
  • These are the web and in-store interfaces used to access module functionality.

Insights

Essential knowledgeThe Insights interface is a comprehensive repository of system Events, representing occurrences or triggers within the Fluent Platform. These Events, like changes in inventory position or entity states, act as notifications, prompting specific workflows and providing a dynamic overview accessible through a user-friendly configuration featuring the Events Search Form, the Events Search Results, and the Event Details Drawer for efficient information retrieval.
  • The Insights interface is a comprehensive repository providing full information about system Events, representing occurrences and triggers that prompt actions or log activities within the Fluent Platform.
  • With a user-friendly configuration, the module enables efficient interaction through the Events Search Form, providing filtered event searches and responsive Events Search Results. The Event Details Drawer ensures users can seamlessly access detailed event information without losing search results or experiencing delays in page navigation.

Feeds Interface

Essential knowledgeThe Feeds interface provides visibility into inventory feeds for an account, enabling monitoring and analysis of feed activity over selected time periods.It includes:
  • Feeds Dashboard—This dashboard displays general information about inventory feeds within the selected time frame (default: last 30 minutes, 1 hour, 8 hours, 24 hours). Learn how to configure custom periods in this guide. The dashboard consists of:
    • Overview: Summarizes overall feed status and key metrics.
    • Feeds: Lists individual feed details for deeper insight.
  • You should know about Inventory Feeds.
  • The Feeds Dashboard offers a comprehensive overview of inventory feeds. It presents general information for selected periods and provides users with insights into their account's feed activities.

Sources Interface

Essential knowledgeThe Sources interface provides inventory and batch-processing metrics visibility, enabling data ingestion and processing efficiency tracking. It includes:
  • Sources Dashboard – Monitors inventory updates, failure rates, and processing times.
  • BPP Metrics Dashboard – Tracks batch-processing efficiency, showing processed, changed, and unchanged records with a date range filter of up to 31 days.
Both dashboards use structured data, support trend analysis within configurable time frames, and require METRICS_VIEW permission for access.
  • Sources Dashboard provides real-time tracking of failed updates, update frequency, total received updates, and estimated processing times.
  • BPP Metrics Dashboard enhances visibility into batch data ingestion by tracking record modifications.

Products Interface

Essential knowledgeThe Products interface is a collection of products and any attributes and details associated with each product in the category.The Products interface of the Fluent Web App provides comprehensive capabilities:
  • Product Catalog management
  • Standard and Variant Product management
  • Category management
The module contains the following configurations:
  • Categories
  • Product Catalogues
  • The Products interface is a centralized hub for managing a collection of products, encompassing all associated attributes and details, offering a holistic approach to product management.
  • It focuses on Product Catalog management, Standard Product management, and Category management. It empowers users to efficiently organize and oversee their product-related information, providing a seamless and comprehensive solution.
  • The interface offers specific configurations for managing Categories and Product Catalogs, ensuring a tailored and effective product categorization and cataloging approach.

JSON Utilities

Essential knowledgeThe `JsonUtils` class in the `util-core` bundle provides a foundational set of helper methods for working with JSON data. Built on top of the Jackson library, these utilities simplify the conversion of raw JSON into usable Plain Old Java Objects (POJOs) and vice-versa.JSON is a common data format found in event attributes, entity attributes, and setting values, and these utilities are essential for effective rule development.
  • Universal Conversion (`anyToPojo`):This method can convert almost any Java object (especially `Map`s from event attributes) into a strongly-typed POJO, making the code safer and easier to read.
  • POJO to Map (`pojoToMap`): The reverse of `anyToPojo`. This is essential for when it is necessary to need to add a complex object as an attribute to a new event.
  • String to POJO (`stringToPojo`): Directly converts a raw JSON string into a typed POJO, which is useful when dealing with data from external systems or settings.
  • Built on Jackson: The utilities are built on the Jackson library.

Dynamic Mutations

Essential knowledge`DynamicUpdateMutation` automatically derives the correct update Mutation for the primary Entity based on the `RulesetContext` and then performs the update on one or more fields.
  • Automatic Mutation Selection: GraphQL mutations are automatically selected from the `RulesetContext` based on entity type.
  • Flexible Field Updates: Update single fields or multiple fields in bulk using simple key-value pairs.
  • Type-Based Safety: Use POJO classes for strongly-typed updates with automatic field derivation.
  • Runtime Validation: Built-in validation ensures only valid fields are included in mutations.
  • Universal Application: Works across different entity types without requiring entity-specific mutation code.

Log Utilities

Essential knowledgeThe `LogUtils` class in the `util-core` bundle provides structured logging helpers that remove boilerplate code when using logging actions within your rules. These utilities make it easy to record key actions, errors, and checkpoints to the event log for debugging and auditing purposes.
  • Standardized Logging: The utilities provide a standard, structured format for log messages, making the event log easier to read and search.
  • Automatic Titling: The log entry's title is automatically generated from the rule's class name, ensuring consistency and saving you from writing boilerplate code.
  • Simple Checkpoints: `logOnce` is an easy way to record a specific outcome or checkpoint in your rule's execution with a formatted message.
  • Collections: `logAttributeCollection` is a convenient helper for logging a list of attributes.

Setting Utilities

Essential knowledgeThe `SettingUtils` class in the `util-core` bundle provides a robust set of tools for retrieving configuration settings from the Fluent Commerce API. A key feature of this utility is that it automatically respects the platform's setting hierarchy, ensuring that the most specific setting value is always returned.
  • Automatic Hierarchy: `SettingUtils` automatically respects the Fluent Commerce setting hierarchy (Location > Retailer > Account > Global), so you always get the most specific value without any extra work.
  • Type-Safe Conversion: The `.as(MyClass.class)` method allows you to convert a setting's value to any type—from simple primitives (`String`, `Integer`) to complex POJOs—in a single, null-safe operation.
  • Efficient Bulk Fetching: You can retrieve multiple settings (`getSettings`) or a group of settings by a common prefix (`getSettingsByNamespace`) in a single API call, which is more performant than fetching them one by one.

Query Utilities

Essential knowledgeThe `QueryUtils` class in the `util-core` bundle offers a set of functions to simplify GraphQL queries from within your Rules. These helpers make it easier to work with query results and handle common data structures like paginated connections.
  • Type-Safe Queries: The `query` method is a wrapper that eliminates the need to manually cast GraphQL responses to the correct type, making your code cleaner and safer.
  • Simplified Connections: `connectionToList` is a powerful helper that converts a standard GraphQL "connection" (with its `edges` and `nodes`) into a simple `List` of objects, removing a significant amount of boilerplate code.
  • Inline Transformation: `connectionToList` can also accept a function, allowing you to transform the list of GraphQL nodes into a list of your own domain objects (POJOs) in a single operation.

Rule Utilities

Essential knowledgeThe `RuleUtils` class in the `util-core` bundle provides helper methods to streamline the process of retrieving and validating Rule properties. Using these utilities helps ensure that your Rules are configured correctly and reduces the risk of runtime errors caused by missing or invalid parameters.
  • Flexible List Properties: `rulePropAsList` reliably parses a rule property into a `List`, whether it's configured as a comma-separated string or a JSON array. This is ideal for properties that require multiple values.
  • Configuration Validation: `validateRulePropsIsNotEmpty` provides a simple, one-line way to ensure that all required properties have been provided to a rule, preventing runtime errors.
  • Fail-Fast Errors: When validation fails, the utility throws a `PropertyNotFoundException` with a clear error message. This stops the rule from executing with an invalid configuration and makes debugging easier.

Event Utilities

Essential knowledgeThe `EventUtils` class in the `util-core` bundle provides a set of essential helper methods to simplify event creation, modification, and forwarding. Using these utilities helps to eliminate boilerplate code and prevent common errors, such as forgetting to copy event attributes or improperly handling event schedules.
  • Safe Event Handling: The utilities eliminate common errors by automatically handling attribute copying and schedule management when cloning or forwarding events.
  • Immutability: `Event` objects are immutable. `EventUtils` methods always return a new event instance when a modification is made.
  • Simplified Forwarding: Provides simple, one-line methods for common forwarding patterns, like cloning and sending an event immediately (`forwardInboundEventWithNewName`) or adding attributes (`forwardInlineEventWithAttributes`).
  • Type-Safe Attribute Access: Use `getEventAttributeAs` to retrieve and convert an event attribute to a specific type (including complex POJOs) in a single, null-safe operation.

Core Utilities Overview

Essential knowledgeThe Core Utility (`util-core`) is a standard library of utility functions designed to simplify and accelerate Rule development on the Fluent Commerce platform. It provides a foundational set of helper classes that address common development challenges - such as safely handling event attributes, retrieving and converting settings, logging consistently, and minimizing boilerplate code when forwarding events or querying data.PrerequisitesThese articles assumes you're familiar with:
  • Java
  • Maven
  • JUnit
  • Event Management (`EventUtils`): Simplifies creating and forwarding events, ensuring attributes are copied correctly.
  • Rule Properties (`RuleUtils`): Streamlines retrieving and validating rule properties to avoid configuration errors.
  • Query Simplification (`QueryUtils`): Eases the execution of GraphQL queries, especially for paginated data.
  • Settings Management (`SettingUtils`) : Simplifies retrieving settings and automatically converts them from JSON to POJOs.
  • Logging (`LogUtils`): Provides structured logging for easier debugging and auditing.
  • JSON Handling (`JsonUtils`): Offers helpers for JSON serialization, deserialization, and comparison.
  • Date Formatting (`GqlDateUtils`): A simple utility for handling GraphQL-compatible dates.

Rulesets

Essential knowledgeRulesets are fundamental components in implementing business flows. They are reusable collections of rules that contain orchestration logic. These functions can be applied across various workflows and use cases, providing flexibility and efficiency. The Order, Inventory, and Fulfilment reference modules contain a set of pre-defined rulesets, each with its corresponding rules.
  • Rulesets are a collection of rules.
  • Rulesets are functions that can be used in multiple places for different use cases.
  • There are four possible Actions available to your rules: SendEventAction, WebhookAction, MutateAction, and LogAction.
  • The Core module contains rules that are common to all reference modules.

Composing Workflows

Essential knowledgeIn this section you will learn all about rules, including:
  • Typical functions of a rule
  • How to use them in workflow
  • Rule design best practices and recommendations
  • Rules are the building blocks of Rulesets.  They should be small, isolated, single-purpose, reusable, and composable.
  • Rulesets are composed of multiple rules to perform specific tasks.
  • Each rule within a Ruleset is executed in sequence.
  • A rule consists of a condition and an outcome (action).
  • Meaningful, descriptive names for Rulesets enhance workflow understanding and ease of troubleshooting.
  • Rulesets can perform functions like logical gates, state management, and notifying other domains.

GraphQL Date Utilities

Essential knowledgeThe `GqlDateUtils` class in the `util-core` bundle provides a simple and effective set of functions for handling the specific date format required by the Fluent Commerce GraphQL API. The platform uses the ISO 8601 format (`yyyy-MM-dd'T'HH:mm:ss.SSS'Z'`), and this utility ensures you can easily parse and format dates to be compatible.
  • GraphQL Compatibility: This utility ensures that dates are always in the precise ISO 8601 string format required by the Fluent Commerce GraphQL API (`yyyy-MM-dd'T'HH:mm:ss.SSS'Z'`).
  • Parsing (`parseGqlDate`): Safely parses a string from an event or external system into a standard Java `Date` object, preventing common parsing errors.
  • Formatting (`toGqlDate`): Converts a Java `Date` object into the specific string format required when passing dates as variables in GraphQL queries or mutations.
  • Centralized Logic: Centralizes date handling to avoid bugs and ensure consistency across your entire implementation.

Rule Development Guidelines & Recommended Practices

Essential knowledgeThis document provides comprehensive guidelines and best practices for custom rule development on the Fluent Commerce platform. Following these guidelines ensures your Rules are maintainable, testable, and follow platform conventions.It is highly recommended that you first read Designing Rules and Writing Custom Rules if you have not done so already.
  • This document will cover the following topics:
    • Best Practices
    • Rule Naming Conventions
    • Rule Descriptions
    • Rule Parameters
    • Exception Handling
    • Logging & Audit Events
    • Utilities Bundles
    • Constants
    • Documentation
    • Additional Best Practices

MockApiClient

Essential knowledgeThe `MockApiClient` is a critical component of the `util-test` library. It provides a mock implementation of the `ApiClient`, which is the interface Rules use to communicate with the Fluent Commerce GraphQL API.By using the `MockApiClient`, you can test how your Rule behaves with different API responses without making any actual network calls. This isolates your tests, makes them faster, and allows you to simulate any scenario, including errors or empty data results.
  • Test API Interactions: The `MockApiClient` allows you to test how your rule responds to different API outcomes (e.g., success, failure, empty data) without making live network calls.
  • Isolate and Speed Up Tests: By mocking the API, your tests run faster and are isolated from network or environment issues.
  • Executor Integration: You typically don't use `MockApiClient` directly. You use the helper methods on `RuleExecutor` and `WorkflowExecutor` (like `.mockQuery()` and `.mockSetting()`) to configure it.
  • Full Coverage: It supports mocking pre-compiled queries/mutations, dynamic queries/mutations, and settings, giving you complete control over your test environment.

Dynamic Pagination

Essential knowledge`DynamicConnectionQuery` automatically derives the Connection fields (arrays) for the primary Entity based on the `RulesetContext` and can dynamically load all connection items, with pagination handled internally.
  • Automatic Pagination: `DynamicUtils.queryList` completely automates fetching paginated data from a GraphQL connection. You get a simple `Iterable`, and the library handles fetching subsequent pages in the background as you iterate.
  • Lazy Loading: The utility is highly efficient because it uses a "lazy loading" approach. It only fetches the next page of data when you have iterated through the current one.
  • POJO-Driven: You define the data you need by creating a simple POJO class. The utility dynamically builds the GraphQL query to fetch only the fields defined in your POJO.
  • Server-Side Filtering: You can pass a `Map` of parameters to `queryList` to filter the connection on the server. This is much more efficient than fetching all the data and filtering it in your rule.

UX Framework - Component Library

Essential knowledgeThe OMX UX Component Library contains a suite of UI Components, ready to be configured and used in Fluent Web Apps.  The Library contains Foundation, Content, Layout,  Interaction and Field Components.
  • Foundation Components, such as Page Components which form the base of a screen
  • Content Components for displaying data and media
  • Layout Components for structuring pages
  • Interaction Components for capturing user input, and 
  • Field Components which are automatically rendered in User Action forms.

Workflow Fragments FAQ

Essential knowledgeFrequently asked questions around composing a workflow from workflow fragments.
  • A collection of frequently asked questions and answers
  • Elaborate on topics that do not neatly fit into the either the reference or long-form how-to's

Fluent Platform Integrations and Connections

Essential knowledgeFluent platform functionalities are designed to be flexible by integrating with other APIs and Connectors and provides a real time view of the Inventory to the sales channels, enables integration with Warehouse Management Systems (WMS), carrier services, ERPs, etc.
  • Some common interfaces, and the information shared between these interfaces and the Fluent Platform
  • GraphQL, and understand its benefits over REST APIs.
  • Events API, Inventory Batches, Webhooks, and Connectors

Working with Rulesets

Essential knowledgeIn this section you will learn all about Rulesets and how they can be configured using the Workflow Builder.
  • Rulesets define the rules that are executed when an Event matching the ruleset trigger criteria is received by the Workflow Engine.
  • Rulesets can be added and edited via the Workflow Builder.
  • Each Ruleset has a name, applicable trigger statuses, and list of rules or user actions.
  • Triggers define when a Ruleset is valid to be executed for a given entity.
  • It's possible to configure User Actions to appear in the Fluent Web Apps, which trigger business logic as defined in the corresponding Ruleset configuration.

Product Management

Essential knowledgeProduct Master in Fluent OMS is defined in this hierarchy:
  • Categories
  • Standard Product
  • Variant Product
The UPSERT_PRODUCT event will help the user to manage the product-related entities in the OMS.

  • Standard Product Management outlines the features that are available in the reference workflows to manage any Standard Products within a Product Catalogue.
  • When a Standard Product is updated there is a step specifically that will update the categories associated with that Standard Product. This is in the same flow as the Update Product, however, there is a distinct step in the flow where the category associations are updated.
  • When a Variant Product payload is sent into the Product Catalogue via a UPSERT_PRODUCT event, the workflow will identify whether that Product exists or not and create a new Product if the given Product doesn't exist.

Test your Rule

Essential knowledgeIn this module, you will learn about Unit Testing and creating a Mocked Unit test for a custom Rule.  You will also learn how to perform testing on the TestExecutor and finally deploy your plugin into your sandbox environment
  • Unit Testing
  • PowerMock
  • TestExecutor
  • Testing on Sandbox

Packing List Generation Logic

Essential knowledgeThe values on the packing list.
  • List of values on the packing list 

Languages and Localisation

Essential knowledgeAs a part of Internationalisation, the Fluent platform supports multiple languages. This support allows users of web apps such as OMS Webapp and Fluent Store to configure and view the modules and interfaces of the Fluent platform in their preferred language.As of the Fluent v4.45 release, the Fluent platform provides pre-configured support for the following languages.Fluent Order Management uses a default language of Australian English `en-AU`.
  • Australian English `en-AU` - Default
  • American English - `en-US`
  • French - `fr-FR`
  • Mexican Spanish - `es-MX`
  • Italian - `it-IT`
  • Enable additional language in OMS
  • Additional language Support - Beta
  • Custom Language Bundles
  • Language Preferences for User Accounts
  • Customizing Languages and Key
  • Customizing Workflow User Actions
  • Adding new Mutation Actions
  • Priority and Fall Back Options of Internationalization
  • Limitations

Master Buffer: Strategic Adjustment of Available-to-Sell (ATS) Quantity

Essential knowledgeUnderstand the Master Buffer: a tool for final Available-to-Sell (ATS) quantity adjustments. This guide covers its function, configuration, and strategic applications. Using it offers precise, SKU-level ATS control, helping optimize stock, support promotions, prevent over/underselling, and align inventory with business goals.
  • Key Points:
    • Final SKU-level ± adjustment applied after all quantity buffers to the aggregated SOH.
    • Directly modifies ATS; negative calculated ATS becomes zero.
    • Intended for strategic, deliberate application.
  • Concluding ATS modifier: Applies a direct SKU-level override after all quantity buffers, just before ATS is calculated.
  • Strategic & Product-Specific: Use it for deliberate, product-level inventory goals (like promotions or managing supply risks), not for general, location-based stock on hand buffering.
  • Direct Impact on Sales: A positive buffer value increases ATS; a negative value decreases it. A resultant negative ATS will always be floored to zero.
  • Use Deliberately & Review: Due to its significant impact, apply the Master Buffer thoughtfully. Document the rationale and regularly review its necessity.

Setting Schema

Essential knowledgeThe Setting Schema is a JSON schema used by the Settings Component to provide metadata for a setting, helping to define its structure. This schema primarily describes the fields that the component will render, allowing for a no-code configuration experience within the Fluent platform.
  • The Setting Schema is defined using JSON schema standards.
  • It describes the structure of a setting rather than validating the content of a JSON file.
  • Only a subset of JSON schema keywords is utilized to define the structure.

Pack Template

Essential knowledgeThe Pack Template is a preconfigured UX Template used within the Fluent Store Web App
  • Ensure Wave Dispatch User Action is configured in the Location Store Workflow.
  • Utilize Wizard Page components from the Component Library.
  • Activate Pack screen when Wave is in PACK state.

Webhooks

Essential knowledgeFluent Commerce can post standard webhooks to a configured endpoint so that the third-party system can be notified or react to the provided event. For example, common webhook scenarios include order status updates and shipping notifications.
  • A webhook is a way for Orchestrated Workflow Logic to call back to an external application.
  • Fluent Commerce provides some standard webhooks as Rules within the Rule Library for common third-party integrations.
  • Since the payload and HTTP request cannot be customised, it is rarely necessary to implement a custom rule to send a webhook

UX Configuration - Deprecated (v1) - Overview

Essential knowledgeMystique customizes the Fluent Admin Console UI, offering businesses development-free control over data presentation and business rules. This empowers them to configure user-centric functions for optimal value. A best-practice template is included. Mystique optimizes existing modules and enables new module creation based on entity perspectives. Please take a look at how it works below for configuration details.
  • Features
  • Benefits
  • How it Works

Order Orchestration Labs

Essential knowledgeThe lab covers creating and managing different order types in Fluent OMS, simulating warehouse and store interactions, and enabling user actions for order cancellation. It focuses on Home Delivery (HD), Click and Collect (CC), split fulfilment, and enhancing workflows with user-configured actions. This lab guide users through hands-on exercises using Postman and the Fluent OMS interface.
  • HD Workflow (Home Delivery): Process and fulfill home delivery orders via a warehouse.
  • CC Workflow (Click and Collect): Understand click and collect orders and simulate stock management and pickup.
  • Split Fulfillment: Explore multi-shipment scenarios when stock is insufficient at one location.
  • Order Cancellation: Configure user actions for order cancellation with reasons before fulfillment starts.
  • Postman Integration: Use Postman to authenticate, create orders, and simulate fulfillment steps.
  • Workflow Customization: Enhance order workflows by adding business rules and user actions.

Extending the UX Framework with the Component SDK

Essential knowledgeThis lesson introduces the Component SDK, a powerful toolkit for extending the UX Framework Component Library. We'll explore the core concepts behind the SDK, covering its purpose, capabilities, and benefits. By the end of this lesson, you'll understand how the Component SDK empowers developers to create custom, OMX-ready components for Fluent Web Apps, streamlining development and ensuring consistent user experiences.
  • What is the Component SDK? A development kit for building custom components for the UX Framework Component Library using modern, developer-friendly tools like React and TypeScript.
  • What can be extended? Developers can create a wide range of components, including content, layout/page, interaction, form field components, and template helpers, significantly expanding the functionality of the standard library.
  • Why use the Component SDK? The SDK simplifies custom component creation by handling complex tasks like manifest configuration, authorization, data access, localization, and workflow interaction, allowing developers to focus on component logic and design. It also leverages the Fluent OMX Design System (based on Material-UI) for consistent and high-quality UX.

Integrate and Connect Labs

Essential knowledgeThe labs in this article will walk you through the following scenarios: GraphQL Introspection and Sending a Webhook
  • Postman Configuration for auto-complete
  • Access to mockable.io

Order Management Overview

Essential knowledgeWhat is Fluent Order Management?'Fluent Order Management', also referred to as the 'Fluent Platform', is the core product of 'Fluent Commerce'.
  • The main components that comprise the platform architecture are:
    • Webapps and Modules
    • Order management Experience (OMX)
    • Orchestration Engine and Cloud Infrastructure
  • Together, they enable faster implementation, decrease development costs, and adapt quickly to ongoing changes.

Getting Started Configuring Fluent OMS (webapps)

Essential knowledgeThe Fluent OMS module is pre-configured with certain standard functions that allow the interface to manage orders, product availability, inventory, and order fulfilment and serve as a starting point for your projects.The default UX templates are hosted on the platform, so there is no need to create the manifest settings yourself unless you need to customize the existing baseline configuration.
  • You can access the baseline Fluent OMS here (with your existing retailer login used in the Webapps OMS): `https://<ACCOUNT_ID>.<ENVIRONMENT>.apps.fluentcommerce.com/oms`
  • The baseline manifest fragments will be loaded unless the UX framework finds any manifests previously configured in the Account settings.
  • Modify the baseline Fluent OMS manifest by adding your own manifest to the Account Settings or add a completely new fragment by adding a new reference route to the manifest setting.
  • Manifest documents are stored as a JSON Setting in the Account context.
  • Edit manifest documents either manually via the Admin Console or the GraphQL Settings API.

Setting up the Manifest Document

Essential knowledgeThis lesson introduces the Manifest document, a crucial component in defining the structure and layout of Fluent Web Apps. We'll cover how to set up your development environment with a pre-configured VS Code workspace, understand the key elements of a Manifest document, and learn how to create a new web app by defining an account-level setting. We'll also explore the different types of routes used in Manifests and walk through creating a simple page route. This setup and introduction will prepare you for more advanced Manifest configurations in later lessons.
  • VS Code Setup: Use the provided VS Code workspace for Manifest editing.
  • Manifest Definition: The Manifest defines a Fluent Web App's structure, layout, navigation, and data.
  • Account Setting: Manifests are stored as account-level settings.
  • Web App Access: Web apps are accessed via URLs based on the Manifest's appName.
  • Key Elements (Name, Title, Context, Routes): Manifests define these core elements.
  • Route Types: Page, Section, and Reference routes define navigation within the app.

Introduction to Setup and Configuration

Essential knowledgeThis section covers the scope of the Setup and Configuration course and the required prerequisites 
  • Access to Fluent training account
  • Basic understanding of Postman tool

UX Framework - Configuration Guide

Essential knowledgeThe OMX UX Framework delivers configuration-based solution implementation for UIs (Web Apps). Configuration is managed in a JSON document called the OMX Web App Manifest.
  • The OMX Web App Manifest document is essential for configuring Fluent Platform web apps and is stored in a setting following the convention "fc.mystique.manifest.<appname>". For instance, Fluent Commerce UIs have settings like "fc.mystique.manifest.oms" and "fc.mystique.manifest.store." 
  • The document, configured in the ACCOUNT context, is a specific JSON structure that includes sections like App-Level Configuration, Route-Level Configuration, and Local Development Options. Each web app defined within an account has a unique URL, and the Manifest guides app development, covering aspects like navigation, screen layouts, data sources, and user actions. 
  • Manifest updates can be done through Console/settings or directly via the API, with the ability to partition the document for manageability.

Account Settings

Essential knowledgeThis article contains the list of Settings used in the context of ACCOUNT.
  • Explore the ACCOUNT Settings available

How Inventory Batch Pre-Processing works

Essential knowledgeThis document outlines the functionality of Inventory Batch Pre-Processing, offering insights into how unchanged records are filtered during the inventory ingestion process using Inventory Batches.
  • Efficient Processing: Inventory Batch Pre-Processing handles batch inventory updates before they reach the inventory workflows, streamlining the process.
  • Change Detection: Identifying inventory records that have changed, ensuring the workflow engine processes only necessary updates.
  • Performance Improvement: Reduces workflow engine load by filtering unchanged records, enabling faster and more efficient inventory processing.
  • Enhanced Flexibility: Supports additional fields in batch records, allowing for more precise control and management of inventory updates.

Exception Management, Debugging and Logging Events

Essential knowledgeThis section covers the Exception handling, Debugging and Logging in a Custom Rule
  • Custom Rule should be ready along with the Unit Test Cases
  • Effect of Exceptions on Event processing
  • IDE Debugging
  • Log Action

Case Scenario - Implement Fraud Check

Essential knowledgeIn this scenario we will implement a Fraud Check step in the Order Workflow
  • Prerequisites setup
  • Basics of Rule writing

Introduction to Fluent Rules

Essential knowledgeWorkflow Framework Rules are written using Java and contain a specific structure and metadata for describing and validating the Rule. In this lesson, you will learn how to write Rules by adding customised business logic. 
  • OMX Workflow -  Understand the Workflow Engine (previously 'Rubix Orchestration Engine'), Workflow Design Patterns, Workflow Builder
  • Workflow Framework - Understand the Workflow Framework, Events, and Triggers.

Plugin Structure & JS GraphQL

Essential knowledgeIn this module, you will learn about a Plugin Project structure and JS GraphQL within the Plugin Project.  You will also learn how to modify and run a JS GraphQL query.
  • Installed SDK
  • GQL Basics

Rules SDK Setup & Plugin Creation

Essential knowledgeIn this lesson, you will learn about Rules SDK, the Software Development Kit for Fluent Order Management, and the key features of the SDK.
  • Prerequisites software installation

Introduction to the Fluent OMX: Configure - UX Framework

Essential knowledgeThis module provides an introduction to the Fluent OMX UX Framework (Mystique) and its role in building user interfaces for the Fluent Platform. We'll explore the core concepts behind the framework, how it functions, and the basic structure of a Fluent Web App. This foundational knowledge will prepare you for more advanced topics in later modules.
  • UX Framework Purpose: Understand the role of the UX Framework in building UIs for the Fluent Platform.
  • Framework Functionality: Learn how the UX Framework enables UIs to respond to workflow changes.
  • Web App Structure: Grasp the basic structure of a Fluent Web App.

Manifest Creation and Customization

Essential knowledgeThis series of lessons guides you through building a feature to manage storage areas within the Fluent Store web app. We'll cover creating a new Manifest fragment, adding it to account settings, and referencing it in the main Manifest. We'll then add a List component to display storage areas, configure a data source for the list using a page query, and create a details page for individual storage areas. Finally, we'll explore working with dynamic values, including date formatting, array access, image rendering, and configuring i18n language translation.
  • Manifest Fragment Creation: Learn to create and configure a new Manifest fragment for managing storage areas.
  • Account Settings Integration: Integrate the new fragment into account settings and reference it in the main Manifest.
  • List Component Integration: Use the List Component to display storage area data.
  • Data Source Configuration: Use the `activeLocation` context to configure a page query as a data source for the List Component.
  • Details Page Creation: Create a details page for individual storage areas with a dedicated page query.
  • Dynamic Value Handling: Learn to work with dynamic values using formatters (e.g., `dateStringFormatter`), array access, attribute retrieval by name, and image rendering.
  • i18n Configuration: Configure i18n language translation keys for the web app.

Understanding Manifest Structure

Essential knowledgeThis lesson details the structure of Manifest documents, covering both main web application manifests and fragment manifests. We'll explore the required fields and optional configurations for the main manifest, including context, routes (section, page, and reference), and plugin integration. We'll also examine the simpler structure of fragment manifests and how they contribute to managing complex UI configurations.
  • Manifest Types: There are two types of Manifests: main and fragment.
  • Main Manifest Structure: Required fields include manifestVersion, name, title, context, and routes. Optional fields include homePath.
  • Context Configuration: Defines whether the app operates at a LOCATION or RETAILER level and allows role-based access control.
  • Routes (Section, Page, Reference): Routes define the navigation menu. Section routes group menu items, Page routes link to specific pages, and Reference routes include fragment manifests.
  • Fragment Manifests: Fragment manifests contain only manifestVersion and routes, allowing for modular management of large Manifest configurations.
  • Plugin Integration: The Manifest can include references to custom component plugins hosted externally.

Introduction to the Component Library

Essential knowledgeThis lesson introduces the OMX Component Library, a collection of pre-built, configurable UI components designed for use in Fluent Web Apps. Unlike standard UI components, these components are specifically built to interact natively with the Fluent Platform. We'll explore the various categories of components within the library, including Foundation, Content, Layout, Interaction, and Field Components, and understand their distinct roles in building user interfaces.
  • Fluent Platform Integration: OMX Components seamlessly integrate with the Fluent Platform.
  • Component Categories: The library includes Foundation, Content, Layout, Interaction, and Field Components, each with distinct roles.
  • Component Hierarchy: Content and Layout components are typically children of Foundation Components.
  • Mobile Responsiveness: Components should be designed with mobile responsiveness in mind.
  • Interaction Components: These enable user interaction with the application.
  • Field Components: Automatically rendered form elements, essential for complex workflow input, are not configured via the manifest.

Unit Testing Custom Components

Essential knowledgeThis lesson covers the process of unit testing custom components using the tools provided within the Component SDK: Jest and React's test renderer. We'll walk through the steps of creating mock objects for dependencies (authentication, data, attributes), arranging the test environment, acting by rendering the component with the mocks, and asserting the output using snapshot testing. This process ensures the reliability and correctness of your custom components.
  • Testing Framework: The SDK includes Jest and React's test renderer for unit testing.
  • Mock Objects: Mock objects are created for external dependencies like authentication (`useAuth`), data from the page query, and dynamic attributes from the manifest.
  • Arrange, Act, Assert: The testing process follows the standard Arrange, Act, Assert pattern.
    • Arrange: Mocks are set up and configured.
    • Act: The component is rendered with the mock data.
    • Assert: The rendered output is compared against a snapshot.
  • Snapshot Testing: Jest's snapshot feature is used to compare the component's output to a previously saved snapshot, ensuring consistency.
  • Testable Components: Unit tests help ensure the reliability and maintainability of custom components.

Fetching Data with the useQuery Hook

Essential knowledgeThis lesson focuses on fetching data within a custom form field using the `useQuery` hook. We'll move away from relying on page query data and instead directly query the Fluent GraphQL API to retrieve a list of nearby locations with product stock. This involves defining data structures for query results, storing the query in a constant, and using the `useQuery` hook to execute the query with dynamic parameters derived from the form's context and the user's context (via `useAuth`). We will then render the results in a selectable list using radio buttons.
  • Data Independence: Components should fetch their own data using the `useQuery` hook, rather than relying on potentially unavailable page query data.
  • GraphQL Query: A GraphQL query (`searchVirtualInventory`) is used to retrieve nearby locations with stock.
  • Data Structures: Interfaces (SVINode, SVIResult) are defined to structure the query results.
  • `useQuery` Hook: The `useQuery` hook is used to execute the GraphQL query with dynamic parameters.
  • Dynamic Parameters: Query parameters (`productRef`, `locationRef`, `lat`, `lng`) are derived from the form's entity context (product) and the user's context (location) using the `useAuth` hook.
  • Loading State: A loading state is implemented while the query progresses.
  • Result Rendering: The query results are initially logged to the console and then rendered as a list of selectable locations using radio buttons.
  • User Selection: A state variable and event handler are used to track the user's selected location.

Enhance Your Custom Fields: Leveraging Existing Components from the Registry

Essential knowledgeThis lesson details how to enhance custom form fields by adding structure, styling, and interactive controls. We'll focus on improving the user experience and data capture capabilities of our custom field component. This involves using Material-UI for styling, organizing the field's layout, and integrating pre-built form controls from the component library, such as the `QuantitySelector`. We'll also cover best practices like using the `useEffect` hook for debugging.
  • Structure and Layout: Learn how to structure and organize the elements within your custom form field for optimal presentation.
  • Styling with Material-UI: Use Material-UI's styling capabilities (e.g., makeStyles) to style your custom field and maintain design consistency.
  • Form Control Integration: Integrate pre-built form controls, like the QuantitySelector, to efficiently capture specific data types (e.g., integers for quantity).
  • Component Registry Retrieval: Learn how to retrieve and use existing components from the component registry (e.g., the QuantitySelector using its alias "number").
  • State Management: Manage the state of form inputs using React's state mechanisms.
  • Debugging with `useEffect`: Use the `useEffect` hook to debug and verify the behavior and output of your custom field.

Make Your Component Interactive

Essential knowledgeThis lesson focuses on adding interactivity to the map pins. Building on the previous styling enhancements, we'll use React's `useState` hook to manage the state of pin interactions, specifically clicks. This will enable us to trigger actions when a pin is clicked, making the map more dynamic and responsive.
  • React `useState` Hook: Learn how to use the `useState` hook to manage the interactive state of components, such as tracking pin clicks.
  • Pin Click Actions: This lesson demonstrates how to implement actions that occur when a pin is clicked, enabling interactive map functionality.
  • Interactive Components: This provides a practical example of making components interactive, a core concept in front-end development.

Style and Theme Your Component

Essential knowledgeThis lesson focuses on enhancing the visual representation of our map pins through styling. We'll explore how to add color to the map pins, improving their visual appeal and potentially conveying additional information. This styling process will demonstrate how to customize the look and feel of custom components.
  • Pin Styling: Learn how to style map pins, including adding color, to improve their visual presentation.
  • Visual Enhancement: Styling enhances the user experience by making the map more visually appealing and informative.
  • Custom Component Styling: This lesson provides a practical example of styling custom components, a key aspect of UI development.

Accessing Page Query Data

Essential knowledgeThis lesson focuses on retrieving data for our map visualization. We'll explore how to access data from the page query defined in the manifest document, rather than making GraphQL queries directly within the component. This approach promotes reusability and configurability. We'll specifically target retrieving a list of locations that stock a given product, a crucial step in displaying product availability on the map.
  • Data Fetching Strategy: Learn why accessing data from the page query is preferred over making direct GraphQL queries within the component.
  • Manifest-Driven Data: Understand how to define and configure data queries in the manifest, making data accessible to components.
  • Data Access: This lesson demonstrates how to retrieve the list of locations stocking the product from the page query data.
  • Product Availability: The retrieved data will be used to populate the map with markers indicating store locations and product availability.

Adding Nested (Child) Components

Essential knowledgeThis lesson combines adding map pins with the concept of nested components. Building on the Google Map integration, we'll show how to dynamically add pins (child components) to the map (parent component). This is crucial for visualizing location data and illustrates building complex, modular UIs using nested components. You'll learn how to place markers representing locations and how this parent-child relationship contributes to organized, reusable UI elements.
  • Nested Component Structure: This lesson emphasizes the use of nested components to create more organized and reusable UI elements.
  • Parent-Child Relationship: We'll explore how parent components can manage and interact with their child components, such as adding pins (child) to a map (parent).
  • Dynamic Pin Placement: This lesson focuses on adding pins to the map, enabling you to visually represent data points or locations.
  • Data Visualization: Adding pins to the map allows for the visualization of location-based data, a key aspect of many applications, including the product availability map we are building.

Integrating a Third-Party Map Component

Essential knowledgeThis lesson demonstrates how to integrate a third-party component, specifically a Google Maps React component, into your custom map card. We'll cover the installation process using Yarn and discuss best practices for selecting third-party components for use in Fluent Web Apps. We'll also explore the option of using the map in development mode without an API key.
  • Third-Party Component Integration: This lesson focuses on incorporating external libraries into your custom components, showcasing the use of a Google Maps React component for map display.
  • Best Practices: When choosing third-party components, prioritize React-based libraries and those compatible with Material UI to ensure seamless integration with the Fluent framework.
  • Installation with Yarn: We'll walk through the steps of installing the chosen map component using Yarn.
  • Development Mode: The lesson also covers using the map component in development mode without providing a Google Maps API key, allowing for testing and development before deploying to production.

Accessing User and Location Context with the useAuth Hook

Essential knowledgeThis lesson explores the `useAuth` hook provided by the Component SDK, which grants access to crucial information about the currently logged-in user. We'll learn how to retrieve user details, including roles/permissions and the current location/retailer context. Specifically for location-context web apps like Fluent Store, we'll focus on using this hook to access the currently selected store's information, such as longitude and latitude coordinates, which will be essential for our map implementation.
  • `useAuth` Hook Purpose: The useAuth hook provides a convenient way to access details about the authenticated user, including their roles, permissions, and current context.
  • Contextual Information: The hook provides access to the user's current location or retailer context, which is vital for location-based applications.
  • Location Coordinates: For location-context apps, useAuth allows retrieval of the selected store's coordinates (longitude and latitude), enabling map integration and location-based functionality.
  • Fluent Store Application: In the context of Fluent Store, this hook will be used to get the coordinates of the currently viewed store, providing the data needed to display the store's location on the map.

Configuring Custom Components via the Manifest

Essential knowledgeThis lesson focuses on configuring custom components using the Manifest file. We'll demonstrate how to define an interface for your component's properties, allowing it to receive data from the Manifest. Specifically, we'll show how to declare a `MapCardProps` interface with properties like `title` and `width`, and then configure these properties within the Manifest to dynamically control the component's appearance and behavior.
  • Component Properties Interface: Defining an interface (e.g., `MapCardProps`) allows you to specify the data a component can receive, ensuring type safety and clarity.
  • Manifest Configuration: The Manifest file is used to configure the properties of custom components. This allows developers to control how components are displayed and function without modifying the component's code directly.
  • Dynamic Control: By configuring properties in the Manifest, you can easily change a component's behavior or appearance without recompiling or redeploying the component. This provides flexibility and simplifies updates.

Creating and Registering a Custom Component

Essential knowledgeThis lesson demonstrates the process of creating and registering a custom component using the Component SDK. We'll walk through the steps of building a simple React Function Component, leveraging a utility component (Card) provided by the SDK. We'll then register this custom component with the Component Registry, making it available for use within our web application. Finally, we'll show how to integrate the registered component into a page by updating the application's manifest.
  • React Function Components (FCs): Fluent components are built as React Function Components, providing a familiar and efficient development model.
  • Utility Components: The Component SDK provides utility components (like a `Card`) that can be used as building blocks for custom components, simplifying development and ensuring consistency.
  • Component Registry: Custom components must be registered with the Component Registry before being used in a web app. This makes them discoverable and configurable.
  • Manifest Integration: Once registered, custom components are added to web app pages by referencing them in the application's manifest file, allowing developers to control the UI dynamically.

Building Custom Components with the Component SDK

Essential knowledgeThis lesson dives into the practical application of the Component SDK, focusing on how to build custom components for OMX Web Apps. We'll explore the different types of custom components you can create, the powerful hooks available for interacting with the Fluent platform, and the utility components that streamline development and ensure consistency. We'll also touch on the crucial concept of component registries.
  • Types of Custom Components: The Component SDK enables the creation of custom view components (for page content) and custom field components (for workflow user actions), allowing developers to tailor interfaces to specific needs.
  • Hooks for OMX Integration: Fluent-specific React hooks (e.g., `useAuth`, `useI18n`, `useQuery`) provide easy access to platform functionalities like authentication, localization, and API interaction, simplifying complex tasks.
  • Utility Components for Consistency: The SDK offers utility components (e.g., Card, Loading, Drawers) that serve as building blocks for custom components, ensuring a consistent look and feel, theme responsiveness, and mobile compatibility.
  • Component Registries: Custom components must be registered with the appropriate registry (Component, Field, or Template) before they can be used in OMX Web Apps, making them discoverable and usable within the framework.

Deploying a Custom Component Plugin

Essential knowledgeThis lesson covers the deployment process for custom component plugins. Unlike server-side plugins, component plugins are frontend JavaScript bundles that can be hosted on any web server. We'll explore the key steps involved in preparing your plugin for production, including versioning, bundling, and deployment, and how to reference the deployed plugin in the manifest document.
  • Frontend Deployment: Custom component plugins are deployed as frontend JavaScript bundles, simplifying the deployment process compared to server-side plugins.
  • Versioning: Versioning the bundle.js file (e.g., using Webpack's contenthash) is crucial for cache busting and ensuring updates are immediately reflected.
  • Bundling with Yarn: The yarn run bundle command is used to create the production-ready bundle, which is placed in the dist folder.
  • Web Hosting: The contents of the dist folder can be deployed to any web host.
  • Manifest Reference: The deployed plugin is referenced in the manifest document via its URL.
  • Multiple Plugins: Multiple plugins for a single project can be deployed to a single folder, with the folder path used in the manifest.

Creating Custom Template Helpers

Essential knowledgeThis lesson explores the creation and registration of custom template helpers within the Component SDK. Template helpers are powerful utilities that can be used within Manifest documents for tasks like styling, formatting, and calculations. We'll demonstrate how to create a custom template helper, in this case, one that bolds entity references, showcasing how to leverage the `TemplateRegistry` and its utility methods for generating formatted HTML.
  • Template Helpers: Template helpers are reusable functions that can be called within Manifest documents to perform various operations.
  • Use Cases: Template helpers can be used for styling, formatting, calculations, and other data transformations.
  • `TemplateRegistry`: The `TemplateRegistry` is used to register custom template helpers, making them available for use in Manifests.
  • HTML Formatting: The lesson demonstrates creating a template helper that bolds entity references using `TemplateRegistry` utility methods for formatted HTML generation.
  • Customizability: Custom template helpers extend the functionality of Manifests, allowing for greater flexibility and control over data presentation.

Completing the Custom Form Field: Outputting the Result

Essential knowledgeThis lesson completes the custom form field component by implementing the crucial step of outputting the captured data to the form's submitted payload. We'll learn how to use the `onChange` event provided by the `FormFieldProps` to pass the structured data (containing `locationRef` and `quantity`) back to the form. This ensures that the user's input is included in the data posted when the form is submitted. We'll also demonstrate how to verify the output using browser developer tools.
  • Outputting Data: Custom form fields must output their captured data to be included in the form's submitted payload.
  • `onChange` Event: The onChange event of FormFieldProps is used to pass the data back to the form.
  • `StockReservationPayload`: The output data is structured according to the StockReservationPayload interface, containing `locationRef` and `quantity`.
  • Conditional `onChange` Call: The `onChange` event is called only when a valid location is selected.
  • Verification: The lesson demonstrates how to use browser developer tools (Network tab) to inspect the posted event data and verify that the custom field's output is correctly included in the `reservationDetails` attribute.

Implementing a Custom Form Field

Essential knowledgeThis lesson walks through the implementation of a custom form field component for a Stock Reservation user action. We'll build a field that captures `locationRef` and `quantity` and outputs a JSON object structured as required by the Ruleset. The lesson covers configuring the user action button, creating the custom field component using React Function Components and the `FormFieldProps` interface, registering the field, and updating the workflow definition to use the new custom field type.
  • User Action Configuration: Enabling user actions in the manifest is a prerequisite for testing the custom field.
  • `StockReservation` Data Structure: The custom field will capture data in a specific JSON format: { "locationRef": "F_NSYD", "quantity": 1 }.
  • React Function Component: The custom field is implemented as a React Function Component (FC).
  • `FormFieldProps` Interface: The component uses the `FormFieldProps` interface from the UX Framework, typed with the output payload structure.
  • `onChange` Handler: The `onChange` property of `FormFieldProps` is used to capture user input.
  • Field Registration: The custom field is registered with the `FieldRegistry` using a specific name.
  • Workflow Update: The workflow user action definition is updated to use the new custom field type.
  • Testing: The lesson includes steps to verify that the custom field is correctly rendered in the user action form.

Extending Forms with Custom Field Components

Essential knowledgeThis lesson introduces the concept of custom form fields within the UX Framework. While standard form fields are automatically generated based on data types, developers can create custom field components to handle more complex data structures or enhance the user experience for specific scenarios, such as workflow user actions, GraphQL mutations, and list filters. In our client scenario, we'll focus on building a custom form field to capture stock reservation details, which requires a JSON object containing `locationRef` and `quantity`.
  • Form Field Generation: The UX Framework automatically generates forms based on expected data types.
  • Custom Field Components: Developers can create custom field components to handle complex data types or improve UX.
  • Extending Scenarios: Custom field components can be used with workflow user actions, GraphQL mutations, and list filters.
  • JSON Data Capture: This lesson's focus is on creating a custom field component to capture a JSON object for stock reservation details, containing locationRef and quantity fields.
  • Client Scenario: The need for a custom form field arises from the client's requirement to capture stock reservations, which involves a specific JSON structure.

Configuring Components with Dynamic Attributes

Essential knowledgeThis lesson explores the use of Dynamic Attributes within components, a powerful mechanism for making component content configurable. We'll demonstrate how to create a component, in this case an `InfoBox` that appears when a map pin is clicked, and how to fully configure the information displayed within it directly from the Manifest using Dynamic Attributes. This approach allows for flexible and data-driven component content.
  • Dynamic Content: Learn how Dynamic Attributes enable you to configure the information displayed within a component without modifying its code.
  • Manifest-Driven Configuration: Understand how to define and configure Dynamic Attributes within the Manifest, controlling the content of components.
  • InfoBox Example: This lesson uses an InfoBox component that appears on pin click as a practical example of using Dynamic Attributes.
  • Flexibility and Reusability: Dynamic Attributes make components more flexible and reusable, as their content can be easily adapted through Manifest configuration.

Configuring Components with Settings

Essential knowledgeThis lesson addresses the best practice of avoiding hardcoded values, specifically API keys, within components. We'll explore how to use the `useSettings` hook provided by the Component SDK to retrieve configuration values from platform settings. This approach makes components more configurable and reusable across different clients and environments, simplifying maintenance and updates.
  • Avoiding Hardcoding: Learn why hardcoding API keys or other configuration values directly in components is not recommended.
  • `useSettings` Hook: Understand how to use the `useSettings` hook to access and utilize platform settings within your components.
  • Centralized Configuration: This lesson demonstrates how storing configuration values as platform settings allows for centralized management and easy updates.
  • Reusability and Configurability: By using settings, components become more reusable and adaptable to different clients and environments.

Introduction to Webhooks

Essential knowledgeIn this lesson, we'll look at what Webhooks are, their structure, features and some recommended practices around using Webhooks.
  • Introduction/Recap on what Webhooks are
  • Webhook Structure
  • Webhook Features
  • Types of integrations for Webhooks
  • Webhook best practices

Introduction to GraphQL

Essential knowledgeIn this lesson, we'll look at the benefits of using GraphQL, as well as explore the differences between GraphQL and REST based APIs. We will also look at some examples of a GraphQL query and a GraphQL mutation. 
  • Introduction to GraphQL
  • Differences to REST
  • Benefits of using GraphQL
  • Basic structure of a query
  • A GraphQL mutation
  • Types of common integrations that use GraphQL

Introduction to Integrations and Connections

Essential knowledgeWelcome! This course talks about the various Integrations and Connections of the Fluent Platform.
  • Some common interfaces, and the information shared between these interfaces and the Fluent Platform
  • GraphQL, and understand its benefits over REST APIs.
  • Events API, Inventory Batches, Webhooks, and Connectors
  • Some recommended practices around the use of these methods.

Workflow Scenario (Recommended Practice)

Essential knowledgeWalkthrough of an example scenario that demonstrates the advantages of following recommended practices in workflow design.
  • Smaller, granular rules offer better flexibility and adaptability, allowing for easier updates when requirements change.
  • Composing logic within the workflow gives clients and partners more control over business processes, reducing the need for expensive and time-consuming development changes.
  • Workflow-based logic enhances transparency and makes the process details more accessible, avoiding the "black box" effect of code-based logic.
  • Granularity in workflows leads to richer audit events, which improves triage and problem identification, resulting in faster issue resolution.

Workflow Process Flows

Essential knowledgeAn overview of workflow process flows, explaining how processes are executed by the workflow framework and offering best practices for workflow design.
  • Workflow processes execute business logic through rulesets within an execution context.
  • Processes can be initiated at the Root Entity level or Sub-Entity level.
  • Processes may flow across the same entity, down to a sub-entity, or back up to the parent entity.
  • Recommended practices include executing rulesets inline, making business logic visible, and avoiding cyclic flows.

Logical Gates in Workflows

Essential knowledgeAn introduction to the concept of Logical Gates and examples of how to use these in a workflow.
  • Logical Gates are a common workflow design pattern, and are used to control workflow execution flow. 
  • A logical gate can evaluate a simple condition that resolves to either TRUE or FALSE, or a condition with multiple possible paths such as evaluating an ENUM value.
  • A Logical Gate ruleset should only ever produce a single outcome, typically an inline event to process the following ruleset.

Working with Workflows

Essential knowledgeYou will learn about key Workflow concepts and the Workflow Builder 
  • Workflows are accessible via the Workflow Builder and the Fluent API
  • The Workflow Builder can be used for:
    • Adding and configuring rules, rulesets, triggers, user actions for UI integration
    • Configuring entity states and transitions to match the client's business process
  • Each entity type has its own workflow, such as Home Delivery orders (ORDER:HD) and Click & Collect orders (ORDER:CC)

Recap of Workflow Framework

Essential knowledgeThis article will provide an introduction to the fundamental concepts of the Workflow Framework, including:
  • Explanation of Events, Rules, Rulesets, and Triggers 
  • Description of Statuses representing the condition and state of entities in a workflow
  • Details about Actions as outcomes of Rules
  • Explanation of User Actions, which are UI interactions integrated with workflows
  • Events within the Fluent Commerce platform trigger the execution of rulesets, which are defined in a workflow.
  • Rulesets are collections of rules that form steps within a process, executing specific tasks based on configured criteria.
  • Rules are single-purpose building blocks of business logic that produce actions such as changing entity states or sending notifications.
  • Triggers define conditions under which rulesets are executed when a matching event is received.
  • Statuses represent the current state of an entity within its lifecycle.

Overview of Workflow Framework

Essential knowledgeYou'll acquire new knowledge of the Workflow Framework, its fundamental concepts and terminologies, and also learn about best practice workflow design concepts.  After covering the theory, you will get ‘hands-on’ by completing a Lab where you'll have a go at composing business logic (code free) via the Workflow Builder.
  • The Workflow Framework is a component of the Order Management Experience (OMX) platform and drives the business logic orchestration aspects of the Fluent Order Management.
  • The Workflow Framework enables flexible workflow customization via low-code configuration, high-performance and scalable processing, and seamless UI user action integration.
  • The Workflow Framework comprises the Workflow Engine, Workflow Builder, Rule Library, and Rules SDK.

Security Domain and Entities

Essential knowledgeThe Security Domain represents the Users, Roles, and Permissions across the Fluent platform.  
  • User can have multiple roles 
  • Roles are collection of permissions
  • Users and roles are associated to contexts which can be Account, Retailer and/or Location

Foundational Domains & Entities

Essential knowledgeThe Foundation Domain contains the core foundational entities to support the Order Management capabilities. 
  • The foundation domain is made up of:
    • Accounts
    • Retailers
    • Locations
    • Networks

Domain Model & Entities

Essential knowledgeIn this section the reader will learn about the Fluent domain model and the various entities that make it up. 
  • Fluent provides a flexible domain model to represent data and processes critical for running any business. There are nine Domains:
    • Order Management Domain
    • Billing Management Domain
    • Global Inventory Domain
    • Foundation Domain
    • Store Fulfilment Domain
    • Security Domain
    • Shipping Domain
    • Payment Domain
    • Product Availability Domain

Order Management - Fluent Web Apps & User Interfaces

Essential knowledgeThis section outlines how the webapps interact with the modules
  • Webapps Include:
    • Fluent OMS
    • Fluent Store
    • Custom Web apps
    • Headless/Third party applications

Order Management Experience (OMX)

Essential knowledgeIn this lesson, we'll discuss Fluent OMX, which stands for Order Management Experience. We'll be introducing concepts such as Fluent workflow and UI configuration and customization.
  • Workflow - defines the logical flow or lifecycle of a top-level entity within a domain
  • The UX, Workflows, and Integration can be enhanced to suit business needs via configuration or extension
  • Fluent provides tools that empower both technical and non-technical users 

Orchestration Engine

Essential knowledgeThe  Orchestration Engine powers the execution of workflows, business logic, and business processes. It enables real-time sync for orchestrated availability calls, high-volume batch processing for inventory loads and updates, event tracking which logs all activities, responds to events triggering execution, and triggers activity in external systems.
  • Orchestration Engine
    • Powers the execution of workflows, business logic, and business processes.
    • Enables real-time sync for orchestrated availability calls, high-volume batch processing for inventory loads and updates, event tracking which logs all activities
    • Responds to events triggering execution, and triggers activity in external systems.

Overview of Payments in Fluent

Essential knowledge
  • Fluent Order Management enables the management of payments throughout the lifecycle of an Order.
  • Build custom payment logic into the Order workflow using the OMX Workflow Framework and provided entities.
  • This document provides an overview of the Payment Data Model and GraphQL API capabilities and does not include any reference Rules, Workflows, or UX Components.
  • Pre-requistes
  • Data Model
  • Entities
  • Explanation of the Entity Relationships through an Example
  • Relationship details
  • GraphQL queries required for Payments

Getting Started Configuring Fluent Big Inventory Web App

Essential knowledgeThe Fluent Big Inventory Web App is pre-configured with standard functions that provide the interface for managing products, inventory, feeds, and sources and serve as a starting point for your projects.The default UX templates are hosted on the platform, so you don't have to create the manifest settings unless you need to customize the existing baseline configuration.
  • The Fluent Big Inventory Web App comes with pre-configured standard functions, offering a user-friendly interface for effective management of products, inventory, feeds, and sources.
  • Default UX templates are readily available on the platform, eliminating the need to create manifest settings unless customization of the existing baseline configuration is required, streamlining the setup process for a seamless user experience.

Start your journey here

Essential knowledgeTo guide you through your journey of understanding and learning the Fluent Commerce OMS platform, the documentation is modeled according to the internal building blocks of the system, like 🔀Workflow or ⚙️Settings, with other top-level content types, such as 💡Essential Knowledge and 🧭How-to Guides layered on top of it. Dive right into it by starting here.
  • Navigating through the content structure will help you better understand the platform's inner workings, dependencies, and components.
  • Leverage the extensive tagging system to narrow your search for the right article.
  • Feedback wherever you want to highlight areas of improvement.

Fluent Commerce Fundamentals

Essential knowledgeThis is a guidepost for Developers highlighting important guides and articles to speed up Fluent Commerce's learning process. 
  • Workflows that consist of states, rulesets, triggers, user actions, and Modules, used for distributing workflows and it's artifacts, are a key part of the Fluent Commerce platform.
  • Settings are used to adjust Workflow execution

SSO User Management

Essential knowledgeUser management is a client’s internal process. Your nominated IT team or a partner is responsible for user management.
  • Corporate IdP
  • Fluent IdP & API Users

Ready for Launch Process

Essential knowledgeThe Ready for Launch process (RFL) is an engagement with the Fluent Commerce Expert Services team throughout the lifecycle of a Fluent project. The process is initiated at the beginning of a Fluent Commerce project and completed with the go-live of the project in production.The final review ("RFL Launch Gate") should be planned for 3-4 weeks before the desired Go-Live event to receive the approval to move into production.
  • The Kickoff stage covers the introduction to the Ready for Launch process and the initial project & solution overview.
  • The Design Review stage covers a detailed presentation of the solution by the partner and the review of the implementation by Fluent Commerce.
  • The Launch Gate stage covers the presentation of the final solution and performance test results as well as the confirmation of the desired launch date. After a final review, Fluent Commerce provides the production go-live approval.

Returns in Fluent OMS Web App

Essential knowledgeReturns OMS configuration contains:
  • Creating a Return
  • Returns List page
  • Return Details page
  • Return Fulfillment Details page
  • Create a return in Fluent OMS
  • View returns from all retailers associated with the logged-in user
  • View detailed information about a return
  • View detailed information about how a return was fulfilled

Reports page

Essential knowledgeDiscover how the Reports page in the Big Inventory Web App enables understanding an account Inventory Position Update and Inventory Position Change usage for selected periods.
  • The reports provided enable a user to understand an account Inventory Position Update and Inventory Position Change usage for selected periods of time
  • These usage metrics are split into two different reports so the user can analyze the metric that is most important

Workflow Settings Overview

Essential knowledgeThis article describes settings that can be added to a Workflow. 
  • Explore the Workflow Settings available

Metrics Overview

Essential knowledgeThis document is intended to introduce the Metrics and describe their place within the Fluent Big Inventory product.Pre-requisites:
  • You should have knowledge of the Inventory.
  • You should have knowledge of OMX Workflow Framework.
  • You should have knowledge of Events.
  • You should have knowledge of GraphQL.
  • Metrics are available for all Fluent Order Management and Fluent Big Inventory customers.
  • Metrics data is captured, uploaded, and stored in a monitoring system.
  • Metrics data is retrieved via the Metrics API.
  • Metrics data can be visualized with the OMX UX Framework, Business intelligence tools, and third-party Metrics analytics platforms.

OMX Design System Foundations

Essential knowledgeThe Order Management Experience (OMX) Design System provides guidelines for delivering a user experience tailored to the Omnichannel Order Management space. This article will describe the foundations of the Design System, including color palette and typography which make up the overarching design theme of the Fluent Commerce platform. 
  • The Fluent OMX Design System is based on Material Design 2, this article covers the exceptions & elements not included in this documentation.
  • Learn about the Fluent Commerce color palette & typography through usage examples, recommended practices, and code samples.

Webhook Receivers

Essential knowledgeAn overview of how webhooks work in Fluent Commerce, how they are signed, and validated, and what public keys are used.
  • For security purposes, Fluent Commerce cryptographically signs each webhook request with a private key before sending it to the target endpoint.
  • Every webhook request from Fluent contains two custom headers `flex.signature` (MD5withRSA) and `fluent-signature` (SHA512withRSA). 
  • You can use standard cryptography (e.g. in Node) or built-in Java functions to verify webhook calls.

Order Workflow Templates Overview

Essential knowledgeWe provide three reference workflows Home Delivery (HD), Click and Collect (CC) and Mixed Baskets. Suppose our reference workflows do not accommodate your business case. In that case, you can create a new Order Workflow to support additional Order Types that require different processing and timing, with such as marketplace orders and back ordersLearn more about supported reference workflows here.
  • Plan your Workflow
  • PreOrder Workflow Example
  • Create your workflow

UX Framework - Extending Existing Components

Essential knowledgeThis article provides an overview of methods for configuring components within the UX framework. Customization is possible through configuring the various types of components, such as sub-components, wrapper components, and context components. Read on to find out how to use the above approaches.
  • Core components are highly extensible through configuration; check if your requirements can be met by updating the manifest or component properties (props in the configuration).
  • `DynamicAttribute` values in core components allow for the creation of small, specialized sub-components that enhance functionality.
  • Wrapper components can be used to modify existing components' props or styles, enabling more complex customizations beyond basic configurations.
  • Context components can override default data handling by performing additional queries, but be cautious as this can impact performance.

How Metrics works

Essential knowledgeThis document is intended to describe to implementers Metrics technical details within the Fluent Big Inventory product.Pre-requisites:
  • You should have knowledge of Metrics
  • You should have knowledge of OMX Workflow Framework.
  • You should have knowledge of Events.
  • You should have knowledge of GraphQL.
  • All customers' Metrics are isolated in the dedicated workspaces.
  • Metrics are captured from the Fluent APIs, Orchestration Engine (Rubix), Batch Pre-Processing, and Inventory Feeds.
  • Use `metricInstant` and `metricRange` GraphQL queries to retrieve the Metrics data.

UX Framework - Overview

Essential knowledgeThe OMX UX Framework, or Mystique, delivers configuration-based solution implementation for UIs (Web Apps) that understand the Fluent Platform. It enables UIs to react to changes within workflows and provides best-in-class user experience and design. Web apps can be built using code-free configuration, utilising a rich library of ready-to-use UI Components.  Customising UIs to meet specific business requirements using Component SDKs is also possible.  Configuration is managed in a JSON document called the OMX Web App Manifest.  
  • Code-free configuration through the Manifest document.
  • Dynamic user management experience.
  • Configurable left-navigation menu items.
  • Dynamic views, labels, and fields based on configuration and GraphQL queries.
  • Dynamic and contextual user actions based on workflow configuration.
  • Create and edit all entities, including non-workflow entities.
  • Customise UIs to meet specific business needs and processes.
  • Configure contextual actions based on roles and process states.

UX Framework Overview

Essential knowledgeThe OMX UX Framework, or Mystique, delivers configuration-based solution implementation for UIs (Web Apps) that understand the Fluent Platform. It enables UIs to react to changes within workflows and provides best-in-class user experience and design. Web apps can be built using code-free configuration, utilising a rich library of ready-to-use UI Components.  Customising UIs to meet specific business requirements using Component SDKs is also possible.  Configuration is managed in a JSON document called the OMX Web App Manifest.  

  • Dynamic user management experience.
  • Configurable left-navigation menu items.
  • Dynamic views, labels, and fields based on configuration and GraphQL queries.
  • Dynamic and contextual user actions based on workflow configuration.
  • Ability to create and edit all entities, including non-workflow entities.
  • Customise UIs to meet specific business needs and processes.
  • Ability to configure contextual actions based on roles and process states.
  • Enables centralised management of orders, products, inventory, fulfillments, and locations.

How to transform v1.0 manifest into the manifest v2.0

Essential knowledgeThis article explains how to transform manifests v1.0 into the new manifests v2.0. From this guide, you will learn how to configure manifest with necessary menu items, add filters and configure them, and add custom components. The examples below demonstrate the following Fluent OMS menu items:
  • Orders
  • Roles & Permissions
  • Settings
Learn more about App-Level and Route-Level configuration here.Differences between Admin Console and Fluent OMS manifests are summarised in the following tables
  • Admin Console Vs Fluent OMS Manifests
  • How to add a component to a tab
  • How to add a filter and exclude filters that should not be displayed on
  • How to add breadcrumbs
  • How to set the default page size
  • How to add Mutations and UserActions
  • How to add components to a card
  • How to add components to a list
  • How to configure navigation from Dashboard to the page with applying date and time range filter

The run Method

Essential knowledgeThe `run` method is called by the Workflow Engine when executing each Rule in a Ruleset triggered by an Orchestration Event.
  • Rules are the smallest building block for logic, it is important to remember that this method should be implemented to perform 1 simple task
  • You may not need all of these steps within your Rule. Some rules produce an action without a condition. Some rules do not need to query additional data. Make sure your Rule is as lean as possible, and simple to read.
  • The Rubix Plugin SDK provides a useful Util class to facilitate validation: RuleUtils
  • You can retrieve the data by using Context / Entity
  • Typically, a Rule will produce an output action.

Rules SDK Testing Rules

Essential knowledgeThis page describes the best practice testing approaches for rules and plugins.
  • As per standard industry practices, rules should be tested as part of the development cycle, on the developer's local machine.
  • Testing on Sandbox after local testing has been completed.

Accessing the Workflow Builder

Essential knowledgeAccessing the Workflow Builder
  • The Workflow Builder UI is accessible through the Admin Console (not available on Fluent OMS).
  •  In order to add or edit an existing WF from the UI, you would need to have the right permissions. 

Fluent OMS UI / Admin Console Date Time Format - (include UTC conversion)

Essential knowledgeHandy reference guide on how to display date time value on the UIFor Date format and conversion in UI, two functions can be used:
  • `formateDate`
  • `dateStringFormatter` (if true, then it will leave it as UTC timezone, else, it will convert to the user's browser timezone)
  • Examples of how to display date time format in both OMS webapp and Admin Console

Getting Started with Metrics API

Essential knowledgeThis guide is intended to provide implementers with information about the Metrics API within the Fluent Big Inventory product, describing its functionalities and utilization principles within the Fluent Platform.Pre-requisites:
  • You should have knowledge of How Metrics works.
  • You should have knowledge of Metrics usage for Platform Observability.
  • You should have knowledge of GraphQL.
  • You should configure your User role with `METRICS_VIEW` permission for Metrics data access.
  • Metrics data is fetched and visualized for the Fluent Platform Observability enablement.
  • Use `metricInstant` and `metricRange` GraphQL queries to retrieve the Metrics data.
  • Prometheus Query Language is utilized for the Metrics API queries construction.

Metrics usage for Platform Observability

Essential knowledgeThis document is intended to describe to implementers which Metrics are available within the Fluent Big Inventory product and what kind of data they provide to achieve Platform Observability.Pre-requisites:
  • You should have knowledge of How Metrics works.
  • You should have knowledge of Events.
  • You should have knowledge of Fluent APIs.
  • Metrics are available for all customers with Fluent Order Management and Fluent Big Inventory.
  • Metrics data is captured, uploaded, and stored in the Metrics workspace.
  • Metrics data is fetched and visualized for the Platform Observability enablement.

Order Management Experience (OMX) Framework

Essential knowledgeFluent's Order Management Experience (OMX) framework comprises the UX Framework, Workflow Framework, and Connect Framework, which can be configured and extended (or customised) using software development kits (SDKs).
  • Configuration of user interfaces via the UI Builder
  • Configuration of workflows Workflow Builder
  • Configuration of system integrations via Connector Builder
  • Custom Rules (workflows), UI features, and integration are also possible via Rules SDK, Components SDK, and Connect SDK.

Add colours to statuses to highlight important information

Essential knowledgeThis document provides an overview of enhancing visual representation within a system by displaying coloured dots. These dots serve as a quick reference to different statuses of orders or items, making it easier to recognize and prioritize tasks at a glance. You will learn how to customize the appearance of these dots by changing their colour through hex codes and understand the default settings. The guide also includes recommendations for a colour palette to optimize the utility of status indicators.
  • Feature Benefits: Utilize colourful dots to easily identify and prioritize different statuses.
  • Status Color Palette: Use recommended hex codes to customize dot colours for optimal status indication.
  • Configuration Guide: Follow step-by-step instructions to implement coloured status dots in your system. notify and prioritize different statuses.
  • Default Settings: The system defaults to a grey colour for statuses that are not configured, ensuring consistency across various status indicators.
  • Customization: Hex codes allow for full customization of dot colours to match your company's branding or to signify specific statuses.
  • Visual Prioritization: Assign colours to statuses based on the level of urgency or importance, aiding in quick decision-making.
  • Colour System Best Practices: Refer to the detailed best practices in the Colour section to effectively apply theming and enhance user experience.

Workflow Framework and the Rules SDK

Essential knowledgeThis section covers the fundamentals of the Workflow Engine, provides an overview of the architecture, identifies key concepts, and prepares clients to build and use their workflows.
  • How it Works
  • Workflow Engine Architecture
  • Workflow Builder
  • Rules SDK
  • Key Concepts of the Workflow Engine

Settings Overview

Essential knowledgeThis page provides a high-level understanding of what settings represent within the Fluent platform.
  • Settings are leveraged to enable/disable specific features in the platform.   
  • Settings are set in a specific context (Account, Retailer, Location/Agent).

Escalated Fulfillments

Essential knowledgeA fulfillment represents one or more items in an order that need to be picked and packed for the customer. It is assigned to a location based on the retailer's fulfillment rules and available inventory. A fulfillment will have an origin (from) and destination (to) associated with it. A fulfillment containing unfulfillable items can be moved to the Escalated state. The Escalated Fulfilments page displays fulfillments in the Escalated state.
  • Layout
  • Fulfilment Details page

Self-Service IPU/IPC visibility Overview

Essential knowledgeThis document will detail how customers can view their Inventory Position Update(IPU) and Inventory Position Change(IPC) usage from within the Inventory Web App. Using this, customers can easily compare their usage to contracted rates.Pre-requisites
  • To view the reports, a user must have:
    • Access to the Fluent Big Inventory Web application
    • Access to the Admin module of the Fluent Big Inventory Web application
    • Assigned `ACCOUNTUSAGE_VIEW` permission
  • The UI is configured to display admin reports
  • Self-service IPU/IPC visibility is available for customers with the `ACCOUNTUSAGE_VIEW` permission in the Fluent Big Inventory Web application.
  • The data is captured, uploaded, and stored within Metrics.
  • The data is visualized with the OMX UX Framework.

Users Configuration Overview

Essential knowledgeOMS Webapp's Users List page allows users to efficiently search and view existing users using a versatile filter component. The Users table provides essential user details, with a clickable Username link leading to a detailed User Details page displaying user information. The paging control at the bottom ensures easy entry management with customizable rows per page and intuitive navigation.
  • `Type`: Understand the different types of users; ADMIN, RETAILER, API, and AGENT
  • User Status: Be aware of the user status options, ACTIVE and INACTIVE, which reflect the user's current accessibility.
  • Filtering Users: Utilize the filter component to efficiently search for users based on various criteria like username, status, creation date, and type.
  • Roles and Permissions: Assign roles to users to manage permissions within the system, ensuring each user has the appropriate level of access.
  • Paging Control: Utilize the paging controls at the bottom of the Users table to navigate between pages and manage the number of entries displayed per page, with options for 10, 25, or 100 entries.
  • Deprecation Notice: Be aware that certain user types such as AGENT, SUPPORT, and others have been deprecated and should not be used for new users.

Federated Identity Provider (IdP)

Essential knowledgeFederated identity management means establishing of a trusted relationship between separate organizations and third parties, allowing users to authenticate to one domain and access resources in another without a separate login, enhancing security and user satisfaction. Fluent's Federated SSO utilizes protocols like SAML and OIDC for secure data exchange, providing a seamless single sign-on experience across Fluent OMX applications. These open standards enable the secure transmission of authentication and access information across domains
  • Federated IdP data storage

Exploring Roles & Permissions via the UI

Essential knowledgeRoles & Permissions configuration contains:
  • Roles & permissions page
  • Role Details page
  • Roles & permissions page
  • Role Details page

Mystique Config Guide V1

Essential knowledgeThis config guide refers to version 1 of the UX Framework which is now deprecated
  • Mystique Components
  • Add/Edit Entities
  • Configure Dynamic UIs
  • Configure Search or Listing Pages
  • Configure Detail Pages
  • Add Attributes to Mystique Components

Escaping / unescaping of values in UX Framework

Essential knowledgeCharacter escaping and unescaping are crucial for data integrity and security in UX frameworks. This document focuses on the Mustache.js templating engine, which escapes HTML by default to prevent XSS attacks. When special characters like ampersands need to be displayed, the framework offers unescaping methods to ensure correct and secure rendering.This overview highlights the significance of proper value escaping and the techniques for accurately rendering special characters within the UX framework.
  • Mustache.js Templating: The UX framework utilizes mustache.js for templating, which automatically escapes HTML characters. This is important for preventing XSS (Cross-Site Scripting) attacks and ensuring data is displayed as intended.
  • Unescaping Variables: To display special characters properly, such as ampersands, you must unescape variables using triple mustaches, e.g., `{{{variable}}}`, or the `&` symbol in the variable tag, e.g., `{{&variable}}`.
  • Correct Display of Values: Escaping or unescaping variables correctly is crucial for the accurate representation of data within the UX. This ensures that special characters are rendered as intended, maintaining the integrity of the information displayed to users.

Admin Console Overview

Essential knowledgeThe Fluent Admin Console is a web browser-based portal, for retail business users, that provides the interface to manage orders, product availability, inventory and order fulfillment. The Admin Console is used by businesses and administrators to access a large range of functionality provided by the following Fluent Commerce apps:
  • Distributed Order Management
  • Global Inventory
  • Product Availability
Each app provides out-of-the-box capabilities that are accessed by the Fluent Admin Console.By default, the Admin Console displays content in English. However, v4.44 release onwards, the Fluent platform provides support for multiple languages. For more information on languages and localization and configuring other languages, click here. The console should be used on tablets and computers that have an active internet connection and a supported web browser.
  • Fluent Admin Console Overview
  • Console Dashboard Overview
  • Configure the Console Dashboard to Identify and Display Missed SLAs

Webhooks Frequently Asked Questions

Essential knowledgeFluent Commerce doesn't support static IP whitelisting due to AWS Cloud's dynamic nature. Instead, robust authentication measures are in place for webhook security, including cryptographic signing and signature verification. While static IPs aren't recommended, securing webhook endpoints is achievable by configuring unique URLs and firewall rules. Additionally, setting up custom authorizers or message queue validation enhances security. Each webhook establishes a single connection, with inbound and outbound calls dependent on workflow events. For detailed guidance, refer to Fluent's 'Webhook overview' documentation.
  • Static IP Whitelisting: Fluent Commerce's AWS Cloud setup doesn't allow for static IP whitelisting due to the potential for IP address changes caused by scaling or architectural adjustments, as well as AWS's own IP address alterations.
  • Authentication Measures: Instead of relying on IP Access Control Lists, Fluent Commerce employs strong authentication measures for webhook requests, including cryptographic signing with a private key and verification using a public key to ensure the request's legitimacy and integrity.
  • IP-Based Restrictions: Implementing IP-based restrictions, such as whitelisting or IP ranges, is not recommended due to the dynamic nature of IP addresses in the AWS Cloud setup, which can lead to high exposure levels and difficulty in implementation.
  • Alternative Approaches for Access Control: Instead of IP-based restrictions, companies can utilize firewall/networking equipment or reverse proxies to restrict access based on incoming HTTP request details, or configure unique, specific static URLs for incoming traffic to filter and accept connections securely.

Location details page overview and configuration

Essential knowledgeA Location represents a physical place, whether a retail store, a warehouse, or even third-party vendor facilities.  A Location page displays the list of existing locations, while a Location Details page displays detailed information about the particular location.
  • Locations page
  • Location Details page

Using the Event API

Essential knowledgeUsing the Event API
  • Retrieving Orchestration and Orchestration Audit events are done via the Fluent Event API
  • The Event API has various parameters that are available to filter for specific events, for example for a particular entity or during a particular timeframe.

Workflow Configuration - Getting Started

Essential knowledgeClients and Partners will need to have their Fluent Account set up prior to being able to work with Orchestration.You should have received an "Account Ready" email with your Fluent Account Details, including user login credentials.If you do not have access to a Sandbox account, please contact your Fluent Account Manager.
  • Overview and Key Concepts on Workflow Configuration.
  • The primary setting required to be enabled for working with Orchestration is that your Account should be RUBIX_ENABLED. 
  • As a user working with the Orchestration Modeller via the Admin Console, you will require the ORCHESTRATION_ADMIN role.
Building Blocks
Building Blocks
Packages & Modules
All UI Components
Workflows
Settings
Interface Contracts
All Rules
By Type
All Types
Knowledge Tracks
Extend Knowledge
Glossary
All How-to Guides
Sitemap
Topics
Use Cases
Helpful Resources
Platform Limits
Support Policy
Service Level Agreement (SLA) - Enterprise
Deprecation Policy
Extend Knowledge Content – Terms and Conditions
System and Organization Controls (SOC) 3 Report
Data Privacy Addendum
Security Policy
Quick Links
For Partners
Customer Resources
Webinars and Events
Certifications
Training Resources
Knowledge Tracks
Builders Portal
Product Update Newsletter
Industry Blogs & Events Newsletter
Trust Center Portal

Copyright © 2024-2026 Fluent Retail Pty Ltd (trading as Fluent Commerce). Unless otherwise expressly stated in a current written agreement with Fluent Commerce or any of its affiliates or on any single page of the docs.fluentcommerce.com site, use of the materials on this site is strictly limited to viewing by individuals over 18 years old for legitimate commercially appropriate reasons; and any downloading, copying or other actions or uses of any kind or by any means of the materials on this site, including by artificial intelligence tools, is strictly prohibited. All other rights reserved.

Fluent Logo