@ollie-shop/cli 0.2.0 → 0.3.0

package/src/utils/validation-helpers.ts

@@ -0,0 +1,192 @@
+import {
+  ComponentNameSchema,
+  FunctionNameSchema,
+  PrioritySchema,
+  SemverSchema,
+  StoreIdSchema,
+  UrlSchema,
+  VersionNameSchema,
+} from "../schemas/command.schema";
+import type { CliConsole } from "./console";
+
+export interface ValidationResult {
+  valid: boolean;
+  errors?: Array<{ message?: string } | string>;
+  warnings?: Array<{ message?: string } | string>;
+}
+
+export interface SpinnerManager {
+  succeed: (text: string) => void;
+  fail: (text: string) => void;
+}
+
+/**
+ * Validate component name format using Zod schema
+ */
+export function validateComponentName(name: string): true | string {
+  const result = ComponentNameSchema.safeParse(name);
+  return result.success
+    ? true
+    : result.error.errors[0]?.message || "Invalid component name";
+}
+
+/**
+ * Validate function name format using Zod schema
+ */
+export function validateFunctionName(name: string): true | string {
+  const result = FunctionNameSchema.safeParse(name);
+  return result.success
+    ? true
+    : result.error.errors[0]?.message || "Invalid function name";
+}
+
+/**
+ * Validate store ID format using Zod schema
+ */
+export function validateStoreId(storeId: string): true | string {
+  const result = StoreIdSchema.safeParse(storeId);
+  return result.success
+    ? true
+    : result.error.errors[0]?.message || "Invalid store ID";
+}
+
+/**
+ * Validate version name using Zod schema
+ */
+export function validateVersionName(name: string): true | string {
+  const result = VersionNameSchema.safeParse(name);
+  return result.success
+    ? true
+    : result.error.errors[0]?.message || "Invalid version name";
+}
+
+/**
+ * Validate priority value using Zod schema
+ */
+export function validatePriority(priority: number): true | string {
+  const result = PrioritySchema.safeParse(priority);
+  return result.success
+    ? true
+    : result.error.errors[0]?.message || "Invalid priority";
+}
+
+/**
+ * Validate URL or URL pattern using Zod schema
+ */
+export function validateUrl(url: string): true | string {
+  const result = UrlSchema.safeParse(url);
+  return result.success
+    ? true
+    : result.error.errors[0]?.message || "Invalid URL";
+}
+
+/**
+ * Validate semantic version using Zod schema
+ */
+export function validateSemver(version: string): true | string {
+  const result = SemverSchema.safeParse(version);
+  return result.success
+    ? true
+    : result.error.errors[0]?.message || "Invalid semantic version";
+}
+
+/**
+ * Process validation errors and display them to the user
+ */
+export function processValidationErrors(
+  errors: Array<{ message?: string } | string>,
+  cliConsole: CliConsole,
+): void {
+  cliConsole.error("Errors:");
+  for (const error of errors) {
+    const message = typeof error === "string" ? error : error.message || error;
+    cliConsole.error(`• ${message}`);
+  }
+}
+
+/**
+ * Process validation warnings and display them to the user
+ */
+export function processValidationWarnings(
+  warnings: Array<{ message?: string } | string>,
+  cliConsole: CliConsole,
+): void {
+  cliConsole.warn("Warnings:");
+  for (const warning of warnings) {
+    const message =
+      typeof warning === "string" ? warning : warning.message || warning;
+    cliConsole.warn(`• ${message}`);
+  }
+}
+
+/**
+ * Handle validation result with spinner and console output
+ */
+export function handleValidationResult(
+  result: ValidationResult | unknown,
+  spinner: SpinnerManager,
+  cliConsole: CliConsole,
+  entityType: string,
+): void {
+  if (typeof result === "object" && result !== null && "valid" in result) {
+    const validationResult = result as ValidationResult;
+
+    handleValidResult(validationResult, spinner, cliConsole, entityType);
+    handleValidationWarnings(validationResult, cliConsole);
+    handleValidationErrors(validationResult);
+  } else {
+    spinner.succeed(`${entityType} validation completed`);
+  }
+}
+
+/**
+ * Handle valid/invalid validation status
+ */
+function handleValidResult(
+  result: ValidationResult,
+  spinner: SpinnerManager,
+  cliConsole: CliConsole,
+  entityType: string,
+): void {
+  if (result.valid) {
+    spinner.succeed(`${entityType} is valid!`);
+  } else {
+    spinner.fail(`${entityType} validation failed`);
+    if (result.errors?.length) {
+      processValidationErrors(result.errors, cliConsole);
+    }
+  }
+}
+
+/**
+ * Handle validation warnings display
+ */
+function handleValidationWarnings(
+  result: ValidationResult,
+  cliConsole: CliConsole,
+): void {
+  if (result.warnings?.length) {
+    processValidationWarnings(result.warnings, cliConsole);
+  }
+}
+
+/**
+ * Handle validation errors and throw if invalid
+ */
+function handleValidationErrors(result: ValidationResult): void {
+  if (!result.valid) {
+    throw new Error("Validation failed");
+  }
+}
+
+// Test helpers for mocking
+export function createMockSpinner(): SpinnerManager {
+  return {
+    succeed: () => {
+      // Mock spinner success - intentionally empty
+    },
+    fail: () => {
+      // Mock spinner failure - intentionally empty
+    },
+  };
+}

