@knocklabs/cli 0.1.0-rc.0

package/dist/lib/marshal/workflow/reader.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    validateTemplateFilePathFormat: ()=>validateTemplateFilePathFormat,
+    readWorkflowDir: ()=>readWorkflowDir
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _error = require("../../helpers/error");
+const _json = require("../../helpers/json");
+const _object = require("../../helpers/object");
+const _helpers = require("./helpers");
+const _types = require("./types");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const validateTemplateFilePathFormat = (relpath, workflowDirCtx)=>{
+    if (typeof relpath !== "string") return false;
+    if (_nodePath.isAbsolute(relpath)) return false;
+    const abspath = _nodePath.resolve(workflowDirCtx.abspath, relpath);
+    const pathDiff = _nodePath.relative(workflowDirCtx.abspath, abspath);
+    return !pathDiff.startsWith("..");
+};
+/*
+ * Validate that a file exists at the given relative path in the directory.
+ */ const validateTemplateFileExists = async (relpath, workflowDirCtx)=>{
+    const abspath = _nodePath.resolve(workflowDirCtx.abspath, relpath);
+    return _fsExtra.pathExists(abspath);
+};
+const readTemplateFile = async (relpath, workflowDirCtx)=>{
+    const abspath = _nodePath.resolve(workflowDirCtx.abspath, relpath);
+    switch(true){
+        case abspath.toLowerCase().endsWith(".json"):
+            {
+                const [obj, errors] = await (0, _json.readJson)(abspath);
+                const content = obj && JSON.stringify(obj);
+                return [
+                    content,
+                    errors
+                ];
+            }
+        default:
+            {
+                const content = await _fsExtra.readFile(abspath, "utf8");
+                return [
+                    content,
+                    []
+                ];
+            }
+    }
+};
+/*
+ * Validates that a given value is a valid template file path and the file
+ * actually exists, before reading the file content.
+ */ const maybeReadTemplateFile = async (val, workflowDirCtx, extractedFilePaths, pathToFieldStr)=>{
+    // Validate the file path format, and that it is unique per workflow.
+    if (!validateTemplateFilePathFormat(val, workflowDirCtx) || typeof val !== "string" || val in extractedFilePaths) {
+        const error = new _error.JsonError("must be a relative path string to a unique file within the directory", pathToFieldStr);
+        return [
+            undefined,
+            error
+        ];
+    }
+    // Keep track of all the extracted file paths that have been seen, so we
+    // can validate each file path's uniqueness as we traverse.
+    extractedFilePaths[val] = true;
+    // Check a file actually exists at the given file path.
+    const exists = await validateTemplateFileExists(val, workflowDirCtx);
+    if (!exists) {
+        const error = new _error.JsonError("must be a relative path string to a file that exists", pathToFieldStr);
+        return [
+            undefined,
+            error
+        ];
+    }
+    // Read the template file and inline the content into the workflow json
+    // under the same field name but without the @ filepath marker.
+    const [content, contentErrors] = await readTemplateFile(val, workflowDirCtx);
+    if (contentErrors.length > 0) {
+        const error = new _error.JsonError(`points to a file with invalid content (${val})\n\n` + (0, _error.formatErrors)(contentErrors), pathToFieldStr);
+        return [
+            undefined,
+            error
+        ];
+    }
+    return [
+        content,
+        undefined
+    ];
+};
+const compileTemplateFiles = async (workflowDirCtx, workflowJson)=>{
+    const errors = [];
+    const extractedFilePaths = {};
+    const objPath = new _object.ObjPath();
+    // 1. Make sure we have a list of steps to look through.
+    if (workflowJson.steps === undefined) {
+        return [
+            workflowJson,
+            errors
+        ];
+    }
+    if (!Array.isArray(workflowJson.steps)) {
+        errors.push(new _error.JsonError("must be an array of workflow steps", objPath.to("steps").str));
+        return [
+            workflowJson,
+            errors
+        ];
+    }
+    // 2. Make sure we can reach `steps[i].template` for channel steps.
+    const steps = workflowJson.steps || [];
+    const pathToSteps = objPath.push("steps").checkout();
+    for (const [stepIdx, step] of steps.entries()){
+        objPath.reset(pathToSteps).push(stepIdx);
+        if (!(0, _lodash.isPlainObject)(step)) {
+            errors.push(new _error.JsonError("must be a workflow step object", objPath.str));
+            continue;
+        }
+        if (step.type === undefined) {
+            errors.push(new _error.JsonError("must have a `type` field", objPath.str));
+            continue;
+        }
+        // Not a channel step, nothing more to do.
+        if (step.type !== _types.StepType.Channel) {
+            continue;
+        }
+        if (step.template === undefined) {
+            errors.push(new _error.JsonError("must have a `template` field containing a template object", objPath.str));
+            continue;
+        }
+        if (!(0, _lodash.isPlainObject)(step.template)) {
+            errors.push(new _error.JsonError("must be a template object", objPath.to("template").str));
+            continue;
+        }
+        // 3. For a given template, look for any extracted template content, read
+        // the extracted template files, then inline the content.
+        objPath.push("template");
+        for (const [field, val] of Object.entries(step.template)){
+            if (field.startsWith("settings")) continue;
+            if (!_helpers.FILEPATH_MARKED_RE.test(field)) continue;
+            const pathToFieldStr = objPath.to(field).str;
+            // eslint-disable-next-line no-await-in-loop
+            const [content, error] = await maybeReadTemplateFile(val, workflowDirCtx, extractedFilePaths, pathToFieldStr);
+            if (error) {
+                errors.push(error);
+                continue;
+            }
+            const inlinePathStr = pathToFieldStr.replace(_helpers.FILEPATH_MARKED_RE, "");
+            (0, _lodash.set)(workflowJson, inlinePathStr, content);
+        }
+        if (!step.template.settings) continue;
+        objPath.push("settings");
+        for (const [field, val] of Object.entries(step.template.settings)){
+            if (!_helpers.FILEPATH_MARKED_RE.test(field)) continue;
+            const pathToFieldStr = objPath.to(field).str;
+            // eslint-disable-next-line no-await-in-loop
+            const [content, error] = await maybeReadTemplateFile(val, workflowDirCtx, extractedFilePaths, pathToFieldStr);
+            if (error) {
+                errors.push(error);
+                continue;
+            }
+            const inlinePathStr = pathToFieldStr.replace(_helpers.FILEPATH_MARKED_RE, "");
+            (0, _lodash.set)(workflowJson, inlinePathStr, content);
+        }
+    }
+    // TODO: Consider validating content for liquid syntax too maybe?
+    return [
+        workflowJson,
+        errors
+    ];
+};
+const readWorkflowDir = async (workflowDirCtx, opts = {})=>{
+    const { abspath  } = workflowDirCtx;
+    const { withTemplateFiles =false , withReadonlyField =false  } = opts;
+    const dirExists = await _fsExtra.pathExists(abspath);
+    if (!dirExists) throw new Error(`${abspath} does not exist`);
+    const workflowJsonPath = await (0, _helpers.lsWorkflowJson)(abspath);
+    if (!workflowJsonPath) throw new Error(`${abspath} is not a workflow directory`);
+    const result = await (0, _json.readJson)(workflowJsonPath);
+    if (!result[0]) return result;
+    let [workflowJson] = result;
+    workflowJson = withReadonlyField ? workflowJson : (0, _object.omitDeep)(workflowJson, [
+        "__readonly"
+    ]);
+    return withTemplateFiles ? compileTemplateFiles(workflowDirCtx, workflowJson) : [
+        workflowJson,
+        []
+    ];
+};

