entities.components.title

Оператор . позволяет осуществлять доступ к элементам нашего объекта

    entities.components.schema.'$defs'.'seaf.app.sber.component_type'.enum[-1]

    entities...enum[[0..1]] - в качестве индекса массива, можно использовать диапазоны
    [0..1] - диапазон значений от 0 до 1, интервалы включены.

$[0] /* Оператор '$' - получить доступ ко всему документу */

$[0].'object 1' /*Получили плоскую структуру.*/

JSonata позволяет работать с большими входными объектами и эффективно
трансформировать в нужные нам объект.
Jsonata предоставляет возможность создания новых объектов

{
    "my-object": entities /* где entities поле существующего объекта */
}

Мы можем добавлять новые поля

{
    "my-object": entities,
    "a_new_property": "a value"
}

Создание новой структуры объекта

{
    "data": {
        "device": components,
        "when": entities
    }
}

Phone[type='office'].number /* [type='office'] - указываем предикат, для фильтрации элементов массива*/

[выражение] - если выражение возвращает true, то значение остается, если false, то значение удаляется из результирующей выборки.

Если при фильтрации элементов массива возвращается один элемент, но мы хотим в результате получить массив, то можно сделать следующееЖ

Phone[type='home'][] /*[] можно использовать префексную форму, так и постфиксную, например: Phone[][type='home']*/

    live_stage.* /* получить значения всех полей объекта live_stage */

    *.components

    **.enum

Литерал - это то что мы можем выразить односложно, например: число, строка.

Строковые литералы в jsonata создаются следующим образом: "тестовая строка" или 'тестовая строка'.

entities.components.title & ' AC'

entities.components.schema.(type & ' ' & additionalProperties)

Язык jsonata поддерживает работу с числами как и во многих других языках.
    + сложение
    - вычитание
    * умножение
    / деление
    % деление по модулю
Операции сравнения:
    = equals
    != not equals
    < less than
    <= less than or equal
    > greater than
    >= greater than or equal
    in value is contained in an array
Логические выражения:
    and
    or  

На языке jsonata можно формировать выходные объекты различного типа, например:
    - string - 'Привет Мир!'
    - number - 23.5
    - Boolean - true, false
    - null - null
    - object - {"key1": "value1"}
    - array - ["value1", value2]

Рассмотрим 2 варианта, часто встречающихся на практике:

В качестве примера возьмем простой объект

1) Создание массивов  

Email.address

Email.[address]

[property1, property2].Object

1) Создание объектов 

Phone.{type: number}

Phone{type: number}

Phone{type: number[]}

 В JSONata все является выражением.
 Выражение состоит из значений, функций и операторов, которые при вычислении дают результирующее значение.
 Функции и операторы применяются к значениям, которые сами могут быть результатами вычисления подвыражений. 
 
 При арифметических опрерациях возможно задавать приоритет с помощью круглых скобок, например:
        
        (5 + 7) * 3
 
 Для более сложных выражений можно использовать следующий подход:       
            
            Product.(Price * Quantity) - Price b Quantity являются свойствами объека Product
            
 Можно выделять в блок набор выражений разделенных точкой с запятой, например:
            (expr1; expr2; expr3) - каждое выражение в блоке вычисляется последовательно, результат последнего выражения возвращается как результат блока.

Язык предоставляет несколько способов для сортировки массивов.
    1) Использование функции $sort()
    2) order-by operator
    
Группировка данных



Account.Order.Product{`Product Name`: Price}

Result	
{
  "Bowler Hat": [ 34.45, 34.45 ],
  "Trilby hat": 21.67,
  "Cloak": 107.99
}

Account.Order.Product {
  `Product Name`: {"Price": Price, "Qty": Quantity}
}
Result	
{
  "Bowler Hat": {
    "Price": [ 34.45, 34.45 ],
    "Qty": [ 2, 4 ]
  },
  "Trilby hat": { "Price": 21.67, "Qty": 1 },
  "Cloak": { "Price": 107.99, "Qty": 1 }
}

Jsonata позволяет создавать функции

Для создании функии нужно придерживаться простых правил
    - указывать область видимисти с помощью ().

(
    $localizeTemperature := function($degrees_celsius, $country) {(
        $conversion_ratio := (9 / 5);
        ($country = "US") ? (($degrees_celsius * $conversion_ratio) + 32)
                : $degrees_celsius;
        )};

    {
        "temp": $localizeTemperature(body.temp, best_country)
    }
)

(
        /* Определяем шаблон для идентификаторов */
        $isl2 := /^([^\.]*)(\.([^\.]*))?$/;
        /* Генерируем список компонентов L1 ровня */
        $result := $mergedeep($.components.$spread().(
          $id := $keys()[0];
          $node := $.*;
          $levels := $isl2($id).groups;
          /* Формируем ноду */
          $node :=
            /* Если это компонент уровня L2 */
            $levels[2]
            /* Создаем виртуальный компонент L1 с информацией о связях */
            ? $merge([
              {
                $levels[0]: {
                  "links":
                    $distinct($node.links.{
                      /* Преобразуем идентификатор связи к L1 */
                      "id": $split(id, ".")[0],
                      "title":  title,
                      "direction": "--"
                    })[id != $levels[0]]
                }
              }
            ])
            /* Иначе, преобразуем связи компонента к уровню L1 */
            : $merge([
              {
                $id: $merge([$.*, {
                  "links":
                    $distinct($node.links.{
                      /* Преобразуем идентификатор связи к L1 */
                      "id": $split(id, ".")[0],
                      "title":  title,
                      "direction": "--"
                    })[id != $levels[0]]
                }])
              }
            ])
        ));
        /* Перезаписываем данные манифеста новыми компонентами */
        $merge([$,
          { "components": $result}
        ]);
)

