ballerina-core 1.0.228 → 1.0.230

package/src/forms/domains/dispatched-forms/runner/domains/kind/edit/coroutines/_init.ts

@@ -0,0 +1,272 @@
+import { List } from "immutable";
+import {
+  DispatchInjectablesTypes,
+  Unit,
+  PredicateValue,
+  Synchronize,
+  DispatchParsedEditLauncher,
+  Synchronized,
+  unit,
+  AsyncState,
+  replaceWith,
+  DispatchFormRunnerStatus,
+  id,
+  Dispatcher,
+  HandleApiResponse,
+  DispatcherContextWithApiSources,
+} from "../../../../../../../../../main";
+import { ApiResponseChecker } from "../../../../../../../../api-response-handler/state";
+import {
+  DispatchEditFormLauncherContext,
+  DispatchEditFormLauncherState,
+} from "../state";
+import { EditCoBuilder } from "./builder";
+
+export const initCo = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>(
+  Co: ReturnType<
+    typeof EditCoBuilder<T, Flags, CustomPresentationContexts, ExtraContext>
+  >,
+) => {
+  const setChecked = (checked: boolean) =>
+    Co.SetState(
+      DispatchEditFormLauncherState<
+        T,
+        Flags
+      >().Updaters.Core.apiChecker.children.init(
+        checked
+          ? ApiResponseChecker.Updaters().toChecked()
+          : ApiResponseChecker.Updaters().toUnchecked(),
+      ),
+    );
+
+  const getValueCo = (
+    getValueApi: () => Promise<PredicateValue>,
+    editFormLauncher: DispatchParsedEditLauncher<T>,
+  ) =>
+    Synchronize<Unit, PredicateValue>(
+      () =>
+        getValueApi().then((raw) => {
+          const result = editFormLauncher.fromApiParser(raw);
+          return result.kind == "errors"
+            ? Promise.reject(result.errors)
+            : Promise.resolve(result.value);
+        }),
+      (_) => "transient failure",
+      5,
+      50,
+    ).embed(
+      (_: DispatchEditFormLauncherState<T, Flags>) => _.entity,
+      DispatchEditFormLauncherState<T, Flags>().Updaters.Core.entity,
+    );
+
+  const configValueCo = (
+    getGlobalConfig: () => Promise<PredicateValue>,
+    createFormLauncher: DispatchParsedEditLauncher<T>,
+    current: DispatchEditFormLauncherContext<
+      T,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext
+    >,
+  ) =>
+    current.launcherRef.config.source == "api"
+      ? Synchronize<Unit, PredicateValue>(() =>
+          getGlobalConfig().then((raw) => {
+            const result =
+              createFormLauncher.parseGlobalConfigurationFromApi(raw);
+            return result.kind == "errors"
+              ? Promise.reject(result.errors)
+              : Promise.resolve(result.value);
+          }),
+        ).embed(
+          (_: DispatchEditFormLauncherState<T, Flags>) => _.config,
+          DispatchEditFormLauncherState<T, Flags>().Updaters.Core.config,
+        )
+      : Co.SetState(
+          DispatchEditFormLauncherState<T, Flags>().Updaters.Core.config(
+            replaceWith(
+              current.launcherRef.config.value.kind == "l" &&
+                current.launcherRef.config.value.value.kind == "value"
+                ? Synchronized.Default(
+                    unit,
+                    AsyncState.Default.loaded(
+                      current.launcherRef.config.value.value.value,
+                    ),
+                  )
+                : Synchronized.Default(unit),
+            ),
+          ),
+        );
+
+  const errorUpd = (errors: List<string>) =>
+    DispatchEditFormLauncherState<T, Flags>().Updaters.Core.status(
+      replaceWith<DispatchFormRunnerStatus<T, Flags>>({
+        kind: "error",
+        errors,
+      }),
+    );
+
+  return Co.Seq([
+    Co.SetState(
+      DispatchEditFormLauncherState<T, Flags>().Updaters.Core.status(
+        replaceWith<DispatchFormRunnerStatus<T, Flags>>({ kind: "loading" }),
+      ),
+    ),
+    setChecked(false),
+    Co.GetState().then((current) => {
+      if (
+        !AsyncState.Operations.hasValue(current.deserializedSpecification.sync)
+      ) {
+        return Co.SetState(id);
+      }
+
+      if (current.deserializedSpecification.sync.value.kind == "errors") {
+        return Co.SetState(
+          errorUpd(current.deserializedSpecification.sync.value.errors),
+        );
+      }
+
+      const dispatcherContext =
+        current.deserializedSpecification.sync.value.value.dispatcherContext;
+
+      const editFormLauncher =
+        current.deserializedSpecification.sync.value.value.launchers.edit.get(
+          current.launcherRef.name,
+        );
+
+      if (editFormLauncher == undefined) {
+        console.error(
+          `Cannot find form '${current.launcherRef.name}' in the edit launchers`,
+        );
+
+        return Co.SetState(
+          errorUpd(
+            List([
+              `Cannot find form '${current.launcherRef.name}' in the edit launchers`,
+            ]),
+          ),
+        );
+      }
+
+      const getApi = () =>
+        current.launcherRef.apiSources.entityApis.get(editFormLauncher.api)(
+          current.launcherRef.entityId,
+        );
+      const getGlobalConfig =
+        current.launcherRef.config.source == "api" &&
+        current.launcherRef.config.getGlobalConfig
+          ? current.launcherRef.config.getGlobalConfig
+          : () =>
+              current.launcherRef.apiSources.entityApis.get(
+                editFormLauncher.configApi,
+              )("");
+
+      return Co.Seq([
+        Co.Seq([
+          Co.All([
+            getValueCo(getApi, editFormLauncher),
+            configValueCo(getGlobalConfig, editFormLauncher, current),
+          ]),
+          Co.UpdateState((_) => {
+            if (_.entity.sync.kind == "error") {
+              return errorUpd(List([_.entity.sync.error]));
+            }
+
+            if (_.config.sync.kind == "error") {
+              return errorUpd(List([_.config.sync.error]));
+            }
+
+            if (
+              _.config.sync.kind == "loading" ||
+              _.config.sync.kind == "reloading"
+            ) {
+              return id;
+            }
+
+            if (
+              _.entity.sync.kind == "loading" ||
+              _.entity.sync.kind == "unloaded" ||
+              _.entity.sync.kind == "reloading"
+            ) {
+              return id;
+            }
+
+            const dispatcherContextWithApiSources: DispatcherContextWithApiSources<
+              T,
+              Flags,
+              CustomPresentationContexts,
+              ExtraContext
+            > = {
+              ...dispatcherContext,
+              ...current.launcherRef.apiSources,
+              defaultState: dispatcherContext.defaultState(
+                current.launcherRef.apiSources.infiniteStreamSources,
+                current.launcherRef.apiSources.lookupSources,
+                current.launcherRef.apiSources.tableApiSources,
+              ),
+            };
+
+            const Form = Dispatcher.Operations.Dispatch(
+              editFormLauncher.renderer,
+              dispatcherContextWithApiSources,
+              false,
+              false,
+              undefined,
+            );
+
+            if (Form.kind == "errors") {
+              console.error(Form.errors.valueSeq().toArray().join("\n"));
+              return errorUpd(Form.errors);
+            }
+
+            const initialState = dispatcherContext.defaultState(
+              current.launcherRef.apiSources.infiniteStreamSources,
+              current.launcherRef.apiSources.lookupSources,
+              current.launcherRef.apiSources.tableApiSources,
+            )(editFormLauncher.type, editFormLauncher.renderer);
+
+            if (initialState.kind == "errors") {
+              console.error(
+                initialState.errors.valueSeq().toArray().join("\n"),
+              );
+              return errorUpd(initialState.errors);
+            }
+
+            return DispatchEditFormLauncherState<T, Flags>()
+              .Updaters.Core.formState(replaceWith(initialState.value))
+              .thenMany([
+                DispatchEditFormLauncherState<T, Flags>().Updaters.Core.status(
+                  replaceWith<DispatchFormRunnerStatus<T, Flags>>({
+                    kind: "loaded",
+                    Form: Form.value,
+                  }),
+                ),
+                DispatchEditFormLauncherState<T, Flags>().Updaters.Core.config(
+                  replaceWith(_.config),
+                ),
+              ]);
+          }),
+        ]),
+        HandleApiResponse<
+          DispatchEditFormLauncherState<T, Flags>,
+          DispatchEditFormLauncherContext<
+            T,
+            Flags,
+            CustomPresentationContexts,
+            ExtraContext
+          >,
+          any
+        >((_) => _.entity.sync, {
+          handleSuccess: current.launcherRef.apiHandlers?.onGetSuccess,
+          handleError: current.launcherRef.apiHandlers?.onGetError,
+        }),
+        setChecked(true),
+      ]);
+    }),
+  ]);
+};

