Kirill Gaiduk

Fluent Commerce

I authored

articles. I write about:

Out-of-the-box features

Other resources

GraphQL

Increase speed-to-market

Rule performance

Rule SDK

Utility bundle

Boiler plates and reference modules

Developer tooling

Enterprise Inventory Availability (GI)

GraphQL query

Inventory monitoring

API

Modules

Inventory management lifecycle

GraphQL mutation

Customer Service

Monitor and alert

Rule

Inventory processing

Intelligent Inventory Processing

Fluent Big Inventory

Workflow

Event

Order customer service

Inventory position

Core API

Availability management

Retailer

Inventory catalog

SKU / Variant product

Standard product

Available to Promise (ATP) Feeds

Decision logic / Orchestration

Testing

Virtual inventory catalog

Virtual inventory position

Inventory quantity

Group product

Ruleset

Inventory event processing

UX framework

Event API

Platform flexibility

Implementation

Mutation

Product catalog

Rule plugin

Inventory controls

Support and maintain

Authentication API

Entities

Status

Returns Management

Fragments (functional components)

Return flow

Location

Log

Batch processing

Object attributes

Fluent Distributed Order Management

Order management lifecycle

Roles and Permissions

User management

API recommendations

Batch API

Variables

Action

Webhook

UI Component SDK

Reference Apps

Component

Template

Ready for launch process

Configuration manifest

Promising

Iterate the solution

Trigger

Contracts

Product category

Order entity

Product entities

Promise Sourcing

Order Sourcing

Building blocks

Sourcing

Order Workflows

Workflow Settings

Network

Active user

EntityType and Subtype

Account

Setting

Integrate

Payment Processing

Order Orchestration

Payment processing

Fulfillment

Return entity

Billing account

Payment transaction entity

Docs I have written

API Error Codes

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

Edited 143 days ago

Configure Bulk Threshold Controls to manage Inventory and Virtual Positions Statuses

Edited 124 days ago

Configure JsonPath Property for Event attributes with Core Reference Module 1.2.6

Edited 197 days ago

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 the most common challenges and repetitive tasks developers face.

Prerequisites

These articles assumes you're familiar with:

Java
Maven
JUnit

Create Comment

Edited 132 days ago

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

Dynamic Mutations

Edited 8 days ago

`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

Edited 8 days ago

`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

Edited 8 days ago

`DynamicEntityQuery`

automatically derives the correct GraphQL query operation for the primary Entity from the

`RulesetContext`

, allowing it to dynamically retrieve fields related to that Entity. This eliminates the need for pre-compiled queries while maintaining type safety and performance.

Dynamic Utilities Overview

Edited 2 days ago

The

`util-dynamic`

library is a collection of powerful 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

Edited 8 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 363 days ago

Improving the way you can monitor failures

Edited 394 days ago

Fixed Retailer Updates

Edited 106 days ago

Fluent Commerce Utility Bundles: An Overview

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

Edited 5 days ago

Prerequisites

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

Get Comment by Id

Edited 132 days ago

The

`commentById`

Query retrieves a Comment based on a provided Id.

Prerequisites

```
`COMMENT_VIEW`
```
Permission is required for retrieving a Comment

Getting Started with Metrics API

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

GraphQL Date Utilities

Edited 8 days ago

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 205 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

Edited 13 days ago

The articles below will walk you through the Core Utilities (

`util-core`

), designed to simplify rule development and reduce repetitive code. Understanding and applying these utilities will help you become a more productive and successful developer on the Fluent Commerce platform.

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

Edited 12 days ago

The articles below will walk you through the Dynamic Utilities (

`dynamic-core`

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 358 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 Test Utilities work

Edited 8 days ago

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

Identify Inventory Failed Events

Edited 474 days ago

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

Edited 366 days ago

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

Edited 243 days ago

Optimize your Inventory Workflows with Inventory Reference Module 2.1.0

Edited 251 days ago

Inventory Module 2.2.0: Expanded Inventory Types & Simplified Configuration

Edited 134 days ago

JSON Utilities

Edited 8 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 powerful Jackson library, these utilities simplify the conversion of raw JSON into usable 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

Edited 8 days ago

The

`LogUtils`

class in the

`util-core`

bundle provides simple, 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 378 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

Edited 8 days ago

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

Enhanced Order Lookup and Tagging Capabilities

Edited 104 days ago

Platform Observability with Metrics

Edited 359 days ago

Product GraphQL API Overview

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

Edited 132 days ago

The

`comments`

Query retrieves Comments based on various filter criteria.

Prerequisites

```
`COMMENT_VIEW`
```
Permission is required for retrieving Comments

Query Utilities

Edited 8 days ago

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.

Responsive Sourcing Framework Overview

Edited 3 days ago

The Responsive Sourcing Framework is a configurable, scalable alternative to custom Workflows and rigid Rules for managing Order fulfillment 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 in Sourcing decisions.