Kirill Gaiduk

The Core Utilities is a standard library of utility functions for simplifying Rule development.

Prerequisites

These articles assumes you're familiar with:

Java
Maven
JUnit

Create Comment

`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

automatically derives the correct update Mutation for the primary Entity based on the

`DynamicUpdateMutation`

`RulesetContext`

and then performs the update on one or more fields.

Dynamic Pagination

automatically derives the Connection fields (arrays) for the primary Entity based on the

`DynamicConnectionQuery`

`RulesetContext`

and can dynamically load all connection items, with pagination handled internally.

Dynamic Queries

automatically derives the correct Query operation for the primary Entity from the

`DynamicEntityQuery`

`RulesetContext`

, allowing it to dynamically retrieve fields related to that Entity.

Typically, the appropriate GraphQL query to fetch data is selected based on the Entity type within

`RulesetContext`

, though a certain Query can be specified if preferred.

Dynamic Utilities Overview

The Dynamic Utilities is a collection of utility functions to allow Queries and Mutations to be generated at runtime.

Prerequisites

These articles assumes you're familiar with:

Java
Maven
JUnit

Event Utilities

helps to eliminate unnecessary boilerplate code when propagating new Events and handles common error scenarios, such as:

`EventUtils`

Forgetting to copy Event attributes
Or improperly handling schedules

It simplifies Event forwarding and ensures consistency by automatically managing critical tasks like:

Attribute retention
And the conversion of scheduled Events when needed

Prerequisites

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

Get Comment by Id

`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 267 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 the Fluent Utility Bundles

Edited 114 days ago

GraphQL Date Utilities

provides a bunch of functions for working with Date data, which is often used in:

`GqlDateUtils`

Event attributes
Entity attributes

These utilities facilitate exploring and converting Date data into usable formats and vice versa, making dates manipulations more accessible and efficient in Rule development.

How Comment GraphQL API works

Edited 94 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 library of utility functions, and that, in turn, will help you become a more productive and successful developer on the Fluent Commerce platform.

Prerequisites

You should have knowledge of the Fluent Utility Bundles
You should complete the Getting Started with the Fluent Utility Bundles Guide

What are Dynamic Utilities and how do they work?

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

In the articles below, you'll learn how to make use of Dynamic Utilities to take advantage of runtime-generated Queries and Mutations to build more flexible, cross-domain Rules.

Prerequisites

You should have knowledge of the Fluent Utility Bundles
You should complete the Getting Started with the Fluent Utility Bundles Guide

How Metrics works

Edited 247 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 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 283 days ago

Identify Inventory Failed Events

Edited 363 days ago

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

Edited 255 days ago

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

Edited 132 days ago

Optimize your Inventory Workflows with Inventory Reference Module 2.1.0

Edited 140 days ago

Inventory Module 2.2.0: Expanded Inventory Types & Simplified Configuration

Edited 23 days ago

JSON Utilities

provides a collection of functions for working with JSON data, which is often found in:

`JsonUtils`

Event attributes
Entity attributes
And Settings values

These utilities facilitate exploring and converting raw JSON into usable formats, making JSON manipulation more accessible and efficient in Rule development.

Log Utilities

removes boilerplate code around using Logging Actions within Rules.

`LogUtils`

This simplifies logging, making it more efficient to record without repetitive code:

Key actions
Errors
Or checkpoints

Metrics usage for Platform Observability

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

is designed to manually create a mocked API Client that the Rules under test use to make queries.

The

`MockApiClient`

Metrics Overview

Edited 203 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 7 days ago

Platform Observability with Metrics

Edited 248 days ago

Query Comments

`comments`

Query retrieves Comments based on various filter criteria.

Prerequisites

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

Query Utilities

offers a set of functions to simplify content querying from Rules.

`QueryUtils`

It includes:

Support for handling generic response types
And managing connection types as streamable collections

Making it easier to work with Query results and integrate them smoothly into Rules.

Rule Context Generator

The

`RuleContextGenerator`

accepts a mocked API instance and an optional

`Event`

It then allows you to generate

`Context`

objects for specific

`RuleInstances`

, enabling you to:

Populate Rule properties
And perform targeted testing

Rule Executor

is a utility that simulates Rule execution. It:

The

`RuleExecutor`

Provides an easy way to mock GraphQL queries and manage inputs with sensible defaults
Allows simple mocking of GraphQL query responses and access to any actions produced during execution for assertions

Rule Utilities

provides helper functions to streamline the process of retrieving and validating Rule parameters.

`RuleUtils`

These Utilities help to:

Ensure that Rules are correctly configured
And avoid common errors related to missing or incorrect parameters

Setting Utilities

enables loading Settings from a Fluent Account while respecting the context hierarchy.

`SettingUtils`

This means that higher-level Settings (such as Account-level Settings) will automatically be returned if the lower level Settings (like Retailer-level or Location-level Settings) are not present.

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

Edited 122 days ago

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

Edited 2 days ago

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

Edited 97 days ago

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

Edited 95 days ago

Improving Integration and fixes for Orders and Payments

Edited 241 days ago

Test Utilities Overview

The Test Utilities is a collection of utility functions that provides a series of helpers and mocks designed to minimize the overhead of Rules testing.

Prerequisites

These articles assumes you're familiar with:

Java
Maven
JUnit

Improving Search, Filtering, and Aggregations across the Inventory Domain

Edited 142 days ago

Update Comment

`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