ballerina-core 1.0.78 → 1.0.80

package/main.ts

@@ -118,11 +118,8 @@ export * from "./src/forms/domains/launcher/template"
 export * from "./src/forms/domains/parser/domains/injectables/state"
 export * from "./src/forms/domains/collection/domains/unionCase/state"
 export * from "./src/forms/domains/parser/domains/predicates/state"
-export * from "./src/forms/domains/integrated-forms/domains/launcher/domains/integrated-form/state"
-export * from "./src/forms/domains/integrated-forms/domains/launcher/domains/integrated-form/template"
-export * from "./src/forms/domains/integrated-forms/domains/parser/state"
-export * from "./src/forms/domains/integrated-forms/domains/launcher/state"
-export * from "./src/forms/domains/integrated-forms/domains/launcher/template"
+export * from "./src/forms/domains/launcher/domains/passthrough/state"
+export * from "./src/forms/domains/launcher/domains/passthrough/template"
 
 // import { simpleUpdater, simpleUpdaterWithChildren } from "./src/fun/domains/updater/domains/simpleUpdater/state"
 // import { Updater } from "./src/fun/domains/updater/state"

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.78",
+  "version": "1.0.80",
   "main": "main.ts",
   "dependencies": {
     "immutable": "^5.0.0-beta.5",

package/src/forms/domains/launcher/coroutines/runner.ts

@@ -73,7 +73,32 @@ export const FormRunnerLoader = () => {
                   })
                 )
               )
+          } else if (formRef.kind == "passthrough") {
+            const form = current.formsConfig.sync.value.value.passthrough.get(formRef.formName)
+            if (form == undefined)
+                return FormRunnerState.Updaters.form(
+                  replaceWith(
+                      Sum.Default.left(
+                        FormRunnerErrorsTemplate(Sum.Default.right(List([`Cannot find form '${formRef.formName}'`])))                      )   
+                  )
+                )
+                const instantiatedForm = form()
+            return FormRunnerState.Updaters.form(
+              replaceWith(
+                  Sum.Default.left({
+                    form: instantiatedForm.form,
+                    formFieldStates: instantiatedForm.initialState.formFieldStates,
+                    commonFormState: instantiatedForm.initialState.commonFormState,
+                    customFormState: instantiatedForm.initialState.customFormState,
+                    entity: undefined,
+                    rawEntity: undefined,
+                    rawGlobalConfiguration: undefined,
+                    globalConfiguration: undefined
+                  })
+              )
+            )
           }
+
           return id
         })
     ),

package/src/forms/domains/{integrated-forms/domains/launcher/domains/integrated-form → launcher/domains/passthrough}/coroutines/runner.ts

@@ -1,17 +1,16 @@
 import { List } from "immutable";
