ballerina-core 1.0.10 → 1.0.12

package/main.ts

@@ -95,6 +95,8 @@ export * from "./src/forms/domains/parser/state"
 export * from "./src/forms/domains/parser/template"
 export * from "./src/forms/domains/parser/coroutines/runner"
 export * from "./src/forms/domains/parser/domains/validator/state"
+export * from "./src/forms/domains/parser/domains/built-ins/state"
+export * from "./src/forms/domains/parser/domains/types/state"
 export * from "./src/forms/domains/launcher/domains/edit/state"
 export * from "./src/forms/domains/launcher/domains/edit/template"
 export * from "./src/forms/domains/launcher/domains/edit/coroutines/runner"

package/package.json

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

package/src/coroutines/state.ts

@@ -243,10 +243,10 @@ export const Coroutine = {
           return CoroutineStep.Result(nextState, step.result);
         else {
           if (step.excludeOthers) {
-            console.log(
-              `exclude others detected, killing ${ps.length - 1
-              } other coroutines`
-            );
+            // console.log(
+            //   `exclude others detected, killing ${ps.length - 1
+            //   } other coroutines`
+            // );
             return CoroutineStep.MapState(
               step.next([context, deltaT]),
               ((_) => thenMaybe(nextState, _) || id)

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

@@ -1,9 +1,37 @@
-import { FormValidationError } from "../../../parser/domains/validator/state"
+import { merge } from 'immutable'
+
+const INITIAL_CONFIG = {
+  types: {},
+  forms: {},
+  apis: {
+    enumOptions: {},
+    searchableStreams: {},
+    entities: {},
+  },
+  mappings: {},
+  launchers: {}
+}
 
 export const FormsConfigMerger = {
   Default:{
-    merge:(formsConfigs:any, errors:Array<FormValidationError>) : [any, Array<FormValidationError>] => {
-      return null!
+    merge: (formsConfigs: any): any => {
+      if (!formsConfigs || formsConfigs.length === 0) {
+        return {...INITIAL_CONFIG};
+      }
+
+      return formsConfigs.reduce((acc: any, current: any) => {
+        return {
+          types: merge(acc.types, current.types),
+          forms: merge(acc.forms, current.forms),
+          apis: {
+            enumOptions: merge(acc.apis.enumOptions, current.apis.enumOptions),
+            searchableStreams: merge(acc.apis.searchableStreams, current.apis.searchableStreams),
+            entities: merge(acc.apis.entities, current.apis.entities),
+          },
+          mappings: merge(acc.mappings, current.mappings),
+          launchers: merge(acc.launchers, current.launchers),
+        }
+      }, {...INITIAL_CONFIG})
     }
   }
 }

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

@@ -1,6 +1,6 @@
-import { AsyncState, FormsConfig, Sum, Synchronize, Unit } from "../../../../../main"
+import { AsyncState, builtInsFromFieldViews, FormsConfig, Sum, Synchronize, Unit } from "../../../../../main"
 import { CoTypedFactory } from "../../../../coroutines/builder"
-import { builtInsFromFieldViews, FormParsingResult, FormsParserContext, FormsParserState, parseForms } from "../state"
+import { FormParsingResult, FormsParserContext, FormsParserState, parseForms } from "../state"
 
 export const LoadValidateAndParseFormsConfig = () => {
   const Co = CoTypedFactory<FormsParserContext, FormsParserState>()
@@ -9,13 +9,14 @@ export const LoadValidateAndParseFormsConfig = () => {
   Co.GetState().then(current => 
   Synchronize<Unit, FormParsingResult>(async() => {
     const formsConfig = await current.getFormsConfig()
-    const builtIns = builtInsFromFieldViews(current.fieldViews)
+    const builtIns = builtInsFromFieldViews(current.fieldViews, current.fieldTypeConverters)
     const validationResult = FormsConfig.Default.validateAndParseAPIResponse(builtIns)(formsConfig)
     if (validationResult.kind == "r")
       return Sum.Default.right(validationResult.value)
     return parseForms(
       builtIns,
       current.containerFormView,
+      current.nestedContainerFormView,
       current.fieldViews,
       current.infiniteStreamSources,
       current.enumOptionsSources,

package/src/forms/domains/parser/domains/built-ins/state.ts

@@ -0,0 +1,189 @@
+import { Map, List, Set, OrderedMap } from "immutable"
+import { CollectionReference } from "../../../collection/domains/reference/state";
+import { CollectionSelection } from "../../../collection/domains/selection/state";
+import { BasicFun } from "../../../../../fun/state";
+import { Option, Sum } from "../../../../../collections/domains/sum/state"
+import { Type, TypeDefinition, TypeName } from "../../../../../../main";
+
+export const PrimitiveTypes =
+  ["string",
+    "number",
+    "boolean",
+    "maybeBoolean",
+    "Date",
+    "CollectionReference"] as const
+export type PrimitiveType = (typeof PrimitiveTypes)[number]
+
+export const GenericTypes = [
+  "SingleSelection",
+  "MultiSelection",
+  "List"] as const
+export type GenericType = (typeof GenericTypes)[number]
+
+export type ApiConverter<T> = { fromAPIRawValue: BasicFun<any, T>, toAPIRawValue: BasicFun<T, any> }
+export type ApiConverters = {
+  "string": ApiConverter<string>
+  "number": ApiConverter<number>
+  "boolean": ApiConverter<boolean>
+  "maybeBoolean": ApiConverter<boolean | undefined>
+  "Date": ApiConverter<Date>
+  "CollectionReference": ApiConverter<CollectionReference>
+  "SingleSelection": ApiConverter<CollectionSelection<any>>
+  "MultiSelection": ApiConverter<OrderedMap<string, any>>
+  "List": ApiConverter<List<any>>
+}
+
+export type PrimitiveBuiltIn = { renderers: Set<keyof BuiltIns["renderers"]>, apiConverters: ApiConverter<any>, defaultValue: any }
+export type GenericBuiltIn = { defaultValue: any, apiConverters: ApiConverter<any> }
+export type BuiltIns = {
+  primitives: Map<string, PrimitiveBuiltIn>;
+  generics: Map<string, GenericBuiltIn>;
+  renderers: {
+    boolean: Set<string>;
+    maybeBoolean: Set<string>;
+    number: Set<string>;
+    string: Set<string>;
+    date: Set<string>;
+    enumSingleSelection: Set<string>;
+    enumMultiSelection: Set<string>;
+    streamSingleSelection: Set<string>;
+    streamMultiSelection: Set<string>;
+    list: Set<string>;
+  };
+};
+
+export const builtInsFromFieldViews = (fieldViews: any, fieldTypeConverters: ApiConverters): BuiltIns => {
+  let builtins: BuiltIns = {
+    "primitives": Map<string, PrimitiveBuiltIn>([
+      ["string", { renderers: Set(["string"]), apiConverters: fieldTypeConverters["string"], defaultValue: "" }] as [string, PrimitiveBuiltIn],
+      ["number", { renderers: Set(["number"]), apiConverters: fieldTypeConverters["number"], defaultValue: 0 }] as [string, PrimitiveBuiltIn],
+      ["boolean", { renderers: Set(["boolean"]), apiConverters: fieldTypeConverters["boolean"], defaultValue: false }],
+      ["maybeBoolean", { renderers: Set(["maybeBoolean"]), apiConverters: fieldTypeConverters["maybeBoolean"], defaultValue: undefined }] as [string, PrimitiveBuiltIn],
+      ["date", { renderers: Set(["date"]), apiConverters: fieldTypeConverters["Date"], defaultValue: new Date(Date.now()) }] as [string, PrimitiveBuiltIn],
+      ["Date", { renderers: Set(["date"]), apiConverters: fieldTypeConverters["Date"], defaultValue: new Date(Date.now()) }] as [string, PrimitiveBuiltIn],
+      ["CollectionReference", { renderers: Set(["enumSingleSelection", "enumMultiSelection", "streamSingleSelection", "streamMultiSelection"]), apiConverters: fieldTypeConverters["CollectionReference"], defaultValue: CollectionReference.Default("", "") }] as [string, PrimitiveBuiltIn]
+    ]),
+    "generics": Map([
+      ["SingleSelection", { apiConverters: fieldTypeConverters["SingleSelection"], defaultValue: CollectionSelection().Default.right("no selection") }] as [string, GenericBuiltIn],
+      ["Multiselection", { apiConverters: fieldTypeConverters["SingleSelection"], defaultValue: Map() }] as [string, GenericBuiltIn],
+      ["List", { apiConverters: fieldTypeConverters["SingleSelection"], defaultValue: [] }] as [string, GenericBuiltIn]
+    ]),
+    "renderers": {
+      "boolean": Set(),
+      "maybeBoolean": Set(),
+      "date": Set(),
+      "enumMultiSelection": Set(),
+      "enumSingleSelection": Set(),
+      "streamMultiSelection": Set(),
+      "streamSingleSelection": Set(),
+      "number": Set(),
+      "string": Set(),
+      "list": Set(),
+    }
+  }
+  Object.keys(builtins.renderers).forEach((_categoryName) => {
+    const categoryName = _categoryName as keyof BuiltIns["renderers"]
+    if (categoryName in fieldViews) {
+      Object.keys(fieldViews[categoryName]).forEach(viewName => {
+        builtins.renderers[categoryName] = builtins.renderers[categoryName].add(viewName)
+      })
+    }
+  })
+  return builtins
+}
+
+
+export const defaultValue = (types:Map<TypeName, TypeDefinition>, builtIns:BuiltIns) => (t: TypeName): any => {
+  let primitive = builtIns.primitives.get(t)
+  if (primitive != undefined) {
+    return primitive.defaultValue
+  } else {
+    let generic = builtIns.generics.get(t)
+    if (generic != undefined) {
+      return generic.defaultValue
+    } else {
+      let custom = types.get(t)
+      if (custom != undefined) {
+        let res = {} as any
+        custom.fields.forEach((field, fieldName) => {
+          res[fieldName] = defaultValue(types, builtIns)(field.kind == "primitive" ? field.value : field.kind == "lookup" ? field.name : field.value)
+        }
+        )
+        return res
+      } else {
+        throw `cannot find type ${t} when resolving defaultValue`
+      }
+    }
+  }
+}
+
+export const fromAPIRawValue = (t:Type, types:Map<TypeName, TypeDefinition>, builtIns:BuiltIns, converters:ApiConverters) => (raw:any) : any => {
+  if (raw == undefined) {
+    console.error(`instantiating default value for type ${JSON.stringify(t)}: something is missing from the API response`)
+    return defaultValue(types, builtIns)(t.kind == "primitive" ? t.value : t.kind == "lookup" ? t.name : t.value)
+  }
+
+  if (t.kind == "primitive") {
+    return converters[t.value].fromAPIRawValue(raw)
+  } else if (t.kind == "application") { // application here means "generic type application"
+    if (t.value == "SingleSelection" && t.args.length == 1) {
+      let result = converters[t.value].fromAPIRawValue(raw)
+      result = CollectionSelection().Updaters.left(
+        fromAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters))(result)
+      return result
+    }
+    if (t.value == "MultiSelection" && t.args.length == 1) {
+      let result = converters[t.value].fromAPIRawValue(raw)
+      result = result.map(fromAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters))
+      return result
+    }
+    if (t.value == "List" && t.args.length == 1) {
+      let result = converters[t.value].fromAPIRawValue(raw)
+      result = result.map(fromAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters))
+      return result
+    }
+  } else { // t.kind == lookup: we are dealing with a record/object
+    let result:any = {}
+    const tDef = types.get(t.name)!
+    tDef.fields.forEach((fieldType, fieldName) => {
+      result[fieldName] = fromAPIRawValue(fieldType, types, builtIns, converters)(raw[fieldName])
+    })
+    return result
+  }
+  console.error(`instantiating default value for type ${JSON.stringify(t)}: something is missing from the API response`)
+  return defaultValue(types, builtIns)(t.value)     
+}
+
+
+export const toAPIRawValue = (t:Type, types:Map<TypeName, TypeDefinition>, builtIns:BuiltIns, converters:ApiConverters) => (raw:any) : any => {
+  if (t.kind == "primitive") {
+    // t.value == ""
+    return converters[t.value].toAPIRawValue(raw as never)
+  } else if (t.kind == "application") { // application here means "generic type application"
+    if (t.value == "SingleSelection" && t.args.length == 1) {
+      let result = converters[t.value].toAPIRawValue(raw)
+      result = CollectionSelection().Updaters.left(
+        toAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters))(result)
+      return result
+    }
+    if (t.value == "MultiSelection" && t.args.length == 1) {
+      let result = converters[t.value].toAPIRawValue(raw)
+      result = result.map(toAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters))
+      return result
+    }
+    if (t.value == "List" && t.args.length == 1) {
+      let result = converters[t.value].toAPIRawValue(raw)
+      result = result.map(toAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters))
+      return result
+    }
+  } else { // t.kind == lookup: we are dealing with a record/object
+    let result:any = {}
+    const tDef = types.get(t.name)!
+    tDef.fields.forEach((fieldType, fieldName) => {
+      result[fieldName] = toAPIRawValue(fieldType, types, builtIns, converters)(raw[fieldName])
+    })
+    return result
+  }
+  console.error(`instantiating default value for type ${JSON.stringify(t)}: something is missing from the API response`)
+  return defaultValue(types, builtIns)(t.value)     
+}

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

@@ -0,0 +1 @@
+// export type 

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

@@ -0,0 +1,31 @@
+import { OrderedMap } from "immutable";
+
+export type FieldName = string;
+export type TypeName = string;
+export type TypeDefinition = {
+  extends: Array<TypeName>;
+  name: TypeName;
+  fields: OrderedMap<FieldName, Type>;
+};
+export type Type = {
+  kind: "lookup"; name: TypeName;
+} | {
+  kind: "primitive"; value: "string" | "number" | "maybeBoolean" | "boolean" | "Date" | "CollectionReference";
+} | {
+  kind: "application"; value: TypeName; args: Array<TypeName>;
+};
+export const Type = {
+  Default: {
+    lookup: (name: TypeName): Type => ({ kind: "lookup", name })
+  },
+  Operations: {
+    Equals: (fst: Type, snd: Type): boolean =>
+      fst.kind == "lookup" && snd.kind == "lookup" ? fst.name == snd.name :
+        fst.kind == "primitive" && snd.kind == "primitive" ? fst.value == snd.value :
+          fst.kind == "application" && snd.kind == "application" ?
+            fst.value == snd.value &&
+            fst.args.length == snd.args.length &&
+            fst.args.every((v, i) => v == snd.args[i]) :
+            false
+  }
+}

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

@@ -1,35 +1,6 @@
 import { Set, Map, OrderedMap } from "immutable";
-import { BoolExpr, FormsConfigMerger, MappingPaths, Sum } from "../../../../../../main";
+import { BoolExpr, BuiltIns, FieldName, FormsConfigMerger, MappingPaths, Sum, Type, TypeDefinition, TypeName } from "../../../../../../main";
 
-export type FieldName = string;
-export type TypeName = string;
-export type TypeDefinition = {
-  extends: Array<TypeName>;
-  name: TypeName;
-  fields: OrderedMap<FieldName, Type>;
-};
-export type Type = {
-  kind: "lookup"; name: TypeName;
-} | {
-  kind: "primitive"; value: "string" | "number" | "maybeBoolean" | "boolean" | "Date" | "CollectionReference";
-} | {
-  kind: "application"; value: TypeName; args: Array<TypeName>;
-};
-export const Type = {
-  Default: {
-    lookup: (name: TypeName): Type => ({ kind: "lookup", name })
-  },
-  Operations: {
-    Equals: (fst: Type, snd: Type): boolean =>
-      fst.kind == "lookup" && snd.kind == "lookup" ? fst.name == snd.name :
-        fst.kind == "primitive" && snd.kind == "primitive" ? fst.value == snd.value :
-          fst.kind == "application" && snd.kind == "application" ?
-            fst.value == snd.value &&
-            fst.args.length == snd.args.length &&
-            fst.args.every((v, i) => v == snd.args[i]) :
-            false
-  }
-}
 export type FieldConfig = {
   renderer: string;
   label: string
@@ -91,37 +62,12 @@ export type FormsConfig = {
 };
 export type FormValidationError = string;
 
-export type PrimitiveBuiltIn = { renderers: Set<keyof BuiltIns["renderers"]>, defaultValue: any }
-export type GenericBuiltIn = { defaultValue: any }
-export type BuiltIns = {
-  primitives: Map<string, PrimitiveBuiltIn>;
-  generics: Map<string, GenericBuiltIn>;
-  renderers: {
-    BooleanViews: Set<string>;
-    MaybeBooleanViews: Set<string>;
-    NumberViews: Set<string>;
-    StringViews: Set<string>;
-    DateViews: Set<string>;
-    EnumViews: Set<string>;
-    EnumMultiselectViews: Set<string>;
-    InfiniteStreamViews: Set<string>;
-    InfiniteStreamMultiselectViews: Set<string>;
-    ListViews: Set<string>;
-  };
-};
-
 export type FormValidationResult = Sum<FormsConfig, Array<FormValidationError>>
 export const FormsConfig = {
   Default: {
-    validateAndParseAPIResponse: (builtIns: BuiltIns) => (formsConfig: any): FormValidationResult => {
+    validateAndParseAPIResponse: (builtIns: BuiltIns) => (fc: any): FormValidationResult => {
       let errors: Array<FormValidationError> = [];
-      if (Array.isArray(formsConfig)) {
-        alert("formsConfig is an array!")
-        const merged = FormsConfigMerger.Default.merge(formsConfig, errors)
-        formsConfig = merged[0]
-        errors = merged[0]
-      }
-
+      const formsConfig = Array.isArray(fc) ? FormsConfigMerger.Default.merge(fc) : fc;
       let types: Map<TypeName, TypeDefinition> = Map();
       if ("types" in formsConfig == false) {
         errors.push("the formsConfig does not contain a 'types' field");
@@ -346,57 +292,59 @@ export const FormsConfig = {
                 if (fieldTypeDef.value == "maybeBoolean") {
                   // alert(JSON.stringify(fieldConfig["renderer"]))
                   // alert(JSON.stringify(builtIns.renderers.MaybeBooleanViews))
-                  if (!builtIns.renderers.MaybeBooleanViews.has(fieldConfig["renderer"]))
+                  if (!builtIns.renderers.maybeBoolean.has(fieldConfig["renderer"]))
                     errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
                 } else if (fieldTypeDef.value == "boolean") {
-                  if (!builtIns.renderers.BooleanViews.has(fieldConfig["renderer"]))
+                  if (!builtIns.renderers.boolean.has(fieldConfig["renderer"]))
                     errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
                 } else if (fieldTypeDef.value == "number") {
-                  if (!builtIns.renderers.NumberViews.has(fieldConfig["renderer"]))
+                  if (!builtIns.renderers.number.has(fieldConfig["renderer"]))
                     errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
                 } else if (fieldTypeDef.value == "string") {
-                  if (!builtIns.renderers.StringViews.has(fieldConfig["renderer"]))
+                  if (!builtIns.renderers.string.has(fieldConfig["renderer"]))
                     errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
                 } else if (fieldTypeDef.value == "Date") {
-                  if (!builtIns.renderers.DateViews.has(fieldConfig["renderer"]))
+                  if (!builtIns.renderers.date.has(fieldConfig["renderer"])) {
+                    alert(JSON.stringify(builtIns.renderers))
                     errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
-                } else {
+                  }
+                  } else {
                   errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
                 }
               } else if (fieldTypeDef?.kind == "application") {
                 if (fieldTypeDef?.value == "SingleSelection") {
-                  if (!builtIns.renderers.EnumViews.has(fieldConfig["renderer"]) &&
-                    !builtIns.renderers.InfiniteStreamViews.has(fieldConfig["renderer"]))
+                  if (!builtIns.renderers.enumSingleSelection.has(fieldConfig["renderer"]) &&
+                    !builtIns.renderers.streamSingleSelection.has(fieldConfig["renderer"]))
                     errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
                 } else if (fieldTypeDef?.value == "Multiselection") {
-                  if (!builtIns.renderers.EnumMultiselectViews.has(fieldConfig["renderer"]) &&
-                    !builtIns.renderers.InfiniteStreamMultiselectViews.has(fieldConfig["renderer"]))
+                  if (!builtIns.renderers.enumMultiSelection.has(fieldConfig["renderer"]) &&
+                    !builtIns.renderers.streamMultiSelection.has(fieldConfig["renderer"]))
                     errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
                 } else if (fieldTypeDef?.value == "List") {
-                  if (!builtIns.renderers.ListViews.has(fieldConfig["renderer"]))
+                  if (!builtIns.renderers.list.has(fieldConfig["renderer"]))
                     errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
                 }
                 if (fieldTypeDef.args.length < 1)
                   errors.push(`field ${fieldName} of form ${formName} should have one type argument}`);
                 else if (
-                  (builtIns.renderers.ListViews.has(fieldConfig["renderer"])) && "elementRenderer" in fieldConfig != true)
+                  (builtIns.renderers.list.has(fieldConfig["renderer"])) && "elementRenderer" in fieldConfig != true)
                   errors.push(`field ${fieldName} of form ${formName} is missing the 'elementRenderer' property`);
                 else if (
-                  (builtIns.renderers.EnumMultiselectViews.has(fieldConfig["renderer"]) ||
-                    builtIns.renderers.EnumViews.has(fieldConfig["renderer"])) && "options" in fieldConfig != true)
+                  (builtIns.renderers.enumMultiSelection.has(fieldConfig["renderer"]) ||
+                    builtIns.renderers.enumSingleSelection.has(fieldConfig["renderer"])) && "options" in fieldConfig != true)
                   errors.push(`field ${fieldName} of form ${formName} is missing the 'options' property`);
                 else if (
-                  (builtIns.renderers.InfiniteStreamViews.has(fieldConfig["renderer"]) ||
-                    builtIns.renderers.InfiniteStreamMultiselectViews.has(fieldConfig["renderer"])) && "stream" in fieldConfig != true)
+                  (builtIns.renderers.streamSingleSelection.has(fieldConfig["renderer"]) ||
+                    builtIns.renderers.streamMultiSelection.has(fieldConfig["renderer"])) && "stream" in fieldConfig != true)
                   errors.push(`field ${fieldName} of form ${formName} is missing the 'stream' property`);
-                else if ((builtIns.renderers.EnumMultiselectViews.has(fieldConfig["renderer"]) ||
-                  builtIns.renderers.EnumViews.has(fieldConfig["renderer"])) && (enums.get(fieldConfig["options"])) != fieldTypeDef.args[0]) {
+                else if ((builtIns.renderers.enumMultiSelection.has(fieldConfig["renderer"]) ||
+                  builtIns.renderers.enumSingleSelection.has(fieldConfig["renderer"])) && (enums.get(fieldConfig["options"])) != fieldTypeDef.args[0]) {
                   if (enums.has(fieldConfig["options"]))
                     errors.push(`field ${fieldName} of form ${formName} references an enum api with type ${enums.get(fieldConfig["options"])} when ${fieldTypeDef.args[0]} was expected`);
                   else
                     errors.push(`field ${fieldName} of form ${formName} references a non-existing enum api`);
-                } else if ((builtIns.renderers.InfiniteStreamMultiselectViews.has(fieldConfig["renderer"]) ||
-                  builtIns.renderers.InfiniteStreamViews.has(fieldConfig["renderer"])) && (streams.get(fieldConfig["stream"])) != fieldTypeDef.args[0]) {
+                } else if ((builtIns.renderers.streamMultiSelection.has(fieldConfig["renderer"]) ||
+                  builtIns.renderers.streamSingleSelection.has(fieldConfig["renderer"])) && (streams.get(fieldConfig["stream"])) != fieldTypeDef.args[0]) {
                   if (streams.has(fieldConfig["stream"]))
                     errors.push(`field ${fieldName} of form ${formName} references an api with type ${streams.get(fieldConfig["stream"])} when ${fieldTypeDef.args[0]} was expected`);
                   else
@@ -415,7 +363,7 @@ export const FormsConfig = {
         Object.keys(configFormDef["fields"]).forEach(fieldName => {
           const fieldConfig = configFormDef["fields"][fieldName]
           const fieldTypeDef = formTypeDef?.fields.get(fieldName);
-          if (fieldTypeDef && fieldTypeDef.kind == "application" && fieldTypeDef.value == "List" && (builtIns.renderers.ListViews.has(fieldConfig["renderer"]))) {
+          if (fieldTypeDef && fieldTypeDef.kind == "application" && fieldTypeDef.value == "List" && (builtIns.renderers.list.has(fieldConfig["renderer"]))) {
             let elementRenderer = fieldConfig["elementRenderer"]
             let elementType = fieldTypeDef.args[0]
             const rendererHasType = (elementRenderer: string, elementType: string): Array<string> => {
@@ -570,8 +518,8 @@ export const FormsConfig = {
       })
 
       if (errors.length > 0) {
-        console.log("parsing errors")
-        console.log(errors)
+        console.error("parsing errors")
+        console.error(errors)
         return Sum.Default.right(errors);
       }
 

package/src/forms/domains/parser/state.tsx

@@ -1,5 +1,5 @@
 import { Collection, Map, OrderedMap, OrderedSet, Set } from "immutable";
-import { BoolExpr, Unit, PromiseRepo, Guid, LeafPredicatesEvaluators, Predicate, FormsConfig, BuiltIns, FormDef, Sum, BasicFun, Template, unit, EditFormState, EditFormTemplate, ApiErrors, CreateFormTemplate, EntityFormTemplate, SharedFormState, CreateFormState, Entity, EditFormContext, CreateFormContext, MappedEntityFormTemplate, Mapping, FormValidationResult, Synchronized, simpleUpdater, PrimitiveBuiltIn, GenericBuiltIn, TypeName, ListFieldState, ListForm, TypeDefinition } from "../../../../main";
+import { BoolExpr, Unit, PromiseRepo, Guid, LeafPredicatesEvaluators, Predicate, FormsConfig, BuiltIns, FormDef, Sum, BasicFun, Template, unit, EditFormState, EditFormTemplate, ApiErrors, CreateFormTemplate, EntityFormTemplate, SharedFormState, CreateFormState, Entity, EditFormContext, CreateFormContext, MappedEntityFormTemplate, Mapping, FormValidationResult, Synchronized, simpleUpdater, PrimitiveType, GenericType, ApiConverter, TypeName, ListFieldState, ListForm, TypeDefinition, ApiConverters, defaultValue, fromAPIRawValue } from "../../../../main";
 import { Value } from "../../../value/state";
 import { CollectionReference } from "../collection/domains/reference/state";
 import { CollectionSelection } from "../collection/domains/selection/state";
@@ -26,43 +26,43 @@ const parseOptions = (leafPredicates: any, options: any) => {
 export const FieldView = //<Context, FieldViews extends DefaultFieldViews, EnumFieldConfigs extends {}, EnumSources extends {}>() => <ViewType extends keyof FieldViews, ViewName extends keyof FieldViews[ViewType]>
   (fieldViews: any, viewType: any, viewName: any, fieldName: string, label: string, enumFieldConfigs: any, enumSources: any, leafPredicates: any): any => // FieldView<Context, FieldViews, ViewType, ViewName> => 
   {
-    if (viewType == "MaybeBooleanViews")
+    if (viewType == "maybeBoolean")
       return MaybeBooleanForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & SharedFormState & Value<boolean>>(_ => ({ ..._, label: label })) as any
-    if (viewType == "BooleanViews")
+    if (viewType == "boolean")
       return BooleanForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & SharedFormState & Value<boolean>>(_ => ({ ..._, label: label })) as any
-    if (viewType == "DateViews")
+    if (viewType == "date")
       return DateForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & DateFormState & Value<Date>>(_ => ({ ..._, label: label })) as any
-    if (viewType == "NumberViews")
+    if (viewType == "number")
       return NumberForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & SharedFormState & Value<number>>(_ => ({ ..._, label: label })) as any
-    if (viewType == "StringViews")
+    if (viewType == "string")
       return StringForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & SharedFormState & Value<string>>(_ => ({ ..._, label: label })) as any
-    if (viewType == "EnumViews")
+    if (viewType == "enumSingleSelection")
       return EnumForm<any & FormLabel & BaseEnumContext<any, CollectionReference>, Unit, CollectionReference>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & EnumFormState<any & BaseEnumContext<any, CollectionReference>, CollectionReference> & Value<CollectionSelection<CollectionReference>>>(_ => ({
           ..._, label: label, getOptions: () => ((enumFieldConfigs as any)((enumSources as any)[fieldName]) as Promise<any>).then(options => parseOptions(leafPredicates, options))
         })) as any
-    if (viewType == "EnumMultiselectViews")
+    if (viewType == "enumMultiSelection")
       return EnumMultiselectForm<any & FormLabel & BaseEnumContext<any, CollectionReference>, Unit, CollectionReference>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & EnumFormState<any & BaseEnumContext<any, CollectionReference>, CollectionReference> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({
           ..._, label: label, getOptions: () => ((enumFieldConfigs as any)((enumSources as any)[fieldName]) as Promise<any>).then(options => parseOptions(leafPredicates, options))
         })) as any
-    if (viewType == "InfiniteStreamViews")
+    if (viewType == "streamSingleSelection")
       return SearchableInfiniteStreamForm<CollectionReference, any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & SearchableInfiniteStreamState<CollectionReference> & Value<CollectionSelection<CollectionReference>>>(_ => ({ ..._, label: label })) as any
-    if (viewType == "InfiniteStreamMultiselectViews")
+    if (viewType == "streamMultiSelection")
       return InfiniteMultiselectDropdownForm<CollectionReference, any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & FormLabel & SharedFormState & SearchableInfiniteStreamState<CollectionReference> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({ ..._, label: label })) as any
@@ -71,19 +71,19 @@ export const FieldView = //<Context, FieldViews extends DefaultFieldViews, EnumF
 
 export const FieldFormState = //<Context, FieldViews extends DefaultFieldViews, InfiniteStreamSources extends {}, InfiniteStreamConfigs extends {}>() => <ViewType extends keyof FieldViews, ViewName extends keyof FieldViews[ViewType]>
   (fieldViews: any, viewType: any, viewName: any, fieldName: string, InfiniteStreamSources: any, infiniteStreamConfigs: any): any => {
-    if (viewType == "MaybeBooleanViews" || viewType == "BooleanViews" || viewType == "NumberViews" || viewType == "StringViews")
+    if (viewType == "maybeBoolean" || viewType == "boolean" || viewType == "number" || viewType == "string")
       return SharedFormState.Default();
-    if (viewType == "DateViews")
+    if (viewType == "date")
       return DateFormState.Default("");
-    if (viewType == "EnumViews" || viewType == "EnumMultiselectViews")
+    if (viewType == "enumSingleSelection" || viewType == "enumMultiSelection")
       return ({ ...EnumFormState<any, any>().Default(), ...SharedFormState.Default() });
-    if (viewType == "InfiniteStreamViews" || viewType == "InfiniteStreamMultiselectViews") {
+    if (viewType == "streamSingleSelection" || viewType == "streamMultiSelection") {
       return ({
         ...SearchableInfiniteStreamState<any>().Default("", (InfiniteStreamSources as any)((infiniteStreamConfigs as any)[fieldName])
         ), ...SharedFormState.Default()
       });
     }
-    if (viewType == "ListViews")
+    if (viewType == "list")
       return ListFieldState<any, any>().Default(Map())
     return `error: the view for ${viewType as string}::${viewName as string} cannot be found when creating the corresponding field form state`;
   };
@@ -97,6 +97,7 @@ export type ParsedForm = {
 export const ParseForm = (
   formDef: FormDef,
   containerFormView: any,
+  nestedContainerFormView: any,
   fieldViews: any,
   otherForms: ParsedForms,
   fieldsViewsConfig: any,
@@ -145,17 +146,15 @@ export const ParseForm = (
     }
   });
   const formConfig: any = {};
-  console.log(fieldsViewsConfig)
-  console.log(Object.keys(fieldsViewsConfig))
   Object.keys(fieldsViewsConfig).forEach(fieldName => {
     const label = formDef.fields.get(fieldName)!.label
     const viewName = (fieldsViewsConfig as any)[fieldName];
     const otherForm = otherForms.get(viewName)
     if (otherForm != undefined) {
-      formConfig[fieldName] = otherForm.form.withView(containerFormView).mapContext<any>(_ => ({ ..._, label: label }))
+      formConfig[fieldName] = otherForm.form.withView(nestedContainerFormView).mapContext<any>(_ => ({ ..._, label: label }))
     } else {
       const viewType = fieldNameToViewCategory(fieldName) as any
-      if (viewType == "ListViews") {
+      if (viewType == "list") {
         const elementRendererName = formFieldElementRenderers[fieldName]
         const field = type.fields.get(fieldName)!
         const initialElementValue = defaultValue(field.kind == "primitive" ? field.value : field.kind == "lookup" ? field.name : field.args[0])
@@ -166,7 +165,7 @@ export const ParseForm = (
             { Default: () => ({ ...initialFormState }) },
             { Default: () => ({ ...initialElementValue }) },
             _ => PromiseRepo.Default.mock(() => []),
-            elementForm.form.withView(containerFormView)
+            elementForm.form.withView(nestedContainerFormView)
           ).withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
             .mapContext<any>(_ => ({ ..._, label: label }))
         } else { // the list argument is a primitive
@@ -187,7 +186,7 @@ export const ParseForm = (
     if (typeof formConfig[fieldName] == "string") {
       debugger
       const err = formConfig[fieldName]
-      console.log(`error processing field ${fieldName}`, err)
+      console.error(`error processing field ${fieldName}`, err)
       formConfig[fieldName] = (props: any) => <>Error: field {fieldName} with {viewName} could not be instantiated</>
       throw err
     }
@@ -214,44 +213,6 @@ export const parseVisibleFields = (
     visibleFields.map(([fieldName, boolExpr]) => ([fieldName, boolExpr.eval<any>(leafPredicates)]) as any)
   );
 
-export const builtInsFromFieldViews = (fieldViews: any): BuiltIns => {
-  let builtins: BuiltIns = {
-    "primitives": Map([
-      ["string", { renderers: Set(["StringViews"]), defaultValue: "" }] as [string, PrimitiveBuiltIn],
-      ["number", { renderers: Set(["NumberViews"]), defaultValue: 0 }],
-      ["boolean", { renderers: Set(["BooleanViews"]), defaultValue: false }],
-      ["maybeBoolean", { renderers: Set(["MaybeBooleanViews"]), defaultValue: undefined }],
-      ["Date", { renderers: Set(["DateViews"]), defaultValue: new Date(Date.now()) }],
-      ["CollectionReference", { renderers: Set(["EnumViews"]), defaultValue: CollectionReference.Default("", "") }]]),
-    "generics": Map([
-      ["SingleSelection", { defaultValue: CollectionSelection().Default.right("no selection") }] as [string, GenericBuiltIn],
-      ["Multiselection", { defaultValue: Map() }],
-      ["List", { defaultValue: [] }]
-    ]),
-    "renderers": {
-      "BooleanViews": Set(),
-      "MaybeBooleanViews": Set(),
-      "DateViews": Set(),
-      "EnumMultiselectViews": Set(),
-      "EnumViews": Set(),
-      "InfiniteStreamMultiselectViews": Set(),
-      "InfiniteStreamViews": Set(),
-      "NumberViews": Set(),
-      "StringViews": Set(),
-      "ListViews": Set(),
-    }
-  }
-  Object.keys(builtins.renderers).forEach((_categoryName) => {
-    const categoryName = _categoryName as keyof BuiltIns["renderers"]
-    if (categoryName in fieldViews) {
-      Object.keys(fieldViews[categoryName]).forEach(viewName => {
-        builtins.renderers[categoryName] = builtins.renderers[categoryName].add(viewName)
-      })
-    }
-  })
-  return builtins
-}
-
 export type EditLauncherContext<Entity, FormState, ExtraContext> =
   Omit<
     EditFormContext<Entity, FormState> &
@@ -306,11 +267,14 @@ export type EntityApis = {
   get: BasicFun<EntityName, BasicFun<Guid, Promise<any>>>
 }
 export type EnumName = string
+
+
 export type EnumOptionsSources = BasicFun<EnumName, Promise<Array<[CollectionReference, BoolExpr<Unit>]>>>
 export const parseForms =
   <LeafPredicates,>(
     builtIns: BuiltIns,
     containerFormView: any,
+    nestedContainerFormView: any,
     fieldViews: any,
     infiniteStreamSources: InfiniteStreamSources,
     enumOptionsSources: EnumOptionsSources,
@@ -322,31 +286,6 @@ export const parseForms =
       let seen = Set<string>()
       let formProcessingOrder = OrderedSet<string>()
 
-      const defaultValue = (t: TypeName): any => {
-        let primitive = builtIns.primitives.get(t)
-        if (primitive != undefined) {
-          return primitive.defaultValue
-        } else {
-          let generic = builtIns.generics.get(t)
-          if (generic != undefined) {
-            return generic.defaultValue
-          } else {
-            let custom = formsConfig.types.get(t)
-            if (custom != undefined) {
-              let res = {} as any
-              custom.fields.forEach((field, fieldName) => {
-                res[fieldName] = defaultValue(field.kind == "primitive" ? field.value : field.kind == "lookup" ? field.name : field.value)
-              }
-              )
-              return res
-            } else {
-              errors.push(`cannot find type ${t} when resolving defaultValue`)
-              return undefined
-            }
-          }
-        }
-      }
-
       let parsedLaunchers: ParsedLaunchers = {
         create: Map(),
         edit: Map(),
@@ -384,6 +323,7 @@ export const parseForms =
           const parsedForm = ParseForm(
             formConfig,
             containerFormView,
+            nestedContainerFormView,
             fieldViews,
             parsedForms,
             formFieldRenderers,
@@ -395,7 +335,7 @@ export const parseForms =
             leafPredicates,
             formFieldVisibilities,
             formFieldDisabled,
-            defaultValue,
+            defaultValue(formsConfig.types, builtIns),
             formConfig.typeDef,
           )
           const formBuilder = Form<any, any, any, any>().Default<any>()
@@ -442,7 +382,12 @@ export const parseForms =
         const initialState = parsedForm.initialFormState
         const api = {
           create: entityApis.create(launcher.api),
-          default: entityApis.default(launcher.api)
+          default: (_:Unit) => entityApis.default(launcher.api)(unit)
+          // .then((raw:undefined) => {
+          //   alert(JSON.stringify(parsedForm.formConfig))
+          //   const parsed = fromAPIRawValue({ kind:"lookup", name:"" }, null!, null!, null!)(raw)
+          //   return parsed
+          // })
         }
         parsedLaunchers.create = parsedLaunchers.create.set(
           launcherName,
@@ -497,7 +442,9 @@ export const parseForms =
 
 export type FormsParserContext = {
   containerFormView: any,
+  nestedContainerFormView: any,
   fieldViews: any,
+  fieldTypeConverters: ApiConverters,
   infiniteStreamSources: InfiniteStreamSources,
   enumOptionsSources: EnumOptionsSources,
   entityApis: EntityApis,

package/src/fun/domains/updater/domains/caseUpdater/state.ts

@@ -35,10 +35,10 @@ const X = {
   }
 }
 
-const visitor = 
-  X.Updaters.y.l(LeftValue.Updaters.value(_ => _ + 1)).then(
-    X.Updaters.y.r(RightValue.Updaters.value(_ => !_))
-  )
+// const visitor =
+//   X.Updaters.y.l(LeftValue.Updaters.value(_ => _ + 1)).then(
+//     X.Updaters.y.r(RightValue.Updaters.value(_ => !_))
+//   )
 
 
-console.log(visitor)
+// console.log(visitor)