ballerina-core 1.0.220 → 1.0.221

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/one/template.js

@@ -1,25 +1,28 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Map } from "immutable";
 import {
+  AsyncState,
   DispatchCommonFormState,
   id,
   PredicateValue,
   RecordAbstractRendererState,
   replaceWith,
+  Synchronized,
   Template,
   ValueInfiniteStreamState,
   ValueOption,
+  ValueOrErrors,
   ValueUnit,
+  Debounced,
+  Value,
   Option,
-  MapRepo,
-  Sum,
-  ValueStreamPosition,
 } from "../../../../../../../../main";
 import { OneAbstractRendererState } from "./state";
 import {
   initializeOneRunner,
-  initializeStreamRunner,
   oneTableDebouncerRunner,
   oneTableLoaderRunner,
+  reinitializeOneRunner,
 } from "./coroutines/runner";
 /*
  * The clear, set, create and delete callbacks are used when and only when the one is partial (it can have a value of unit or One)
@@ -39,19 +42,31 @@ export const OneAbstractRenderer = (
   PreviewRenderer,
   IdProvider,
   ErrorRenderer,
+  SerializedType,
   oneEntityType,
 ) => {
-  const typedInitializeStreamRunner = initializeStreamRunner();
   const typedInitializeOneRunner = initializeOneRunner();
+  const typedReinitializeOneRunner = reinitializeOneRunner();
   const typedOneTableLoaderRunner = oneTableLoaderRunner();
   const typedOneTableDebouncerRunner = oneTableDebouncerRunner();
-  // value is Unit -> partial one, dont'run
-  // value is Option<none> -> signal to run the initialization
-  // value is Option<some> -> there is a value, we do not care about what's inside
   const embeddedDetailsRenderer = (flags) =>
     DetailsRenderer.mapContext((_) => {
       var _a, _b;
-      if (PredicateValue.Operations.IsUnit(_.value)) {
+      if (
+        !AsyncState.Operations.hasValue(_.customFormState.selectedValue.sync)
+      ) {
+        return undefined;
+      }
+      if (_.customFormState.selectedValue.sync.value.kind == "errors") {
+        console.error(
+          _.customFormState.selectedValue.sync.value.errors
+            .join("\n")
+            .concat(`\n...When parsing the "one" field value\n...`),
+        );
+        return undefined;
+      }
+      const value = _.customFormState.selectedValue.sync.value.value;
+      if (PredicateValue.Operations.IsUnit(value)) {
         return undefined;
       }
       const state =
@@ -61,16 +76,19 @@ export const OneAbstractRenderer = (
             : _a.detailsState) !== null && _b !== void 0
           ? _b
           : RecordAbstractRendererState.Default.zero();
-      return Object.assign(Object.assign({ value: _.value.value }, state), {
+      return Object.assign(Object.assign({ value }, state), {
         disabled: _.disabled,
         bindings: _.bindings,
         extraContext: _.extraContext,
         type: oneEntityType,
         customPresentationContext: _.customPresentationContext,
         remoteEntityVersionIdentifier: _.remoteEntityVersionIdentifier,
-        typeAncestors: [_.type].concat(_.typeAncestors),
-        domNodeAncestorPath: _.domNodeAncestorPath + "[one][details]",
-        lookupTypeAncestorNames: _.lookupTypeAncestorNames,
+        serializedTypeHierarchy: [SerializedType].concat(
+          _.serializedTypeHierarchy,
+        ),
+        domNodeTypeHierarchy: ["[details]", SerializedType].concat(
+          _.domNodeTypeHierarchy,
+        ),
       });
     })
       .mapState((_) =>
@@ -91,14 +109,57 @@ export const OneAbstractRenderer = (
                     ),
                   ),
                 ),
-              ),
+              )
+              .then((__) => {
+                if (
+                  __.customFormState.selectedValue.sync.kind != "loaded" ||
+                  __.customFormState.selectedValue.sync.value.kind ==
+                    "errors" ||
+                  !PredicateValue.Operations.IsRecord(
+                    __.customFormState.selectedValue.sync.value.value,
+                  ) ||
+                  updater.kind == "l"
+                ) {
+                  return __;
+                }
+                return Object.assign(Object.assign({}, __), {
+                  customFormState: Object.assign(
+                    Object.assign({}, __.customFormState),
+                    {
+                      selectedValue: Object.assign(
+                        Object.assign({}, __.customFormState.selectedValue),
+                        {
+                          sync: Object.assign(
+                            Object.assign(
+                              {},
+                              __.customFormState.selectedValue.sync,
+                            ),
+                            {
+                              value: Object.assign(
+                                Object.assign(
+                                  {},
+                                  __.customFormState.selectedValue.sync.value,
+                                ),
+                                {
+                                  value: updater.value(
+                                    __.customFormState.selectedValue.sync.value
+                                      .value,
+                                  ),
+                                },
+                              ),
+                            },
+                          ),
+                        },
+                      ),
+                    },
+                  ),
+                });
+              }),
           );
           const delta = {
             kind: "OneValue",
             nestedDelta,
             flags,
-            sourceAncestorLookupTypeNames:
-              nestedDelta.sourceAncestorLookupTypeNames,
           };
           // The Option component of the one is a lazy load signal. Either the value is provided initially,
           // or it is loaded lazily. Here we always update a some, because if the detail renderer is displayed,
@@ -118,14 +179,14 @@ export const OneAbstractRenderer = (
         },
       }));
   const embeddedPreviewRenderer = PreviewRenderer
-    ? (value) => (id) => (flags) =>
+    ? (value) => (flags) =>
         PreviewRenderer.mapContext((_) => {
           var _a, _b;
           const state =
             (_b =
               (_a = _.customFormState) === null || _a === void 0
                 ? void 0
-                : _a.previewStates.get(id)) !== null && _b !== void 0
+                : _a.detailsState) !== null && _b !== void 0
               ? _b
               : RecordAbstractRendererState.Default.zero();
           return Object.assign(Object.assign({}, state), {
@@ -136,19 +197,17 @@ export const OneAbstractRenderer = (
             type: oneEntityType,
             customPresentationContext: _.customPresentationContext,
             remoteEntityVersionIdentifier: _.remoteEntityVersionIdentifier,
-            typeAncestors: [_.type].concat(_.typeAncestors),
-            domNodeAncestorPath: _.domNodeAncestorPath + "[one][preview]",
-            lookupTypeAncestorNames: _.lookupTypeAncestorNames,
+            serializedTypeHierarchy: [SerializedType].concat(
+              _.serializedTypeHierarchy,
+            ),
+            domNodeTypeHierarchy: ["[preview]", SerializedType].concat(
+              _.domNodeTypeHierarchy,
+            ),
           });
         })
-          .mapState((_) =>
-            OneAbstractRendererState.Updaters.Core.customFormState.children.previewStates(
-              MapRepo.Updaters.upsert(
-                id,
-                () => RecordAbstractRendererState.Default.zero(),
-                _,
-              ),
-            ),
+          .mapState(
+            OneAbstractRendererState.Updaters.Core.customFormState.children
+              .detailsState,
           )
           .mapForeignMutationsFromProps((props) => ({
             onChange: (updater, nestedDelta) => {
@@ -163,14 +222,58 @@ export const OneAbstractRenderer = (
                         ),
                       ),
                     ),
-                  ),
+                  )
+                  .then((__) => {
+                    if (
+                      __.customFormState.selectedValue.sync.kind != "loaded" ||
+                      __.customFormState.selectedValue.sync.value.kind ==
+                        "errors" ||
+                      !PredicateValue.Operations.IsRecord(
+                        __.customFormState.selectedValue.sync.value.value,
+                      ) ||
+                      updater.kind == "l"
+                    ) {
+                      return __;
+                    }
+                    return Object.assign(Object.assign({}, __), {
+                      customFormState: Object.assign(
+                        Object.assign({}, __.customFormState),
+                        {
+                          selectedValue: Object.assign(
+                            Object.assign({}, __.customFormState.selectedValue),
+                            {
+                              sync: Object.assign(
+                                Object.assign(
+                                  {},
+                                  __.customFormState.selectedValue.sync,
+                                ),
+                                {
+                                  value: Object.assign(
+                                    Object.assign(
+                                      {},
+                                      __.customFormState.selectedValue.sync
+                                        .value,
+                                    ),
+                                    {
+                                      value: updater.value(
+                                        __.customFormState.selectedValue.sync
+                                          .value.value,
+                                      ),
+                                    },
+                                  ),
+                                },
+                              ),
+                            },
+                          ),
+                        },
+                      ),
+                    });
+                  }),
               );
               const delta = {
                 kind: "OneValue",
                 nestedDelta,
                 flags,
-                sourceAncestorLookupTypeNames:
-                  nestedDelta.sourceAncestorLookupTypeNames,
               };
               props.foreignMutations.onChange(
                 updater.kind == "l"
@@ -189,7 +292,13 @@ export const OneAbstractRenderer = (
     : undefined;
   return Template.Default((props) => {
     var _a;
-    const domNodeId = props.context.domNodeAncestorPath + "[one]";
+    const completeSerializedTypeHierarchy = [SerializedType].concat(
+      props.context.serializedTypeHierarchy,
+    );
+    const domNodeTypeHierarchy = [SerializedType].concat(
+      props.context.domNodeTypeHierarchy,
+    );
+    const domNodeId = domNodeTypeHierarchy.join(".");
     const value = props.context.value;
     if (
       !PredicateValue.Operations.IsUnit(value) &&
@@ -198,38 +307,102 @@ export const OneAbstractRenderer = (
           value.isSome &&
           !PredicateValue.Operations.IsRecord(value.value)))
     ) {
+      _jsx(ErrorRenderer, {
+        message: `${SerializedType}: Option of record or unit expected but got ${JSON.stringify(props.context.value)}`,
+      });
+    }
+    const local = props.context.bindings.get("local");
+    if (local == undefined) {
+      console.error(
+        `local binding is undefined when intialising one\n...${SerializedType}`,
+      );
       return _jsx(ErrorRenderer, {
-        message: `${domNodeId}: Option of record or unit expected but got ${JSON.stringify(props.context.value)}`,
+        message: `local binding is undefined when intialising one\n...${SerializedType}`,
       });
     }
-    const maybeId = OneAbstractRendererState.Operations.GetIdFromContext(
-      props.context,
-    ).MapErrors((_) => _.concat(`\n...${domNodeId}`));
-    if (maybeId.kind === "errors") {
-      const errorMsg = maybeId.errors.join("\n");
-      return _jsx(ErrorRenderer, { message: errorMsg });
+    if (!PredicateValue.Operations.IsRecord(local)) {
+      console.error(
+        `local binding is not a record when intialising one\n...${SerializedType}`,
+      );
+      return _jsx(ErrorRenderer, {
+        message: `local binding is not a record when intialising one\n...${SerializedType}`,
+      });
+    }
+    if (!local.fields.has("Id")) {
+      console.error(
+        `local binding is missing Id (check casing) when intialising one\n...${SerializedType}`,
+      );
+      return _jsx(ErrorRenderer, {
+        message: `local binding is missing Id (check casing) when intialising one\n...${SerializedType}`,
+      });
+    }
+    const Id = local.fields.get("Id"); // safe because of above check;
+    if (!PredicateValue.Operations.IsString(Id)) {
+      console.error(
+        `local Id is not a string when intialising one\n...${SerializedType}`,
+      );
+      return _jsx(ErrorRenderer, {
+        message: `local Id is not a string when intialising one\n...${SerializedType}`,
+      });
+    }
+    if (
+      !AsyncState.Operations.hasValue(
+        props.context.customFormState.selectedValue.sync,
+      )
+    ) {
+      return _jsx(_Fragment, {
+        children: _jsx(IdProvider, {
+          domNodeId: domNodeId,
+          children: _jsx(
+            props.view,
+            Object.assign({}, props, {
+              context: Object.assign(Object.assign({}, props.context), {
+                domNodeId,
+                kind: "uninitialized",
+              }),
+              kind: "uninitialized",
+              foreignMutations: {
+                kind: "uninitialized",
+              },
+            }),
+          ),
+        }),
+      });
+    }
+    if (
+      props.context.customFormState.selectedValue.sync.value.kind == "errors"
+    ) {
+      console.error(
+        props.context.customFormState.selectedValue.sync.value.errors.join(
+          "\n",
+        ),
+      );
+      return _jsx(_Fragment, {});
     }
+    const syncValue =
+      props.context.customFormState.selectedValue.sync.value.value;
     return _jsx(_Fragment, {
       children: _jsx(IdProvider, {
         domNodeId: domNodeId,
         children: _jsx(
           props.view,
           Object.assign({}, props, {
+            kind: "initialized",
             context: Object.assign(Object.assign({}, props.context), {
+              kind: "initialized",
               domNodeId,
-              value,
-              hasMoreValues:
-                props.context.customFormState.stream.kind === "r"
-                  ? false
-                  : !!((_a =
-                      props.context.customFormState.stream.value.loadedElements.last()) ===
-                      null || _a === void 0
-                      ? void 0
-                      : _a.hasMoreValues),
+              value: syncValue,
+              hasMoreValues: !!((_a =
+                props.context.customFormState.stream.loadedElements.last()) ===
+                null || _a === void 0
+                ? void 0
+                : _a.hasMoreValues),
+              completeSerializedTypeHierarchy,
             }),
             foreignMutations: Object.assign(
               Object.assign({}, props.foreignMutations),
               {
+                kind: "initialized",
                 toggleOpen: () =>
                   props.setState(
                     OneAbstractRendererState.Updaters.Core.customFormState.children
@@ -241,56 +414,81 @@ export const OneAbstractRenderer = (
                         ),
                       )
                       .then(
-                        props.context.customFormState.stream.kind === "l" &&
-                          props.context.customFormState.stream.value.loadedElements.count() ==
-                            0
+                        props.context.customFormState.stream.loadedElements.count() ==
+                          0
                           ? OneAbstractRendererState.Updaters.Core.customFormState.children.stream(
-                              Sum.Updaters.left(
-                                ValueInfiniteStreamState.Updaters.Template.initLoad(),
-                              ),
+                              ValueInfiniteStreamState.Updaters.Template.loadMore(),
                             )
                           : id,
                       ),
                   ),
-                setStreamParam: (key, value, shouldReload) =>
+                setStreamParam: (key, _) =>
                   props.setState(
                     OneAbstractRendererState.Updaters.Template.streamParam(
                       key,
-                      replaceWith(value),
-                      shouldReload,
-                    ).then(
-                      OneAbstractRendererState.Updaters.Core.customFormState.children.stream(
-                        Sum.Updaters.left(
-                          ValueInfiniteStreamState.Updaters.Core.position(
-                            ValueStreamPosition.Updaters.Core.nextStart(
-                              replaceWith(0),
-                            ),
-                          ),
-                        ),
-                      ),
+                      replaceWith(_),
                     ),
                   ),
                 loadMore: () =>
                   props.setState(
                     OneAbstractRendererState.Updaters.Core.customFormState.children.stream(
-                      Sum.Updaters.left(
-                        ValueInfiniteStreamState.Updaters.Template.loadMore(),
+                      ValueInfiniteStreamState.Updaters.Template.loadMore(),
+                    ),
+                  ),
+                reload: () =>
+                  props.setState(
+                    OneAbstractRendererState.Updaters.Core.customFormState.children.streamParams(
+                      Debounced.Updaters.Template.value(
+                        Value.Updaters.value(replaceWith(Map())),
                       ),
                     ),
                   ),
                 clear: () =>
                   // See comment at top of file
+                  // TODO: test the reinitialization behaviour
                   props.foreignMutations.clear &&
-                  props.foreignMutations.clear(),
+                  (props.foreignMutations.clear(),
+                  props.setState(
+                    OneAbstractRendererState.Updaters.Core.customFormState.children
+                      .selectedValue(
+                        Synchronized.Updaters.sync(
+                          AsyncState.Updaters.toLoaded(
+                            ValueOrErrors.Default.return(
+                              PredicateValue.Default.unit(),
+                            ),
+                          ),
+                        ),
+                      )
+                      .then(
+                        OneAbstractRendererState.Updaters.Template.shouldReinitialize(
+                          true,
+                        ),
+                      ),
+                  )),
                 delete: (flags) => {
                   const delta = {
                     kind: "OneDeleteValue",
                     flags,
-                    sourceAncestorLookupTypeNames:
-                      props.context.lookupTypeAncestorNames,
                   };
                   props.foreignMutations.delete &&
-                    props.foreignMutations.delete(delta);
+                    (props.foreignMutations.delete(delta),
+                    props.setState(
+                      OneAbstractRendererState.Updaters.Core.customFormState.children
+                        .selectedValue(
+                          Synchronized.Updaters.sync(
+                            AsyncState.Updaters.toLoaded(
+                              ValueOrErrors.Default.return(
+                                PredicateValue.Default.unit(),
+                              ),
+                            ),
+                          ),
+                        )
+                        .then(
+                          OneAbstractRendererState.Updaters.Template.shouldReinitialize(
+                            true,
+                          ),
+                        ),
+                    ));
                 },
                 select: (value, flags) => {
                   const delta = {
@@ -298,8 +496,6 @@ export const OneAbstractRenderer = (
                     replace: value,
                     flags,
                     type: props.context.type,
-                    sourceAncestorLookupTypeNames:
-                      props.context.lookupTypeAncestorNames,
                   };
                   const updater = replaceWith(ValueOption.Default.some(value));
                   props.foreignMutations.select &&
@@ -309,6 +505,21 @@ export const OneAbstractRenderer = (
                         Option.Default.some(updater),
                         delta,
                       );
+                  props.setState(
+                    OneAbstractRendererState.Updaters.Core.customFormState.children
+                      .selectedValue(
+                        Synchronized.Updaters.sync(
+                          AsyncState.Updaters.toLoaded(
+                            ValueOrErrors.Default.return(value),
+                          ),
+                        ),
+                      )
+                      .then(
+                        OneAbstractRendererState.Updaters.Template.shouldReinitialize(
+                          true,
+                        ),
+                      ),
+                  );
                 },
                 create: (value, flags) => {
                   const delta = {
@@ -316,8 +527,6 @@ export const OneAbstractRenderer = (
                     value,
                     flags,
                     type: props.context.type,
-                    sourceAncestorLookupTypeNames:
-                      props.context.lookupTypeAncestorNames,
                   };
                   const updater = replaceWith(ValueOption.Default.some(value));
                   props.foreignMutations.select &&
@@ -327,55 +536,72 @@ export const OneAbstractRenderer = (
                         Option.Default.some(updater),
                         delta,
                       );
+                  props.setState(
+                    OneAbstractRendererState.Updaters.Core.customFormState.children
+                      .selectedValue(
+                        Synchronized.Updaters.sync(
+                          AsyncState.Updaters.toLoaded(
+                            ValueOrErrors.Default.return(value),
+                          ),
+                        ),
+                      )
+                      .then(
+                        OneAbstractRendererState.Updaters.Template.shouldReinitialize(
+                          true,
+                        ),
+                      ),
+                  );
                 },
               },
             ),
-            DetailsRenderer:
-              value.kind === "unit" || value.isSome
-                ? embeddedDetailsRenderer
-                : undefined,
-            PreviewRenderer:
-              value.kind === "unit" || value.isSome
-                ? embeddedPreviewRenderer
-                : undefined,
+            DetailsRenderer: embeddedDetailsRenderer,
+            PreviewRenderer: embeddedPreviewRenderer,
           }),
         ),
       }),
     });
   }).any([
-    typedInitializeStreamRunner,
+    typedInitializeOneRunner,
+    typedReinitializeOneRunner,
     typedOneTableLoaderRunner,
-    typedInitializeOneRunner.mapContextFromProps((props) =>
-      Object.assign(Object.assign({}, props.context), {
-        onChange: props.foreignMutations.onChange,
-      }),
-    ),
     typedOneTableDebouncerRunner.mapContextFromProps((props) => {
-      const maybeId = OneAbstractRendererState.Operations.GetIdFromContext(
-        props.context,
-      ).MapErrors((_) =>
-        _.concat(`\n...${props.context.domNodeAncestorPath + "[one]"}`),
-      );
-      if (maybeId.kind === "errors") {
-        console.error(maybeId.errors.join("\n"));
+      const local = props.context.bindings.get("local");
+      if (local == undefined) {
+        console.error(
+          `local binding is undefined when intialising one\n...${SerializedType}`,
+        );
+        return undefined;
+      }
+      if (!PredicateValue.Operations.IsRecord(local)) {
+        console.error(
+          `local binding is not a record when intialising one\n...${SerializedType}`,
+        );
+        return undefined;
+      }
+      if (!local.fields.has("Id")) {
+        console.error(
+          `local binding is missing Id (check casing) when intialising one\n...${SerializedType}`,
+        );
+        return undefined;
+      }
+      const Id = local.fields.get("Id"); // safe because of above check;
+      if (!PredicateValue.Operations.IsString(Id)) {
+        console.error(
+          `local Id is not a string when intialising one\n...${SerializedType}`,
+        );
         return undefined;
       }
       return Object.assign(Object.assign({}, props.context), {
         onDebounce: () => {
-          if (props.context.customFormState.streamParams.value[1]) {
-            props.setState(
-              OneAbstractRendererState.Updaters.Core.customFormState.children.stream(
-                Sum.Updaters.left(
-                  ValueInfiniteStreamState.Updaters.Template.reload(
-                    // safe because we check for undefined in the runFilter
-                    props.context.customFormState.getChunkWithParams(
-                      maybeId.value,
-                    )(props.context.customFormState.streamParams.value[0]),
-                  ),
+          props.setState(
+            OneAbstractRendererState.Updaters.Core.customFormState.children.stream(
+              ValueInfiniteStreamState.Updaters.Template.reload(
+                props.context.customFormState.getChunkWithParams(Id)(
+                  props.context.customFormState.streamParams.value,
                 ),
               ),
-            );
-          }
+            ),
+          );
         },
       });
     }),