ballerina-core 1.0.81 → 1.0.83

package/main.ts

@@ -116,7 +116,6 @@ export * from "./src/forms/domains/launcher/coroutines/runner";
 export * from "./src/forms/domains/launcher/state";
 export * from "./src/forms/domains/launcher/template";
 export * from "./src/forms/domains/parser/domains/injectables/state";
-export * from "./src/forms/domains/collection/domains/unionCase/state";
 export * from "./src/forms/domains/parser/domains/predicates/state";
 export * from "./src/forms/domains/launcher/domains/passthrough/state";
 export * from "./src/forms/domains/launcher/domains/passthrough/template";

package/package.json

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

package/src/forms/domains/collection/domains/reference/state.ts

@@ -24,6 +24,11 @@ export const CollectionReference = {
     ...simpleUpdater<CollectionReference>()("Id"),
     ...simpleUpdater<CollectionReference>()("DisplayValue"),
   },
+  Operations: {
+    IsCollectionReference: (value: any): value is CollectionReference => {
+      return typeof value == "object" && value.Id && value.DisplayValue;
+    },
+  },
 };
 
 export type EnumReference = {
@@ -36,4 +41,9 @@ export const EnumReference = {
   Updaters: {
     ...simpleUpdater<EnumReference>()("Value"),
   },
+  Operations: {
+    IsEnumReference: (value: any): value is EnumReference => {
+      return typeof value == "object" && value.Value;
+    },
+  },
 };

package/src/forms/domains/launcher/coroutines/runner.ts

@@ -58,13 +58,10 @@ export const FormRunnerLoader = () => {
                     formFieldStates:
                       instantiatedForm.initialState.formFieldStates,
                     entity: instantiatedForm.initialState.entity,
-                    rawEntity: instantiatedForm.initialState.rawEntity,
                     commonFormState:
                       instantiatedForm.initialState.commonFormState,
                     customFormState:
                       instantiatedForm.initialState.customFormState,
-                    rawGlobalConfiguration:
-                      instantiatedForm.initialState.rawGlobalConfiguration,
                     globalConfiguration:
                       instantiatedForm.initialState.globalConfiguration,
                   }),
@@ -94,13 +91,10 @@ export const FormRunnerLoader = () => {
                     formFieldStates:
                       instantiatedForm.initialState.formFieldStates,
                     entity: instantiatedForm.initialState.entity,
-                    rawEntity: instantiatedForm.initialState.rawEntity,
                     commonFormState:
                       instantiatedForm.initialState.commonFormState,
                     customFormState:
                       instantiatedForm.initialState.customFormState,
-                    rawGlobalConfiguration:
-                      instantiatedForm.initialState.rawGlobalConfiguration,
                     globalConfiguration:
                       instantiatedForm.initialState.globalConfiguration,
                   }),
@@ -134,8 +128,6 @@ export const FormRunnerLoader = () => {
                     customFormState:
                       instantiatedForm.initialState.customFormState,
                     entity: undefined,
-                    rawEntity: undefined,
-                    rawGlobalConfiguration: undefined,
                     globalConfiguration: undefined,
                   }),
                 ),

package/src/forms/domains/launcher/domains/create/coroutines/runner.ts

