@knocklabs/cli 0.1.23 → 0.2.0

package/dist/lib/user-config.js

@@ -4,16 +4,29 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default", {
+Object.defineProperty(exports, "UserConfigStore", {
     enumerable: true,
     get: function() {
-        return _default;
+        return UserConfigStore;
     }
 });
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
-const _yup = /*#__PURE__*/ _interop_require_wildcard(require("yup"));
+const _zod = require("zod");
 const _const = require("./helpers/const");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -55,33 +68,58 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const userConfigSchema = _yup.object({
-    serviceToken: _yup.string(),
-    apiOrigin: _yup.string()
+// When a user has authenticated via OAuth, we store the session in the user config.
+const userSessionSchema = _zod.z.object({
+    accessToken: _zod.z.string(),
+    clientId: _zod.z.string(),
+    refreshToken: _zod.z.string()
+});
+const userConfigSchema = _zod.z.object({
+    serviceToken: _zod.z.string().optional(),
+    apiOrigin: _zod.z.string().optional(),
+    dashboardOrigin: _zod.z.string().optional(),
+    authOrigin: _zod.z.string().optional(),
+    userSession: userSessionSchema.optional()
 });
-let USER_CONFIG;
-const maybeReadJsonConfig = async (configDir)=>{
-    // Don't use a user config file in tests.
-    if (_const.isTestEnv) return null;
-    const pathToJsonConfig = _nodepath.resolve(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.");
+class UserConfigStore {
+    async load() {
+        const readConfig = await this.maybeReadJsonConfig();
+        const validConfig = userConfigSchema.parse(readConfig || {});
+        this.userConfig = validConfig || {};
+        return this.userConfig;
+    }
+    get() {
+        return this.userConfig;
+    }
+    async set(updatedConfig) {
+        this.userConfig = {
+            ...this.userConfig,
+            ...updatedConfig
+        };
+        await this.maybeWriteJsonConfig();
+        return this.userConfig;
     }
-    return USER_CONFIG;
-};
-const _default = {
-    load,
-    get
-};
+    configPath() {
+        return _nodepath.resolve(this.configDir, "config.json");
+    }
+    async maybeReadJsonConfig() {
+        if (_const.isTestEnv) return {};
+        const path = this.configPath();
+        const exists = await _fsextra.pathExists(path);
+        if (!exists) return {};
+        return _fsextra.readJSON(path);
+    }
+    async maybeWriteJsonConfig() {
+        if (_const.isTestEnv) return;
+        const path = this.configPath();
+        await _fsextra.outputJson(path, this.userConfig, {
+            spaces: 2
+        });
+    }
+    constructor(configDir){
+        _define_property(this, "configDir", void 0);
+        _define_property(this, "userConfig", void 0);
+        this.configDir = configDir;
+        this.userConfig = {};
+    }
+}