ballerina-core 1.0.228 → 1.0.230

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

@@ -18,7 +18,7 @@ import { TupleDispatcher } from "./domains/tupleDispatcher/state";
 import { UnionDispatcher } from "./domains/unionDispatcher/state";
 import { PrimitiveDispatcher } from "./domains/primitive/state";
 import { LookupRenderer } from "../../../deserializer/domains/specification/domains/forms/domains/renderer/domains/lookup/state";
-import { DispatcherContextWithApiSources } from "../../coroutines/runner";
+import { DispatcherContextWithApiSources } from "../../state";
 
 export const Dispatcher = {
   Operations: {

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

@@ -0,0 +1,279 @@
+import { List } from "immutable";
+import {
+  replaceWith,
+  id,
+  Synchronize,
+  Unit,
+  HandleApiResponse,
+  Synchronized,
+  unit,
+  DispatchParsedCreateLauncher,
+} from "../../../../../../../../../main";
+import { ApiResponseChecker } from "../../../../../../../../api-response-handler/state";
+import { AsyncState } from "../../../../../../../../async/state";
+import { PredicateValue } from "../../../../../../parser/domains/predicates/state";
+import {
+  DispatcherContextWithApiSources,
+  DispatchFormRunnerStatus,
+} from "../../../../state";
+import { DispatchInjectablesTypes } from "../../../abstract-renderers/injectables/state";
+import { Co } from "../../../abstract-renderers/table/coroutines/builder";
+import { Dispatcher } from "../../../dispatcher/state";
+import {
+  DispatchCreateFormLauncherState,
+  DispatchCreateFormLauncherContext,
+} from "../state";
+import { CreateCoBuilder } from "./builder";
+
+export const initCo = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>(
+  Co: ReturnType<
+    typeof CreateCoBuilder<T, Flags, CustomPresentationContexts, ExtraContext>
+  >,
+) => {
+  const setChecked = (checked: boolean) =>
+    Co.SetState(
+      DispatchCreateFormLauncherState<
+        T,
+        Flags
+      >().Updaters.Core.apiChecker.children.init(
+        checked
+          ? ApiResponseChecker.Updaters().toChecked()
+          : ApiResponseChecker.Updaters().toUnchecked(),
+      ),
+    );
+
+  const defaultValueCo = (
+    defaultApi: () => Promise<PredicateValue>,
+    createFormLauncher: DispatchParsedCreateLauncher<T>,
+  ) =>
+    Synchronize<Unit, PredicateValue>(
+      () =>
+        defaultApi().then((raw) => {
+          const result = createFormLauncher.fromApiParser(raw);
+          return result.kind == "errors"
+            ? Promise.reject(result.errors)
+            : Promise.resolve(result.value);
+        }),
+      (_) => "transient failure",
+      5,
+      50,
+    ).embed(
+      (_: DispatchCreateFormLauncherState<T, Flags>) => _.entity,
+      DispatchCreateFormLauncherState<T, Flags>().Updaters.Core.entity,
+    );
+
+  const configValueCo = (
+    getGlobalConfig: () => Promise<PredicateValue>,
+    createFormLauncher: DispatchParsedCreateLauncher<T>,
+    current: DispatchCreateFormLauncherContext<
+      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(
+          (_: DispatchCreateFormLauncherState<T, Flags>) => _.config,
+          DispatchCreateFormLauncherState<T, Flags>().Updaters.Core.config,
+        )
+      : Co.SetState(
+          DispatchCreateFormLauncherState<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>) =>
+    DispatchCreateFormLauncherState<T, Flags>().Updaters.Core.status(
+      replaceWith<DispatchFormRunnerStatus<T, Flags>>({
+        kind: "error",
+        errors,
+      }),
+    );
+
+  return Co.Seq([
+    Co.SetState(
+      DispatchCreateFormLauncherState<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 createFormLauncher =
+        current.deserializedSpecification.sync.value.value.launchers.create.get(
+          current.launcherRef.name,
+        );
+
+      if (createFormLauncher == undefined) {
+        console.error(
+          `Cannot find form '${current.launcherRef.name}' in the create launchers`,
+        );
+
+        return Co.SetState(
+          errorUpd(
+            List([
+              `Cannot find form '${current.launcherRef.name}' in the create launchers`,
+            ]),
+          ),
+        );
+      }
+
+      const defaultApi = () =>
+        current.launcherRef.apiSources.entityApis.default(
+          createFormLauncher.api,
+        )("");
+      const getGlobalConfig =
+        current.launcherRef.config.source == "api" &&
+        current.launcherRef.config.getGlobalConfig
+          ? current.launcherRef.config.getGlobalConfig
+          : () =>
+              current.launcherRef.apiSources.entityApis.get(
+                createFormLauncher.configApi,
+              )("");
+
+      return Co.Seq([
+        Co.Seq([
+          Co.All([
+            defaultValueCo(defaultApi, createFormLauncher),
+            configValueCo(getGlobalConfig, createFormLauncher, 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(
+              createFormLauncher.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,
+            )(createFormLauncher.type, createFormLauncher.renderer);
+
+            if (initialState.kind == "errors") {
+              console.error(
+                initialState.errors.valueSeq().toArray().join("\n"),
+              );
+              return errorUpd(initialState.errors);
+            }
+
+            return DispatchCreateFormLauncherState<T, Flags>()
+              .Updaters.Core.formState(replaceWith(initialState.value))
+              .thenMany([
+                DispatchCreateFormLauncherState<
+                  T,
+                  Flags
+                >().Updaters.Core.status(
+                  replaceWith<DispatchFormRunnerStatus<T, Flags>>({
+                    kind: "loaded",
+                    Form: Form.value,
+                  }),
+                ),
+                DispatchCreateFormLauncherState<
+                  T,
+                  Flags
+                >().Updaters.Core.config(replaceWith(_.config)),
+              ]);
+          }),
+        ]),
+        HandleApiResponse<
+          DispatchCreateFormLauncherState<T, Flags>,
+          DispatchCreateFormLauncherContext<
+            T,
+            Flags,
+            CustomPresentationContexts,
+            ExtraContext
+          >,
+          any
+        >((_) => _.entity.sync, {
+          handleSuccess: current.launcherRef.apiHandlers?.onDefaultSuccess,
+          handleError: current.launcherRef.apiHandlers?.onDefaultError,
+        }),
+        setChecked(true),
+      ]);
+    }),
+  ]);
+};

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

@@ -0,0 +1,103 @@
+import {
+  ApiErrors,
+  ApiResponseChecker,
+  AsyncState,
+  HandleApiResponse,
+  id,
+  Synchronize,
+  Synchronized,
+  Unit,
+} from "../../../../../../../../../main";
+import { DispatchInjectablesTypes } from "../../../abstract-renderers/injectables/state";
+import {
+  DispatchCreateFormLauncherContext,
+  DispatchCreateFormLauncherState,
+} from "../state";
+import { CreateCoBuilder } from "./builder";
+
+export const syncCo = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>(
+  Co: ReturnType<
+    typeof CreateCoBuilder<T, Flags, CustomPresentationContexts, ExtraContext>
+  >,
+) => {
+  const setChecked = (checked: boolean) =>
+    Co.SetState(
+      DispatchCreateFormLauncherState<
+        T,
+        Flags
+      >().Updaters.Core.apiChecker.children.create(
+        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 createFormLauncher =
+      current.deserializedSpecification.sync.value.value.launchers.create.get(
+        current.launcherRef.name,
+      );
+
+    if (!createFormLauncher) {
+      return Co.SetState(id);
+    }
+
+    const create = current.launcherRef.apiSources.entityApis.create(
+      createFormLauncher.api,
+    );
+
+    return Co.Seq([
+      setChecked(false),
+      Synchronize<Unit, ApiErrors, Unit>(
+        (_) => {
+          if (current.entity.sync.kind !== "loaded") {
+            return Promise.resolve([]);
+          }
+
+          const parsed = createFormLauncher?.toApiParser(
+            current.entity.sync.value,
+            createFormLauncher?.type,
+            current.formState,
+          );
+
+          return !parsed || parsed?.kind == "errors"
+            ? Promise.reject(parsed?.errors)
+            : create(parsed.value).then(() => []);
+        },
+        (_) => "transient failure",
+        3,
+        50,
+      ).embed(
+        (_) => _.apiRunner,
+        DispatchCreateFormLauncherState<T, Flags>().Updaters.Core.apiRunner,
+      ),
+      HandleApiResponse<
+        DispatchCreateFormLauncherState<T, Flags>,
+        DispatchCreateFormLauncherContext<
+          T,
+          Flags,
+          CustomPresentationContexts,
+          ExtraContext
+        >,
+        ApiErrors
+      >((_) => _.apiRunner.sync, {
+        handleSuccess: current.launcherRef.apiHandlers?.onCreateSuccess,
+        handleError: current.launcherRef.apiHandlers?.onCreateError,
+      }),
+      setChecked(true),
+    ]);
+  });
+};

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

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

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

@@ -0,0 +1,44 @@
+import {
+  DispatchInjectablesTypes,
+  Debounced,
+  ApiResponseChecker,
+} from "../../../../../../../../../main";
+import { DispatchCreateFormLauncherForeignMutationsExpected } from "../state";
+import { CreateCoBuilder } from "./builder";
+import { initCo } from "./_init";
+import { syncCo } from "./_sync";
+
+export const DispatchCreateFormRunner = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>() => {
+  const Co = CreateCoBuilder<
+    T,
+    Flags,
+    CustomPresentationContexts,
+    ExtraContext
+  >();
+
+  const init = initCo<T, Flags, CustomPresentationContexts, ExtraContext>(Co);
+  const sync = syncCo<T, Flags, CustomPresentationContexts, ExtraContext>(Co);
+
+  return Co.Template<DispatchCreateFormLauncherForeignMutationsExpected<T>>(
+    init,
+    {
+      runFilter: (_) =>
+        !ApiResponseChecker.Operations.checked(_.context.apiChecker.init) ||
+        _.context.entity.sync.kind != "loaded",
+    },
+  ).any([
+    Co.Template<DispatchCreateFormLauncherForeignMutationsExpected<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.create),
+    }),
+  ]);
+};

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

