ballerina-core 1.0.83 → 1.0.84

package/package.json

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

package/src/forms/domains/parser/domains/built-ins/state.ts

@@ -12,6 +12,7 @@ import {
   PredicateValue,
   Sum,
   TypeName,
+  unit,
   ValueRecord,
   ValueTuple,
 } from "../../../../../../main";
@@ -60,7 +61,7 @@ export type ApiConverters<
 > = { [key in keyof T]: ApiConverter<T[key]["type"]> } & BuiltInApiConverters;
 
 export type VerifiedRawUnionCase = {
-  caseName: string;
+  case: string;
   fields: Record<string, any>;
 };
 
@@ -70,7 +71,7 @@ export const VerifiedRawUnionCase = {
       return (
         typeof value == "object" &&
         "caseName" in value &&
-        typeof value.caseName == "string" &&
+        typeof value.case == "string" &&
         "fields" in value &&
         typeof value.fields == "object"
       );
@@ -325,8 +326,19 @@ export const fromAPIRawValue =
       );
     }
     if (t.kind == "union") {
+      if (!VerifiedRawUnionCase.Operations.IsVerifiedRawUnionCase(raw)) {
+        return ValueOrErrors.Default.throwOne(
+          `union expected but got ${JSON.stringify(raw)}`,
+        );
+      }
+      const caseType = t.args.get(raw.case);
+      if (caseType == undefined) {
+        return ValueOrErrors.Default.throwOne(
+          `union case ${raw.case} not found in type ${JSON.stringify(t)}`,
+        );
+      }
       return fromAPIRawValue(
-        { kind: "unionCase", name: "", fields: {} as ParsedType<T> },
+        caseType,
         types,
         builtIns,
         converters,
@@ -340,12 +352,28 @@ export const fromAPIRawValue =
         );
       }
       const result = converters[t.kind].fromAPIRawValue(raw);
-      return ValueOrErrors.Default.return(
-        PredicateValue.Default.unionCase(
-          result.caseName,
-          PredicateValue.Default.record(Map(result.fields)),
-        ),
-      );
+      return fromAPIRawValue(
+        t.fields == unit
+          ? {
+              kind: "form",
+              value: "unionCase",
+              fields: Map<string, ParsedType<T>>(),
+            }
+          : t.fields,
+        types,
+        builtIns,
+        converters,
+        injectedPrimitives,
+      )(result.fields).Then((fields) => {
+        if (!PredicateValue.Operations.IsRecord(fields)) {
+          return ValueOrErrors.Default.throwOne(
+            `record expected but got ${JSON.stringify(fields)}`,
+          );
+        }
+        return ValueOrErrors.Default.return(
+          PredicateValue.Default.unionCase(result.case, fields),
+        );
+      });
     }
     if (t.kind == "application") {
       if (t.value == "SingleSelection") {
@@ -567,7 +595,7 @@ export const toAPIRawValue =
       }
       return ValueOrErrors.Operations.Return(
         converters[t.kind].toAPIRawValue([
-          { caseName: raw.caseName, fields: raw.fields },
+          { case: raw.caseName, fields: raw.fields },
           formState.modifiedByUser,
         ]),
       );
@@ -637,7 +665,9 @@ export const toAPIRawValue =
             !EnumReference.Operations.IsEnumReference(fieldsObject)
           ) {
             return ValueOrErrors.Default.throwOne(
-              `CollectionReference or EnumReference expected but got ${JSON.stringify(fieldsObject)}`,
+              `CollectionReference or EnumReference expected but got ${JSON.stringify(
+                fieldsObject,
+              )}`,
             );
           }
           return ValueOrErrors.Default.return(fieldsObject);

package/src/forms/domains/parser/domains/predicates/state.ts

@@ -177,6 +177,9 @@ export type PredicateValue =
   | ValueOption
   | ValueVarLookup;
 
