ballerina-core 1.0.256 → 1.0.257

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

@@ -45,8 +45,8 @@ export const EnumApis = {
   Operations: {
     Deserialize: (
       serializedApiEnums?: unknown,
-    ): ValueOrErrors<undefined | EnumApis, string> =>
-      serializedApiEnums === undefined
+    ): ValueOrErrors<undefined | EnumApis, string> => {
+      return serializedApiEnums === undefined
         ? ValueOrErrors.Default.return(undefined)
         : !isObject(serializedApiEnums)
           ? ValueOrErrors.Default.throwOne(
@@ -72,7 +72,8 @@ export const EnumApis = {
                 errors.map(
                   (error) => `${error}\n...When deserializing enum apis`,
                 ),
-              ),
+              );
+    },
   },
 };
 
@@ -82,8 +83,8 @@ export const StreamApis = {
   Operations: {
     Deserialize: (
       serializedApiStreams?: unknown,
-    ): ValueOrErrors<undefined | StreamApis, string> =>
-      serializedApiStreams === undefined
+    ): ValueOrErrors<undefined | StreamApis, string> => {
+      return serializedApiStreams === undefined
         ? ValueOrErrors.Default.return(undefined)
         : !isObject(serializedApiStreams)
           ? ValueOrErrors.Default.throwOne(
@@ -109,7 +110,8 @@ export const StreamApis = {
                 errors.map(
                   (error) => `${error}\n...When deserializing stream apis`,
                 ),
-              ),
+              );
+    },
   },
 };
 
