@ollie-shop/cli 0.3.4 → 1.0.1

package/src/utils/deploy-helpers.ts

@@ -1,357 +0,0 @@
-import {
-  type BuildResponse,
-  type BuildResult,
-  formatBuildError,
-  setBuilderUrl,
-  waitForBuildCompletion,
-} from "@ollie-shop/core";
-import { validateBuilderApiUrl } from "../schemas/command.schema";
-import type { CliConsole } from "./console";
-import { DEPLOYMENT_SETTINGS, ERROR_MESSAGES } from "./constants";
-import { RichProgressReporter } from "./rich-progress.js";
-
-/**
- * Resource types that can be deployed through the CLI
- * @typedef {"component" | "function"} ResourceType
- */
-export type ResourceType = "component" | "function";
-
-/**
- * Error types that can occur during deployment operations
- * @typedef {"BuildTimeoutError" | "BuildFailedError" | "BuildValidationError" | "UnknownError"} DeploymentErrorType
- */
-export type DeploymentErrorType =
-  | "BuildTimeoutError"
-  | "BuildFailedError"
-  | "BuildValidationError"
-  | "UnknownError";
-
-/**
- * Deployment progress information returned after successful deployment
- * @interface DeploymentProgress
- * @property {BuildResponse} completedBuild - The completed build response from the builder service
- * @property {number} duration - Total deployment duration in seconds
- */
-export interface DeploymentProgress {
-  completedBuild: BuildResponse;
-  duration: number;
-}
-
-/**
- * Configure the builder URL from environment variable with validation
- * Uses BUILDER_API_URL environment variable if set, validates it's a proper URL
- *
- * @throws {Error} If BUILDER_API_URL is set but invalid
- * @example
- * ```typescript
- * // Set environment variable first
- * process.env.BUILDER_API_URL = "https://builder.ollie.shop";
- *
- * // Configure the builder
- * configureBuilderUrl();
- * ```
- */
-export function configureBuilderUrl(): void {
-  const builderUrl = process.env.BUILDER_API_URL;
-  if (builderUrl) {
-    if (!validateBuilderApiUrl(builderUrl)) {
-      throw new Error(
-        "Invalid BUILDER_API_URL environment variable. Must be a valid HTTP or HTTPS URL.",
-      );
-    }
-    setBuilderUrl(builderUrl);
-  }
-}
-
-/**
- * Handle deployment errors with proper type safety and user-friendly messages
- * Provides specific error messages and recovery suggestions based on error type
- *
- * @param {unknown} error - The error that occurred during deployment
- * @param {string} _buildId - The build ID (currently unused but kept for future use)
- * @param {ResourceType} resourceType - Type of resource being deployed (component/function)
- * @param {CliConsole} cliConsole - Console instance for output
- * @example
- * ```typescript
- * try {
- *   await deployComponent(options);
- * } catch (error) {
- *   handleDeploymentError(error, buildId, "component", console);
- * }
- * ```
- */
-export function handleDeploymentError(
-  error: unknown,
-  _buildId: string,
-  resourceType: ResourceType,
-  cliConsole: CliConsole,
-): void {
-  const errorType = getErrorType(error);
-  const errorMessage = getErrorMessage(error);
-
-  switch (errorType) {
-    case "BuildTimeoutError":
-      cliConsole.error(ERROR_MESSAGES.DEPLOYMENT_TIMEOUT);
-      cliConsole.suggestions([
-        `Retry deployment: ollieshop ${resourceType} deploy --id <${resourceType}-id>`,
-        "Check your network connection and try again",
-        "Contact support if timeouts persist - this may indicate infrastructure issues",
-      ]);
-      break;
-    case "BuildFailedError":
-      cliConsole.error(ERROR_MESSAGES.BUILD_FAILED);
-      cliConsole.info("Review the build logs above for specific error details");
-      if (errorMessage) {
-        cliConsole.info(`Error details: ${errorMessage}`);
-      }
-      cliConsole.suggestions([
-        `Validate your ${resourceType} code: ollieshop ${resourceType} validate`,
-        "Check your code for syntax errors and missing dependencies",
-        "Ensure all imports and exports are correctly defined",
-      ]);
-      break;
-    case "BuildValidationError":
-      cliConsole.error(ERROR_MESSAGES.BUILD_VALIDATION_FAILED);
-      handleBuildValidationError(error, resourceType, cliConsole);
-      break;
-    default:
-      cliConsole.error(`${ERROR_MESSAGES.UNKNOWN_ERROR}: ${errorMessage}`);
-      break;
-  }
-}
-
-/**
- * Get the error type from an unknown error with proper type safety
- */
-function getErrorType(error: unknown): DeploymentErrorType {
-  if (error && typeof error === "object" && "name" in error) {
-    const errorName = (error as { name: string }).name;
-    if (isValidErrorType(errorName)) {
-      return errorName;
-    }
-  }
-  return "UnknownError";
-}
-
-/**
- * Get the error message from an unknown error with proper type safety
- */
-function getErrorMessage(error: unknown): string {
-  if (error && typeof error === "object" && "message" in error) {
-    return String((error as { message: unknown }).message);
-  }
-  return "An unknown error occurred";
-}
-
-/**
- * Type guard to check if a string is a valid error type
- */
-function isValidErrorType(errorName: string): errorName is DeploymentErrorType {
-  return [
-    "BuildTimeoutError",
-    "BuildFailedError",
-    "BuildValidationError",
-  ].includes(errorName);
-}
-
-/**
- * Show deployment success message with build details
- * Displays build ID, duration, and infrastructure deployment confirmation
- *
- * @param {BuildResponse} completedBuild - The completed build response
- * @param {number} duration - Deployment duration in seconds
- * @param {string} _resourceId - Resource ID (currently unused but kept for future use)
- * @param {ResourceType} _resourceType - Resource type (currently unused but kept for future use)
- * @param {CliConsole} cliConsole - Console instance for output
- * @example
- * ```typescript
- * const { completedBuild, duration } = await waitForDeploymentWithProgress(
- *   buildId,
- *   "component",
- *   console
- * );
- * showDeploymentSuccess(completedBuild, duration, componentId, "component", console);
- * ```
- */
-export function showDeploymentSuccess(
-  completedBuild: BuildResponse,
-  duration: number,
-  _resourceId: string,
-  _resourceType: ResourceType,
-  cliConsole: CliConsole,
-): void {
-  cliConsole.success("\n✅ Deployment completed successfully!");
-  cliConsole.info(`Build ID: ${completedBuild.id}`);
-  cliConsole.info(`Duration: ${duration.toFixed(1)}s`);
-
-  // Note: Deployment URLs are dynamically generated by the infrastructure
-  // For components: CloudFront URL (managed by SST router)
-  // For functions: Lambda ARN (managed by AWS)
-  cliConsole.info("✨ Resources deployed to cloud infrastructure");
-}
-
-// Removed showAsyncModeNextSteps as deployments now always wait for completion
-
-/**
- * Wait for deployment completion with real-time progress reporting
- * Shows animated progress bar with ETA while polling the builder service
- *
- * @async
- * @param {string} buildId - The build ID to monitor
- * @param {ResourceType} resourceType - Type of resource being deployed
- * @param {CliConsole} cliConsole - Console instance for progress display
- * @returns {Promise<DeploymentProgress>} Deployment details including completed build and duration
- * @throws {Error} If deployment times out or fails
- * @example
- * ```typescript
- * const result = await buildAndDeployComponent(componentId, path);
- * const { completedBuild, duration } = await waitForDeploymentWithProgress(
- *   result.buildId,
- *   "component",
- *   console
- * );
- * console.log(`Deployment completed in ${duration}s`);
- * ```
- */
-export async function waitForDeploymentWithProgress(
-  buildId: string,
-  resourceType: ResourceType,
-  cliConsole: CliConsole,
-): Promise<DeploymentProgress> {
-  const progressReporter = new RichProgressReporter(cliConsole);
-  progressReporter.start();
-
-  const startTime = Date.now();
-  const estimatedDuration = DEPLOYMENT_SETTINGS.ESTIMATED_BUILD_DURATION_MS;
-
-  // Update progress based on elapsed time
-  const progressTimer = setInterval(() => {
-    const elapsed = Date.now() - startTime;
-    const progress = Math.min(
-      elapsed / estimatedDuration,
-      DEPLOYMENT_SETTINGS.MAX_PROGRESS_BEFORE_COMPLETION,
-    );
-    const remainingSeconds = Math.max(
-      0,
-      Math.ceil((estimatedDuration - elapsed) / 1000),
-    );
-
-    progressReporter.updateProgress({
-      phase: "building",
-      message: `Building ${resourceType}... ETA: ${remainingSeconds}s`,
-      progress,
-    });
-  }, DEPLOYMENT_SETTINGS.PROGRESS_UPDATE_INTERVAL_MS);
-
-  try {
-    const completedBuild = await waitForBuildCompletion(buildId, {
-      pollIntervalMs: DEPLOYMENT_SETTINGS.DEFAULT_POLL_INTERVAL_MS,
-      maxWaitMs: DEPLOYMENT_SETTINGS.DEFAULT_MAX_WAIT_MS,
-    });
-
-    clearInterval(progressTimer);
-    const duration = (Date.now() - startTime) / 1000;
-    progressReporter.stop(true);
-
-    return { completedBuild, duration };
-  } catch (error) {
-    clearInterval(progressTimer);
-    progressReporter.stop(false);
-    throw error;
-  }
-}
-
-/**
- * Handle build validation errors with specific suggestions
- * Provides targeted help for common validation issues
- *
- * @param {unknown} error - The validation error
- * @param {ResourceType} resourceType - Type of resource that failed validation
- * @param {CliConsole} cliConsole - Console instance for output
- * @example
- * ```typescript
- * if (error.code === "BUILD_VALIDATION_ERROR") {
- *   handleBuildValidationError(error, "component", console);
- * }
- * ```
- */
-export function handleBuildValidationError(
-  error: unknown,
-  resourceType: ResourceType,
-  cliConsole: CliConsole,
-): void {
-  const errorCode = getErrorCode(error);
-
-  if (errorCode === "BUILD_VALIDATION_ERROR") {
-    cliConsole.suggestions([
-      `Ensure the ${resourceType} ID is a valid UUID format (e.g., 123e4567-e89b-12d3-a456-426614174000)`,
-      `Verify the ${resourceType} directory exists and contains the required files`,
-      `Check that your ${resourceType} has a valid package.json with correct entry point`,
-      `Run: ollieshop ${resourceType} validate --path <path> to identify specific issues`,
-    ]);
-  }
-}
-
-/**
- * Get error code from unknown error with proper type safety
- */
-function getErrorCode(error: unknown): string | undefined {
-  if (error && typeof error === "object" && "code" in error) {
-    const code = (error as { code: unknown }).code;
-    return typeof code === "string" ? code : undefined;
-  }
-  return undefined;
-}
-
-/**
- * Handle deployment result with proper error handling and type safety
- * Updates spinner state and throws error if deployment failed
- *
- * @param {BuildResult} result - The build result from the deployment attempt
- * @param {ResourceType} resourceType - Type of resource being deployed
- * @param {CliConsole} cliConsole - Console instance for output
- * @param {ReturnType<CliConsole["spinner"]>} spinner - Active spinner to update
- * @throws {Error} If the deployment failed
- * @example
- * ```typescript
- * const result = await buildAndDeployComponent(componentId, path);
- * handleDeploymentResult(result, "component", console, spinner);
- * // If we get here, deployment was initiated successfully
- * ```
- */
-export function handleDeploymentResult(
-  result: BuildResult,
-  resourceType: ResourceType,
-  cliConsole: CliConsole,
-  spinner: ReturnType<CliConsole["spinner"]>,
-): void {
-  if (!result.success) {
-    const capitalizedType = capitalizeResourceType(resourceType);
-    spinner.fail(`${capitalizedType} deployment failed`);
-
-    const errorMessage = result.error
-      ? formatBuildError(result.error)
-      : "Unknown error occurred";
-
-    cliConsole.error(errorMessage);
-    handleBuildValidationError(result.error, resourceType, cliConsole);
-
-    const error = new Error(
-      getErrorMessage(result.error) || "Deployment failed",
-    );
-    error.name = "DeploymentError";
-    throw error;
-  }
-
-  const capitalizedType = capitalizeResourceType(resourceType);
-  spinner.succeed(`${capitalizedType} deployment initiated!`);
-  cliConsole.success(`Build ID: ${result.buildId}`);
-  cliConsole.info(`Status: ${result.status}`);
-}
-
-/**
- * Capitalize resource type for display purposes
- */
-function capitalizeResourceType(resourceType: ResourceType): string {
-  return resourceType.charAt(0).toUpperCase() + resourceType.slice(1);
-}

