ballerina-core 1.0.48 → 1.0.49

package/package.json

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

package/src/collections/domains/valueOrErrors/state.ts

@@ -0,0 +1,136 @@
+import { List } from "immutable";
+import { BasicFun, BasicFun2, Fun } from "../../../fun/state";
+import { Value } from "../../../value/state";
+
+export type ValueOrErrors<v, e> = (
+  | (Value<v> & { kind: "value" })
+  | { errors: List<e>; kind: "errors" }
+) & {
+  map: <a, b, e>(
+    this: ValueOrErrors<a, e>,
+    f: BasicFun<a, b>
+  ) => ValueOrErrors<b, e>;
+  mapErrors: <a, e, e2>(
+    this: ValueOrErrors<a, e>,
+    f: BasicFun<List<e>, List<e2>>
+  ) => ValueOrErrors<a, e2>;
+  flatten: <a, e>(
+    this: ValueOrErrors<ValueOrErrors<a, e>, e>
+  ) => ValueOrErrors<a, e>;
+  then: <a, b, e>(
+    this: ValueOrErrors<a, e>,
+    k: BasicFun<a, ValueOrErrors<b, e>>
+  ) => ValueOrErrors<b, e>;
+};
+
+const operations = {
+  map: function <a, b, e>(
+    this: ValueOrErrors<a, e>,
+    f: BasicFun<a, b>
+  ): ValueOrErrors<b, e> {
+    if (this.kind == "errors") {
+      return this;
+    }
+    return ValueOrErrors.Default.return(f(this.value));
+  },
+  mapErrors: function <a, e, e2>(
+    this: ValueOrErrors<a, e>,
+    f: BasicFun<List<e>, List<e2>>
+  ): ValueOrErrors<a, e2> {
+    if (this.kind == "errors") {
+      return ValueOrErrors.Default.throw(f(this.errors));
+    }
+    return this;
+  },
+  flatten: function <a, e>(
+    this: ValueOrErrors<ValueOrErrors<a, e>, e>
+  ): ValueOrErrors<a, e> {
+    if (this.kind == "errors") {
+      return this;
+    } else if (this.value.kind == "errors") {
+      return ValueOrErrors.Default.throw(this.value.errors);
+    } else {
+      return this.value;
+    }
+  },
+  then: function <a, b, e>(
+    this: ValueOrErrors<a, e>,
+    k: BasicFun<a, ValueOrErrors<b, e>>
+  ): ValueOrErrors<b, e> {
+    return this.map(k).flatten();
+  },
+};
+
+export const ValueOrErrors = {
+  Default: {
+    return: <v, e>(_: v): ValueOrErrors<v, e> => ({
+      ...Value.Default(_),
+      kind: "value",
+      ...operations,
+    }),
+    throw: <v, e>(_: List<e>): ValueOrErrors<v, e> => ({
+      errors: _,
+      kind: "errors",
+      ...operations,
+    }),
+  },
+  Operations: {
+    return: <v, e>(_: v): ValueOrErrors<v, e> =>
+      ValueOrErrors.Default.return(_),
+    throw: <v, e>(_: e): ValueOrErrors<v, e> =>
+      ValueOrErrors.Default.throw(List([_])),
+    map: <a, b, e>(
+      f: BasicFun<a, b>
+    ): Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>> =>
+      Fun((_) =>
+        _.kind == "errors" ? _ : ValueOrErrors.Default.return(f(_.value))
+      ),
+    mapErrors: <a, e, e2>(
+      f: BasicFun<List<e>, List<e2>>
+    ): BasicFun<ValueOrErrors<a, e>, ValueOrErrors<a, e2>> =>
+      Fun((_) =>
+        _.kind == "errors" ? ValueOrErrors.Default.throw(f(_.errors)) : _
+      ),
+    flatten: <a, e>(): Fun<
+      ValueOrErrors<ValueOrErrors<a, e>, e>,
+      ValueOrErrors<a, e>
+    > =>
+      Fun((_) => {
+        if (_.kind == "errors") {
+          return _;
+        } else if (_.value.kind == "errors") {
+          return ValueOrErrors.Default.throw(_.value.errors);
+        } else {
+          return _.value;
+        }
+      }),
+    then: <a, b, e>(
+      k: BasicFun<a, ValueOrErrors<b, e>>
+    ): Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>> =>
+      Fun((_: ValueOrErrors<a, e>) =>
+        ValueOrErrors.Operations.flatten<b, e>()(
+          ValueOrErrors.Operations.map<a, ValueOrErrors<b, e>, e>(k)(_)
+        )
+      ),
+    fold: <v, e, c>(
+      l: BasicFun<v, c>,
+      r: BasicFun<List<e>, c>
+    ): Fun<ValueOrErrors<v, e>, c> =>
+      Fun((_) => (_.kind == "value" ? l(_.value) : r(_.errors))),
+    all: <v, e>(_: List<ValueOrErrors<v, e>>): ValueOrErrors<List<v>, e> =>
+      _.reduce(
+        (reduction, value) =>
+          ValueOrErrors.Operations.fold<v, e, ValueOrErrors<List<v>, e>>(
+            (v: v) =>
+              reduction.kind == "errors"
+                ? reduction
+                : reduction.map((_) => _.concat(v)),
+            (es: List<e>) =>
+              reduction.kind == "errors"
+                ? reduction.mapErrors((_) => _.concat(es))
+                : ValueOrErrors.Default.throw(es)
+          )(value),
+        ValueOrErrors.Default.return(List<v>())
+      ),
+  },
+};

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

