@ollie-shop/cli 0.2.0 → 0.3.0

package/dist/utils/command-builder.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCommand = buildCommand;
+exports.buildCommandGroup = buildCommandGroup;
+const zod_1 = require("zod");
+const console_1 = require("./console");
+const validation_error_formatter_1 = require("./validation-error-formatter");
+/**
+ * Build an enhanced command with validation and error handling
+ */
+function setupCommandAliases(cmd, aliases) {
+    if (!aliases)
+        return;
+    for (const alias of aliases) {
+        cmd.alias(alias);
+    }
+}
+function isValidDefaultValue(value) {
+    return (typeof value === "string" ||
+        typeof value === "boolean" ||
+        Array.isArray(value));
+}
+function addOption(cmd, option) {
+    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, options) {
+    if (!options)
+        return;
+    for (const option of options) {
+        addOption(cmd, option);
+    }
+}
+function setupCommandExamples(cmd, examples) {
+    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`);
+    }
+}
+function buildCommand(parent, config) {
+    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(options, config, parent);
+            await config.handler(validatedOptions, console_1.console);
+        }
+        catch (error) {
+            handleCommandError(error, config, parent);
+        }
+    });
+    // Override error handling
+    cmd.exitOverride();
+    cmd.configureOutput({
+        writeErr: (str) => handleCommanderError(str, parent, cmd, config),
+    });
+    return cmd;
+}
+/**
+ * Extract option name from flags string
+ */
+function getOptionName(flags) {
+    // 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(options, config, parent) {
+    let validatedOptions = options;
+    // Validate with schema if provided
+    if (config.schema) {
+        const result = config.schema.safeParse(options);
+        if (!result.success) {
+            const errors = (0, validation_error_formatter_1.formatZodError)(result.error, parent.name());
+            (0, validation_error_formatter_1.displayErrors)(console_1.console, errors, `${parent.name()} ${config.name}`);
+            // Throw an error that will be caught by the command handler
+            const error = new Error("Validation failed");
+            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(options, config, parent) {
+    if (!config.options)
+        return;
+    const missingRequired = config.options
+        .filter((opt) => opt.required &&
+        !options[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");
+        error.exitCode = 1;
+        error.isValidationError = true;
+        throw error;
+    }
+}
+/**
+ * Display missing required options
+ */
+function displayMissingOptions(missingRequired, config, parent) {
+    console_1.console.error("❌ Missing required options:");
+    for (const optName of missingRequired) {
+        const opt = config.options?.find((o) => getOptionName(o.flags) === optName);
+        if (opt) {
+            console_1.console.error(`  • --${optName}: ${opt.description}`);
+        }
+    }
+    console_1.console.log("");
+    console_1.console.info(`💡 For more help, run: ollieshop ${parent.name()} ${config.name} --help`);
+}
+/**
+ * Handle command errors
+ */
+function handleCommandError(error, config, parent) {
+    // Check if this is a validation error that was already displayed
+    if (error instanceof Error) {
+        const cliError = error;
+        if (cliError.isValidationError) {
+            // Error messages already displayed, just exit
+            process.exit(cliError.exitCode || 1);
+        }
+    }
+    else if (error instanceof zod_1.z.ZodError) {
+        const errors = (0, validation_error_formatter_1.formatZodError)(error, config.name);
+        (0, validation_error_formatter_1.displayErrors)(console_1.console, errors, `${parent.name()} ${config.name}`);
+    }
+    else {
+        console_1.console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    process.exit(1);
+}
+/**
+ * Handle Commander.js errors
+ */
+function handleCommanderError(str, parent, cmd, config) {
+    if (str.includes("error: unknown option")) {
+        handleUnknownOption(str, parent, cmd, config);
+    }
+    else if (str.includes("error: missing required argument")) {
+        handleMissingArgument(str, parent, config);
+    }
+    else {
+        console_1.console.error(str.trim());
+    }
+}
+/**
+ * Handle unknown option error
+ */
+function handleUnknownOption(str, parent, cmd, config) {
+    const match = str.match(/unknown option '(.+)'/);
+    if (!match)
+        return;
+    const unknownOption = match[1] ?? "";
+    console_1.console.error(`❌ Unknown option: ${unknownOption}`);
+    // Suggest similar options
+    const validOptions = config.options?.map((opt) => `--${getOptionName(opt.flags)}`) || [];
+    const suggestion = (0, validation_error_formatter_1.suggestCommand)(unknownOption.replace(/^-+/, ""), validOptions.map((opt) => opt.replace(/^-+/, "")));
+    if (suggestion) {
+        console_1.console.log("");
+        console_1.console.info(`💡 Did you mean: --${suggestion}?`);
+    }
+    console_1.console.log("");
+    console_1.console.info(`💡 For available options, run: ollieshop ${parent.name()} ${cmd.name()} --help`);
+}
+/**
+ * Handle missing argument error
+ */
+function handleMissingArgument(str, parent, config) {
+    const match = str.match(/missing required argument '(.+)'/);
+    if (!match)
+        return;
+    console_1.console.error(`❌ Missing required argument: ${match[1]}`);
+    console_1.console.log("");
+    console_1.console.info(`💡 For usage help, run: ollieshop ${parent.name()} ${config.name} --help`);
+}
+/**
+ * Build a command group (like "component" or "function")
+ */
+function buildCommandGroup(program, name, description, aliases) {
+    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, cmd, groupName) {
+    if (str.includes("is not a") && str.includes("command")) {
+        handleUnknownSubcommand(str, cmd, groupName);
+    }
+    else {
+        console_1.console.error(str.trim());
+    }
+}
+/**
+ * Handle unknown subcommand error
+ */
+function handleUnknownSubcommand(str, cmd, groupName) {
+    const match = str.match(/'([^']+)' is not a/);
+    if (!match)
+        return;
+    const unknownCmd = match[1] ?? "";
+    console_1.console.error(`❌ Unknown command: ${unknownCmd}`);
+    // Get subcommands
+    const subcommands = cmd.commands.map((c) => c.name());
+    const suggestion = (0, validation_error_formatter_1.suggestCommand)(unknownCmd, subcommands);
+    if (suggestion) {
+        console_1.console.log("");
+        console_1.console.info(`💡 Did you mean: ollieshop ${groupName} ${suggestion}?`);
+    }
+    console_1.console.log("");
+    console_1.console.info("💡 Available commands:");
+    for (const subcmd of subcommands) {
+        console_1.console.log(`   • ${subcmd}`);
+    }
+}

package/dist/utils/command-helpers.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import type { CliConsole } from "./console";
+/**
+ * Handle errors in a consistent way across all commands
+ */
+export declare function handleCommandError(error: unknown, console: CliConsole): void;
+/**
+ * Parse and validate command options using a Zod schema
+ */
+export declare function parseOptions<T>(schema: z.ZodSchema<T>, options: Record<string, unknown>): T;
+/**
+ * Create an action handler with schema validation and error handling
+ */
+export declare function createAction<T>(schema: z.ZodSchema<T>, action: (options: T, cliConsole: CliConsole) => Promise<void>): (firstArg: unknown, options: Record<string, unknown>) => Promise<void>;
+/**
+ * Create a simple action handler without schema validation
+ */
+export declare function createSimpleAction(action: (cliConsole: CliConsole) => Promise<void>): () => Promise<void>;
+//# sourceMappingURL=command-helpers.d.ts.map

package/dist/utils/command-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-helpers.d.ts","sourceRoot":"","sources":["../../src/utils/command-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAU5E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACtB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,CAAC,CAYH;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACtB,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,IAE/C,UAAU,OAAO,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,mBAqBlE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,uBASlD"}

package/dist/utils/command-helpers.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCommandError = handleCommandError;
+exports.parseOptions = parseOptions;
+exports.createAction = createAction;
+exports.createSimpleAction = createSimpleAction;
+const zod_1 = require("zod");
+const console_1 = require("./console");
+/**
+ * Handle errors in a consistent way across all commands
+ */
+function handleCommandError(error, console) {
+    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
+ */
+function parseOptions(schema, options) {
+    try {
+        return schema.parse(options);
+    }
+    catch (error) {
+        if (error instanceof zod_1.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
+ */
+function createAction(schema, action) {
+    return async (firstArg, options) => {
+        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, console_1.console);
+        }
+        catch (error) {
+            handleCommandError(error, console_1.console);
+        }
+    };
+}
+/**
+ * Create a simple action handler without schema validation
+ */
+function createSimpleAction(action) {
+    return async () => {
+        try {
+            await action(console_1.console);
+        }
+        catch (error) {
+            handleCommandError(error, console_1.console);
+        }
+    };
+}

package/dist/utils/command-parser.d.ts

@@ -0,0 +1,146 @@
+import { z } from "zod";
+/**
+ * Create a Commander option parser that validates with Zod schema
+ */
+export declare function createOptionParser<T>(schema: z.ZodSchema<T>, fieldName: string, helpText?: string): (value: string) => T;
+/**
+ * Parse component name with validation
+ */
+export declare const parseComponentName: (value: string) => string;
+/**
+ * Parse function name with validation
+ */
+export declare const parseFunctionName: (value: string) => string;
+/**
+ * Parse component slot with validation
+ */
+export declare const parseComponentSlot: (value: string) => "header" | "footer" | "sidebar" | "main" | "checkout-summary" | "payment-method" | "shipping-method" | "customer-info" | "order-confirmation";
+/**
+ * Parse function invocation with validation
+ */
+export declare const parseFunctionInvocation: (value: string) => "request" | "response";
+/**
+ * Parse boolean option with better error handling
+ */
+export declare function parseBooleanOption(value: string): boolean;
+/**
+ * Parse path option with validation
+ */
+export declare const parsePath: (value: string) => string;
+/**
+ * Parse UUID with validation
+ */
+export declare const parseUUID: (value: string) => string;
+/**
+ * Parse store ID with validation
+ */
+export declare const parseStoreId: (value: string) => string;
+/**
+ * Parse version name with validation
+ */
+export declare const parseVersionName: (value: string) => string;
+/**
+ * Parse priority with validation
+ */
+export declare const parsePriority: (value: string) => number;
+/**
+ * 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 declare const COMMON_OPTIONS: {
+    componentName: {
+        flags: string;
+        description: string;
+        parser: (value: string) => string;
+        required: true;
+    };
+    functionName: {
+        flags: string;
+        description: string;
+        parser: (value: string) => string;
+        required: true;
+    };
+    componentSlot: {
+        flags: string;
+        description: string;
+        parser: (value: string) => "header" | "footer" | "sidebar" | "main" | "checkout-summary" | "payment-method" | "shipping-method" | "customer-info" | "order-confirmation";
+        defaultValue: string;
+    };
+    functionInvocation: {
+        flags: string;
+        description: string;
+        parser: (value: string) => "request" | "response";
+        defaultValue: string;
+    };
+    tests: {
+        flags: string;
+        description: string;
+        defaultValue: boolean;
+    };
+    noTests: {
+        flags: string;
+        description: string;
+    };
+    path: {
+        flags: string;
+        description: string;
+        parser: (value: string) => string;
+    };
+    wait: {
+        flags: string;
+        description: string;
+        defaultValue: boolean;
+    };
+    storeId: {
+        flags: string;
+        description: string;
+        parser: (value: string) => string;
+        required: true;
+    };
+    versionName: {
+        flags: string;
+        description: string;
+        parser: (value: string) => string;
+        required: true;
+    };
+    template: {
+        flags: string;
+        description: string;
+        defaultValue: string;
+    };
+    active: {
+        flags: string;
+        description: string;
+        defaultValue: boolean;
+    };
+    noActive: {
+        flags: string;
+        description: string;
+    };
+    force: {
+        flags: string;
+        description: string;
+        defaultValue: boolean;
+    };
+    watch: {
+        flags: string;
+        description: string;
+        defaultValue: boolean;
+    };
+    priority: {
+        flags: string;
+        description: string;
+        parser: (value: string) => number;
+        defaultValue: number;
+    };
+};
+//# sourceMappingURL=command-parser.d.ts.map

package/dist/utils/command-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-parser.d.ts","sourceRoot":"","sources":["../../src/utils/command-parser.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,IAET,OAAO,MAAM,KAAG,CAAC,CAiB1B;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,UAtBd,MAAM,WA0BtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,UA/Bb,MAAM,WAmCtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,UAxCd,MAAM,kJA4CtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,UAjDnB,MAAM,2BAqDtB,CAAC;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAczD;AAED;;GAEG;AACH,eAAO,MAAM,SAAS,UA7EL,MAAM,WA6EwC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,SAAS,UAlFL,MAAM,WAwFtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,UA7FR,MAAM,WAiGtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,UAtGZ,MAAM,WA0GtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,MAe7C,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;wBA9IV,MAAM;;;;;;wBAAN,MAAM;;;;;;wBAAN,MAAM;;;;;;wBAAN,MAAM;;;;;;;;;;;;;;;wBAAN,MAAM;;;;;;;;;;wBAAN,MAAM;;;;;;wBAAN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+Gc,MAAM,KAAG,MAAM;;;CAsHV,CAAC"}