ballerina-core 1.0.61 → 1.0.62

package/package.json

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

package/src/forms/domains/collection/domains/selection/state.ts

@@ -1,5 +1,5 @@
-import { Sum } from "../../../../../../main";
+import { Sum, Value } from "../../../../../../main";
 import { CollectionReference } from "../reference/state"
 
-export type CollectionSelection<Element extends CollectionReference> = Sum<Element, "no selection">;
-export const CollectionSelection = <Element extends CollectionReference>() => Sum<Element, "no selection">();
+export type CollectionSelection<Element extends CollectionReference | Value<CollectionReference>> = Sum<Element, "no selection">;
+export const CollectionSelection = <Element extends CollectionReference | Value<CollectionReference>>() => Sum<Element, "no selection">();

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

@@ -1,4 +1,4 @@
-import { Map, List, Set, OrderedMap, is } from "immutable"
+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";
@@ -6,12 +6,13 @@ import { InjectedPrimitives, Maybe, ParsedType, TypeName } from "../../../../../
 import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
 
 export const PrimitiveTypes =
-  ["string",
+  [ 
+    "guid", //resolves to string
+    "string",
     "number",
     "boolean",
     "maybeBoolean",
     "Date",
-    "CollectionReference",
     "base64File",
     "secret",
   ] as const
@@ -21,7 +22,9 @@ export const GenericTypes = [
   "SingleSelection",
   "MultiSelection",
   "List",
-  "Map"] as const
+  "Map",
+  "Union"
+] as const
 export type GenericType = (typeof GenericTypes)[number]
 
 export type ApiConverter<T> =  { fromAPIRawValue: BasicFun<any, T>, toAPIRawValue: BasicFun<[T, boolean], any> }
@@ -35,7 +38,6 @@ export type BuiltInApiConverters = {
   "base64File": ApiConverter<string>
   "secret": ApiConverter<string>
   "Date": ApiConverter<Maybe<Date>>
-  "CollectionReference": ApiConverter<CollectionReference>
   "SingleSelection": ApiConverter<CollectionSelection<any>>
   "MultiSelection": ApiConverter<OrderedMap<string, any>>
   "List": ApiConverter<List<any>>,
@@ -73,7 +75,6 @@ export const builtInsFromFieldViews = (fieldViews: any): BuiltIns => {
       ["maybeBoolean", { renderers: Set(["maybeBoolean"]), defaultValue: undefined }] as [string, PrimitiveBuiltIn],
       ["date", { renderers: Set(["date"]), defaultValue: undefined }] as [string, PrimitiveBuiltIn],
       ["Date", { renderers: Set(["date"]), defaultValue: undefined }] as [string, PrimitiveBuiltIn],
-      ["CollectionReference", { renderers: Set(["enumSingleSelection", "enumMultiSelection", "streamSingleSelection", "streamMultiSelection"]), defaultValue: CollectionReference.Default("", "") }] as [string, PrimitiveBuiltIn],
       ["base64File", { renderers: Set(["base64File"]), defaultValue: "" }] as [string, PrimitiveBuiltIn],
       ["secret", { renderers: Set(["secret"]), defaultValue: "" }] as [string, PrimitiveBuiltIn],
     ]),
