@ollie-shop/cli 0.3.4 → 1.0.1

package/src/utils/__tests__/rich-progress.test.ts

@@ -1,181 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { CliConsole } from "../console";
-import { RichProgressReporter, SimpleProgressReporter } from "../rich-progress";
-
-// Mock cli-progress
-vi.mock("cli-progress", () => {
-  const mockBar = {
-    update: vi.fn(),
-  };
-
-  const mockMultiBar = {
-    create: vi.fn().mockReturnValue(mockBar),
-    stop: vi.fn(),
-  };
-
-  return {
-    default: {
-      MultiBar: vi.fn(() => mockMultiBar),
-      Presets: {
-        shades_classic: {},
-      },
-    },
-  };
-});
-
-// Mock ora
-vi.mock("ora", () => ({
-  default: vi.fn(() => ({
-    start: vi.fn().mockReturnThis(),
-    succeed: vi.fn(),
-    fail: vi.fn(),
-    text: "",
-  })),
-}));
-
-describe("RichProgressReporter", () => {
-  let reporter: RichProgressReporter;
-  let mockConsole: CliConsole;
-  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    // Create a mock console with all required methods
-    mockConsole = {
-      info: vi.fn(),
-      success: vi.fn(),
-      error: vi.fn(),
-      warn: vi.fn(),
-      debug: vi.fn(),
-      log: vi.fn(),
-    } as unknown as CliConsole;
-
-    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {
-      // Intentionally empty for test isolation
-    });
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    consoleLogSpy.mockRestore();
-  });
-
-  it("should start progress tracking", () => {
-    reporter = new RichProgressReporter(mockConsole);
-    reporter.start();
-
-    expect(mockConsole.info).toHaveBeenCalledWith(
-      expect.stringContaining("🚀 Starting deployment..."),
-    );
-  });
-
-  it("should update progress with build status", () => {
-    reporter = new RichProgressReporter(mockConsole);
-
-    const progress = {
-      phase: "build",
-      message: "Bundling files...",
-      progress: 0.5,
-    };
-
-    // Just verify no errors
-    expect(() => reporter.updateProgress(progress)).not.toThrow();
-  });
-
-  it("should show success summary", () => {
-    // Test just the summary method
-    const reporter = new RichProgressReporter(mockConsole);
-    // Access private method for testing
-    const reporterWithPrivate = reporter as unknown as {
-      showSuccessSummary(): void;
-    };
-    reporterWithPrivate.showSuccessSummary();
-
-    expect(mockConsole.success).toHaveBeenCalledWith(
-      expect.stringContaining("✅ Deployment completed successfully!"),
-    );
-  });
-
-  it("should show failure message", () => {
-    // Create a minimal test that doesn't rely on bars
-    const reporter = new RichProgressReporter(mockConsole);
-    // Access private properties for testing
-    const reporterWithPrivate = reporter as unknown as {
-      multibar: { stop: () => void };
-      bars: Map<string, unknown>;
-    };
-    reporterWithPrivate.multibar = { stop: vi.fn() };
-    reporterWithPrivate.bars = new Map(); // Empty map
-
-    reporter.stop(false);
-
-    expect(mockConsole.error).toHaveBeenCalledWith(
-      expect.stringContaining("❌ Deployment failed"),
-    );
-  });
-
-  it("should display build stats when available", () => {
-    const reporter = new RichProgressReporter(mockConsole);
-
-    // Set stats directly for testing
-    const reporterWithPrivate = reporter as unknown as {
-      stats: { bundleSize?: number; gzippedSize?: number };
-    };
-    reporterWithPrivate.stats = {
-      bundleSize: 150000,
-      gzippedSize: 50000,
-    };
-
-    // Call the summary method
-    const reporterWithSummary = reporter as unknown as {
-      showSuccessSummary(): void;
-    };
-    reporterWithSummary.showSuccessSummary();
-
-    expect(mockConsole.info).toHaveBeenCalledWith(
-      expect.stringContaining("📊 Build Stats:"),
-    );
-    expect(mockConsole.info).toHaveBeenCalledWith(
-      expect.stringContaining("Bundle size: 146.5KB"),
-    );
-  });
-});
-
-describe("SimpleProgressReporter", () => {
-  let reporter: SimpleProgressReporter;
-
-  beforeEach(() => {
-    reporter = new SimpleProgressReporter("Testing...");
-    vi.clearAllMocks();
-  });
-
-  it("should start spinner", () => {
-    reporter.start();
-
-    // Spinner is mocked, verify no errors
-    expect(() => reporter.start()).not.toThrow();
-  });
-
-  it("should update message", () => {
-    reporter.start();
-    reporter.update("New message");
-
-    // Update is mocked, verify no errors
-    expect(() => reporter.update("test")).not.toThrow();
-  });
-
-  it("should succeed with message", () => {
-    reporter.start();
-    reporter.succeed("Success!");
-
-    // Success is mocked, verify no errors
-    expect(() => reporter.succeed()).not.toThrow();
-  });
-
-  it("should fail with message", () => {
-    reporter.start();
-    reporter.fail("Failed!");
-
-    // Fail is mocked, verify no errors
-    expect(() => reporter.fail()).not.toThrow();
-  });
-});