@@ -199,6 +201,7 @@ export const TableApis = {
         ExtraContext
       >,
       types: Map<DispatchTypeName, DispatchParsedType<T>>,
+      serializedTypes: Record<string, SerializedType<T>>,
       serializedFiltering?: unknown,
       injectedPrimitives?: DispatchInjectedPrimitives<T>,
     ): ValueOrErrors<undefined | TableApiFiltering<T>, string> => {
@@ -249,11 +252,8 @@ export const TableApis = {
                                 : DispatchParsedType.Operations.ParseRawType(
                                     "filter",
                                     value.type as SerializedType<T>,
-                                    Set(types.keys()),
-                                    {},
-                                    types.map((t) =>
-                                      ValueOrErrors.Default.return(t),
-                                    ),
+                                    serializedTypes,
+                                    Map(),
                                     injectedPrimitives,
                                   ).Then((type) =>
                                     Renderer.Operations.Deserialize(
@@ -269,7 +269,9 @@ export const TableApis = {
                                       concreteRenderers,
                                       types,
                                       undefined,
-                                    ).Then((renderer) =>
+                                      {},
+                                      Map(),
+                                    ).Then(([renderer, _]) =>
                                       ValueOrErrors.Operations.All<
                                         FilterType<T>,
                                         string
@@ -348,110 +350,113 @@ export const TableApis = {
         ExtraContext
       >,
       types: Map<DispatchTypeName, DispatchParsedType<T>>,
+      serializedTypes: Record<string, SerializedType<T>>,
       serializedApiTables?: unknown,
       injectedPrimitives?: DispatchInjectedPrimitives<T>,
-    ): ValueOrErrors<undefined | TableApis<T>, string> =>
-      serializedApiTables === undefined
-        ? ValueOrErrors.Default.return(undefined)
-        : !TableApis.Operations.IsValidTables(serializedApiTables)
-          ? ValueOrErrors.Default.throwOne(
-              `serializedApiTables is not a valid tables api object`,
-            )
-          : ValueOrErrors.Operations.All(
-              List<
-                ValueOrErrors<
-                  [
-                    TableApiName,
-                    {
-                      type: DispatchTypeName;
-                      methods: Array<TableMethod>;
-                      highlightedFilters?: List<ColumnName>;
-                      filtering?: TableApiFiltering<T>;
-                    },
-                  ],
-                  string
-                >
-              >(
-                Object.entries(serializedApiTables).map(([key, value]) =>
-                  !TableApis.Operations.IsValidTableApi(value)
-                    ? ValueOrErrors.Default.throwOne(
-                        `${key} is not a valid table api object`,
-                      )
-                    : TableApis.Operations.DeserializeFiltering(
-                        concreteRenderers,
-                        types,
-                        value.filtering,
-                        injectedPrimitives,
-                      ).Then((filtering) => {
-                        if (typeof value.type !== "string") {
-                          return ValueOrErrors.Default.throwOne(
-                            `type is not a string`,
-                          );
-                        }
+    ): ValueOrErrors<undefined | TableApis<T>, string> => {
+      if (serializedApiTables === undefined) {
+        return ValueOrErrors.Default.return(undefined);
+      }
 
-                        const finalMethods = value.methods ?? [];
-                        const finalSorting = value.sorting ?? [];
+      const isValidTables =
+        TableApis.Operations.IsValidTables(serializedApiTables);
+      if (!isValidTables) {
+        return ValueOrErrors.Default.throwOne(
+          `serializedApiTables is not a valid tables api object`,
+        );
+      }
 
-                        if (
-                          !TableApis.Operations.IsValidSorting(finalSorting)
-                        ) {
-                          return ValueOrErrors.Default.throwOne(
-                            `sorting is not an array of strings`,
-                          );
-                        }
+      return ValueOrErrors.Operations.All(
+        List<
+          ValueOrErrors<
+            [
+              TableApiName,
+              {
+                type: DispatchTypeName;
+                methods: Array<TableMethod>;
+                highlightedFilters?: List<ColumnName>;
+                filtering?: TableApiFiltering<T>;
+              },
+            ],
+            string
+          >
+        >(
+          Object.entries(serializedApiTables).map(([key, value], index) =>
+            !TableApis.Operations.IsValidTableApi(value)
+              ? ValueOrErrors.Default.throwOne(
+                  `${key} is not a valid table api object`,
+                )
+              : TableApis.Operations.DeserializeFiltering(
+                  concreteRenderers,
+                  types,
+                  serializedTypes,
+                  value.filtering,
+                  injectedPrimitives,
+                ).Then((filtering) => {
+                  if (typeof value.type !== "string") {
+                    return ValueOrErrors.Default.throwOne(
+                      `type is not a string`,
+                    );
+                  }
 
-                        if (
-                          !TableApis.Operations.IsMethodsArray(finalMethods)
-                        ) {
-                          return ValueOrErrors.Default.throwOne(
-                            `methods is not an array of valid table methods`,
-                          );
-                        }
+                  const finalMethods = value.methods ?? [];
+                  const finalSorting = value.sorting ?? [];
 
-                        if (
-                          !TableApis.Operations.IsValidHighlightedFilters(
-                            value.highlightedFilters,
-                          )
-                        ) {
-                          return ValueOrErrors.Default.throwOne(
-                            `highlightedFilters is not an array of strings`,
-                          );
-                        }
+                  if (!TableApis.Operations.IsValidSorting(finalSorting)) {
+                    return ValueOrErrors.Default.throwOne(
+                      `sorting is not an array of strings`,
+                    );
+                  }
 
-                        return ValueOrErrors.Default.return([
-                          key,
-                          {
-                            type: value.type,
-                            methods: finalMethods,
-                            highlightedFilters: value.highlightedFilters
-                              ? List(value.highlightedFilters)
-                              : undefined,
-                            filtering,
-                            sorting: finalSorting,
-                          },
-                        ]);
-                      }),
-                ),
-              ),
-            )
-              .Then((entries) =>
-                ValueOrErrors.Default.return(
-                  Map<
-                    TableApiName,
+                  if (!TableApis.Operations.IsMethodsArray(finalMethods)) {
+                    return ValueOrErrors.Default.throwOne(
+                      `methods is not an array of valid table methods`,
+                    );
+                  }
+
+                  if (
+                    !TableApis.Operations.IsValidHighlightedFilters(
+                      value.highlightedFilters,
+                    )
+                  ) {
+                    return ValueOrErrors.Default.throwOne(
+                      `highlightedFilters is not an array of strings`,
+                    );
+                  }
+
+                  return ValueOrErrors.Default.return([
+                    key,
                     {
-                      type: DispatchTypeName;
-                      methods: Array<TableMethod>;
-                      highlightedFilters?: List<ColumnName>;
-                      filtering?: TableApiFiltering<T>;
-                    }
-                  >(entries),
-                ),
-              )
-              .MapErrors((errors) =>
-                errors.map(
-                  (error) => `${error}\n...When deserializing table apis`,
-                ),
-              ),
+                      type: value.type,
+                      methods: finalMethods,
+                      highlightedFilters: value.highlightedFilters
+                        ? List(value.highlightedFilters)
+                        : undefined,
+                      filtering,
+                      sorting: finalSorting,
+                    },
+                  ]);
+                }),
+          ),
+        ),
+      )
+        .Then((entries) =>
+          ValueOrErrors.Default.return(
+            Map<
+              TableApiName,
+              {
+                type: DispatchTypeName;
+                methods: Array<TableMethod>;
+                highlightedFilters?: List<ColumnName>;
+                filtering?: TableApiFiltering<T>;
+              }
+            >(entries),
+          ),
+        )
+        .MapErrors((errors) =>
+          errors.map((error) => `${error}\n...When deserializing table apis`),
+        );
+    },
   },
 };
 
@@ -524,8 +529,8 @@ export const LookupApis = {
           ),
     Deserialize: (
       serializedApiLookups?: unknown,
-    ): ValueOrErrors<undefined | LookupApis, string> =>
-      serializedApiLookups === undefined
+    ): ValueOrErrors<undefined | LookupApis, string> => {
+      return serializedApiLookups === undefined
         ? ValueOrErrors.Default.return(undefined)
         : !isObject(serializedApiLookups)
           ? ValueOrErrors.Default.throwOne(
@@ -551,6 +556,7 @@ export const LookupApis = {
                 errors.map(
                   (error) => `${error}\n...When deserializing lookup apis`,
                 ),
-              ),
+              );
+    },
   },
 };

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

