@ollie-shop/cli 0.3.4 → 1.0.1

package/src/utils/command-builder.ts

@@ -1,390 +0,0 @@
-import type { Command } from "@commander-js/extra-typings";
-import { z } from "zod";
-import type { CLIError, CommandHandler } from "../types";
-import type { EnhancedOption } from "./command-parser";
-import { console as cliConsole } from "./console";
-import {
-  displayErrors,
-  formatZodError,
-  suggestCommand,
-} from "./validation-error-formatter";
-
-export interface CommandConfig<T = unknown> {
-  name: string;
-  description: string;
-  aliases?: string[];
-  options?: EnhancedOption[];
-  schema?: z.ZodSchema<T>;
-  examples?: Array<{
-    description: string;
-    command: string;
-  }>;
-  handler: CommandHandler<T>;
-}
-
-/**
- * Build an enhanced command with validation and error handling
- */
-function setupCommandAliases(cmd: Command, aliases?: string[]): void {
-  if (!aliases) return;
-  for (const alias of aliases) {
-    cmd.alias(alias);
-  }
-}
-
-function isValidDefaultValue(
-  value: unknown,
-): value is string | boolean | string[] {
-  return (
-    typeof value === "string" ||
-    typeof value === "boolean" ||
-    Array.isArray(value)
-  );
-}
-
-function addOption(cmd: Command, option: EnhancedOption): void {
-  if (option.required) {
-    cmd.requiredOption(option.flags, option.description);
-    return;
-  }
-
-  const hasParser = option.parser !== undefined;
-  const hasDefault =
-    option.defaultValue !== undefined && option.defaultValue !== null;
-
-  if (hasParser && hasDefault && option.parser) {
-    cmd.option(
-      option.flags,
-      option.description,
-      option.parser,
-      option.defaultValue,
-    );
-  } else if (hasParser && option.parser) {
-    cmd.option(option.flags, option.description, option.parser);
-  } else if (hasDefault) {
-    // Commander.js doesn't accept number as defaultValue, convert to string
-    const defaultValue =
-      typeof option.defaultValue === "number"
-        ? String(option.defaultValue)
-        : option.defaultValue;
-
-    if (isValidDefaultValue(defaultValue)) {
-      cmd.option(option.flags, option.description, defaultValue);
-    } else {
-      cmd.option(option.flags, option.description);
-    }
-  } else {
-    cmd.option(option.flags, option.description);
-  }
-}
-
-function setupCommandOptions(cmd: Command, options?: EnhancedOption[]): void {
-  if (!options) return;
-  for (const option of options) {
-    addOption(cmd, option);
-  }
-}
-
-function setupCommandExamples(
-  cmd: Command,
-  examples?: Array<{ description: string; command: string }>,
-): void {
-  if (!examples || examples.length === 0) return;
-  cmd.addHelpText("after", "\nExamples:");
-  for (const example of examples) {
-    cmd.addHelpText("after", `  ${example.description}:`);
-    cmd.addHelpText("after", `  $ ${example.command}\n`);
-  }
-}
-
-export function buildCommand<T = unknown>(
-  parent: Command,
-  config: CommandConfig<T>,
-): Command {
-  const cmd = parent.command(config.name).description(config.description);
-
-  setupCommandAliases(cmd, config.aliases);
-  setupCommandOptions(cmd, config.options);
-  setupCommandExamples(cmd, config.examples);
-
-  // Add enhanced action handler with validation
-  cmd.action(async (options) => {
-    try {
-      const validatedOptions = await validateOptions<T>(
-        options,
-        config,
-        parent,
-      );
-      await config.handler(validatedOptions, cliConsole);
-    } catch (error) {
-      handleCommandError(error, config as CommandConfig<unknown>, parent);
-    }
-  });
-
-  // Override error handling
-  cmd.exitOverride();
-  cmd.configureOutput({
-    writeErr: (str) =>
-      handleCommanderError(str, parent, cmd, config as CommandConfig<unknown>),
-  });
-
-  return cmd;
-}
-
-/**
- * Extract option name from flags string
- */
-function getOptionName(flags: string): string {
-  // Extract long option name from flags like "-n, --name <value>"
-  const match = flags.match(/--([a-z-]+)/i);
-  return match?.[1] ?? flags;
-}
-
-/**
- * Validate command options
- */
-async function validateOptions<T>(
-  options: unknown,
-  config: CommandConfig<T>,
-  parent: Command,
-): Promise<T> {
-  let validatedOptions = options as T;
-
-  // Validate with schema if provided
-  if (config.schema) {
-    const result = config.schema.safeParse(options);
-    if (!result.success) {
-      const errors = formatZodError(result.error, parent.name());
-      displayErrors(cliConsole, errors, `${parent.name()} ${config.name}`);
-      // Throw an error that will be caught by the command handler
-      const error = new Error("Validation failed") as CLIError;
-      error.exitCode = 1;
-      error.isValidationError = true;
-      throw error;
-    }
-    validatedOptions = result.data;
-  }
-
-  // Check for required options
-  checkRequiredOptions(options, config, parent);
-
-  return validatedOptions;
-}
-
-/**
- * Check required options
- */
-function checkRequiredOptions<T>(
-  options: unknown,
-  config: CommandConfig<T>,
-  parent: Command,
-): void {
-  if (!config.options) return;
-
-  const missingRequired = config.options
-    .filter(
-      (opt) =>
-        opt.required &&
-        !(options as Record<string, unknown>)[getOptionName(opt.flags)],
-    )
-    .map((opt) => getOptionName(opt.flags));
-
-  if (missingRequired.length > 0) {
-    displayMissingOptions(missingRequired, config, parent);
-    // Throw an error that will be caught by the command handler
-    const error = new Error("Missing required options") as CLIError;
-    error.exitCode = 1;
-    error.isValidationError = true;
-    throw error;
-  }
-}
-
-/**
- * Display missing required options
- */
-function displayMissingOptions<T>(
-  missingRequired: string[],
-  config: CommandConfig<T>,
-  parent: Command,
-): void {
-  cliConsole.error("❌ Missing required options:");
-
-  for (const optName of missingRequired) {
-    const opt = config.options?.find((o) => getOptionName(o.flags) === optName);
-    if (opt) {
-      cliConsole.error(`  • --${optName}: ${opt.description}`);
-    }
-  }
-
-  cliConsole.log("");
-  cliConsole.info(
-    `💡 For more help, run: ollieshop ${parent.name()} ${config.name} --help`,
-  );
-}
-
-/**
- * Handle command errors
- */
-function handleCommandError(
-  error: unknown,
-  config: CommandConfig,
-  parent: Command,
-): never {
-  // Check if this is a validation error that was already displayed
-  if (error instanceof Error) {
-    const cliError = error as CLIError;
-    if (cliError.isValidationError) {
-      // Error messages already displayed, just exit
-      process.exit(cliError.exitCode || 1);
-    }
-  } else if (error instanceof z.ZodError) {
-    const errors = formatZodError(error, config.name);
-    displayErrors(cliConsole, errors, `${parent.name()} ${config.name}`);
-  } else {
-    cliConsole.error(
-      `Error: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-  process.exit(1);
-}
-
-/**
- * Handle Commander.js errors
- */
-function handleCommanderError(
-  str: string,
-  parent: Command,
-  cmd: Command,
-  config: CommandConfig,
-): void {
-  if (str.includes("error: unknown option")) {
-    handleUnknownOption(str, parent, cmd, config);
-  } else if (str.includes("error: missing required argument")) {
-    handleMissingArgument(str, parent, config);
-  } else {
-    cliConsole.error(str.trim());
-  }
-}
-
-/**
- * Handle unknown option error
- */
-function handleUnknownOption(
-  str: string,
-  parent: Command,
-  cmd: Command,
-  config: CommandConfig,
-): void {
-  const match = str.match(/unknown option '(.+)'/);
-  if (!match) return;
-
-  const unknownOption = match[1] ?? "";
-  cliConsole.error(`❌ Unknown option: ${unknownOption}`);
-
-  // Suggest similar options
-  const validOptions =
-    config.options?.map((opt) => `--${getOptionName(opt.flags)}`) || [];
-  const suggestion = suggestCommand(
-    unknownOption.replace(/^-+/, ""),
-    validOptions.map((opt) => opt.replace(/^-+/, "")),
-  );
-
-  if (suggestion) {
-    cliConsole.log("");
-    cliConsole.info(`💡 Did you mean: --${suggestion}?`);
-  }
-
-  cliConsole.log("");
-  cliConsole.info(
-    `💡 For available options, run: ollieshop ${parent.name()} ${cmd.name()} --help`,
-  );
-}
-
-/**
- * Handle missing argument error
- */
-function handleMissingArgument(
-  str: string,
-  parent: Command,
-  config: CommandConfig,
-): void {
-  const match = str.match(/missing required argument '(.+)'/);
-  if (!match) return;
-
-  cliConsole.error(`❌ Missing required argument: ${match[1]}`);
-  cliConsole.log("");
-  cliConsole.info(
-    `💡 For usage help, run: ollieshop ${parent.name()} ${config.name} --help`,
-  );
-}
-
-/**
- * Build a command group (like "component" or "function")
- */
-export function buildCommandGroup(
-  program: Command,
-  name: string,
-  description: string,
-  aliases?: string[],
-): Command {
-  const cmd = program.command(name).description(description);
-
-  if (aliases) {
-    for (const alias of aliases) {
-      cmd.alias(alias);
-    }
-  }
-
-  // Add custom error handling
-  cmd.exitOverride();
-  cmd.configureOutput({
-    writeErr: (str) => handleGroupCommandError(str, cmd, name),
-  });
-
-  return cmd;
-}
-
-/**
- * Handle command group errors
- */
-function handleGroupCommandError(
-  str: string,
-  cmd: Command,
-  groupName: string,
-): void {
-  if (str.includes("is not a") && str.includes("command")) {
-    handleUnknownSubcommand(str, cmd, groupName);
-  } else {
-    cliConsole.error(str.trim());
-  }
-}
-
-/**
- * Handle unknown subcommand error
- */
-function handleUnknownSubcommand(
-  str: string,
-  cmd: Command,
-  groupName: string,
-): void {
-  const match = str.match(/'([^']+)' is not a/);
-  if (!match) return;
-
-  const unknownCmd = match[1] ?? "";
-  cliConsole.error(`❌ Unknown command: ${unknownCmd}`);
-
-  // Get subcommands
-  const subcommands = cmd.commands.map((c) => c.name());
-  const suggestion = suggestCommand(unknownCmd, subcommands);
-
-  if (suggestion) {
-    cliConsole.log("");
-    cliConsole.info(`💡 Did you mean: ollieshop ${groupName} ${suggestion}?`);
-  }
-
-  cliConsole.log("");
-  cliConsole.info("💡 Available commands:");
-  for (const subcmd of subcommands) {
-    cliConsole.log(`   • ${subcmd}`);
-  }
-}

package/src/utils/command-helpers.ts

@@ -1,83 +0,0 @@
-import { z } from "zod";
-import { console as cliConsole } from "./console";
-import type { CliConsole } from "./console";
-
-/**
- * Handle errors in a consistent way across all commands
- */
-export function handleCommandError(error: unknown, console: CliConsole): void {
-  if (error instanceof Error) {
-    console.error(error.message);
-    if (process.env.DEBUG) {
-      console.debug(error.stack || "");
-    }
-  } else {
-    console.error("An unexpected error occurred");
-  }
-  process.exit(1);
-}
-
-/**
- * Parse and validate command options using a Zod schema
- */
-export function parseOptions<T>(
-  schema: z.ZodSchema<T>,
-  options: Record<string, unknown>,
-): T {
-  try {
-    return schema.parse(options);
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const formattedErrors = error.errors
-        .map((err) => `${err.path.join(".")}: ${err.message}`)
-        .join("\n");
-      throw new Error(`Invalid options:\n${formattedErrors}`);
-    }
-    throw error;
-  }
-}
-
-/**
- * Create an action handler with schema validation and error handling
- */
-export function createAction<T>(
-  schema: z.ZodSchema<T>,
-  action: (options: T, cliConsole: CliConsole) => Promise<void>,
-) {
-  return async (firstArg: unknown, options: Record<string, unknown>) => {
-    try {
-      // Handle both positional args and options
-      const combinedOptions = { ...options };
-      if (firstArg !== undefined) {
-        // Try to determine the first property name from common patterns
-        const possibleKeys = ["name", "path", "target"];
-        for (const key of possibleKeys) {
-          if (!combinedOptions[key]) {
-            combinedOptions[key] = firstArg;
-            break;
-          }
-        }
-      }
-
-      const parsedOptions = parseOptions(schema, combinedOptions);
-      await action(parsedOptions, cliConsole);
-    } catch (error) {
-      handleCommandError(error, cliConsole);
-    }
-  };
-}
-
-/**
- * Create a simple action handler without schema validation
- */
-export function createSimpleAction(
-  action: (cliConsole: CliConsole) => Promise<void>,
-) {
-  return async () => {
-    try {
-      await action(cliConsole);
-    } catch (error) {
-      handleCommandError(error, cliConsole);
-    }
-  };
-}

package/src/utils/command-parser.ts

@@ -1,245 +0,0 @@
-import { InvalidArgumentError } from "@commander-js/extra-typings";
-import { ComponentSlot, FunctionInvocationType } from "@ollie-shop/core";
-import { z } from "zod";
-import {
-  ComponentNameSchema,
-  FunctionNameSchema,
-  PathSchema,
-  PrioritySchema,
-  StoreIdSchema,
-  VersionNameSchema,
-} from "../schemas/command.schema";
-
-/**
- * Create a Commander option parser that validates with Zod schema
- */
-export function createOptionParser<T>(
-  schema: z.ZodSchema<T>,
-  fieldName: string,
-  helpText?: string,
-) {
-  return (value: string): T => {
-    const result = schema.safeParse(value);
-
-    if (!result.success) {
-      const errors = result.error.errors.map((err) => err.message).join(", ");
-
-      let errorMessage = `Invalid ${fieldName}: ${errors}`;
-
-      if (helpText) {
-        errorMessage += `\n\n${helpText}`;
-      }
-
-      throw new InvalidArgumentError(errorMessage);
-    }
-
-    return result.data;
-  };
-}
-
-/**
- * Parse component name with validation
- */
-export const parseComponentName = createOptionParser(
-  ComponentNameSchema,
-  "component name",
-  "Examples: header-nav, shopping-cart, product-list",
-);
-
-/**
- * Parse function name with validation
- */
-export const parseFunctionName = createOptionParser(
-  FunctionNameSchema,
-  "function name",
-  "Examples: validate-order, apply-discount, check-inventory",
-);
-
-/**
- * Parse component slot with validation
- */
-export const parseComponentSlot = createOptionParser(
-  ComponentSlot,
-  "component slot",
-  "Valid slots: header, footer, sidebar, main, checkout-summary, payment-method, shipping-method, customer-info, order-confirmation",
-);
-
-/**
- * Parse function invocation with validation
- */
-export const parseFunctionInvocation = createOptionParser(
-  FunctionInvocationType,
-  "function invocation",
-  "Valid invocations: request, response",
-);
-
-/**
- * Parse boolean option with better error handling
- */
-export function parseBooleanOption(value: string): boolean {
-  const normalized = value.toLowerCase().trim();
-
-  if (["true", "1", "yes", "y"].includes(normalized)) {
-    return true;
-  }
-
-  if (["false", "0", "no", "n"].includes(normalized)) {
-    return false;
-  }
-
-  throw new InvalidArgumentError(
-    `Invalid boolean value: "${value}". Use true/false, yes/no, or 1/0`,
-  );
-}
-
-/**
- * Parse path option with validation
- */
-export const parsePath = createOptionParser(PathSchema, "path");
-
-/**
- * Parse UUID with validation
- */
-export const parseUUID = createOptionParser(
-  z
-    .string()
-    .uuid("Must be a valid UUID (e.g., 123e4567-e89b-12d3-a456-426614174000)"),
-  "ID",
-  "Format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-);
-
-/**
- * Parse store ID with validation
- */
-export const parseStoreId = createOptionParser(
-  StoreIdSchema,
-  "store ID",
-  "Example: 123e4567-e89b-12d3-a456-426614174000",
-);
-
-/**
- * Parse version name with validation
- */
-export const parseVersionName = createOptionParser(
-  VersionNameSchema,
-  "version name",
-  "Examples: v1.0.0, summer-sale-2024, black-friday",
-);
-
-/**
- * Parse priority with validation
- */
-export const parsePriority = (value: string): number => {
-  const numValue = Number(value);
-  if (Number.isNaN(numValue)) {
-    throw new InvalidArgumentError(
-      `Priority must be a number, received: ${value}`,
-    );
-  }
-
-  const result = PrioritySchema.safeParse(numValue);
-  if (!result.success) {
-    const errors = result.error.errors.map((err) => err.message).join(", ");
-    throw new InvalidArgumentError(`Invalid priority: ${errors}`);
-  }
-
-  return result.data;
-};
-
-/**
- * Create an enhanced option configuration with validation
- */
-export interface EnhancedOption {
-  flags: string;
-  description: string;
-  defaultValue?: unknown;
-  parser?: (value: string) => unknown;
-  required?: boolean;
-}
-
-/**
- * Common option configurations
- */
-export const COMMON_OPTIONS = {
-  componentName: {
-    flags: "-n, --name <name>",
-    description: "Component name (lowercase with hyphens)",
-    parser: parseComponentName,
-    required: true,
-  },
-  functionName: {
-    flags: "-n, --name <name>",
-    description: "Function name (lowercase with hyphens)",
-    parser: parseFunctionName,
-    required: true,
-  },
-  componentSlot: {
-    flags: "-s, --slot <slot>",
-    description:
-      "Component slot (header|footer|sidebar|main|checkout-summary|payment-method|shipping-method|customer-info|order-confirmation)",
-    parser: parseComponentSlot,
-    defaultValue: "main",
-  },
-  functionInvocation: {
-    flags: "-i, --invocation <invocation>",
-    description: "Function invocation type (request|response)",
-    parser: parseFunctionInvocation,
-    defaultValue: "request",
-  },
-  tests: {
-    flags: "--tests",
-    description: "Include test files (default: true)",
-    defaultValue: true,
-  },
-  noTests: {
-    flags: "--no-tests",
-    description: "Skip test file generation",
-  },
-  path: {
-    flags: "-p, --path <path>",
-    description: "Path to component or function directory",
-    parser: parsePath,
-  },
-  storeId: {
-    flags: "-s, --store <id>",
-    description: "Store ID (UUID format)",
-    parser: parseStoreId,
-    required: true,
-  },
-  versionName: {
-    flags: "-n, --name <name>",
-    description: "Version name",
-    parser: parseVersionName,
-    required: true,
-  },
-  template: {
-    flags: "-t, --template <template>",
-    description: "Template to use (default|grocery|sales)",
-    defaultValue: "default",
-  },
-  active: {
-    flags: "--active",
-    description: "Make version active (default: true)",
-    defaultValue: true,
-  },
-  noActive: {
-    flags: "--no-active",
-    description: "Create inactive version",
-  },
-  force: {
-    flags: "-f, --force",
-    description: "Skip confirmation prompts",
-    defaultValue: false,
-  },
-  watch: {
-    flags: "--watch",
-    description: "Watch for changes and rebuild automatically",
-    defaultValue: false,
-  },
-  priority: {
-    flags: "-p, --priority <priority>",
-    description: "Execution priority (0-100)",
-    parser: parsePriority,
-    defaultValue: 0,
-  },
-} satisfies Record<string, EnhancedOption>;