@@ -2,7 +2,8 @@ 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 { InjectedPrimitives, Maybe, replaceKeyword, replaceKeywords, revertKeyword, Type, TypeDefinition, TypeName, Unit } from "../../../../../../main";
+import { InjectedPrimitives, Maybe, replaceKeyword, replaceKeywords, revertKeyword, Type, TypeDefinition, TypeName, Unit, Value } from "../../../../../../main";
+import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
 
 export const PrimitiveTypes =
   ["string",
@@ -233,74 +234,105 @@ export const fromAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>
   return obj
 }
 
-export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns, converters: BuiltInApiConverters, isKeywordsReverted: boolean = false, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any, formState: any) : any => {
+export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns, converters: BuiltInApiConverters, isKeywordsReverted: boolean = false, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any, formState: any) : ValueOrErrors<any, string> => {
   const obj = !isKeywordsReverted ? replaceKeywords(raw, "to api") : raw
   if (t.kind == "primitive") {
-    return converters[t.value].toAPIRawValue([obj, formState.modifiedByUser] as never)
+    return ValueOrErrors.Operations.return(converters[t.value].toAPIRawValue([obj, formState.modifiedByUser] 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([obj, formState.modifiedByUser])
-      if (result != undefined && typeof result == "object"){
-        result = toAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters, true, injectedPrimitives)(result, formState)
-      }
-      return result
+      const result = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
+      if(typeof result != "object") return ValueOrErrors.Operations.return(result)
+      
+      return toAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters, true, injectedPrimitives)(result, formState)
     }
     if ((t.value == "Multiselection" || t.value == "MultiSelection") && t.args.length == 1) {
-      // alert(`MultiSelect ${JSON.stringify(t)} ${JSON.stringify(obj)}`)
-      let result = converters["MultiSelection"].toAPIRawValue([obj, formState.modifiedByUser])
-      // alert(`MultiSelect result1 = ${JSON.stringify(result)}`)
-      // alert(`${JSON.stringify(t.args[0])}`)
-      result = result.map((_:any) => 
-        typeof _ == "object" ? toAPIRawValue({ kind:"lookup", name: t.args[0] }, types, builtIns, converters, true, injectedPrimitives)(_, formState) : _)
-      // alert(`MultiSelect result2 = ${JSON.stringify(result)}`)
-      return result
+      const result = converters["MultiSelection"].toAPIRawValue([obj, formState.modifiedByUser])
+
+      return ValueOrErrors.Operations.all(List<ValueOrErrors<any, string>>(result.map((_:any) =>
+        typeof _ == "object" ? toAPIRawValue({ kind:"lookup", name: t.args[0] }, types, builtIns, converters, true, injectedPrimitives)(_, formState) : ValueOrErrors.Operations.return(_))))
     }
     if (t.value == "List" && t.args.length == 1) {
       const converterResult = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
       const isPrimitive = PrimitiveTypes.some(_ => _ == t.args[0]) || injectedPrimitives?.injectedPrimitives.has(t.args[0] as keyof T) 
-      return converterResult.map((item: any, index: number) =>
+      return ValueOrErrors.Operations.all(List<ValueOrErrors<any, string>>(converterResult.map((item: any, index: number) =>
         toAPIRawValue(
           isPrimitive ?
             { kind:"primitive", value:t.args[0] as PrimitiveType }
           : { kind:"lookup", name:t.args[0] },
           types, builtIns, converters, true, injectedPrimitives)(item,
             formState.elementFormStates.get(index)
-      ))
+      ))))
     }
     if (t.value == "Map" && t.args.length == 2) {
       const converterResult = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
+      const isKeyPrimitive = PrimitiveTypes.some(_ => _ == t.args[0]) || injectedPrimitives?.injectedPrimitives.has(t.args[0] as keyof T)
       const isValuePrimitive = PrimitiveTypes.some(_ => _ == t.args[1]) || injectedPrimitives?.injectedPrimitives.has(t.args[1] as keyof T)
       let t_args = t.args.map(parseTypeIShouldBePartOfFormValidation)
-      return (converterResult as List<[any, any]>).reduce((acc: Record<any, any>, [k, v]: [any, any], index: number) => { 
-        if(typeof k != "string" && typeof k != "number") {
-          throw new Error(`key ${k} is not a valid javascript object key (string, number), it is ${typeof k} check field converters.`)
-        }
-        const value = toAPIRawValue(
-          typeof t_args[1] == "string" ? 
-            isValuePrimitive ?
-              { kind: "primitive", value: t_args[1] as PrimitiveType }
-            : { kind: "lookup", name: t_args[1] }
+
+      const parsedMap: ValueOrErrors<{key: ValueOrErrors<any, any>, value: ValueOrErrors<any, any>}, any>[] = converterResult.map((keyValue: any, index: number) => {
+        const key = toAPIRawValue(
+          typeof t_args[0] == "string" ? 
+            isKeyPrimitive ?
+              { kind: "primitive", value: t_args[0] as PrimitiveType }
+            : { kind: "lookup", name: t_args[0] }
           :
-            t_args[1], 
-          types, builtIns, converters, true, injectedPrimitives)(v, formState.elementFormStates.get(index).ValueFormState);
-        acc[k] = value;
-        return acc;
-        }, {} as Record<any, any>
+            t_args[0], 
+            types, builtIns, converters, true, injectedPrimitives)(keyValue[0], formState.elementFormStates.get(index).KeyFormState
+          )
+
+          if(key.kind == "value" && (key.value == undefined || key.value == null)) {
+            return ValueOrErrors.Operations.throw([`A mapped key is undefined for type ${JSON.stringify(t.args[0])}`])
+          } else if ( key.kind == "errors"){
+            return key
+          }
+
+          const value = toAPIRawValue(
+            typeof t_args[1] == "string" ? 
+              isValuePrimitive ?
+                { kind: "primitive", value: t_args[1] as PrimitiveType }
+              : { kind: "lookup", name: t_args[1] }
+            :
+              t_args[1], 
+            types, builtIns, converters, true, injectedPrimitives)(keyValue[1], formState.elementFormStates.get(index).ValueFormState)
+
+          if(value.kind == "errors") return value
+
+          return ValueOrErrors.Operations.return({key, value})
+        }
       )
-    }
 
+      if(parsedMap.length > 0 && parsedMap.some((_: ValueOrErrors<any, any>) => _.kind == "errors")) {
+        return ValueOrErrors.Operations.all(List(parsedMap))
+      }
+      // TODO this needs improvement
+      const allKeysStringified = parsedMap.map((_) => _.kind == "value" ? JSON.stringify((_.value.key as any).value) : "")
+      const allKeysUnique = Set(allKeysStringified).size == allKeysStringified.length
+
+      if(allKeysStringified.length > 0 && !allKeysUnique) {
+        return ValueOrErrors.Operations.throw(`Keys in the map are not unique: ${JSON.stringify(allKeysStringified)}`)
+      }
+      
+      // return ValueOrErrors.Operations.return(parsedMap.map(_ => _.flatten()))
+      return ValueOrErrors.Operations.return(parsedMap.map(_ => (_ as any).map(({key, value}: {key: any, value: any}) => ({key: key.value, value: value.value}))).map((_: any) => _.value))
+
+    }
   } else { // t.kind == lookup: we are dealing with a record/object or extended type 
-    let result: any = { ...obj }
     const tDef = types.get(t.name)!
     if("extends" in tDef && tDef.extends.length == 1) {
-      return converters[(tDef.extends[0] as keyof BuiltInApiConverters)].toAPIRawValue([obj, formState.modifiedByUser] as never)
-    }
-    tDef.fields.forEach((fieldType, fieldName) => {
+      return ValueOrErrors.Operations.return(converters[(tDef.extends[0] as keyof BuiltInApiConverters)].toAPIRawValue([obj, formState.modifiedByUser] as never))
+    }    
+    const convertedMap = tDef.fields.mapEntries(([fieldName, fieldType] ) => {
       const revertedFieldName = revertKeyword(fieldName)
       const fieldValue = obj[revertedFieldName]
-      result[revertedFieldName] = toAPIRawValue(fieldType, types, builtIns, converters, true, injectedPrimitives)(fieldValue, formState[fieldName])
+      const converted = toAPIRawValue(fieldType, types, builtIns, converters, true, injectedPrimitives)(fieldValue, formState[fieldName])
+      return [revertedFieldName, converted]
     })
-    return result
+    if(convertedMap.some((valueOrError) => valueOrError.kind == "errors")) {
+      const propertiesWithErrors = convertedMap.filter((valueOrError) => valueOrError.kind == "errors")
+      const namedErrors = propertiesWithErrors.map((value, key) => value.mapErrors(_ => _.map((_: string) => `${key}: ${_}`)))
+      return ValueOrErrors.Operations.all(List<ValueOrErrors<any, string>>(namedErrors.valueSeq().toList()))
+    }
+    return ValueOrErrors.Operations.return(convertedMap.map(valueOrError => valueOrError.kind == "value" ? valueOrError.value : valueOrError.errors).toJS())
   }
-  return defaultValue(types, builtIns, injectedPrimitives)(t.value)
+  return ValueOrErrors.Operations.return(defaultValue(types, builtIns, injectedPrimitives)(t.value))
 }

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