package/src/forms/domains/dispatched-forms/runner/domains/kind/edit/coroutines/_sync.ts

@@ -0,0 +1,101 @@
+import {
+  ApiErrors,
+  DispatchInjectablesTypes,
+  HandleApiResponse,
+  id,
+  Synchronize,
+  Unit,
+} from "../../../../../../../../../main";
+import { ApiResponseChecker } from "../../../../../../../../api-response-handler/state";
+import {
+  DispatchEditFormLauncherContext,
+  DispatchEditFormLauncherState,
+} from "../state";
+import { EditCoBuilder } from "./builder";
+
+export const syncCo = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>(
+  Co: ReturnType<
+    typeof EditCoBuilder<T, Flags, CustomPresentationContexts, ExtraContext>
+  >,
+) => {
+  const setChecked = (checked: boolean) =>
+    Co.SetState(
+      DispatchEditFormLauncherState<
+        T,
+        Flags
+      >().Updaters.Core.apiChecker.children.update(
+        checked
+          ? ApiResponseChecker.Updaters().toChecked()
+          : ApiResponseChecker.Updaters().toUnchecked(),
+      ),
+    );
+
+  return Co.GetState().then((current) => {
+    if (current.deserializedSpecification.sync.kind !== "loaded") {
+      return Co.SetState(id);
+    }
+
+    if (current.deserializedSpecification.sync.value.kind == "errors") {
+      return Co.SetState(id);
+    }
+
+    const editFormLauncher =
+      current.deserializedSpecification.sync.value.value.launchers.edit.get(
+        current.launcherRef.name,
+      );
+
+    if (!editFormLauncher) {
+      return Co.SetState(id);
+    }
+
+    const update = current.launcherRef.apiSources.entityApis.update(
+      editFormLauncher.api,
+    );
+
+    return Co.Seq([
+      setChecked(false),
+      Synchronize<Unit, ApiErrors, Unit>(
+        (_) => {
+          if (current.entity.sync.kind !== "loaded") {
+            return Promise.resolve([]);
+          }
+
+          const parsed = editFormLauncher?.toApiParser(
+            current.entity.sync.value,
+            editFormLauncher?.type,
+            current.formState,
+          );
+
+          return !parsed || parsed?.kind == "errors"
+            ? Promise.reject(parsed?.errors)
+            : update(current.launcherRef.entityId, parsed.value).then(() => []);
+        },
+        (_) => "transient failure",
+        3,
+        50,
+      ).embed(
+        (_) => _.apiRunner,
+        DispatchEditFormLauncherState<T, Flags>().Updaters.Core.apiRunner,
+      ),
+      HandleApiResponse<
+        DispatchEditFormLauncherState<T, Flags>,
+        DispatchEditFormLauncherContext<
+          T,
+          Flags,
+          CustomPresentationContexts,
+          ExtraContext
+        >,
+        ApiErrors
+      >((_) => _.apiRunner.sync, {
+        handleSuccess: current.launcherRef.apiHandlers?.onUpdateSuccess,
+        handleError: current.launcherRef.apiHandlers?.onUpdateError,
+      }),
+      setChecked(true),
+    ]);
+  });
+};

