ballerina-core 1.0.191 → 1.0.193

package/package.json

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

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

@@ -1324,30 +1324,15 @@ export const dispatchFromAPIRawValue =
             )}`,
           );
 
-        if (caseType.kind != "record" && caseType.kind != "lookup")
-          return ValueOrErrors.Default.throwOne(
-            `union case ${
-              result.caseName
-            } expected record or lookup type, got ${JSON.stringify(caseType)}`,
-          );
-
         return dispatchFromAPIRawValue(
           caseType,
           types,
           converters,
           injectedPrimitives,
         )(result.fields).Then((value) =>
-          PredicateValue.Operations.IsRecord(value)
-            ? ValueOrErrors.Default.return(
-                PredicateValue.Default.unionCase(result.caseName, value),
-              )
-            : ValueOrErrors.Default.throwOne(
-                `union case ${
-                  result.caseName
-                } expected record, got ${PredicateValue.Operations.GetKind(
-                  value,
-                )}`,
-              ),
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.unionCase(result.caseName, value),
+          ),
         );
       }
 

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/types/state.ts

@@ -191,6 +191,8 @@ export const SerializedType = {
     SerializedType.isApplication(_) &&
     _.fun == "ReadOnly" &&
     _.args.length == 1,
+  isRecordFields: (_: unknown) =>
+    typeof _ == "object" && _ != null && !("fun" in _) && !("args" in _),
 };
 
 export type StringSerializedType = string;
@@ -1042,41 +1044,25 @@ export const DispatchParsedType = {
           return ValueOrErrors.Operations.All(
             List<ValueOrErrors<[string, DispatchParsedType<T>], string>>(
               rawType.args.map((unionCase) =>
-                typeof unionCase.fields == "string" // lookup case
-                  ? serializedTypes[unionCase.fields] == undefined // probably dont need this
-                    ? ValueOrErrors.Default.throwOne(
-                        `Cannot find union case type: ${JSON.stringify(
-                          unionCase.fields,
-                        )} in types`,
-                      )
-                    : DispatchParsedType.Operations.ParseRawType(
-                        `Union:Case ${unionCase.caseName}`,
-                        unionCase.fields,
-                        typeNames,
-                        serializedTypes,
-                        alreadyParsedTypes,
-                        injectedPrimitives,
-                      ).Then((parsedType) =>
-                        ValueOrErrors.Default.return([
-                          unionCase.caseName,
-                          parsedType[0],
-                        ]),
-                      )
-                  : DispatchParsedType.Operations.ParseRawType(
-                      `Union:Case ${unionCase.caseName}`,
-                      unionCase.fields == undefined
-                        ? { fields: {} }
-                        : unionCase,
-                      typeNames,
-                      serializedTypes,
-                      alreadyParsedTypes,
-                      injectedPrimitives,
-                    ).Then((parsedType) =>
-                      ValueOrErrors.Default.return([
-                        unionCase.caseName,
-                        parsedType[0],
-                      ]),
-                    ),
+                DispatchParsedType.Operations.ParseRawType(
+                  `Union:Case ${unionCase.caseName}`,
+                  unionCase.fields == undefined
+                    ? { fields: {} }
+                    : // we allow the record fields to be defined directly in the spec instead of
+                      // inside a fields key
+                      SerializedType.isRecordFields(unionCase.fields)
+                      ? { fields: unionCase.fields }
+                      : unionCase.fields,
+                  typeNames,
+                  serializedTypes,
+                  alreadyParsedTypes,
+                  injectedPrimitives,
+                ).Then((parsedType) =>
+                  ValueOrErrors.Default.return([
+                    unionCase.caseName,
+                    parsedType[0],
+                  ]),
+                ),
               ),
             ),
           ).Then((parsedUnionCases) =>

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

@@ -504,9 +504,6 @@ export const TableAbstractRenderer = <
               .flatMap((_, column) => {
                 const EmbeddedCell = EmbeddedCellTemplates.get(column);
                 if (EmbeddedCell == undefined) {
-                  console.error(
-                    `Cannot find column ${column} in fields ${rowData.fields.keySeq().toArray()}, this is likely due to a mismatch between the data we are trying to parse and the specs.`,
-                  );
                   return [];
                 }
                 return [

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

@@ -78,31 +78,77 @@ export const RendererTraversal = {
 
       if (
         renderer.kind == "lookupType-lookupRenderer" ||
-        renderer.kind == "inlinedType-lookupRenderer" ||
-        renderer.kind == "lookupType-inlinedRenderer"
+        renderer.kind == "lookupType-inlinedRenderer" ||
+        renderer.kind == "inlinedType-lookupRenderer"
       ) {
         if (
           renderer.kind == "lookupType-lookupRenderer" ||
-          renderer.kind == "inlinedType-lookupRenderer"
+          renderer.kind == "lookupType-inlinedRenderer"
         ) {
-          // renderer.renderer.renderer is the form name
-          // this is a form lookup, so "local" changes here to the traversed value
           return LookupRenderer.Operations.ResolveRenderer(
             renderer,
             traversalContext.forms,
           ).Then((resolvedRenderer) =>
             rec(resolvedRenderer, traversalContext).Then(
               (valueTraversal: Option<ValueTraversal<T, Res>>) =>
-                ValueOrErrors.Default.return(
-                  mapEvalContext((ctx) => ({
-                    ...ctx,
-                    local: ctx.traversalIterator,
-                  }))(valueTraversal),
-                ),
+                ValueOrErrors.Default.return<
+                  Option<ValueTraversal<T, Res>>,
+                  string
+                >(
+                  // reassign local if it's a lookup renderer
+                  renderer.kind == "lookupType-lookupRenderer"
+                    ? mapEvalContext((ctx) => ({
+                        ...ctx,
+                        local: ctx.traversalIterator,
+                      }))(valueTraversal)
+                    : valueTraversal,
+                ).Then((resolvedTraversal) => {
+                  if (
+                    traverseNode.kind == "l" &&
+                    resolvedTraversal.kind == "l"
+                  ) {
+                    return ValueOrErrors.Default.return(Option.Default.none());
+                  }
+
+                  if (traverseNode.kind == "l") {
+                    return ValueOrErrors.Default.return(resolvedTraversal);
+                  }
+
+                  if (resolvedTraversal.kind == "l") {
+                    return ValueOrErrors.Default.return(
+                      Option.Default.some((evalContext: EvalContext<T, Res>) =>
+                        traverseNode
+                          .value(evalContext)
+                          .Then((nodeResult) =>
+                            ValueOrErrors.Default.return(nodeResult),
+                          ),
+                      ),
+                    );
+                  }
+
+                  return ValueOrErrors.Default.return(
+                    Option.Default.some((evalContext: EvalContext<T, Res>) => {
+                      return resolvedTraversal
+                        .value(evalContext)
+                        .Then((resolvedTraversal) =>
+                          traverseNode
+                            .value(evalContext)
+                            .Then((nodeResult) =>
+                              ValueOrErrors.Default.return<Res, string>(
+                                traversalContext.joinRes([
+                                  nodeResult,
+                                  resolvedTraversal,
+                                ]),
+                              ),
+                            ),
+                        );
+                    }),
+                  );
+                }),
             ),
           );
         }
-        // otherwise the form is inlined, so the local doesn't change
+
         return LookupRenderer.Operations.ResolveRenderer(
           renderer,
           traversalContext.forms,
@@ -113,6 +159,54 @@ export const RendererTraversal = {
           ),
         );
       }
+
+      if (
+        renderer.type.kind == "readOnly" &&
+        renderer.kind == "readOnlyRenderer"
+      ) {
+        return rec(renderer.childRenderer.renderer, traversalContext).Then(
+          (valueTraversal: Option<ValueTraversal<T, Res>>) => {
+            if (valueTraversal.kind == "l" && traverseNode.kind == "l") {
+              return ValueOrErrors.Default.return(Option.Default.none());
+            }
+            return ValueOrErrors.Default.return(
+              Option.Default.some((evalContext: EvalContext<T, Res>) => {
+                const iterator = evalContext.traversalIterator;
+                if (!PredicateValue.Operations.IsReadOnly(iterator)) {
+                  return ValueOrErrors.Default.throwOne<Res, string>(
+                    `Error: traversal iterator is not read only, got ${JSON.stringify(
+                      iterator,
+                      undefined,
+                      2,
+                    )}`,
+                  );
+                }
+                return (
+                  valueTraversal.kind == "r"
+                    ? valueTraversal.value({
+                        ...evalContext,
+                        traversalIterator: iterator.ReadOnly,
+                      })
+                    : ValueOrErrors.Default.return<Res, string>(
+                        traversalContext.zeroRes(unit),
+                      )
+                ).Then((valueResult) =>
+                  traverseNode.kind == "r"
+                    ? traverseNode
+                        .value(evalContext)
+                        .Then((nodeResult) =>
+                          ValueOrErrors.Default.return(
+                            traversalContext.joinRes([valueResult, nodeResult]),
+                          ),
+                        )
+                    : ValueOrErrors.Default.return(valueResult),
+                );
+              }),
+            );
+          },
+        );
+      }
+
       if (renderer.type.kind == "record" && renderer.kind == "recordRenderer") {
         return ValueOrErrors.Operations.All(
           List(

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

@@ -425,7 +425,7 @@ export const PredicateValue = {
       kind: "record",
       fields,
     }),
-    unionCase: (caseName: string, fields: ValueRecord): ValueUnionCase => ({
+    unionCase: (caseName: string, fields: PredicateValue): ValueUnionCase => ({
       kind: "unionCase",
       caseName,
       fields,