@@ -16,6 +16,7 @@ import { SearchableInfiniteStreamForm } from "../primitives/domains/searchable-i
 import { StringForm } from "../primitives/domains/string/template";
 import { FormLabel } from "../singleton/domains/form-label/state";
 import { Form } from "../singleton/template";
+import { ValueOrErrors } from "../../../collections/domains/valueOrErrors/state";
 
 const parseOptions = (leafPredicates: any, options: any) => {
   const result = options.map((_: any) => ([_[0].id, [_[0], (_[1] as BoolExpr<any>).eval<any>(leafPredicates)]]));
@@ -483,13 +484,12 @@ export const parseForms =
         const initialState = parsedForm.initialFormState
         const api = {
           get: (id: string) => entityApis.get(launcher.api)(id).then((raw: any) => {
-            // alert(JSON.stringify(raw))
-            // alert(JSON.stringify(parsedForm.formDef.type))
-            const parsed = fromAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(raw)
-            return parsed
+            return fromAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(raw)
           }),
-          update: (id: Guid, value: any, formState: any) =>
-            entityApis.update(launcher.api)(id, toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(value, formState))
+          update: (id: Guid, value: any, formState: any) => {
+            const raw = toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(value, formState)
+            return raw.kind == "errors" ? Promise.reject(raw.errors) : entityApis.update(launcher.api)(id, raw.value)  
+          }
         }
         parsedLaunchers.edit = parsedLaunchers.edit.set(
           launcherName,
@@ -513,12 +513,8 @@ export const parseForms =
         const initialState = parsedForm.initialFormState
         const api = {
           create: ([value, formState]: [any, any]) => {
-            // alert(`type = ${JSON.stringify(parsedForm.formDef.type)}`)
-            // alert(`value = ${JSON.stringify(value)}`)
-            console.log("value", JSON.stringify(value))
             const raw = toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(value, formState)
-            // alert(`raw = ${JSON.stringify(raw.interests)}`)
-            return entityApis.create(launcher.api)(raw)
+            return raw.kind == "errors" ? Promise.reject(raw.errors) : entityApis.create(launcher.api)(raw.value)
           },
           default: (_: Unit) => entityApis.default(launcher.api)(unit)
             .then((raw: any) => {