-import { Synchronize, Unit, replaceWith, Sum, ValueOrErrors, Debounce, id } from "../../../../../../../../../main";
-import { ApiResultStatus } from "../../../../../../../../apiResultStatus/state";
-import { AsyncState } from "../../../../../../../../async/state";
-import { CoTypedFactory } from "../../../../../../../../coroutines/builder";
-import { Debounced } from "../../../../../../../../debounced/state";
-import { PredicateValue, evaluatePredicates, FormFieldPredicateEvaluation } from "../../../../../../parser/domains/predicates/state";
-import { IntegratedFormContext, IntegratedFormForeignMutationsExpected, IntegratedFormWritableState, IntegratedFormState } from "../state";
+import { replaceWith, ValueOrErrors, Debounce } from "../../../../../../../main";
+import { ApiResultStatus } from "../../../../../../apiResultStatus/state";
+import { CoTypedFactory } from "../../../../../../coroutines/builder";
+import { Debounced } from "../../../../../../debounced/state";
+import { PredicateValue, evaluatePredicates, FormFieldPredicateEvaluation } from "../../../../parser/domains/predicates/state";
+import { PassthroughFormContext, PassthroughFormForeignMutationsExpected, PassthroughFormWritableState, PassthroughFormState } from "../state";
 
 
-export const integratedFormRunner = <E, FS>() => {
+export const passthroughFormRunner = <E, FS>() => {
   const Co = CoTypedFactory<
-    IntegratedFormContext<E, FS> & IntegratedFormForeignMutationsExpected<E, FS> & { onRawEntityChange: (updatedRawEntity: any, path: List<string>) => void },
-    IntegratedFormWritableState<E, FS>
+    PassthroughFormContext<E, FS> & PassthroughFormForeignMutationsExpected<E, FS> & { onRawEntityChange: (updatedRawEntity: any, path: List<string>) => void },
+    PassthroughFormWritableState<E, FS>
   >();
 
   const calculateInitialVisibilities = Co.GetState().then((current) => { 
@@ -24,23 +23,23 @@ export const integratedFormRunner = <E, FS>() => {
     if(typeof parsedRootPredicate.value != "object" || !("kind" in parsedRootPredicate.value) || parsedRootPredicate.value.kind != "record") {
       return Co.Do(() => {})
     }
-    return Co.SetState(IntegratedFormState<E, FS>().Updaters.Core.customFormState.children.predicateEvaluations(
+    return Co.SetState(PassthroughFormState<E, FS>().Updaters.Core.customFormState.children.predicateEvaluations(
       replaceWith(Debounced.Default(evaluatePredicates({
         global: current.globalConfiguration.value,
         types: current.types,
         visibilityPredicateExpressions: current.visibilityPredicateExpressions,
         disabledPredicatedExpressions: current.disabledPredicatedExpressions
-      }, parsedRootPredicate.value)))).then(IntegratedFormState<E, FS>().Updaters.Core.customFormState.children.isInitialized(replaceWith(true)))
+      }, parsedRootPredicate.value)))).then(PassthroughFormState<E, FS>().Updaters.Core.customFormState.children.isInitialized(replaceWith(true)))
     )
   })
 