(
        $business_entities := $.business_entities;
        $makeLocation := function($id) {(
            $arrleft := function($arr ,$count) {
                $map($arr, function($v, $i) {
                $i <= $count ? $v
                })
            };
            $domains := $split($id, ".");
            "Документы/Моё болото/Бизнес-сущности/" & $join($map($domains, function($domain, $index) {(
                $lookup(business_entities, $join($arrleft($domains, $index), ".")).title
            )}), "/");
        )};
        $append(
        [{
            "icon": *.icon,                                                 /* Получаем иконку */
            "link": "entities/business_entities/business_entities_list",
            "location": "Документы/Моё болото/1. Бизнес-сущности"
        }],
        [{
            "icon": *.icon,                                                 /* Получаем иконку */
            "link": "entities/business_entities/business_entities_in_systems",
            "location": "Документы/Моё болото/2. Список бизнес-сущностей в системах"
        }]
        );

        $entities := [$.business_entities.$spread().$merge([$.*, {"id": $keys($)}])];
        $entities [id=$params.id];
        $[system_id=$params.system_id]
)

(
        [{
          /* Размещение в пользовательском меню */
          "location": "C4 Model",
          /* URI представления context см. ниже.*/
          "link": "entities/c4model/context"
        }];

       /* В переменной $parent содержатся переданные параметры из URI */
       $parent_id := $params.parent;
       /* Определяем уровень диаграммы */
       $levels := $split($parent_id, ".");
       $level := $count($levels);
       /* Сохраняем корень данных */
       $c4model := c4model;
       /* Получаем компонент, который ходим раскрыть. Для L1 = undefined */
       $parent := $lookup($c4model, $parent_id);
       /* Генерируем шаблон для выбора компонентов диаграммы */
       $pattern := $eval("/^" & ($parent_id != "" ? $parent_id & "." : "") & "[a-zA-Z0-9\\_]*$/");

       /* Обходим все компоненты сущности C4Model */
       $nodes := $c4model.$spread().(
         $id := $keys()[0];
         /* Обрабатываем компонент, если идентификатор компонента соответствует искомому */
         $match($id, $pattern) ? $merge([$.*, {
           /* Сохраняем идентификатор компонента в массиве компонентов диаграммы */
           "$id": $id
         }])
       );

       /* Находим связь выбранных копонентов с внешними */
       $extraNodes := $distinct([$nodes.links.(
         $not($exists($match(id, $pattern))) ? $merge([
           $lookup($c4model, id),
           {
             "$id": id,
             "links": [],
             "boundary": "*"
           }
         ])
       )]);

       /* Генерируем код Mermaid компонентов */
       $node2code := function($nodes, $bid) {(
         $join([$nodes[$bid ? boundary = $bid : $not($exists(boundary))].(
           /* Формируем заголовок компонента */
           $title := $level < 2
               /* Если уровень выше L2, даем возможность "провалиться" глубже */
               ? "![" & title & "](/entities/c4model/context?parent=" & $."$id" & ")"
               /* иначе нет */
               : title;
           entity & "(" & $."$id" & ", \"" & $title & "\", \"" & description & "\")"
         )], "\n") & "\n"
       )};

       /* Генерируем код Mermaid границ и их наполнения */
       $components := function($parent) {(
         $pattern := $eval("/^" & $parent & "[a-zA-Z0-9\\_]*$/");
         $boundaries := $distinct($nodes.boundary)^(boundary);
         $join($boundaries[$match($, $pattern)].(
           "Boundary(" & $ & ", \"" & $ & "\") {\n"
           & $node2code($nodes, $)
           & $join($components($ & "."), "\n")
           & "\n}"
         ), "\n") & "\n"
       )};

       /* Парсим связи компонентов */
       $relations := function() {(
         $join([$nodes.(
             $from := $."$id";
             links.{
               "from": $from,
               "to": id,
               "direction": direction,
               "title": title,
               "description": description
             }
           )].(
             (direction = "<->" ? "BiRel" : "Rel")
             & "("
             & from
             & ", " & to
             & ", \"" & title & "\""
             & ", \"" & description & "\""
             & ")"
           )
         , "\n") & "\n"
       )};

       /* Генерируем код диаграммы Mermaid */
       $code := function () {(
         /* Сначала выводим вгешние компонент обнаруженные в связях */
         $node2code($extraNodes, "*")
         /* Если уровень глубже L1, создаем контейнер */
         & ($level > 0 ? "Container_Boundary(" & $parent_id & ", \"\") {\n" : "")
         /* Выводим обнаруженные без областей */
         & $node2code($nodes)
         /* Выводим обнаруженные компоненты разложенные в области */
         & $components("")
         /* Если нужно, завершаем контейнер */
         & ($level > 0 ? "}\n" : "")
         /* Генерируем связи компонентов на диаграмме */
         & $relations()
       )};

       /* Возвращаем результирующие данные */
       {
         /* Определяем уровень представления */
         "notation": $lookup({
           "0": "C4Context",
           "1": "C4Container",
           "2": "C4Component"
         }, $string($level)),

         /* Генерируем код */
         "code":
             /* Если количество компонентов на диаграмме есть */
             $count($nodes) > 0
             /* выводом */
             ? $code()
             /* иначе сообщаем, что внутри пусто */
             : "\nBoundary(bempty, \"\") {\nSystem(sempty, \"Здесь пусто\")\n}"
             ,

         /* Генерируем заголовок диаграммы */
         "title":
           /* Если есть компонент верхнего уровня */
           $parent
           /* Возвращаем его название */
           ? $parent.title
           /* Иначе идентификатор, а если он пустой, то считаем диаграмму L1 */
           : ($parent_id ? $parent_id : "Context")
       }
)