@@ -0,0 +1,100 @@
+import {
+  DispatchFormRunnerContext,
+  DispatchInjectablesTypes,
+  CreateLauncherRef,
+  Unit,
+  ApiErrors,
+  Synchronized,
+  PredicateValue,
+  unit,
+  simpleUpdater,
+  ApiResponseChecker,
+  DispatchCommonFormRunnerState,
+  AsyncState,
+  BasicUpdater,
+  Updater,
+  simpleUpdaterWithChildren,
+} from "../../../../../../../../main";
+
+export type DispatchCreateFormLauncherApi = {
+  default: () => Promise<any>;
+  create: (raw: any) => Promise<ApiErrors>;
+};
+
+export type DispatchCreateFormLauncherContext<
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+  CustomPresentationContexts = Unit,
+  ExtraContext = Unit,
+> = Omit<
+  DispatchFormRunnerContext<T, Flags, CustomPresentationContexts, ExtraContext>,
+  "launcherRef"
+> & {
+  launcherRef: CreateLauncherRef;
+};
+
+export type DispatchCreateFormLauncherState<
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+> = DispatchCommonFormRunnerState<T, Flags> & {
+  entity: Synchronized<Unit, PredicateValue>;
+  config: Synchronized<Unit, PredicateValue>;
+  apiChecker: {
+    init: ApiResponseChecker;
+    create: ApiResponseChecker;
+  };
+  apiRunner: Synchronized<Unit, ApiErrors>;
+};
+
+export const DispatchCreateFormLauncherState = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+>() => ({
+  Default: (): DispatchCreateFormLauncherState<T, Flags> => ({
+    ...DispatchCommonFormRunnerState<T, Flags>().Default(),
+    entity: Synchronized.Default(unit),
+    config: Synchronized.Default(unit),
+    apiChecker: {
+      init: ApiResponseChecker.Default(false),
+      create: ApiResponseChecker.Default(false),
+    },
+    apiRunner: Synchronized.Default(unit),
+  }),
+  Updaters: {
+    Core: {
+      ...simpleUpdater<DispatchCreateFormLauncherState<T, Flags>>()("status"),
+      ...simpleUpdater<DispatchCreateFormLauncherState<T, Flags>>()(
+        "formState",
+      ),
+      ...simpleUpdater<DispatchCreateFormLauncherState<T, Flags>>()("entity"),
+      ...simpleUpdater<DispatchCreateFormLauncherState<T, Flags>>()("config"),
+      ...simpleUpdater<DispatchCreateFormLauncherState<T, Flags>>()(
+        "apiRunner",
+      ),
+      ...simpleUpdaterWithChildren<DispatchCreateFormLauncherState<T, Flags>>()(
+        {
+          ...simpleUpdater<
+            DispatchCreateFormLauncherState<T, Flags>["apiChecker"]
+          >()("init"),
+          ...simpleUpdater<
+            DispatchCreateFormLauncherState<T, Flags>["apiChecker"]
+          >()("create"),
+        },
+      )("apiChecker"),
+    },
+    Template: {
+      entity: (
+        _: BasicUpdater<PredicateValue>,
+      ): Updater<DispatchCreateFormLauncherState<T, Flags>> =>
+        DispatchCreateFormLauncherState<T, Flags>().Updaters.Core.entity(
+          Synchronized.Updaters.sync(AsyncState.Operations.map(_)),
+        ),
+      submit: (): Updater<DispatchCreateFormLauncherState<T, Flags>> =>
+        DispatchCreateFormLauncherState<T, Flags>().Updaters.Core.apiRunner(
+          Synchronized.Updaters.sync(AsyncState.Updaters.toLoading()),
+        ),
+    },
+  },
+});
+
+export type DispatchCreateFormLauncherForeignMutationsExpected<T> = {};

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

