@ollie-shop/cli 0.1.3 → 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/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" },
-});