package/src/forms/domains/dispatched-forms/runner/domains/kind/edit/coroutines/builder.ts

@@ -0,0 +1,24 @@
+import {
+  CoTypedFactory,
+  DispatchInjectablesTypes,
+} from "../../../../../../../../../main";
+import {
+  DispatchEditFormLauncherContext,
+  DispatchEditFormLauncherState,
+} from "../state";
+
+export const EditCoBuilder = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>() =>
+  CoTypedFactory<
+    DispatchEditFormLauncherContext<
+      T,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext
+    >,
+    DispatchEditFormLauncherState<T, Flags>
+  >();

package/src/forms/domains/dispatched-forms/runner/domains/kind/edit/coroutines/runner.ts

@@ -0,0 +1,43 @@
+import {
+  ApiResponseChecker,
+  DispatchInjectablesTypes,
+} from "../../../../../../../../../main";
+import { initCo } from "./_init";
+import { syncCo } from "./_sync";
+import { DispatchEditFormLauncherForeignMutationsExpected } from "../state";
+import { EditCoBuilder } from "./builder";
+
+export const DispatchEditFormRunner = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>() => {
+  const Co = EditCoBuilder<
+    T,
+    Flags,
+    CustomPresentationContexts,
+    ExtraContext
+  >();
+
+  const init = initCo<T, Flags, CustomPresentationContexts, ExtraContext>(Co);
+  const sync = syncCo<T, Flags, CustomPresentationContexts, ExtraContext>(Co);
+
+  return Co.Template<DispatchEditFormLauncherForeignMutationsExpected<T>>(
+    init,
+    {
+      runFilter: (_) =>
+        !ApiResponseChecker.Operations.checked(_.context.apiChecker.init) ||
+        _.context.entity.sync.kind != "loaded",
+    },
+  ).any([
+    Co.Template<DispatchEditFormLauncherForeignMutationsExpected<T>>(sync, {
+      runFilter: (_) =>
+        _.context.entity.sync.kind == "loaded" &&
+        (_.context.apiRunner.sync.kind === "loading" ||
+          _.context.apiRunner.sync.kind === "reloading" ||
+          _.context.apiRunner.sync.kind === "loaded") &&
+        !ApiResponseChecker.Operations.checked(_.context.apiChecker.update),
+    }),
+  ]);
+};

