ballerina-core 1.0.256 → 1.0.258

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

@@ -8,7 +8,6 @@ import {
   EditLauncher,
   PassthroughLauncher,
   SerializedEntityApi,
-  Launcher,
   EnumApis,
   StreamApis,
   SpecificationApis,
@@ -33,15 +32,25 @@ export type SerializedSpecification = {
   launchers?: unknown;
 };
 
+export type SerializedLauncher = {
+  kind: "create" | "edit" | "passthrough";
+  form: string;
+  api?: string;
+  configApi?: string;
+  configType?: string;
+};
+
 export type Specification<T> = {
   types: Map<DispatchTypeName, DispatchParsedType<T>>;
   apis: SpecificationApis<T>;
   forms: Map<string, Renderer<T>>;
-  launchers: {
-    create: Map<string, CreateLauncher>;
-    edit: Map<string, EditLauncher>;
-    passthrough: Map<string, PassthroughLauncher>;
-  };
+  launchers: Launchers;
+};
+
+export type Launchers = {
+  create: Map<string, CreateLauncher>;
+  edit: Map<string, EditLauncher>;
+  passthrough: Map<string, PassthroughLauncher>;
 };
 
 export const Specification = {
@@ -94,18 +103,20 @@ export const Specification = {
     } =>
       DispatchIsObject(_) && "launchers" in _ && DispatchIsObject(_.launchers),
     DeserializeSpecTypes: <T>(
+      launcherTypes: List<DispatchTypeName>,
       serializedTypes: Record<string, SerializedType<T>>,
       injectedPrimitives?: DispatchInjectedPrimitives<T>,
     ): ValueOrErrors<Map<DispatchTypeName, DispatchParsedType<T>>, string> => {
-      const serializedTypeNames = Set(Object.keys(serializedTypes));
       return ValueOrErrors.Operations.All(
         List<ValueOrErrors<[DispatchTypeName, DispatchParsedType<T>], string>>(
-          Object.entries(serializedTypes)
-            .reduce((acc, [rawTypeName, rawType]) => {
+          launcherTypes
+            .reduce((acc, rawTypeName) => {
+              if (acc.has(rawTypeName)) {
+                return acc;
+              }
               const res = DispatchParsedType.Operations.ParseRawType(
                 rawTypeName,
-                rawType,
-                serializedTypeNames,
+                serializedTypes[rawTypeName],
                 serializedTypes,
                 acc,
                 injectedPrimitives,
@@ -129,7 +140,60 @@ export const Specification = {
               ),
             ),
         ),
-      ).Then((parsedTypes) => ValueOrErrors.Default.return(Map(parsedTypes)));
+      ).Then((parsedTypes) =>
+        ValueOrErrors.Default.return(
+          Map<DispatchTypeName, DispatchParsedType<T>>(parsedTypes),
+        ),
+      );
+    },
+    DeserializeLaunchers: <T>(
+      desiredLaunchers: string[] | undefined,
+      serializedLaunchers: Record<string, SerializedLauncher>,
+    ): ValueOrErrors<Launchers, string> => {
+      let launchers: Specification<T>["launchers"] = {
+        create: Map<string, CreateLauncher>(),
+        edit: Map<string, EditLauncher>(),
+        passthrough: Map<string, PassthroughLauncher>(),
+      };
+      Object.entries(serializedLaunchers)
+        .filter(([launcherName, _]) =>
+          desiredLaunchers ? desiredLaunchers.includes(launcherName) : true,
+        )
+        .forEach(([launcherName, serializedLauncher]) => {
+          const launcher =
+            serializedLauncher["kind"] == "create" ||
+            serializedLauncher["kind"] == "edit"
+              ? {
+                  name: launcherName,
+                  kind: serializedLauncher["kind"],
+                  form: serializedLauncher["form"],
+                  api: serializedLauncher["api"],
+                  configApi: serializedLauncher["configApi"],
+                }
+              : {
+                  name: launcherName,
+                  kind: serializedLauncher["kind"],
+                  form: serializedLauncher["form"],
+                  configType: serializedLauncher["configType"],
+                };
+          if (launcher.kind == "create")
+            launchers.create = launchers.create.set(
+              launcherName,
+              launcher as CreateLauncher,
+            );
+          else if (launcher.kind == "edit")
+            launchers.edit = launchers.edit.set(
+              launcherName,
+              launcher as EditLauncher,
+            );
+          else if (launcher.kind == "passthrough")
+            launchers.passthrough = launchers.passthrough.set(
+              launcherName,
+              launcher as PassthroughLauncher,
+            );
+        });
+
+      return ValueOrErrors.Default.return(launchers);
     },
     DeserializeForms: <
       T extends DispatchInjectablesTypes<T>,
@@ -145,51 +209,187 @@ export const Specification = {
         CustomPresentationContext,
         ExtraContext
       >,
-    ): ValueOrErrors<Map<string, Renderer<T>>, string> =>
-      ValueOrErrors.Operations.All(
-        List<ValueOrErrors<[string, Renderer<T>], string>>(
-          Object.entries(forms).map(([formName, form]) =>
-            !DispatchIsObject(form) ||
-            !("type" in form) ||
-            typeof form.type != "string"
-              ? ValueOrErrors.Default.throwOne(
-                  `form ${formName} is missing the required type attribute`,
-                )
-              : MapRepo.Operations.tryFindWithError(
-                  form.type,
-                  types,
-                  () => `form type ${form.type} not found in types`,
-                ).Then((formType) =>
-                  Renderer.Operations.Deserialize(
-                    "columns" in form
-                      ? DispatchParsedType.Default.table(
-                          DispatchParsedType.Default.lookup(
-                            form.type as string,
+      launcherForms: List<string>,
+    ): ValueOrErrors<Map<string, Renderer<T>>, string> => {
+      return Object.entries(forms)
+        .filter(([formName]) => launcherForms.includes(formName))
+        .reduce<
+          ValueOrErrors<
+            [Map<string, Renderer<T>>, Map<string, Renderer<T>>],
+            string
+          >
+        >(
+          (acc, [formName, form]) =>
+            acc.Then(([formsMap, accumulatedAlreadyParsedForms]) =>
+              !DispatchIsObject(form) ||
+              !("type" in form) ||
+              typeof form.type != "string"
+                ? ValueOrErrors.Default.throwOne<
+                    [Map<string, Renderer<T>>, Map<string, Renderer<T>>],
+                    string
+                  >(`form ${formName} is missing the required type attribute`)
+                : accumulatedAlreadyParsedForms.has(formName)
+                  ? ValueOrErrors.Default.return<
+                      [Map<string, Renderer<T>>, Map<string, Renderer<T>>],
+                      string
+                    >([
+                      formsMap.set(
+                        formName,
+                        accumulatedAlreadyParsedForms.get(formName)!,
+                      ),
+                      accumulatedAlreadyParsedForms,
+                    ])
+                  : MapRepo.Operations.tryFindWithError(
+                      form.type,
+                      types,
+                      () => `form type ${form.type} not found in types`,
+                    ).Then((formType) =>
+                      Renderer.Operations.Deserialize(
+                        "columns" in form
+                          ? DispatchParsedType.Default.table(
+                              DispatchParsedType.Default.lookup(
+                                form.type as string,
+                              ),
+                            )
+                          : formType,
+                        form,
+                        concreteRenderers as unknown as ConcreteRenderers<
+                          T,
+                          Flags,
+                          CustomPresentationContext
+                        >,
+                        types,
+                        undefined,
+                        forms,
+                        accumulatedAlreadyParsedForms,
+                      )
+                        .MapErrors((errors) =>
+                          errors.map(
+                            (error) =>
+                              `${error}\n...When deserializing form ${formName}`,
                           ),
                         )
-                      : formType,
-                    form,
-                    concreteRenderers as unknown as ConcreteRenderers<
-                      T,
-                      Flags,
-                      CustomPresentationContext
-                    >,
-                    types,
-                    undefined,
-                  )
-                    .MapErrors((errors) =>
-                      errors.map(
-                        (error) =>
-                          `${error}\n...When deserializing form ${formName}`,
-                      ),
-                    )
-                    .Then((form) =>
-                      ValueOrErrors.Default.return([formName, form]),
+                        .Then(([deserializedForm, newAlreadyParsedForms]) =>
+                          ValueOrErrors.Default.return<
+                            [
+                              Map<string, Renderer<T>>,
+                              Map<string, Renderer<T>>,
+                            ],
+                            string
+                          >([
+                            formsMap.set(formName, deserializedForm),
+                            newAlreadyParsedForms,
+                          ]),
+                        ),
                     ),
-                ),
+            ),
+          ValueOrErrors.Default.return<
+            [Map<string, Renderer<T>>, Map<string, Renderer<T>>],
+            string
+          >([Map<string, Renderer<T>>(), Map<string, Renderer<T>>()]),
+        )
+        .Then(([forms, accumulatedAlreadyParsedForms]) =>
+          ValueOrErrors.Default.return<Map<string, Renderer<T>>, string>(
+            accumulatedAlreadyParsedForms.concat(forms),
           ),
-        ),
-      ).Then((forms) => ValueOrErrors.Default.return(Map(forms))),
+        );
+    },
+    GetFormType: <T>(form: object): ValueOrErrors<string, string> => {
+      if (!("type" in form) || typeof form.type != "string")
+        return ValueOrErrors.Default.throwOne(
+          `form is missing the required type attribute`,
+        );
+      return ValueOrErrors.Default.return(form.type);
+    },
+    TryFindForm: <T>(
+      formName: string,
+      forms: object,
+    ): ValueOrErrors<object, string> => {
+      if (!(formName in forms))
+        return ValueOrErrors.Default.throwOne(
+          `form ${formName} not found in forms`,
+        );
+      return ValueOrErrors.Default.return(Reflect.get(forms, formName));
+    },
+    GetLauncherFormNames: <T>(launchers: Launchers): List<string> => {
+      const forms: string[] = [];
+      launchers.create.forEach((launcher) => forms.push(launcher.form));
+      launchers.edit.forEach((launcher) => forms.push(launcher.form));
+      launchers.passthrough.forEach((launcher) => forms.push(launcher.form));
+      return List(forms);
+    },
+    GetCreateAndEditConfigEntityTypes: <T>(
+      launchers: Launchers,
+      apis: object,
+    ): List<ValueOrErrors<string, string>> => {
+      const entities = Reflect.get(apis, "entities");
+      const results: ValueOrErrors<string, string>[] = [];
+      launchers.create.forEach((launcher) => {
+        const entityType = Reflect.get(entities, launcher.configApi)?.type;
+        results.push(
+          entityType
+            ? ValueOrErrors.Default.return<string, string>(entityType)
+            : ValueOrErrors.Default.throwOne<string, string>(
+                `entity type ${launcher.configApi} not found in entities`,
+              ),
+        );
+      });
+      launchers.edit.forEach((launcher) => {
+        const entityType = Reflect.get(entities, launcher.configApi)?.type;
+        results.push(
+          entityType
+            ? ValueOrErrors.Default.return<string, string>(entityType)
+            : ValueOrErrors.Default.throwOne<string, string>(
+                `entity type ${launcher.configApi} not found in entities`,
+              ),
+        );
+      });
+      return List(results);
+    },
+
+    GetLauncherConfigTypes: <T>(launchers: Launchers): List<string> => {
+      return launchers.passthrough
+        .map((launcher) => launcher.configType)
+        .toList();
+    },
+    GetLaucherFormTypes: <T>(
+      launchers: Launchers,
+      forms: object,
+      apis: object,
+    ): ValueOrErrors<List<string>, string> => {
+      const results: ValueOrErrors<string, string>[] = [];
+      launchers.create.forEach((launcher) => {
+        results.push(
+          Specification.Operations.TryFindForm(launcher.form, forms).Then(
+            (form) => Specification.Operations.GetFormType(form),
+          ),
+        );
+      });
+      launchers.edit.forEach((launcher) => {
+        results.push(
+          Specification.Operations.TryFindForm(launcher.form, forms).Then(
+            (form) => Specification.Operations.GetFormType(form),
+          ),
+        );
+      });
+      launchers.passthrough.forEach((launcher) => {
+        results.push(
+          Specification.Operations.TryFindForm(launcher.form, forms).Then(
+            (form) => Specification.Operations.GetFormType(form),
+          ),
+        );
+        results.push(
+          ValueOrErrors.Default.return<string, string>(launcher.configType),
+        );
+      });
+      results.push(
+        ...Specification.Operations.GetCreateAndEditConfigEntityTypes(
+          launchers,
+          apis,
+        ).toArray(),
+      );
+      return ValueOrErrors.Operations.All(List(results));
+    },
     Deserialize:
       <
         T extends DispatchInjectablesTypes<T>,
@@ -207,205 +407,143 @@ export const Specification = {
         injectedPrimitives?: DispatchInjectedPrimitives<T>,
       ) =>
       (
-        serializedSpecifications:
+        serializedSpecificationV2s:
           | SerializedSpecification
           | SerializedSpecification[],
+        launcherNames?: string[],
       ): ValueOrErrors<Specification<T>, string> =>
         injectedPrimitives
           ?.keySeq()
-          .toArray()
           .some(
             (injectedPrimitiveName) =>
-              !Object.keys(apiConverters).includes(
-                injectedPrimitiveName as string,
-              ),
+              !(injectedPrimitiveName in apiConverters),
           )
           ? ValueOrErrors.Default.throwOne(
               `the formsConfig does not contain an Api Converter for all injected primitives`,
             )
-          : !Specification.Operations.hasTypes(serializedSpecifications)
+          : !Specification.Operations.hasLaunchers(serializedSpecificationV2s)
             ? ValueOrErrors.Default.throwOne<Specification<T>, string>(
-                "types are missing from the specification",
+                "launchers are missing from the specificationV2",
               )
-            : Specification.Operations.DeserializeSpecTypes(
-                serializedSpecifications.types,
-                injectedPrimitives,
+            : Specification.Operations.DeserializeLaunchers(
+                launcherNames,
+                serializedSpecificationV2s.launchers,
               )
-                .Then((allTypes) =>
-                  !Specification.Operations.hasForms(serializedSpecifications)
+                .Then((launchers) =>
+                  !Specification.Operations.hasTypes(serializedSpecificationV2s)
                     ? ValueOrErrors.Default.throwOne<Specification<T>, string>(
-                        "forms are missing from the specification",
+                        "types are missing from the specificationV2",
                       )
-                    : Specification.Operations.DeserializeForms<
-                        T,
-                        Flags,
-                        CustomPresentationContext,
-                        ExtraContext
-                      >(
-                        serializedSpecifications.forms,
-                        allTypes,
-                        concreteRenderers,
-                      ).Then((forms) =>
-                        !Specification.Operations.hasApis(
-                          serializedSpecifications,
+                    : !Specification.Operations.hasForms(
+                          serializedSpecificationV2s,
                         )
-                          ? ValueOrErrors.Default.throwOne<
-                              Specification<T>,
-                              string
-                            >("apis are missing from the specification")
-                          : // TODO move all apis serialization to the apis state file
-                            EnumApis.Operations.Deserialize(
-                              serializedSpecifications.apis.enumOptions,
-                            ).Then((enums) =>
-                              StreamApis.Operations.Deserialize(
-                                serializedSpecifications.apis.searchableStreams,
-                              ).Then((streams) =>
-                                TableApis.Operations.Deserialize(
-                                  concreteRenderers,
-                                  allTypes,
-                                  serializedSpecifications.apis.tables,
-                                  injectedPrimitives,
-                                ).Then((tables) =>
-                                  LookupApis.Operations.Deserialize(
-                                    serializedSpecifications.apis.lookups,
-                                  ).Then((lookups) => {
-                                    let entities: Map<string, EntityApi> =
-                                      Map();
-                                    Object.entries(
-                                      serializedSpecifications.apis.entities,
-                                    ).forEach(
-                                      ([entityApiName, entityApi]: [
-                                        entiyApiName: string,
-                                        entityApi: SerializedEntityApi,
-                                      ]) => {
-                                        entities = entities.set(entityApiName, {
-                                          type: entityApi.type,
-                                          methods: {
-                                            create:
-                                              entityApi.methods.includes(
-                                                "create",
-                                              ),
-                                            get: entityApi.methods.includes(
-                                              "get",
-                                            ),
-                                            update:
-                                              entityApi.methods.includes(
-                                                "update",
-                                              ),
-                                            default:
-                                              entityApi.methods.includes(
-                                                "default",
-                                              ),
-                                          },
-                                        });
-                                      },
-                                    );
-
-                                    let launchers: Specification<T>["launchers"] =
-                                      {
-                                        create: Map<string, CreateLauncher>(),
-                                        edit: Map<string, EditLauncher>(),
-                                        passthrough: Map<
+                      ? ValueOrErrors.Default.throwOne<
+                          Specification<T>,
+                          string
+                        >("forms are missing from the specificationV2")
+                      : !Specification.Operations.hasApis(
+                            serializedSpecificationV2s,
+                          )
+                        ? ValueOrErrors.Default.throwOne<
+                            Specification<T>,
+                            string
+                          >("apis are missing from the specificationV2")
+                        : Specification.Operations.GetLaucherFormTypes(
+                            launchers,
+                            serializedSpecificationV2s.forms,
+                            serializedSpecificationV2s.apis,
+                          ).Then((formTypes) =>
+                            Specification.Operations.DeserializeSpecTypes(
+                              formTypes,
+                              serializedSpecificationV2s.types,
+                              injectedPrimitives,
+                            ).Then((allTypes) =>
+                              Specification.Operations.DeserializeForms<
+                                T,
+                                Flags,
+                                CustomPresentationContext,
+                                ExtraContext
+                              >(
+                                serializedSpecificationV2s.forms,
+                                allTypes,
+                                concreteRenderers,
+                                Specification.Operations.GetLauncherFormNames(
+                                  launchers,
+                                ),
+                              ).Then((forms) =>
+                                EnumApis.Operations.Deserialize(
+                                  serializedSpecificationV2s.apis.enumOptions,
+                                ).Then((enums) =>
+                                  StreamApis.Operations.Deserialize(
+                                    serializedSpecificationV2s.apis
+                                      .searchableStreams,
+                                  ).Then((streams) =>
+                                    TableApis.Operations.Deserialize(
+                                      concreteRenderers,
+                                      allTypes,
+                                      serializedSpecificationV2s.types,
+                                      serializedSpecificationV2s.apis.tables,
+                                      injectedPrimitives,
+                                    ).Then((tables) =>
+                                      LookupApis.Operations.Deserialize(
+                                        serializedSpecificationV2s.apis.lookups,
+                                      ).Then((lookups) => {
+                                        const entityEntries: [
                                           string,
-                                          PassthroughLauncher
-                                        >(),
-                                      };
-
-                                    if (
-                                      !Specification.Operations.hasLaunchers(
-                                        serializedSpecifications,
-                                      )
-                                    )
-                                      return ValueOrErrors.Default.throwOne<
-                                        Specification<T>,
-                                        string
-                                      >(
-                                        "launchers are missing from the specification",
-                                      );
-
-                                    Object.keys(
-                                      serializedSpecifications["launchers"],
-                                    ).forEach((launcherName: any) => {
-                                      const launcher: Launcher =
-                                        serializedSpecifications.launchers[
-                                          launcherName
-                                        ]["kind"] == "create" ||
-                                        serializedSpecifications.launchers[
-                                          launcherName
-                                        ]["kind"] == "edit"
-                                          ? {
-                                              name: launcherName,
-                                              kind: serializedSpecifications
-                                                .launchers[launcherName][
-                                                "kind"
-                                              ],
-                                              form: serializedSpecifications
-                                                .launchers[launcherName][
-                                                "form"
-                                              ],
-                                              api: serializedSpecifications
-                                                .launchers[launcherName]["api"],
-                                              configApi:
-                                                serializedSpecifications
-                                                  .launchers[launcherName][
-                                                  "configApi"
-                                                ],
-                                            }
-                                          : {
-                                              name: launcherName,
-                                              kind: serializedSpecifications
-                                                .launchers[launcherName][
-                                                "kind"
-                                              ],
-                                              form: serializedSpecifications
-                                                .launchers[launcherName][
-                                                "form"
-                                              ],
-                                              configType:
-                                                serializedSpecifications
-                                                  .launchers[launcherName][
-                                                  "configType"
-                                                ],
-                                            };
-                                      if (launcher.kind == "create")
-                                        launchers.create = launchers.create.set(
-                                          launcherName,
-                                          launcher,
-                                        );
-                                      else if (launcher.kind == "edit")
-                                        launchers.edit = launchers.edit.set(
-                                          launcherName,
-                                          launcher,
+                                          EntityApi,
+                                        ][] = Object.entries(
+                                          serializedSpecificationV2s.apis
+                                            .entities,
+                                        ).map(
+                                          ([entityApiName, entityApi]: [
+                                            entiyApiName: string,
+                                            entityApi: SerializedEntityApi,
+                                          ]) => {
+                                            const methods = entityApi.methods;
+                                            return [
+                                              entityApiName,
+                                              {
+                                                type: entityApi.type,
+                                                methods: {
+                                                  create:
+                                                    methods.includes("create"),
+                                                  get: methods.includes("get"),
+                                                  update:
+                                                    methods.includes("update"),
+                                                  default:
+                                                    methods.includes("default"),
+                                                },
+                                              },
+                                            ] as [string, EntityApi];
+                                          },
                                         );
-                                      else if (launcher.kind == "passthrough")
-                                        launchers.passthrough =
-                                          launchers.passthrough.set(
-                                            launcherName,
-                                            launcher,
-                                          );
-                                    });
+                                        const entities: Map<string, EntityApi> =
+                                          Map(entityEntries);
 
-                                    return ValueOrErrors.Default.return({
-                                      types: allTypes,
-                                      forms,
-                                      apis: {
-                                        enums,
-                                        streams,
-                                        entities,
-                                        tables,
-                                        lookups,
-                                      },
-                                      launchers,
-                                    });
-                                  }),
+                                        return ValueOrErrors.Default.return({
+                                          types: allTypes,
+                                          forms,
+                                          apis: {
+                                            enums,
+                                            streams,
+                                            entities,
+                                            tables,
+                                            lookups,
+                                          },
+                                          launchers,
+                                        });
+                                      }),
+                                    ),
+                                  ),
                                 ),
                               ),
                             ),
-                      ),
+                          ),
                 )
                 .MapErrors((errors) =>
                   errors.map(
-                    (error) => `${error}\n...When deserializing specification`,
+                    (error) =>
+                      `${error}\n...When deserializing specificationV2`,
                   ),
                 ),
   },