The Processor module is responsible for generating and executing functions to compute API output from API input.

Processors

Process input

The role of the processor is to compute the output variables of an api call based on the input variables. Such a computation is made using the run/2 function:

{:ok, %{output: state.output, input: state.input}} = Processor.run(processor, input)

Build a processor

A processor is an in memory function, compiled from a description called "Blueprint". The procedure to obtain a blueprint is described in the "Blueprint edition" and "Blueprint export/import" sections below.

The compilation from a blueprint to a processor is made using the Processor.compile_blueprint/1 function:

{:ok, processor} = Processor.compile_blueprint(blueprint)

Blueprint

A blueprint is an ecto model living in the database and attached to a workspace. It has the following composition:

       _ Blueprint _
      |             |
    0..n           0..n
      |             |
Variables         Deductions
(input, output      |
intermediate)      0..n
                    |
                _ Branches _
               |            |
              0..n         1..n
               |            |
          Condition    Assignment
               |            |
               1            1
               |            |
          Expession    Expression

variables

Variables describe the values the processor can receive (input), return (output) or compute as intermediary values. They are attached to a type, a position in the input or output and some other properties like optional/required.

deductions

Deductions are descriptions of how intermediary and output variables should be computed. They are built as tables whose columns correspond to the involved variables (assigned one or ones playing role in conditions) and the rows to subsidiary conditions/assignement branches (if the conditions of the first branch are not met, the second branch is tested, and so on).

branches

A (possibly empty) set of conditions on certain variables linked with an assignation to other (or same) variables.

condition

An expression describing when the condition is met based on it's column's variable.

assignment

An expression describing the value the column's variable should take in case the branch conditions are met.

expression

Either a constant, a variable or a function involving other expressions that can be computed based on the current variables state. Condition expressions return nullable booleans, assignment expression return a nullable value of the type of the column's variable.

Blueprint manipulation

Creation and import

Blueprints can be created using the create_blueprint/2 function. This function requires you to provide attributes for the blueprint.

Update to the blueprint such as modifying name or description can be made using the update_blueprint/2 function.

Populating a whole blueprint can done by importing a blueprint from a .json file definition. This is done using the update_blueprint_from_file/2 function.

Manipulation

A set of functions allow you to directly load and update variables and deductions.

Schemas

Below, the ecto schemas available in the Processor module.

Assignment

A variable assignment in the branch of a bluprint deduction.

AstType

Ecto type for AST serialization to the database.

Allows to store tuples as JSON.

BindingElement

An expression binding element.

Binding

An expression binding.

Blueprint

A blueprint describing a full processor.

Branch

A deduction branch.

Column

A deduction column (a structuration feature that has no effect when the processor runs on an input.)

Condition

A condition in a branch.

Deduction

A blueprint deduction.

Expression

Expressions can be found in conditions, assignments or variable default values.

ListType

Ecto type to allow storing a list in a json field.

Variable

A blueprint variable.