package/src/forms/domains/dispatched-forms/runner/domains/kind/edit/state.ts

@@ -0,0 +1,96 @@
+import {
+  DispatchFormRunnerContext,
+  DispatchFormRunnerState,
+  DispatchInjectablesTypes,
+  EditLauncherRef,
+  Guid,
+  ApiErrors,
+  Unit,
+  DispatchCommonFormRunnerState,
+  ApiResponseChecker,
+  Synchronized,
+  unit,
+  simpleUpdaterWithChildren,
+  simpleUpdater,
+  PredicateValue,
+  BasicUpdater,
+  Updater,
+  AsyncState,
+} from "../../../../../../../../main";
+
+export type DispatchEditFormLauncherApi = {
+  get: (id: Guid) => Promise<any>;
+  update: (id: Guid, raw: any) => Promise<ApiErrors>;
+};
+
+export type DispatchEditFormLauncherContext<
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+  CustomPresentationContexts = Unit,
+  ExtraContext = Unit,
+> = Omit<
+  DispatchFormRunnerContext<T, Flags, CustomPresentationContexts, ExtraContext>,
+  "launcherRef"
+> & {
+  launcherRef: EditLauncherRef;
+};
+
+export type DispatchEditFormLauncherState<
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+> = DispatchCommonFormRunnerState<T, Flags> & {
+  entity: Synchronized<Unit, PredicateValue>;
+  config: Synchronized<Unit, PredicateValue>;
+  apiChecker: {
+    init: ApiResponseChecker;
+    update: ApiResponseChecker;
+  };
+  apiRunner: Synchronized<Unit, ApiErrors>;
+};
+
+export type DispatchEditFormLauncherForeignMutationsExpected<T> = {};
+
+export const DispatchEditFormLauncherState = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+>() => ({
+  Default: (): DispatchEditFormLauncherState<T, Flags> => ({
+    ...DispatchCommonFormRunnerState<T, Flags>().Default(),
+    entity: Synchronized.Default(unit),
+    config: Synchronized.Default(unit),
+    apiChecker: {
+      init: ApiResponseChecker.Default(false),
+      update: ApiResponseChecker.Default(false),
+    },
+    apiRunner: Synchronized.Default(unit),
+  }),
+  Updaters: {
+    Core: {
+      ...simpleUpdater<DispatchEditFormLauncherState<T, Flags>>()("status"),
+      ...simpleUpdater<DispatchEditFormLauncherState<T, Flags>>()("formState"),
+      ...simpleUpdater<DispatchEditFormLauncherState<T, Flags>>()("entity"),
+      ...simpleUpdater<DispatchEditFormLauncherState<T, Flags>>()("config"),
+      ...simpleUpdater<DispatchEditFormLauncherState<T, Flags>>()("apiRunner"),
+      ...simpleUpdaterWithChildren<DispatchEditFormLauncherState<T, Flags>>()({
+        ...simpleUpdater<
+          DispatchEditFormLauncherState<T, Flags>["apiChecker"]
+        >()("init"),
+        ...simpleUpdater<
+          DispatchEditFormLauncherState<T, Flags>["apiChecker"]
+        >()("update"),
+      })("apiChecker"),
+    },
+    Template: {
+      entity: (
+        _: BasicUpdater<PredicateValue>,
+      ): Updater<DispatchEditFormLauncherState<T, Flags>> =>
+        DispatchEditFormLauncherState<T, Flags>().Updaters.Core.entity(
+          Synchronized.Updaters.sync(AsyncState.Operations.map(_)),
+        ),
+      submit: (): Updater<DispatchEditFormLauncherState<T, Flags>> =>
+        DispatchEditFormLauncherState<T, Flags>().Updaters.Core.apiRunner(
+          Synchronized.Updaters.sync(AsyncState.Updaters.toLoading()),
+        ),
+    },
+  },
+});