package/dist/lib/marshal/workflow/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "StepType", {
+    enumerable: true,
+    get: ()=>StepType
+});
+var StepType;
+(function(StepType) {
+    StepType["Channel"] = "channel";
+    StepType["Batch"] = "batch";
+    StepType["Delay"] = "delay";
+    StepType["HttpFetch"] = "http_fetch";
+})(StepType || (StepType = {}));

package/dist/lib/marshal/workflow/writer.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    writeWorkflowDir: ()=>writeWorkflowDir,
+    buildWorkflowDirBundle: ()=>buildWorkflowDirBundle,
+    toWorkflowJson: ()=>toWorkflowJson
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _env = require("../../helpers/env");
+const _json = require("../../helpers/json");
+const _object = require("../../helpers/object");
+const _helpers = require("./helpers");
+const _reader = require("./reader");
+const _types = require("./types");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+/*
+ * For a given workflow step and a template field, return the template file path
+ * we can extract out the content to.
+ *
+ * Note, this is a default "recommended" convention but the template file can
+ * be located at any arbitrary path (as long as it is a relative path that is
+ * inside the workflow directory and unique to the field)
+ */ const newTemplateFilePath = (stepRef, fileName, fileExt)=>_nodePath.join(stepRef, `${fileName}.${fileExt}`).toLowerCase();
+/*
+ * For a given workflow step and a template field, return the path of object
+ * which we can use to check whether the field has been extracted (hence, with
+ * the filepath marker).
+ */ const objPathToExtractableField = (stepRef, pathToFieldInTemplate)=>`${stepRef}.template.${pathToFieldInTemplate}${_helpers.FILEPATH_MARKER}`;
+/*
+ * Sanitize the workflow content into a format that's appropriate for reading
+ * and writing, by stripping out any annotation fields and handling readonly
+ * fields.
+ */ const toWorkflowJson = (workflow)=>{
+    var _workflow___annotation;
+    // Move read only fields of a workflow under the dedicated field "__readonly".
+    const readonlyFields = ((_workflow___annotation = workflow.__annotation) === null || _workflow___annotation === void 0 ? void 0 : _workflow___annotation.readonly_fields) || [];
+    const [readonly, remainder] = (0, _object.split)(workflow, readonlyFields);
+    const worklfowJson = {
+        ...remainder,
+        __readonly: readonly
+    };
+    // Strip out all schema annotations, so not to expose them to end users.
+    return (0, _object.omitDeep)(worklfowJson, [
+        "__annotation"
+    ]);
+};
+/*
+ * Compile and return extractable fields settings from the template and its
+ * template settings if present.
+ *
+ * For example, for a channel step like this:
+ *   {
+ *     ref: "email_1",
+ *     type: "channel",
+ *     channel_key: "email-provider",
+ *     template: {
+ *       settings: {
+ *         layout_key: "default",
+ *         __annotation: {
+ *           extractable_fields: {
+ *             pre_content: { default: true, file_ext: "txt" },
+ *           },
+ *           readonly_fields: [],
+ *         },
+ *       },
+ *       subject: "New activity",
+ *       html_body: "<p>Hi <strong>{{ recipient.name }}</strong>.</p>",
+ *       __annotation: {
+ *         extractable_fields: {
+ *           subject: { default: false, file_ext: "txt" },
+ *           json_body: { default: true, file_ext: "json" },
+ *           html_body: { default: true, file_ext: "html" },
+ *           text_body: { default: true, file_ext: "txt" },
+ *         },
+ *         readonly_fields: [],
+ *       },
+ *     },
+ *   }
+ *
+ * Takes the template data and returns a merged map of extractable fields like
+ * this:
+ *
+ *   {
+ *     subject: { default: false, file_ext: "txt" },
+ *     json_body: { default: true, file_ext: "json" },
+ *     html_body: { default: true, file_ext: "html" },
+ *     text_body: { default: true, file_ext: "txt" },
+ *     settings.pre_content: { default: true, file_ext: "txt" },
+ *   }
+ */ const collateExtractableFields = (template)=>{
+    var _template___annotation, _template_settings___annotation;
+    const extractableFields = ((_template___annotation = template.__annotation) === null || _template___annotation === void 0 ? void 0 : _template___annotation.extractable_fields) || {};
+    if (!template.settings) return extractableFields;
+    // If the template has template settings, then merge in the extractable fields
+    // for the template settings (with the field names prefixed with "settings.")
+    let settingsExtractableFields = ((_template_settings___annotation = template.settings.__annotation) === null || _template_settings___annotation === void 0 ? void 0 : _template_settings___annotation.extractable_fields) || {};
+    settingsExtractableFields = Object.fromEntries(Object.entries(settingsExtractableFields).map(([key, val])=>[
+            `settings.${key}`,
+            val
+        ]));
+    return {
+        ...extractableFields,
+        ...settingsExtractableFields
+    };
+};
+const buildWorkflowDirBundle = (workflowDirCtx, remoteWorkflow, localWorkflow = {})=>{
+    const bundle = {};
+    const mutWorkflow = (0, _lodash.cloneDeep)(remoteWorkflow);
+    const localWorkflowStepsByRef = (0, _lodash.keyBy)(localWorkflow.steps || [], "ref");
+    // For each channel step, extract out any template content into seperate
+    // template files where appropriate.
+    for (const step of mutWorkflow.steps){
+        if (step.type !== _types.StepType.Channel) continue;
+        if (!step.template) continue;
+        const template = step.template;
+        const extractableFields = collateExtractableFields(template);
+        for (const [pathToField, { default: extractByDefault , file_ext: fileExt  }] of Object.entries(extractableFields)){
+            // If this template doesn't have this path, then it's not relevant so
+            // nothing more to do here.
+            if (!(0, _lodash.has)(template, pathToField)) continue;
+            // If the field at this path is extracted in the local workflow, then
+            // always extract; otherwise extract based on the field settings default.
+            const extractedTemplateFilePath = (0, _lodash.get)(localWorkflowStepsByRef, objPathToExtractableField(step.ref, pathToField));
+            const isValidTemplateFilePath = Boolean(extractedTemplateFilePath) && (0, _reader.validateTemplateFilePathFormat)(extractedTemplateFilePath, workflowDirCtx);
+            if (!isValidTemplateFilePath && !extractByDefault) continue;
+            // Add the template content being extracted and its relative file path
+            // within the workflow directory to the bundle.
+            const relpath = extractedTemplateFilePath || newTemplateFilePath(step.ref, pathToField, fileExt);
+            (0, _lodash.set)(bundle, [
+                relpath
+            ], (0, _lodash.get)(template, pathToField));
+            // Replace the extracted field content with the file path, and
+            // append the @ suffix to the field name to mark it as such.
+            (0, _lodash.set)(template, [
+                `${pathToField}${_helpers.FILEPATH_MARKER}`
+            ], relpath);
+            (0, _lodash.unset)(template, pathToField);
+        }
+    }
+    // Finally, prepare the workflow data to be written into a workflow json file.
+    return (0, _lodash.set)(bundle, [
+        _helpers.WORKFLOW_JSON
+    ], toWorkflowJson(mutWorkflow));
+};
+const writeWorkflowDir = async (remoteWorkflow, workflowDirCtx)=>{
+    // If the workflow directory exists on the file system (i.e. previously
+    // pulled before), then read the workflow file to use as a reference.
+    const [localWorkflow] = workflowDirCtx.exists ? await (0, _reader.readWorkflowDir)(workflowDirCtx) : [];
+    const bundle = buildWorkflowDirBundle(workflowDirCtx, remoteWorkflow, localWorkflow);
+    const workflowDirPath = _env.isTestEnv ? _nodePath.join(_env.sandboxDir, remoteWorkflow.key) : workflowDirCtx.abspath;
+    try {
+        // TODO(KNO-2794): Should rather clean up any orphaned template files
+        // individually after successfully writing the workflow directory.
+        await _fsExtra.remove(workflowDirPath);
+        const promises = Object.entries(bundle).map(([relpath, fileContent])=>{
+            const filePath = _nodePath.join(workflowDirPath, relpath);
+            return relpath === _helpers.WORKFLOW_JSON ? _fsExtra.outputJson(filePath, fileContent, {
+                spaces: _json.DOUBLE_SPACES
+            }) : _fsExtra.outputFile(filePath, fileContent);
+        });
+        await Promise.all(promises);
+    } catch (error) {
+        await _fsExtra.remove(workflowDirPath);
+        throw error;
+    }
+};

