ballerina-core 1.0.228 → 1.0.229

package/src/forms/domains/dispatched-forms/runner/{coroutines → domains/kind/passthrough/coroutines}/runner.ts

@@ -1,60 +1,45 @@
-import { AsyncState } from "../../../../../async/state";
-import { CoTypedFactory } from "../../../../../coroutines/builder";
 import {
-  ApiSources,
-  DispatchFormRunnerContext,
-  DispatchFormRunnerForeignMutationsExpected,
+  AsyncState,
+  CoTypedFactory,
+  Dispatcher,
+  DispatchCommonFormRunnerState,
+  DispatchFormRunnerState,
   DispatchFormRunnerStatus,
+  DispatchInjectablesTypes,
+  id,
+  replaceWith,
+  Unit,
+  DispatcherContextWithApiSources,
+} from "../../../../../../../../../main";
+import {
+  DispatchPassthroughFormLauncherContext,
+  DispatchPassthroughFormLauncherState,
+  DispatchPassthroughFormLauncherForeignMutationsExpected,
 } from "../state";
-import { id } from "../../../../../fun/domains/id/state";
-import { DispatchFormRunnerState } from "../state";
-import { replaceWith } from "../../../../../fun/domains/updater/domains/replaceWith/state";
 import { List } from "immutable";
-import {
-  DispatchInjectablesTypes,
-  Dispatcher,
-  DispatcherContext,
-  DispatchParsedType,
-  Renderer,
-  ValueOrErrors,
-} from "../../../../../../main";
 
