@ollie-shop/cli 0.2.0 → 0.3.0

package/src/types/index.ts

@@ -0,0 +1,183 @@
+/**
+ * Shared type definitions for the CLI package
+ */
+
+import type { Ora } from "ora";
+
+/**
+ * CLI Error types
+ */
+export interface CLIError extends Error {
+  code?: string;
+  context?: ErrorContext;
+}
+
+export interface NodeError extends Error {
+  code: string;
+  errno?: number;
+  syscall?: string;
+  path?: string;
+}
+
+export interface ErrorContext {
+  command?: string;
+  file?: string;
+  input?: string;
+  attemptedCommand?: string;
+  path?: string;
+}
+
+/**
+ * Progress and spinner types
+ */
+export type Spinner = Ora;
+
+/**
+ * Command handler types
+ */
+export type CommandHandler<T = unknown> = (
+  options: T,
+  console: typeof import("../utils/console").console,
+) => Promise<void>;
+
+/**
+ * Build progress types
+ */
+export interface BuildProgressPayload {
+  emoji?: string;
+  step?: string;
+  message?: string;
+  startTime?: number;
+}
+
+/**
+ * CLI Progress bar options
+ */
+export interface ProgressBarOptions {
+  barCompleteString: string;
+  barIncompleteString: string;
+  barsize: number;
+}
+
+/**
+ * Progress bar params from cli-progress
+ */
+export interface ProgressParams {
+  progress: number;
+  value: number;
+  total: number;
+  eta: number;
+  startTime: number;
+  stopTime: number | null;
+  duration: number;
+}
+
+/**
+ * Progress bar payload that can contain custom data
+ */
+export interface ProgressPayload {
+  emoji?: string;
+  step?: string;
+  message?: string;
+  startTime?: number;
+  [key: string]: unknown;
+}
+
+/**
+ * Generic formatter for progress bars
+ * Matches cli-progress GenericFormatter interface
+ */
+export type ProgressFormatter = (
+  options: {
+    barCompleteString?: string;
+    barIncompleteString?: string;
+    barsize?: number;
+    [key: string]: unknown;
+  },
+  params: ProgressParams,
+  payload: ProgressPayload,
+) => string;
+
+/**
+ * Interactive command types
+ */
+export interface InteractiveChoice {
+  name: string;
+  value: string;
+  short?: string;
+}
+
+/**
+ * Mock data types for development
+ */
+export interface MockComponent {
+  id: string;
+  name: string;
+  slot: string;
+  version: string;
+  enabled: boolean;
+  createdAt: string;
+  type?: string;
+  description?: string;
+}
+
+export interface MockFunction {
+  id: string;
+  name: string;
+  runtime?: string;
+  version?: string;
+  enabled: boolean;
+  createdAt: string;
+  event?: string;
+  timing?: string;
+  description?: string;
+}
+
+/**
+ * CLI Error with exit code for process control
+ */
+export interface CLIError extends Error {
+  exitCode?: number;
+  isValidationError?: boolean;
+}
+
+/**
+ * Type guards
+ */
+export function isNodeError(error: unknown): error is NodeError {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    typeof (error as NodeError).code === "string"
+  );
+}
+
+export function isCLIError(error: unknown): error is CLIError {
+  return error instanceof Error && "context" in error;
+}
+
+/**
+ * Command option types without index signatures
+ */
+export interface BaseCommandOptions {
+  verbose?: boolean;
+  quiet?: boolean;
+  debug?: boolean;
+}
+
+export interface PathCommandOptions extends BaseCommandOptions {
+  path?: string;
+}
+
+export interface WatchCommandOptions extends PathCommandOptions {
+  watch?: boolean;
+}
+
+export interface BuildCommandOptions extends WatchCommandOptions {
+  minify?: boolean;
+  sourcemap?: boolean;
+}
+
+export interface DeployCommandOptions extends PathCommandOptions {
+  wait?: boolean;
+}

package/src/utils/__tests__/command-parser.test.ts