@@ -1,10 +1,11 @@
-import { List, Map } from "immutable";
+import { Map } from "immutable";
 import {
   ConcreteRenderers,
   DispatchInjectablesTypes,
   DispatchParsedType,
   isObject,
   ListType,
+  Renderer,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../main";
 import { NestedRenderer } from "../nestedRenderer/state";
@@ -115,7 +116,9 @@ export const ListRenderer = {
         ExtraContext
       >,
       types: Map<string, DispatchParsedType<T>>,
-    ): ValueOrErrors<ListRenderer<T>, string> =>
+      forms: object,
+      alreadyParsedForms: Map<string, Renderer<T>>,
+    ): ValueOrErrors<[ListRenderer<T>, Map<string, Renderer<T>>], string> =>
       ListRenderer.Operations.tryAsValidBaseListRenderer(serialized, type)
         .Then((serializedRenderer) =>
           NestedRenderer.Operations.DeserializeAs(
@@ -124,18 +127,24 @@ export const ListRenderer = {
             concreteRenderers,
             "list element",
             types,
-          ).Then((elementRenderer) =>
+            forms,
+            alreadyParsedForms,
+          ).Then(([elementRenderer, newAlreadyParsedForms]) =>
             ListMethods.Operations.fromRawValue(
               serializedRenderer.actions,
             ).Then((methods) =>
-              ValueOrErrors.Default.return(
+              ValueOrErrors.Default.return<
+                [ListRenderer<T>, Map<string, Renderer<T>>],
+                string
+              >([
                 ListRenderer.Default(
                   type,
                   serializedRenderer.renderer,
                   elementRenderer,
                   methods,
                 ),
-              ),
+                newAlreadyParsedForms,
+              ]),
             ),
           ),
         )

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

@@ -5,10 +5,10 @@ import {
   DispatchParsedType,
   LookupType,
   MapRepo,
-  Renderer,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../main";
 import { Map } from "immutable";
+import { Renderer } from "../../state";
 
 export type SerializedLookup<T> =
   | { kind: "lookupType-lookupRenderer"; renderer: string; type: LookupType }
@@ -156,8 +156,10 @@ export const LookupRenderer = {
         ExtraContext
       >,
       types: Map<string, DispatchParsedType<T>>,
-    ): ValueOrErrors<LookupRenderer<T>, string> =>
-      serialized.kind == "lookupType-inlinedRenderer"
+      forms: object,
+      alreadyParsedForms: Map<string, Renderer<T>>,
+    ): ValueOrErrors<[LookupRenderer<T>, Map<string, Renderer<T>>], string> => {
+      return serialized.kind == "lookupType-inlinedRenderer"
         ? DispatchParsedType.Operations.ResolveLookupType(
             serialized.type.name,
             types,
@@ -168,30 +170,85 @@ export const LookupRenderer = {
               concreteRenderers,
               types,
               tableApi,
-            ).Then((renderer) =>
-              ValueOrErrors.Default.return(
+              forms,
+              alreadyParsedForms,
+            ).Then(([renderer, alreadyParsedForms]) =>
+              ValueOrErrors.Default.return([
                 LookupRenderer.Default.LookupTypeInlinedRenderer(
                   serialized.type,
                   renderer,
                   tableApi,
                 ),
-              ),
+                alreadyParsedForms,
+              ]),
             ),
           )
         : serialized.kind == "lookupType-lookupRenderer"
-          ? ValueOrErrors.Default.return(
-              LookupRenderer.Default.LookupTypeLookupRenderer(
-                serialized.type,
-                serialized.renderer,
-                tableApi,
-              ),
-            )
-          : ValueOrErrors.Default.return(
-              LookupRenderer.Default.InlinedTypeLookupRenderer(
+          ? alreadyParsedForms.has(serialized.renderer)
+            ? ValueOrErrors.Default.return<
+                [LookupRenderer<T>, Map<string, Renderer<T>>],
+                string
+              >([
+                LookupRenderer.Default.LookupTypeLookupRenderer(
+                  serialized.type,
+                  serialized.renderer,
+                  tableApi,
+                ),
+                alreadyParsedForms,
+              ])
+            : DispatchParsedType.Operations.ResolveLookupType(
+                serialized.type.name,
+                types,
+              ).Then((resolvedType) =>
+                Renderer.Operations.Deserialize(
+                  resolvedType,
+                  Reflect.get(forms, serialized.renderer),
+                  concreteRenderers,
+                  types,
+                  tableApi,
+                  forms,
+                  alreadyParsedForms,
+                ).Then(([renderer, alreadyParsedForms]) =>
+                  ValueOrErrors.Default.return([
+                    LookupRenderer.Default.LookupTypeLookupRenderer(
+                      serialized.type,
+                      serialized.renderer,
+                      tableApi,
+                    ),
+                    alreadyParsedForms.set(serialized.renderer, renderer),
+                  ]),
+                ),
+              )
+          : alreadyParsedForms.has(serialized.renderer)
+            ? ValueOrErrors.Default.return<
+                [LookupRenderer<T>, Map<string, Renderer<T>>],
+                string
+              >([
+                LookupRenderer.Default.InlinedTypeLookupRenderer(
+                  serialized.type,
+                  serialized.renderer,
+                  tableApi,
+                ),
+                alreadyParsedForms,
+              ])
+            : Renderer.Operations.Deserialize(
                 serialized.type,
-                serialized.renderer,
+                Reflect.get(forms, serialized.renderer),
+                concreteRenderers,
+                types,
                 tableApi,
-              ),
-            ),
+                forms,
+                alreadyParsedForms,
+              ).Then(([renderer, alreadyParsedForms]) =>
+                ValueOrErrors.Default.return([
+                  LookupRenderer.Default.InlinedTypeLookupRenderer(
+                    serialized.type,
+                    serialized.renderer,
+                    tableApi,
+                  ),
+                  alreadyParsedForms.set(serialized.renderer, renderer),
+                ]),
+              );
+    },
   },
 };

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