@@ -21,69 +21,84 @@ import {
 import { CoTypedFactory } from "../../../../../../coroutines/builder";
 import { CreateFormContext, CreateFormWritableState } from "../state";
 
-export const createFormRunner = <E, FS>() => {
+export const createFormRunner = <T, FS>() => {
   const Co = CoTypedFactory<
-    CreateFormContext<E, FS> & CreateFormForeignMutationsExpected<E, FS>,
-    CreateFormWritableState<E, FS>
+    CreateFormContext<T, FS> & CreateFormForeignMutationsExpected<T, FS>,
+    CreateFormWritableState<T, FS>
   >();
 
   const init = Co.GetState().then((current) =>
     Co.Seq([
       Co.SetState(
-        CreateFormState<
-          E,
-          FS
-        >().Updaters.Core.customFormState.children.initApiChecker(
-          ApiResponseChecker.Updaters().toUnchecked(),
-        ),
+        CreateFormState<T, FS>()
+          .Updaters.Core.customFormState.children.initApiChecker(
+            ApiResponseChecker.Updaters().toUnchecked(),
+          )
+          .then(
+            CreateFormState<
+              T,
+              FS
+            >().Updaters.Core.customFormState.children.configApiChecker(
+              ApiResponseChecker.Updaters().toUnchecked(),
+            ),
+          ),
       ),
       Co.All([
-        Synchronize<Unit, E>(
-          () => current.api.default(),
+        Synchronize<Unit, PredicateValue>(
+          () =>
+            current.api.default().then((raw) => {
+              const result = current.fromApiParser(raw);
+              return result.kind == "errors"
+                ? Promise.reject(result.errors)
+                : Promise.resolve(result.value);
+            }),
           (_) => "transient failure",
           5,
           50,
-        ).embed(
-          (_) => _.rawEntity,
-          CreateFormState<E, FS>().Updaters.Core.rawEntity,
-        ),
-        Synchronize<Unit, any>(
-          () => current.api.getGlobalConfiguration(),
+        ).embed((_) => _.entity, CreateFormState<T, FS>().Updaters.Core.entity),
+        Synchronize<Unit, PredicateValue>(
+          () =>
+            current.api.getGlobalConfiguration().then((raw) => {
+              const result = current.parseGlobalConfiguration(raw);
+              return result.kind == "errors"
+                ? Promise.reject(result.errors)
+                : Promise.resolve(result.value);
+            }),
           (_) => "transient failure",
           5,
           50,
         ).embed(
-          (_) => _.rawGlobalConfiguration,
-          CreateFormState<E, FS>().Updaters.Core.rawGlobalConfiguration,
+          (_) => _.globalConfiguration,
+          CreateFormState<T, FS>().Updaters.Core.globalConfiguration,
         ),
       ]),
       HandleApiResponse<
-        CreateFormWritableState<E, FS>,
-        CreateFormContext<E, FS>,
+        CreateFormWritableState<T, FS>,
+        CreateFormContext<T, FS>,
         any
-      >((_) => _.rawEntity.sync, {
+      >((_) => _.entity.sync, {
         handleSuccess: current.apiHandlers?.onDefaultSuccess,
         handleError: current.apiHandlers?.onDefaultError,
       }),
       Co.SetState(
         CreateFormState<
-          E,
+          T,
           FS
         >().Updaters.Core.customFormState.children.initApiChecker(
           ApiResponseChecker.Updaters().toChecked(),
         ),
       ),
       HandleApiResponse<
-        CreateFormWritableState<E, FS>,
-        CreateFormContext<E, FS>,
+        CreateFormWritableState<T, FS>,
+        CreateFormContext<T, FS>,
         any
-      >((_) => _.rawGlobalConfiguration.sync, {
+      >((_) => _.globalConfiguration.sync, {
         handleSuccess: current.apiHandlers?.onConfigSuccess,
         handleError: current.apiHandlers?.onConfigError,
       }),
       Co.SetState(
         CreateFormState<
-          E,
+          T,
           FS
         >().Updaters.Core.customFormState.children.configApiChecker(
           ApiResponseChecker.Updaters().toChecked(),
@@ -92,73 +107,27 @@ export const createFormRunner = <E, FS>() => {
     ]),
   );
 
-  const parseEntity = Co.GetState().then((current) => {
-    if (current.rawEntity.sync.kind == "loaded") {
-      const parsed = current.fromApiParser(current.rawEntity.sync.value);
-      return Synchronize<Unit, any>(
-        () => Promise.resolve(parsed),
-        (_) => "transient failure",
-        5,
-        50,
-      ).embed((_) => _.entity, CreateFormState<E, FS>().Updaters.Core.entity);
-    }
-    return Co.Do(() => {});
-  });
-
-  const parseGlobalConfiguration = Co.GetState().then((current) => {
-    if (current.rawGlobalConfiguration.sync.kind == "loaded") {
-      const parsed = current.parseGlobalConfiguration(
-        current.rawGlobalConfiguration.sync.value,
-      );
-      if (parsed.kind == "value")
-        return Co.SetState(
-          CreateFormState<E, FS>().Updaters.Core.globalConfiguration(
-            replaceWith(Sum.Default.left(parsed.value)),
-          ),
-        );
-    }
-    return Co.Do(() => {});
-  });
-
   const calculateInitialVisibilities = Co.GetState().then((current) => {
     if (
-      current.rawEntity.sync.kind == "loaded" &&
-      current.rawGlobalConfiguration.sync.kind == "loaded"
+      current.entity.sync.kind == "loaded" &&
+      current.globalConfiguration.sync.kind == "loaded"
     ) {
-      const parsedRootPredicate = PredicateValue.Operations.parse(
-        current.rawEntity.sync.value,
-        current.formType,
-        current.types,
-      );
-
-      if (
-        parsedRootPredicate.kind == "errors" ||
-        current.globalConfiguration.kind == "r"
-      )
-        return Co.Do(() => {});
-      if (
-        typeof parsedRootPredicate.value != "object" ||
-        !("kind" in parsedRootPredicate.value) ||
-        parsedRootPredicate.value.kind != "record"
-      )
-        return Co.Do(() => {});
       return Co.SetState(
         CreateFormState<
-          E,
+          T,
           FS
         >().Updaters.Core.customFormState.children.predicateEvaluations(
           replaceWith(
             Debounced.Default(
               evaluatePredicates(
                 {
-                  global: current.globalConfiguration.value,
-                  types: current.types,
+                  global: current.globalConfiguration.sync.value,
                   visibilityPredicateExpressions:
                     current.visibilityPredicateExpressions,
                   disabledPredicatedExpressions:
                     current.disabledPredicatedExpressions,
                 },
-                parsedRootPredicate.value,
+                current.entity.sync.value,
               ),
             ),
           ),
@@ -169,7 +138,7 @@ export const createFormRunner = <E, FS>() => {
   });
 
   const PredicatesCo = CoTypedFactory<
-    CreateFormWritableState<E, FS> & CreateFormContext<E, FS>,
+    CreateFormWritableState<T, FS> & CreateFormContext<T, FS>,
     ValueOrErrors<
       {
         visiblityPredicateEvaluations: FormFieldPredicateEvaluation;
@@ -188,45 +157,27 @@ export const createFormRunner = <E, FS>() => {
         },
         string
       >,
-      CreateFormContext<E, FS> & CreateFormWritableState<E, FS>
+      CreateFormContext<T, FS> & CreateFormWritableState<T, FS>
     >(
       PredicatesCo.GetState().then((current) => {
         if (
-          current.globalConfiguration.kind == "r" ||
+          current.globalConfiguration.sync.kind != "loaded" ||
           current.entity.sync.kind != "loaded"
         ) {
           return PredicatesCo.Return<ApiResultStatus>("permanent failure");
         }
-        const parsedEntity = current.toApiParser(
-          current.entity.sync.value,
-          current,
-          false,
-        );
-        if (parsedEntity.kind == "errors") {
-          console.error("parsedEntity", parsedEntity);
-          return PredicatesCo.Return<ApiResultStatus>("permanent failure");
-        }
-        const parseRootPredicate = PredicateValue.Operations.parse(
-          parsedEntity.value,
-          current.formType,
-          current.types,
-        );
-        if (parseRootPredicate.kind == "errors") {
-          console.error("parseRootPredicate", parseRootPredicate);
-          return PredicatesCo.Return<ApiResultStatus>("permanent failure");
-        }
+
         return PredicatesCo.SetState(
           replaceWith(
             evaluatePredicates(
               {
-                global: current.globalConfiguration.value,
-                types: current.types,
+                global: current.globalConfiguration.sync.value,
                 visibilityPredicateExpressions:
                   current.visibilityPredicateExpressions,
                 disabledPredicatedExpressions:
                   current.disabledPredicatedExpressions,
               },
-              parseRootPredicate.value,
+              current.entity.sync.value,
             ),
           ),
         ).then(() => PredicatesCo.Return<ApiResultStatus>("success"));
@@ -234,29 +185,34 @@ export const createFormRunner = <E, FS>() => {
       50,
     ).embed(
       (_) => ({ ..._, ..._.customFormState.predicateEvaluations }),
-      CreateFormState<E, FS>().Updaters.Core.customFormState.children
+      CreateFormState<T, FS>().Updaters.Core.customFormState.children
         .predicateEvaluations,
     ),
   );
 
+  const SynchronizeCo = CoTypedFactory<
+    CreateFormWritableState<T, FS>,
+    Synchronized<Unit, ApiErrors>
+  >();
+
   const synchronize = Co.Repeat(
-    Co.GetState().then((current) =>
+    Co.GetState().then((createFormState) =>
       Co.Seq([
         Co.SetState(
           CreateFormState<
-            E,
+            T,
             FS
           >().Updaters.Core.customFormState.children.createApiChecker(
             ApiResponseChecker.Updaters().toUnchecked(),
           ),
         ),
-        Debounce<Synchronized<Unit, ApiErrors>, CreateFormWritableState<E, FS>>(
-          (() => {
+        Debounce<Synchronized<Unit, ApiErrors>, CreateFormWritableState<T, FS>>(
+          SynchronizeCo.GetState().then((current) => {
             if (current.entity.sync.kind != "loaded") {
               return Synchronize<
                 Unit,
                 ApiErrors,
-                CreateFormWritableState<E, FS>
+                CreateFormWritableState<T, FS>
               >(
                 (_) => Promise.resolve([]),
                 (_) => "transient failure",
@@ -264,39 +220,38 @@ export const createFormRunner = <E, FS>() => {
                 50,
               );
             }
-            const parsed = current.toApiParser(
+            const parsed = createFormState.toApiParser(
               current.entity.sync.value,
               current,
-              true,
             );
 
-            return Synchronize<Unit, ApiErrors, CreateFormWritableState<E, FS>>(
+            return Synchronize<Unit, ApiErrors, CreateFormWritableState<T, FS>>(
               (_) =>
                 parsed.kind == "errors"
                   ? Promise.reject(parsed.errors)
-                  : current.api.create(parsed),
+                  : createFormState.api.create(parsed),
               (_) => "transient failure",
               parsed.kind == "errors" ? 1 : 5,
               50,
             );
-          })(),
+          }),
           15,
         ).embed(
           (_) => ({ ..._, ..._.customFormState.apiRunner }),
-          CreateFormState<E, FS>().Updaters.Core.customFormState.children
+          CreateFormState<T, FS>().Updaters.Core.customFormState.children
             .apiRunner,
         ),
         HandleApiResponse<
-          CreateFormWritableState<E, FS>,
-          CreateFormContext<E, FS>,
+          CreateFormWritableState<T, FS>,
+          CreateFormContext<T, FS>,
           ApiErrors
         >((_) => _.customFormState.apiRunner.sync, {
-          handleSuccess: current.apiHandlers?.onCreateSuccess,
-          handleError: current.apiHandlers?.onCreateError,
+          handleSuccess: createFormState.apiHandlers?.onCreateSuccess,
+          handleError: createFormState.apiHandlers?.onCreateError,
         }),
         Co.SetState(
           CreateFormState<
-            E,
+            T,
             FS
           >().Updaters.Core.customFormState.children.createApiChecker(
             ApiResponseChecker.Updaters().toChecked(),
@@ -306,45 +261,28 @@ export const createFormRunner = <E, FS>() => {
     ),
   );
 
-  return Co.Template<CreateFormForeignMutationsExpected<E, FS>>(init, {
+  return Co.Template<CreateFormForeignMutationsExpected<T, FS>>(init, {
     interval: 15,
     runFilter: (props) =>
-      !AsyncState.Operations.hasValue(props.context.rawEntity.sync) ||
-      !AsyncState.Operations.hasValue(
-        props.context.rawGlobalConfiguration.sync,
-      ) ||
+      !AsyncState.Operations.hasValue(props.context.entity.sync) ||
+      !AsyncState.Operations.hasValue(props.context.globalConfiguration.sync) ||
       !ApiResponseChecker.Operations.checked(
         props.context.customFormState.initApiChecker,
       ),
   }).any([
-    Co.Template<CreateFormForeignMutationsExpected<E, FS>>(parseEntity, {
-      interval: 15,
-      runFilter: (props) =>
-        props.context.rawEntity.sync.kind == "loaded" &&
-        !AsyncState.Operations.hasValue(props.context.entity.sync),
-    }),
-    Co.Template<CreateFormForeignMutationsExpected<E, FS>>(
-      parseGlobalConfiguration,
-      {
-        interval: 15,
-        runFilter: (props) =>
-          props.context.rawGlobalConfiguration.sync.kind == "loaded" &&
-          props.context.globalConfiguration.kind == "r",
-      },
-    ),
-    Co.Template<CreateFormForeignMutationsExpected<E, FS>>(
+    Co.Template<CreateFormForeignMutationsExpected<T, FS>>(
       calculateInitialVisibilities,
       {
         interval: 15,
         runFilter: (props) =>
-          props.context.rawEntity.sync.kind == "loaded" &&
-          props.context.globalConfiguration.kind == "l",
+          props.context.entity.sync.kind == "loaded" &&
+          props.context.globalConfiguration.sync.kind == "loaded",
       },
     ),
-    Co.Template<CreateFormForeignMutationsExpected<E, FS>>(synchronize, {
+    Co.Template<CreateFormForeignMutationsExpected<T, FS>>(synchronize, {
       interval: 15,
       runFilter: (props) =>
-        props.context.entity.sync.kind === "loaded" &&
+        props.context.entity.sync.kind == "loaded" &&
         (Debounced.Operations.shouldCoroutineRun(
           props.context.customFormState.apiRunner,
         ) ||
@@ -352,13 +290,13 @@ export const createFormRunner = <E, FS>() => {
             props.context.customFormState.createApiChecker,
           )),
     }),
-    Co.Template<CreateFormForeignMutationsExpected<E, FS>>(
+    Co.Template<CreateFormForeignMutationsExpected<T, FS>>(
       calculateVisibilities,
       {
         interval: 15,
         runFilter: (props) =>
           props.context.entity.sync.kind == "loaded" &&
-          props.context.globalConfiguration.kind == "l" &&
+          props.context.globalConfiguration.sync.kind == "loaded" &&
           Debounced.Operations.shouldCoroutineRun(
             props.context.customFormState.predicateEvaluations,
           ),