Kirill Gaiduk

This article explains how to interpret and act on GraphQL and REST API Error Codes to resolve issues faster.Implementing partners will learn how to:

The `activateSourcingProfile` mutation activates a specific version of a Sourcing Profile. When called, it performs the following actions:

Sets the specified version status to `ACTIVE`
Updates the previously `ACTIVE` version to `INACTIVE`

API Error Codes

Edited 450 days ago

Identify Error types
Decode Error Codes
And apply suggested solutions

This supports:

Faster debugging
Better Error handling
And improved integration reliability

The below content covers:

Error Classifications
Known examples
And guidance on when and how to self-resolve vs. escalate

Better GraphQL Pagination, Print Sorting, and Session Handling

Edited 32 days ago

Configure a Master Retailer Inventory Catalog notifying Sub-Retailer(s) Virtual Catalog(s)

Configure Bulk Threshold Controls to manage Inventory and Virtual Positions Statuses

Edited 102 days ago

Control Types

This page describes how to configure a control: the structure of the control data and the values each standard control type expects. For what each type does and how the utility resolves and applies controls, see the Controls Utilities Overview and the Detailed Technical Description on the Controls Utilities page.

Control Utils

`ControlUtils` is the entry point of the Controls Utilities bundle. This page is the API reference for applying controls to a position from a rule.For the underlying concepts (control, control group, bulk vs position-level control) see Controls Utilities Overview. For the order in which the `ControlUtils` resolves and applies controls, and the behavior of the caches, see the Detailed Technical Description on the Controls Utilities package page.

Configure JsonPath Property for Event attributes with Core Reference Module 1.2.6

Core Module 2.0.0 - Refined Rules and Reduced Log Actions

Core Module 2.1.0 - Support for Type-Agnostic Product Updates

Edited 357 days ago

Core Module 2.2.0 - Consistent Utilities for Sourcing and JSON Management

Edited 331 days ago

Core Module 2.2.1 - Improved Webhook Execution Reliability

Edited 255 days ago

Core Module 2.3.0 - Enhanced Workflow Stability and Event Reliability

Edited 14 days ago

Core Utilities Overview

The 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

Create Comment

`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.

The `createComment` Mutation allows the creation of a Comment against a known Entity.
PrerequisitesSpecific Permissions are required for creating Comments:

`COMMENT_CREATE`
`COMMENT_VIEW`

Create or Update Sourcing Profile

Edited 71 days ago

The `createSourcingProfile` mutation creates a Sourcing Profile (or its newer version, i.e., updates) for a Retailer:

If the provided `ref` is unique, it creates the first version with `ACTIVE` status
If a `SourcingProfile` with the same `ref` already exists, it creates a new version with `DRAFT` status

Dynamic Mutations

Edited 155 days ago

Dynamic Pagination

`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.

Dynamic Queries and Utils

Edited 155 days ago

`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.

Dynamic Utilities Overview

Edited 283 days ago

The `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

Enhanced Fulfillment Queries and Responsive Sourcing Platform Improvements

Edited 8 days ago

Event Utilities

Edited 14 days ago

The `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.

Configure extended address for Return Orders

Edited 778 days ago

Improving the way you can monitor failures

Edited 809 days ago

Fixed Retailer Updates

Edited 521 days ago

Fluent Commerce Utility Bundles: An Overview

Edited 435 days ago

Prerequisites

You should have knowledge of the Rules SDK, including:
You should have knowledge of the Rules SDK - Getting Started

Utility Bundles Overview

The Fluent Commerce Utility Bundles are a set of libraries designed to speed up Rule development, reduce boilerplate code, and improve the overall quality and maintainability of implementations. They are essential for writing maintainable, reusable, and easily upgradeable Rules for the Fluent Commerce platform.

Fulfillment Options Utils

Edited 43 days ago

The `FulfilmentOptionsUtils` class in the `util-sourcing` library creates `FulfilmentPlan` records for Fulfillment Options from a `SourcingPlan`. It captures the proposed fulfillment options, available quantities, and optional ETA values, helping rules present calculated sourcing outcomes without recreating fulfillment-plan mapping logic.

Future Inventory - Data Model and API Overview

Edited 92 days ago

Future Inventory extends the Inventory and Virtual Catalog data models to represent inventory that is not yet physically available but is expected to arrive at a known point in time. It enables availability and reservation decisions against future stock using explicit dates and quantities.Future Inventory supports scenarios such as pre-orders and wholesale commitments, where inventory must be promised before receipt, while preserving a single physical inventory model per product and location.This document explains the data model and GraphQL API capabilities introduced for Future Inventory.

Get Comment by Id

The `commentById` Query retrieves a Comment based on a provided Id.
Prerequisites

`COMMENT_VIEW` Permission is required for retrieving a Comment

Get Sourcing Profile

The `sourcingProfile` query retrieves a Sourcing Profile by its Reference:

If a version is provided, the query returns that specific version
If no version is provided, the query returns the latest available version

Create Custom Sourcing Condition

Edited 127 days ago

Create Custom Sourcing Criterion

Edited 127 days ago

Getting Started with Metrics API

Edited 793 days ago

This 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.

Getting Started with Reference Sourcing Conditions

Edited 329 days ago

Getting Started with Reference Sourcing Criteria

Edited 46 days ago

GraphQL Date Utilities

The `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.