package/src/utils/__tests__/validation-error-formatter.test.ts

@@ -1,175 +0,0 @@
-import { createMockConsole } from "@tests/mocks";
-import { beforeEach, describe, expect, it } from "vitest";
-import { z } from "zod";
-import {
-  displayErrors,
-  formatZodError,
-  suggestCommand,
-} from "../validation-error-formatter";
-
-describe("validation-error-formatter", () => {
-  let mockConsole: ReturnType<typeof createMockConsole>;
-
-  beforeEach(() => {
-    mockConsole = createMockConsole();
-  });
-
-  describe("formatZodError", () => {
-    it("should format required field errors", () => {
-      const schema = z.object({
-        name: z.string(),
-      });
-
-      const result = schema.safeParse({});
-      if (!result.success) {
-        const errors = formatZodError(result.error);
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toEqual({
-          field: "name",
-          message: "Name is required",
-        });
-      } else {
-        throw new Error("Expected validation to fail");
-      }
-    });
-
-    it("should format regex validation errors", () => {
-      const schema = z.object({
-        name: z.string().regex(/^[a-z-]+$/),
-      });
-
-      const result = schema.safeParse({ name: "TestComponent" });
-      if (!result.success) {
-        const errors = formatZodError(result.error);
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toEqual({
-          field: "name",
-          message:
-            "Must be lowercase with hyphens only (e.g., 'my-component', 'header-nav')",
-        });
-      } else {
-        throw new Error("Expected validation to fail");
-      }
-    });
-
-    it("should format enum errors with suggestions", () => {
-      const schema = z.object({
-        slot: z.enum(["header", "main", "footer"]),
-      });
-
-      const result = schema.safeParse({ slot: "invalid" });
-      if (!result.success) {
-        const errors = formatZodError(result.error);
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toEqual({
-          field: "slot",
-          message: "Invalid Slot",
-          suggestedValue: "Valid options: header, main, footer",
-        });
-      } else {
-        throw new Error("Expected validation to fail");
-      }
-    });
-
-    it("should include examples when context is provided", () => {
-      const schema = z.object({
-        name: z.string(),
-      });
-
-      const result = schema.safeParse({});
-      if (!result.success) {
-        const errors = formatZodError(result.error, "component");
-        expect(errors[0].examples).toBeDefined();
-        expect(errors[0].examples?.[0]).toEqual({
-          description: "Create a header component",
-          command: "ollieshop component create --name header-nav --slot header",
-        });
-      } else {
-        throw new Error("Expected validation to fail");
-      }
-    });
-  });
-
-  describe("displayErrors", () => {
-    it("should display formatted errors", () => {
-      const errors = [
-        {
-          field: "name",
-          message: "Must be lowercase with hyphens",
-          suggestedValue: "Valid format: my-component",
-        },
-      ];
-
-      displayErrors(mockConsole, errors);
-
-      expect(mockConsole.error).toHaveBeenCalledWith("❌ Validation failed:");
-      expect(mockConsole.error).toHaveBeenCalledWith(
-        "  • name: Must be lowercase with hyphens",
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        "    💡 Valid format: my-component",
-      );
-    });
-
-    it("should display examples when provided", () => {
-      const errors = [
-        {
-          field: "name",
-          message: "Invalid format",
-          examples: [
-            {
-              description: "Create header",
-              command: "ollieshop component create --name header",
-            },
-          ],
-        },
-      ];
-
-      displayErrors(mockConsole, errors);
-
-      expect(mockConsole.log).toHaveBeenCalledWith("    📝 Examples:");
-      expect(mockConsole.log).toHaveBeenCalledWith("       Create header:");
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        "       $ ollieshop component create --name header",
-      );
-    });
-
-    it("should show help command when provided", () => {
-      const errors = [{ field: "name", message: "Required" }];
-
-      displayErrors(mockConsole, errors, "component create");
-
-      expect(mockConsole.info).toHaveBeenCalledWith(
-        "💡 For more help, run: ollieshop component create --help",
-      );
-    });
-  });
-
-  describe("suggestCommand", () => {
-    const commands = ["create", "list", "deploy", "validate", "build"];
-
-    it("should return exact matches", () => {
-      expect(suggestCommand("create", commands)).toBe("create");
-      expect(suggestCommand("CREATE", commands)).toBe("create");
-    });
-
-    it("should return commands that start with input", () => {
-      expect(suggestCommand("cr", commands)).toBe("create");
-      expect(suggestCommand("val", commands)).toBe("validate");
-    });
-
-    it("should return commands that contain input", () => {
-      expect(suggestCommand("ploy", commands)).toBe("deploy");
-    });
-
-    it("should return close matches with small typos", () => {
-      expect(suggestCommand("craete", commands)).toBe("create");
-      expect(suggestCommand("buidl", commands)).toBe("build");
-    });
-
-    it("should return undefined for no matches", () => {
-      expect(suggestCommand("xyz", commands)).toBeUndefined();
-      expect(suggestCommand("random", commands)).toBeUndefined();
-    });
-  });
-});

