genlayer 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -1,6 +1,11 @@
 
 
-## 0.3.1 (2024-11-19)
+## 0.4.0 (2024-11-22)
+
+
+### Features
+
+* new reset db option ([#139](https://github.com/yeagerai/genlayer-cli/issues/139)) ([e3fed64](https://github.com/yeagerai/genlayer-cli/commit/e3fed6437e7313002685258aeced710a6fd63f4f))
 
 ## 0.3.0 (2024-11-15)
 

package/dist/index.js

@@ -46421,7 +46421,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.3.1";
+var version = "0.4.0";
 
 // src/lib/config/text.ts
 var CLI_DESCRIPTION = "GenLayer CLI is a development environment for the GenLayer ecosystem. It allows developers to interact with the protocol by creating accounts, sending transactions, and working with Intelligent Contracts by testing, debugging, and deploying them.";
@@ -47022,9 +47022,12 @@ var MissingRequirementError = class extends Error {
 // src/lib/clients/system.ts
 function checkCommand(command, toolName) {
   return __async(this, null, function* () {
-    const { stderr } = yield import_node_util5.default.promisify(import_child_process.exec)(command);
-    if (stderr) {
-      throw new MissingRequirementError(toolName);
+    try {
+      yield import_node_util5.default.promisify(import_child_process.exec)(command);
+    } catch (error) {
+      if (error.stderr) {
+        throw new MissingRequirementError(toolName);
+      }
     }
   });
 }
@@ -47331,6 +47334,16 @@ var SimulatorService = class {
       return true;
     });
   }
+  cleanDatabase() {
+    return __async(this, null, function* () {
+      try {
+        yield rpcClient.request({ method: "sim_clearDbTables", params: [["current_state", "transactions"]] });
+      } catch (error) {
+        console.error(error);
+      }
+      return true;
+    });
+  }
 };
 var simulator_default = new SimulatorService();
 
@@ -50097,6 +50110,9 @@ function initAction(options, simulatorService) {
       console.error(error);
       return;
     }
+    if (options.resetDb) {
+      yield simulatorService.cleanDatabase();
+    }
     let successMessage = "GenLayer simulator initialized successfully! ";
     successMessage += options.headless ? "" : `Go to ${simulatorService.getFrontendUrl()} in your browser to access it.`;
     console.log(successMessage);
@@ -50113,7 +50129,7 @@ function initAction(options, simulatorService) {
 // src/commands/general/start.ts
 function startAction(options, simulatorService) {
   return __async(this, null, function* () {
-    const { resetValidators, numValidators, branch, location, headless } = options;
+    const { resetValidators, numValidators, branch, location, headless, resetDb } = options;
     simulatorService.setComposeOptions(headless);
     simulatorService.setSimulatorLocation(location);
     const restartValidatorsHintText = resetValidators ? `creating new ${numValidators} random validators` : "keeping the existing validators";
@@ -50150,6 +50166,9 @@ function startAction(options, simulatorService) {
       console.error(error);
       return;
     }
+    if (resetDb) {
+      yield simulatorService.cleanDatabase();
+    }
     if (resetValidators) {
       console.log("Initializing validators...");
       try {
@@ -50195,8 +50214,8 @@ function startAction(options, simulatorService) {
 
 // src/commands/general/index.ts
 function initializeGeneralCommands(program2) {
-  program2.command("init").description("Initialize the GenLayer Environment").option("--numValidators <numValidators>", "Number of validators", "5").option("--branch <branch>", "Branch", "main").option("--location <folder>", "Location where it will be installed", process.cwd()).option("--headless", "Headless mode", false).action((options) => initAction(options, simulator_default));
-  program2.command("up").description("Starts GenLayer's simulator").option("--reset-validators", "Remove all current validators and create new random ones", false).option("--numValidators <numValidators>", "Number of validators", "5").option("--branch <branch>", "Branch", "main").option("--location <folder>", "Location where it will be installed", process.cwd()).option("--headless", "Headless mode", false).action((options) => startAction(options, simulator_default));
+  program2.command("init").description("Initialize the GenLayer Environment").option("--numValidators <numValidators>", "Number of validators", "5").option("--branch <branch>", "Branch", "main").option("--location <folder>", "Location where it will be installed", process.cwd()).option("--headless", "Headless mode", false).option("--reset-db", "Reset Database", false).action((options) => initAction(options, simulator_default));
+  program2.command("up").description("Starts GenLayer's simulator").option("--reset-validators", "Remove all current validators and create new random ones", false).option("--numValidators <numValidators>", "Number of validators", "5").option("--branch <branch>", "Branch", "main").option("--location <folder>", "Location where it will be installed", process.cwd()).option("--headless", "Headless mode", false).option("--reset-db", "Reset Database", false).action((options) => startAction(options, simulator_default));
   return program2;
 }
 

package/package.json

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

package/renovate.json

@@ -13,8 +13,7 @@
       "matchUpdateTypes": [
         "minor",
         "patch"
-      ],
-      "matchConfidence": ["very high", "high"]
+      ]
     }
   ]
 }

package/src/commands/general/index.ts

@@ -13,6 +13,7 @@ export function initializeGeneralCommands(program: Command) {
     .option("--branch <branch>", "Branch", "main")
     .option("--location <folder>", "Location where it will be installed", process.cwd())
     .option("--headless", "Headless mode", false)
+    .option("--reset-db", "Reset Database", false)
     .action((options: InitActionOptions) => initAction(options, simulatorService));
 
   program
@@ -23,6 +24,7 @@ export function initializeGeneralCommands(program: Command) {
     .option("--branch <branch>", "Branch", "main")
     .option("--location <folder>", "Location where it will be installed", process.cwd())
     .option("--headless", "Headless mode", false)
+    .option("--reset-db", "Reset Database", false)
     .action((options: StartActionOptions) => startAction(options, simulatorService));
 
   return program;

package/src/commands/general/init.ts

@@ -7,6 +7,7 @@ export interface InitActionOptions {
   branch: string;
   location: string;
   headless: boolean;
+  resetDb: boolean;
 }
 
 function getRequirementsErrorMessage({git, docker}: Record<string, boolean>): string {
@@ -225,6 +226,10 @@ export async function initAction(options: InitActionOptions, simulatorService: I
     return;
   }
 
+  if(options.resetDb){
+    await simulatorService.cleanDatabase()
+  }
+
   // Simulator ready
   let successMessage = "GenLayer simulator initialized successfully! "
   successMessage += options.headless ? '' :  `Go to ${simulatorService.getFrontendUrl()} in your browser to access it.`;

package/src/commands/general/start.ts

@@ -8,10 +8,11 @@ export interface StartActionOptions {
   branch: string;
   location: string;
   headless: boolean;
+  resetDb: boolean
 }
 
 export async function startAction(options: StartActionOptions, simulatorService: ISimulatorService) {
-  const {resetValidators, numValidators, branch, location, headless} = options;
+  const {resetValidators, numValidators, branch, location, headless, resetDb} = options;
   // Update simulator location with user input
   simulatorService.setComposeOptions(headless);
   simulatorService.setSimulatorLocation(location);
@@ -60,6 +61,10 @@ export async function startAction(options: StartActionOptions, simulatorService:
     return;
   }
 
+  if(resetDb){
+    await simulatorService.cleanDatabase()
+  }
+
   if (resetValidators) {
     // Initializing validators
     console.log("Initializing validators...");

package/src/lib/clients/system.ts

@@ -6,9 +6,12 @@ import {RunningPlatform, AVAILABLE_PLATFORMS} from "../config/simulator";
 import {MissingRequirementError} from "../errors/missingRequirement";
 
 export async function checkCommand(command: string, toolName: string): Promise<void> {
-  const {stderr} = await util.promisify(exec)(command);
-  if (stderr) {
-    throw new MissingRequirementError(toolName);
+  try {
+    await util.promisify(exec)(command);
+  }catch (error:any) {
+    if (error.stderr) {
+      throw new MissingRequirementError(toolName);
+    }
   }
 }
 

package/src/lib/interfaces/ISimulatorService.ts

@@ -20,6 +20,7 @@ export interface ISimulatorService {
   openFrontend(): Promise<boolean>;
   resetDockerContainers(): Promise<boolean>;
   resetDockerImages(): Promise<boolean>;
+  cleanDatabase(): Promise<boolean>;
 }
 
 export type DownloadSimulatorResultType = {

package/src/lib/services/simulator.ts

@@ -317,6 +317,17 @@ export class SimulatorService implements ISimulatorService {
 
     return true;
   }
+
+  public async cleanDatabase(): Promise<boolean> {
+
+    try {
+      await rpcClient.request({method: "sim_clearDbTables", params: [['current_state', 'transactions']]});
+    }catch (error) {
+      console.error(error);
+    }
+    return true;
+  }
+
 }
 
 export default new SimulatorService();

package/tests/actions/init.test.ts

@@ -7,7 +7,7 @@ import {mkdtempSync} from "fs";
 import {join} from "path";
 
 const tempDir = mkdtempSync(join(tmpdir(), "test-initAction-"));
-const defaultActionOptions = { numValidators: 5, branch: "main", location: tempDir, headless: false };
+const defaultActionOptions = { numValidators: 5, branch: "main", location: tempDir, headless: false, resetDb: false };
 
 describe("init action", () => {
   let error: ReturnType<any>;
@@ -188,7 +188,7 @@ describe("init action", () => {
     );
   });
 
-  test("should open the frontend if everything went well (headless mode)", async () => {
+  test("should open the frontend if everything went well (custom options)", async () => {
     inquirerPrompt.mockResolvedValue({
       confirmReset: true,
       confirmDownload: true,
@@ -211,7 +211,7 @@ describe("init action", () => {
     simServResetDockerContainers.mockResolvedValue(true);
     simServResetDockerImages.mockResolvedValue(true);
 
-    await initAction({...defaultActionOptions, headless: true}, simulatorService);
+    await initAction({...defaultActionOptions, headless: true, resetDb: true}, simulatorService);
 
     expect(log).toHaveBeenCalledWith(
       `GenLayer simulator initialized successfully! `
@@ -235,8 +235,12 @@ describe("init action", () => {
     simServWaitForSimulator.mockResolvedValue({ initialized: true });
     simServPullOllamaModel.mockResolvedValue(true);
     simServDeleteAllValidators.mockResolvedValue(true);
+    simServResetDockerContainers.mockResolvedValue(true);
+    simServResetDockerImages.mockResolvedValue(true);
     simServCreateRandomValidators.mockRejectedValue();
     simServOpenFrontend.mockResolvedValue(true);
+    simServResetDockerContainers.mockResolvedValue(true);
+    simServResetDockerImages.mockResolvedValue(true);
 
     await initAction({...defaultActionOptions, headless: true}, simulatorService);
 

package/tests/actions/start.test.ts

@@ -15,6 +15,7 @@ describe("startAction - Additional Tests", () => {
     branch: "main",
     location: '',
     headless: false,
+    resetDb: false
   };
 
   beforeEach(() => {
@@ -36,6 +37,7 @@ describe("startAction - Additional Tests", () => {
         { name: "Provider B", value: "providerB" },
       ]),
       getFrontendUrl: vi.fn(() => "http://localhost:8080"),
+      cleanDatabase: vi.fn().mockResolvedValue(undefined),
     } as unknown as ISimulatorService;
   });
 
@@ -59,8 +61,8 @@ describe("startAction - Additional Tests", () => {
     expect(simulatorService.openFrontend).toHaveBeenCalled();
   });
 
-  test("runs successfully with default options and keeps existing validators (headless)", async () => {
-    await startAction({...defaultOptions, headless: true}, simulatorService);
+  test("runs successfully with custom options and keeps existing validators", async () => {
+    await startAction({...defaultOptions, headless: true, resetDb: true}, simulatorService);
 
     expect(simulatorService.updateSimulator).toHaveBeenCalledWith("main");
     expect(simulatorService.runSimulator).toHaveBeenCalled();

package/tests/commands/init.test.ts

@@ -5,6 +5,13 @@ import { getCommand, getCommandOption } from "../utils";
 import simulatorService from  '../../src/lib/services/simulator'
 
 const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
+const defaultOptions = {
+  numValidators: "5",
+  branch: "main",
+  location: process.cwd(),
+  headless: false,
+  resetDb: false
+}
 
 vi.mock("inquirer", () => ({
   prompt: vi.fn(() => {}),
@@ -74,13 +81,13 @@ describe("init command", () => {
   test("action is called", async () => {
     program.parse(["node", "test", "init"]);
     expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({ numValidators: "5", branch: "main", location: process.cwd(), headless: false });
+    expect(action).toHaveBeenCalledWith(defaultOptions);
   });
 
   test("option --headless is accepted", async () => {
     program.parse(["node", "test", "init", "--headless"]);
     expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({ numValidators: "5", branch: "main", location: process.cwd(), headless: true });
+    expect(action).toHaveBeenCalledWith({...defaultOptions, headless: true});
     expect(openFrontendSpy).not.toHaveBeenCalled();
   });
 });

package/tests/commands/up.test.ts

@@ -7,6 +7,14 @@ import simulatorService from  '../../src/lib/services/simulator'
 const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
 
 const action = vi.fn();
+const defaultOptions = {
+  resetValidators: false,
+  numValidators: "5",
+  branch: "main",
+  location: process.cwd(),
+  headless: false ,
+  resetDb: false
+}
 
 describe("up command", () => {
   let upCommand: Command;
@@ -72,7 +80,7 @@ describe("up command", () => {
   test("action is called with default options", async () => {
     program.parse(["node", "test", "up"]);
     expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({ resetValidators: false, numValidators: "5", branch: "main", location: process.cwd(), headless: false });
+    expect(action).toHaveBeenCalledWith(defaultOptions);
   });
 
   test("action is called with custom options", async () => {
@@ -86,16 +94,12 @@ describe("up command", () => {
       "--branch",
       "development",
       "--headless",
+      "true",
+      "--reset-db",
       "true"
     ]);
     expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({
-      resetValidators: true,
-      numValidators: "10",
-      branch: "development",
-      location: process.cwd(),
-      headless: true,
-    });
+    expect(action).toHaveBeenCalledWith({...defaultOptions, headless: true, branch: 'development', numValidators: '10', resetValidators: true, resetDb: true});
     expect(openFrontendSpy).not.toHaveBeenCalled();
   });
 });

package/tests/libs/system.test.ts

@@ -88,7 +88,7 @@ describe("System Functions - Error Paths", () => {
   });
 
   test("checkCommand returns false if the command does not exist", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject({
       stdout: "",
       stderr: "command not found"
     }));

package/tests/services/simulator.test.ts

@@ -281,6 +281,12 @@ describe("SimulatorService - Basic Tests", () => {
     expect(simulatorService.getAiProvidersOptions(false)).toEqual(expect.any(Array));
   });
 
+  test("clean simulator should success", async () => {
+    vi.mocked(rpcClient.request).mockResolvedValueOnce('Success');
+    await expect(simulatorService.cleanDatabase).not.toThrow();
+    expect(rpcClient.request).toHaveBeenCalledWith({ method: "sim_clearDbTables", params: [['current_state', 'transactions']] });
+  });
+
 });
 describe("SimulatorService - Docker Tests", () => {
   let mockExec: Mock;