package/src/utils/enhanced-error-handler.ts

@@ -1,264 +0,0 @@
-import chalk from "chalk";
-import type { ErrorContext } from "../types";
-import { isNodeError } from "../types";
-import type { CliConsole } from "./console.js";
-import { detectProjectContext } from "./context-detector.js";
-
-interface ErrorRecovery {
-  message: string;
-  suggestions: string[];
-  commands?: string[];
-}
-
-export class EnhancedErrorHandler {
-  constructor(private console: CliConsole) {}
-
-  /**
-   * Common error patterns with recovery suggestions
-   */
-  private readonly errorPatterns = new Map<string | RegExp, ErrorRecovery>([
-    [
-      "ENOENT",
-      {
-        message: "File or directory not found",
-        suggestions: [
-          "Check if the path exists",
-          "Use --path to specify the correct location",
-        ],
-        commands: ["ls", "pwd"],
-      },
-    ],
-    [
-      "EACCES",
-      {
-        message: "Permission denied",
-        suggestions: [
-          "Check file permissions",
-          "Try running with appropriate permissions",
-        ],
-        commands: ["ls -la"],
-      },
-    ],
-    [
-      "ECONNREFUSED",
-      {
-        message: "Connection refused",
-        suggestions: [
-          "Check your internet connection",
-          "Verify your authentication",
-          "Check if backend services are running",
-        ],
-        commands: ["ollieshop login", "ollieshop status"],
-      },
-    ],
-    [
-      /Component .* already exists/,
-      {
-        message: "Component already exists",
-        suggestions: [
-          "Use a different name",
-          "Delete the existing component first",
-          "Update the existing component instead",
-        ],
-        commands: ["ollieshop component list", "rm -rf ./components/{name}"],
-      },
-    ],
-    [
-      /Invalid component name/,
-      {
-        message: "Component name validation failed",
-        suggestions: [
-          "Use lowercase letters and hyphens only",
-          "Examples: header-nav, shopping-cart, product-list",
-        ],
-      },
-    ],
-  ]);
-
-  /**
-   * Handle errors with enhanced recovery suggestions
-   */
-  handle(error: Error, context?: ErrorContext): void {
-    // Display the main error
-    this.console.error(`\n❌ ${error.message}\n`);
-
-    // Get recovery suggestions
-    const recovery = this.getRecoverySuggestions(error);
-
-    if (recovery) {
-      this.displayRecoverySuggestions(recovery, context);
-    }
-
-    // Show contextual information
-    this.displayContextualInfo(error, context);
-
-    // Suggest similar commands if applicable
-    if (this.isCommandError(error)) {
-      this.suggestSimilarCommands(context);
-    }
-  }
-
-  /**
-   * Get recovery suggestions based on error
-   */
-  private getRecoverySuggestions(error: Error): ErrorRecovery | undefined {
-    // Check error code
-    if (isNodeError(error) && this.errorPatterns.has(error.code)) {
-      return this.errorPatterns.get(error.code);
-    }
-
-    // Check error message patterns
-    for (const [pattern, recovery] of this.errorPatterns) {
-      if (pattern instanceof RegExp && pattern.test(error.message)) {
-        return recovery;
-      }
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Display recovery suggestions
-   */
-  private displayRecoverySuggestions(
-    recovery: ErrorRecovery,
-    context?: ErrorContext,
-  ): void {
-    this.console.warn("💡 Possible solutions:\n");
-
-    for (const [index, suggestion] of recovery.suggestions.entries()) {
-      // Replace placeholders in suggestions
-      const formatted = this.formatSuggestion(suggestion, context);
-      this.console.log(chalk.yellow(`  ${index + 1}. ${formatted}`));
-    }
-
-    if (recovery.commands && recovery.commands.length > 0) {
-      this.console.log(chalk.dim("\n📍 Helpful commands:"));
-      for (const cmd of recovery.commands) {
-        const formatted = this.formatSuggestion(cmd, context);
-        this.console.log(chalk.dim(`  $ ${formatted}`));
-      }
-    }
-  }
-
-  /**
-   * Display contextual information
-   */
-  private displayContextualInfo(_error: Error, context?: ErrorContext): void {
-    const projectContext = detectProjectContext();
-
-    this.console.log(chalk.dim("\n📍 Context:"));
-    this.console.log(chalk.dim(`  Current directory: ${process.cwd()}`));
-
-    if (projectContext.type !== "unknown") {
-      this.console.log(chalk.dim(`  Project type: ${projectContext.type}`));
-      if (projectContext.name) {
-        this.console.log(
-          chalk.dim(`  ${projectContext.type} name: ${projectContext.name}`),
-        );
-      }
-    }
-
-    if (context?.path) {
-      this.console.log(chalk.dim(`  Target path: ${context.path}`));
-    }
-  }
-
-  /**
-   * Format suggestion with context values
-   */
-  private formatSuggestion(suggestion: string, context?: ErrorContext): string {
-    if (!context) return suggestion;
-
-    return suggestion.replace(/{(\w+)}/g, (match, key) => {
-      const value = context[key as keyof ErrorContext];
-      return typeof value === "string" ? value : match;
-    });
-  }
-
-  /**
-   * Check if this is a command-related error
-   */
-  private isCommandError(error: Error): boolean {
-    return (
-      error.message.includes("Unknown command") ||
-      error.message.includes("not found") ||
-      (isNodeError(error) && error.code === "COMMAND_NOT_FOUND")
-    );
-  }
-
-  /**
-   * Suggest similar commands
-   */
-  private suggestSimilarCommands(context?: ErrorContext): void {
-    if (!context?.attemptedCommand) return;
-
-    const suggestions = this.findSimilarCommands(
-      String(context.attemptedCommand),
-    );
-
-    if (suggestions.length > 0) {
-      this.console.log(chalk.dim("\n💡 Did you mean:"));
-      for (const cmd of suggestions) {
-        this.console.log(chalk.dim(`  $ ollieshop ${cmd}`));
-      }
-    }
-  }
-
-  /**
-   * Find similar commands using basic string matching
-   */
-  private findSimilarCommands(attempted: string): string[] {
-    const commands = [
-      "component create",
-      "component validate",
-      "component build",
-      "component deploy",
-      "component list",
-      "function create",
-      "function validate",
-      "function build",
-      "function test",
-      "function deploy",
-      "store-version create",
-      "store-version list",
-      "template list",
-      "login",
-      "whoami",
-    ];
-
-    return commands
-      .filter((cmd) => {
-        // Simple similarity check
-        const cmdParts = cmd.toLowerCase().split(" ");
-        const attemptedParts = attempted.toLowerCase().split(" ");
-
-        // Check if any part matches
-        return cmdParts.some((part) =>
-          attemptedParts.some(
-            (aPart) => part.startsWith(aPart) || aPart.startsWith(part),
-          ),
-        );
-      })
-      .slice(0, 3); // Show top 3 suggestions
-  }
-}
-
-/**
- * Create an error with additional context
- */
-export function createContextualError(
-  message: string,
-  code?: string,
-  context?: Record<string, unknown>,
-): Error {
-  const error = new Error(message) as Error & {
-    code?: string;
-    context?: Record<string, unknown>;
-  };
-
-  if (code) error.code = code;
-  if (context) error.context = context;
-
-  return error;
-}

package/src/utils/error-handler.ts

@@ -1,60 +0,0 @@
-import type { ErrorContext } from "../types";
-import { console as cliConsole } from "./console";
-import { EnhancedErrorHandler } from "./enhanced-error-handler.js";
-import { OllieShopCLIError, type RecoveryAction } from "./errors";
-
-function handleOllieShopError(error: OllieShopCLIError): void {
-  cliConsole.error(`\n${error.message}`);
-
-  if (error.details) {
-    displayErrorDetails(error.details);
-  }
-
-  if (error.suggestions && error.suggestions.length > 0) {
-    displayRecoveryActions(error.suggestions);
-  }
-}
-
-function displayErrorDetails(details: ErrorContext): void {
-  cliConsole.dim("\nContext:");
-  for (const [key, value] of Object.entries(details)) {
-    if (key === "fields" && Array.isArray(value)) {
-      displayFieldErrors(value);
-    } else {
-      cliConsole.dim(`  ${key}: ${value}`);
-    }
-  }
-}
-
-function displayFieldErrors(
-  fields: Array<{ field: string; message: string }>,
-): void {
-  cliConsole.dim("  fields:");
-  for (const field of fields) {
-    cliConsole.dim(`    ${field.field}: ${field.message}`);
-  }
-}
-
-function displayRecoveryActions(actions: RecoveryAction[]): void {
-  cliConsole.info("\nSuggestions:");
-  for (const action of actions) {
-    cliConsole.dim(`  • ${action.description}`);
-    if (action.command) {
-      cliConsole.dim(`    $ ${action.command}`);
-    }
-  }
-}
-
-export function handleError(error: unknown, context?: ErrorContext): never {
-  if (error instanceof OllieShopCLIError) {
-    handleOllieShopError(error);
-  } else if (error instanceof Error) {
-    const enhancedHandler = new EnhancedErrorHandler(cliConsole);
-    enhancedHandler.handle(error, context);
-  } else {
-    cliConsole.error("\nAn unexpected error occurred");
-    cliConsole.dim(String(error));
-  }
-
-  process.exit(1);
-}