-  const PredicatesCo = CoTypedFactory<IntegratedFormWritableState<E, FS> & IntegratedFormContext<E, FS>, ValueOrErrors<{
+  const PredicatesCo = CoTypedFactory<PassthroughFormWritableState<E, FS> & PassthroughFormContext<E, FS>, ValueOrErrors<{
     visiblityPredicateEvaluations: FormFieldPredicateEvaluation;
     disabledPredicateEvaluations: FormFieldPredicateEvaluation;
   }, string>>();
 
   const calculateVisibilities = Co.Repeat(
-    Debounce<ValueOrErrors<{visiblityPredicateEvaluations: FormFieldPredicateEvaluation; disabledPredicateEvaluations: FormFieldPredicateEvaluation;}, string>, IntegratedFormContext<E, FS> & IntegratedFormWritableState<E, FS>>(
+    Debounce<ValueOrErrors<{visiblityPredicateEvaluations: FormFieldPredicateEvaluation; disabledPredicateEvaluations: FormFieldPredicateEvaluation;}, string>, PassthroughFormContext<E, FS> & PassthroughFormWritableState<E, FS>>(
     PredicatesCo.GetState().then((current) => { 
       if(current.entity.kind == "r" || current.globalConfiguration.kind == "r") {
         return PredicatesCo.Return<ApiResultStatus>("permanent failure")
@@ -64,14 +63,14 @@ export const integratedFormRunner = <E, FS>() => {
   , 50)
   .embed(
     (_) => ({ ..._, ..._.customFormState.predicateEvaluations }),
-    IntegratedFormState<E, FS>().Updaters.Core.customFormState.children.predicateEvaluations)
+    PassthroughFormState<E, FS>().Updaters.Core.customFormState.children.predicateEvaluations)
   )
 
-  return Co.Template<IntegratedFormForeignMutationsExpected<E, FS>>(calculateInitialVisibilities, {
+  return Co.Template<PassthroughFormForeignMutationsExpected<E, FS>>(calculateInitialVisibilities, {
       interval: 15,
       runFilter: (props) => !props.context.customFormState.isInitialized && props.context.globalConfiguration.kind != "r" && props.context.initialRawEntity.kind != "r"
     }).any([
-    Co.Template<IntegratedFormForeignMutationsExpected<E, FS>>(calculateVisibilities, {
+    Co.Template<PassthroughFormForeignMutationsExpected<E, FS>>(calculateVisibilities, {
       interval: 15,
       runFilter: (props) =>
         Debounced.Operations.shouldCoroutineRun(props.context.customFormState.predicateEvaluations)

package/src/forms/domains/{integrated-forms/domains/launcher/domains/integrated-form → launcher/domains/passthrough}/state.ts

@@ -14,10 +14,10 @@ import {
   id,
   ForeignMutationsInput,
   Sum
-} from "../../../../../../../../main";
+} from "../../../../../../main";
 import { List, Map } from "immutable";
 
-export type IntegratedFormContext<E, FS> = {
+export type PassthroughFormContext<E, FS> = {
   formType: ParsedType<E>;
   types: Map<string, ParsedType<E>>;
   globalConfiguration: Sum<PredicateValue, "not initialized">;
@@ -26,7 +26,7 @@ export type IntegratedFormContext<E, FS> = {
   onRawEntityChange: (updater: Updater<E>, path: List<string>) => void;
   toApiParser: (
     entity: E,
-    formstate: IntegratedFormState<E,FS>,
+    formstate: PassthroughFormState<E,FS>,
     checkKeys: boolean
   ) => ValueOrErrors<E, string>;
   fromApiParser: (raw: any) => any;
@@ -44,7 +44,7 @@ export type IntegratedFormContext<E, FS> = {
   >;
 };
 
-export type IntegratedFormState<E,FS> = {
+export type PassthroughFormState<E,FS> = {
   formFieldStates: FS,  
   commonFormState: CommonFormState,
   customFormState: {
@@ -56,8 +56,8 @@ export type IntegratedFormState<E,FS> = {
   }
 }
 
-export const IntegratedFormState = <E,FS>() => ({
-    Default:(formFieldStates:FS, commonFormState: CommonFormState) : IntegratedFormState<E,FS> => ({
+export const PassthroughFormState = <E,FS>() => ({
+    Default:(formFieldStates:FS, commonFormState: CommonFormState) : PassthroughFormState<E,FS> => ({
       formFieldStates,
       commonFormState,
       customFormState: {
@@ -70,29 +70,29 @@ export const IntegratedFormState = <E,FS>() => ({
     }),
     Updaters:{
       Core:{
-        ...simpleUpdater<IntegratedFormState<E,FS>>()("formFieldStates"),
-        ...simpleUpdaterWithChildren<IntegratedFormState<E,FS>>()({
-            ...simpleUpdater<IntegratedFormState<E,FS>["customFormState"]>()("predicateEvaluations"),
-            ...simpleUpdater<IntegratedFormState<E,FS>["customFormState"]>()("isInitialized"),
+        ...simpleUpdater<PassthroughFormState<E,FS>>()("formFieldStates"),
+        ...simpleUpdaterWithChildren<PassthroughFormState<E,FS>>()({
+            ...simpleUpdater<PassthroughFormState<E,FS>["customFormState"]>()("predicateEvaluations"),
+            ...simpleUpdater<PassthroughFormState<E,FS>["customFormState"]>()("isInitialized"),
         })("customFormState"),
-        ...simpleUpdater<IntegratedFormState<E,FS>>()("commonFormState"),
+        ...simpleUpdater<PassthroughFormState<E,FS>>()("commonFormState"),
       },
       Template:{
-        recalculatePredicates: () : Updater<IntegratedFormState<E,FS>> => 
-          IntegratedFormState<E,FS>().Updaters.Core.customFormState.children.predicateEvaluations(
+        recalculatePredicates: () : Updater<PassthroughFormState<E,FS>> => 
+          PassthroughFormState<E,FS>().Updaters.Core.customFormState.children.predicateEvaluations(
             Debounced.Updaters.Template.value(
               id
             )
           )
       }
     },
-    ForeignMutations: (_: ForeignMutationsInput<IntegratedFormContext<E,FS>, IntegratedFormWritableState<E,FS>>) => ({
+    ForeignMutations: (_: ForeignMutationsInput<PassthroughFormContext<E,FS>, PassthroughFormWritableState<E,FS>>) => ({
   
     })
   })
 
-  export type IntegratedFormWritableState<E, FS> = IntegratedFormState<E,FS>
-  export type IntegratedFormForeignMutationsExposed<E,FS> = ReturnType<ReturnType<typeof IntegratedFormState<E,FS>>["ForeignMutations"]>
-  export type IntegratedFormForeignMutationsExpected<E, FS> = {
+  export type PassthroughFormWritableState<E, FS> = PassthroughFormState<E,FS>
+  export type PassthroughFormForeignMutationsExposed<E,FS> = ReturnType<ReturnType<typeof PassthroughFormState<E,FS>>["ForeignMutations"]>
+  export type PassthroughFormForeignMutationsExpected<E, FS> = {
 
   }

package/src/forms/domains/{integrated-forms/domains/launcher/domains/integrated-form → launcher/domains/passthrough}/template.tsx

@@ -1,27 +1,27 @@
-import { unit } from "../../../../../../../../main";
-import { Template } from "../../../../../../../template/state";
-import { IntegratedFormContext, IntegratedFormForeignMutationsExpected, IntegratedFormState, IntegratedFormWritableState } from "./state";
-import { integratedFormRunner } from "./coroutines/runner";
-export type IntegratedFormView<E, FS> =
+import { unit } from "../../../../../../main";
+import { Template } from "../../../../../template/state";
+import { PassthroughFormContext, PassthroughFormForeignMutationsExpected, PassthroughFormState, PassthroughFormWritableState } from "./state";
+import { passthroughFormRunner } from "./coroutines/runner";
+export type PassthroughFormView<E, FS> =
   Template<
-    IntegratedFormContext<E, FS> & IntegratedFormWritableState<E, FS>,
-    IntegratedFormWritableState<E, FS>,
-    IntegratedFormForeignMutationsExpected<E, FS>,
+    PassthroughFormContext<E, FS> & PassthroughFormWritableState<E, FS>,
+    PassthroughFormWritableState<E, FS>,
+    PassthroughFormForeignMutationsExpected<E, FS>,
     {
       actualForm: JSX.Element | undefined
     }>
-export type IntegratedFormTemplate<E, FS> =
+export type PassthroughFormTemplate<E, FS> =
   Template<
-    IntegratedFormContext<E, FS> & IntegratedFormWritableState<E, FS>,
-    IntegratedFormWritableState<E, FS>,
-    IntegratedFormForeignMutationsExpected<E, FS>,
-    IntegratedFormView<E, FS>>
-export const IntegratedFormTemplate = <E, FS>(): IntegratedFormTemplate<E, FS> =>
+    PassthroughFormContext<E, FS> & PassthroughFormWritableState<E, FS>,
+    PassthroughFormWritableState<E, FS>,
+    PassthroughFormForeignMutationsExpected<E, FS>,
+    PassthroughFormView<E, FS>>
+export const PassthroughFormTemplate = <E, FS>(): PassthroughFormTemplate<E, FS> =>
   Template.Default<
-    IntegratedFormContext<E, FS> & IntegratedFormWritableState<E, FS>,
-    IntegratedFormWritableState<E, FS>,
-    IntegratedFormForeignMutationsExpected<E, FS>,
-    IntegratedFormView<E, FS>>(props => {
+    PassthroughFormContext<E, FS> & PassthroughFormWritableState<E, FS>,
+    PassthroughFormWritableState<E, FS>,
+    PassthroughFormForeignMutationsExpected<E, FS>,
+    PassthroughFormView<E, FS>>(props => {
       if(props.context.entity.kind == "r" || props.context.globalConfiguration.kind == "r") {
         return <>
         </>
@@ -60,7 +60,7 @@ export const IntegratedFormTemplate = <E, FS>(): IntegratedFormTemplate<E, FS> =
                         if(props.context.entity.kind == "r") 
                           return
                         props.context.onRawEntityChange(updater, path)
-                        props.setState(IntegratedFormState<E, FS>().Updaters.Template.recalculatePredicates())
+                        props.setState(PassthroughFormState<E, FS>().Updaters.Template.recalculatePredicates())
                       }
                     },
                     view: unit
@@ -70,5 +70,5 @@ export const IntegratedFormTemplate = <E, FS>(): IntegratedFormTemplate<E, FS> =
         }
       </>
     }).any([
-      integratedFormRunner<E, FS>()
+      passthroughFormRunner<E, FS>()
     ])

package/src/forms/domains/launcher/state.ts

@@ -1,47 +1,72 @@
-import { BasicFun, Guid, simpleUpdater, Sum, Unit } from "../../../../main"
-import { FormParsingResult, FormsParserState } from "../parser/state"
+import { List } from "immutable";
+import { BasicFun, Guid, PredicateValue, simpleUpdater, Sum, Unit, ValueOrErrors } from "../../../../main";
+import { FormParsingResult, FormsParserState } from "../parser/state";
 
 export type FormRefCreateApiHandlers<Arg> = {
-  onDefaultSuccess?: (_: Arg) => void,
-  onDefaultError?: (_: Arg) => void,
-  onCreateSuccess?: (_: Arg) => void,
-  onCreateError?: (_: Arg) => void,
-}
+  onDefaultSuccess?: (_: Arg) => void;
+  onDefaultError?: (_: Arg) => void;
+  onCreateSuccess?: (_: Arg) => void;
+  onCreateError?: (_: Arg) => void;
+};
 
 export type FormRefEditApiHandlers<Arg> = {
-  onGetSuccess?: (_: Arg) => void,
-  onGetError?: (_: Arg) => void,
-  onUpdateSuccess?: (_: Arg) => void,
-  onUpdateError?: (_: Arg) => void,
-}
+  onGetSuccess?: (_: Arg) => void;
+  onGetError?: (_: Arg) => void;
+  onUpdateSuccess?: (_: Arg) => void;
+  onUpdateError?: (_: Arg) => void;
+};
 
 export type FormRef = {
-  formName:string
-} & ({
-  kind:"edit",
-  submitButtonWrapper:any
-  entityId:Guid,
-  apiHandlers?: FormRefEditApiHandlers<any>
-} | {
-  kind:"create",
-  apiHandlers?: FormRefCreateApiHandlers<any>,
-  submitButtonWrapper:any
-})
+  formName: string;
+} & (
+  | {
+      kind: "edit";
+      submitButtonWrapper: any;
+      entityId: Guid;
+      apiHandlers?: FormRefEditApiHandlers<any>;
+    }
+  | {
+      kind: "create";
+      apiHandlers?: FormRefCreateApiHandlers<any>;
+      submitButtonWrapper: any;
+    }
+  | {
+      kind: "passthrough";
+      initialRawEntity: Sum<any, "not initialized">;
+      entity: Sum<any, "not initialized">;
+      globalConfiguration: Sum<PredicateValue, "not initialized">;
+      containerWrapper: any;
+      onRawEntityChange: (updatedRawEntity: any, path: List<string>) => void;
+    }
+);
 
 export type FormRunnerContext = {
-  extraContext:any
-  formRef:FormRef
-  showFormParsingErrors: BasicFun<FormParsingResult, JSX.Element>
-} & FormsParserState
+  extraContext: any;
+  formRef: FormRef;
+  showFormParsingErrors: BasicFun<FormParsingResult, JSX.Element>;
+} & FormsParserState;
+
 export type FormRunnerState = {
-  form:Sum<{ form:any, formFieldStates:any, entity:any, rawEntity:any, rawGlobalConfiguration: any, commonFormState:any, customFormState:any, globalConfiguration:any }, "not initialized">
-}
-export type FormRunnerForeignMutationsExpected = Unit
+  form: Sum<
+    {
+      form: any;
+      formFieldStates: any;
+      entity: any;
+      rawEntity: any;
+      rawGlobalConfiguration: any;
+      commonFormState: any;
+      customFormState: any;
+      globalConfiguration: any;
+    },
+    "not initialized"
+  >;
+};
+export type FormRunnerForeignMutationsExpected = Unit;
 export const FormRunnerState = {
-  Default:():FormRunnerState => ({
-    form:Sum.Default.right("not initialized"),
+  Default: (): FormRunnerState => ({
+    form: Sum.Default.right("not initialized"),
   }),
-  Updaters:{
+  Updaters: {
     ...simpleUpdater<FormRunnerState>()("form"),
-  }
-}
+  },
+};

package/src/forms/domains/launcher/template.tsx

@@ -28,19 +28,21 @@ export const FormRunnerTemplate =
         <props.context.form.value.form
           context={{
             entityId: props.context.formRef.kind == "edit" ? props.context.formRef.entityId : undefined,
-            entity: props.context.form.value.entity,
+            initialRawEntity: props.context.formRef.kind == "passthrough" ? props.context.formRef.initialRawEntity : undefined,
+            entity: props.context.formRef.kind == "passthrough" ? props.context.formRef.entity : props.context.form.value.entity,
+            onRawEntityChange: props.context.formRef.kind == "passthrough" ? props.context.formRef.onRawEntityChange : undefined,
+            globalConfiguration: props.context.formRef.kind == "passthrough" ? props.context.formRef.globalConfiguration : props.context.form.value.globalConfiguration,
             rawEntity: props.context.form.value.rawEntity,
             rawGlobalConfiguration: props.context.form.value.rawGlobalConfiguration,
-            globalConfiguration: props.context.form.value.globalConfiguration,
             formFieldStates: props.context.form.value.formFieldStates,
             commonFormState: props.context.form.value.commonFormState,
             customFormState: props.context.form.value.customFormState,
             extraContext: {
               ...props.context.extraContext,
-              rootValue:
-                  props.context.form.value?.entity.sync?.value,
+              rootValue: props.context.formRef.kind == "passthrough" ? undefined : props.context.form.value?.entity.sync?.value
             },
-            submitButtonWrapper: (props.context.formRef.kind == "create" || props.context.formRef.kind == "edit" )  ? props.context.formRef.submitButtonWrapper : undefined
+            submitButtonWrapper: (props.context.formRef.kind == "create" || props.context.formRef.kind == "edit" )  ? props.context.formRef.submitButtonWrapper : undefined,
+            containerWrapper: props.context.formRef.kind == "passthrough" ? props.context.formRef.containerWrapper : undefined
           }}
           setState={(_: BasicUpdater<any>) => props.setState(
             FormRunnerState.Updaters.form(Sum.Updaters.left(_))

package/src/forms/domains/parser/coroutines/runner.ts

@@ -23,7 +23,6 @@ export const LoadValidateAndParseFormsConfig = <T extends {[key in keyof T] : {t
       current.fieldViews,
       current.infiniteStreamSources,
       current.enumOptionsSources,
-      current.globalConfigurationSources,
       current.entityApis,
       )(validationResult.value)
   }, _ => "transient failure", 5, 50)

package/src/forms/domains/parser/domains/types/state.ts

@@ -118,9 +118,6 @@ export const ParsedType = {
               .Then(parsedField => ValueOrErrors.Default.return<ParsedType<T>, string>(ParsedType.Default.form(fieldName, parsedField)))
       }
       if(RawFieldType.isUnionCase(rawFieldType)){
-        if(Object.keys(rawFieldType.fields).length > 0) {
-          return ValueOrErrors.Default.throwOne(`Error: arg ${JSON.stringify(rawFieldType)} has unsupported fields, not an enum case`)
-        }
         return ParsedType.Operations.ParseRawFieldType(rawFieldType.case, rawFieldType.fields, types, injectedPrimitives).Then(parsedFields =>
           ValueOrErrors.Default.return(ParsedType.Default.unionCase(rawFieldType.case, unit))
         )
@@ -131,9 +128,6 @@ export const ParsedType = {
           if(!RawFieldType.isUnionCase(unionCase)) {
             return ValueOrErrors.Default.throwOne(`Error: arg ${JSON.stringify(unionCase)} is not a valid union case`)
           }
-          if(Object.keys(unionCase.fields).length > 0) {
-            return ValueOrErrors.Default.throwOne(`Error: arg ${JSON.stringify(unionCase)} has unsupported fields, not an enum case`)
-          }
           return ValueOrErrors.Default.return(ParsedType.Default.unionCase(unionCase.case, unit))
           }))
         ).Then(parsedUnionCases => ValueOrErrors.Default.return(ParsedType.Default.union(Map(parsedUnionCases.toArray().map(_ => [_.name, _] as const)))))

package/src/forms/domains/parser/domains/validator/state.ts

@@ -19,7 +19,6 @@ export type ParsedFormConfig<T> = {
   name: string;
   type: ParsedType<T>;
   fields: Map<FieldName, ParsedRenderer<T>>;
-  configType: ParsedType<T>;
   tabs: FormLayout;
   header?: string;
 };
@@ -32,13 +31,30 @@ export type ColumnLayout = {
 export type TabLayout = {
   columns: OrderedMap<string, ColumnLayout>;
 };
-export type Launcher = {
+
+export type BaseLauncher = {
   name: string,
-  kind: "create" | "edit",
   form: string,
+}
+
+export type CreateLauncher = {
+  kind: "create",
   api: string,
   configApi: string
-}
+} & BaseLauncher
+
+export type EditLauncher = {
+  kind: "edit",
+  api: string,
+  configApi: string
+} & BaseLauncher
+
+export type PassthroughLauncher = {
+  kind: "passthrough",
+  configType: string
+} & BaseLauncher
+
+export type Launcher = CreateLauncher | EditLauncher | PassthroughLauncher
 
 export type RawEntityApi = {
   type?: any;
@@ -62,8 +78,7 @@ export type RawFormJSON = {
 export const RawFormJSON = {
   hasTypes: (_: any): _ is { types: object } => isObject(_) && "types" in _ && isObject(_.types),
   hasForms: (_: any): _ is { forms: object } => isObject(_) && "forms" in _ && isObject(_.forms),
-  hasApis: (_: any): _ is { apis: { enumOptions: object; searchableStreams: object; entities: {globalConfiguration: object}; globalConfiguration: object }} => isObject(_) && "apis" in _ && isObject(_.apis) && "enumOptions" in _.apis && isObject(_.apis.enumOptions) && "searchableStreams" in _.apis && isObject(_.apis.searchableStreams) && "entities" in _.apis && isObject(_.apis.entities) && "globalConfiguration" in _.apis.entities && isObject(_.apis.entities.globalConfiguration), 
-  isGlobalConfigurationApi: (_: any): _ is { type: string, methods: string[]}  => isObject(_) && "type" in _  && typeof _.type == "string" && "methods" in _ && Array.isArray(_.methods) && _.methods.every((method: any) => typeof method == "string"),
+  hasApis: (_: any): _ is { apis: { enumOptions: object; searchableStreams: object; entities: {globalConfiguration: object}; globalConfiguration: object }} => isObject(_) && "apis" in _ && isObject(_.apis) && "enumOptions" in _.apis && isObject(_.apis.enumOptions) && "searchableStreams" in _.apis, 
   hasLaunchers: (_: any): _ is { launchers: any } => isObject(_) && "launchers" in _,
 }
 export type ParsedFormJSON<T> = {
@@ -72,12 +87,12 @@ export type ParsedFormJSON<T> = {
     enums: Map<string, TypeName>;
     streams: Map<string, TypeName>;
     entities: Map<string, EntityApi>;
-    globalConfiguration: GlobalConfigurationApi;
   };
   forms: Map<string, ParsedFormConfig<T>>;
   launchers: {
-    create: Map<string, Launcher>;
-    edit: Map<string, Launcher>;
+    create: Map<string, CreateLauncher>;
+    edit: Map<string, EditLauncher>;
+    passthrough: Map<string, PassthroughLauncher>;
   }
 };
 
@@ -153,19 +168,6 @@ export const FormsConfig = {
           streams = streams.set(searchableStreamName, searchableStream)
       )
 
-      const globalConfigFromForm = formsConfig.apis.entities.globalConfiguration;
-      if(!RawFormJSON.isGlobalConfigurationApi(globalConfigFromForm)) {
-        errors = errors.push(`globalConfiguration is missing the required type and methods attributes`);
-        return ValueOrErrors.Default.throw(errors);
-      }
-
-      const globalConfiguration: GlobalConfigurationApi = {
-        type: globalConfigFromForm.type,
-        methods: {
-          get: globalConfigFromForm.methods.includes("get"),
-        }
-      }
-
       let entities: Map<string, EntityApi> = Map();
       Object.entries(formsConfig.apis.entities).forEach(([entityApiName, entityApi]: [entiyApiName: string, entityApi: RawEntityApi ]) => {
         entities = entities.set(entityApiName, {
@@ -191,7 +193,7 @@ export const FormsConfig = {
           return
         }
 
-        const parsedForm: ParsedFormConfig<T> = { name: formName, fields: Map(), tabs: Map(), type: parsedTypes.get(form.type)!, configType: parsedTypes.get(globalConfigFromForm.type)!, header: RawForm.hasHeader(form) ? form.header : undefined };
+        const parsedForm: ParsedFormConfig<T> = { name: formName, fields: Map(), tabs: Map(), type: parsedTypes.get(form.type)!, header: RawForm.hasHeader(form) ? form.header : undefined };
 
         Object.entries(form.fields).forEach(([fieldName, field]: [fieldName: string, field: any]) =>
           {  
@@ -236,23 +238,34 @@ export const FormsConfig = {
         forms = forms.set(formName, parsedForm);
       })
 
-
       let launchers: ParsedFormJSON<T>["launchers"] = {
-        create: Map<string, Launcher>(),
-        edit: Map<string, Launcher>(),
+        create: Map<string, CreateLauncher>(),
+        edit: Map<string, EditLauncher>(),
+        passthrough: Map<string, PassthroughLauncher>(),
       }
+
       Object.keys(formsConfig["launchers"]).forEach((launcherName: any) => {
-        let launcher: Launcher = {
-          name: launcherName,
-          kind: formsConfig.launchers[launcherName]["kind"],
-          form: formsConfig.launchers[launcherName]["form"],
-          api: formsConfig.launchers[launcherName]["api"],
-          configApi: formsConfig.launchers[launcherName]["configApi"],
-        };
+        const launcher: Launcher =
+          formsConfig.launchers[launcherName]["kind"] == "create" || formsConfig.launchers[launcherName]["kind"] == "edit" ?
+            {
+              name: launcherName,
+              kind: formsConfig.launchers[launcherName]["kind"],
+              form: formsConfig.launchers[launcherName]["form"],
+              api: formsConfig.launchers[launcherName]["api"],
+              configApi: formsConfig.launchers[launcherName]["configApi"],
+            } :
+            {
+              name: launcherName,
+              kind: formsConfig.launchers[launcherName]["kind"],
+              form: formsConfig.launchers[launcherName]["form"],
+              configType: formsConfig.launchers[launcherName]["configType"],
+            }
         if (launcher.kind == "create")
           launchers.create = launchers.create.set(launcherName, launcher)
-        else
+        else if (launcher.kind == "edit")
           launchers.edit = launchers.edit.set(launcherName, launcher)
+        else if (launcher.kind == "passthrough")
+          launchers.passthrough = launchers.passthrough.set(launcherName, launcher)
       })
 
       if (errors.size > 0) {
@@ -268,7 +281,6 @@ export const FormsConfig = {
           enums,
           streams,
           entities,
-          globalConfiguration
         },
         launchers
       });