ballerina-core 1.0.149 → 1.0.150

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.149",
+  "version": "1.0.150",
   "main": "main.ts",
   "scripts": {
     "prettier": "prettier --write ."

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/state.ts

@@ -160,7 +160,7 @@ export type AbstractTableRendererView<
     clearRows: SimpleCallback<void>;
     add: SimpleCallback<void>;
     remove: SimpleCallback<string>;
-    moveTo: (key: string, to: number) => void;
+    moveTo: (key: string, to: string) => void;
     duplicate: SimpleCallback<string>;
   },
   {

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/template.tsx

@@ -442,7 +442,7 @@ export const TableAbstractRenderer = <
                   ),
                 );
               },
-              moveTo: (k: string, to: number) => {
+              moveTo: (k: string, to: string) => {
                 const delta: DispatchDelta = {
                   kind: "TableMoveTo",
                   id: k,

package/src/forms/domains/dispatched-forms/runner/domains/deltas/state.ts

@@ -205,7 +205,7 @@ export type DispatchDeltaTable =
   | {
       kind: "TableMoveTo";
       id: string;
-      to: number;
+      to: string;
       type: DispatchParsedType<any>;
     }
   | {
@@ -320,10 +320,10 @@ export type DispatchDeltaTransferTable<DispatchDeltaTransferCustom> =
         Item2: DispatchDeltaTransfer<DispatchDeltaTransferCustom>;
       };
     }
-  | { Discriminator: "TableAdd" }
-  | { Discriminator: "TableRemove"; Remove: string }
-  | { Discriminator: "TableDuplicate"; Dup: string }
-  | { Discriminator: "TableMoveTo"; Move: string; To: number };
+  | { Discriminator: "TableAddEmpty" }
+  | { Discriminator: "TableRemoveAt"; RemoveAt: string }
+  | { Discriminator: "TableDuplicateAt"; DuplicateAt: string }
+  | { Discriminator: "TableMoveFromTo"; MoveFromTo: [string, string] };
 
 export type DispatchDeltaTransfer<DispatchDeltaTransferCustom> =
   | DispatchDeltaTransferPrimitive
@@ -1131,9 +1131,9 @@ export const DispatchDeltaTransfer = {
               string
             >([
               {
-                Discriminator: "TableAdd",
+                Discriminator: "TableAddEmpty",
               },
-              `[TableAdd]`,
+              `[TableAddEmpty]`,
               delta.isWholeEntityMutation,
             ]);
           }
@@ -1147,10 +1147,10 @@ export const DispatchDeltaTransfer = {
               string
             >([
               {
-                Discriminator: "TableRemove",
-                Remove: delta.id,
+                Discriminator: "TableRemoveAt",
+                RemoveAt: delta.id,
               },
-              `[TableRemove][${delta.id}]`,
+              `[TableRemoveAt][${delta.id}]`,
               delta.isWholeEntityMutation,
             ]);
           }
@@ -1164,10 +1164,10 @@ export const DispatchDeltaTransfer = {
               string
             >([
               {
-                Discriminator: "TableDuplicate",
-                Dup: delta.id,
+                Discriminator: "TableDuplicateAt",
+                DuplicateAt: delta.id,
               },
-              `[TableDuplicate][${delta.id}]`,
+              `[TableDuplicateAt][${delta.id}]`,
               delta.isWholeEntityMutation,
             ]);
           }
@@ -1181,11 +1181,10 @@ export const DispatchDeltaTransfer = {
               string
             >([
               {
-                Discriminator: "TableMoveTo",
-                Move: delta.id,
-                To: delta.to,
+                Discriminator: "TableMoveFromTo",
+                MoveFromTo: [delta.id, delta.to],
               },
-              `[TableMoveTo][${delta.id}][${delta.to}]`,
+              `[TableMoveFromTo][${delta.id}][${delta.to}]`,
               delta.isWholeEntityMutation,
             ]);
           }

package/src/forms/domains/dispatched-forms/runner/domains/traversal/state.ts

@@ -12,6 +12,7 @@ import {
   FormLayout,
   Unit,
   unit,
+  TableLayout,
 } from "ballerina-core";
 import { List, Map, Set } from "immutable";
 
@@ -64,12 +65,20 @@ export const RendererTraversal = {
 
       const traverseNode = traversalContext.traverseSingleType(type);
 
-      if (type.kind == "primitive") {
+      if (
+        type.kind == "primitive" ||
+        type.kind == "singleSelection" ||
+        type.kind == "multiSelection"
+      ) {
         return ValueOrErrors.Default.return(traverseNode);
       }
 
+      // TODO -- later when we only resolve lookups at the last moment, we can remove the other type checks
       if (
-        (type.kind == "lookup" || type.kind == "record") &&
+        (type.kind == "lookup" ||
+          type.kind == "record" ||
+          type.kind == "union" ||
+          type.kind == "table") &&
         renderer.kind == "lookupRenderer"
       ) {
         if (traversalContext.primitiveRendererNamesByType.has(type.name)) {
@@ -147,7 +156,11 @@ export const RendererTraversal = {
                 )
               )
                 return ValueOrErrors.Default.throwOne(
-                  `Error: traversal iterator is not a record, got ${evalContext.traversalIterator}`,
+                  `Error: traversal iterator is not a record, got ${JSON.stringify(
+                    evalContext.traversalIterator,
+                    undefined,
+                    2,
+                  )}`,
                 );
               const visibleFieldsRes =
                 FormLayout.Operations.ComputeVisibleFieldsForRecord(
@@ -235,10 +248,7 @@ export const RendererTraversal = {
           );
         }
         if (renderer.kind == "sumRenderer") {
-          const res: ValueOrErrors<
-            Option<ValueTraversal<T, Res>>,
-            string
-          > = rec(type.args[0], renderer, traversalContext).Then(
+          return rec(type.args[0], renderer, traversalContext).Then(
             (leftTraversal) =>
               rec(type.args[1], renderer, traversalContext).Then(
                 (rightTraversal) => {
@@ -340,7 +350,6 @@ export const RendererTraversal = {
                 },
               ),
           );
-          return res;
         }
       }
 
@@ -411,6 +420,409 @@ export const RendererTraversal = {
         });
       }
 
+      if (type.kind == "union" && renderer.kind == "unionRenderer") {
+        return ValueOrErrors.Operations.All(
+          List(
+            renderer.cases
+              .map((caseRenderer, caseName) =>
+                rec(caseRenderer.type, caseRenderer, traversalContext).Then(
+                  (caseTraversal) =>
+                    ValueOrErrors.Default.return({
+                      caseName: caseName,
+                      caseTraversal: caseTraversal,
+                    }),
+                ),
+              )
+              .valueSeq(),
+          ),
+        ).Then((caseTraversals) => {
+          if (
+            caseTraversals.every((c) => c.caseTraversal.kind == "l") &&
+            traverseNode.kind == "l"
+          ) {
+            return ValueOrErrors.Default.return(Option.Default.none());
+          }
+          return ValueOrErrors.Default.return(
+            Option.Default.some((evalContext: EvalContext<T, Res>) => {
+              const iterator = evalContext.traversalIterator;
+              if (!PredicateValue.Operations.IsUnionCase(iterator)) {
+                return ValueOrErrors.Default.throwOne(
+                  `Error: traversal iterator is not a union case, got ${evalContext.traversalIterator}`,
+                );
+              }
+              const caseName = iterator.caseName;
+              const caseTraversal = caseTraversals.find(
+                (c) => c.caseName == caseName,
+              )?.caseTraversal;
+              if (!caseTraversal) {
+                return ValueOrErrors.Default.throwOne(
+                  `Error: cannot find case traversal for case ${caseName}`,
+                );
+              }
+              return caseTraversal.kind == "r"
+                ? caseTraversal
+                    .value({
+                      ...evalContext,
+                      traversalIterator: iterator.fields,
+                    })
+                    .Then((caseRes) => {
+                      return traverseNode.kind == "r"
+                        ? traverseNode
+                            .value(evalContext)
+                            .Then((nodeResult: Res) => {
+                              return ValueOrErrors.Default.return(
+                                traversalContext.joinRes([nodeResult, caseRes]),
+                              );
+                            })
+                        : ValueOrErrors.Default.return(caseRes);
+                    })
+                : traverseNode.kind == "r"
+                  ? traverseNode.value(evalContext).Then((nodeResult: Res) => {
+                      return ValueOrErrors.Default.return(nodeResult);
+                    })
+                  : ValueOrErrors.Default.return(
+                      traversalContext.zeroRes(unit),
+                    );
+            }),
+          );
+        });
+      }
+      // TODO -- add recursion for the detailsRenderer, but requires state
+      if (type.kind == "table" && renderer.kind == "tableRenderer") {
+        return ValueOrErrors.Operations.All(
+          List(
+            renderer.columns
+              .map((column, columnName) => {
+                return rec(
+                  column.renderer.type,
+                  column.renderer,
+                  traversalContext,
+                ).Then((columnTraversal) => {
+                  return ValueOrErrors.Default.return({
+                    columnName: columnName,
+                    columnTraversal: columnTraversal,
+                  });
+                });
+              })
+              .valueSeq(),
+          ),
+        ).Then((columnTraversals) => {
+          if (
+            columnTraversals.every((c) => c.columnTraversal.kind == "l") &&
+            traverseNode.kind == "l"
+          ) {
+            return ValueOrErrors.Default.return(Option.Default.none());
+          }
+          return ValueOrErrors.Default.return(
+            Option.Default.some((evalContext: EvalContext<T, Res>) => {
+              const iterator = evalContext.traversalIterator;
+              if (!PredicateValue.Operations.IsTable(iterator)) {
+                return ValueOrErrors.Default.throwOne(
+                  `Error: traversal iterator is not a table, got ${evalContext.traversalIterator}`,
+                );
+              }
+              return TableLayout.Operations.ComputeLayout(
+                Map([
+                  ["global", evalContext.global],
+                  ["local", evalContext.local],
+                  ["root", evalContext.root],
+                ]),
+                renderer.visibleColumns,
+              ).Then((visibleColumns) => {
+                // Note: we do not allow visiblity predicates on individual column cells
+                return ValueOrErrors.Operations.All<Res, string>(
+                  columnTraversals.flatMap((c) => {
+                    const colTraversal = c.columnTraversal;
+                    if (
+                      colTraversal.kind == "l" ||
+                      !visibleColumns.columns.includes(c.columnName)
+                    ) {
+                      return [];
+                    }
+                    return iterator.data.valueSeq().flatMap((row) => {
+                      // TODO make this monadic
+                      const columnValue = row.fields.get(c.columnName);
+                      if (!columnValue) {
+                        return [
+                          ValueOrErrors.Default.throwOne(
+                            `Error: cannot find column ${
+                              c.columnName
+                            } in row ${JSON.stringify(row)}`,
+                          ),
+                        ];
+                      }
+                      return [
+                        colTraversal.value({
+                          ...evalContext,
+                          traversalIterator: columnValue,
+                        }),
+                      ];
+                    });
+                  }),
+                ).Then((columnResults) => {
+                  return traverseNode.kind == "r"
+                    ? traverseNode
+                        .value(evalContext)
+                        .Then((nodeResult: Res) =>
+                          ValueOrErrors.Default.return(
+                            columnResults.reduce(
+                              (acc, res) =>
+                                traversalContext.joinRes([acc, res]),
+                              nodeResult,
+                            ),
+                          ),
+                        )
+                    : ValueOrErrors.Default.return(
+                        columnResults.reduce(
+                          (acc, res) => traversalContext.joinRes([acc, res]),
+                          traversalContext.zeroRes(unit),
+                        ),
+                      );
+                });
+              });
+            }),
+          );
+        });
+      }
+      // TODO -- should we also look at the previewRenderer? Woud also requite state
+      if (type.kind == "one" && renderer.kind == "oneRenderer") {
+        return rec(
+          renderer.detailsRenderer.renderer.type,
+          renderer.detailsRenderer.renderer,
+          traversalContext,
+        ).Then((itemTraversal) => {
+          if (itemTraversal.kind == "l" && traverseNode.kind == "l") {
+            return ValueOrErrors.Default.return(Option.Default.none());
+          }
+          return ValueOrErrors.Default.return(
+            Option.Default.some<ValueTraversal<T, Res>>(
+              (evalContext: EvalContext<T, Res>) => {
+                const iterator = evalContext.traversalIterator;
+
+                // Handle partial ones
+                if (PredicateValue.Operations.IsUnit(iterator)) {
+                  return traverseNode.kind == "r"
+                    ? traverseNode.value(evalContext)
+                    : ValueOrErrors.Default.return(
+                        traversalContext.zeroRes(unit),
+                      );
+                }
+                if (!PredicateValue.Operations.IsOption(iterator)) {
+                  return ValueOrErrors.Default.throwOne<Res, string>(
+                    `Error: traversal iterator for one is not an option, got ${iterator}`,
+                  );
+                }
+                const isSome =
+                  PredicateValue.Operations.IsOption(iterator) &&
+                  iterator.isSome;
+
+                if (!isSome) {
+                  return traverseNode.kind == "r"
+                    ? traverseNode.value(evalContext)
+                    : ValueOrErrors.Default.return(
+                        traversalContext.zeroRes(unit),
+                      );
+                }
+
+                return traverseNode.kind == "r"
+                  ? traverseNode.value(evalContext).Then((nodeResult: Res) => {
+                      return itemTraversal.kind == "r"
+                        ? itemTraversal
+                            .value({
+                              ...evalContext,
+                              traversalIterator: iterator.value,
+                            })
+                            .Then((itemResult: Res) => {
+                              return ValueOrErrors.Default.return(
+                                traversalContext.joinRes([
+                                  nodeResult,
+                                  itemResult,
+                                ]),
+                              );
+                            })
+                        : ValueOrErrors.Default.return(nodeResult);
+                    })
+                  : itemTraversal.kind == "r"
+                    ? itemTraversal.value({
+                        ...evalContext,
+                        traversalIterator: iterator.value,
+                      })
+                    : ValueOrErrors.Default.return(
+                        traversalContext.zeroRes(unit),
+                      );
+              },
+            ),
+          );
+        });
+      }
+
+      if (type.kind == "list" && renderer.kind == "listRenderer") {
+        return rec(type.args[0], renderer, traversalContext).Then(
+          (elementTraversal) => {
+            if (elementTraversal.kind == "l" && traverseNode.kind == "l") {
+              return ValueOrErrors.Default.return(Option.Default.none());
+            }
+            return ValueOrErrors.Default.return(
+              Option.Default.some((evalContext: EvalContext<T, Res>) => {
+                const iterator = evalContext.traversalIterator;
+                if (!PredicateValue.Operations.IsTuple(iterator)) {
+                  return ValueOrErrors.Default.throwOne<Res, string>(
+                    `Error: traversal iterator for list is not a tuple, got ${JSON.stringify(
+                      iterator,
+                      null,
+                      2,
+                    )}`,
+                  );
+                }
+                return ValueOrErrors.Operations.All<Res, string>(
+                  iterator.values.map((value) =>
+                    elementTraversal.kind == "r"
+                      ? elementTraversal.value({
+                          ...evalContext,
+                          traversalIterator: value,
+                        })
+                      : ValueOrErrors.Default.return(
+                          traversalContext.zeroRes(unit),
+                        ),
+                  ),
+                ).Then((elementResults) =>
+                  traverseNode.kind == "r"
+                    ? traverseNode
+                        .value(evalContext)
+                        .Then((nodeResult: Res) =>
+                          ValueOrErrors.Default.return(
+                            elementResults.reduce(
+                              (acc, res) =>
+                                traversalContext.joinRes([acc, res]),
+                              nodeResult,
+                            ),
+                          ),
+                        )
+                    : ValueOrErrors.Default.return(
+                        elementResults.reduce(
+                          (acc, res) => traversalContext.joinRes([acc, res]),
+                          traversalContext.zeroRes(unit),
+                        ),
+                      ),
+                );
+              }),
+            );
+          },
+        );
+      }
+
+      if (type.kind == "map" && renderer.kind == "mapRenderer") {
+        return rec(
+          type.args[0],
+          renderer.keyRenderer.renderer,
+          traversalContext,
+        ).Then((keyTraversal) => {
+          return rec(
+            type.args[1],
+            renderer.valueRenderer.renderer,
+            traversalContext,
+          ).Then((valueTraversal) => {
+            if (
+              keyTraversal.kind == "l" &&
+              valueTraversal.kind == "l" &&
+              traverseNode.kind == "l"
+            ) {
+              return ValueOrErrors.Default.return(Option.Default.none());
+            }
+            return ValueOrErrors.Default.return(
+              Option.Default.some<ValueTraversal<T, Res>>(
+                (evalContext: EvalContext<T, Res>) => {
+                  if (keyTraversal.kind == "l" && valueTraversal.kind == "l") {
+                    return traverseNode.kind == "r"
+                      ? traverseNode.value(evalContext)
+                      : ValueOrErrors.Default.return<Res, string>(
+                          traversalContext.zeroRes(unit),
+                        );
+                  }
+
+                  const iterator = evalContext.traversalIterator;
+                  if (!PredicateValue.Operations.IsTuple(iterator)) {
+                    return ValueOrErrors.Default.throwOne<Res, string>(
+                      `Error: traversal iterator for map is not a tuple, got ${JSON.stringify(
+                        iterator,
+                        null,
+                        2,
+                      )}`,
+                    );
+                  }
+
+                  return ValueOrErrors.Operations.All<Res, string>(
+                    iterator.values.map((value) => {
+                      if (!PredicateValue.Operations.IsTuple(value)) {
+                        return ValueOrErrors.Default.throwOne<Res, string>(
+                          `Error: traversal iterator for map keyValue is not a tuple, got ${JSON.stringify(
+                            value,
+                            null,
+                            2,
+                          )}`,
+                        );
+                      }
+                      const keyRes =
+                        keyTraversal.kind == "r"
+                          ? keyTraversal.value({
+                              ...evalContext,
+                              traversalIterator: value.values.get(0)!,
+                            })
+                          : ValueOrErrors.Default.return(
+                              traversalContext.zeroRes(unit),
+                            );
+
+                      const valueRes =
+                        valueTraversal.kind == "r"
+                          ? valueTraversal.value({
+                              ...evalContext,
+                              traversalIterator: value.values.get(1)!,
+                            })
+                          : ValueOrErrors.Default.return(
+                              traversalContext.zeroRes(unit),
+                            );
+
+                      if (keyRes.kind == "errors") {
+                        return keyRes as ValueOrErrors<Res, string>;
+                      }
+                      if (valueRes.kind == "errors") {
+                        return valueRes as ValueOrErrors<Res, string>;
+                      }
+
+                      return ValueOrErrors.Default.return<Res, string>(
+                        traversalContext.joinRes([
+                          keyRes.value,
+                          valueRes.value,
+                        ]),
+                      );
+                    }),
+                  ).Then((keyValueResults) => {
+                    return traverseNode.kind == "r"
+                      ? traverseNode
+                          .value(evalContext)
+                          .Then((nodeResult: Res) => {
+                            return ValueOrErrors.Default.return<Res, string>(
+                              keyValueResults.reduce(
+                                (acc, res) =>
+                                  traversalContext.joinRes([acc, res]),
+                                nodeResult,
+                              ),
+                            );
+                          })
+                      : ValueOrErrors.Default.return<Res, string>(
+                          keyValueResults.reduce(
+                            (acc, res) => traversalContext.joinRes([acc, res]),
+                            traversalContext.zeroRes(unit),
+                          ),
+                        );
+                  });
+                },
+              ),
+            );
+          });
+        });
+      }
+
       return ValueOrErrors.Default.return(Option.Default.none());
     },
   },

package/src/forms/domains/primitives/domains/searchable-infinite-stream-multiselect/template.tsx

@@ -179,6 +179,7 @@ export const InfiniteMultiselectDropdownForm = <
               ),
             ),
           toggleSelection: (elementRecord: ValueRecord) => {
+            // TODO - updater logic is using old value rather than inside an updater
             const updater = props.context.value.fields.has(
               elementRecord.fields.get("Id")! as string,
             )
@@ -192,7 +193,7 @@ export const InfiniteMultiselectDropdownForm = <
 
             const delta: Delta = {
               kind: "SetReplace",
-              // Maybe unsafe - check
+              // TODO: Maybe unsafe - check
               replace: updater(props.context.value),
               state: {
                 commonFormState: props.context.commonFormState,