package/src/forms/domains/dispatched-forms/runner/domains/kind/edit/template.tsx

@@ -0,0 +1,115 @@
+import {
+  DispatchEditFormLauncherContext,
+  DispatchEditFormLauncherState,
+  DispatchEditFormLauncherForeignMutationsExpected,
+} from "./state";
+import {
+  DispatchInjectablesTypes,
+  Template,
+  Unit,
+  AsyncState,
+  Bindings,
+  unit,
+} from "../../../../../../../../main";
+import React from "react";
+import { DispatchEditFormRunner } from "./coroutines/runner";
+import { Map } from "immutable";
+
+export const DispatchEditFormLauncherTemplate = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>() =>
+  Template.Default<
+    DispatchEditFormLauncherContext<
+      T,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext
+    >,
+    DispatchEditFormLauncherState<T, Flags>,
+    DispatchEditFormLauncherForeignMutationsExpected<T>
+  >((props) => {
+    const entity = props.context.entity.sync;
+    const config = props.context.config.sync;
+
+    if (
+      !AsyncState.Operations.hasValue(entity) ||
+      !AsyncState.Operations.hasValue(config) ||
+      props.context.status.kind == "not initialized"
+    ) {
+      return <></>;
+    }
+
+    if (props.context.status.kind == "error") {
+      console.error(
+        props.context.status.errors.map((error) => error).join("\n"),
+      );
+      return (
+        props.context.errorComponent ?? <>Error: Check console for details</>
+      );
+    }
+
+    if (config.kind == "failed-reload") {
+      console.error(config.error);
+      return (
+        props.context.errorComponent ?? <>Error: Check console for details</>
+      );
+    }
+
+    if (props.context.status.kind == "loading" || config.kind == "reloading") {
+      return props.context.loadingComponent ?? <></>;
+    }
+
+    const bindings: Bindings = Map([
+      ["global", config.value],
+      ["root", entity.value],
+      ["local", entity.value],
+    ]);
+
+    return (
+      <props.context.status.Form
+        context={{
+          ...props.context.formState,
+          value: entity.value,
+          locked: false,
+          disabled: false,
+          bindings,
+          extraContext: props.context.extraContext,
+          remoteEntityVersionIdentifier:
+            props.context.remoteEntityVersionIdentifier,
+          domNodeAncestorPath: "",
+          lookupTypeAncestorNames: [],
+        }}
+        setState={(stateUpdater) =>
+          props.setState(
+            DispatchEditFormLauncherState<T, Flags>().Updaters.Core.formState(
+              stateUpdater,
+            ),
+          )
+        }
+        view={unit}
+        foreignMutations={{
+          ...props.foreignMutations,
+          onChange: (pvUpdater, delta) => {
+            if (pvUpdater.kind == "l") return;
+
+            props.setState(
+              DispatchEditFormLauncherState<
+                T,
+                Flags
+              >().Updaters.Template.entity(pvUpdater.value),
+            );
+          },
+        }}
+      />
+    );
+  }).any([
+    DispatchEditFormRunner<
+      T,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext
+    >(),
+  ]);