@@ -0,0 +1,159 @@
+import { InvalidArgumentError } from "@commander-js/extra-typings";
+import { describe, expect, it } from "vitest";
+import {
+  parseBooleanOption,
+  parseComponentName,
+  parseComponentSlot,
+  parseFunctionInvocation,
+  parseFunctionName,
+  parsePath,
+} from "../command-parser";
+
+describe("Command Parsers", () => {
+  describe("parseComponentName", () => {
+    it("should accept valid component names", () => {
+      expect(parseComponentName("header-nav")).toBe("header-nav");
+      expect(parseComponentName("shopping-cart")).toBe("shopping-cart");
+      expect(parseComponentName("product-list-2")).toBe("product-list-2");
+    });
+
+    it("should reject invalid component names", () => {
+      expect(() => parseComponentName("")).toThrow(InvalidArgumentError);
+      expect(() => parseComponentName("Test")).toThrow(
+        /lowercase with hyphens/,
+      );
+      expect(() => parseComponentName("test component")).toThrow(
+        /lowercase with hyphens/,
+      );
+      expect(() => parseComponentName("test_component")).toThrow(
+        /lowercase with hyphens/,
+      );
+      expect(() => parseComponentName("Test-Component")).toThrow(
+        /lowercase with hyphens/,
+      );
+    });
+
+    it("should provide helpful error messages", () => {
+      try {
+        parseComponentName("TestComponent");
+      } catch (error) {
+        expect(error).toBeInstanceOf(InvalidArgumentError);
+        expect(error.message).toContain("Invalid component name");
+        expect(error.message).toContain(
+          "Component names must be lowercase with hyphens only",
+        );
+        expect(error.message).toContain("Examples:");
+      }
+    });
+  });
+
+  describe("parseFunctionName", () => {
+    it("should accept valid function names", () => {
+      expect(parseFunctionName("validate-order")).toBe("validate-order");
+      expect(parseFunctionName("apply-discount")).toBe("apply-discount");
+      expect(parseFunctionName("check-inventory-v2")).toBe(
+        "check-inventory-v2",
+      );
+    });
+
+    it("should reject invalid function names", () => {
+      expect(() => parseFunctionName("")).toThrow(InvalidArgumentError);
+      expect(() => parseFunctionName("ValidateOrder")).toThrow(
+        /lowercase with hyphens/,
+      );
+      expect(() => parseFunctionName("validate order")).toThrow(
+        /lowercase with hyphens/,
+      );
+    });
+  });
+
+  describe("parseComponentSlot", () => {
+    it("should accept valid slots", () => {
+      expect(parseComponentSlot("header")).toBe("header");
+      expect(parseComponentSlot("main")).toBe("main");
+      expect(parseComponentSlot("sidebar")).toBe("sidebar");
+      expect(parseComponentSlot("footer")).toBe("footer");
+    });
+
+    it("should reject invalid slots", () => {
+      expect(() => parseComponentSlot("invalid")).toThrow(InvalidArgumentError);
+      expect(() => parseComponentSlot("")).toThrow(InvalidArgumentError);
+    });
+
+    it("should provide list of valid slots in error", () => {
+      try {
+        parseComponentSlot("invalid");
+      } catch (error) {
+        expect(error.message).toContain(
+          "Valid slots: header, footer, sidebar, main, checkout-summary, payment-method, shipping-method, customer-info, order-confirmation",
+        );
+      }
+    });
+  });
+
+  describe("parseFunctionInvocation", () => {
+    it("should accept valid invocations", () => {
+      expect(parseFunctionInvocation("request")).toBe("request");
+      expect(parseFunctionInvocation("response")).toBe("response");
+    });
+
+    it("should reject invalid invocations", () => {
+      expect(() => parseFunctionInvocation("invalid")).toThrow(
+        InvalidArgumentError,
+      );
+    });
+
+    it("should provide list of valid invocations in error", () => {
+      try {
+        parseFunctionInvocation("invalid");
+      } catch (error) {
+        expect(error.message).toContain("request");
+        expect(error.message).toContain("response");
+      }
+    });
+  });
+
+  describe("parseBooleanOption", () => {
+    it("should parse truthy values", () => {
+      expect(parseBooleanOption("true")).toBe(true);
+      expect(parseBooleanOption("TRUE")).toBe(true);
+      expect(parseBooleanOption("yes")).toBe(true);
+      expect(parseBooleanOption("y")).toBe(true);
+      expect(parseBooleanOption("1")).toBe(true);
+    });
+
+    it("should parse falsy values", () => {
+      expect(parseBooleanOption("false")).toBe(false);
+      expect(parseBooleanOption("FALSE")).toBe(false);
+      expect(parseBooleanOption("no")).toBe(false);
+      expect(parseBooleanOption("n")).toBe(false);
+      expect(parseBooleanOption("0")).toBe(false);
+    });
+
+    it("should reject invalid values", () => {
+      expect(() => parseBooleanOption("maybe")).toThrow(InvalidArgumentError);
+      expect(() => parseBooleanOption("")).toThrow(InvalidArgumentError);
+    });
+
+    it("should provide helpful error message", () => {
+      try {
+        parseBooleanOption("invalid");
+      } catch (error) {
+        expect(error.message).toContain("Use true/false, yes/no, or 1/0");
+      }
+    });
+  });
+
+  describe("parsePath", () => {
+    it("should accept valid paths", () => {
+      expect(parsePath("./components/header")).toBe("./components/header");
+      expect(parsePath("/absolute/path")).toBe("/absolute/path");
+      expect(parsePath("relative/path")).toBe("relative/path");
+    });
+
+    it("should reject empty paths", () => {
+      expect(() => parsePath("")).toThrow(InvalidArgumentError);
+      expect(() => parsePath("")).toThrow(/cannot be empty/);
+    });
+  });
+});

