genlayer 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 
 
+## 0.8.0 (2024-12-11)
+
+
+### Features
+
+* implement config command ([#149](https://github.com/yeagerai/genlayer-cli/issues/149)) ([cc0f2ca](https://github.com/yeagerai/genlayer-cli/commit/cc0f2caee2c55f00efc7da0671663827a69be557))
+
 ## 0.7.0 (2024-12-09)
 
 

package/dist/index.js

@@ -50858,7 +50858,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.7.0";
+var version = "0.8.0";
 var package_default = {
   name: "genlayer",
   version,
@@ -78286,11 +78286,62 @@ function initializeKeygenCommands(program2) {
   return program2;
 }
 
+// src/commands/config/getSetReset.ts
+var ConfigActions = class {
+  constructor() {
+    __publicField(this, "configManager");
+    this.configManager = new ConfigFileManager();
+  }
+  set(keyValue) {
+    const [key, value] = keyValue.split("=");
+    if (!key || value === void 0) {
+      console.error("Invalid format. Use key=value.");
+      process.exit(1);
+    }
+    this.configManager.writeConfig(key, value);
+    console.log(`Configuration updated: ${key}=${value}`);
+  }
+  get(key) {
+    if (key) {
+      const value = this.configManager.getConfigByKey(key);
+      if (value === null) {
+        console.log(`No value set for key: ${key}`);
+      } else {
+        console.log(`${key}=${value}`);
+      }
+    } else {
+      const config = this.configManager.getConfig();
+      console.log("Current configuration:", JSON.stringify(config, null, 2));
+    }
+  }
+  reset(key) {
+    const config = this.configManager.getConfig();
+    if (config[key] === void 0) {
+      console.log(`Key does not exist in the configuration: ${key}`);
+      return;
+    }
+    delete config[key];
+    this.configManager.writeConfig(key, void 0);
+    console.log(`Configuration key reset: ${key}`);
+  }
+};
+
+// src/commands/config/index.ts
+function initializeConfigCommands(program2) {
+  const configActions = new ConfigActions();
+  const configCommand = program2.command("config").description("Manage CLI configuration, including the default network");
+  configCommand.command("set").description("Set a configuration value").argument("<key=value>", "Configuration key-value pair to set").action((keyValue) => configActions.set(keyValue));
+  configCommand.command("get").description("Get the current configuration").argument("[key]", "Configuration key to retrieve").action((key) => configActions.get(key));
+  configCommand.command("reset").description("Reset a configuration value to its default").argument("<key>", "Configuration key to reset").action((key) => configActions.reset(key));
+  return program2;
+}
+
 // src/index.ts
 function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
   initializeGeneralCommands(program);
   initializeKeygenCommands(program);
+  initializeConfigCommands(program);
   program.parse(process.argv);
 }
 initializeCLI();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {

package/src/commands/config/getSetReset.ts

@@ -0,0 +1,44 @@
+import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
+
+export class ConfigActions {
+  private configManager: ConfigFileManager;
+
+  constructor() {
+    this.configManager = new ConfigFileManager();
+  }
+
+  set(keyValue: string): void {
+    const [key, value] = keyValue.split("=");
+    if (!key || value === undefined) {
+      console.error("Invalid format. Use key=value.");
+      process.exit(1);
+    }
+    this.configManager.writeConfig(key, value);
+    console.log(`Configuration updated: ${key}=${value}`);
+  }
+
+  get(key?: string): void {
+    if (key) {
+      const value = this.configManager.getConfigByKey(key);
+      if (value === null) {
+        console.log(`No value set for key: ${key}`);
+      } else {
+        console.log(`${key}=${value}`);
+      }
+    } else {
+      const config = this.configManager.getConfig();
+      console.log("Current configuration:", JSON.stringify(config, null, 2));
+    }
+  }
+
+  reset(key: string): void {
+    const config = this.configManager.getConfig();
+    if (config[key] === undefined) {
+      console.log(`Key does not exist in the configuration: ${key}`);
+      return;
+    }
+    delete config[key];
+    this.configManager.writeConfig(key, undefined);
+    console.log(`Configuration key reset: ${key}`);
+  }
+}

package/src/commands/config/index.ts

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import { ConfigActions } from "./getSetReset";
+
+export function initializeConfigCommands(program: Command) {
+  const configActions = new ConfigActions();
+
+  const configCommand = program
+    .command("config")
+    .description("Manage CLI configuration, including the default network");
+
+  configCommand
+    .command("set")
+    .description("Set a configuration value")
+    .argument("<key=value>", "Configuration key-value pair to set")
+    .action((keyValue: string) => configActions.set(keyValue));
+
+  configCommand
+    .command("get")
+    .description("Get the current configuration")
+    .argument("[key]", "Configuration key to retrieve")
+    .action((key?: string) => configActions.get(key));
+
+  configCommand
+    .command("reset")
+    .description("Reset a configuration value to its default")
+    .argument("<key>", "Configuration key to reset")
+    .action((key: string) => configActions.reset(key));
+
+  return program;
+}

package/src/index.ts

@@ -4,11 +4,13 @@ import {version} from "../package.json";
 import {CLI_DESCRIPTION} from "../src/lib/config/text";
 import { initializeGeneralCommands } from "../src/commands/general";
 import { initializeKeygenCommands } from "../src/commands/keygen";
+import { initializeConfigCommands } from "../src/commands/config";
 
 export function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
   initializeGeneralCommands(program);
   initializeKeygenCommands(program);
+  initializeConfigCommands(program);
   program.parse(process.argv);
 }
 

package/tests/actions/create.test.ts

@@ -89,7 +89,7 @@ describe("KeypairCreator", () => {
 
   test("overwrites the file if overwrite is true", () => {
     const consoleLogSpy = vi.spyOn(console, "log");
-    vi.mocked(existsSync).mockReturnValue(true); // Simulate file exists
+    vi.mocked(existsSync).mockReturnValue(true);
     const options = { output: "keypair.json", overwrite: true };
 
     keypairCreator.createKeypairAction(options);

package/tests/actions/getSetReset.test.ts

@@ -0,0 +1,101 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import { ConfigActions } from "../../src/commands/config/getSetReset";
+import { ConfigFileManager } from "../../src/lib/config/ConfigFileManager";
+
+vi.mock("../../src/lib/config/ConfigFileManager");
+
+describe("ConfigActions", () => {
+  let configActions: ConfigActions;
+
+  beforeEach(() => {
+    configActions = new ConfigActions();
+    vi.clearAllMocks();
+  });
+
+  new ConfigFileManager();
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("set method writes key-value pair to the configuration", () => {
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.set("defaultNetwork=testnet");
+
+    expect(configActions["configManager"].writeConfig).toHaveBeenCalledWith("defaultNetwork", "testnet");
+    expect(consoleLogSpy).toHaveBeenCalledWith("Configuration updated: defaultNetwork=testnet");
+  });
+
+  test("set method throws error for invalid format", () => {
+    const consoleErrorSpy = vi.spyOn(console, "error");
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+
+    expect(() => configActions.set("invalidFormat")).toThrowError("process.exit");
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith("Invalid format. Use key=value.");
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test("get method retrieves value for a specific key", () => {
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue("testnet");
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.get("defaultNetwork");
+
+    expect(configActions["configManager"].getConfigByKey).toHaveBeenCalledWith("defaultNetwork");
+    expect(consoleLogSpy).toHaveBeenCalledWith("defaultNetwork=testnet");
+  });
+
+  test("get method prints message when key has no value", () => {
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue(null);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.get("nonexistentKey");
+
+    expect(configActions["configManager"].getConfigByKey).toHaveBeenCalledWith("nonexistentKey");
+    expect(consoleLogSpy).toHaveBeenCalledWith("No value set for key: nonexistentKey");
+  });
+
+  test("get method retrieves the entire configuration when no key is provided", () => {
+    const mockConfig = { defaultNetwork: "testnet" };
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.get();
+
+    expect(configActions["configManager"].getConfig).toHaveBeenCalledTimes(1);
+    expect(consoleLogSpy).toHaveBeenCalledWith("Current configuration:", JSON.stringify(mockConfig, null, 2));
+  });
+
+  test("reset method removes key from configuration", () => {
+    const mockConfig = { defaultNetwork: "testnet" };
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.reset("defaultNetwork");
+
+    expect(configActions["configManager"].getConfig).toHaveBeenCalledTimes(1);
+    expect(configActions["configManager"].writeConfig).toHaveBeenCalledWith("defaultNetwork", undefined);
+    expect(consoleLogSpy).toHaveBeenCalledWith("Configuration key reset: defaultNetwork");
+  });
+
+  test("reset method prints message when key does not exist", () => {
+    const mockConfig = {};
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.reset("nonexistentKey");
+
+    expect(configActions["configManager"].getConfig).toHaveBeenCalledTimes(1);
+    expect(configActions["configManager"].writeConfig).not.toHaveBeenCalled();
+    expect(consoleLogSpy).toHaveBeenCalledWith("Key does not exist in the configuration: nonexistentKey");
+  });
+});

package/tests/commands/config.test.ts

@@ -0,0 +1,54 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeConfigCommands } from "../../src/commands/config";
+import { ConfigActions } from "../../src/commands/config/getSetReset";
+
+vi.mock("../../src/commands/config/getSetReset");
+
+describe("config commands", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeConfigCommands(program);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("ConfigActions.set is called with the correct key-value pair", async () => {
+    program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.set).toHaveBeenCalledWith("defaultNetwork=testnet");
+  });
+
+  test("ConfigActions.get is called with a specific key", async () => {
+    program.parse(["node", "test", "config", "get", "defaultNetwork"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.get).toHaveBeenCalledWith("defaultNetwork");
+  });
+
+  test("ConfigActions.get is called without a key", async () => {
+    program.parse(["node", "test", "config", "get"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.get).toHaveBeenCalledWith(undefined);
+  });
+
+  test("ConfigActions.reset is called with the correct key", async () => {
+    program.parse(["node", "test", "config", "reset", "defaultNetwork"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.reset).toHaveBeenCalledWith("defaultNetwork");
+  });
+
+  test("ConfigActions is instantiated when the command is executed", async () => {
+    program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+  });
+
+  test("ConfigActions.set is called without throwing errors for valid input", async () => {
+    program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"]);
+    vi.mocked(ConfigActions.prototype.set).mockReturnValue();
+    expect(() => program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"])).not.toThrow();
+  });
+});

package/tests/index.test.ts

@@ -17,6 +17,10 @@ vi.mock("../src/commands/keygen", () => ({
   initializeKeygenCommands: vi.fn(),
 }));
 
+vi.mock("../src/commands/config", () => ({
+  initializeConfigCommands: vi.fn(),
+}));
+
 
 describe("CLI", () => {
   it("should initialize CLI", () => {