+export type ExprLambda = { kind: "lambda"; parameter: string; body: Expr };
+export type ExprMatchCase = { kind: "matchCase"; operands: Expr[] };
+export type ExprCase = { kind: "caseName"; caseName: string; handler: ExprLambda };
 export type ExprFieldLookup = { kind: "fieldLookup"; operands: [Expr, string] };
 export type ExprIsCase = { kind: "isCase"; operands: [Expr, string] };
 export type ExprBinaryOperator = {
@@ -188,7 +191,10 @@ export type Expr =
   | PredicateValue
   | ExprFieldLookup
   | ExprIsCase
-  | ExprBinaryOperator;
+  | ExprBinaryOperator
+  | ExprLambda
+  | ExprMatchCase
+  | ExprCase;
 
 export const BinaryOperators = ["or", "equals"] as const;
 export const BinaryOperatorsSet = Set(BinaryOperators);
@@ -451,11 +457,6 @@ export const PredicateValue = {
         return PredicateValue.Operations.parse(json, subType, types);
       }
       if (type.kind == "unionCase") {
-        if (Object.keys(type.fields).length > 0) {
-          return ValueOrErrors.Default.throwOne(
-            `Error: union case ${type} has fields, not a valid enum`,
-          );
-        }
         return PredicateValue.Operations.ParseAsUnionCase({
           kind: "unionCase",
           caseName: json,
@@ -466,7 +467,7 @@ export const PredicateValue = {
         const unionCase = type.args.get(json);
         if (unionCase == undefined) {
           return ValueOrErrors.Default.throwOne(
-            `Error: cannot find union case ${json} in types`,
+            `Error: cannot find union case ${JSON.stringify(json)} in types`,
           );
         }
         return PredicateValue.Operations.parse(json, unionCase, types);
@@ -658,6 +659,20 @@ export const Expr = {
       kind: op,
       operands: [e1, e2],
     }),
+    matchCase: (operands: Expr[]): Expr => ({
+      kind: "matchCase",
+      operands,
+    }),
+    lambda: (parameter: string, body: Expr): Expr => ({
+      kind: "lambda",
+      parameter,
+      body,
+    }),
+    case: (caseName: string, handler: ExprLambda): Expr => ({
+      kind: "caseName",
+      caseName,
+      handler,
+    }),
   },
   Operations: {
     IsFieldLookup: (e: Expr): e is ExprFieldLookup => {
@@ -681,6 +696,30 @@ export const Expr = {
         BinaryOperatorsSet.has(e.kind as BinaryOperator)
       );
     },
+    IsCase: (e: Expr): e is ExprCase => {
+      return (
+        typeof e == "object" &&
+        !PredicateValue.Operations.IsDate(e) &&
+        e.kind == "caseName"
+      );
+    },
+    IsCaseArray: (e: Expr[]): e is ExprCase[] => {
+      return e.every((e) => Expr.Operations.IsCase(e));
+    },
+    IsMatchCase: (e: Expr): e is ExprMatchCase => {
+      return (
+        typeof e == "object" &&
+        !PredicateValue.Operations.IsDate(e) &&
+        e.kind == "matchCase"
+      );
+    },
+    IsLambda: (e: Expr): e is ExprLambda => {
+      return (
+        typeof e == "object" &&
+        !PredicateValue.Operations.IsDate(e) &&
+        e.kind == "lambda"
+      );
+    },
     parse: (json: any): ValueOrErrors<Expr, string> => {
       const asValue = PredicateValue.Operations.parse(
         json,
@@ -688,27 +727,22 @@ export const Expr = {
         Map<string, ParsedType<unknown>>(),
       );
       if (asValue.kind == "value") return asValue;
-      if (
-        "kind" in json &&
-        "operands" in json &&
-        typeof json["kind"] == "string" &&
-        Array.isArray(json["operands"]) &&
-        json["operands"].length == 2
-      ) {
-        const kind: string = json["kind"];
+
+      if (Expr.Operations.IsFieldLookup(json)) {
+        const [first, second]: Array<any> = json["operands"];
+        return Expr.Operations.parse(first).Then((first) =>
+          ValueOrErrors.Default.return(Expr.Default.fieldLookup(first, second)),
+        );
+      }
+      if (Expr.Operations.IsIsCase(json)) {
+        const [first, second]: Array<any> = json["operands"];
+        return Expr.Operations.parse(first).Then((first) =>
+          ValueOrErrors.Default.return(Expr.Default.isCase(first, second)),
+        );
+      }
+
+      if (Expr.Operations.IsBinaryOperator(json)) {
         const [first, second]: Array<any> = json["operands"];
-        if (json["kind"] == "fieldLookup" && typeof second == "string") {
-          return Expr.Operations.parse(first).Then((first) =>
-            ValueOrErrors.Default.return(
-              Expr.Default.fieldLookup(first, second),
-            ),
-          );
-        }
-        if (json["kind"] == "isCase" && typeof second == "string") {
-          return Expr.Operations.parse(first).Then((first) =>
-            ValueOrErrors.Default.return(Expr.Default.isCase(first, second)),
-          );
-        }
         if (BinaryOperatorsSet.contains(json["kind"] as BinaryOperator)) {
           return Expr.Operations.parse(first).Then((first) =>
             Expr.Operations.parse(second).Then((second) =>
@@ -719,6 +753,36 @@ export const Expr = {
           );
         }
       }
+
+      if (Expr.Operations.IsMatchCase(json)) {
+        return ValueOrErrors.Operations.All(
+          List<ValueOrErrors<Expr, string>>(
+            json["operands"].map((operand) => Expr.Operations.parse(operand)),
+          ),
+        ).Then((operands) =>
+          ValueOrErrors.Default.return(
+            Expr.Default.matchCase(operands.toArray()),
+          ),
+        );
+      }
+      if (Expr.Operations.IsLambda(json)) {
+        return Expr.Operations.parse(json["body"]).Then((body) =>
+          ValueOrErrors.Default.return(
+            Expr.Default.lambda(json["parameter"], body),
+          ),
+        );
+      }
+      if (Expr.Operations.IsCase(json)) {
+        return Expr.Operations.parse(json["handler"]).Then((handler) =>
+          Expr.Operations.IsLambda(handler)
+            ? ValueOrErrors.Default.return(
+                Expr.Default.case(json["caseName"], handler),
+              )
+            : ValueOrErrors.Default.throwOne(
+                `Error: expected lambda, got ${JSON.stringify(handler)}`,
+              ),
+        );
+      }
       return ValueOrErrors.Default.throwOne(
         `Error: cannot parse ${JSON.stringify(json)} to Expr.`,
       );
@@ -747,6 +811,26 @@ export const Expr = {
               `Error: expected boolean, got ${JSON.stringify(e)}`,
             )
           : ValueOrErrors.Default.return(e),
+    MatchCase:
+      (vars: Bindings) =>
+      (
+        e: ValueUnionCase,
+        cases: ExprCase[],
+      ): ValueOrErrors<PredicateValue, string> => {
+        const matchedCase = cases.find((c) => c.caseName == e.caseName);
+        if (matchedCase == undefined) {
+          return ValueOrErrors.Default.throwOne(
+            `Error: cannot find match case ${JSON.stringify(
+              e.caseName,
+            )} in ${JSON.stringify(cases)}`,
+          );
+        }
+        const updatedBindings = vars.set(
+          matchedCase.handler.parameter,
+          e.fields,
+        );
+        return Expr.Operations.Evaluate(updatedBindings)(matchedCase.handler);
+      },
     Evaluate:
       (vars: Bindings) =>
       (e: Expr): ValueOrErrors<PredicateValue, string> => {
@@ -767,8 +851,8 @@ export const Expr = {
               )
             : Expr.Operations.IsFieldLookup(e)
               ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                  (record: PredicateValue) =>
-                    Expr.Operations.EvaluateAsRecord(vars)(record).Then(
+                  (maybeRecord: PredicateValue) =>
+                    Expr.Operations.EvaluateAsRecord(vars)(maybeRecord).Then(
                       (record: ValueRecord) =>
                         MapRepo.Operations.tryFindWithError(
                           e.operands[1],
@@ -782,39 +866,68 @@ export const Expr = {
                 )
               : Expr.Operations.IsIsCase(e)
                 ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                    (unionCase: PredicateValue) =>
-                      Expr.Operations.EvaluateAsUnionCase(vars)(unionCase).Then(
-                        (unionCase: ValueUnionCase) =>
-                          ValueOrErrors.Default.return(
-                            unionCase.caseName == e.operands[1],
-                          ),
-                      ),
-                  )
-                : Expr.Operations.IsBinaryOperator(e) && e.kind == "equals"
-                  ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((v1) =>
-                      Expr.Operations.Evaluate(vars)(e.operands[1]).Then((v2) =>
-                        PredicateValue.Operations.Equals(vars)(v1, v2).Then(
-                          (eq) => ValueOrErrors.Default.return(eq),
+                    (maybeUnionCase: PredicateValue) =>
+                      Expr.Operations.EvaluateAsUnionCase(vars)(
+                        maybeUnionCase,
+                      ).Then((unionCase: ValueUnionCase) =>
+                        ValueOrErrors.Default.return(
+                          unionCase.caseName == e.operands[1],
                         ),
                       ),
+                  )
+                : Expr.Operations.IsMatchCase(e)
+                  ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
+                      (maybeUnionCase: PredicateValue) =>
+                        Expr.Operations.EvaluateAsUnionCase(vars)(
+                          maybeUnionCase,
+                        ).Then((unionCase: ValueUnionCase) => {
+                          const cases = e.operands.slice(1);
+                          if (!Expr.Operations.IsCaseArray(cases)) {
+                            return ValueOrErrors.Default.throwOne(
+                              `Error: expected cases, got ${JSON.stringify(cases)}`,
+                            );
+                          }
+                          return Expr.Operations.MatchCase(vars)(
+                            unionCase,
+                            cases,
+                          );
+                        }),
                     )
-                  : Expr.Operations.IsBinaryOperator(e) && e.kind == "or"
-                    ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((v1) =>
-                        Expr.Operations.Evaluate(vars)(e.operands[1]).Then(
-                          (v2) =>
-                            Expr.Operations.EvaluateAsBoolean(vars)(v1).Then(
-                              (v1) =>
-                                Expr.Operations.EvaluateAsBoolean(vars)(
+                  : Expr.Operations.IsLambda(e)
+                    ? Expr.Operations.Evaluate(vars)(e.body)
+                    : Expr.Operations.IsBinaryOperator(e) && e.kind == "equals"
+                      ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
+                          (v1) =>
+                            Expr.Operations.Evaluate(vars)(e.operands[1]).Then(
+                              (v2) =>
+                                PredicateValue.Operations.Equals(vars)(
+                                  v1,
                                   v2,
-                                ).Then((v2) =>
-                                  ValueOrErrors.Default.return(v1 || v2),
+                                ).Then((eq) =>
+                                  ValueOrErrors.Default.return(eq),
                                 ),
                             ),
-                        ),
-                      )
-                    : ValueOrErrors.Default.throwOne(
-                        `Error: unsupported expression ${JSON.stringify(e)}`,
-                      );
+                        )
+                      : Expr.Operations.IsBinaryOperator(e) && e.kind == "or"
+                        ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
+                            (v1) =>
+                              Expr.Operations.Evaluate(vars)(
+                                e.operands[1],
+                              ).Then((v2) =>
+                                Expr.Operations.EvaluateAsBoolean(vars)(
+                                  v1,
+                                ).Then((v1) =>
+                                  Expr.Operations.EvaluateAsBoolean(vars)(
+                                    v2,
+                                  ).Then((v2) =>
+                                    ValueOrErrors.Default.return(v1 || v2),
+                                  ),
+                                ),
+                              ),
+                          )
+                        : ValueOrErrors.Default.throwOne(
+                            `Error: unsupported expression ${JSON.stringify(e)}`,
+                          );
       },
   },
 };
@@ -960,7 +1073,9 @@ export const evaluatePredicates = <T>(
                   const valueLocal = kv.values.get(1)!;
                   if (keyLocal == undefined || valueLocal == undefined) {
                     return ValueOrErrors.Default.throwOne(
-                      `Error: cannot find key or value of ${JSON.stringify(kv)} in local ${JSON.stringify(raw)}`,
+                      `Error: cannot find key or value of ${JSON.stringify(
+                        kv,
+                      )} in local ${JSON.stringify(raw)}`,
                     );
                   }
                   const keyBindings = bindings.set("local", keyLocal);
@@ -998,7 +1113,9 @@ export const evaluatePredicates = <T>(
           });
         }
         return ValueOrErrors.Default.throwOne(
-          `Error: parsing expected tuple of key value pairs, got ${JSON.stringify(raw)}`,
+          `Error: parsing expected tuple of key value pairs, got ${JSON.stringify(
+            raw,
+          )}`,
         );
       });
     }

package/src/forms/domains/parser/domains/renderer/state.ts

@@ -348,41 +348,41 @@ export const ParsedRenderer = {
         case "enum":
         case "stream":
           return Expr.Operations.parse(parsedRenderer.visible ?? true).Then(
-            (visibilityExpr) =>
-              Expr.Operations.parse(parsedRenderer.disabled ?? false).Then(
-                (disabledExpr) =>
-                  ValueOrErrors.Default.return({
-                    form: {
-                      renderer: ParsedRenderer.Operations.FormRenderers(
-                        parsedRenderer,
-                        parsingContext.formViews,
-                        viewKind,
-                        parsedRenderer.renderer,
-                        parsedRenderer.label,
-                        parsedRenderer.tooltip,
-                        parsedRenderer.details,
-                        parsingContext.enumOptionsSources,
-                        parsingContext.injectedPrimitives,
-                      ),
-                      initialValue: parsingContext.defaultValue(
-                        parsedRenderer.type,
-                      ),
-                      initialState: ParsedRenderer.Operations.FormStates(
-                        parsedRenderer,
-                        viewKind,
-                        parsedRenderer.renderer,
-                        parsingContext.infiniteStreamSources,
-                        parsingContext.injectedPrimitives,
-                      ),
-                    },
-                    visibilityPredicateExpression:
-                      FieldPredicateExpression.Default.primitive(
-                        visibilityExpr,
-                      ),
-                    disabledPredicatedExpression:
-                      FieldPredicateExpression.Default.primitive(disabledExpr),
-                  }),
-              ),
+            (visibilityExpr) => {
+              return Expr.Operations.parse(
+                parsedRenderer.disabled ?? false,
+              ).Then((disabledExpr) =>
+                ValueOrErrors.Default.return({
+                  form: {
+                    renderer: ParsedRenderer.Operations.FormRenderers(
+                      parsedRenderer,
+                      parsingContext.formViews,
+                      viewKind,
+                      parsedRenderer.renderer,
+                      parsedRenderer.label,
+                      parsedRenderer.tooltip,
+                      parsedRenderer.details,
+                      parsingContext.enumOptionsSources,
+                      parsingContext.injectedPrimitives,
+                    ),
+                    initialValue: parsingContext.defaultValue(
+                      parsedRenderer.type,
+                    ),
+                    initialState: ParsedRenderer.Operations.FormStates(
+                      parsedRenderer,
+                      viewKind,
+                      parsedRenderer.renderer,
+                      parsingContext.infiniteStreamSources,
+                      parsingContext.injectedPrimitives,
+                    ),
+                  },
+                  visibilityPredicateExpression:
+                    FieldPredicateExpression.Default.primitive(visibilityExpr),
+                  disabledPredicatedExpression:
+                    FieldPredicateExpression.Default.primitive(disabledExpr),
+                }),
+              );
+            },
           );
         case "form":
           return Expr.Operations.parse(parsedRenderer.visible ?? true).Then(

package/src/forms/domains/parser/domains/types/state.ts

@@ -41,7 +41,7 @@ export const RawType = {
     _.fun == "Union" &&
     Array.isArray(_["args"]) &&
     _["args"].every(
-      (__) => typeof __ == "object" && "case" in __ && "fields" in __,
+      (__) => typeof __ == "object" && "caseName"ame" in __ && "fields" in __,
     ),
 };
 export type RawApplicationType<T> = {
@@ -114,7 +114,7 @@ export const RawFieldType = {
     _.fun == "MultiSelection" &&
     _.args.length == 1,
   isUnionCase: <T>(_: RawFieldType<T>): _ is { case: string; fields: object } =>
-    typeof _ == "object" && "case" in _ && "fields" in _,
+    typeof _ == "object" && "caseName"ame" in _ && "fields" in _,
   isUnion: <T>(
     _: RawFieldType<T>,
   ): _ is { fun: "Union"; args: Array<{ case: string; fields: object }> } =>
@@ -124,7 +124,7 @@ export const RawFieldType = {
     _.fun == "Union" &&
     _.args.length > 0 &&
     _.args.every(
-      (__) => typeof __ == "object" && "case" in __ && "fields" in __,
+      (__) => typeof __ == "object" && "caseName"ame" in __ && "fields" in __,
     ),
   isForm: <T>(_: RawFieldType<T>): _ is { fields: Object } =>
     typeof _ == "object" && "fields" in _ && isObject(_.fields),
@@ -153,7 +153,7 @@ export type FormFields<T> = Map<FieldName, ParsedType<T>>;
 export type ParsedUnionCase<T> = {
   kind: "unionCase";
   name: CaseName;
-  fields: ParsedType<T> | Unit;
+  fields: ParsedType<T>;
 };
 export type ParsedType<T> =
   | ParsedUnionCase<T>
@@ -168,7 +168,7 @@ export const ParsedType = {
   Default: {
     unionCase: <T>(
       name: CaseName,
-      fields: ParsedType<T> | Unit,
+      fields: ParsedType<T>,
     ): ParsedUnionCase<T> => ({ kind: "unionCase", name, fields }),
     option: <T>(value: ParsedType<T>): ParsedType<T> => ({
       kind: "option",
@@ -329,7 +329,7 @@ export const ParsedType = {
           injectedPrimitives,
         ).Then((parsedFields) =>
           ValueOrErrors.Default.return(
-            ParsedType.Default.unionCase(rawFieldType.case, unit),
+            ParsedType.Default.unionCase(rawFieldType.case, parsedFields),
           ),
         );
       }
@@ -344,8 +344,15 @@ export const ParsedType = {
                   )} is not a valid union case`,
                 );
               }
-              return ValueOrErrors.Default.return(
-                ParsedType.Default.unionCase(unionCase.case, unit),
+              return ParsedType.Operations.ParseRawFieldType(
+                unionCase.case,
+                unionCase,
+                types,
+                injectedPrimitives,
+              ).Then((parsedFields) =>
+                ValueOrErrors.Default.return(
+                  ParsedType.Default.unionCase(unionCase.case, parsedFields),
+                ),
               );
             }),
           ),

package/src/forms/domains/parser/state.tsx

@@ -432,11 +432,13 @@ export const parseFormsToLaunchers =
                 formType: formType,
                 api: api,
                 parseGlobalConfiguration: (raw: any) =>
-                  PredicateValue.Operations.parse(
-                    raw,
+                  fromAPIRawValue(
                     globalConfigurationType,
                     formsConfig.types,
-                  ),
+                    builtIns,
+                    apiConverters,
+                    injectedPrimitives,
+                  )(raw),
                 fromApiParser: (value: any) =>
                   fromAPIRawValue(
                     formType,
@@ -546,11 +548,13 @@ export const parseFormsToLaunchers =
               formType: formType,
               api: api,
               parseGlobalConfiguration: (raw: any) =>
-                PredicateValue.Operations.parse(
-                  raw,
+                fromAPIRawValue(
                   globalConfigurationType,
                   formsConfig.types,
-                ),
+                  builtIns,
+                  apiConverters,
+                  injectedPrimitives,
+                )(raw),
               fromApiParser: (value: any) =>
                 fromAPIRawValue(
                   formType,
@@ -653,11 +657,13 @@ export const parseFormsToLaunchers =
                   formType: formType,
                   onEntityChange: parentContext.onEntityChange,
                   parseGlobalConfiguration: (raw: any) =>
-                    PredicateValue.Operations.parse(
-                      raw,
+                    fromAPIRawValue(
                       globalConfigurationType,
                       formsConfig.types,
-                    ),
+                      builtIns,
+                      apiConverters,
+                      injectedPrimitives,
+                    )(raw),
                   fromApiParser: (value: any) =>
                     fromAPIRawValue(
                       formType,