Recently Updated
Some of the recently updated content.
External Webhook Integration Architecture - commercetools Connector
Essential knowledgeExplains how the commercetools Connector ingests inbound webhooks and dispatches outbound payloads across the integration ecosystem. Partners will learn to configure and apply this shared framework utility, which manages message routing, handler resolution, and internal queue mechanics. For the business, this asynchronous architecture ensures real-time, secure data transmission and protects platform stability by preventing message loss during high-volume storefront traffic spikes.Note: This architectural component serves as a global framework utility rather than a single functional pipeline.- Core Function & Outcome: You will learn how the framework utility orchestrates bidirectional ingress and egress loops, serving as the master execution blueprint for all entity-specific data synchronization pipelines.
- Asynchronous Queue Infrastructure: The architecture processes incoming webhook payloads through an external
`ct-queue` and an internal Event Queue sequentially, decoupling network reception tasks from backend data processing to maintain platform throughput. - Declarative Route Filtering: Implementing partners can manage message names, configure explicit inclusion filters, and reassign target event pathways directly inside the
`application-connector.yml` configuration file. - Extensible Handler Architecture: The core message routing and processing layers are completely decoupled, allowing developers to cleanly register custom storefront event handlers by extending the base
`MessageHandler` class.
Webhooks Frequently Asked Questions
Essential knowledgeThis page contains frequently asked questions about Fluent Webhooks. Due to the nature of being a cloud-hosted application, there are some restrictions in place regarding IP Whitelisting and Authentication that frequently come up.- Static IP Whitelisting: Fluent Commerce's 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 or GCP'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 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.
Store Locator - Adobe Commerce Connector
Essential knowledgeExplains how the Adobe Commerce Connector pulls physical fulfillment locations—including retail stores, warehouses, and collection nodes—from Fluent Order Management. Partners will learn to configure manual, full, and delta background cron tasks that map data models. For the business, this feature provides accurate store listing directories to support omnichannel options.Note: This article forms part of the inbound pipeline category, where data flows into the Adobe Commerce environment from an external source.- Core Function & Outcome: You will learn how the integration service layer pulls multi-retailer location metrics from Fluent to update internal storefront database records using a four-step pipeline.
- Three Extraction Profiles: Data sets are sustained via command-line full synchronizations, custom administration interface date filters, or automated background cron runs.
- Infrastructure Dependencies: Because processing relies on native messaging queues and background chronologies, proper system execution configuration is vital to maintain accurate store profiles.
- Developer Customization: If you need to alter the default behavior, the framework provides eight distinct events to customize query payloads, request variables, and data models before they are saved.
Consignment - Adobe Commerce Connector
Essential knowledgeExplains how the Adobe Commerce Connector ingests inbound consignment updates from Fluent Order Management to update storefront shipments. Partners will learn to manage asynchronous validation chains, message queues, and tracking details. For the business, this automation creates precise full or partial customer shipments and provides real-time carrier tracking links.Note: This article forms part of the inbound pipeline category, where data flows into the Adobe Commerce environment from an external source.- Core Functionality & Outcome: You will learn how this pipeline intercepts Fluent consignment webhooks to automatically create and update full or partial shipments, including tracking codes, in Adobe Commerce.
- Global Scope & Trigger Constraints: If you skip the text, you must know that this framework can only be activated globally across all websites, and shipment generation relies entirely on a configurable, comma-separated list of specified Fluent statuses.
- Asynchronous Validation Flow: Inbound webhooks undergo a strict multi-step validation chain (verifying accounts, retailer IDs, and entity types) before being offloaded to an asynchronous message queue (
`fluentcommerce.consignment.updater`) for safe, decoupled processing. - Architecture & Customization: Developers can extend or override webhook handlers, validation rules, and processing commands using standard Adobe Commerce Dependency Injection (DI) (
`di.xml`) or tap into two dedicated event hooks (`before`/`after` processing).
Category Sync - commercetools Connector
Essential knowledgeExplains how the commercetools Connector synchronizes category trees from a storefront outbound to Fluent Order Management. Partners will learn to manage real-time subscriptions and batch execution paths to mirror catalog hierarchies. For the business, this automation aligns navigation structures across platforms, ensures consistent item grouping for backend orchestration, and eliminates manual data entry.Note: This article forms part of the outbound pipeline category, where data flows out of the commercetools environment to an external destination.- Core Function & Outcome: You will learn how the connector coordinates the export of category trees from commercetools to Fluent Order Management, establishing matching catalog nodes across both environments.
- Dual-Trigger Execution: Supports manual, scheduler-driven complete catalog extraction alongside automatic background delta tracking.
- Subscription Management: Relies on core commercetools subscriptions to stream real-time creation and modification alerts into the integration layers.
- Extensible Routing Architecture: Allows business rules, message paths, and handler logic maps to be safely overridden via central YAML configurations. Technical partners can easily reassign event paths, manage inclusion filters, and override standard handler classes inside the centralized
`application-connector.yml` configuration file.
Consignment Updates - commercetools Connector
Essential knowledgeExplains how the commercetools Connector tracks shipping events from Fluent Order Management to update commercetools. Partners will learn to manage the inbound webhook pipeline that automatically generates native delivery records, parcel data, and carrier tracking links. For the business, this sync eliminates manual shipment logging and gives customers instant visibility into order transit via the storefront interface.Note: This article forms part of the inbound pipeline category, where data flows into the commercetools environment from an external source.- Core Function & Outcome: You will learn how the commercetools Connector captures consignment updates from Fluent Order Management to automatically generate delivery records, package manifests, and carrier tracking data inside commercetools.
- Asynchronous Queue Infrastructure: Inbound webhook payloads undergo cryptographic signature and parameter verification in the first stage before entering an internal queue, where a named handler processes the data updates asynchronously in the second stage.
- Structural Entity Mapping: The system maps Fluent consignment entities directly onto fulfillment models, which translate into native, line-item level delivery records to cleanly support orders split across multiple packages or locations.
- Data Enrichment Mechanism: Because incoming webhooks carry minimal payloads to reduce network overhead, the connector automatically dispatches a
`GetConsignmentById` GraphQL query back to Fluent to pull complete carrier details and package dimensions before updating commercetools.
Customer Sync - commercetools Connector
Essential knowledgeExplains how the commercetools Connector synchronizes customer profile data from a storefront to Fluent Order Management. Partners will learn to configure, validate, and extend this outbound data pipeline from the storefront trigger to the final GraphQL delivery. For the business, this real-time pipeline removes profile fragmentation, giving customer service agents instant access to accurate records.Note: This article forms part of the outbound pipeline category, where data flows out of the commercetools environment to an external destination.- Core Function & Outcome: You will learn how the commercetools Connector detects and processes customer creations and modifications automatically the moment they occur on the storefront, removing the need for manual batch data transfers.
- Asynchronous Queue Infrastructure: The architecture routes payloads through an external
`ct-queue` and an internal Event Queue sequentially, decoupling storefront event triggers from backend database processing to protect platform stability. - Declarative Route Filtering: Implementing partners can manage message types, configure explicit inclusion filters, and reassign target data pathways directly within the
`application-connector.yml` configuration file without modifying core system code. - Extensible Handler Architecture: The core message routing and transformation layers are completely decoupled, enabling developers to cleanly introduce custom profile fields and data-mapping logic by extending the base
`MessageHandler` class.
Order Sync - commercetools Connector
Essential knowledgeExplains how the commercetools Connector manages the two-way pipeline that exports new orders from a storefront to Fluent Order Management and handles asynchronous status updates. Partners will learn to configure event-driven triggers, enable customer profile creations, and apply route filters. For the business, this real-time sync establishes a single source of truth for transactions across Home Delivery and store pickup channels.Note: This article forms part of the outbound pipeline category, where data flows out of the commercetools environment to an external destination.- Core Function & Outcome: You will learn how the commercetools Connector handles order exports from commercetools to Fluent Order Management, automates integrated customer profile creation, and establishes the webhook ecosystem for order status processing.
- Out-of-the-Box Capabilities: Out-of-the-box (OOTB) functionality natively supports Home Delivery (HD) and Click and Collect (CC) order structures, complete with automated type-specific order number generation patterns.
- System & Sync Limitations: Designed strictly for new transactions and does not synchronize historical orders created prior to extension installation. Additionally, the order update and modification handlers must be customized to fit your specific implementation needs.
- Extensible Pipeline Architecture: The message routing and handler framework is completely decoupled. Developers can easily update message names, override standard classes, or extend the baseline order creation logic to attach custom operational attributes.
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.
Connect SDK Libraries
Essential knowledgeThe Connect SDK Libraries comprise a modular software development framework designed for building integrations with Fluent Order Management. The architecture centers around a mandatory core module that handles foundational communication, configuration storage, and routing capabilities. Implementation teams can extend this baseline engine using specialized, pluggable add-on libraries to introduce web frameworks, security filters, specific cloud or infrastructure adapters, and isolated simulation testing suites.- What You Will Learn: You will understand the structural purpose of each component within the Connect SDK framework and learn how to select the appropriate core, web, cloud infrastructure, or testing dependencies for your implementation project.
- Mandatory Core Requirement: The
`connect-sdk-core` library is a mandatory dependency for all SDK-based implementations. It houses the baseline engine components, including the REST and GraphQL API client, authentication management for sensitive credentials, message routing, and the configuration manager. - Asynchronous Processing Boundary: All transactional endpoints and internal processing steps handled by the SDK execute asynchronously in the background. The explicit exception to this design rule is product availability processing, which runs synchronously.
- Pluggable Architecture Strategy: Advanced technical capabilities are intentionally isolated into decoupled modules. Developers append specialized add-ons like
`connect-sdk-core-web-security` for Spring Security filters, `connect-sdk-core-aws` for Amazon Web Services (AWS) deployment services like Amazon Simple Queue Service (SQS) and AWS Secrets Manager, or `connect-sdk-core-kafka` for Apache Kafka support. - Isolated Testing Frameworks: The SDK segregates quality assurance utilities into specific test scopes. Teams deploy
`connect-sdk-test-core` to mock external API calls with Wiremock, or utilize the AWS and Kafka test extensions to run integration tests inside software containers alongside LocalStack or virtual Kafka brokers.
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.
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.
Fluent Analytics Studio
Essential knowledgeAnalytics Studio is a dedicated web application within Fluent that enables users to explore, analyse, and act on business data. Where embedded Fluent Analytics metrics are designed for monitoring in specific contexts, Analytics Studio is designed for investigation, giving users access to dashboards, individual records, and data exports to understand what drives changes in key metrics.- Analytics Studio is a dedicated web application for exploring and analyzing business data
- The application is available at
`https://<ACCOUNT_ID>.<ENVIRONMENT>.apps.fluentcommerce.com/analytics` - It extends dashboards by allowing access to the underlying records behind metrics
- Users can investigate issues, identify trends, and understand what is driving changes in key metrics
- The application supports exporting data, setting alerts, and scheduling reports
- Built-in dashboard actions allow users to refresh data, reset filters, change time zone settings, export dashboards, and schedule reports
Adobe Commerce Connector - Core Authentication & Webhook Infrastructure
Essential knowledgeEstablishes the foundational security mechanisms, credential mapping strategies, and inbound validation rules required to securely pass transactional payloads between Adobe Commerce and Fluent Commerce:- Safeguards multi-retailer setups by auto-mapping Adobe website scopes to isolated Fluent credentials.
- Speeds up extensions via a unified API layer and an easily modifiable webhook validation chain (
`di.xml`). - Webhooks require a strict 3-step signature and data check. Because all modules rely on this, any configuration issue breaks the entire integration.
- Core Foundation & Outcome: You will learn how the General module acts as the integration's architectural backbone, housing all shared utilities, services, and core API authentication layers that every other module fundamentally depends on.
- Scoped Multi-Retailer Support: If you skip the text, you must know that credentials are completely isolated per website scope, allowing each distinct Adobe Commerce website to map to and authenticate with its own specific Fluent retailer configuration.
- Global Webhook Validation: All incoming webhooks share a centralized, 3-step validation chain (
`MessageValidatorChain`) configured via `di.xml` that automatically enforces field presence, entity types, and security signature integrity. - System-Wide Dependency Risk: Because this module manages the single point of truth for global communication and data validation, any misconfiguration or failure here will break the entire integration ecosystem.
commercetools Connector Extend Configuration
Essential knowledgeThe commercetools Connector features a highly adaptable runtime architecture governed by four baseline configuration files: `application-connector.yml`, `application.yml`, `bootstrap.yml`, and `logback-spring.xml`. Together, these files define core connector settings, server/container properties, and logging rules.To manage multi-environment rollouts efficiently, you can override common baseline settings by creating dedicated files that follow standard Spring Boot profile conventions (e.g., `application-dev.yml`) to isolate your development, staging, and production environments.- What You Will Learn: You will understand how to safely configure, secure, and scale the bidirectional data flow between commercetools and Fluent Commerce across multi-profile cloud environments without modifying core connector code.
- Core File Architecture: The connector requires a strict baseline of four configuration files (
`application-connector.yml`, `application.yml`, `bootstrap.yml`, and `logback-spring.xml`). You can dynamically override any environment setting by appending standard Spring Boot profile suffixes (e.g., `application-dev.yml`). - Critical Operational Guardrails: * Job Serialization: The asynchronous job scheduler enforces strict concurrency control—multiple instances of the same data synchronization job cannot run simultaneously.
- Data Retention: Manual
`customDateRange` overrides are destructive parameters; the connector executes the targeted historical timeframe exactly once and automatically deletes the custom range to prevent looping data.
- Security and Performance Impact: Moving or updating sensitive external platform endpoints requires configuring the connector's dedicated credential storage layer. Additionally, message processing throughout during peak traffic events is directly governed by adjusting the
`pool-size` and queue listener properties.
GraphQL Permissions
Essential knowledgeThe GraphQL Permissions define the access rights that control every operation in the Fluent platform’s GraphQL API. Each permission represents a single, specific action a user can perform on an entity, ensuring secure access management across all services.By assigning permissions to roles, organizations can control user capabilities at a granular level. This ensures that users only access and modify data relevant to their role and business context.- Permission Structure: GraphQL queries and mutations are secured by permissions that follow the ENTITY_ACTION naming convention (for example, ORDER_VIEW, ORDER_UPDATE). This ensures precise and predictable access control across all API operations
- Nested and Partial Mutations: Nested mutations require separate permissions. Partial mutations are not allowed — if one permission check fails, the entire operation is rolled back
- Plugin Management Access: Plugin-related operations are governed by specific permissions such as PLUGIN_VIEW, PLUGIN_UPLOAD, and PLUGIN_INSTALL. Only users with these permissions can manage plugin
- Error Handling and Troubleshooting: Operations attempted without proper permissions return the error code C0020E. Users must obtain the required permissions before retrying the operation
- Analytics Permissions: Domain-level permissions (for example, ORDER_REPORT, INVENTORY_REPORT) control access to analytics capabilities across business domains via the GraphQL API.
Integration Tests with the Connect SDK
How-to Guide- End-to-End Test Orchestration: You will learn how to wire, configure, and execute automated integration tests using specialized Connect SDK test modules (
`connect-sdk-test-core`, `connect-sdk-test-core-aws`, and `connect-sdk-test-core-kafka`) to validate custom data handlers against simulated API footprints and containerized queue systems. - Execution Command Restrictions: Standard unit test triggers like
`mvn test` will completely ignore these integration suites. You must invoke the pipeline using `mvn clean integration-test` and explicitly declare or preset the targeted active Spring profiles (such as `aws,localstack` or `kafka`) to instantiate the proper environment dependencies and messaging beans. - Isolated Bootstrapping Requirements: When building integration tests inside a decoupled code module that lacks a primary application runner, you must manually deploy an executable bootstrap class annotated with
`@SpringBootApplication` and `@EnableScheduling` inside your `src/test/java` directory. Additionally, you must place three mandatory configuration manifests (`application.yml`, `application-connector.yml`, and `bootstrap.yml`) into the `src/test/resources` folder. - Automated Environment Isolation: The test suite leverages
`Testcontainers` and `WireMock` to manage external asset lifecycles dynamically. Activating specific environment flags like `localstack` inside the configuration settings instructs the SDK to auto-provision localized mock instances of cloud services (including Amazon SQS queues, Amazon S3 buckets, and secrets vaults), eliminating the need to manage external persistent test infrastructure.
Stock Segmentation - Data Model and API Overview
Essential knowledgeStock Segmentation extends Fluent’s Inventory and Virtual Catalog data models to represent multiple logical segments for the same product and location using explicit, queryable factors.Stock Segmentation supports scenarios such as channel-specific reservations, manufacturing batch traceability, compliance restrictions (for example by country of origin), and supplier-level inventory management while preserving a single physical inventory model per product and location.This document explains the data model and GraphQL API capabilities introduced for Stock Segmentation.- Physical stock in the Inventory Catalog is represented through Inventory Quantities that can be segmented using dedicated fields such as
`condition`, `expiresOn`, `countryOfOrigin`, `channel`, `manufacturer`, `manufacturerBatchNumber`, `supplier`, and `segment1/2/3` - Inventory Quantities support parent-child hierarchies, allowing multi-level segmentation trees to be modeled explicitly via the parent relationship
- Inventory Quantities can be linked to operational entities using
`associationType` and `associationRef`, particularly for reservation linkage and traceability - Virtual availability can expose a single customer-facing segment using Virtual Segments
- Segmentation fields are exact-match searchable to ensure predictable query behavior (partial matching is not supported)
ICP, Qualification Criteria and Additional Use Cases
Essential knowledgeThe article provides a comprehensive guide to identifying the Ideal Customer Profile (ICP) for an Order Management System (OMS), highlighting key criteria and red flags to ensure successful implementation. It also explores Fluent OMS use cases, showcasing its capabilities in order capture, fulfillment, tracking, promising, shipping, and inventory management.- Ideal Customer Profile (ICP) based on specific industries, company maturity, and high order volumes
- Poor fit indicators, such as outdated legacy infrastructure or a lack of executive buy in
- Fast Qualification Framework to rapidly assess a prospect's Budget, Systems, Volume, and Channels.
Send Enhanced Inventory Attributes in Your Payloads
Essential knowledgeInventory payloads can include additional Inventory Quantity attributes to capture richer stock context.This article explains how to use the `attributes` object to include additional data in inventory payloads. It supports both simple key-value pairs and custom JSON structures to meet diverse business requirements - whether you’re:- managing detailed product information
- optimizing warehouse processes
- or integrating with custom workflows
The Inventory Reference Module supports a set of reference attributes that are persisted automatically, while custom attributes provide additional flexibility.- Prerequisites: To fully leverage the extended attributes functionality within the inventory payload, ensure that you are using the Inventory Reference Module v2.3.0 or later
- Flexible attribute structure: The
`attributes` object supports any combination of key-value pairs, including complex JSON structures and arrays. This flexibility allows you to customize the data sent in your inventory payloads to meet specific business needs - Use reference attributes first: Certain key attributes (such as
`associationType`, `associationRef`, `parentRef`, `expectedOn`, `expiresOn`, `condition`, `storageAreaRef`, `supplier`, `manufacturer`, `manufacturerBatchNumber`, `countryOfOrigin`, and `channel`) will be directly updated in the Inventory Quantity associated with the incoming record, facilitating seamless integration with existing fields - Use segment fields for flexible key-value extensions:
`segment1`, `segment2`, and `segment3` provide flexibility for additional flat classification data without introducing new custom attributes - Custom attribute availability: Any custom attributes that you include in the
`attributes` object will be available in workflows via `inventoryPosition.inventoryQuantity.attributes.<fieldName>`. This enables you to incorporate custom data into rule-based processes or other logic tailored to your business requirements
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.
Overview of Payments in Fluent
Essential knowledgeThe Fluent platform enables payment orchestration across the full lifecycle of an Order. Using the OMX Workflow Framework and core payment entities, businesses can implement custom logic for fulfilment, capture, refunds, and reconciliation. This document outlines the Payments Data Model and GraphQL API capabilities, excluding reference Rules, Workflows, or UX components. Financial operations within the Payments domain rely on precision-safe monetary representations to ensure accuracy and consistency across transactions.- This document covers the Payments data model and GraphQL API
- Payments are usually fulfilment-driven, but capture can occur at different stages depending on workflow configuration
- Core entities: FinancialTransaction (funds source), Payment (capture/refund), PaymentTransaction (status log)
- Monetary values support precision-safe amounts via preciseAmount (BigDecimal/NUMERIC); legacy Float fields remain optional for backward compatibility
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.
BigDecimal Precision & Rounding Principles
Essential knowledgeThis document defines the core principles for using `BigDecimal` in monetary and high-precision calculations. After reading, developers can apply the appropriate constructors, division rules, and rounding strategies to ensure consistent numeric representation across services, APIs, and storage. These principles reduce defects caused by floating-point arithmetic, undefined division, rounding errors, and incorrect value comparisons.- Monetary calculations rely on deterministic precision across all services.
- Precision is preserved using
`NUMERIC` (DB), `BigDecimal` (Java), and (`unscaledValue`, `scale`) (API). - Division requires explicit scale and rounding to avoid runtime exceptions.
- Most defects originate from constructing from
`double`, confusing scale vs precision, or misusing `equals()`.
Fluent Metrics Library Overview
Essential knowledgeThe Fluent Metrics Library is a collection of metrics and dashboards available to Fluent customers. Delivered through the Fluent Analytics feature, it gives retailers real-time visibility into order, fulfillment, returns, and inventory operations to enable faster, smarter decisions.
Designed for retail operations managers, inventory analysts, business intelligence, and many other teams who need visibility across retail operations.- Operational clarity - get a clear view of what's working and what needs attention across your network.
- Proactive issue management - quickly detect spikes in cancellations, rejections, or delays.
- Continuous optimization - track key metrics across locations, channels and fulfillment types to drive improvements.
- Data-driven decisions - support trade planning, performance reviews and customer experiences with real-time data.
"FC Retail Group" Sample Setup
Essential knowledgeThis section goes through the different sections of an account and the different parts that make a Fluent Account work. It introduces the account structure, including training accounts, locations, networks, catalogs, data files, user roles, and settings at various levels.- Training accounts model a retail group with shared and individual workflows for FC Fashion and FC Sports.
- Locations and networks enable fulfillment options like Home Delivery and Click & Collect, tailored to each retailer.
- Catalogs, including virtual ones, determine sellable items and fulfillment types across networks.
- Settings at account, retailer, and location levels control permissions, workflows, and inventory behavior.
Tool Overview: LaunchPad v1
Essential knowledgeThis page provides an overview of Fluent LaunchPad v1. It is a tool designed to streamline the setup of Fluent accounts for efficient order processing by leveraging Postman's advanced features to automate workflows, reducing manual effort and minimizing errors. LaunchPad ensures comprehensive account configuration, including dynamic authentication, retailer creation, inventory management, and fulfillment setup.- Fluent LaunchPad is a smart Postman workflow that quickly sets up a Fluent account to be ready for end-to-end order processing (retailers, locations, products, inventory, workflows).
- It is a “guided engine”, using pre-/post-request scripts, variables, and execution control to improve on the more manual SDK Insomnia collection.
- It covers dynamic auth, retailer creation, locations & networks, products, global inventory, and fulfillment/order-management configuration.
Platform Foundations
Essential knowledgeThis section covers the basics of the Fluent Platform, such as sandbox and production environments, account structure, retailer management, location networks, user roles and permissions, and platform configuration.- Sandbox environments are used for non-live activities like development, testing, training, and demos, while production environments are strictly for live client operations.
- Accounts represent single tenants with their own data, endpoints, and the ability to manage multiple retailers and install custom apps.
- The platform allows for flexible user roles and permissions with context-specific settings at account, retailer, or location levels.
- JSON Configuration files are used to alter settings in Fluent's web apps
Raise a Support Request for Reference Modules
How-to Guide- Before raising a ticket, review the reference module setup and configuration guides, Use the Event API to validate the workflow process executed, including source Event, Rulesets, and Rules, and Check all Settings, Users, Roles, Auth Tokens, etc. before raising an issue.
- Support is provided for reference modules, which are Core, Order, Fulfilment, and Inventory.
- Raise a Support Request for Reference Modules with a Fluent Retail Support (FRS) ticket.
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.
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.
Why Fluent Commerce Focuses on SOC 2 Type 2 Attestation (Not SOC 1 / ISAE 3402)
Essential knowledgeFluent Commerce prioritizes SOC 2 Type 2 attestation over SOC 1 / ISAE 3402 due to its focus on order management, fulfillment, and inventory processes. SOC 2 Type 2 evaluates controls across Security, Availability, Processing Integrity, Confidentiality, and Privacy, addressing customer concerns about data protection and system reliability. Annual audits reinforce Fluent Commerce's commitment to these areas.- SOC 1 / ISAE 3402 focuses on financial reporting, which is not relevant to Fluent Commerce's services.
- Fluent Commerce provides tools for order management and fulfillment, not direct financial transaction processing.
- SOC 2 Type 2 attestation is more appropriate for evaluating cloud-based software providers.
- SOC 2 Type 2 assesses controls across five Trust Services Categories: Security, Availability, Processing Integrity, Confidentiality, and Privacy.
- Annual independent audits of SOC 2 Type 2 demonstrate Fluent Commerce's commitment to data protection and system reliability.
Search Sourcing Profiles
Essential knowledgeThe `sourcingProfiles` query retrieves existing Sourcing Profiles. It supports multiple filters and pagination.- Prerequisites: User should have
`SOURCINGPROFILE_VIEW` permission - Flexible Filtering: Multiple filters are supported, including
`ref`, `version`, `versionComment`, `name`, `description`, `status`, `defaultMaxSplit`, and date ranges (`createdOn`, `updatedOn`). This lets you target specific Profiles or narrow results down by lifecycle state and time window - Pagination Support: The query supports cursor-based pagination (
`first`, `last`, `before`, `after`), making it efficient to handle large sets of Sourcing Profiles
Product Description - Fluent Hosted Connectors
Essential knowledgeFluent Connect provides Hosted Connectors for integration between Fluent Order Management and external systems such as marketplaces, commerce platforms, payment providers, service platforms, and inventory distribution services. This approach simplifies integrations, reduces delivery timelines, and enables reliable connectivity across platforms.- Enables connectivity between Fluent Order Management and external systems (marketplaces, commerce, payments, service platforms, inventory).
- Hosted connectors simplify operations but are not customer-modifiable
- Includes specialized Connected Inventory hosted connectors for near real-time inventory updates to downstream platforms.
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.
Adding a Ruleset to your Workflow
How-to Guide- The Ruleset, defining the executed actions for matching events, can be added through the UI using either an existing Ruleset list or the Entity Workflow Swimlane.
- Green icons in the Status rectangles represent Rulesets triggered on that State, while those outside a status transition the entity to the indicated state.
- Adding a Ruleset via JSON requires inclusion in the Workflow JSON's Rulesets Array, following a schema with mandatory elements like name, rules, and triggers, and optional elements like description, type, subtype, eventType, and userActions.
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 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.
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.
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 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.
Inventory Ingestion
Essential knowledgeInventory Ingestion in Fluent Commerce ensures that stock levels across all sales channels remain accurate and up-to-date, enabling effective inventory management. It allows businesses to send inventory updates to the platform using two distinct methods: Inventory Batch and Inventory Delta. Each method is tailored to different scenarios, depending on data volume, frequency, and operational needs.- Inventory Batches handle large-scale updates (thousands to millions of records), while Delta updates are ideal for smaller, incremental changes in real time.
- Batches use asynchronous processing for bulk data, grouped into Jobs for tracking, whereas Deltas are processed individually directly by the workflow engine.
- Batches are suited for periodic updates like ERP integrations and stocktakes, while Inventory Deltas are designed for real-time changes to reflect inventory movements such as store sales, returns, or daily adjustments.
- Batches require management of file sizes and grouping, while Deltas focus only on incremental updates, ensuring simplicity and speed for smaller changes.
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.
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.
Utility Bundles Overview
Essential knowledgeThe Fluent Commerce Utility Bundles are a set of libraries designed to accelerate Rule development, reduce boilerplate code, and improve the overall quality and maintainability of implementations. They are the cornerstone of writing maintainable, reusable, and easily upgradeable Rules for the Fluent Commerce platform.- Prerequisites: You should have knowledge of the Rules SDK, including Designing Rules, Rule Structure, Writing Rules, Rule Development Guidelines, General Principles, and Rules SDK - Getting Started.
- Focus on Business Logic: The libraries handle common, repetitive tasks (like data fetching and JSON conversion), allowing developers to concentrate on writing the business logic that delivers value.
- Three Specialized Bundles: The utilities are organized into three modules:
`util-core` for essential daily tasks, `util-dynamic` for building runtime queries, and `util-test` for simplifying testing. - Easy Upgrades: Receive bug fixes and new features from Fluent Commerce by updating the dependency version in your
`pom.xml`, ensuring your implementation stays current. - Built for Extensibility: The utilities are designed to be flexible, allowing you to inject your custom logic into standard processes.
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.
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.
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.
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.
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.
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.
Core Google Cloud Platform (GCP) Components Supporting Fluent Commerce
Essential knowledgeFluent integrates key Google Cloud Platform (GCP) services to enhance scalability, performance, and security across its infrastructure. By leveraging Compute & Serverless, Data & Storage, Networking & Delivery, and Security & Compliance solutions, Fluent ensures a reliable and efficient cloud environment.- Google Cloud Platform components used by Fluent fall into the Compute & Serverless, Data & Storage, Networking & Delivery, and Security & Compliance categories
- Compute & Serverless: Run workloads with virtual machines (GCE), Kubernetes (GKE), and event-driven functions (Cloud Functions).
- Data & Storage: Store and analyze data with Cloud Storage, BigQuery, Cloud SQL, and Cloud Spanner.
- Networking & Delivery: Speed up content with Cloud CDN and balance traffic efficiently with Cloud Load Balancer.
- Security & Compliance: Protect workloads with IAM, Cloud KMS, Secret Manager, and Audit Logs.
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.
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.
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.
Client Scenario: Building a Product Availability Map
Essential knowledgeThis lesson introduces a practical client scenario: visualizing product availability on a map. Building upon the foundation laid in the UX Framework course, we'll enhance the Fluent Store app's Product Availability screen by adding a map that displays nearby store locations and stock information for a selected product variant. This hands-on lab will guide you through configuring the product lookup and detail availability pages, setting the stage for creating custom components in subsequent lessons.- Client Need: The client requires a visual representation of product availability in nearby stores, which would enable staff to locate items quickly for customers.
- Map Functionality: The map should be integrated into the Product Availability details screen. It should display pins for the 10 closest stores with stock and show store details (name, product reference, available stock) when a pin is clicked. The map's appearance and behavior should be configurable via the manifest.
- Product Lookup Configuration: This involves adding a new page to the Fluent Store app, using a List Component to display product variants, configuring list filters, and creating hyperlinks to product details pages.
- Detail Availability Page Configuration: This includes creating a new page, linking it from the Product Lookup page, and adding card components to display product details and images. A List Component will show data from the search VirtualInventory query.
- Hands-on Lab Focus: The lab simulates a real-world scenario where a customer seeks a specific shoe size, requiring a store associate to check nearby store inventory. This exercise will prepare you for creating custom components in the following lessons to realize the client's vision fully.
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.
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.
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.
Support & Operations Activities
Essential knowledgeThis lesson covers key operational activities in Fluent Commerce, including Plugin Management, Workflow Versioning, and Audit Events. You’ll learn how to manage Fluent plugins, version workflows, and utilize audit events to debug and analyze processes within the Fluent platform.- Plugin Management: Upload, activate, and manage plugin versions via Plugin API.
- Workflow Versions: Submit, view, and retrieve versions for effective workflow management.
- Event Categories: Includes snapshots, rulesets, rules, actions, and exceptions.
- Event Viewing: Access audit data via Event API, Event Search, or Fluent OMS Activity tab.
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.
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.
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.
Using the anyMatch Template
Essential knowledgeThe Mystique manifest configures icons, cards, and templates. Templates can be structured in various ways; for further details, please consult the UX Configuration Common Concepts article. This article, however, will specifically concentrate on the any Match template. This template functions as a filter for a stream (such as a list of items), capable of matching none, some, or all records where a specific condition is met by a field path. This feature is particularly valuable for filtering purposes.- The anyMatch template is used for performing conditional checks on structured data streams (i.e lists, arrays), typically JSON. The template requires three inputs parameters:
`STRING_PATH_TO_VARIABLE`, `VALUE` and `OPTIONAL_FUNCTION .` - This template checks if a specific path within your data structure matches a given value.
- The anyMatch template also supports optional functions to perform different kinds of comparisons. The optional functions will compare the specified path to the value and return results if there is a match.
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.
APIs Overview
Essential knowledgeFluent provides both REST and GraphQL APIs. However, REST APIs are limited to specific Platform operations, while the GraphQL API provides the core Domain Model.- Common Authentication Token: Both Platform REST and Domain GraphQL APIs utilize a shared authentication token, ensuring a unified authentication approach.
- Platform REST APIs: Various Platform-level APIs, including Event, Workflow, Job, Plugin, and User Action APIs, are implemented in REST format with version 4.1.
- GraphQL API Advantages: The actively supported GraphQL API offers significant benefits over REST, while deprecated Domain-based REST APIs are in maintenance mode for existing clients, with documentation available for reference.
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.
Multi-factor authentication (MFA)
Essential knowledgeMulti-factor authentication (MFA) is used to ensure that digital users provide at least two pieces of evidence to prove their identity. Each piece of evidence must come from a different category, something they know, have, or something they are.Traditionally, authentication mechanisms or factors have been categorized as belonging to one of three groups:- Something you know (for example, a password or a PIN).
- Something you have (for example, a mobile phone or a token).
- Something you are (for example, a fingerprint or other biometric data).
In best practice, though, MFA goes beyond 2FA by requiring a user to authenticate via two or more authentication factors from different categories (e.g., a “something you know” combined with a “something you have”). The goal of having two or more authentication factors from different categories is to reduce the likelihood of an impostor gaining access.- MFA Categories: OTP, delivered through various means, offer time-limited codes effective against online attacks.
- OTP Options: SMS, Voice, Email, and Application/Soft Tokens provide versatile MFA choices.
- Authentication Methods: Mobile Apps, Authentication App (TOTP), Email, and SMS come with specified security settings for password limits, block duration, and passcode refresh.
Domain Model
Essential knowledgeFluent's Order Management domain oversees the entire order process, including entities like Order, Fulfillment, and Return Order. Billing Management handles financial operations, while Global Inventory aggregates product inventory. The Foundation domain configures setups, and Store Fulfillment manages order fulfillment through the Wave entity. Security governs users and permissions, Shipping records shipping details, and the Product Availability domain ensures real-time product availability. Fulfillment Option and Fulfillment Plan provide flexibility in order fulfillment strategies.- Order Management: Comprehensive system for handling orders, from creation to fulfillment and returns.
- Billing Management: Orchestrates billing operations and manages invoices, credit/debit memos, payments, and ERP integrations.
- Foundation Domain: Sets up Fluent Commerce app ecosystem, including Account, Retailer, Activity, and defines locations and networks.
- Store Fulfillment: Crucial for retailers, utilizes the Wave entity for grouping and monitoring orders.
- Shipping & Product Availability: Records shipping details offer real-time product availability considering custom attributes.
- Security Domain: Governs users, roles, and permissions across the Fluent platform.
Fluent Connect SDK Architecture
Essential knowledgeThis article will cover the high-level design and features of the SDK.- The Connect SDK architecture consists of core, cloud, and additional libraries, enabling the building and extension of connectors.
- Key features include configurations, a secret manager for sensitive information, a scheduler for periodic operations, listeners/subscribers, web services/webhooks, an event log, product availability options, and SDK handlers for custom business logic.
- The message lifecycle follows a specific flow, and there are two integration approaches: Pull and Push. The SDK offers patterns for scheduled operations and receiving external requests, and it includes dead letter queues, metrics, and logs for monitoring and observability.
- Build and deployment use SpringBoot, generating a deployable JAR with an embedded Tomcat.