package/tsconfig.json

@@ -1,20 +1,26 @@
 {
   "compilerOptions": {
-    "lib": ["ESNext", "DOM"],
-    "module": "ESNext",
-    "target": "ESNext",
-    "moduleResolution": "Bundler",
+    "lib": ["ESNext"],
+    "module": "Node16",
+    "target": "ES2020",
+    "moduleResolution": "Node16",
     "jsx": "react-jsx",
     "strict": true,
     "declaration": true,
+    "declarationMap": true,
     "noUncheckedIndexedAccess": true,
     "skipLibCheck": true,
     "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
     "resolveJsonModule": true,
-    "types": ["node", "vitest/globals"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "isolatedModules": true,
     "paths": {
-      "@/*": ["./src/*"]
+      "@/*": ["./src/*"],
+      "@tests/*": ["./src/__tests__/*"]
     }
   },
-  "exclude": ["node_modules", "dist"]
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
 }

package/vitest.config.ts

@@ -1,7 +1,35 @@
+import path from "node:path";
 import { defineConfig } from "vitest/config";
 
 export default defineConfig({
   test: {
     globals: true,
+    environment: "node",
+    exclude: ["**/node_modules/**", "**/dist/**", "**/components/**"],
+    include: ["src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: [
+        "node_modules/",
+        "dist/",
+        "**/*.d.ts",
+        "**/*.config.ts",
+        "**/__tests__/**",
+      ],
+      thresholds: {
+        lines: 80,
+        functions: 80,
+        branches: 80,
+        statements: 80,
+      },
+    },
+    setupFiles: ["./vitest.setup.ts"],
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+      "@tests": path.resolve(__dirname, "./src/__tests__"),
+    },
   },
 });

package/vitest.setup.ts

@@ -0,0 +1,29 @@
+import { vi } from "vitest";
+
+// Mock console methods
+global.console = {
+  ...console,
+  log: vi.fn(),
+  debug: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+};
+
+// Mock process.exit
+vi.spyOn(process, "exit").mockImplementation((code?: string | number) => {
+  throw new Error(`process.exit called with code ${code}`);
+});
+
+// Set test environment
+process.env.NODE_ENV = "test";
+process.env.OLLIE_SHOP_CONFIG_DIR = "/tmp/ollie-shop-test";
+
+// Global test utilities
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});

package/src/commands/validate.ts

@@ -1,62 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import chalk from "chalk";
-import type { Command } from "commander";
-
-/**
- * Register the `validate` command
- */
-export function configureValidateCommand(program: Command): void {
-  program
-    // Make componentPath optional here to suppress Commander error
-    .command("validate [componentPath]")
-    .description("Validate the structure of your custom component")
-    .action(async (componentPath: string | undefined) => {
-      if (!componentPath) {
-        console.error(
-          `${chalk.red("❌ Missing required argument:")} component path\n\n` +
-            `Example usage:\n  ${chalk.cyan("ollieshop validate")} ./path/to/your/component\n`,
-        );
-        process.exit(1);
-      }
-
-      const resolvedPath = path.resolve(componentPath);
-      const requiredFiles = ["index.tsx", "package.json", "meta.json"];
-      const optionalFile = "styles.module.css";
-
-      let isValid = true;
-
-      // Track missing required files
-      const missingFiles: string[] = [];
-
-      // Check required files
-      for (const file of requiredFiles) {
-        try {
-          await fs.access(path.join(resolvedPath, file));
-          console.log(`${chalk.green("✔")} Found: ${chalk.cyan(file)}`);
-        } catch {
-          console.log(`${chalk.red("✖")} Missing: ${chalk.cyan(file)}`);
-          missingFiles.push(file);
-          isValid = false;
-        }
-      }
-
-      // Check optional file presence
-      try {
-        await fs.access(path.join(resolvedPath, optionalFile));
-        console.log(
-          `${chalk.yellow("ℹ")} Optional file found: ${chalk.cyan(optionalFile)}`,
-        );
-      } catch {
-        console.log(
-          `${chalk.dim("ℹ")} Optional file not found: ${chalk.cyan(optionalFile)}`,
-        );
-      }
-
-      if (isValid) {
-        console.log(`\n${chalk.green("✔")} Component structure looks valid!`);
-      } else {
-        process.exit(1);
-      }
-    });
-}