package/dist/lib/run-context.js

@@ -0,0 +1,79 @@
+/*
+ * Module for surveying the cwd location of the command run and its parent dirs
+ * to gather context about a knock resource or the project that the command may
+ * be refering to.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "load", {
+    enumerable: true,
+    get: ()=>load
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _workflow = /*#__PURE__*/ _interopRequireWildcard(require("./marshal/workflow"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const evaluateRecursively = async (ctx, currDir)=>{
+    // If we reached the root of the filesystem, nothing more to do.
+    const { root  } = _nodePath.parse(currDir);
+    if (currDir === root) return ctx;
+    // Check if we are inside a workflow directory, and if so update the context.
+    const isWorkflowDir = await _workflow.isWorkflowDir(currDir);
+    if (!ctx.resourceDir && isWorkflowDir) {
+        ctx.resourceDir = {
+            type: "workflow",
+            key: _nodePath.basename(currDir),
+            abspath: currDir,
+            exists: true
+        };
+    }
+    // If we've identified the resource context, no need to go further.
+    // TODO: In the future also check for knock project dir context.
+    if (ctx.resourceDir) return ctx;
+    const parentDir = _nodePath.resolve(currDir, "..");
+    return evaluateRecursively(ctx, parentDir);
+};
+const load = async ()=>{
+    const ctx = {
+        cwd: process.cwd()
+    };
+    return evaluateRecursively(ctx, ctx.cwd);
+};

package/dist/lib/user-config.js

@@ -0,0 +1,83 @@
+/*
+ * Module for loading and retrieving user configs from a knock config file.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _yup = /*#__PURE__*/ _interopRequireWildcard(require("yup"));
+const _env = require("./helpers/env");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const userConfigSchema = _yup.object({
+    serviceToken: _yup.string(),
+    apiOrigin: _yup.string()
+});
+let USER_CONFIG;
+const maybeReadJsonConfig = async (configDir)=>{
+    // Don't use a user config file in tests.
+    if (_env.isTestEnv) return null;
+    const pathToJsonConfig = _nodePath.join(configDir, "config.json");
+    const exists = await _fsExtra.pathExists(pathToJsonConfig);
+    if (!exists) return null;
+    return _fsExtra.readJSON(pathToJsonConfig);
+};
+const load = async (configDir)=>{
+    const readConfig = await maybeReadJsonConfig(configDir);
+    const validConfig = await userConfigSchema.validate(readConfig || {});
+    // If no valid user config was available, give it an empty map.
+    USER_CONFIG = validConfig || {};
+    return USER_CONFIG;
+};
+const get = ()=>{
+    if (!USER_CONFIG) {
+        throw new Error("User config must be loaded first.");
+    }
+    return USER_CONFIG;
+};
+const _default = {
+    load,
+    get
+};