ballerina-core 1.0.72 → 1.0.74

package/main.ts

@@ -117,6 +117,7 @@ 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"
 
 // import { simpleUpdater, simpleUpdaterWithChildren } from "./src/fun/domains/updater/domains/simpleUpdater/state"
 // import { Updater } from "./src/fun/domains/updater/state"

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.72",
+  "version": "1.0.74",
   "main": "main.ts",
   "dependencies": {
     "immutable": "^5.0.0-beta.5",

package/src/collections/domains/valueOrErrors/state.ts

@@ -2,7 +2,7 @@ import { List } from "immutable";
 import { BasicFun, BasicFun2, Fun } from "../../../fun/state";
 import { Value } from "../../../value/state";
 import { Errors } from "../errors/state"
-import { unit, Unit, Updater, Option } from "../../../../main";
+import { unit, Unit, Updater, Option, Sum } from "../../../../main";
 
 export type ValueOrErrors<v, e> = (
   | (Value<v> & { kind: "value" })
@@ -122,25 +122,23 @@ export const ValueOrErrors = {
           ValueOrErrors.Operations.Map<a, ValueOrErrors<b, e>, e>(k)(_)
         )
       ),
+    Catch: <v, e>(_: ValueOrErrors<v, e>): ValueOrErrors<Sum<v, List<e>>, e> =>
+      _.kind == "errors" ?
+        ValueOrErrors.Default.return(Sum.Default.right(_.errors)) : ValueOrErrors.Default.return(Sum.Default.left(_.value)),
     Fold: <v, e, c>(
       l: BasicFun<v, c>,
       r: BasicFun<List<e>, c>
     ): Fun<ValueOrErrors<v, e>, c> =>
       Fun((_) => (_.kind == "value" ? l(_.value) : r(_.errors))),
     All: <v, e>(_: List<ValueOrErrors<v, e>>): ValueOrErrors<List<v>, e> =>
-      _.reduce(
-        (reduction, value) =>
-          ValueOrErrors.Operations.Fold<v, e, ValueOrErrors<List<v>, e>>(
-            (v: v) =>
-              reduction.kind == "errors"
-                ? reduction
-                : reduction.Map((_) => _.concat(v)),
-            (es: List<e>) =>
-              reduction.kind == "errors"
-                ? reduction.MapErrors((_) => _.concat(es))
-                : ValueOrErrors.Default.throw(es)
-          )(value),
-        ValueOrErrors.Default.return(List<v>())
-      ),
+      _.size == 0 ? 
+        ValueOrErrors.Default.return(List())
+      : ValueOrErrors.Operations.Catch(_.first()!).Then(res_p => 
+        res_p.kind == "l" ? 
+          ValueOrErrors.Operations.All(_.slice(1).toList()).Then(values => 
+            ValueOrErrors.Default.return(List<v>().push(res_p.value).concat(values))
+          )
+        : ValueOrErrors.Default.throw(res_p.value)
+      )
   },
 };

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

@@ -40,8 +40,11 @@ export const FormRunnerLoader = () => {
                     form: instantiatedForm.form,
                     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
                   })
                 )
               )  
@@ -62,8 +65,11 @@ export const FormRunnerLoader = () => {
                     form: instantiatedForm.form,
                     formFieldStates: instantiatedForm.initialState.formFieldStates,
                     entity: instantiatedForm.initialState.entity,
+                    rawEntity: instantiatedForm.initialState.rawEntity,
                     commonFormState: instantiatedForm.initialState.commonFormState,
-                    customFormState: instantiatedForm.initialState.customFormState
+                    customFormState: instantiatedForm.initialState.customFormState,
+                    rawGlobalConfiguration: instantiatedForm.initialState.rawGlobalConfiguration,
+                    globalConfiguration: instantiatedForm.initialState.globalConfiguration
                   })
                 )
               )

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