How Comment GraphQL API works

Edited 620 days ago

The Comment GraphQL API enables you to Create, Update, and Query comments linked to various entities within the Fluent platform.
Prerequisites

You should have knowledge of the GraphQL API, including:
- GraphQL Operations
- GraphQL Permissions
You should have knowledge of Users, Roles, and Permissions

How Controls Utilities work

The articles walks you through the Controls Utilities bundle (`util-controls`): a library that applies controls to catalog positions from within a Rule, so that inclusion, exclusion, buffer, limit and threshold logic is resolved and applied the same way everywhere it is used.Prerequisites

Basic understanding of the Utility Bundles
Familiarity with writing Rules using the Rules SDK
Completion of the Getting Started with the Utility Bundles guide

How Core Utilities work

Edited 3 days ago

The articles below will walk you through the Core Utilities (`util-core`), designed to simplify rule development and reduce repetitive code. Each utility focuses on a specific area of functionality to make development easier and more efficient.PrerequisitesBefore diving in, make sure you have:

A basic understanding of the Utility Bundles
Familiarity with writing Rules using the Rules SDK
Completed the Getting Started with the Utility Bundles guide

How Dynamic Utilities work

The articles below will walk you through the Dynamic Utilities (`dynamic-core`), designed to simplify rule development and reduce repetitive code.PrerequisitesBefore diving in, make sure you have:

A basic understanding of the Utility Bundles and Dynamic Bundles
Familiarity with writing Rules using the Rules SDK
Completed the Getting Started with the Utility Bundles guide

How Metrics works

Edited 773 days ago

This 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.

How Sourcing Auditability Works

Edited 7 days ago

Sourcing Auditability gives you an immutable record of every sourcing decision. These articles explain how the audit model captures the sourcing profile and version applied, each strategy considered, the pass or fail result of every condition, and per-location criteria scores and positions, so you can compare any considered location against the one selected. Implementing partners gain a faster way to test, debug and validate sourcing logic; businesses gain the traceability their operations, support, analytics and compliance teams need. Applies to the Responsive Sourcing Framework only.

How Sourcing Conditions work

Edited 330 days ago

This article introduces Sourcing Conditions as the mechanism that evaluates Sourcing Requests and returns outcomes used in Strategy selection. Readers will learn how reference schema, operators, and parameters shape these evaluations, and how custom schema can extend them.

How Sourcing Criteria work

Edited 330 days ago

This article introduces Sourcing Criteria as the ranking (and exclusion) functions that score candidate Locations during Strategy evaluation. You’ll learn how Criteria order affects final rankings, which reference Criteria are available, and how to extend the library with custom implementations.

How Sourcing Profile GraphQL API works

Edited 338 days ago

The Sourcing Profile GraphQL API allows technical users to manage sourcing logic within the Fluent platform.
PrerequisitesYou should have knowledge of:

GraphQL API, including GraphQL Operations and GraphQL Permissions
Responsive Sourcing Framework
Order Reference Module

How Test Utilities work

The articles below will walk you through the library of utility functions designed to simplify Rules testing. It provides methods to interact with Rules in isolation, making it easier to test various scenarios. These Utilities are commonly used in conjunction with JUnit.
Prerequisites

You should have knowledge of the Fluent Utility Bundles
You should complete the Getting Started with the Fluent Utility Bundles Guide
You should have knowledge of How Core Utilities work
You should have knowledge of How Dynamic Utilities work

Improving API, UI, and fixes for the Inventory and Availability

Edited 809 days ago

Identify Inventory Failed Events

Edited 889 days ago

Speed up your configuration and keep your Inventory Positions up-to-date with Inventory Reference Module 1.3.0

Introducing new Reference Statuses: manage Inventory proactively to minimize stockouts with Inventory Reference Module 2.0.0

Optimize your Inventory Workflows with Inventory Reference Module 2.1.0

The `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.

Inventory Module 2.2.0: Expanded Inventory Types & Simplified Configuration

Edited 357 days ago

Inventory Module 2.2.3 - Consistent On-Hand Evaluation in Inventory Workflows

Edited 256 days ago

Inventory Module 2.3.0 - Capture Richer Inventory Quantity Data

Edited 88 days ago

JSON Utilities

Edited 389 days ago

Log Utilities

The `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.

