Home
Design concepts
Learn about HCL Link services, projects, flows, maps and schemas.
Flows
A HCL Link flow is a transactional data flow comprised of processing nodes.
Introduction to Flows
This documentation describes how Flows can be run from REST API, listeners, or they can be scheduled.
Nodes
Cache Read and Write Nodes
Cache Read and Cache Write node functionality is described in this section.
Cache Read
The Cache Read node reads key/value pairs from the global cache, or from the flow variables. Optionally, it can delete keys and read from the cache.
Settings
This documentation describes the settings available for the Cache Read Node.
Data Format
The format of the incoming input and output data.
JSON data format
JSON array and JSON object formats are described in this documentation.

Design concepts
Learn about HCL Link services, projects, flows, maps and schemas.
- Introduction
  The documentation provided here defiens the main artifacts in HCL Link. It is necessar to understand what these artifacts are and the relationship between them.
- Services
  Service definitions define REST services and the endpoints of a service.
- Projects
  A project is a container for HCL Link artifacts.
- Flows
  A HCL Link flow is a transactional data flow comprised of processing nodes.
  - Introduction to Flows
    This documentation describes how Flows can be run from REST API, listeners, or they can be scheduled.
    - Nodes
      - Map Node
        A Map Node invokes an HCL Link map within a flow.
      - Flow Node
        A Flow node invokes a sub-flow within a flow.
      - Source and Target Nodes
        Source and Target Nodes provide HCL Link with an outside-in approach to developing integrations.
      - Request Node
        The Request Node has a single input request terminal and a single output response terminal.
      - Cache Read and Write Nodes
        Cache Read and Cache Write node functionality is described in this section.
        Configuring Cache Read and Cache Write nodes
        Detailed description of how to configure the Cache Read Node and the Cache Write Node.
        Cache Read
        The Cache Read node reads key/value pairs from the global cache, or from the flow variables. Optionally, it can delete keys and read from the cache.
        Settings
        This documentation describes the settings available for the Cache Read Node.
        Cache Scope
        Determines whether to read values from flow variables, or from the Cache.
        Data Format
        The format of the incoming input and output data.
        JSON data format
        JSON array and JSON object formats are described in this documentation.
        Delimited data format
        The data sent to the input terminal is delimited according to the Record Delimiter properties.
        Key Delimiter
        The Key Delimiter is enabled when the Data Format is Delimited.
        Record Delimiter
        The Record Delimiter is enabled when Data Format is Delimited.
        Include Key
        The Include Key is enabled when the Data Format is Delimited.
        Key Prefix
        Prefix the key values with this value. This property can include flow variables.
        Delete Key
        Determines whether or not to delete the matched keys from the cache after reading the value.
        Node Logging
        When executed the node reports the property values and matched keys into the log.
        Cache Write Node
        The Cache Write Node writes key/value pairs to the global cache, or to the flow variables based on the scope property
      - Clone Node
        The Clone Node has one input and two output terminals.
      - Decision Node
        The Decision Node routes input data to the true, or false terminals depending upon the condition.
      - Fail Node
        The Fail Node causes the flow execution to fail.
      - Format Converter Node
        The Format Converter Node can be used to quickly convert data from one format to another.
      - JSON Read Node
        This documentation describes the function and use of the JSON Read Node.
      - JSON Transform Node
        The JSON Transform node is used to transform JSON documents from one form to another.
      - Java Node
        The Java Node invokes a Java class, thus performing user defined functionality based on the properties specified for the Java class to act on the input.
      - Join Node
        The Join Node gathers the individual results and appends to a single output file or terminal.
      - Log Node
        The Log Node logs the raw data from the node input into the file and propagates the data from the input to the output terminal.
      - Passthrough Node
        The Passthrough Node propagates data from the input to the output terminal.
      - REST Client Node
        The REST Client Node provides a simple and powerful way to access REST services.
      - Route Node
        The Route Node provides a way to route data conditionally to one or more outputs of the node. The node bases decisions by evaluating a condition for a flow variable and determining whether to send the data to output 1 or 2 or both, based on the result of the condition.
      - Sleep Node
        The Sleep Node suspends the execution of the flow for the specified number of milliseconds
      - Split Node
        A Split Node should be used when there is a need to split CSV data processing. This might occur when CSV data processing becomes excessively time consuming.
    - Terminals
    - Flow terminals
      Flow terminals represent the inputs and outputs to a flow. Every node has input and/or ouptut terminals.
    - Scheduled flows
      This documentation describes the options for defining the flow schedule.
    - Listener
      A Flow that has a Map node as its first node, and uses a File adapter for an input, can enable that node's input to be a Watch.
    - Flow audits
      Flow audits are a way to retrieve more verbose information about a flow instance.
    - Flow variables
      Flow Variables are process data variables that go along with the flow execution, accessible to all nodes in the flow while it is being executed under flow executor/engine context.
    - Create a flow
      Steps required to create a flow.
    - Running flows in the Designer
      When you develop a flow in the Flow Designer you can run the flow directly from the Designer either in Link, or on a different runtime environment.
- Maps
  A HCL Link map defines how to generate data that complies to a specific schema. A map can have any number of inputs and outputs.
- Schemas
  Schemas specify the format of data witin HCL Link maps and flows.
- Connections and Actions
  This documentation describes connections and actions.
- Files
  Files are used in various places within HCL Link. HCL Link allows files to be uploaded to the HCL Linkserver.
- Flow variables
  Flow variables provide a means of passing information throughout a flow instance without requiring that the information to be passed through data links. flow variables are name-value pairs that persist, unless deleted.
- Cache variables
  Cache variables provide a means of processing information throughout a flow instance without requiring that the information to be passed through data links.

JSON data format

JSON array and JSON object formats are described in this documentation.

JSON Array

If an array, each object in the array must have a key named key:

[
  {"key": "MyKey1"},
  {"key": "MyKey2"}
]

The matched terminal produces an array of JSON objects with key and value keys:

[
   {"key": "MyKey1", "value": "MyVal1"},
   {"key": "MyKey2", "value": "MyVal2"}

The unmatched terminal produces an array of JSON objects with a single key named key:

[
  {"key": "MyKey1"},
  {"key": "MyKey2"}
]

If there are no results on matched or unmatched terminals, an empty array will be returned.

JSON Object

If a JSON object is sent to the input terminal the names of the fields of the object specify which keys to lookup in the cache. The value of the keys is irrelevant and can be null, or any other value:

{
   "MyKey1": null,
   "MyKey2": 1
}

The matched terminal will populate the values of the fields:

{
   "MyKey1": "MyVal1",
   "MyKey2": "MyVal2"
}

The unmatched terminal will provide an object that has fields with null values:

{
   "MyKey1": null,
   "MyKey2": null
}

If there are no results on matched or unmatched terminals, an empty object will be returned.