package/src/utils/__tests__/command-suggestions.test.ts

@@ -0,0 +1,185 @@
+import * as fs from "node:fs";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { CommandSuggestions } from "../command-suggestions";
+import type { CliConsole } from "../console";
+
+// Mock the fs module
+vi.mock("fs");
+
+describe("CommandSuggestions", () => {
+  let mockConsole: CliConsole;
+  let suggestions: CommandSuggestions;
+
+  beforeEach(() => {
+    // Create a mock console
+    mockConsole = {
+      log: vi.fn(),
+      error: vi.fn(),
+      warn: vi.fn(),
+      info: vi.fn(),
+      success: vi.fn(),
+      dim: vi.fn(),
+      bold: vi.fn(),
+      list: vi.fn(),
+      table: vi.fn(),
+      json: vi.fn(),
+      spinner: vi.fn(),
+      confirm: vi.fn(),
+      prompt: vi.fn(),
+      setOptions: vi.fn(),
+      group: vi.fn(),
+      groupEnd: vi.fn(),
+      separator: vi.fn(),
+      suggestions: vi.fn(),
+      debug: vi.fn(),
+      nextSteps: vi.fn(),
+    };
+    suggestions = new CommandSuggestions(mockConsole);
+    vi.clearAllMocks();
+
+    // Mock process.cwd
+    vi.spyOn(process, "cwd").mockReturnValue("/test/project");
+  });
+
+  describe("show", () => {
+    it("should show suggestions for component directory", () => {
+      // Mock component detection
+      vi.mocked(fs.existsSync).mockImplementation((path) => {
+        if (path.toString().includes("package.json")) return true;
+        if (path.toString().includes("meta.json")) return true;
+        if (path.toString().includes("index.tsx")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({ type: "component", name: "header-nav" }),
+      );
+
+      suggestions.show();
+
+      // Check context display
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("You're in a component directory: header-nav"),
+      );
+
+      // Check component commands
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Common commands for this component:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("validate"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("build"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("deploy"),
+      );
+
+      // Check tip
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Run 'ollieshop dev' to start developing"),
+      );
+    });
+
+    it("should show suggestions for function directory", () => {
+      // Mock function detection - ensure we ONLY return true for function files
+      vi.mocked(fs.existsSync).mockImplementation((path) => {
+        const pathStr = path.toString();
+        // Check for function-specific files
+        const isFunctionFile =
+          pathStr.includes("package.json") ||
+          pathStr.includes("meta.json") ||
+          (pathStr.includes("index.ts") && !pathStr.includes("index.tsx"));
+        return isFunctionFile;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({ type: "function", name: "validate-order" }),
+      );
+
+      suggestions.show();
+
+      // Check context display
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "You're in a function directory: validate-order",
+        ),
+      );
+
+      // Check function commands
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Common commands for this function:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("test"),
+      );
+
+      // Check tip
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Run 'ollieshop test' to test this function"),
+      );
+    });
+
+    it("should show suggestions for project root", () => {
+      // Mock project root detection
+      vi.mocked(fs.existsSync).mockImplementation((path) => {
+        if (path.toString().includes("components")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+
+      suggestions.show();
+
+      // Check context display
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("You're in the project root"),
+      );
+
+      // Check general commands
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Common commands:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("component create"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("function create"),
+      );
+
+      // Check tip
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "Navigate to a component with 'cd components/<name>'",
+        ),
+      );
+    });
+
+    it("should show recent commands for component", () => {
+      // Mock component detection
+      vi.mocked(fs.existsSync).mockImplementation((path) => {
+        if (path.toString().includes("package.json")) return true;
+        if (path.toString().includes("meta.json")) return true;
+        if (path.toString().includes("index.tsx")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({ type: "component" }),
+      );
+
+      suggestions.show();
+
+      // Check recent commands section
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Recent commands:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("validate --fix"),
+      );
+    });
+  });
+});