Metrics usage for Platform Observability

Edited 793 days ago

This 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.

MockApiClient

The `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.

Metrics Overview

Edited 729 days ago

This 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.

Order Module 2.0.0 - Responsive Sourcing Framework in Action

Edited 326 days ago

Order Module 2.0.1 - Utilities Fixes

Edited 290 days ago

Order Module 2.1.0 - Consistent State Transitions in Order Workflows

Edited 256 days ago

Order Module 2.2.0 - Greater Sourcing Control and More Reliable Re-Sourcing

Edited 8 days ago

Enhanced Order Lookup and Tagging Capabilities

This article is intended to provide technical users with information about the Product GraphQL API, describing its functionalities within the Fluent Platform.
PrerequisitesYou should have knowledge of:

Platform Observability with Metrics

Edited 774 days ago

Platform Security Updates - May 2026

Edited 88 days ago

Platform Security Updates - August 2025

Edited 332 days ago

Platform Security Updates - November 2025

Edited 284 days ago

Platform Security Updates - October 2025

Edited 309 days ago

Prevent Duplicate Fulfillments During Concurrent Re-Sourcing

Edited 52 days ago

Product GraphQL API Overview

Edited 430 days ago

Products, Product Catalogs, and Product Management
Inventory Reference Module, including the Product Catalog Workflow Interface Contracts
GraphQL API

Query Comments

The `comments` Query retrieves Comments based on various filter criteria.
Prerequisites

`COMMENT_VIEW` Permission is required for retrieving Comments

Query Utilities

The `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.

Reliable Retailer Filtering for Fulfillment Options and Plans

Edited 256 days ago

Setting Up Region-Specific Sourcing Logic

Setting Up Country-Specific Sourcing Logic

Setting Up Customer-Specific Sourcing Logic

Responsive Sourcing Framework Overview

Edited 322 days ago

The 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.

Rule Context Generator

The `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.

Rule Executor

The `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.

Rule Utilities

The `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.

Search Sourcing Profiles

The `sourcingProfiles` query retrieves existing Sourcing Profiles. It supports multiple filters and pagination.

Setting Utilities

The `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.

Share Inventory for Master/Sub-Retailer(s) setup

Improving GraphQL APIs: fixes for Inventory Search, Products, and Comments

Edited 528 days ago

Improve your Data Security with Retailer-specific Permissions enabled for Comment GraphQL API

Edited 623 days ago

Speed up Product Search with enhanced Product Catalog filtering by Retailer Reference

Edited 621 days ago

Improving Integration and fixes for Orders and Payments

Edited 767 days ago

Sourcing Auditability GraphQL API Overview

This article provides technical users with information about the Sourcing Auditability GraphQL API, which writes and reads Sourcing Audit records within the Responsive Sourcing Framework.

Sourcing Auditability Overview

Edited 2 days ago

Sourcing Auditability records why each sourcing decision was made within the Responsive Sourcing Framework. For each Sourcing Request, it captures the evaluated inputs and outcomes in an immutable audit record.It helps teams understand:

Which Strategies and Conditions were evaluated
Which Locations were considered and how they scored against configured Criteria
Which Location(s) was selected, and why

This document explains:

What Sourcing Auditability captures
How Sourcing Audit records are stored and accessed
How they appear in the Fluent OMS Web App

Sourcing Conditions Overview

Sourcing 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.

Sourcing Criteria Overview

Edited 46 days ago

Sourcing 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.

Sourcing Profile GraphQL API Overview

This article provides technical users with information about the Sourcing Profile GraphQL API, which enables configuration and querying of Sourcing Profiles within the Fluent Platform.

Inventory Modeling Guide

Edited 92 days ago

This document explains the foundational concepts behind stock segmentation in Fluent Commerce and provides guidance on how to approach segmentation when designing inventory models.Stock segmentation is not a single feature or configuration option. It emerges from how inventory data is modeled and how stock attributes are preserved throughout the data flow from ingestion to availability calculation.The goal is to establish a shared mental model to clarify when different segmentation approaches should be considered, understand their trade-offs, and avoid common anti-patterns.

Stock Segmentation - Data Model and API Overview

Edited 92 days ago

Stock 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.

Strengthen Sourcing Decision Transparency

Edited 7 days ago

Test Utilities Overview

Edited 372 days ago

The `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

Improving Search, Filtering, and Aggregations across the Inventory Domain

Edited 668 days ago

Update Comment

The `updateComment` Mutation allows for the updating of an existing Comment object.
PrerequisitesSpecific Permissions are required for updating Comments:

`COMMENT_UPDATE`
`COMMENT_VIEW`

Workflow Executor