@ollie-shop/cli 0.2.0 → 0.3.0

package/src/commands/__tests__/store-version.test.ts

@@ -0,0 +1,405 @@
+import type { Command } from "@commander-js/extra-typings";
+import {
+  storeFactory,
+  versionFactory,
+} from "@ollie-shop/core/__tests__/factories";
+import {
+  createTestProgram,
+  executeCLI,
+  resetCLIMocks,
+} from "@tests/helpers/cli-test-helper";
+import { createMockCore } from "@tests/mocks";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { registerStoreVersionCommands } from "../store-version";
+
+// Mock the version actions module
+vi.mock("../../actions/version.actions", () => ({
+  create: vi.fn(),
+  list: vi.fn(),
+  get: vi.fn(),
+  setDefault: vi.fn(),
+  activate: vi.fn(),
+  deactivate: vi.fn(),
+  clone: vi.fn(),
+  deleteVersion: vi.fn(),
+}));
+
+// Import mocked actions
+import * as versionActions from "../../actions/version.actions";
+
+describe("Store Version Command", () => {
+  let program: Command;
+  let _mockCore: ReturnType<typeof createMockCore>;
+
+  beforeEach(() => {
+    const testSetup = createTestProgram();
+    program = testSetup.program;
+    _mockCore = createMockCore();
+
+    // Register the store-version commands
+    registerStoreVersionCommands(program);
+
+    // Reset all mocks
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    resetCLIMocks();
+  });
+
+  describe("create subcommand", () => {
+    it("should create a version with required options", async () => {
+      // Arrange
+      const newVersion = versionFactory.build({
+        name: "test-version",
+        template: "default",
+        active: true,
+      });
+
+      vi.mocked(versionActions.create).mockResolvedValue(newVersion);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        "test-version",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.create).toHaveBeenCalledWith({
+        store: "123e4567-e89b-12d3-a456-426614174000",
+        name: "test-version",
+        template: "default",
+        active: true,
+      });
+    });
+
+    it("should create an inactive version when --no-active is specified", async () => {
+      // Arrange
+      const newVersion = versionFactory.build({
+        name: "test-version",
+        active: false,
+      });
+
+      vi.mocked(versionActions.create).mockResolvedValue(newVersion);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        "test-version",
+        "--no-active",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.create).toHaveBeenCalledWith({
+        store: "123e4567-e89b-12d3-a456-426614174000",
+        name: "test-version",
+        template: "default",
+        active: false,
+      });
+    });
+
+    it("should handle validation errors for invalid store ID", async () => {
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "invalid-uuid",
+        "--name",
+        "test-version",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.create).not.toHaveBeenCalled();
+    });
+
+    it("should handle missing required options", async () => {
+      // Act
+      const result = await executeCLI(program, ["store-version", "create"]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.create).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("list subcommand", () => {
+    it("should list versions for a store", async () => {
+      // Arrange
+      const store = storeFactory.build();
+      const versions = [
+        versionFactory.build({
+          storeId: store.id,
+          name: "Production",
+          default: true,
+        }),
+        versionFactory.build({
+          storeId: store.id,
+          name: "Staging",
+          default: false,
+        }),
+      ];
+
+      vi.mocked(versionActions.list).mockResolvedValue(versions);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "list",
+        "--store",
+        store.id,
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.list).toHaveBeenCalledWith({
+        store: store.id,
+      });
+    });
+
+    it("should handle validation errors for invalid store ID", async () => {
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "list",
+        "--store",
+        "invalid-uuid",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.list).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("get subcommand", () => {
+    it("should get version details by ID", async () => {
+      // Arrange
+      const version = versionFactory.build();
+      vi.mocked(versionActions.get).mockResolvedValue(version);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "get",
+        version.id,
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.get).toHaveBeenCalledWith(version.id);
+    });
+
+    it("should handle validation errors for invalid version ID", async () => {
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "get",
+        "invalid-uuid",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.get).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("set-default subcommand", () => {
+    it("should set a version as default", async () => {
+      // Arrange
+      const version = versionFactory.build();
+      const defaultVersion = { ...version, default: true };
+      vi.mocked(versionActions.setDefault).mockResolvedValue(defaultVersion);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "set-default",
+        version.id,
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.setDefault).toHaveBeenCalledWith(version.id);
+    });
+  });
+
+  describe("activate subcommand", () => {
+    it("should activate a version", async () => {
+      // Arrange
+      const version = versionFactory.build({ active: false });
+      const activeVersion = { ...version, active: true };
+      vi.mocked(versionActions.activate).mockResolvedValue(activeVersion);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "activate",
+        version.id,
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.activate).toHaveBeenCalledWith(version.id);
+    });
+  });
+
+  describe("deactivate subcommand", () => {
+    it("should deactivate a version", async () => {
+      // Arrange
+      const version = versionFactory.build({ active: true });
+      const inactiveVersion = { ...version, active: false };
+      vi.mocked(versionActions.deactivate).mockResolvedValue(inactiveVersion);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "deactivate",
+        version.id,
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.deactivate).toHaveBeenCalledWith(version.id);
+    });
+  });
+
+  describe("clone subcommand", () => {
+    it("should clone a version with a new name", async () => {
+      // Arrange
+      const originalVersion = versionFactory.build();
+      const clonedVersion = versionFactory.build({ name: "Cloned Version" });
+      vi.mocked(versionActions.clone).mockResolvedValue(clonedVersion);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "clone",
+        originalVersion.id,
+        "--name",
+        "Cloned Version",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.clone).toHaveBeenCalledWith(
+        originalVersion.id,
+        "Cloned Version",
+      );
+    });
+
+    it("should handle missing name option", async () => {
+      // Arrange
+      const version = versionFactory.build();
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "clone",
+        version.id,
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.clone).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("delete subcommand", () => {
+    it("should delete a version", async () => {
+      // Arrange
+      const version = versionFactory.build();
+      vi.mocked(versionActions.deleteVersion).mockResolvedValue(undefined);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "delete",
+        version.id,
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.deleteVersion).toHaveBeenCalledWith(
+        version.id,
+        undefined,
+      );
+    });
+
+    it("should delete a version with force flag", async () => {
+      // Arrange
+      const version = versionFactory.build();
+      vi.mocked(versionActions.deleteVersion).mockResolvedValue(undefined);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "delete",
+        version.id,
+        "--force",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.deleteVersion).toHaveBeenCalledWith(
+        version.id,
+        true,
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("should handle action errors gracefully", async () => {
+      // Arrange
+      const error = new Error("Version creation failed");
+      vi.mocked(versionActions.create).mockRejectedValue(error);
+
+      // Act
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        "test-version",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("alias support", () => {
+    it("should work with sv alias", async () => {
+      // Arrange
+      const store = storeFactory.build();
+      const versions = [versionFactory.build({ storeId: store.id })];
+      vi.mocked(versionActions.list).mockResolvedValue(versions);
+
+      // Act
+      const result = await executeCLI(program, [
+        "sv",
+        "list",
+        "--store",
+        store.id,
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.list).toHaveBeenCalledWith({
+        store: store.id,
+      });
+    });
+  });
+});

package/src/commands/__tests__/version.test.ts

@@ -0,0 +1,71 @@
+import type { Command } from "@commander-js/extra-typings";
+import {
+  createTestProgram,
+  executeCLI,
+  resetCLIMocks,
+} from "@tests/helpers/cli-test-helper";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { configureVersionCommand } from "../version";
+
+// Mock the package.json to provide a test version
+vi.mock("../../package.json", () => ({
+  default: { version: "0.2.0" },
+}));
+
+// Mock the console utility
+vi.mock("../../utils/console", () => ({
+  console: {
+    info: vi.fn(),
+    error: vi.fn(),
+    success: vi.fn(),
+    warn: vi.fn(),
+    log: vi.fn(),
+  },
+}));
+
+// Import the mocked console
+import { console as mockConsole } from "../../utils/console";
+
+describe("Version Command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    const testSetup = createTestProgram();
+    program = testSetup.program;
+
+    // Configure the version command
+    configureVersionCommand(program);
+
+    // Reset all mocks
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    resetCLIMocks();
+  });
+
+  describe("version command", () => {
+    it("should display the CLI version", async () => {
+      // Act
+      const result = await executeCLI(program, ["version"]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(mockConsole.info).toHaveBeenCalledWith(
+        "Ollie Shop CLI version: 0.2.0",
+      );
+    });
+
+    it("should call the version command action", async () => {
+      // Act
+      const result = await executeCLI(program, ["version"]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(mockConsole.info).toHaveBeenCalledTimes(1);
+      expect(mockConsole.info).toHaveBeenCalledWith(
+        expect.stringContaining("Ollie Shop CLI version:"),
+      );
+    });
+  });
+});

package/src/commands/component.ts

@@ -0,0 +1,188 @@
+import type { Command } from "@commander-js/extra-typings";
+import * as componentActions from "../actions/component.actions";
+import {
+  ComponentBuildOptionsSchema,
+  type ComponentCreateOptions,
+  ComponentCreateOptionsSchema,
+  type ComponentDeployOptions,
+  ComponentDeployOptionsSchema,
+  ComponentValidateOptionsSchema,
+} from "../schemas/command.schema";
+import { buildCommand, buildCommandGroup } from "../utils/command-builder";
+import { COMMON_OPTIONS } from "../utils/command-parser";
+
+export function registerComponentCommands(program: Command): void {
+  const cmd = buildCommandGroup(
+    program,
+    "component",
+    "Manage Ollie Shop components",
+    ["comp"],
+  );
+
+  // Create component command
+  buildCommand(cmd, {
+    name: "create",
+    description: "Create a new component",
+    options: [
+      COMMON_OPTIONS.componentName,
+      COMMON_OPTIONS.componentSlot,
+      COMMON_OPTIONS.tests,
+      COMMON_OPTIONS.noTests,
+      {
+        flags: "-i, --interactive",
+        description: "Use interactive mode",
+        defaultValue: false,
+      },
+    ],
+    schema: ComponentCreateOptionsSchema,
+    examples: [
+      {
+        description: "Create a header component",
+        command: "ollieshop component create --name header --slot header",
+      },
+      {
+        description: "Create a component with TypeScript",
+        command: "ollieshop component create --name product-list --typescript",
+      },
+      {
+        description: "Interactive mode",
+        command: "ollieshop component create --interactive",
+      },
+      {
+        description: "Create with tests",
+        command: "ollieshop component create --name product-list",
+      },
+    ],
+    handler: async (options, console) => {
+      // Use interactive mode if requested
+      if ("interactive" in options && options.interactive) {
+        const { runInteractiveCommand } = await import(
+          "../utils/interactive-builder.js"
+        );
+        await runInteractiveCommand("component-create", console);
+        return;
+      }
+
+      await componentActions.createComponent(
+        options as ComponentCreateOptions,
+        console,
+      );
+    },
+  });
+
+  // Validate component command
+  buildCommand(cmd, {
+    name: "validate",
+    description: "Validate a component",
+    options: [COMMON_OPTIONS.path],
+    schema: ComponentValidateOptionsSchema,
+    examples: [
+      {
+        description: "Validate current directory",
+        command: "ollieshop component validate",
+      },
+      {
+        description: "Validate specific component",
+        command: "ollieshop component validate --path ./components/header",
+      },
+    ],
+    handler: async (options, console) => {
+      await componentActions.validateComponent(
+        {
+          path: options.path || process.cwd(),
+          strict: options.strict ?? false,
+          fix: options.fix ?? false,
+        },
+        console,
+      );
+    },
+  });
+
+  // Build component command
+  buildCommand(cmd, {
+    name: "build",
+    description: "Build a component",
+    options: [COMMON_OPTIONS.path, COMMON_OPTIONS.watch],
+    schema: ComponentBuildOptionsSchema,
+    examples: [
+      {
+        description: "Build current directory",
+        command: "ollieshop component build",
+      },
+      {
+        description: "Build specific component",
+        command: "ollieshop component build --path ./components/header",
+      },
+      {
+        description: "Build with watch mode",
+        command: "ollieshop component build --watch",
+      },
+    ],
+    handler: async (options, console) => {
+      await componentActions.buildComponent(
+        {
+          path: options.path || process.cwd(),
+          watch: options.watch ?? false,
+        },
+        console,
+      );
+    },
+  });
+
+  // Deploy component command
+  buildCommand(cmd, {
+    name: "deploy",
+    description: "Deploy a component",
+    options: [
+      {
+        flags: "--id <id>",
+        description: "Component ID",
+        required: true,
+      },
+      COMMON_OPTIONS.path,
+      {
+        flags: "--wait",
+        description: "Wait for deployment to complete",
+        defaultValue: false,
+      },
+    ],
+    schema: ComponentDeployOptionsSchema,
+    examples: [
+      {
+        description: "Deploy a component",
+        command: "ollieshop component deploy --id comp-123",
+      },
+      {
+        description: "Deploy and wait for completion",
+        command: "ollieshop component deploy --id comp-123 --wait",
+      },
+    ],
+    handler: async (options: ComponentDeployOptions, console) => {
+      // Map id to componentId if provided
+      const deployOptions = {
+        path: options.path,
+        componentId: options.id || options.componentId,
+        wait: options.wait,
+      };
+      await componentActions.deployComponent(deployOptions, console);
+    },
+  });
+
+  // List components command
+  buildCommand(cmd, {
+    name: "list",
+    description: "List all components",
+    aliases: ["ls"],
+    examples: [
+      {
+        description: "List all components",
+        command: "ollieshop component list",
+      },
+    ],
+    handler: async (_, console) => {
+      await componentActions.listComponents(console);
+    },
+  });
+
+  // Add more commands as needed
+}

package/src/commands/docs.ts

@@ -1,24 +1,24 @@
-import chalk from "chalk";
-import type { Command } from "commander";
+import type { Command } from "@commander-js/extra-typings";
+import { console as cliConsole } from "../utils/console";
 
 export function configureDocsCommand(program: Command): void {
   program
     .command("docs")
     .description("Show documentation links for Ollie Shop")
     .action(() => {
-      console.log(chalk.cyanBright("\nOllie Shop Documentation\n"));
+      cliConsole.info("Ollie Shop Documentation\n");
 
-      console.log(
-        `${chalk.green("Main Docs:".padEnd(20))} https://docs.ollie.shop/ollie-shop`,
+      cliConsole.info(
+        `${"Main Docs:".padEnd(20)} https://docs.ollie.shop/ollie-shop`,
       );
-      console.log(
-        `${chalk.green("Components:".padEnd(20))} https://docs.ollie.shop/ollie-shop/concepts/component`,
+      cliConsole.info(
+        `${"Components:".padEnd(20)} https://docs.ollie.shop/ollie-shop/concepts/component`,
       );
-      console.log(
-        `${chalk.green("Functions:".padEnd(20))} https://docs.ollie.shop/ollie-shop/concepts/function`,
+      cliConsole.info(
+        `${"Functions:".padEnd(20)} https://docs.ollie.shop/ollie-shop/concepts/function`,
       );
-      console.log(
-        `${chalk.green("Versions:".padEnd(20))} https://docs.ollie.shop/ollie-shop/concepts/version\n`,
+      cliConsole.info(
+        `${"Versions:".padEnd(20)} https://docs.ollie.shop/ollie-shop/concepts/version\n`,
       );
     });
 }