Kirill Gaiduk

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

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:

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

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 243 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 61 days ago

Core Module 2.2.0 - Consistent Utilities for Sourcing and JSON Management

Edited 35 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.

Prerequisites

These articles assumes you're familiar with:

Java
Maven
JUnit

Create Comment

The `createComment` Mutation allows the creation of a Comment against a known Entity.

Prerequisites

Specific Permissions are required for creating Comments:

`COMMENT_CREATE`
`COMMENT_VIEW`

Create or Update Sourcing Profile

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

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

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

Prerequisites

These articles assumes you're familiar with:

Java
Maven
JUnit

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

Improving the way you can monitor failures

Edited 513 days ago

Fixed Retailer Updates

Edited 225 days ago

Utility Bundles Overview

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

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

Create Custom Sourcing Criterion

Edited 33 days ago

Getting Started with Metrics API

Edited 497 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 33 days ago

Getting Started with Reference Sourcing Criteria

Edited 33 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 324 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.

Prerequisites

Before 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

This document is intended to describe to implementers Metrics technical details within the Fluent Big Inventory product.

The articles below will walk you through the Dynamic Utilities (`dynamic-core`), designed to simplify rule development and reduce repetitive code.

Prerequisites

Before 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 477 days ago

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 34 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 34 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 42 days ago

The Sourcing Profile GraphQL API allows technical users to manage sourcing logic within the Fluent platform.

Prerequisites

You 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 513 days ago

Identify Inventory Failed Events

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

Inventory Module 2.2.0: Expanded Inventory Types & Simplified Configuration

Edited 61 days ago

JSON Utilities

Edited 93 days ago

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.

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 497 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 433 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 30 days ago

Order Module 2.0.1 - Utilities Fixes

Edited 26 days ago

Enhanced Order Lookup and Tagging Capabilities

Platform Observability with Metrics

Edited 478 days ago

Platform Security Updates - August 2025

Edited 36 days ago

Platform Security Updates - October 2025

Edited 13 days ago

Product GraphQL API Overview

Edited 139 days ago

This article is intended to provide technical users with information about the Product GraphQL API, describing its functionalities within the Fluent Platform.

Prerequisites

You should have knowledge of:

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.

Setting Up Region-Specific Sourcing Logic

Edited 16 days ago

Setting Up Country-Specific Sourcing Logic

Edited 16 days ago

Setting Up Customer-Specific Sourcing Logic

Edited 16 days ago

Responsive Sourcing Framework Overview

Edited 26 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 352 days ago

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

Edited 232 days ago

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

Edited 327 days ago

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

Edited 325 days ago

Improving Integration and fixes for Orders and Payments

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

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.

Test Utilities Overview

Edited 76 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.

Prerequisites

These articles assumes you're familiar with:

Java
Maven
JUnit

Improving Search, Filtering, and Aggregations across the Inventory Domain

Edited 372 days ago

Update Comment

The `updateComment` Mutation allows for the updating of an existing Comment object.

Prerequisites

Specific Permissions are required for updating Comments:

`COMMENT_UPDATE`
`COMMENT_VIEW`

Workflow Executor