@@ -81,7 +82,8 @@ export const builtInsFromFieldViews = (fieldViews: any): BuiltIns => {
       ["SingleSelection", { defaultValue: CollectionSelection().Default.right("no selection") }] as [string, GenericBuiltIn],
       ["MultiSelection", { defaultValue: Map() }] as [string, GenericBuiltIn],
       ["List", { defaultValue: List() }] as [string, GenericBuiltIn],
-      ["Map", { defaultValue: List() }] as [string, GenericBuiltIn]
+      ["Map", { defaultValue: List() }] as [string, GenericBuiltIn],    
+      ["Union", { defaultValue: Map() }] as [string, GenericBuiltIn],
     ]),
     "renderers": {
       "boolean": Set(),
@@ -147,6 +149,9 @@ export const fromAPIRawValue = <T extends { [key in keyof T]: { type: any; state
   if (t.kind == "primitive") {
     return converters[t.value].fromAPIRawValue(raw)
   }
+  if(t.kind == "union") {
+    return CollectionReference.Default(raw, raw, "enum")
+  }
   if (t.kind == "application") {
     if (t.value == "SingleSelection") {
       return CollectionSelection().Updaters.left(
@@ -191,7 +196,9 @@ export const fromAPIRawValue = <T extends { [key in keyof T]: { type: any; state
 export const toAPIRawValue = <T extends { [key in keyof T]: { type: any; state: any; }}>(t: ParsedType<T>, types: Map<TypeName, ParsedType<T>>, builtIns: BuiltIns, converters: ApiConverters<T>, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any, formState: any) : ValueOrErrors<any, string> => {
   if (t.kind == "primitive")
     return ValueOrErrors.Operations.Return(converters[t.value as string | keyof T].toAPIRawValue([raw, formState.modifiedByUser]))
-  
+  if(t.kind == "union"){
+    return ValueOrErrors.Operations.Return(raw.id)
+  }
   if (t.kind == "application") {
     if (t.value == "SingleSelection") {
       const result = converters[t.value].toAPIRawValue([raw, formState.modifiedByUser])

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

@@ -1,5 +1,5 @@
 import { List, Map, OrderedMap, Set } from "immutable";
-import { Base64FileForm, BaseEnumContext, BasicFun, BooleanForm, BoolExpr, CollectionReference, CollectionSelection, CommonFormState, DateForm, DateFormState, EnumForm, EnumFormState, EnumMultiselectForm, EnumOptionsSources, FormLabel, Guid, InfiniteMultiselectDropdownForm, InjectedPrimitives, ListFieldState, ListForm, MapFieldState, MapForm, Maybe, MaybeBooleanForm, NumberForm, ParsedForms, ParsedType, SearchableInfiniteStreamForm, SearchableInfiniteStreamState, SecretForm, StringForm, Template, Unit, Value } from "../../../../../../main";
+import { Base64FileForm, BaseEnumContext, BasicFun, BasicPredicate, BooleanForm, BoolExpr, CollectionReference, CollectionSelection, CommonFormState, DateForm, DateFormState, EnumForm, EnumFormState, EnumMultiselectForm, EnumOptionsSources, FormLabel, Guid, InfiniteMultiselectDropdownForm, InjectedPrimitives, ListFieldState, ListForm, MapFieldState, MapForm, Maybe, MaybeBooleanForm, NumberForm, OrderedMapRepo, ParsedForms, ParsedType, SearchableInfiniteStreamForm, SearchableInfiniteStreamState, SecretForm, StringForm, Template, Unit, Value } from "../../../../../../main";
 import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
 
 type Form = {
@@ -128,11 +128,6 @@ export const ParsedRenderer = {
       console.error(`Invalid field type ${JSON.stringify(fieldType)} for field ${JSON.stringify(field)}`)
       throw new Error("Invalid field type")
     },
-    ParseOptions: (leafPredicates: any, options: any) => {
-      const result = options.map((_: any) => ([_[0].id, [_[0], (_[1] as BoolExpr<any>).eval<any>(leafPredicates)]]));
-      const resultMap = result.reduce((a: any, b: any) => a.set(b[0], b[1]), OrderedMap<any, any>());
-      return resultMap;
-    },
     FormViewToViewKind: (viewName: string | undefined, formViews: Record<string, any>, formNames: Set<string>) => {
       if (viewName == undefined) {
         throw Error(`cannot resolve view ${viewName}`) // TODO -- better error handling
@@ -223,18 +218,18 @@ export const ParsedRenderer = {
           .withView(formViews[viewKind][viewName]())
           .mapContext<any & CommonFormState & Value<string>>(_ => ({ ..._, label: label, tooltip }))
       if (viewKind == "enumSingleSelection" && rendererConfig.kind == "enum")
-        return EnumForm<any & FormLabel & BaseEnumContext<any, CollectionReference>, Unit, CollectionReference>()
+        return EnumForm<any & FormLabel & BaseEnumContext<Value<CollectionReference>>, Unit, Value<CollectionReference>>()
           .withView(formViews[viewKind][viewName]())
-          .mapContext<any & EnumFormState<any & BaseEnumContext<any, CollectionReference>, CollectionReference> & Value<CollectionSelection<CollectionReference>>>(_ => ({
+          .mapContext<any & EnumFormState<any & BaseEnumContext<Value<CollectionReference>>, Value<CollectionReference>> & Value<CollectionSelection<Value<CollectionReference>>>>(_ => ({
             ..._, label: label, tooltip, getOptions: () => {
-              return ((enumOptionsSources as any)(rendererConfig.options)() as Promise<any>).then(options => ParsedRenderer.Operations.ParseOptions(leafPredicates, options))
+              return ((enumOptionsSources as any)(rendererConfig.options)() as Promise<any>).then(options => Map(options.map((o: {value: CollectionReference}) => [o.value.id, o])))
             }
           })) 
       if (viewKind == "enumMultiSelection" && rendererConfig.kind == "enum")
-        return EnumMultiselectForm<any & FormLabel & BaseEnumContext<any, CollectionReference>, Unit, CollectionReference>()
+        return EnumMultiselectForm<any & FormLabel & BaseEnumContext<Value<CollectionReference>>, Unit, Value<CollectionReference>>()
           .withView(formViews[viewKind][viewName]() )
-          .mapContext<any & EnumFormState<any & BaseEnumContext<any, CollectionReference>, CollectionReference> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({
-            ..._, label: label, tooltip, getOptions: () => ((enumOptionsSources as any)(rendererConfig.options)() as Promise<any>).then(options => ParsedRenderer.Operations.ParseOptions(leafPredicates, options))
+          .mapContext<any & EnumFormState<any & BaseEnumContext<Value<CollectionReference>>, Value<CollectionReference>> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({
+            ..._, label: label, tooltip, getOptions: () => ((enumOptionsSources as any)(rendererConfig.options)() as Promise<any>).then(options => OrderedMap(options.map((o: {value: CollectionReference}) => [o.value.id, o])))
           })) 
       if (viewKind == "streamSingleSelection")
         return SearchableInfiniteStreamForm<CollectionReference, any & FormLabel, Unit>()

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

@@ -2,12 +2,14 @@ import { Set, List, Map, OrderedMap } from "immutable";
 import { GenericType, GenericTypes, PrimitiveTypes } from "../built-ins/state";
 import { InjectedPrimitives } from "../injectables/state";
 import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
+import { Value } from "../../../../../value/state";
 
 export const isString = (_: any): _ is string => typeof _ == "string"
 export const isObject = (_: any): _ is Object => typeof _ == "object"
 export const isGenericType = (_: any): _ is GenericType => _  && GenericTypes.includes(_)
 export const hasFun = (_: any): _ is { fun: string } => isObject(_) && "fun" in _ && isString(_.fun) 
 export const hasArgs = (_: any): _ is { args: Array<any> } => isObject(_) && "args" in _ && Array.isArray(_.args)
+export type CaseName = string;
 export type FieldName = string;
 export type TypeName = string;
 export type RawType<T> = {
@@ -18,13 +20,26 @@ export const RawType = {
     isMaybeExtendedType: <T>(type: RawType<T>): type is RawType<T> & {extends: unknown} => "extends" in type,
     isExtendedType: <T>(type: RawType<T>): type is RawType<T> & {extends: Array<TypeName>} => "extends" in type && Array.isArray(type.extends) && type.extends.length == 1 && (isString(type.extends[0])) ,
     hasFields: <T>(type: RawType<T>): type is {fields: any} => "fields" in type,
+    isMaybeUnion: (_: any): _ is RawUnionType => isObject(_) && "fun" in _ && "args" in _ && _.fun == "Union" && Array.isArray(_["args"]) && _["args"].every(__ => typeof __ == "object" && "case" in __ && "fields" in __),
 }
 export type RawApplicationType<T> = {
   fun?: GenericType;
   args?: Array<RawFieldType<T>>;
 }
 
-export type RawFieldType<T> = RawApplicationType<T> | string | PrimitiveTypeName<T>
+export type RawUnionCase = {
+  case?: string;
+  fields?: Object;
+}
+
+export type RawUnionType = {
+  fun?: "Union";
+  args?: Array<RawUnionCase>;
+}
+
+export type RawFormType = {fields?: Object}
+
+export type RawFieldType<T> = RawApplicationType<T> | string | PrimitiveTypeName<T> | RawUnionType | RawFormType | RawUnionCase;
 export const RawFieldType = { 
   isMaybePrimitive: (_: any) => isString(_),
   isPrimitive: <T>(_: RawFieldType<T>, injectedPrimitives: InjectedPrimitives<T> | undefined): _ is PrimitiveTypeName<T> => Boolean(PrimitiveTypes.some(__ => _ == __) || injectedPrimitives?.injectedPrimitives.has(_ as keyof T)),
@@ -36,24 +51,32 @@ export const RawFieldType = {
   isMap: <T>(_: RawFieldType<T>): _ is {fun: "Map", args: Array<RawFieldType<T>>} => RawFieldType.isApplication(_) && _.fun == "Map" && _.args.length == 2,
   isSingleSelection: <T>(_: RawFieldType<T>): _ is {fun: "SingleSelection", args: Array<RawFieldType<T>>} => RawFieldType.isApplication(_) && _.fun == "SingleSelection" && _.args.length == 1,
   isMultiSelection: <T>(_: RawFieldType<T>): _ is {fun: "MultiSelection", args: Array<RawFieldType<T>>} => RawFieldType.isApplication(_) && _.fun == "MultiSelection" && _.args.length == 1,
+  isUnionCase: <T>(_: RawFieldType<T>): _ is {case: string, fields: object} => typeof _ == "object" && "case" in _ && "fields" in _,
+  isUnion: <T>(_: RawFieldType<T>): _ is {fun: "Union", args: Array<{case: string, fields: object}>} => hasFun(_) && isGenericType(_.fun) && hasArgs(_) && _.fun == "Union" && _.args.length > 1 && _.args.every(__ => typeof __ == "object" && "case" in __ && "fields" in __),
+  isForm: <T>(_: RawFieldType<T>): _ is {fields: Object} => typeof _ == "object" && "fields" in _ && isObject(_.fields),
 }
 
-export type PrimitiveTypeName<T> = "string" | "number" | "maybeBoolean" | "boolean" | "Date" | "CollectionReference" | "base64File" | "secret" | keyof T;
+export type PrimitiveTypeName<T> = "string" | "number" | "maybeBoolean" | "boolean" | "Date" | "base64File" | "secret" | keyof T | "guid";
+export type FormFields<T> =  Map<FieldName, ParsedType<T>>
 export type ParsedType<T> = 
-  | { kind: "form"; value: TypeName; fields: Map<FieldName, ParsedType<T>> }
+  | { kind: "unionCase", name: CaseName, fields: ParsedType<T> }
+  | { kind: "form"; value: TypeName; fields: FormFields<T> }
   | { kind: "lookup"; name: TypeName; } 
-  | { kind: "primitive"; value: PrimitiveTypeName<T>}
-  | { kind: "application"; value: GenericType; args: Array<ParsedType<T>>;
-};
+  | { kind: "primitive"; value: PrimitiveTypeName<T> ;}
+  | { kind: "application"; value: GenericType; args: Array<ParsedType<T>>; }
+  | { kind: "union";  args: Map<CaseName, ParsedType<T>> }
 
 export const ParsedType = {
   Default: {
-    form: <T>(value: TypeName, fields: Map<FieldName, ParsedType<T>>): ParsedType<T> => ({ kind: "form", value, fields }),
+    unionCase: <T>(name: CaseName, fields: ParsedType<T>): ParsedType<T> => ({ kind: "unionCase", name, fields }),
+    form: <T>(value: TypeName, fields: FormFields<T>): ParsedType<T> => ({ kind: "form", value, fields }),
     primitive: <T>(name: PrimitiveTypeName<T> | keyof T): ParsedType<T> => ({ kind: "primitive", value: name }),
     application: <T>(value: GenericType, args: Array<ParsedType<T>>): ParsedType<T> => ({ kind: "application", value, args }),
+    union: <T>(args: Map<CaseName, ParsedType<T>>): ParsedType<T> => ({ kind: "union", args }),
     lookup: <T>(name: string): ParsedType<T> => ({ kind: "lookup", name }),
   },
   Operations: {
+    //TODO: Add cases
     Equals: <T>(fst: ParsedType<T>, snd: ParsedType<T>): boolean =>
       fst.kind == "form" && snd.kind == "form" ? fst.value == snd.value :
         fst.kind == "lookup" && snd.kind == "lookup" ? fst.name == snd.name :
@@ -65,9 +88,8 @@ export const ParsedType = {
               false,
     
     ParseRawFieldType: <T>(fieldName: TypeName, rawFieldType: RawFieldType<T>, types: Set<TypeName>, injectedPrimitives?: InjectedPrimitives<T>) : ValueOrErrors<ParsedType<T>, string> => {
-      
       if (RawFieldType.isPrimitive(rawFieldType, injectedPrimitives))
-         return ValueOrErrors.Default.return(ParsedType.Default.primitive(rawFieldType))
+         return ValueOrErrors.Default.return(ParsedType.Default.primitive(rawFieldType == "guid" ? "string" : rawFieldType))
       if (RawFieldType.isSingleSelection(rawFieldType))
         return ParsedType.Operations.ParseRawFieldType(fieldName, rawFieldType.args[0], types, injectedPrimitives).Then(parsedArgs =>
           ValueOrErrors.Default.return(ParsedType.Default.application("SingleSelection", [parsedArgs]))
@@ -86,9 +108,25 @@ export const ParsedType = {
             ValueOrErrors.Default.return(ParsedType.Default.application("Map", [parsedArgs0, parsedArgs1]))
           )
         )
+      if(RawFieldType.isForm(rawFieldType))
+        return ValueOrErrors.Operations
+              .All(List(Object.entries(rawFieldType.fields).map(([fieldName, fieldType]) => ParsedType.Operations.ParseRawFieldType(fieldName, fieldType as RawFieldType<T>, types, injectedPrimitives)
+              .Then(parsedField => ValueOrErrors.Default.return([fieldName, parsedField] as const))
+              )))
+              .Then(parsedFields =>  ValueOrErrors.Default.return(Map(parsedFields.map(([fieldName, parsedField]) => [fieldName, parsedField]))))
+              .Then(parsedField => ValueOrErrors.Default.return<ParsedType<T>, string>(ParsedType.Default.form(fieldName, parsedField)))
+      if(RawFieldType.isUnionCase(rawFieldType))
+        return ParsedType.Operations.ParseRawFieldType(rawFieldType.case, rawFieldType.fields, types, injectedPrimitives).Then(parsedFields =>
+          ValueOrErrors.Default.return(ParsedType.Default.unionCase(rawFieldType.case, parsedFields))
+        )
+      if(RawFieldType.isUnion(rawFieldType))
+        return ValueOrErrors.Operations.All(List(
+          rawFieldType.args.map(_ => ParsedType.Operations.ParseRawFieldType(_.case, _, types, injectedPrimitives).Map(parsedFields => ({name: _.case, fields: parsedFields})))))
+          .Then(parsedFields =>  ValueOrErrors.Default.return(ParsedType.Default.union(Map(parsedFields.toArray().map(_ => [_.name, _.fields] as const)))))
+           
       if(RawFieldType.isLookup(rawFieldType, types))
          return ValueOrErrors.Default.return(ParsedType.Default.lookup(rawFieldType))
       return ValueOrErrors.Default.throw(List([`Invalid type ${JSON.stringify(rawFieldType)} for field ${JSON.stringify(fieldName)}`]))
     }
   }
-}
+}

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

@@ -94,8 +94,17 @@ export const FormsConfig = {
       let parsedTypes: Map<TypeName, ParsedType<T>> = Map();
       const rawTypesFromConfig = formsConfig.types;
       const rawTypeNames = Set(Object.keys(rawTypesFromConfig))
-      Object.entries(formsConfig.types).forEach(([rawTypeName, rawType]) => {        
+      Object.entries(rawTypesFromConfig).forEach(([rawTypeName, rawType]) => {        
         const parsedType: ParsedType<T> = { kind: "form", value: rawTypeName, fields: Map() };
+          if (RawFieldType.isUnion(rawType)){
+          const parsingResult = ParsedType.Operations.ParseRawFieldType(rawTypeName, rawType, rawTypeNames, injectedPrimitives)
+          if(parsingResult.kind == "errors"){
+            errors = errors.concat(parsingResult.errors.toArray());
+            return;
+          }
+          parsedTypes = parsedTypes.set(rawTypeName, parsingResult.value)
+          return
+        }
         
         if (!RawType.hasFields(rawType)){
           errors = errors.push(`missing 'fields' in type ${rawTypeName}: expected object`);
@@ -136,6 +145,7 @@ export const FormsConfig = {
           enums = enums.set(enumOptionName, enumOption)
       )
 
+
       let streams: Map<string, TypeName> = Map();
       Object.entries(formsConfig.apis.searchableStreams).forEach(([searchableStreamName, searchableStream]) => 
           streams = streams.set(searchableStreamName, searchableStream)
@@ -193,6 +203,7 @@ export const FormsConfig = {
         forms = forms.set(formName, parsedForm);
       })
 
+
       let launchers: ParsedFormJSON<T>["launchers"] = {
         create: Map<string, Launcher>(),
         edit: Map<string, Launcher>(),

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

@@ -121,7 +121,7 @@ export type EntityApis = {
 export type EnumName = string
 
 
-export type EnumOptionsSources = BasicFun<EnumName, BasicFun<Unit, Promise<Array<[CollectionReference, BoolExpr<Unit>]>>>>
+export type EnumOptionsSources = BasicFun<EnumName, BasicFun<Unit, Promise<Array<{value: CollectionReference}>>>>
 export const parseForms =
   <LeafPredicates, T extends { [key in keyof T]: { type: any; state: any; }; },>(
     builtIns: BuiltIns,
@@ -155,6 +155,7 @@ export const parseForms =
         }
         seen = seen.add(formDef.name)
         formDef.fields.forEach((field, fieldName) => {
+          // TODO add a union case
           if (field.type.kind == "lookup" || field.type.kind == "form") {
             traverse(formsConfig.forms.get(field.renderer)!)
           }
@@ -187,6 +188,7 @@ export const parseForms =
         traverse(form)
       })
 
+
       formProcessingOrder.forEach(formName => {
         const formConfig = formsConfig.forms.get(formName)!
         const formFieldRenderers = formConfig.fields.map(field => field.renderer).toObject()
@@ -241,7 +243,8 @@ export const parseForms =
         const initialState = parsedForm.initialFormState
         const api = {
           get: (id: string) => entityApis.get(launcher.api)(id).then((raw: any) => {
-            return fromAPIRawValue(parsedForm.formDef.type , formsConfig.types, builtIns, apiConverters, injectedPrimitives)(raw)
+            const x =fromAPIRawValue(parsedForm.formDef.type , formsConfig.types, builtIns, apiConverters, injectedPrimitives)(raw)
+            return x
           }),
           update: (id: any, parsed: any) => {
             return parsed.kind =="errors" ? Promise.reject(parsed.errors) : entityApis.update(launcher.api)(id, parsed.value)  
@@ -285,13 +288,12 @@ export const parseForms =
         const form = parsedForm.form
         const initialState = parsedForm.initialFormState
         const api = {
-          default: (_: Unit) => entityApis.default(launcher.api)(unit)
-            .then((raw: any) => {
-              return fromAPIRawValue(parsedForm.formDef.type , formsConfig.types, builtIns, apiConverters, injectedPrimitives)(raw)
-            }),
-          create: (parsed: any) => {
-            return parsed.kind == "errors" ? Promise.reject(parsed.errors) : entityApis.create(launcher.api)(parsed.value)
-          },
+          default: (_: Unit) => 
+            entityApis.default(launcher.api)(unit).then((raw: any) => 
+              fromAPIRawValue(parsedForm.formDef.type , formsConfig.types, builtIns, apiConverters, injectedPrimitives)(raw)),
+          create: (parsed: any) => 
+            parsed.kind == "errors" ? Promise.reject(parsed.errors) : entityApis.create(launcher.api)(parsed.value)
+          ,
         }
         parsedLaunchers.create = parsedLaunchers.create.set(
           launcherName,

package/src/forms/domains/primitives/domains/enum/state.ts

@@ -8,17 +8,17 @@ import { FormLabel } from "../../../singleton/domains/form-label/state";
 import { OnChange, CommonFormState } from "../../../singleton/state";
 
 
-export type BaseEnumContext<Context, Element extends CollectionReference> = { getOptions:() => Promise<OrderedMap<Guid, [Element, BasicPredicate<Context>]>> }
-export type EnumFormState<Context, Element extends CollectionReference> = 
+export type BaseEnumContext<Element extends Value<CollectionReference>> = { getOptions:() => Promise<OrderedMap<Guid, Element>> }
+export type EnumFormState<Context, Element extends Value<CollectionReference>> = 
     { commonFormState: CommonFormState,
-      customFormState: { options: Synchronized<Unit, OrderedMap<Guid, [Element, BasicPredicate<Context>]>>; }; };
-export const EnumFormState = <Context extends BaseEnumContext<Context, Element>, Element extends CollectionReference>() => ({
-  Default: (): EnumFormState<Context, Element> => ({ 
+      customFormState: { options: Synchronized<Unit, OrderedMap<Guid, Element>>; }; };
+export const EnumFormState = <Context extends BaseEnumContext<Value<Element>>, Element extends CollectionReference>() => ({
+  Default: (): EnumFormState<Context, Value<Element>> => ({ 
     commonFormState: CommonFormState.Default(),
     customFormState: { options: Synchronized.Default(unit) }
   }),
 });
-export type EnumView<Context extends FormLabel & BaseEnumContext<Context, Element>, Element extends CollectionReference, ForeignMutationsExpected> = View<
+export type EnumView<Context extends FormLabel & BaseEnumContext<Element>, Element extends Value<CollectionReference>, ForeignMutationsExpected> = View<
   Context & Value<CollectionSelection<Element>> & EnumFormState<Context, Element> & 
   { activeOptions: "loading" | Array<Element>; } & { disabled:boolean }, EnumFormState<Context, Element>, 
   ForeignMutationsExpected & { 

package/src/forms/domains/primitives/domains/enum/template.tsx

@@ -9,7 +9,7 @@ import { FieldValidation, FieldValidationWithPath, FormValidatorSynchronized, On
 import { BaseEnumContext, EnumFormState, EnumView } from "./state";
 
 
-export const EnumForm = <Context extends FormLabel & BaseEnumContext<Context, Element>, ForeignMutationsExpected, Element extends CollectionReference>(
+export const EnumForm = <Context extends FormLabel & BaseEnumContext<Element>, ForeignMutationsExpected, Element extends Value<CollectionReference>>(
   validation?: BasicFun<CollectionSelection<Element>, Promise<FieldValidation>>
 ) => {
   const Co = CoTypedFactory<Context & Value<CollectionSelection<Element>> & { disabled:boolean }, EnumFormState<Context, Element>>()
@@ -20,7 +20,7 @@ export const EnumForm = <Context extends FormLabel & BaseEnumContext<Context, El
         context={{
           ...props.context,
           activeOptions: !AsyncState.Operations.hasValue(props.context.customFormState.options.sync) ? "loading"
-            : props.context.customFormState.options.sync.value.valueSeq().filter(o => o[1](props.context)).map(o => o[0]).toArray()
+            : props.context.customFormState.options.sync.value.valueSeq().toArray()
         }}
         foreignMutations={{
           ...props.foreignMutations,
@@ -30,7 +30,7 @@ export const EnumForm = <Context extends FormLabel & BaseEnumContext<Context, El
             if (newSelection == undefined)
               return props.foreignMutations.onChange(replaceWith(CollectionSelection<Element>().Default.right("no selection")), List());
             else
-              return props.foreignMutations.onChange(replaceWith(CollectionSelection<Element>().Default.left(newSelection[0])), List());
+              return props.foreignMutations.onChange(replaceWith(CollectionSelection<Element>().Default.left(newSelection)), List());
 
           }
         }} />
@@ -42,7 +42,7 @@ export const EnumForm = <Context extends FormLabel & BaseEnumContext<Context, El
       Co.Template<ForeignMutationsExpected & { onChange: OnChange<CollectionSelection<Element>>; }>(
         Co.GetState().then(current =>
           { 
-            return Synchronize<Unit, OrderedMap<Guid, [Element, BasicPredicate<Context>]>>(current.getOptions, () => "transient failure", 5, 50)
+            return Synchronize<Unit, OrderedMap<Guid, Element>>(current.getOptions, () => "transient failure", 5, 50)
             .embed(_ =>  _.customFormState.options,
                _ => current => ({ ...current, customFormState: { ...current.customFormState, options: _(current.customFormState.options) } })
               )}

package/src/forms/domains/primitives/domains/enum-multiselect/state.ts

@@ -8,7 +8,7 @@ import { OnChange } from "../../../singleton/state";
 import { BaseEnumContext, EnumFormState } from "../enum/state";
 
 
-export type EnumMultiselectView<Context extends FormLabel & BaseEnumContext<Context, Element>, Element extends CollectionReference, ForeignMutationsExpected> = View<
+export type EnumMultiselectView<Context extends FormLabel & BaseEnumContext<Element>, Element extends Value<CollectionReference>, ForeignMutationsExpected> = View<
   Context & Value<OrderedMap<Guid, Element>> & EnumFormState<Context, Element> & {
     selectedIds: Array<Guid>;
     activeOptions: "loading" | Array<Element>;

package/src/forms/domains/primitives/domains/enum-multiselect/template.tsx

@@ -1,15 +1,15 @@
 import { List, OrderedMap } from "immutable";
-import { AsyncState, BasicFun, BasicPredicate, CoTypedFactory, Debounce, Debounced, Guid, OrderedMapRepo, replaceWith, Synchronize, Unit, ValidateRunner } from "../../../../../../main";
+import { AsyncState, BasicFun, CoTypedFactory, Guid, OrderedMapRepo, replaceWith, Synchronize, Unit, ValidateRunner } from "../../../../../../main";
 import { Template } from "../../../../../template/state";
 import { Value } from "../../../../../value/state";
 import { CollectionReference } from "../../../collection/domains/reference/state";
 import { FormLabel } from "../../../singleton/domains/form-label/state";
-import { FieldValidation, FieldValidationWithPath, FormValidatorSynchronized, OnChange, CommonFormState, ValidationError } from "../../../singleton/state";
+import { FieldValidation, FieldValidationWithPath, OnChange,} from "../../../singleton/state";
 import { BaseEnumContext, EnumFormState } from "../enum/state";
 import { EnumMultiselectView } from "./state";
 
 
-export const EnumMultiselectForm = <Context extends FormLabel & BaseEnumContext<Context, Element>, ForeignMutationsExpected, Element extends CollectionReference>(
+export const EnumMultiselectForm = <Context extends FormLabel & BaseEnumContext<Element>, ForeignMutationsExpected, Element extends Value<CollectionReference>>(
   validation?: BasicFun<OrderedMap<Guid, Element>, Promise<FieldValidation>>
 ) => {
   const Co = CoTypedFactory<Context & Value<OrderedMap<Guid, Element>> & EnumFormState<Context, Element> & { disabled:boolean }, EnumFormState<Context, Element>>()
@@ -17,9 +17,9 @@ export const EnumMultiselectForm = <Context extends FormLabel & BaseEnumContext<
     <props.view {...props}
       context={{
         ...props.context,
-        selectedIds: props.context.value.map(_ => _.id).valueSeq().toArray(),
+        selectedIds: props.context.value.map(_ => _.value.id).valueSeq().toArray(),
         activeOptions: !AsyncState.Operations.hasValue(props.context.customFormState.options.sync) ? "loading"
-        : props.context.customFormState.options.sync.value.valueSeq().filter(o => o[1](props.context)).map(o => o[0]).toArray()
+        : props.context.customFormState.options.sync.value.valueSeq().toArray()
       }}
       foreignMutations={{
         ...props.foreignMutations,
@@ -27,13 +27,15 @@ export const EnumMultiselectForm = <Context extends FormLabel & BaseEnumContext<
           if (!AsyncState.Operations.hasValue(props.context.customFormState.options.sync)) return
           const options = props.context.customFormState.options.sync.value
           const newSelection = _
-            .flatMap(_ => {
+            .flatMap(_ => { 
               const selectedItem = options.get(_);
-              if (selectedItem != undefined) return [selectedItem[0]];
+              if (selectedItem != undefined) {
+                const item: [string, Element] = [selectedItem.value.id, selectedItem];
+                return [item];
+              }
               return [];
             });
-
-          props.foreignMutations.onChange(replaceWith(OrderedMapRepo.Default.fromSmallIdentifiables(newSelection)), List());
+          props.foreignMutations.onChange(replaceWith(OrderedMap<string, Element>(newSelection)), List());
         }
       }}
     />
@@ -44,7 +46,7 @@ export const EnumMultiselectForm = <Context extends FormLabel & BaseEnumContext<
     ),
     Co.Template<ForeignMutationsExpected & { onChange: OnChange<OrderedMap<Guid, Element>>; }>(
       Co.GetState().then(current =>
-        Synchronize<Unit, OrderedMap<Guid, [Element, BasicPredicate<Context>]>>(current.getOptions, () => "transient failure", 5, 50)
+        Synchronize<Unit, OrderedMap<Guid, Element>>(current.getOptions, () => "transient failure", 5, 50)
           .embed(_ => _.customFormState.options, _ => current => ({ ...current, customFormState: { ...current.customFormState, options: _(current.customFormState.options) } }))
       ),
       {