@ollie-shop/cli 0.2.0 → 0.3.0

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

@@ -0,0 +1,170 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+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 consoleLogSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    // Skip creating the actual reporter to avoid mocking issues
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {
+      // Intentionally empty for test isolation
+    });
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+  });
+
+  it("should start progress tracking", () => {
+    reporter = new RichProgressReporter();
+    reporter.start();
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining("🚀 Starting deployment..."),
+    );
+  });
+
+  it("should update progress with build status", () => {
+    reporter = new RichProgressReporter();
+
+    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();
+    // Access private method for testing
+    const reporterWithPrivate = reporter as unknown as {
+      showSuccessSummary(): void;
+    };
+    reporterWithPrivate.showSuccessSummary();
+
+    expect(consoleLogSpy).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();
+    // 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(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining("❌ Deployment failed"),
+    );
+  });
+
+  it("should display build stats when available", () => {
+    const reporter = new RichProgressReporter();
+
+    // 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(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining("📊 Build Stats:"),
+    );
+    expect(consoleLogSpy).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

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,125 @@
+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/auth.ts

@@ -1,4 +1,3 @@
-// lib/auth.ts
 import fs from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";

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

@@ -0,0 +1,84 @@
+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.currentPhase);
+    const etaFormatted = this.formatETA(progress.estimatedRemainingSeconds);
+
+    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();
+}