@@ -5,11 +5,11 @@ import {
   DispatchParsedType,
   isObject,
   isString,
+  Renderer,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../main";
 import { MapType } from "../../../../../types/state";
 import { NestedRenderer } from "../nestedRenderer/state";
-import { Renderer } from "../../state";
 
 export type SerializedMapRenderer = {
   renderer: string;
@@ -74,7 +74,9 @@ export const MapRenderer = {
         ExtraContext
       >,
       types: Map<string, DispatchParsedType<T>>,
-    ): ValueOrErrors<MapRenderer<T>, string> =>
+      forms: object,
+      alreadyParsedForms: Map<string, Renderer<T>>,
+    ): ValueOrErrors<[MapRenderer<T>, Map<string, Renderer<T>>], string> =>
       MapRenderer.Operations.tryAsValidMapBaseRenderer(serialized)
         .Then((renderer) =>
           NestedRenderer.Operations.DeserializeAs(
@@ -83,22 +85,30 @@ export const MapRenderer = {
             concreteRenderers,
             "Map key",
             types,
-          ).Then((deserializedKeyRenderer) =>
+            forms,
+            alreadyParsedForms,
+          ).Then(([deserializedKeyRenderer, keyAlreadyParsedForms]) =>
             NestedRenderer.Operations.DeserializeAs(
               type.args[1],
               renderer.valueRenderer,
               concreteRenderers,
               "Map value",
               types,
-            ).Then((deserializedValueRenderer) =>
-              ValueOrErrors.Default.return(
+              forms,
+              keyAlreadyParsedForms,
+            ).Then(([deserializedValueRenderer, valueAlreadyParsedForms]) =>
+              ValueOrErrors.Default.return<
+                [MapRenderer<T>, Map<string, Renderer<T>>],
+                string
+              >([
                 MapRenderer.Default(
                   type,
                   renderer.renderer,
                   deserializedKeyRenderer,
                   deserializedValueRenderer,
                 ),
-              ),
+                valueAlreadyParsedForms,
+              ]),
             ),
           ),
         )

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

@@ -92,12 +92,16 @@ export const NestedRenderer = {
       >,
       as: string,
       types: Map<string, DispatchParsedType<T>>,
-    ): ValueOrErrors<NestedRenderer<T>, string> =>
+      forms: object,
+      alreadyParsedForms: Map<string, Renderer<T>>,
+    ): ValueOrErrors<[NestedRenderer<T>, Map<string, Renderer<T>>], string> =>
       NestedRenderer.Operations.Deserialize(
         type,
         serialized,
         concreteRenderers,
         types,
+        forms,
+        alreadyParsedForms,
       ).MapErrors((errors) =>
         errors.map((error) => `${error}\n...When parsing as ${as}`),
       ),
@@ -116,7 +120,9 @@ export const NestedRenderer = {
         ExtraContext
       >,
       types: Map<string, DispatchParsedType<T>>,
-    ): ValueOrErrors<NestedRenderer<T>, string> =>
+      forms: object,
+      alreadyParsedForms: Map<string, Renderer<T>>,
+    ): ValueOrErrors<[NestedRenderer<T>, Map<string, Renderer<T>>], string> =>
       NestedRenderer.Operations.tryAsValidSerializedNestedRenderer(
         serialized,
       ).Then((validatedSerialized) =>
@@ -134,13 +140,25 @@ export const NestedRenderer = {
           "api" in validatedSerialized && isString(validatedSerialized.api)
             ? validatedSerialized.api
             : undefined,
-        ).Then((renderer) =>
-          ValueOrErrors.Default.return<NestedRenderer<T>, string>({
-            renderer,
-            label: validatedSerialized.label,
-            tooltip: validatedSerialized.tooltip,
-            details: validatedSerialized.details,
-          }).MapErrors<NestedRenderer<T>, string, string>((errors) =>
+          forms,
+          alreadyParsedForms,
+        ).Then(([renderer, newAlreadyParsedForms]) =>
+          ValueOrErrors.Default.return<
+            [NestedRenderer<T>, Map<string, Renderer<T>>],
+            string
+          >([
+            {
+              renderer,
+              label: validatedSerialized.label,
+              tooltip: validatedSerialized.tooltip,
+              details: validatedSerialized.details,
+            },
+            newAlreadyParsedForms,
+          ]).MapErrors<
+            [NestedRenderer<T>, Map<string, Renderer<T>>],
+            string,
+            string
+          >((errors) =>
             errors.map(
               (error) =>
                 `${error}\n...When parsing as ${renderer.kind} nested renderer`,