package/src/utils/core.ts

@@ -1,105 +0,0 @@
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import path from "node:path";
-import chalk from "chalk";
-import latestVersion from "latest-version";
-
-const require = createRequire(import.meta.url);
-export const pkg = require("../package.json");
-
-/**
- * Checks if there is a newer version of the CLI available
- * and notifies the user to update if so.
- */
-export async function checkForUpdates() {
-  try {
-    const latest = await latestVersion(pkg.name);
-    if (latest !== pkg.version) {
-      console.log(
-        chalk.yellow(
-          `\n⚠️  A new version ${chalk.bold(latest)} is available!\n   Update now: ${chalk.bold(
-            "npm install -g @ollie-shop/cli",
-          )}\n`,
-        ),
-      );
-    }
-  } catch {
-    // Silently ignore errors if offline or failed
-  }
-}
-
-/**
- * Displays a custom welcome message when no arguments are passed
- */
-export function showWelcomeMessage() {
-  console.log(
-    chalk.cyanBright.bold(
-      `\n✨ Welcome to the Ollie Shop CLI - ${pkg.version} ✨\n`,
-    ),
-  );
-  console.log("Build, customize and deploy your e-commerce with ease.\n");
-
-  console.log("Usage:");
-  console.log("  ollieshop <command> [options]\n");
-
-  console.log("Available commands:");
-
-  // Stable commands
-  const stableCommands = [
-    { cmd: "login", desc: "Log in to your Ollie Shop account" },
-    { cmd: "validate", desc: "Validate your component files" },
-    { cmd: "whoami", desc: "Show logged-in user and current store" },
-  ];
-
-  for (const { cmd, desc } of stableCommands) {
-    console.log(`  ${chalk.green(cmd.padEnd(20))} ${desc}`);
-  }
-
-  console.log("\nComing soon:");
-
-  // Coming soon
-  const comingSoonCommands = [
-    { cmd: "build", desc: "Compile components for deployment" },
-    { cmd: "deploy", desc: "Deploy a component or function" },
-    { cmd: "dev", desc: "Start local preview server" },
-    { cmd: "status", desc: "Show store status" },
-  ];
-
-  for (const { cmd, desc } of comingSoonCommands) {
-    console.log(`  ${chalk.yellow(cmd.padEnd(20))} ${desc}`);
-  }
-
-  console.log(
-    `\nFor a full list of commands, run: ${chalk.yellow.bold("ollieshop help")}\n`,
-  );
-
-  console.log(
-    "Documentation:",
-    chalk.underline.blue("https://docs.ollie.shop/ollie-shop"),
-  );
-  console.log();
-}
-
-/**
- * Ensures the current working directory is a valid Ollie Shop project.
- * If not, it shows an error and exits the process.
- */
-export function validateProjectLocation() {
-  const command = process.argv[2] ?? "";
-
-  // Commands allowed outside a valid Ollie Shop project
-  const allowedOutside = ["help", "docs", "version"];
-
-  if (allowedOutside.includes(command)) return;
-
-  const configPath = path.join(process.cwd(), "ollie.json");
-  const isValidProject = fs.existsSync(configPath);
-
-  if (!isValidProject) {
-    console.log(`
-      ${chalk.red("❌")} This command must be run inside an ${chalk.bold("Ollie Shop project")}.
-      Please navigate to your project directory and try again.\n`);
-
-    process.exit(1);
-  }
-}

package/tsup.config.ts

@@ -1,15 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["./src/index.ts"],
-  bundle: true,
-  splitting: false,
-  minify: false,
-  sourcemap: false,
-  platform: "node",
-  format: "cjs",
-  clean: true,
-  treeshake: true,
-  dts: false,
-  banner: { js: "#!/usr/bin/env node" },
-});