package/src/utils/__tests__/validation-helpers.test.ts

@@ -1,125 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  validateComponentName,
-  validateFunctionName,
-  validatePriority,
-  validateSemver,
-  validateUrl,
-  validateVersionName,
-} from "../validation-helpers";
-
-describe("Validation Helpers", () => {
-  describe("validateComponentName", () => {
-    it("should accept valid component names", () => {
-      expect(validateComponentName("my-component")).toBe(true);
-      expect(validateComponentName("header-123")).toBe(true);
-      expect(validateComponentName("a")).toBe(true);
-      expect(validateComponentName("component-with-many-parts")).toBe(true);
-    });
-
-    it("should reject invalid component names", () => {
-      expect(validateComponentName("My Component")).toContain(
-        "Component names must be lowercase with hyphens only",
-      );
-      expect(validateComponentName("UPPERCASE")).toContain(
-        "Component names must be lowercase with hyphens only",
-      );
-      expect(validateComponentName("special@char")).toContain(
-        "Component names must be lowercase with hyphens only",
-      );
-      expect(validateComponentName("")).toContain("required");
-      expect(validateComponentName("_underscore")).toContain(
-        "Component names must be lowercase with hyphens only",
-      );
-    });
-  });
-
-  describe("validateFunctionName", () => {
-    it("should accept valid function names", () => {
-      expect(validateFunctionName("my-function")).toBe(true);
-      expect(validateFunctionName("auth-handler")).toBe(true);
-      expect(validateFunctionName("process-order-v2")).toBe(true);
-    });
-
-    it("should reject invalid function names", () => {
-      expect(validateFunctionName("My Function")).toContain(
-        "Function names must be lowercase with hyphens only",
-      );
-      expect(validateFunctionName("function!")).toContain(
-        "Function names must be lowercase with hyphens only",
-      );
-      expect(validateFunctionName("")).toContain("required");
-    });
-  });
-
-  describe("validateVersionName", () => {
-    it("should accept valid version names", () => {
-      expect(validateVersionName("Production")).toBe(true);
-      expect(validateVersionName("v1.0")).toBe(true);
-      expect(validateVersionName("Development Branch")).toBe(true);
-    });
-
-    it("should reject invalid version names", () => {
-      expect(validateVersionName("")).toContain("required");
-      expect(validateVersionName("a".repeat(101))).toContain("too long");
-    });
-  });
-
-  describe("validatePriority", () => {
-    it("should accept valid priorities", () => {
-      expect(validatePriority(0)).toBe(true);
-      expect(validatePriority(50)).toBe(true);
-      expect(validatePriority(100)).toBe(true);
-    });
-
-    it("should reject invalid priorities", () => {
-      expect(validatePriority(-1)).toContain("between 0 and 100");
-      expect(validatePriority(101)).toContain("between 0 and 100");
-      expect(validatePriority(50.5)).toContain("whole number");
-      expect(validatePriority(Number.NaN)).toContain(
-        "Expected number, received nan",
-      );
-    });
-  });
-
-  describe("validateUrl", () => {
-    it("should accept valid URLs", () => {
-      expect(validateUrl("https://example.com")).toBe(true);
-      expect(validateUrl("http://localhost:3000")).toBe(true);
-      expect(validateUrl("https://api.example.com/v1/endpoint")).toBe(true);
-    });
-
-    it("should accept valid URL patterns", () => {
-      expect(validateUrl("/api/v1/*")).toBe(true);
-      expect(validateUrl("/*")).toBe(true);
-      expect(validateUrl("/users/:id")).toBe(true);
-    });
-
-    it("should reject invalid URLs", () => {
-      expect(validateUrl("")).toContain("required");
-      expect(validateUrl("not a url")).toContain(
-        "URL must be a valid URL or path pattern",
-      );
-      expect(validateUrl("ftp://example.com")).toContain(
-        "URL must be a valid URL or path pattern",
-      );
-    });
-  });
-
-  describe("validateSemver", () => {
-    it("should accept valid semantic versions", () => {
-      expect(validateSemver("1.0.0")).toBe(true);
-      expect(validateSemver("2.1.3")).toBe(true);
-      expect(validateSemver("10.20.30")).toBe(true);
-    });
-
-    it("should reject invalid versions", () => {
-      expect(validateSemver("1.0")).toContain("semantic versioning");
-      expect(validateSemver("v1.0.0")).toContain("semantic versioning");
-      expect(validateSemver("1.0.0-alpha")).toContain("semantic versioning");
-      expect(validateSemver("")).toContain(
-        "Version must follow semantic versioning format",
-      );
-    });
-  });
-});

