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 425 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 7 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 77 days ago

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 332 days ago

Core Module 2.2.0 - Consistent Utilities for Sourcing and JSON Management

Edited 306 days ago

Core Module 2.2.1 - Improved Webhook Execution Reliability

Edited 230 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 46 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 130 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 130 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 258 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 5 days ago

Event Utilities

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 753 days ago

Improving the way you can monitor failures

Edited 784 days ago

Fixed Retailer Updates

Edited 496 days ago

Utility Bundles Overview

Edited 346 days ago

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

Future Inventory - Data Model and API Overview

Edited 67 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 102 days ago

Create Custom Sourcing Criterion

Edited 102 days ago

Getting Started with Metrics API

Edited 768 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 304 days ago

Getting Started with Reference Sourcing Criteria

Edited 49 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 595 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 Core Utilities work

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 748 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 Conditions work

Edited 305 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 305 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 313 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 784 days ago

Identify Inventory Failed Events

Edited 864 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 332 days ago

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

Edited 231 days ago

Inventory Module 2.3.0 - Capture Richer Inventory Quantity Data

Edited 63 days ago

JSON Utilities

Edited 364 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 768 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 704 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 301 days ago

Order Module 2.0.1 - Utilities Fixes

Edited 265 days ago

Order Module 2.1.0 - Consistent State Transitions in Order Workflows

Edited 231 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 749 days ago

Platform Security Updates - May 2026

Edited 63 days ago

Platform Security Updates - August 2025

Edited 307 days ago

Platform Security Updates - November 2025

Edited 259 days ago

Platform Security Updates - October 2025

Edited 284 days ago

Product GraphQL API Overview

Edited 410 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 231 days ago

Setting Up Region-Specific Sourcing Logic

Edited 287 days ago

Setting Up Country-Specific Sourcing Logic

Edited 287 days ago

Setting Up Customer-Specific Sourcing Logic

Edited 287 days ago

Responsive Sourcing Framework Overview

Edited 297 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

Edited 623 days ago

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

Edited 503 days ago

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

Edited 598 days ago

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

Edited 596 days ago

Improving Integration and fixes for Orders and Payments

Edited 742 days ago

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 75 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 67 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 67 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.

Test Utilities Overview

Edited 347 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 643 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