@@ -10,6 +10,13 @@ import {
   Unit,
   HandleApiResponse,
   ApiResponseChecker,
+  Sum,
+  replaceWith,
+  PredicateValue,
+  evaluatePredicates,
+  FormFieldPredicateEvaluation,
+  ValueOrErrors,
+  ApiResultStatus,
 } from "../../../../../../../main";
 import { CoTypedFactory } from "../../../../../../coroutines/builder";
 import { CreateFormContext, CreateFormWritableState } from "../state";
@@ -23,31 +30,124 @@ export const createFormRunner = <E, FS>() => {
   const init = Co.GetState().then((current) =>
     Co.Seq([
       Co.SetState(
-        CreateFormState<
-          E,
-          FS
-        >().Updaters.Core.customFormState.children.initApiChecker(ApiResponseChecker.Updaters().toUnchecked())
+        CreateFormState<E,FS>().Updaters.Core.customFormState.children.initApiChecker(ApiResponseChecker.Updaters().toUnchecked())
       ),
-      Synchronize<Unit, E>(
-        () => current.api.default(),
-        (_) => "transient failure",
-        5,
-        50
-      ).embed((_) => _.entity, CreateFormState<E, FS>().Updaters.Core.entity),
+      Co.All([
+        Synchronize<Unit, E>(
+          () => current.api.default(),
+          (_) => "transient failure",
+          5,
+          50
+        ).embed((_) => _.rawEntity, CreateFormState<E, FS>().Updaters.Core.rawEntity),
+        Synchronize<Unit, any>(
+          () => current.api.getGlobalConfiguration(),
+          (_) => "transient failure",
+          5,
+          50
+        ).embed((_) => _.rawGlobalConfiguration, CreateFormState<E, FS>().Updaters.Core.rawGlobalConfiguration),
+      ]),
       HandleApiResponse<
         CreateFormWritableState<E, FS>,
         CreateFormContext<E, FS>,
-        E
-      >((_) => _.entity.sync, {
+        any
+      >((_) => _.rawEntity.sync, {
         handleSuccess: current.apiHandlers?.onDefaultSuccess,
         handleError: current.apiHandlers?.onDefaultError,
       }),
       Co.SetState(
         CreateFormState<E, FS>().Updaters.Core.customFormState.children.initApiChecker(ApiResponseChecker.Updaters().toChecked())
       ),
-    ])
+      HandleApiResponse<
+      CreateFormWritableState<E, FS>,
+      CreateFormContext<E, FS>,
+      any
+    >((_) => _.rawGlobalConfiguration.sync, {
+      handleSuccess: current.apiHandlers?.onConfigSuccess,
+      handleError: current.apiHandlers?.onConfigError,
+    }),
+    Co.SetState(
+      CreateFormState<E, FS>().Updaters.Core.customFormState.children.configApiChecker(ApiResponseChecker.Updaters().toChecked())
+    ),
+    ]),
   );
 
+  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") {
+      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, FS>().Updaters.Core.customFormState.children.predicateEvaluations(
+        replaceWith(Debounced.Default(evaluatePredicates({
+          global: current.globalConfiguration.value,
+          types: current.types,
+          visibilityPredicateExpressions: current.visibilityPredicateExpressions,
+          disabledPredicatedExpressions: current.disabledPredicatedExpressions
+        }, parsedRootPredicate.value)))))
+    }
+    return Co.Do(() => {})
+  })
+
+  const PredicatesCo = CoTypedFactory<CreateFormWritableState<E, FS> & CreateFormContext<E, FS>, ValueOrErrors<{
+    visiblityPredicateEvaluations: FormFieldPredicateEvaluation;
+    disabledPredicateEvaluations: FormFieldPredicateEvaluation;
+  }, string>>();
+
+  const calculateVisibilities = 
+    Co.Repeat(
+      Debounce<ValueOrErrors<{visiblityPredicateEvaluations: FormFieldPredicateEvaluation; disabledPredicateEvaluations: FormFieldPredicateEvaluation;}, string>, CreateFormContext<E, FS> & CreateFormWritableState<E, FS>>(
+        PredicatesCo.GetState().then((current) => {
+            if((current.globalConfiguration.kind == "r" || 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,
+              visibilityPredicateExpressions: current.visibilityPredicateExpressions,
+              disabledPredicatedExpressions: current.disabledPredicatedExpressions
+            }, parseRootPredicate.value))).then(() => PredicatesCo.Return<ApiResultStatus>("success"))
+          })
+        , 50)
+        .embed(
+        (_) => ({ ..._, ..._.customFormState.predicateEvaluations }),
+        CreateFormState<E, FS>().Updaters.Core.customFormState.children.predicateEvaluations)
+    )
+
   const synchronize = Co.Repeat(
     Co.GetState().then((current) =>
       Co.Seq([
@@ -63,7 +163,7 @@ export const createFormRunner = <E, FS>() => {
                 50
               )
             }
-            const parsed = current.parser(current.entity.sync.value, current)
+            const parsed = current.toApiParser(current.entity.sync.value, current, true)
 
             return Synchronize<Unit, ApiErrors, CreateFormWritableState<E, FS>>(
               (_) => parsed.kind == "errors" ? Promise.reject(parsed.errors) : current.api.create(parsed),
@@ -95,8 +195,25 @@ export const createFormRunner = <E, FS>() => {
   return Co.Template<CreateFormForeignMutationsExpected<E, FS>>(init, {
     interval: 15,
     runFilter: (props) =>
-      !AsyncState.Operations.hasValue(props.context.entity.sync) || !ApiResponseChecker.Operations.checked(props.context.customFormState.initApiChecker),
+      !AsyncState.Operations.hasValue(props.context.rawEntity.sync) || !AsyncState.Operations.hasValue(props.context.rawGlobalConfiguration.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>>(calculateInitialVisibilities, {
+      interval: 15,
+      runFilter: (props) =>
+        props.context.rawEntity.sync.kind == "loaded" &&
+        props.context.globalConfiguration.kind == "l"
+    }),
     Co.Template<CreateFormForeignMutationsExpected<E, FS>>(synchronize, {
       interval: 15,
       runFilter: (props) =>
@@ -104,5 +221,12 @@ export const createFormRunner = <E, FS>() => {
         (Debounced.Operations.shouldCoroutineRun(props.context.customFormState.apiRunner) ||
         !ApiResponseChecker.Operations.checked(props.context.customFormState.createApiChecker))
     }),
+    Co.Template<CreateFormForeignMutationsExpected<E, FS>>(calculateVisibilities, {
+      interval: 15,
+      runFilter: (props) =>
+        props.context.entity.sync.kind == "loaded" &&
+        props.context.globalConfiguration.kind == "l" &&
+        Debounced.Operations.shouldCoroutineRun(props.context.customFormState.predicateEvaluations)
+    })
   ]);
 };

package/src/forms/domains/launcher/domains/create/state.ts

@@ -1,26 +1,41 @@
-import { ApiErrors, ApiResponseChecker, AsyncState, BasicUpdater, CommonFormState, Debounced, ForeignMutationsInput, id, SimpleCallback, simpleUpdater, simpleUpdaterWithChildren, Synchronized, Template, unit, Unit, Updater, Value } from "../../../../../../main"
-import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state"
-import { BasicFun } from "../../../../../fun/state"
+import { ApiErrors, ApiResponseChecker, AsyncState, BasicUpdater, CommonFormState, Debounced, FieldPredicateExpressions, ForeignMutationsInput, FormFieldPredicateEvaluation, id, ParsedType, PredicateValue, SimpleCallback, simpleUpdater, simpleUpdaterWithChildren, Sum, Synchronized, Template, unit, Unit, Updater, Value } from "../../../../../../main"
+import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
+import { Map } from "immutable";
 
 export type CreateFormContext<E,FS> = {
   entityId:string,
   api:{
     default:() => Promise<E>,
-    create: (raw: any) => Promise<ApiErrors>
+    create: (raw: any) => Promise<ApiErrors>,
+    getGlobalConfiguration: () => Promise<any>
   },
-  parser: (entity:E, formstate: CreateFormState<E,FS>) => ValueOrErrors<E, ApiErrors>,
-  actualForm:Template<Value<E> & {formFieldStates:FS} & { commonFormState: CommonFormState }, {formFieldStates: FS} & { commonFormState: CommonFormState }, { onChange:SimpleCallback<BasicUpdater<E>> }>
+  formType: ParsedType<E>,
+  types: Map<string, ParsedType<E>>,
+  toApiParser: (entity:E, formstate: CreateFormState<E,FS>, checkKeys: boolean) => ValueOrErrors<E, ApiErrors>,
+  fromApiParser: (raw: any) => any,
+  parseGlobalConfiguration: (raw: any) => ValueOrErrors<PredicateValue, ApiErrors>,
+  visibilityPredicateExpressions: FieldPredicateExpressions,
+  disabledPredicatedExpressions: FieldPredicateExpressions,
+  actualForm:Template<Value<E> & {formFieldStates:FS} & { commonFormState: CommonFormState } & { visibilities: FormFieldPredicateEvaluation | undefined } & { disabledFields: FormFieldPredicateEvaluation | undefined }, {formFieldStates: FS} & { commonFormState: CommonFormState }, { onChange:SimpleCallback<BasicUpdater<E>> }>
 }
 
 export type CreateFormState<E,FS> = {
+  rawEntity: Synchronized<Unit, any>,
   entity: Synchronized<Unit, E>
+  rawGlobalConfiguration: Synchronized<Unit, any>,
+  globalConfiguration: Sum<any, "not parsed">
   formFieldStates: FS,
   commonFormState: CommonFormState,
   customFormState: {
     initApiChecker: ApiResponseChecker,
+    configApiChecker: ApiResponseChecker,
     createApiChecker: ApiResponseChecker,
+    predicateEvaluations: Debounced<ValueOrErrors<{
+      visiblityPredicateEvaluations: FormFieldPredicateEvaluation;
+      disabledPredicateEvaluations: FormFieldPredicateEvaluation;
+    }, string>>,
     apiRunner: Debounced<Synchronized<Unit, ApiErrors>>
-  }
+  },
 }
 
 export const CreateFormState = <E,FS>() => ({
@@ -28,22 +43,36 @@ export const CreateFormState = <E,FS>() => ({
     commonFormState: CommonFormState,
     customFormState: {
       initApiChecker: ApiResponseChecker,
+      configApiChecker: ApiResponseChecker,
       createApiChecker: ApiResponseChecker,
+      predicateEvaluations: Debounced<ValueOrErrors<{
+        visiblityPredicateEvaluations: FormFieldPredicateEvaluation;
+        disabledPredicateEvaluations: FormFieldPredicateEvaluation;
+      }, string>>,
+      shouldCalculatePredicates: boolean,
       apiRunner: Debounced<Synchronized<Unit, ApiErrors>>
   }) : CreateFormState<E,FS> => ({
+    rawEntity: Synchronized.Default(unit),
     entity:Synchronized.Default(unit),
+    rawGlobalConfiguration: Synchronized.Default(unit),
+    globalConfiguration: Sum.Default.right("not parsed"),
     formFieldStates,
     commonFormState,
-    customFormState
+    customFormState,
   }),
   Updaters:{
     Core:{
+      ...simpleUpdater<CreateFormState<E,FS>>()("rawEntity"),
       ...simpleUpdater<CreateFormState<E,FS>>()("entity"),
+      ...simpleUpdater<CreateFormState<E,FS>>()("rawGlobalConfiguration"),
+      ...simpleUpdater<CreateFormState<E,FS>>()("globalConfiguration"),
       ...simpleUpdater<CreateFormState<E,FS>>()("formFieldStates"),
       ...simpleUpdaterWithChildren<CreateFormState<E,FS>>()({
           ...simpleUpdater<CreateFormState<E,FS>["customFormState"]>()("initApiChecker"),
+          ...simpleUpdater<CreateFormState<E,FS>["customFormState"]>()("configApiChecker"),
           ...simpleUpdater<CreateFormState<E,FS>["customFormState"]>()("createApiChecker"),
           ...simpleUpdater<CreateFormState<E,FS>["customFormState"]>()("apiRunner"),
+          ...simpleUpdater<CreateFormState<E,FS>["customFormState"]>()("predicateEvaluations"),
       })("customFormState"),
       ...simpleUpdater<CreateFormState<E,FS>>()("commonFormState"),
     },
@@ -65,8 +94,13 @@ export const CreateFormState = <E,FS>() => ({
                 )
               )
             )
+          ),
+      recalculatePredicates: () : Updater<CreateFormState<E,FS>> => 
+        CreateFormState<E,FS>().Updaters.Core.customFormState.children.predicateEvaluations(
+          Debounced.Updaters.Template.value(
+            id
           )
-  
+        )
     }
   },
   ForeignMutations: (_: ForeignMutationsInput<CreateFormContext<E,FS>, CreateFormWritableState<E,FS>>) => ({
@@ -80,6 +114,8 @@ export type CreateFormForeignMutationsExpected<E,FS> = {
   apiHandlers?: {
     onDefaultSuccess?: (_: CreateFormWritableState<E, FS> & CreateFormContext<E, FS> | undefined) => void;
     onDefaultError?: <ApiErrors>(_: ApiErrors | undefined) => void;
+    onConfigSuccess?: (_: CreateFormWritableState<E, FS> & CreateFormContext<E, FS> | undefined) => void;
+    onConfigError?: <ApiErrors>(_: ApiErrors | undefined) => void;
     onCreateSuccess?: (_: CreateFormWritableState<E, FS> & CreateFormContext<E, FS> | undefined) => void;
     onCreateError?: <ApiErrors>(_: ApiErrors | undefined) => void;
   }

package/src/forms/domains/launcher/domains/create/template.tsx

@@ -22,6 +22,12 @@ export const CreateFormTemplate = <E, FS>(): CreateFormTemplate<E, FS> =>
     CreateFormWritableState<E, FS>,
     CreateFormForeignMutationsExpected<E, FS>,
     CreateFormView<E, FS>>(props => {
+      const visibilities = props.context.customFormState.predicateEvaluations.kind == "value" && 
+        props.context.customFormState.predicateEvaluations.value.visiblityPredicateEvaluations.kind == "form" ?
+        props.context.customFormState.predicateEvaluations.value.visiblityPredicateEvaluations : undefined;
+      const disabledFields = props.context.customFormState.predicateEvaluations.kind == "value" 
+        && props.context.customFormState.predicateEvaluations.value.disabledPredicateEvaluations.kind == "form" ?
+        props.context.customFormState.predicateEvaluations.value.disabledPredicateEvaluations : undefined;
       return <>
         {
           props.view({
@@ -40,6 +46,8 @@ export const CreateFormTemplate = <E, FS>(): CreateFormTemplate<E, FS> =>
                       value: props.context.entity.sync.value,
                       formFieldStates: props.context.formFieldStates,
                       commonFormState: props.context.commonFormState,
+                      visibilities,
+                      disabledFields
                     },
                     setState: _ => {
                       props.setState(__ => ({
@@ -50,7 +58,8 @@ export const CreateFormTemplate = <E, FS>(): CreateFormTemplate<E, FS> =>
                     },
                     foreignMutations: {
                       onChange: (e) => {
-                        props.setState(CreateFormState<E, FS>().Updaters.Template.entity(e))
+                        props.setState(CreateFormState<E, FS>().Updaters.Template.entity(e));
+                        props.setState(CreateFormState<E, FS>().Updaters.Template.recalculatePredicates())
                       }
                     },
                     view: unit