Introduction to Fluent OMS

Get Started
Functionality
Learning
Extension
Dev Tooling
APIs
Releases

Essential knowledge

Changed on:

28 Oct 2024

Overview

Haha sike

Key points

Nothing

What is Fluent Commerce OMS?

Fluent Commerce Order Management System (OMS) is an event-driven system consisting of two key domains: the front-end Order Management Experience (OMX) Framework and the back-end Workflow Framework. The front-end OMX Framework is made up of:

The OMX UX Framework (`Mystique`) is not an 'app' in itself but is a framework that allows developers to customize apps through a human-readable JSON file known as a Manifest. This framework offers a Component Library of ready-to-use React components that can be referenced in the Manifest to assemble Fluent's web applications. The Component SDK enables users to extend these components and develop new ones.
The OMS Web Application is a higher-level back-office tool for managing store data and viewing information such as orders, inventory, and store locations, amongst other datasets. It contains tools that enable the user to edit and change settings of the web applications on the administrator level.
The Store Web Application is the in-store tool for managing processes such as Pick and Pack, courier bookings and collections, and customer returns.

The back-end Workflow Framework utilizes three APIs and the Orchestration Engine:

The OMX Orchestration Engine (`Rubix`) executes business logic by loading workflows and triggering rulesets. Fluent provides a Rule Library containing predefined rules that can be used out of the box. Custom rulesets can be built using the Rules SDK. Orchestration utilizes a web-hook connector (Connect SDK) to allow the platform to integrate with third-party systems.
REST API is used for user authentication (sign-in and SSO), batch-loading data (in cases of inventory processing or creating new accounts and retailers), and workflow processing (which requires specific validation logic that has yet to be ported to GraphQL).
GraphQL API is the current API used by Fluent to handle all data retrieval and storage.
The Event API retrieves event logs. Events can be triggers for workflow logic (Orchestration Events), information about how an Orchestration event was processed (Orchestration Audits), or log-style content from other system components.

Fluent also offers Modules, a group of Artifacts bundled together to achieve a domain functionality. Artifacts can be built by:

The Rule SDK (Rules) and Component SDK (UI Components)
The Workflow Engine (Workflows)
The UX Builder (Web App Manifests)

Artifacts also include Settings.

Understanding the OMX UX Framework

The OMS UX Framework allows users to customize Fluent's web applications and enables the application's UI to change automatically according to workflow alterations. All web application alterations and customization are done through the use of Manifests.Role and User contexts allow for restriction of platform access and functionalities, which can be regulated through custom roles to ensure users only have access to appropriate data. Roles at different context levels (such as Accounts, Retailers, and Locations) can be given different scopes.

Manifests and Configuring Fluent OMS Web Applications

Manifests are JSON files that describe the UI configuration for a Fluent Web Application. They define navigation, screen layouts, data sources (queries), and user actions. These files act as a communication medium between the OMX UX Framework and the Orchestration Engine. Fragments are also JSON files, but rather than settings, they define the structure of individual pages by identifying what components should be included.

Components and The Component SDK

(insert some stuff explaining what a component is) The Component SDK allows developers to create new custom components to extend the standard library. Components are generic React components, but they can also be tailored to utilize key features of the OMX UX Framework. These features include:

being configurable via the manifest (which means no-code updates to apps)
fetching and displaying data from the Fluent APIs
internationalization of any text labels based on the user profile
auto-adapting to workflows (generating new user action forms when the workflow changes)
showing and hiding content based on the logged-in user's roles and permissions

Understanding the Workflow Framework

The Workflow Framework runs Fluent OMS. It specifies application behavior via a JSON Manifest by triggering workflows. Workflows execute rulesets, which are groups of configured rules. This allows business logic, code, and middleware to be moved out of the platform API and into workflows.

REST, GraphQL, and Event APIs

(is this necessary?)

The OMX Orchestration Engine

Orchestration, built on Apache Karaf, is the main component of the Workflow Framework. It runs workflows, which are event-based triggers for rulesets, to handle everything from calculating how orders should be fulfilled to booking couriers. Workflows are low-code 'instructions' for how Fluent OMS should react to system-generated events. Events are produced when user actions or integrations create a new entity.When an event is produced, Orchestration loads the correct workflow and finds any rulesets set to be triggered by that event. All rulesets are then run in sequence. Workflows do not interact directly with the data stores but instead use the public APIs to load and update data.Clients can create custom workflows and rulesets using the Workflow Builder with the provided Rules Library. Custom rule plugins are developed using the Rules SDK.

Rules and The Rules SDK

The Rules SDK allows developers to build custom plugins with rules for the Workflow Framework Rule Library. Rule plugins are written in Java, and the SDK comes with a Java API Client for REST and GraphQL APIs so that any custom rules can be easily integrated with the platform.

The Connect SDK

The Connect SDK is a launchpad connecting any external system with Fluent OMS. It is a Java Maven Archetype and Java Library Utils toolkit used to build Spring Boot micro-service applications. Any connectors built using Connect SDK are cloud-agnostic. The solution integrator maintains and owns the integration layer, which will become part of the project's code base.

Understanding Application Modules

A Module is a 'bundle' containing any combination of Artifacts. However, every Module must contain Metadata. The Artifacts in a Module should provide a single package of domain capability or a reference to create or extend domain capability. Modules work together and extend each other.There are two categories of Modules: Reference Modules and Extensions.

Reference Modules are designed to provide reference artifacts that can be used to create custom domain solutions.
Extensions are Modules designed to provide a complete feature or features that solve domain problems.

------------------------------------extra notes and stuff that i haven't edited------------------------------------I wanna sleep :3