@@ -0,0 +1,116 @@
+import {
+  DispatchCreateFormLauncherContext,
+  DispatchCreateFormLauncherState,
+  DispatchCreateFormLauncherForeignMutationsExpected,
+} from "./state";
+import {
+  DispatchInjectablesTypes,
+  Template,
+  Unit,
+  AsyncState,
+  unit,
+  Bindings,
+  PredicateValue,
+  Synchronized,
+} from "../../../../../../../../main";
+import { DispatchCreateFormRunner } from "./coroutines/runner";
+import { Map } from "immutable";
+
+export const DispatchCreateFormLauncherTemplate = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>() =>
+  Template.Default<
+    DispatchCreateFormLauncherContext<
+      T,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext
+    >,
+    DispatchCreateFormLauncherState<T, Flags>,
+    DispatchCreateFormLauncherForeignMutationsExpected<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(
+            DispatchCreateFormLauncherState<T, Flags>().Updaters.Core.formState(
+              stateUpdater,
+            ),
+          )
+        }
+        view={unit}
+        foreignMutations={{
+          ...props.foreignMutations,
+          onChange: (pvUpdater, delta) => {
+            if (pvUpdater.kind == "l") return;
+
+            props.setState(
+              DispatchCreateFormLauncherState<
+                T,
+                Flags
+              >().Updaters.Template.entity(pvUpdater.value),
+            );
+          },
+        }}
+      />
+    );
+  }).any([
+    DispatchCreateFormRunner<
+      T,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext
+    >(),
+  ]);