@f1studio/form-spec 5.0.0-alpha.111 → 5.0.0-alpha.113

package/src/FormSpec.FS/Integrations/Adapters/CorEMR/CoreMREncoder.ts

@@ -0,0 +1,320 @@
+import { fromString, Auto_generateBoxedDecoder_Z6670B51 } from "../../../../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { CoreMRStepMap, CoreMRSourceMap, CoreMRSourceMap_$reflection, CoreMRFieldAnchor, CoreMRFieldAnchor_$reflection, CoreMRMatrixItemAnchor, CoreMRMatrixItemAnchor_$reflection, CoreMRChoiceAnchor, CoreMRChoiceAnchor_$reflection, ValueEncodingInfo, ValueEncodingInfo_$reflection } from "./CoreMRSourceMap.js";
+import { FSharpResult$2_Ok, FSharpResult$2_Error, FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { ExtraCoders, ErrorReason_$union } from "../../../../fable_modules/Thoth.Json.10.4.1/Types.fs.js";
+import { Spec_FormSpec$1, Spec_FormStep$1, Spec_FormField$1, Shared_PluginDataProperty, Shared_MatrixItemKey, Shared_MatrixAnswer, Shared_FieldAnswer, Shared_FieldValue, Shared_FieldValue_$union, Spec_FieldType_$union, Spec_MultiChoiceInfo, Spec_SingleChoiceInfo, Shared_FieldOption, Shared_FieldOptionKey, Shared_FieldKey, Shared_FieldKey_$reflection } from "../../../FormSpec.js";
+import { toString, Auto_generateBoxedEncoder_437914C6 } from "../../../../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { newGuid } from "@fable-org/fable-library-js/Guid.js";
+import { FSharpMap, ofList, tryFind as tryFind_1, add } from "@fable-org/fable-library-js/Map.js";
+import { IOptionalGetter, IRequiredGetter, IGetters, list as list_9, bool, string, int, object } from "../../../../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { comparePrimitives, uncurry2 } from "@fable-org/fable-library-js/Util.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { collect, exists, head, tail, map as map_1, isEmpty, choose, singleton, tryFind, empty, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { orElse, map, value as value_10, Option, bind, defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { empty as empty_1 } from "../../../../fable_modules/Thoth.Json.10.4.1/Extra.fs.js";
+import { CoreMRAnswer, CoreMRFormInsertRequest, CoreMRFormInsertRequest_$reflection } from "./FormSpecToCoreMRInsert.js";
+import { isNullOrWhiteSpace } from "@fable-org/fable-library-js/String.js";
+import { toList, FSharpSet } from "@fable-org/fable-library-js/Set.js";
+import { toInt32 } from "@fable-org/fable-library-js/BigInt.js";
+import { computeBitmask } from "../../../BitmaskHelpers.js";
+
+const sourceMapExtra: ExtraCoders = (() => {
+    let copyOfStruct: string;
+    const valueEncodingDecoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<ValueEncodingInfo, [string, ErrorReason_$union]>)) = Auto_generateBoxedDecoder_Z6670B51(ValueEncodingInfo_$reflection(), undefined, undefined);
+    const choiceAnchorDecoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<CoreMRChoiceAnchor, [string, ErrorReason_$union]>)) = Auto_generateBoxedDecoder_Z6670B51(CoreMRChoiceAnchor_$reflection(), undefined, undefined);
+    const fieldKeyDecoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<Shared_FieldKey, [string, ErrorReason_$union]>)) = Auto_generateBoxedDecoder_Z6670B51(Shared_FieldKey_$reflection(), undefined, undefined);
+    const matrixItemAnchorDecoder: ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<CoreMRMatrixItemAnchor, [string, ErrorReason_$union]>)) = Auto_generateBoxedDecoder_Z6670B51(CoreMRMatrixItemAnchor_$reflection(), undefined, undefined);
+    const encoder: ((arg0: CoreMRFieldAnchor) => any) = Auto_generateBoxedEncoder_437914C6(CoreMRFieldAnchor_$reflection(), undefined, undefined, undefined);
+    return new ExtraCoders((copyOfStruct = newGuid(), copyOfStruct), add<string, [((arg0: any) => any), ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))]>("FormSpec.Integrations.CorEMR.CoreMRSourceMap.CoreMRFieldAnchor", [encoder, (path_8: string): ((arg0: any) => FSharpResult$2_$union<CoreMRFieldAnchor, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<CoreMRFieldAnchor, [string, ErrorReason_$union]> => object<CoreMRFieldAnchor>((get$: IGetters): CoreMRFieldAnchor => {
+        let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter, objectArg_3: IRequiredGetter, objectArg_4: IRequiredGetter, objectArg_5: IRequiredGetter, objectArg_6: IOptionalGetter, objectArg_7: IOptionalGetter, objectArg_8: IOptionalGetter, objectArg_9: IOptionalGetter, objectArg_10: IRequiredGetter, objectArg_11: IRequiredGetter, objectArg_12: IRequiredGetter, objectArg_13: IOptionalGetter;
+        return new CoreMRFieldAnchor((objectArg = get$.Required, objectArg.Field<int32>("ItemId", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("ItemTypeId", uncurry2(int))), (objectArg_2 = get$.Required, objectArg_2.Field<int32>("Sequence", uncurry2(int))), (objectArg_3 = get$.Required, objectArg_3.Field<int32>("NestingLevel", uncurry2(int))), (objectArg_4 = get$.Required, objectArg_4.Field<string>("Label", string)), (objectArg_5 = get$.Required, objectArg_5.Field<boolean>("IsRequired", bool)), (objectArg_6 = get$.Optional, objectArg_6.Field<string>("SequenceText", string)), (objectArg_7 = get$.Optional, objectArg_7.Field<string>("Code", string)), (objectArg_8 = get$.Optional, objectArg_8.Field<string>("Uuid", string)), (objectArg_9 = get$.Optional, objectArg_9.Field<string>("GenderRequired", string)), (objectArg_10 = get$.Required, objectArg_10.Field<ValueEncodingInfo>("Encoding", uncurry2(valueEncodingDecoder))), (objectArg_11 = get$.Required, objectArg_11.Field<FSharpList<CoreMRChoiceAnchor>>("Choices", (path_6: string, value_6: any): FSharpResult$2_$union<FSharpList<CoreMRChoiceAnchor>, [string, ErrorReason_$union]> => list_9<CoreMRChoiceAnchor>(uncurry2(choiceAnchorDecoder), path_6, value_6))), (objectArg_12 = get$.Required, objectArg_12.Field<Shared_FieldKey>("FieldKey", uncurry2(fieldKeyDecoder))), defaultArg((objectArg_13 = get$.Optional, objectArg_13.Field<FSharpList<CoreMRMatrixItemAnchor>>("MatrixItemAnchors", (path_7: string, value_7: any): FSharpResult$2_$union<FSharpList<CoreMRMatrixItemAnchor>, [string, ErrorReason_$union]> => list_9<CoreMRMatrixItemAnchor>(uncurry2(matrixItemAnchorDecoder), path_7, value_7))), empty<CoreMRMatrixItemAnchor>()));
+    }, path_8, v))] as [((arg0: any) => any), ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))], empty_1.Coders));
+})();
+
+/**
+ * Decode provenance payload using Thoth Auto — same type that was encoded by
+ * CoreMRSourceMap.convertWithMapAndProvenance (Encode.Auto.toString).
+ * Uses sourceMapExtra so MatrixItemAnchors defaults to [] when missing.
+ */
+export function tryDecodeSourceMap(payloadJson: string): FSharpResult$2_$union<CoreMRSourceMap, string> {
+    return fromString<CoreMRSourceMap>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(CoreMRSourceMap_$reflection(), undefined, sourceMapExtra)), payloadJson);
+}
+
+/**
+ * Serialize CoreMRFormInsertRequest to JSON for bridge POST body
+ */
+export function serializeRequest(req: CoreMRFormInsertRequest): string {
+    return toString(0, Auto_generateBoxedEncoder_437914C6(CoreMRFormInsertRequest_$reflection(), undefined, undefined, undefined)(req));
+}
+
+function canonicalize(s: string): string {
+    if (isNullOrWhiteSpace(s)) {
+        return "";
+    }
+    else {
+        return s.trim().toLowerCase();
+    }
+}
+
+function getFieldKeyGuid(_arg: Shared_FieldKey): string {
+    return _arg.fields[0];
+}
+
+function getFieldOptionKeyGuid(_arg: Shared_FieldOptionKey): string {
+    return _arg.fields[0];
+}
+
+function getScoreFromOption(options: FSharpList<Shared_FieldOption>, selectedValue: string): Option<int32> {
+    const canonicalSelected: string = canonicalize(selectedValue);
+    return bind<Shared_FieldOption, int32>((opt_1: Shared_FieldOption): Option<int32> => opt_1.Score, tryFind<Shared_FieldOption>((opt: Shared_FieldOption): boolean => (canonicalize(opt.Value) === canonicalSelected), options));
+}
+
+function getOptionsFromFieldType(ft: Spec_FieldType_$union): FSharpList<Shared_FieldOption> {
+    let matchResult: int32, info: Spec_SingleChoiceInfo, info_1: Spec_MultiChoiceInfo;
+    switch (ft.tag) {
+        case /* Radio */ 12: {
+            matchResult = 0;
+            info = ft.fields[0];
+            break;
+        }
+        case /* SingleChoice */ 13: {
+            matchResult = 0;
+            info = ft.fields[0];
+            break;
+        }
+        case /* Dropdown */ 14: {
+            matchResult = 0;
+            info = ft.fields[0];
+            break;
+        }
+        case /* TextAutoComplete */ 18: {
+            matchResult = 0;
+            info = ft.fields[0];
+            break;
+        }
+        case /* MultiChoice */ 15: {
+            matchResult = 1;
+            info_1 = ft.fields[0];
+            break;
+        }
+        case /* CheckboxList */ 16: {
+            matchResult = 1;
+            info_1 = ft.fields[0];
+            break;
+        }
+        case /* TagList */ 17: {
+            matchResult = 1;
+            info_1 = ft.fields[0];
+            break;
+        }
+        case /* Matrix */ 19: {
+            matchResult = 2;
+            break;
+        }
+        default:
+            matchResult = 3;
+    }
+    switch (matchResult) {
+        case 0:
+            return info!.Options;
+        case 1:
+            return info_1!.Options;
+        case 2:
+            return ft.fields[0].Options;
+        default:
+            return empty<Shared_FieldOption>();
+    }
+}
+
+function fieldToAnswers(field: Spec_FormField$1<Spec_FieldType_$union>, anchor: CoreMRFieldAnchor): FSharpList<CoreMRAnswer> {
+    let canonicalAnswer: string;
+    if (anchor.Encoding.IsSkip) {
+        return empty<CoreMRAnswer>();
+    }
+    else if (anchor.Encoding.IsScaffold) {
+        return singleton(new CoreMRAnswer(anchor.Sequence, 2, undefined));
+    }
+    else {
+        const matchValue: Option<Shared_FieldValue_$union> = field.Value;
+        if (matchValue != null) {
+            switch (value_10(matchValue).tag) {
+                case /* Multiple */ 1: {
+                    const answers: FSharpSet<Shared_FieldAnswer> = (value_10(matchValue) as Shared_FieldValue<1>).fields[0];
+                    if (anchor.Encoding.ValueEncoding !== "choice_score") {
+                        return empty<CoreMRAnswer>();
+                    }
+                    else {
+                        const options_1: FSharpList<Shared_FieldOption> = getOptionsFromFieldType(field.FieldType);
+                        const choicesWithBitPos: FSharpList<[string, int32]> = choose<CoreMRChoiceAnchor, [string, int32]>((c_2: CoreMRChoiceAnchor): Option<[string, int32]> => {
+                            if (c_2.BitPosition != null) {
+                                return [getFieldOptionKeyGuid(c_2.FieldOptionKey), value_10(c_2.BitPosition)] as [string, int32];
+                            }
+                            else {
+                                return undefined;
+                            }
+                        }, anchor.Choices);
+                        if (isEmpty(choicesWithBitPos)) {
+                            return empty<CoreMRAnswer>();
+                        }
+                        else {
+                            return singleton(new CoreMRAnswer(anchor.Sequence, ~~toInt32(computeBitmask(choose<string, int32>((key: string): Option<int32> => map<[string, int32], int32>((tuple: [string, int32]): int32 => tuple[1], tryFind<[string, int32]>((tupledArg: [string, int32]): boolean => (tupledArg[0] === key), choicesWithBitPos)), choose<string, string>((valStr_1: string): Option<string> => map<Shared_FieldOption, string>((opt_2: Shared_FieldOption): string => getFieldOptionKeyGuid(opt_2.OptionKey), tryFind<Shared_FieldOption>((opt_1: Shared_FieldOption): boolean => (canonicalize(opt_1.Value) === canonicalize(valStr_1)), options_1)), map_1<Shared_FieldAnswer, string>((a: Shared_FieldAnswer): string => a.Value, toList<Shared_FieldAnswer>(answers)))))), undefined));
+                        }
+                    }
+                }
+                case /* Matrix */ 2: {
+                    const matrixAnswer: Shared_MatrixAnswer = (value_10(matchValue) as Shared_FieldValue<2>).fields[0];
+                    if (isEmpty(anchor.MatrixItemAnchors)) {
+                        return empty<CoreMRAnswer>();
+                    }
+                    else {
+                        const options_2: FSharpList<Shared_FieldOption> = getOptionsFromFieldType(field.FieldType);
+                        return choose<CoreMRMatrixItemAnchor, CoreMRAnswer>((rowAnchor: CoreMRMatrixItemAnchor): Option<CoreMRAnswer> => map<string, CoreMRAnswer>((selectedValue: string): CoreMRAnswer => (new CoreMRAnswer(rowAnchor.Sequence, defaultArg(getScoreFromOption(options_2, selectedValue), 0), undefined)), tryFind_1<Shared_MatrixItemKey, string>(rowAnchor.MatrixItemKey, matrixAnswer.Values)), anchor.MatrixItemAnchors);
+                    }
+                }
+                case /* PluginData */ 3: {
+                    const props: FSharpList<Shared_PluginDataProperty> = (value_10(matchValue) as Shared_FieldValue<3>).fields[0];
+                    let matchResult: int32, p_1: Shared_PluginDataProperty;
+                    if (!isEmpty(props)) {
+                        if (isEmpty(tail(props))) {
+                            if (!isNullOrWhiteSpace(head(props).Value)) {
+                                matchResult = 0;
+                                p_1 = head(props);
+                            }
+                            else {
+                                matchResult = 1;
+                            }
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                    switch (matchResult) {
+                        case 0:
+                            return singleton(new CoreMRAnswer(anchor.Sequence, 0, p_1!.Value));
+                        default:
+                            return empty<CoreMRAnswer>();
+                    }
+                }
+                default: {
+                    const answer: Shared_FieldAnswer = (value_10(matchValue) as Shared_FieldValue<0>).fields[0];
+                    const options: FSharpList<Shared_FieldOption> = getOptionsFromFieldType(field.FieldType);
+                    const matchValue_2: string = anchor.Encoding.ValueEncoding;
+                    switch (matchValue_2) {
+                        case "choice_score": {
+                            const matchValue_3: Option<int32> = orElse(getScoreFromOption(options, answer.Value), (canonicalAnswer = canonicalize(answer.Value), map<CoreMRChoiceAnchor, int32>((c_1: CoreMRChoiceAnchor): int32 => c_1.Score, tryFind<CoreMRChoiceAnchor>((c: CoreMRChoiceAnchor): boolean => exists<Shared_FieldOption>((opt: Shared_FieldOption): boolean => {
+                                if (getFieldOptionKeyGuid(opt.OptionKey) === getFieldOptionKeyGuid(c.FieldOptionKey)) {
+                                    return canonicalize(opt.Value) === canonicalAnswer;
+                                }
+                                else {
+                                    return false;
+                                }
+                            }, options), anchor.Choices))));
+                            if (matchValue_3 == null) {
+                                return singleton(new CoreMRAnswer(anchor.Sequence, 0, undefined));
+                            }
+                            else {
+                                return singleton(new CoreMRAnswer(anchor.Sequence, value_10(matchValue_3), undefined));
+                            }
+                        }
+                        case "1_yes_2_no": {
+                            const valStr: string = canonicalize(answer.Value);
+                            return singleton(new CoreMRAnswer(anchor.Sequence, (((valStr === "yes") ? true : (valStr === "true")) ? true : (valStr === "1")) ? 1 : 2, undefined));
+                        }
+                        case "zero":
+                        case "scaffold":
+                        case "unknown":
+                            return singleton(new CoreMRAnswer(anchor.Sequence, 0, answer.Value));
+                        default:
+                            return singleton(new CoreMRAnswer(anchor.Sequence, 0, answer.Value));
+                    }
+                }
+            }
+        }
+        else {
+            const matchValue_1: string = anchor.Encoding.ValueEncoding;
+            switch (matchValue_1) {
+                case "1_yes_2_no":
+                    return singleton(new CoreMRAnswer(anchor.Sequence, 2, undefined));
+                case "choice_score":
+                    if (isEmpty(anchor.Choices)) {
+                        return empty<CoreMRAnswer>();
+                    }
+                    else {
+                        return singleton(new CoreMRAnswer(anchor.Sequence, 0, undefined));
+                    }
+                case "zero":
+                    return singleton(new CoreMRAnswer(anchor.Sequence, 0, undefined));
+                default:
+                    return empty<CoreMRAnswer>();
+            }
+        }
+    }
+}
+
+function buildFieldByKeyMap(spec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpMap<string, Spec_FormField$1<Spec_FieldType_$union>> {
+    return ofList<string, Spec_FormField$1<Spec_FieldType_$union>>(map_1<Spec_FormField$1<Spec_FieldType_$union>, [string, Spec_FormField$1<Spec_FieldType_$union>]>((f: Spec_FormField$1<Spec_FieldType_$union>): [string, Spec_FormField$1<Spec_FieldType_$union>] => ([getFieldKeyGuid(f.FieldKey), f] as [string, Spec_FormField$1<Spec_FieldType_$union>]), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, spec.Steps)), {
+        Compare: comparePrimitives,
+    });
+}
+
+function anchorToAnswers(fieldMap: FSharpMap<string, Spec_FormField$1<Spec_FieldType_$union>>, anchor: CoreMRFieldAnchor): FSharpList<CoreMRAnswer> {
+    const field: Option<Spec_FormField$1<Spec_FieldType_$union>> = tryFind_1<string, Spec_FormField$1<Spec_FieldType_$union>>(getFieldKeyGuid(anchor.FieldKey), fieldMap);
+    if (anchor.Encoding.IsSkip) {
+        return empty<CoreMRAnswer>();
+    }
+    else if (anchor.Encoding.IsScaffold) {
+        return singleton(new CoreMRAnswer(anchor.Sequence, 2, undefined));
+    }
+    else if (field != null) {
+        return fieldToAnswers(value_10(field), anchor);
+    }
+    else {
+        const matchValue: string = anchor.Encoding.ValueEncoding;
+        switch (matchValue) {
+            case "1_yes_2_no":
+                return singleton(new CoreMRAnswer(anchor.Sequence, 2, undefined));
+            case "choice_score":
+                if (isEmpty(anchor.Choices)) {
+                    return empty<CoreMRAnswer>();
+                }
+                else {
+                    return singleton(new CoreMRAnswer(anchor.Sequence, 0, undefined));
+                }
+            case "zero":
+                return singleton(new CoreMRAnswer(anchor.Sequence, 0, undefined));
+            default:
+                return empty<CoreMRAnswer>();
+        }
+    }
+}
+
+/**
+ * Encode filled FormSpec to CoreMR form-insert payload.
+ * scaffoldMode: when true, omit answers (scaffold mode — all items get value=2).
+ * Iterates over provenance anchors (source of truth) so we never omit required items.
+ */
+export function encodeToFormAnswers(provenancePayload: string, filledFormSpec: Spec_FormSpec$1<Spec_FieldType_$union>, scaffoldMode: boolean, dryRun: boolean): FSharpResult$2_$union<CoreMRFormInsertRequest, string> {
+    let acc: FSharpList<CoreMRAnswer>;
+    const matchValue: FSharpResult$2_$union<CoreMRSourceMap, string> = tryDecodeSourceMap(provenancePayload);
+    if (matchValue.tag === /* Ok */ 0) {
+        const sourceMap: CoreMRSourceMap = matchValue.fields[0];
+        if (sourceMap.FormSpecId !== filledFormSpec.Id) {
+            return FSharpResult$2_Error<CoreMRFormInsertRequest, string>(`FormSpecId mismatch: provenance is for form ${sourceMap.FormSpecId} but data is from form ${filledFormSpec.Id}. This could cause patient data mixing!`);
+        }
+        else {
+            let formName: string;
+            const value = `CORE-${sourceMap.FormId}`;
+            formName = defaultArg(orElse(sourceMap.FormName, isNullOrWhiteSpace(filledFormSpec.Title) ? undefined : filledFormSpec.Title), value);
+            const fieldMap: FSharpMap<string, Spec_FormField$1<Spec_FieldType_$union>> = buildFieldByKeyMap(filledFormSpec);
+            return FSharpResult$2_Ok<CoreMRFormInsertRequest, string>(new CoreMRFormInsertRequest(sourceMap.FormId, formName, scaffoldMode ? undefined : ((acc = collect<CoreMRFieldAnchor, CoreMRAnswer>((anchor: CoreMRFieldAnchor): FSharpList<CoreMRAnswer> => anchorToAnswers(fieldMap, anchor), collect<CoreMRStepMap, CoreMRFieldAnchor>((step: CoreMRStepMap): FSharpList<CoreMRFieldAnchor> => step.FieldAnchors, sourceMap.Steps)), isEmpty(acc) ? undefined : acc)), dryRun));
+        }
+    }
+    else {
+        return FSharpResult$2_Error<CoreMRFormInsertRequest, string>(`Invalid provenance payload: ${matchValue.fields[0]}`);
+    }
+}
+
+//# sourceMappingURL=CoreMREncoder.ts.map