@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/esm/ts/Contract/Datamap.js

@@ -0,0 +1,287 @@
+import { equalsWith, item } from "@fable-org/fable-library-js/Array.js";
+import { combineMany } from "../FileSystem/Path.js";
+import { safeHash, defaultOf } from "@fable-org/fable-library-js/Util.js";
+import { value } from "@fable-org/fable-library-js/Option.js";
+import { Run_datamapFileNameFromIdentifier, Workflow_datamapFileNameFromIdentifier, Study_datamapFileNameFromIdentifier, Assay_datamapFileNameFromIdentifier } from "../Core/Helper/Identifier.js";
+import { Contract } from "./Contract.js";
+import { fromFsWorkbook, toFsWorkbook } from "../Spreadsheet/DataMap.js";
+import { DataMap__set_StaticHash_Z524259A4 } from "../Core/DataMap.js";
+export function $007CDatamapPath$007C_$007C(input) {
+    let matchResult;
+    if (!equalsWith((x, y) => (x === y), input, defaultOf()) && (input.length === 3)) {
+        if (item(0, input) === "assays") {
+            if (item(2, input) === "isa.datamap.xlsx") {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else if (item(0, input) === "studies") {
+            if (item(2, input) === "isa.datamap.xlsx") {
+                matchResult = 1;
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        matchResult = 2;
+    }
+    switch (matchResult) {
+        case 0: {
+            const anyAssayName = item(1, input);
+            return combineMany(input);
+        }
+        case 1: {
+            const anyStudyName = item(1, input);
+            return combineMany(input);
+        }
+        default:
+            return undefined;
+    }
+}
+export function ARCtrl_DataMap__DataMap_ToCreateContractForAssay_Z721C83C5(this$, assayIdentifier) {
+    const path = Assay_datamapFileNameFromIdentifier(assayIdentifier);
+    return Contract.createCreate(path, "ISA_Datamap", toFsWorkbook(this$));
+}
+export function ARCtrl_DataMap__DataMap_ToUpdateContractForAssay_Z721C83C5(this$, assayIdentifier) {
+    const path = Assay_datamapFileNameFromIdentifier(assayIdentifier);
+    return Contract.createUpdate(path, "ISA_Datamap", toFsWorkbook(this$));
+}
+export function ARCtrl_DataMap__DataMap_ToDeleteContractForAssay_Z721C83C5(this$, assayIdentifier) {
+    const path = Assay_datamapFileNameFromIdentifier(assayIdentifier);
+    return Contract.createDelete(path);
+}
+export function ARCtrl_DataMap__DataMap_toDeleteContractForAssay_Static_Z721C83C5(assayIdentifier) {
+    return (dataMap) => ARCtrl_DataMap__DataMap_ToDeleteContractForAssay_Z721C83C5(dataMap, assayIdentifier);
+}
+export function ARCtrl_DataMap__DataMap_toUpdateContractForAssay_Static_Z721C83C5(assayIdentifier) {
+    return (dataMap) => ARCtrl_DataMap__DataMap_ToUpdateContractForAssay_Z721C83C5(dataMap, assayIdentifier);
+}
+export function ARCtrl_DataMap__DataMap_tryFromReadContractForAssay_Static(assayIdentifier, c) {
+    let fsworkbook;
+    const path = Assay_datamapFileNameFromIdentifier(assayIdentifier);
+    let matchResult, fsworkbook_1, p_1;
+    if (c.Operation === "READ") {
+        if (c.DTOType != null) {
+            if (value(c.DTOType) === "ISA_Datamap") {
+                if (c.DTO != null) {
+                    if ((fsworkbook = value(c.DTO), c.Path === path)) {
+                        matchResult = 0;
+                        fsworkbook_1 = value(c.DTO);
+                        p_1 = c.Path;
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            const dm = fromFsWorkbook(fsworkbook_1);
+            DataMap__set_StaticHash_Z524259A4(dm, safeHash(dm));
+            return dm;
+        }
+        default:
+            return undefined;
+    }
+}
+export function ARCtrl_DataMap__DataMap_ToCreateContractForStudy_Z721C83C5(this$, studyIdentifier) {
+    const path = Study_datamapFileNameFromIdentifier(studyIdentifier);
+    return Contract.createCreate(path, "ISA_Datamap", toFsWorkbook(this$));
+}
+export function ARCtrl_DataMap__DataMap_ToUpdateContractForStudy_Z721C83C5(this$, studyIdentifier) {
+    const path = Study_datamapFileNameFromIdentifier(studyIdentifier);
+    return Contract.createUpdate(path, "ISA_Datamap", toFsWorkbook(this$));
+}
+export function ARCtrl_DataMap__DataMap_ToDeleteContractForStudy_Z721C83C5(this$, studyIdentifier) {
+    const path = Study_datamapFileNameFromIdentifier(studyIdentifier);
+    return Contract.createDelete(path);
+}
+export function ARCtrl_DataMap__DataMap_toDeleteContractForStudy_Static_Z721C83C5(studyIdentifier) {
+    return (dataMap) => ARCtrl_DataMap__DataMap_ToDeleteContractForStudy_Z721C83C5(dataMap, studyIdentifier);
+}
+export function ARCtrl_DataMap__DataMap_toUpdateContractForStudy_Static_Z721C83C5(studyIdentifier) {
+    return (dataMap) => ARCtrl_DataMap__DataMap_ToUpdateContractForStudy_Z721C83C5(dataMap, studyIdentifier);
+}
+export function ARCtrl_DataMap__DataMap_tryFromReadContractForStudy_Static(studyIdentifier, c) {
+    let fsworkbook;
+    const path = Study_datamapFileNameFromIdentifier(studyIdentifier);
+    let matchResult, fsworkbook_1, p_1;
+    if (c.Operation === "READ") {
+        if (c.DTOType != null) {
+            if (value(c.DTOType) === "ISA_Datamap") {
+                if (c.DTO != null) {
+                    if ((fsworkbook = value(c.DTO), c.Path === path)) {
+                        matchResult = 0;
+                        fsworkbook_1 = value(c.DTO);
+                        p_1 = c.Path;
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            const dm = fromFsWorkbook(fsworkbook_1);
+            DataMap__set_StaticHash_Z524259A4(dm, safeHash(dm));
+            return dm;
+        }
+        default:
+            return undefined;
+    }
+}
+export function ARCtrl_DataMap__DataMap_ToCreateContractForWorkflow_Z721C83C5(this$, workflowIdentifier) {
+    const path = Workflow_datamapFileNameFromIdentifier(workflowIdentifier);
+    return Contract.createCreate(path, "ISA_Datamap", toFsWorkbook(this$));
+}
+export function ARCtrl_DataMap__DataMap_ToUpdateContractForWorkflow_Z721C83C5(this$, workflowIdentifier) {
+    const path = Workflow_datamapFileNameFromIdentifier(workflowIdentifier);
+    return Contract.createUpdate(path, "ISA_Datamap", toFsWorkbook(this$));
+}
+export function ARCtrl_DataMap__DataMap_ToDeleteContractForWorkflow_Z721C83C5(this$, workflowIdentifier) {
+    const path = Workflow_datamapFileNameFromIdentifier(workflowIdentifier);
+    return Contract.createDelete(path);
+}
+export function ARCtrl_DataMap__DataMap_toDeleteContractForWorkflow_Static_Z721C83C5(workflowIdentifier) {
+    return (dataMap) => ARCtrl_DataMap__DataMap_ToDeleteContractForWorkflow_Z721C83C5(dataMap, workflowIdentifier);
+}
+export function ARCtrl_DataMap__DataMap_toUpdateContractForWorkflow_Static_Z721C83C5(workflowIdentifier) {
+    return (dataMap) => ARCtrl_DataMap__DataMap_ToUpdateContractForWorkflow_Z721C83C5(dataMap, workflowIdentifier);
+}
+export function ARCtrl_DataMap__DataMap_tryFromReadContractForWorkflow_Static(workflowIdentifier, c) {
+    let fsworkbook;
+    const path = Workflow_datamapFileNameFromIdentifier(workflowIdentifier);
+    let matchResult, fsworkbook_1, p_1;
+    if (c.Operation === "READ") {
+        if (c.DTOType != null) {
+            if (value(c.DTOType) === "ISA_Datamap") {
+                if (c.DTO != null) {
+                    if ((fsworkbook = value(c.DTO), c.Path === path)) {
+                        matchResult = 0;
+                        fsworkbook_1 = value(c.DTO);
+                        p_1 = c.Path;
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            const dm = fromFsWorkbook(fsworkbook_1);
+            DataMap__set_StaticHash_Z524259A4(dm, safeHash(dm));
+            return dm;
+        }
+        default:
+            return undefined;
+    }
+}
+export function ARCtrl_DataMap__DataMap_ToCreateContractForRun_Z721C83C5(this$, runIdentifier) {
+    const path = Run_datamapFileNameFromIdentifier(runIdentifier);
+    return Contract.createCreate(path, "ISA_Datamap", toFsWorkbook(this$));
+}
+export function ARCtrl_DataMap__DataMap_ToUpdateContractForRun_Z721C83C5(this$, runIdentifier) {
+    const path = Run_datamapFileNameFromIdentifier(runIdentifier);
+    return Contract.createUpdate(path, "ISA_Datamap", toFsWorkbook(this$));
+}
+export function ARCtrl_DataMap__DataMap_ToDeleteContractForRun_Z721C83C5(this$, runIdentifier) {
+    const path = Run_datamapFileNameFromIdentifier(runIdentifier);
+    return Contract.createDelete(path);
+}
+export function ARCtrl_DataMap__DataMap_toDeleteContractForRun_Static_Z721C83C5(runIdentifier) {
+    return (dataMap) => ARCtrl_DataMap__DataMap_ToDeleteContractForRun_Z721C83C5(dataMap, runIdentifier);
+}
+export function ARCtrl_DataMap__DataMap_toUpdateContractForRun_Static_Z721C83C5(runIdentifier) {
+    return (dataMap) => ARCtrl_DataMap__DataMap_ToUpdateContractForRun_Z721C83C5(dataMap, runIdentifier);
+}
+export function ARCtrl_DataMap__DataMap_tryFromReadContractForRun_Static(runIdentifier, c) {
+    let fsworkbook;
+    const path = Run_datamapFileNameFromIdentifier(runIdentifier);
+    let matchResult, fsworkbook_1, p_1;
+    if (c.Operation === "READ") {
+        if (c.DTOType != null) {
+            if (value(c.DTOType) === "ISA_Datamap") {
+                if (c.DTO != null) {
+                    if ((fsworkbook = value(c.DTO), c.Path === path)) {
+                        matchResult = 0;
+                        fsworkbook_1 = value(c.DTO);
+                        p_1 = c.Path;
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            const dm = fromFsWorkbook(fsworkbook_1);
+            DataMap__set_StaticHash_Z524259A4(dm, safeHash(dm));
+            return dm;
+        }
+        default:
+            return undefined;
+    }
+}

package/dist/ts/esm/ts/Contract/Git.js

@@ -0,0 +1,72 @@
+import { Contract, CLITool } from "./Contract.js";
+import { dgi } from "../FileSystem/DefaultGitignore.js";
+import { dga } from "../FileSystem/DefaultGitattributes.js";
+import { class_type } from "@fable-org/fable-library-js/Reflection.js";
+import { value, defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { replace } from "@fable-org/fable-library-js/String.js";
+import { empty, singleton, append, delay, toArray } from "@fable-org/fable-library-js/Seq.js";
+export function gitWithArgs(arguments$) {
+    return CLITool.create("git", arguments$);
+}
+export function createGitContractAt(path, arguments$) {
+    return Contract.createExecute(gitWithArgs(arguments$), path);
+}
+export function createGitContract(arguments$) {
+    return Contract.createExecute(gitWithArgs(arguments$));
+}
+export const gitignoreContract = Contract.createCreate(".gitignore", "PlainText", dgi);
+export const gitattributesContract = Contract.createCreate(".gitattributes", "PlainText", dga);
+export class Init {
+    constructor() {
+    }
+}
+export function Init_$reflection() {
+    return class_type("ARCtrl.Contract.Git.Init", undefined, Init);
+}
+export class Clone {
+    constructor() {
+    }
+}
+export function Clone_$reflection() {
+    return class_type("ARCtrl.Contract.Git.Clone", undefined, Clone);
+}
+export function Init_get_init() {
+    return "init";
+}
+export function Init_get_branchFlag() {
+    return "-b";
+}
+export function Init_get_remote() {
+    return "remote";
+}
+export function Init_get_add() {
+    return "add";
+}
+export function Init_get_origin() {
+    return "origin";
+}
+export function Init_createInitContract_6DFDD678(branch) {
+    const branch_1 = defaultArg(branch, "main");
+    return createGitContract([Init_get_init(), Init_get_branchFlag(), branch_1]);
+}
+export function Init_createAddRemoteContract_Z721C83C5(remoteUrl) {
+    return createGitContract([Init_get_remote(), Init_get_add(), Init_get_origin(), remoteUrl]);
+}
+export function Clone_get_clone() {
+    return "clone";
+}
+export function Clone_get_branchFlag() {
+    return "-b";
+}
+export function Clone_get_noLFSConfig() {
+    return "-c \"filter.lfs.smudge = git-lfs smudge --skip -- %f\" -c \"filter.lfs.process = git-lfs filter-process --skip\"";
+}
+export function Clone_formatRepoString(username, pass, url) {
+    return replace(url, "https://", "https://" + (((username + ":") + pass) + "@"));
+}
+export function Clone_createCloneContract_5000466F(remoteUrl, merge, branch, token, nolfs) {
+    const nolfs_1 = defaultArg(nolfs, false);
+    const merge_1 = defaultArg(merge, false);
+    const remoteUrl_1 = (token == null) ? remoteUrl : Clone_formatRepoString(value(token)[0], value(token)[1], remoteUrl);
+    return createGitContract(toArray(delay(() => append(singleton(Clone_get_clone()), delay(() => append(nolfs_1 ? singleton(Clone_get_noLFSConfig()) : empty(), delay(() => append((branch != null) ? singleton(Clone_get_branchFlag()) : empty(), delay(() => append((branch != null) ? singleton(value(branch)) : empty(), delay(() => append(singleton(remoteUrl_1), delay(() => (merge_1 ? singleton(".") : empty()))))))))))))));
+}

package/dist/ts/esm/ts/Contract/ValidationPackagesConfig.js

@@ -0,0 +1,88 @@
+import { combineMany } from "../FileSystem/Path.js";
+import { Contract } from "./Contract.js";
+import { item, equalsWith } from "@fable-org/fable-library-js/Array.js";
+import { defaultOf } from "@fable-org/fable-library-js/Util.js";
+import { value } from "@fable-org/fable-library-js/Option.js";
+import { ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_fromYamlString_Static_Z721C83C5, ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toYamlString_Static_71136F3F } from "../Yaml/ValidationPackagesConfig.js";
+export const ValidationPackagesConfigHelper_ConfigFilePath = combineMany([".arc", "validation_packages.yml"]);
+export const ValidationPackagesConfigHelper_ReadContract = new Contract("READ", ValidationPackagesConfigHelper_ConfigFilePath, "YAML", undefined);
+export function ValidationPackagesConfigExtensions_$007CValidationPackagesYamlPath$007C_$007C(input) {
+    let matchResult;
+    if (!equalsWith((x, y) => (x === y), input, defaultOf()) && (input.length === 2)) {
+        if (item(0, input) === ".arc") {
+            if (item(1, input) === "validation_packages.yml") {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return combineMany(input);
+        default:
+            return undefined;
+    }
+}
+export function ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToCreateContract(this$) {
+    return Contract.createCreate(ValidationPackagesConfigHelper_ConfigFilePath, "YAML", ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toYamlString_Static_71136F3F()(this$));
+}
+export function ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToDeleteContract(this$) {
+    return Contract.createDelete(ValidationPackagesConfigHelper_ConfigFilePath);
+}
+export function ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toDeleteContract_Static_724DAE55(config) {
+    return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToDeleteContract(config);
+}
+export function ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toCreateContract_Static_724DAE55(config) {
+    return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToCreateContract(config);
+}
+export function ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_tryFromReadContract_Static_7570923F(c) {
+    let yaml;
+    let matchResult, p_1, yaml_1;
+    if (c.Operation === "READ") {
+        if (c.DTOType != null) {
+            if (value(c.DTOType) === "YAML") {
+                if (c.DTO != null) {
+                    if (typeof value(c.DTO) === "string") {
+                        if ((yaml = value(c.DTO), c.Path === ValidationPackagesConfigHelper_ConfigFilePath)) {
+                            matchResult = 0;
+                            p_1 = c.Path;
+                            yaml_1 = value(c.DTO);
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_fromYamlString_Static_Z721C83C5(yaml_1);
+        default:
+            return undefined;
+    }
+}

package/dist/ts/esm/ts/ContractIO/ContractIO.js

@@ -0,0 +1,207 @@
+import { startSequential, catchWith } from "../CrossAsync.js";
+import { printf, toText } from "@fable-org/fable-library-js/String.js";
+import { FSharpResult$2_Ok, FSharpResult$2_Error } from "@fable-org/fable-library-js/Result.js";
+import { Contract } from "../Contract/Contract.js";
+import { PromiseBuilder__Delay_62FBFDE1, PromiseBuilder__Run_212F1D4B } from "../fable_modules/Fable.Promise.3.2.0/Promise.fs.js";
+import { promise } from "../fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs.js";
+import { value as value_1 } from "@fable-org/fable-library-js/Option.js";
+import { combine } from "../FileSystem/Path.js";
+import { deleteFileOrDirectoryAsync, renameFileOrDirectoryAsync, writeFileXlsxAsync, writeFileTextAsync, ensureDirectoryOfFileAsync, readFileTextAsync, readFileXlsxAsync } from "./FileSystemHelper.js";
+import { curry2 } from "@fable-org/fable-library-js/Util.js";
+import { append, fold } from "@fable-org/fable-library-js/Array.js";
+export function fulfillReadContractAsync(basePath, c) {
+    return catchWith((e_1) => {
+        let arg_4;
+        return FSharpResult$2_Error((arg_4 = e_1.message, toText(printf("Error reading contract %s: %s"))(c.Path)(arg_4)));
+    }, PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (PromiseBuilder__Delay_62FBFDE1(promise, () => {
+        const matchValue = c.DTOType;
+        let matchResult;
+        if (matchValue != null) {
+            switch (value_1(matchValue)) {
+                case "ISA_Assay":
+                case "ISA_Investigation":
+                case "ISA_Study":
+                case "ISA_Workflow":
+                case "ISA_Run":
+                case "ISA_Datamap": {
+                    matchResult = 0;
+                    break;
+                }
+                case "PlainText": {
+                    matchResult = 1;
+                    break;
+                }
+                default:
+                    matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+        switch (matchResult) {
+            case 0: {
+                const path = combine(basePath, c.Path);
+                return readFileXlsxAsync(path).then((_arg) => {
+                    const dto = _arg;
+                    return Promise.resolve(FSharpResult$2_Ok(new Contract(c.Operation, c.Path, c.DTOType, dto)));
+                });
+            }
+            case 1: {
+                const path_1 = combine(basePath, c.Path);
+                return readFileTextAsync(path_1).then((_arg_1) => (Promise.resolve(FSharpResult$2_Ok(new Contract(c.Operation, c.Path, c.DTOType, _arg_1)))));
+            }
+            default:
+                return Promise.resolve(FSharpResult$2_Error(toText(printf("Contract %s is neither an ISA nor a freetext contract"))(c.Path)));
+        }
+    }).catch((_arg_2) => {
+        let arg_2;
+        return Promise.resolve(FSharpResult$2_Error((arg_2 = _arg_2.message, toText(printf("Error reading contract %s: %s"))(c.Path)(arg_2))));
+    })))));
+}
+export function fullfillContractBatchAsyncBy(contractF, basePath, cs) {
+    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (startSequential(curry2(contractF)(basePath), cs).then((_arg) => {
+        const res = fold((acc, cr) => {
+            const copyOfStruct = acc;
+            if (copyOfStruct.tag === /* Error */ 1) {
+                const copyOfStruct_1 = cr;
+                if (copyOfStruct_1.tag === /* Error */ 1) {
+                    const acc_2 = copyOfStruct.fields[0];
+                    const e_1 = copyOfStruct_1.fields[0];
+                    return FSharpResult$2_Error(append(acc_2, [e_1]));
+                }
+                else {
+                    const e = copyOfStruct.fields[0];
+                    return FSharpResult$2_Error(e);
+                }
+            }
+            else {
+                const copyOfStruct_2 = cr;
+                if (copyOfStruct_2.tag === /* Error */ 1) {
+                    const e_2 = copyOfStruct_2.fields[0];
+                    return FSharpResult$2_Error([e_2]);
+                }
+                else {
+                    const acc_1 = copyOfStruct.fields[0];
+                    const cr_1 = copyOfStruct_2.fields[0];
+                    return FSharpResult$2_Ok(append(acc_1, [cr_1]));
+                }
+            }
+        }, FSharpResult$2_Ok([]), _arg);
+        return Promise.resolve(res);
+    }))));
+}
+export function fulfillWriteContractAsync(basePath, c) {
+    return catchWith((e_1) => {
+        let arg_4;
+        return FSharpResult$2_Error((arg_4 = e_1.message, toText(printf("Error writing contract %s: %s"))(c.Path)(arg_4)));
+    }, PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (PromiseBuilder__Delay_62FBFDE1(promise, () => {
+        const matchValue = c.DTO;
+        if (matchValue == null) {
+            const path_2 = combine(basePath, c.Path);
+            return ensureDirectoryOfFileAsync(path_2).then(() => (writeFileTextAsync(path_2, "").then(() => (Promise.resolve(FSharpResult$2_Ok(c))))));
+        }
+        else if (typeof value_1(matchValue) === "string") {
+            const t = value_1(matchValue);
+            const path = combine(basePath, c.Path);
+            return ensureDirectoryOfFileAsync(path).then(() => (writeFileTextAsync(path, t).then(() => (Promise.resolve(FSharpResult$2_Ok(c))))));
+        }
+        else {
+            const wb = value_1(matchValue);
+            const path_1 = combine(basePath, c.Path);
+            return ensureDirectoryOfFileAsync(path_1).then(() => (writeFileXlsxAsync(path_1, wb).then(() => (Promise.resolve(FSharpResult$2_Ok(c))))));
+        }
+    }).catch((_arg_6) => {
+        let arg_2;
+        return Promise.resolve(FSharpResult$2_Error((arg_2 = _arg_6.message, toText(printf("Error writing contract %s: %s"))(c.Path)(arg_2))));
+    })))));
+}
+export function fulfillUpdateContractAsync(basePath, c) {
+    return catchWith((e_1) => {
+        let arg_4;
+        return FSharpResult$2_Error((arg_4 = e_1.message, toText(printf("Error updating contract %s: %s"))(c.Path)(arg_4)));
+    }, PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (PromiseBuilder__Delay_62FBFDE1(promise, () => {
+        const matchValue = c.DTO;
+        if (matchValue == null) {
+            const path_2 = combine(basePath, c.Path);
+            return ensureDirectoryOfFileAsync(path_2).then(() => (writeFileTextAsync(path_2, "").then(() => (Promise.resolve(FSharpResult$2_Ok(c))))));
+        }
+        else if (typeof value_1(matchValue) === "string") {
+            const t = value_1(matchValue);
+            const path = combine(basePath, c.Path);
+            return ensureDirectoryOfFileAsync(path).then(() => (writeFileTextAsync(path, t).then(() => (Promise.resolve(FSharpResult$2_Ok(c))))));
+        }
+        else {
+            const wb = value_1(matchValue);
+            const path_1 = combine(basePath, c.Path);
+            return ensureDirectoryOfFileAsync(path_1).then(() => (writeFileXlsxAsync(path_1, wb).then(() => (Promise.resolve(FSharpResult$2_Ok(c))))));
+        }
+    }).catch((_arg_6) => {
+        let arg_2;
+        return Promise.resolve(FSharpResult$2_Error((arg_2 = _arg_6.message, toText(printf("Error updating contract %s: %s"))(c.Path)(arg_2))));
+    })))));
+}
+export function fullfillRenameContractAsync(basePath, c) {
+    return catchWith((e_1) => {
+        let arg_5;
+        return FSharpResult$2_Error((arg_5 = e_1.message, toText(printf("Error renaming contract %s: %s"))(c.Path)(arg_5)));
+    }, PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (PromiseBuilder__Delay_62FBFDE1(promise, () => {
+        const matchValue = c.DTO;
+        let matchResult, t_1, t_2;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                if (value_1(matchValue) === c.Path) {
+                    matchResult = 0;
+                    t_1 = value_1(matchValue);
+                }
+                else {
+                    matchResult = 1;
+                    t_2 = value_1(matchValue);
+                }
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+        switch (matchResult) {
+            case 0:
+                return Promise.resolve(FSharpResult$2_Error(toText(printf("Rename Contract %s old and new Path are the same"))(c.Path)));
+            case 1: {
+                const newPath = combine(basePath, t_2);
+                const oldPath = combine(basePath, c.Path);
+                return renameFileOrDirectoryAsync(oldPath, newPath).then(() => (Promise.resolve(FSharpResult$2_Ok(c))));
+            }
+            default:
+                return Promise.resolve(FSharpResult$2_Error(toText(printf("Rename Contract %s does not contain new Path"))(c.Path)));
+        }
+    }).catch((_arg_1) => {
+        let arg_3;
+        return Promise.resolve(FSharpResult$2_Error((arg_3 = _arg_1.message, toText(printf("Error renaming contract %s: %s"))(c.Path)(arg_3))));
+    })))));
+}
+export function fullfillDeleteContractAsync(basePath, c) {
+    return catchWith((e_1) => {
+        let arg_3;
+        return FSharpResult$2_Error((arg_3 = e_1.message, toText(printf("Error deleting contract %s: %s"))(c.Path)(arg_3)));
+    }, PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (PromiseBuilder__Delay_62FBFDE1(promise, () => {
+        const path = combine(basePath, c.Path);
+        return deleteFileOrDirectoryAsync(path).then(() => (Promise.resolve(FSharpResult$2_Ok(c))));
+    }).catch((_arg_1) => {
+        let arg_1;
+        return Promise.resolve(FSharpResult$2_Error((arg_1 = _arg_1.message, toText(printf("Error deleting contract %s: %s"))(c.Path)(arg_1))));
+    })))));
+}
+export function fullFillContract(basePath, c) {
+    return catchWith((e) => {
+        let arg_2;
+        return FSharpResult$2_Error((arg_2 = e.message, toText(printf("Error fulfilling contract %s: %s"))(c.Path)(arg_2)));
+    }, PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => {
+        const matchValue = c.Operation;
+        return (matchValue === "READ") ? (fulfillReadContractAsync(basePath, c)) : ((matchValue === "CREATE") ? (fulfillWriteContractAsync(basePath, c)) : ((matchValue === "UPDATE") ? (fulfillUpdateContractAsync(basePath, c)) : ((matchValue === "DELETE") ? (fullfillDeleteContractAsync(basePath, c)) : ((matchValue === "RENAME") ? (fullfillRenameContractAsync(basePath, c)) : (Promise.resolve(FSharpResult$2_Error(toText(printf("Operation %A not supported"))(c.Operation))))))));
+    })));
+}
+export function fullFillContractBatchAsync(basePath, cs) {
+    return fullfillContractBatchAsyncBy(fullFillContract, basePath, cs);
+}