package/src/utils/cli-progress-reporter.ts

@@ -1,84 +0,0 @@
-import type { BuildProgress } from "@ollie-shop/core";
-import chalk from "chalk";
-import cliProgress from "cli-progress";
-
-const PHASE_DISPLAY_NAMES: Record<string, string> = {
-  SUBMITTED: "Queued",
-  PROVISIONING: "Setting up",
-  DOWNLOAD_SOURCE: "Downloading",
-  INSTALL: "Installing deps",
-  PRE_BUILD: "Preparing",
-  BUILD: "Building",
-  POST_BUILD: "Finalizing",
-  UPLOAD_ARTIFACTS: "Uploading",
-  FINALIZING: "Completing",
-  COMPLETED: "Done",
-};
-
-export class CLIProgressReporter {
-  private bar: cliProgress.SingleBar;
-
-  constructor() {
-    this.bar = new cliProgress.SingleBar({
-      format: `Building |${chalk.cyan("{bar}")}| {percentage}% | {phase} | ETA: {eta_formatted}`,
-      barCompleteChar: "\u2588",
-      barIncompleteChar: "\u2591",
-      hideCursor: true,
-      stopOnComplete: false,
-      clearOnComplete: false,
-    });
-  }
-
-  start(): void {
-    this.bar.start(100, 0, {
-      phase: "Initializing",
-      eta_formatted: "calculating...",
-    });
-  }
-
-  updateProgress(progress: BuildProgress): void {
-    const phaseDisplay = this.formatPhase(progress.status);
-    const etaFormatted = this.formatETA(0); // ETA not available in BuildProgress
-
-    this.bar.update(progress.percentComplete, {
-      phase: phaseDisplay,
-      eta_formatted: etaFormatted,
-    });
-  }
-
-  stop(success: boolean): void {
-    this.bar.stop();
-
-    // Clear the line and show final status
-    process.stdout.clearLine(0);
-    process.stdout.cursorTo(0);
-
-    if (success) {
-      console.log(chalk.green("✓ Build completed successfully!"));
-    } else {
-      console.log(chalk.red("✗ Build failed"));
-    }
-  }
-
-  private formatPhase(phase: string): string {
-    return PHASE_DISPLAY_NAMES[phase] || phase;
-  }
-
-  private formatETA(seconds: number): string {
-    if (seconds <= 0) {
-      return "completing...";
-    }
-
-    if (seconds < 60) {
-      return `${Math.ceil(seconds)}s`;
-    }
-
-    const minutes = Math.floor(seconds / 60);
-    const remainingSeconds = Math.ceil(seconds % 60);
-    return `${minutes}m ${remainingSeconds}s`;
-  }
-}
-
-export function createCLIProgressReporter(): CLIProgressReporter {
-  return new CLIProgressReporter();
-}