-export type DispatcherContextWithApiSources<
-  T extends DispatchInjectablesTypes<T>,
-  Flags,
-  CustomPresentationContexts,
-  ExtraContext,
-> = Omit<
-  DispatcherContext<T, Flags, CustomPresentationContexts, ExtraContext>,
-  "defaultState"
-> &
-  ApiSources & {
-    defaultState: (
-      t: DispatchParsedType<T>,
-      renderer: Renderer<T>,
-    ) => ValueOrErrors<any, string>;
-  };
-
-export const DispatchFormRunner = <
+export const DispatchPassthroughFormRunner = <
   T extends DispatchInjectablesTypes<T>,
   Flags,
   CustomPresentationContexts,
   ExtraContext,
 >() => {
   const Co = CoTypedFactory<
-    DispatchFormRunnerContext<
+    DispatchPassthroughFormLauncherContext<
       T,
       Flags,
       CustomPresentationContexts,
       ExtraContext
     >,
-    DispatchFormRunnerState<T, Flags>
+    DispatchPassthroughFormLauncherState<T, Flags>
   >();
 
-  return Co.Template<DispatchFormRunnerForeignMutationsExpected>(
+  return Co.Template<
+    DispatchPassthroughFormLauncherForeignMutationsExpected<T>
+  >(
     Co.Seq([
       Co.SetState(
-        DispatchFormRunnerState<T, Flags>().Updaters.status(
+        DispatchCommonFormRunnerState<T, Flags>().Updaters.status(
           replaceWith<DispatchFormRunnerStatus<T, Flags>>({ kind: "loading" }),
         ),
       ),
@@ -72,7 +57,10 @@ export const DispatchFormRunner = <
                 return id;
 
               if (current.deserializedSpecification.sync.value.kind == "errors")
-                return DispatchFormRunnerState<T, Flags>().Updaters.status(
+                return DispatchCommonFormRunnerState<
+                  T,
+                  Flags
+                >().Updaters.status(
                   replaceWith<DispatchFormRunnerStatus<T, Flags>>({
                     kind: "error",
                     errors: current.deserializedSpecification.sync.value.errors,
@@ -88,7 +76,10 @@ export const DispatchFormRunner = <
                     .toArray()
                     .join("\n")}`,
                 );
-                return DispatchFormRunnerState<T, Flags>().Updaters.status(
+                return DispatchCommonFormRunnerState<
+                  T,
+                  Flags
+                >().Updaters.status(
                   replaceWith<DispatchFormRunnerStatus<T, Flags>>({
                     kind: "error",
                     errors: current.launcherRef.entity.value.errors,
@@ -105,7 +96,10 @@ export const DispatchFormRunner = <
                     .toArray()
                     .join("\n")}`,
                 );
-                return DispatchFormRunnerState<T, Flags>().Updaters.status(
+                return DispatchCommonFormRunnerState<
+                  T,
+                  Flags
+                >().Updaters.status(
                   replaceWith<DispatchFormRunnerStatus<T, Flags>>({
                     kind: "error",
                     errors: current.launcherRef.config.value.errors,
@@ -128,7 +122,10 @@ export const DispatchFormRunner = <
                   `Cannot find form '${launcherRef.name}' in the launchers`,
                 );
 
-                return DispatchFormRunnerState<T, Flags>().Updaters.status(
+                return DispatchCommonFormRunnerState<
+                  T,
+                  Flags
+                >().Updaters.status(
                   replaceWith<DispatchFormRunnerStatus<T, Flags>>({
                     kind: "error",
                     errors: List([
@@ -163,7 +160,10 @@ export const DispatchFormRunner = <
 
               if (Form.kind == "errors") {
                 console.error(Form.errors.valueSeq().toArray().join("\n"));
-                return DispatchFormRunnerState<T, Flags>().Updaters.status(
+                return DispatchCommonFormRunnerState<
+                  T,
+                  Flags
+                >().Updaters.status(
                   replaceWith<DispatchFormRunnerStatus<T, Flags>>({
                     kind: "error",
                     errors: Form.errors,
@@ -181,17 +181,21 @@ export const DispatchFormRunner = <
                 console.error(
                   initialState.errors.valueSeq().toArray().join("\n"),
                 );
-                return DispatchFormRunnerState<T, Flags>().Updaters.status(
+                return DispatchCommonFormRunnerState<
+                  T,
+                  Flags
+                >().Updaters.status(
                   replaceWith<DispatchFormRunnerStatus<T, Flags>>({
                     kind: "error",
                     errors: initialState.errors,
                   }),
                 );
               }
-              return DispatchFormRunnerState<T, Flags>()
+
+              return DispatchCommonFormRunnerState<T, Flags>()
                 .Updaters.formState(replaceWith(initialState.value))
                 .then(
-                  DispatchFormRunnerState<T, Flags>().Updaters.status(
+                  DispatchCommonFormRunnerState<T, Flags>().Updaters.status(
                     replaceWith<DispatchFormRunnerStatus<T, Flags>>({
                       kind: "loaded",
                       Form: Form.value,

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

@@ -0,0 +1,45 @@
+import {
+  DispatchCommonFormRunnerState,
+  DispatchFormRunnerContext,
+  DispatchFormRunnerState,
+  DispatchInjectablesTypes,
+  PassthroughLauncherRef,
+  simpleUpdater,
+  Unit,
+} from "../../../../../../../../main";
+
+export type DispatchPassthroughFormLauncherContext<
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+  CustomPresentationContexts = Unit,
+  ExtraContext = Unit,
+> = Omit<
+  DispatchFormRunnerContext<T, Flags, CustomPresentationContexts, ExtraContext>,
+  "launcherRef"
+> & {
+  launcherRef: PassthroughLauncherRef<Flags>;
+};
+
+export type DispatchPassthroughFormLauncherState<
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+> = DispatchCommonFormRunnerState<T, Flags>;
+
+export type DispatchPassthroughFormLauncherForeignMutationsExpected<T> = {};
+
+export const DispatchPassthroughFormLauncherState = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+>() => ({
+  Default: (): DispatchPassthroughFormLauncherState<T, Flags> => ({
+    ...DispatchCommonFormRunnerState<T, Flags>().Default(),
+  }),
+  Updaters: {
+    ...simpleUpdater<DispatchPassthroughFormLauncherState<T, Flags>>()(
+      "status",
+    ),
+    ...simpleUpdater<DispatchPassthroughFormLauncherState<T, Flags>>()(
+      "formState",
+    ),
+  },
+});

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

@@ -0,0 +1,118 @@
+import {
+  DispatchPassthroughFormLauncherContext,
+  DispatchPassthroughFormLauncherState,
+  DispatchPassthroughFormLauncherForeignMutationsExpected,
+} from "./state";
+import {
+  BasicUpdater,
+  Bindings,
+  DispatchFormRunnerState,
+  DispatchInjectablesTypes,
+  Template,
+  unit,
+  Unit,
+} from "../../../../../../../../main";
+import { DispatchPassthroughFormRunner } from "./coroutines/runner";
+import { Map } from "immutable";
+
+export const DispatchPassthroughFormLauncherTemplate = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+>() =>
+  Template.Default<
+    DispatchPassthroughFormLauncherContext<
+      T,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext
+    > &
+      DispatchFormRunnerState<T, Flags>,
+    DispatchPassthroughFormLauncherState<T, Flags>,
+    DispatchPassthroughFormLauncherForeignMutationsExpected<T>
+  >((props) => {
+    const entity = props.context.launcherRef.entity;
+    const config = props.context.launcherRef.config;
+
+    if (
+      entity.kind == "r" ||
+      config.kind == "r" ||
+      props.context.status.kind == "not initialized"
+    ) {
+      return <></>;
+    }
+
+    if (entity.value.kind == "errors") {
+      console.error(entity.value.errors.map((error) => error).join("\n"));
+      return (
+        props.context.errorComponent ?? <>Error: Check console for details</>
+      );
+    }
+
+    if (config.value.kind == "errors") {
+      console.error(config.value.errors.map((error) => error).join("\n"));
+      return (
+        props.context.errorComponent ?? <>Error: Check console for details</>
+      );
+    }
+
+    const bindings: Bindings = Map([
+      ["global", config.value.value],
+      ["root", entity.value.value],
+      ["local", entity.value.value],
+    ]);
+
+    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 (props.context.status.kind == "loading") {
+      return props.context.loadingComponent ?? <></>;
+    }
+
+    return (
+      <props.context.status.Form
+        context={{
+          ...props.context.formState,
+          value: entity.value.value,
+          locked: false,
+          disabled: false,
+          bindings,
+          extraContext: props.context.extraContext,
+          remoteEntityVersionIdentifier:
+            props.context.remoteEntityVersionIdentifier,
+          domNodeAncestorPath: "",
+          lookupTypeAncestorNames: [],
+          // domNodeAncestorPath: `[${props.context.launcherRef.name}]`,
+        }}
+        setState={(stateUpdater) =>
+          props.setState(
+            DispatchPassthroughFormLauncherState<T, Flags>().Updaters.formState(
+              stateUpdater,
+            ),
+          )
+        }
+        view={unit}
+        foreignMutations={{
+          ...props.foreignMutations,
+          onChange: (updater, delta) => {
+            if (props.context.launcherRef.entity.kind == "r") return;
+            props.context.launcherRef.onEntityChange(updater, delta);
+          },
+        }}
+      />
+    );
+  }).any([
+    DispatchPassthroughFormRunner<
+      T,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext
+    >().mapContext((context) => context),
+  ]);

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

@@ -1,6 +1,7 @@
 import { List } from "immutable";
 import {
   BasicFun,
+  DispatchParsedType,
   DispatchSpecificationDeserializationResult,
   DispatchFormsParserState,
   PredicateValue,
@@ -17,24 +18,87 @@ import {
   DispatchEntityApis,
   DispatchTableApiSources,
   DispatchLookupSources,
+  FormRefEditApiHandlers,
+  FormRefCreateApiHandlers,
+  Guid,
+  BasicUpdater,
+  Updater,
+  Renderer,
+  DispatcherContext,
 } from "../../../../../main";
+import { DispatchCreateFormLauncherState } from "./domains/kind/create/state";
+import {
+  DispatchEditFormLauncherApi,
+  DispatchEditFormLauncherState,
+} from "./domains/kind/edit/state";
+import { DispatchPassthroughFormLauncherState } from "./domains/kind/passthrough/state";
+
+export type DispatcherContextWithApiSources<
+  T extends DispatchInjectablesTypes<T>,
+  Flags,
+  CustomPresentationContexts,
+  ExtraContext,
+> = Omit<
+  DispatcherContext<T, Flags, CustomPresentationContexts, ExtraContext>,
+  "defaultState"
+> &
+  BaseApiSources & {
+    defaultState: (
+      t: DispatchParsedType<T>,
+      renderer: Renderer<T>,
+    ) => ValueOrErrors<any, string>;
+  };
 
-export type ApiSources = {
+export type BaseLauncherRef<T extends BaseApiSources> = {
+  name: string;
+  apiSources: T;
+};
+
+export type LauncherRefWithEntityApis<T extends BaseApiSources> = T & {
+  entityApis: DispatchEntityApis;
+};
+
+export type BaseApiSources = {
   infiniteStreamSources: DispatchInfiniteStreamSources;
   enumOptionsSources: DispatchEnumOptionsSources;
-  entityApis: DispatchEntityApis;
   tableApiSources?: DispatchTableApiSources;
   lookupSources?: DispatchLookupSources;
 };
 
-export type LauncherRef<Flags = Unit> = {
-  name: string;
+export type EntityLauncherRefConfig =
+  | {
+      source: "entity";
+      value: Sum<ValueOrErrors<PredicateValue, string>, "not initialized">;
+    }
+  | {
+      source: "api";
+      getGlobalConfig?: () => Promise<any>;
+    };
+
+export type PassthroughLauncherRef<Flags = Unit> = {
   kind: "passthrough";
   entity: Sum<ValueOrErrors<PredicateValue, string>, "not initialized">;
   config: Sum<ValueOrErrors<PredicateValue, string>, "not initialized">;
   onEntityChange: DispatchOnChange<PredicateValue, Flags>;
-  apiSources: ApiSources;
-};
+} & BaseLauncherRef<BaseApiSources>;
+
+export type EditLauncherRef = {
+  kind: "edit";
+  entityId: Guid;
+  apiHandlers?: FormRefEditApiHandlers<any>;
+  config: EntityLauncherRefConfig;
+} & BaseLauncherRef<LauncherRefWithEntityApis<BaseApiSources>>;
+
+export type CreateLauncherRef = {
+  kind: "create";
+  apiHandlers?: FormRefCreateApiHandlers<any>;
+  config: EntityLauncherRefConfig;
+} & BaseLauncherRef<LauncherRefWithEntityApis<BaseApiSources>>;
+
+export type LauncherRef<Flags = Unit> =
+  | PassthroughLauncherRef<Flags>
+  | EditLauncherRef
+  | CreateLauncherRef;
 
 export type DispatchFormRunnerStatus<
   T extends DispatchInjectablesTypes<T>,
@@ -85,23 +149,89 @@ export type DispatchFormRunnerContext<
 export type DispatchFormRunnerState<
   T extends DispatchInjectablesTypes<T>,
   Flags = Unit,
+> = {
+  innerFormState:
+    | { kind: "create"; state: DispatchCreateFormLauncherState<T, Flags> }
+    | { kind: "edit"; state: DispatchEditFormLauncherState<T, Flags> }
+    | {
+        kind: "passthrough";
+        state: DispatchPassthroughFormLauncherState<T, Flags>;
+      };
+};
+
+export const DispatchFormRunnerState = <
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+>() => ({
+  Default: {
+    create: (): DispatchFormRunnerState<T, Flags> => ({
+      innerFormState: {
+        kind: "create",
+        state: DispatchCreateFormLauncherState<T, Flags>().Default(),
+      },
+    }),
+    edit: (): DispatchFormRunnerState<T, Flags> => ({
+      innerFormState: {
+        kind: "edit",
+        state: DispatchEditFormLauncherState<T, Flags>().Default(),
+      },
+    }),
+    passthrough: (): DispatchFormRunnerState<T, Flags> => ({
+      innerFormState: {
+        kind: "passthrough",
+        state: DispatchPassthroughFormLauncherState<T, Flags>().Default(),
+      },
+    }),
+  },
+  Updaters: {
+    Core: {
+      ...simpleUpdater<DispatchFormRunnerState<T, Flags>>()("innerFormState"),
+    },
+    Template: {
+      create: (
+        upd: BasicUpdater<DispatchCreateFormLauncherState<T, Flags>>,
+      ): Updater<DispatchFormRunnerState<T, Flags>> =>
+        DispatchFormRunnerState<T, Flags>().Updaters.Core.innerFormState((v) =>
+          v.kind === "create" ? { ...v, state: upd(v.state) } : v,
+        ),
+      edit: (
+        upd: BasicUpdater<DispatchEditFormLauncherState<T, Flags>>,
+      ): Updater<DispatchFormRunnerState<T, Flags>> =>
+        DispatchFormRunnerState<T, Flags>().Updaters.Core.innerFormState((v) =>
+          v.kind === "edit" ? { ...v, state: upd(v.state) } : v,
+        ),
+      passthrough: (
+        upd: BasicUpdater<DispatchPassthroughFormLauncherState<T, Flags>>,
+      ): Updater<DispatchFormRunnerState<T, Flags>> =>
+        DispatchFormRunnerState<T, Flags>().Updaters.Core.innerFormState((v) =>
+          v.kind === "passthrough" ? { ...v, state: upd(v.state) } : v,
+        ),
+    },
+  },
+});
+
+export type DispatchFormRunnerForeignMutationsExpected = Unit;
+
+export type DispatchCommonFormRunnerState<
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
 > = {
   status: DispatchFormRunnerStatus<T, Flags>;
   formState: any;
 };
-export type DispatchFormRunnerForeignMutationsExpected = Unit;
-export const DispatchFormRunnerState = <
+
+export const DispatchCommonFormRunnerState = <
   T extends DispatchInjectablesTypes<T>,
   Flags = Unit,
 >() => {
   return {
-    Default: (): DispatchFormRunnerState<T, Flags> => ({
+    Default: (): DispatchCommonFormRunnerState<T, Flags> => ({
       status: { kind: "not initialized" },
       formState: unit,
     }),
     Updaters: {
-      ...simpleUpdater<DispatchFormRunnerState<T, Flags>>()("status"),
-      ...simpleUpdater<DispatchFormRunnerState<T, Flags>>()("formState"),
+      ...simpleUpdater<DispatchCommonFormRunnerState<T, Flags>>()("status"),
+      ...simpleUpdater<DispatchCommonFormRunnerState<T, Flags>>()("formState"),
     },
   };
 };