@jaypie/fabric 0.1.0

package/dist/esm/commander/index.js

@@ -0,0 +1,1482 @@
+import { Option, Command } from 'commander';
+import { BadRequestError } from '@jaypie/errors';
+
+// Create Commander.js options from service config
+/**
+ * Convert camelCase to kebab-case
+ */
+function toKebabCase$1(str) {
+    return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/**
+ * Check if a type is a typed array (e.g., [String], [Number])
+ */
+function isTypedArrayType$2(type) {
+    if (!Array.isArray(type)) {
+        return false;
+    }
+    if (type.length === 0) {
+        return true; // [] is untyped array
+    }
+    if (type.length !== 1) {
+        return false;
+    }
+    const element = type[0];
+    return (element === Boolean ||
+        element === Number ||
+        element === String ||
+        element === Object ||
+        element === "boolean" ||
+        element === "number" ||
+        element === "string" ||
+        element === "object" ||
+        element === "" ||
+        (typeof element === "object" &&
+            element !== null &&
+            !(element instanceof RegExp) &&
+            Object.keys(element).length === 0));
+}
+/**
+ * Check if a type represents a boolean
+ */
+function isBooleanType$1(type) {
+    return type === Boolean || type === "boolean";
+}
+/**
+ * Check if a type is variadic (array-like)
+ */
+function isVariadicType(type) {
+    if (type === Array || type === "array") {
+        return true;
+    }
+    return isTypedArrayType$2(type);
+}
+/**
+ * Get default description for a field
+ */
+function getDescription(fieldName, definition, override) {
+    if (override?.description) {
+        return override.description;
+    }
+    if (definition.description) {
+        return definition.description;
+    }
+    return fieldName;
+}
+/**
+ * Build the flags string for an option
+ */
+function buildFlags(fieldName, definition, override) {
+    if (override?.flags) {
+        return override.flags;
+    }
+    // Priority: override.long > definition.flag > toKebabCase(fieldName)
+    const long = override?.long ?? definition.flag ?? toKebabCase$1(fieldName);
+    // Priority: override.short > definition.letter
+    const short = override?.short ?? definition.letter;
+    const isBoolean = isBooleanType$1(definition.type);
+    const isVariadic = isVariadicType(definition.type);
+    const isRequired = definition.required !== false && definition.default === undefined;
+    let flags = "";
+    if (short) {
+        flags += `-${short}, `;
+    }
+    flags += `--${long}`;
+    if (!isBoolean) {
+        if (isVariadic) {
+            // Variadic: can take multiple values
+            if (isRequired) {
+                flags += ` <${fieldName}...>`;
+            }
+            else {
+                flags += ` [${fieldName}...]`;
+            }
+        }
+        else {
+            // Scalar value
+            if (isRequired) {
+                flags += ` <${fieldName}>`;
+            }
+            else {
+                flags += ` [${fieldName}]`;
+            }
+        }
+    }
+    return flags;
+}
+/**
+ * Create a Commander Option from a field definition
+ */
+function createOption(fieldName, definition, override) {
+    const flags = buildFlags(fieldName, definition, override);
+    const description = getDescription(fieldName, definition, override);
+    const option = new Option(flags, description);
+    // Set default value if provided
+    if (definition.default !== undefined) {
+        option.default(definition.default);
+    }
+    // Hide from help if specified
+    if (override?.hidden) {
+        option.hideHelp();
+    }
+    return option;
+}
+/**
+ * Create Commander.js Option objects from a service config
+ *
+ * @param input - The input field definitions from a service config
+ * @param config - Optional configuration for excluding fields or overriding options
+ * @returns An object containing an array of Commander Option objects
+ *
+ * @example
+ * ```typescript
+ * const handler = createService({
+ *   input: {
+ *     name: { type: String, description: "User name" },
+ *     age: { type: Number, default: 25 },
+ *     verbose: { type: Boolean },
+ *   },
+ *   service: (input) => input,
+ * });
+ *
+ * const { options } = createCommanderOptions(handler.input);
+ * options.forEach(opt => command.addOption(opt));
+ * ```
+ */
+function createCommanderOptions(input, config = {}) {
+    if (!input) {
+        return { options: [] };
+    }
+    const { exclude = [], overrides = {} } = config;
+    const options = [];
+    for (const [fieldName, definition] of Object.entries(input)) {
+        // Skip excluded fields
+        if (exclude.includes(fieldName)) {
+            continue;
+        }
+        const override = overrides[fieldName];
+        const option = createOption(fieldName, definition, override);
+        options.push(option);
+        // For boolean fields, also create a --no-<flag> option for negation
+        // Commander.js requires separate options for --flag and --no-flag
+        if (isBooleanType$1(definition.type) && !override?.flags) {
+            const long = override?.long ?? definition.flag ?? toKebabCase$1(fieldName);
+            const negateOption = new Option(`--no-${long}`, `Disable ${fieldName}`);
+            // Hide the negatable option from help to avoid clutter
+            negateOption.hideHelp();
+            options.push(negateOption);
+        }
+    }
+    return { options };
+}
+
+/**
+ * Meta-modeling Constants
+ */
+// =============================================================================
+// Constants
+// =============================================================================
+/** Root organizational unit */
+/** Fabric version - used to identify pre-instantiated Services */
+const FABRIC_VERSION = "0.1.0";
+
+/**
+ * Date Type Conversion for @jaypie/fabric
+ *
+ * Adds Date as a supported type in the fabric type system.
+ * Follows the same conversion patterns as String, Number, Boolean.
+ */
+/**
+ * Convert a value to a Date
+ *
+ * Supported inputs:
+ * - Date: returned as-is (validated)
+ * - Number: treated as Unix timestamp (milliseconds)
+ * - String: parsed via Date constructor (ISO 8601, etc.)
+ * - Object with value property: unwrapped and converted
+ *
+ * @throws BadRequestError if value cannot be converted to valid Date
+ */
+function fabricDate(value) {
+    // Already a Date
+    if (value instanceof Date) {
+        if (Number.isNaN(value.getTime())) {
+            throw new BadRequestError("Invalid Date value");
+        }
+        return value;
+    }
+    // Null/undefined
+    if (value === null || value === undefined) {
+        throw new BadRequestError("Cannot convert null or undefined to Date");
+    }
+    // Object with value property (fabric pattern)
+    if (typeof value === "object" && value !== null && "value" in value) {
+        return fabricDate(value.value);
+    }
+    // Number (timestamp in milliseconds)
+    if (typeof value === "number") {
+        if (Number.isNaN(value)) {
+            throw new BadRequestError("Cannot convert NaN to Date");
+        }
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) {
+            throw new BadRequestError(`Cannot convert ${value} to Date`);
+        }
+        return date;
+    }
+    // String (ISO 8601 or parseable format)
+    if (typeof value === "string") {
+        // Empty string is invalid
+        if (value.trim() === "") {
+            throw new BadRequestError("Cannot convert empty string to Date");
+        }
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) {
+            throw new BadRequestError(`Cannot convert "${value}" to Date`);
+        }
+        return date;
+    }
+    // Boolean cannot be converted to Date
+    if (typeof value === "boolean") {
+        throw new BadRequestError("Cannot convert boolean to Date");
+    }
+    // Arrays - attempt single element extraction
+    if (Array.isArray(value)) {
+        if (value.length === 1) {
+            return fabricDate(value[0]);
+        }
+        throw new BadRequestError(`Cannot convert array with ${value.length} elements to Date`);
+    }
+    throw new BadRequestError(`Cannot convert ${typeof value} to Date`);
+}
+/**
+ * Type guard for Date type in schema definitions
+ */
+function isDateType(type) {
+    return type === Date;
+}
+
+// Fabric functions for @jaypie/fabric
+/**
+ * Try to parse a string as JSON if it looks like JSON
+ * Returns the parsed value or the original string if not JSON
+ */
+function tryParseJson(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // Not valid JSON, return original
+            return value;
+        }
+    }
+    return value;
+}
+/**
+ * Unwrap arrays and objects to get to the scalar value
+ * - Single-element arrays unwrap to their element
+ * - Objects with value property unwrap to that value
+ * - Recursively unwraps nested structures
+ */
+function unwrapToScalar(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    // Unwrap single-element arrays
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return undefined;
+        }
+        if (value.length === 1) {
+            return unwrapToScalar(value[0]);
+        }
+        throw new BadRequestError("Cannot convert multi-value array to scalar");
+    }
+    // Unwrap objects with value property
+    if (typeof value === "object") {
+        const obj = value;
+        if ("value" in obj) {
+            return unwrapToScalar(obj.value);
+        }
+        throw new BadRequestError("Object must have a value attribute");
+    }
+    return value;
+}
+/**
+ * Prepare a value for scalar conversion by parsing JSON strings and unwrapping
+ */
+function prepareForScalarConversion(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    // Try to parse JSON strings
+    if (typeof value === "string") {
+        const parsed = tryParseJson(value);
+        if (parsed !== value) {
+            // Successfully parsed, unwrap the result
+            return unwrapToScalar(parsed);
+        }
+        return value;
+    }
+    // Unwrap arrays and objects
+    if (Array.isArray(value) || typeof value === "object") {
+        return unwrapToScalar(value);
+    }
+    return value;
+}
+/**
+ * Convert a value to a boolean
+ * - Arrays, objects, and JSON strings are unwrapped first
+ * - String "true" becomes true
+ * - String "false" becomes false
+ * - Strings that parse to numbers: positive = true, zero or negative = false
+ * - Numbers: positive = true, zero or negative = false
+ * - Boolean passes through
+ */
+function fabricBoolean(value) {
+    // Prepare value by parsing JSON and unwrapping arrays/objects
+    const prepared = prepareForScalarConversion(value);
+    if (prepared === undefined || prepared === null) {
+        return undefined;
+    }
+    if (typeof prepared === "boolean") {
+        return prepared;
+    }
+    if (typeof prepared === "string") {
+        if (prepared === "") {
+            return undefined;
+        }
+        const lower = prepared.toLowerCase();
+        if (lower === "true") {
+            return true;
+        }
+        if (lower === "false") {
+            return false;
+        }
+        // Try to parse as number
+        const num = parseFloat(prepared);
+        if (isNaN(num)) {
+            throw new BadRequestError(`Cannot convert "${prepared}" to Boolean`);
+        }
+        return num > 0;
+    }
+    if (typeof prepared === "number") {
+        if (isNaN(prepared)) {
+            throw new BadRequestError("Cannot convert NaN to Boolean");
+        }
+        return prepared > 0;
+    }
+    throw new BadRequestError(`Cannot convert ${typeof prepared} to Boolean`);
+}
+/**
+ * Convert a value to a number
+ * - Arrays, objects, and JSON strings are unwrapped first
+ * - String "" becomes undefined
+ * - String "true" becomes 1
+ * - String "false" becomes 0
+ * - Strings that parse to numbers use those values
+ * - Strings that parse to NaN throw BadRequestError
+ * - Boolean true becomes 1, false becomes 0
+ * - Number passes through
+ */
+function fabricNumber(value) {
+    // Prepare value by parsing JSON and unwrapping arrays/objects
+    const prepared = prepareForScalarConversion(value);
+    if (prepared === undefined || prepared === null) {
+        return undefined;
+    }
+    if (typeof prepared === "number") {
+        if (isNaN(prepared)) {
+            throw new BadRequestError("Cannot convert NaN to Number");
+        }
+        return prepared;
+    }
+    if (typeof prepared === "boolean") {
+        return prepared ? 1 : 0;
+    }
+    if (typeof prepared === "string") {
+        if (prepared === "") {
+            return undefined;
+        }
+        const lower = prepared.toLowerCase();
+        if (lower === "true") {
+            return 1;
+        }
+        if (lower === "false") {
+            return 0;
+        }
+        const num = parseFloat(prepared);
+        if (isNaN(num)) {
+            throw new BadRequestError(`Cannot convert "${prepared}" to Number`);
+        }
+        return num;
+    }
+    throw new BadRequestError(`Cannot convert ${typeof prepared} to Number`);
+}
+/**
+ * Convert a value to a string
+ * - Arrays, objects, and JSON strings are unwrapped first
+ * - String "" becomes undefined
+ * - Boolean true becomes "true", false becomes "false"
+ * - Number converts to string representation
+ * - String passes through
+ */
+function fabricString(value) {
+    // Prepare value by parsing JSON and unwrapping arrays/objects
+    const prepared = prepareForScalarConversion(value);
+    if (prepared === undefined || prepared === null) {
+        return undefined;
+    }
+    if (typeof prepared === "string") {
+        if (prepared === "") {
+            return undefined;
+        }
+        return prepared;
+    }
+    if (typeof prepared === "boolean") {
+        return prepared ? "true" : "false";
+    }
+    if (typeof prepared === "number") {
+        if (isNaN(prepared)) {
+            throw new BadRequestError("Cannot convert NaN to String");
+        }
+        return String(prepared);
+    }
+    throw new BadRequestError(`Cannot convert ${typeof prepared} to String`);
+}
+/**
+ * Convert a value to an array
+ * - Non-arrays become arrays containing that value
+ * - Arrays of a single value become that value (unwrapped)
+ * - Multi-value arrays throw BadRequestError
+ * - undefined/null become undefined
+ */
+function fabricArray(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        // Arrays pass through (single-element unwrapping happens when converting FROM array)
+        return value;
+    }
+    // Non-arrays become single-element arrays
+    return [value];
+}
+/**
+ * Convert a value to an object with a value property
+ * - Scalars become { value: scalar }
+ * - Arrays become { value: array }
+ * - Objects with a value attribute pass through
+ * - Objects without a value attribute throw BadRequestError
+ * - undefined/null become undefined
+ */
+function fabricObject(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    // Check if already an object (but not an array)
+    if (typeof value === "object" && !Array.isArray(value)) {
+        const obj = value;
+        if ("value" in obj) {
+            return obj;
+        }
+        throw new BadRequestError("Object must have a value attribute");
+    }
+    // Scalars and arrays become { value: ... }
+    return { value };
+}
+/**
+ * Check if a type is a typed array (e.g., [String], [Number], [], etc.)
+ */
+function isTypedArrayType$1(type) {
+    return Array.isArray(type);
+}
+/**
+ * Split a string on comma or tab delimiters for typed array conversion.
+ * Only splits if the string contains commas or tabs.
+ * Returns the original value if not a string or no delimiters found.
+ */
+function splitStringForArray(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    // Check for comma or tab delimiters
+    if (value.includes(",")) {
+        return value.split(",").map((s) => s.trim());
+    }
+    if (value.includes("\t")) {
+        return value.split("\t").map((s) => s.trim());
+    }
+    return value;
+}
+/**
+ * Try to parse a string as JSON for array context.
+ * Returns parsed value if it's an array, otherwise returns original.
+ */
+function tryParseJsonArray(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Not valid JSON, fall through
+        }
+    }
+    return value;
+}
+/**
+ * Get the element type from a typed array type
+ * Returns undefined for untyped arrays ([])
+ */
+function getArrayElementType(type) {
+    if (type.length === 0) {
+        return undefined; // Untyped array
+    }
+    const elementType = type[0];
+    // Handle constructor types
+    if (elementType === Boolean)
+        return "boolean";
+    if (elementType === Number)
+        return "number";
+    if (elementType === String)
+        return "string";
+    if (elementType === Object)
+        return "object";
+    // Handle string types
+    if (elementType === "boolean")
+        return "boolean";
+    if (elementType === "number")
+        return "number";
+    if (elementType === "string")
+        return "string";
+    if (elementType === "object")
+        return "object";
+    // Handle shorthand types
+    if (elementType === "")
+        return "string"; // "" shorthand for String
+    if (typeof elementType === "object" &&
+        elementType !== null &&
+        Object.keys(elementType).length === 0) {
+        return "object"; // {} shorthand for Object
+    }
+    throw new BadRequestError(`Unknown array element type: ${String(elementType)}`);
+}
+/**
+ * Convert a value to a typed array
+ * - Tries to parse JSON arrays first
+ * - Splits strings on comma/tab if present
+ * - Wraps non-arrays in an array
+ * - Converts each element to the specified element type
+ */
+function fabricTypedArray(value, elementType) {
+    // Try to parse JSON array first
+    let processed = tryParseJsonArray(value);
+    // If still a string, try to split on comma/tab
+    processed = splitStringForArray(processed);
+    // Convert to array (wraps non-arrays)
+    const array = fabricArray(processed);
+    if (array === undefined) {
+        return undefined;
+    }
+    // If no element type specified, return as-is
+    if (elementType === undefined) {
+        return array;
+    }
+    // Convert each element to the element type
+    return array.map((element, index) => {
+        try {
+            switch (elementType) {
+                case "boolean":
+                    return fabricBoolean(element);
+                case "number":
+                    return fabricNumber(element);
+                case "object":
+                    return fabricObject(element);
+                case "string":
+                    return fabricString(element);
+                default:
+                    throw new BadRequestError(`Unknown element type: ${elementType}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof BadRequestError) {
+                throw new BadRequestError(`Cannot convert array element at index ${index}: ${error.message}`);
+            }
+            throw error;
+        }
+    });
+}
+/**
+ * Fabric a value to the specified type
+ */
+function fabric(value, type) {
+    // Check for Date type first
+    if (isDateType(type)) {
+        return fabricDate(value);
+    }
+    // Check for typed array types
+    if (isTypedArrayType$1(type)) {
+        const elementType = getArrayElementType(type);
+        return fabricTypedArray(value, elementType);
+    }
+    const normalizedType = normalizeType(type);
+    switch (normalizedType) {
+        case "array":
+            return fabricArray(value);
+        case "boolean":
+            return fabricBoolean(value);
+        case "number":
+            return fabricNumber(value);
+        case "object":
+            return fabricObject(value);
+        case "string":
+            return fabricString(value);
+        default:
+            throw new BadRequestError(`Unknown type: ${String(type)}`);
+    }
+}
+/**
+ * Normalize type to string representation
+ */
+function normalizeType(type) {
+    if (type === Array || type === "array") {
+        return "array";
+    }
+    if (type === Boolean || type === "boolean") {
+        return "boolean";
+    }
+    if (type === Number || type === "number") {
+        return "number";
+    }
+    if (type === Object || type === "object") {
+        return "object";
+    }
+    if (type === String || type === "string") {
+        return "string";
+    }
+    throw new BadRequestError(`Unknown type: ${String(type)}`);
+}
+
+// Service for @jaypie/fabric
+/**
+ * Check if a single-element array is a typed array type constructor.
+ */
+function isTypedArrayConstructor(element) {
+    return (element === Boolean ||
+        element === Number ||
+        element === String ||
+        element === Object ||
+        element === "boolean" ||
+        element === "number" ||
+        element === "string" ||
+        element === "object" ||
+        element === "" ||
+        (typeof element === "object" &&
+            element !== null &&
+            !(element instanceof RegExp) &&
+            Object.keys(element).length === 0));
+}
+/**
+ * Check if a type is a validated string type (array of string literals and/or RegExp).
+ * Distinguishes from typed arrays like [String], [Number], etc.
+ */
+function isValidatedStringType(type) {
+    if (!Array.isArray(type)) {
+        return false;
+    }
+    // Empty array is untyped array, not validated string
+    if (type.length === 0) {
+        return false;
+    }
+    // Single-element arrays with type constructors are typed arrays
+    if (type.length === 1 && isTypedArrayConstructor(type[0])) {
+        return false;
+    }
+    // Check that all elements are strings or RegExp
+    return type.every((item) => typeof item === "string" || item instanceof RegExp);
+}
+/**
+ * Check if a type is a validated number type (array of number literals).
+ * Distinguishes from typed arrays like [Number], etc.
+ */
+function isValidatedNumberType(type) {
+    if (!Array.isArray(type)) {
+        return false;
+    }
+    // Empty array is untyped array, not validated number
+    if (type.length === 0) {
+        return false;
+    }
+    // Single-element arrays with type constructors are typed arrays
+    if (type.length === 1 && isTypedArrayConstructor(type[0])) {
+        return false;
+    }
+    // Check that all elements are numbers
+    return type.every((item) => typeof item === "number");
+}
+/**
+ * Parse input string as JSON if it's a string
+ */
+function parseInput(input) {
+    if (input === undefined || input === null) {
+        return {};
+    }
+    if (typeof input === "string") {
+        if (input === "") {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(input);
+            if (typeof parsed !== "object" ||
+                parsed === null ||
+                Array.isArray(parsed)) {
+                throw new BadRequestError("Input must be an object");
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof BadRequestError) {
+                throw error;
+            }
+            throw new BadRequestError("Invalid JSON input");
+        }
+    }
+    if (typeof input === "object" && !Array.isArray(input)) {
+        return input;
+    }
+    throw new BadRequestError("Input must be an object or JSON string");
+}
+/**
+ * Run validation on a value (supports async validators)
+ */
+async function runValidation(value, validate, fieldName) {
+    if (typeof validate === "function") {
+        const result = await validate(value);
+        if (result === false) {
+            throw new BadRequestError(`Validation failed for field "${fieldName}"`);
+        }
+    }
+    else if (validate instanceof RegExp) {
+        if (typeof value !== "string" || !validate.test(value)) {
+            throw new BadRequestError(`Validation failed for field "${fieldName}"`);
+        }
+    }
+    else if (Array.isArray(validate)) {
+        // Check if value matches any item in the array
+        for (const item of validate) {
+            if (item instanceof RegExp) {
+                if (typeof value === "string" && item.test(value)) {
+                    return; // Match found
+                }
+            }
+            else if (typeof item === "function") {
+                try {
+                    const result = await item(value);
+                    if (result !== false) {
+                        return; // Match found
+                    }
+                }
+                catch {
+                    // Continue to next item
+                }
+            }
+            else if (value === item) {
+                return; // Scalar match found
+            }
+        }
+        throw new BadRequestError(`Validation failed for field "${fieldName}"`);
+    }
+}
+/**
+ * Check if a field is required
+ * A field is required unless it has a default OR required is explicitly false
+ */
+function isFieldRequired(definition) {
+    if (definition.required === false) {
+        return false;
+    }
+    if (definition.default !== undefined) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Process a single field through conversion and validation
+ */
+async function processField(fieldName, value, definition) {
+    // Apply default if value is undefined
+    let processedValue = value;
+    if (processedValue === undefined && definition.default !== undefined) {
+        processedValue = definition.default;
+    }
+    // Determine actual type and validation
+    let actualType = definition.type;
+    let validation = definition.validate;
+    // Handle bare RegExp shorthand: /regex/
+    if (definition.type instanceof RegExp) {
+        actualType = String;
+        validation = definition.type; // The RegExp becomes the validation
+    }
+    // Handle validated string shorthand: ["value1", "value2"] or [/regex/]
+    else if (isValidatedStringType(definition.type)) {
+        actualType = String;
+        validation = definition.type; // The array becomes the validation
+    }
+    // Handle validated number shorthand: [1, 2, 3]
+    else if (isValidatedNumberType(definition.type)) {
+        actualType = Number;
+        validation = definition.type; // The array becomes the validation
+    }
+    // Fabric to target type
+    const convertedValue = fabric(processedValue, actualType);
+    // Check if required field is missing
+    if (convertedValue === undefined && isFieldRequired(definition)) {
+        throw new BadRequestError(`Missing required field "${fieldName}"`);
+    }
+    // Run validation if provided
+    if (validation !== undefined && convertedValue !== undefined) {
+        await runValidation(convertedValue, validation, fieldName);
+    }
+    return convertedValue;
+}
+/**
+ * Fabric a service function
+ *
+ * Service builds a function that initiates a "controller" step that:
+ * - Parses the input if it is a string to object
+ * - Fabrics each input field to its type
+ * - Calls the validation function or regular expression or checks the array
+ * - Calls the service function and returns the response
+ *
+ * The returned function has config properties for introspection.
+ */
+function fabricService(config) {
+    const { input: inputDefinitions, service } = config;
+    const handler = async (rawInput, context) => {
+        // Parse input (handles string JSON)
+        const parsedInput = parseInput(rawInput);
+        // If no input definitions, pass through to service or return parsed input
+        if (!inputDefinitions) {
+            if (service) {
+                return service(parsedInput, context);
+            }
+            return parsedInput;
+        }
+        // Process all fields in parallel
+        const entries = Object.entries(inputDefinitions);
+        const processedValues = await Promise.all(entries.map(([fieldName, definition]) => processField(fieldName, parsedInput[fieldName], definition)));
+        // Build processed input object
+        const processedInput = {};
+        entries.forEach(([fieldName], index) => {
+            processedInput[fieldName] = processedValues[index];
+        });
+        // Return processed input if no service, otherwise call service
+        if (service) {
+            return service(processedInput, context);
+        }
+        return processedInput;
+    };
+    // Attach config properties directly to handler for flat access
+    const typedHandler = handler;
+    typedHandler.$fabric = FABRIC_VERSION;
+    if (config.alias !== undefined)
+        typedHandler.alias = config.alias;
+    if (config.description !== undefined)
+        typedHandler.description = config.description;
+    if (config.input !== undefined)
+        typedHandler.input = config.input;
+    if (config.service !== undefined)
+        typedHandler.service = config.service;
+    return typedHandler;
+}
+
+// Resolve inline service definitions to full Service objects
+/**
+ * Type guard to check if a value is a pre-instantiated Service
+ * A Service is a function with the `$fabric` property set by fabricService
+ */
+function isService(value) {
+    return typeof value === "function" && "$fabric" in value;
+}
+/**
+ * Resolve a service configuration to a full Service object
+ *
+ * Supports two patterns:
+ * 1. Inline service definition - pass a plain function as `service` along with
+ *    `alias`, `description`, and `input` in the config
+ * 2. Pre-instantiated Service - pass a Service object as `service`
+ *
+ * When a pre-instantiated Service is passed, config fields act as overrides:
+ * - `alias` overrides service.alias
+ * - `description` overrides service.description
+ * - `input` overrides service.input
+ *
+ * The original Service is never mutated - a new Service is created when overrides
+ * are applied.
+ *
+ * @example
+ * ```typescript
+ * // Inline service definition
+ * const service = resolveService({
+ *   alias: "greet",
+ *   description: "Greet a user",
+ *   input: { name: { type: String } },
+ *   service: ({ name }) => `Hello, ${name}!`,
+ * });
+ *
+ * // Pre-instantiated with override
+ * const baseService = fabricService({ alias: "foo", service: (x) => x });
+ * const overridden = resolveService({
+ *   alias: "bar",  // Override alias
+ *   service: baseService,
+ * });
+ * ```
+ */
+function resolveService(config) {
+    const { alias, description, input, service } = config;
+    if (isService(service)) {
+        // Service is pre-instantiated - config fields act as overrides
+        // Create new Service with merged properties (config overrides service)
+        return fabricService({
+            alias: alias ?? service.alias,
+            description: description ?? service.description,
+            input: input ?? service.input,
+            service: service.service,
+        });
+    }
+    // Service is an inline function - create Service from config
+    return fabricService({
+        alias,
+        description,
+        input,
+        service,
+    });
+}
+
+// Parse Commander.js options back to handler input format
+/**
+ * Convert kebab-case to camelCase
+ */
+function toCamelCase(str) {
+    return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+/**
+ * Convert camelCase to kebab-case
+ */
+function toKebabCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/**
+ * Check if a type is a typed array (e.g., [String], [Number])
+ */
+function isTypedArrayType(type) {
+    if (!Array.isArray(type)) {
+        return false;
+    }
+    if (type.length === 0) {
+        return true; // [] is untyped array
+    }
+    if (type.length !== 1) {
+        return false;
+    }
+    const element = type[0];
+    return (element === Boolean ||
+        element === Number ||
+        element === String ||
+        element === Object ||
+        element === "boolean" ||
+        element === "number" ||
+        element === "string" ||
+        element === "object" ||
+        element === "" ||
+        (typeof element === "object" &&
+            element !== null &&
+            !(element instanceof RegExp) &&
+            Object.keys(element).length === 0));
+}
+/**
+ * Check if a type represents a number (scalar or validated)
+ */
+function isNumberType(type) {
+    if (type === Number || type === "number") {
+        return true;
+    }
+    // Check for validated number type [1, 2, 3]
+    if (Array.isArray(type) && type.length > 0) {
+        // If it's not a typed array and all elements are numbers, it's a validated number
+        if (!isTypedArrayType(type) &&
+            type.every((item) => typeof item === "number")) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a type represents a boolean
+ */
+function isBooleanType(type) {
+    return type === Boolean || type === "boolean";
+}
+/**
+ * Check if a type is an array type (Array, "array", or typed array)
+ */
+function isArrayType(type) {
+    if (type === Array || type === "array") {
+        return true;
+    }
+    return isTypedArrayType(type);
+}
+/**
+ * Check if a type is an object type
+ */
+function isObjectType(type) {
+    return type === Object || type === "object";
+}
+/**
+ * Convert a single value based on its target type
+ */
+function convertValue(value, type) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    // Boolean type - Commander handles this automatically
+    if (isBooleanType(type)) {
+        if (typeof value === "boolean") {
+            return value;
+        }
+        if (typeof value === "string") {
+            const lower = value.toLowerCase();
+            if (lower === "true" || lower === "1" || lower === "yes") {
+                return true;
+            }
+            if (lower === "false" || lower === "0" || lower === "no") {
+                return false;
+            }
+        }
+        return Boolean(value);
+    }
+    // Number type
+    if (isNumberType(type)) {
+        if (typeof value === "number") {
+            return value;
+        }
+        if (typeof value === "string") {
+            const num = Number(value);
+            if (!isNaN(num)) {
+                return num;
+            }
+        }
+        return value;
+    }
+    // Date type
+    if (isDateType(type)) {
+        if (value instanceof Date) {
+            return value;
+        }
+        try {
+            return fabricDate(value);
+        }
+        catch {
+            // If conversion fails, return as-is and let createService handle it
+            return value;
+        }
+    }
+    // Array types - handle variadic options
+    if (isArrayType(type)) {
+        if (Array.isArray(value)) {
+            return value;
+        }
+        if (typeof value === "string") {
+            // Try to parse as JSON first
+            try {
+                const parsed = JSON.parse(value);
+                if (Array.isArray(parsed)) {
+                    return parsed;
+                }
+            }
+            catch {
+                // Not JSON, check for comma or tab separated
+                if (value.includes(",")) {
+                    return value.split(",").map((s) => s.trim());
+                }
+                if (value.includes("\t")) {
+                    return value.split("\t").map((s) => s.trim());
+                }
+            }
+            // Single value becomes array
+            return [value];
+        }
+        return [value];
+    }
+    // Object type - try to parse JSON
+    if (isObjectType(type)) {
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            return value;
+        }
+        if (typeof value === "string") {
+            try {
+                const parsed = JSON.parse(value);
+                if (typeof parsed === "object" &&
+                    parsed !== null &&
+                    !Array.isArray(parsed)) {
+                    return parsed;
+                }
+            }
+            catch {
+                // Not valid JSON
+            }
+        }
+        return value;
+    }
+    // String type (default) - just return as-is
+    return value;
+}
+/**
+ * Parse Commander.js options back to handler input format
+ *
+ * This function converts the options object from Commander.js (which uses
+ * kebab-case converted to camelCase) back to the expected handler input
+ * format with proper type conversion based on the input definitions.
+ *
+ * @param options - The options object from Commander.js (program.opts())
+ * @param config - Configuration including input field definitions
+ * @returns An object suitable for passing to a service
+ *
+ * @example
+ * ```typescript
+ * const handler = createService({
+ *   input: {
+ *     userName: { type: String },
+ *     age: { type: Number },
+ *     tags: { type: [String] },
+ *   },
+ *   service: (input) => input,
+ * });
+ *
+ * program.action((options) => {
+ *   const input = parseCommanderOptions(options, {
+ *     input: handler.input,
+ *   });
+ *   await handler(input);
+ * });
+ * ```
+ */
+function parseCommanderOptions(options, config = {}) {
+    const { exclude = [], input: inputDefinitions } = config;
+    const result = {};
+    // Build reverse mapping from flag name (camelCase) to field name
+    // This handles cases where input.flag overrides the default flag name
+    const flagToFieldMap = new Map();
+    if (inputDefinitions) {
+        for (const [fieldName, definition] of Object.entries(inputDefinitions)) {
+            if (definition.flag) {
+                // Custom flag: map flag (as camelCase) -> fieldName
+                const flagCamelCase = toCamelCase(definition.flag);
+                flagToFieldMap.set(flagCamelCase, fieldName);
+            }
+            else {
+                // Default: kebab-case of fieldName -> fieldName
+                const defaultFlag = toKebabCase(fieldName);
+                const defaultFlagCamelCase = toCamelCase(defaultFlag);
+                flagToFieldMap.set(defaultFlagCamelCase, fieldName);
+            }
+        }
+    }
+    for (const [key, value] of Object.entries(options)) {
+        // Skip excluded fields
+        if (exclude.includes(key)) {
+            continue;
+        }
+        // Convert kebab-case Commander option to camelCase
+        const keyCamelCase = toCamelCase(key);
+        // Look up the actual field name from our mapping
+        const fieldName = flagToFieldMap.get(keyCamelCase) ?? keyCamelCase;
+        // Skip if excluded after resolution
+        if (exclude.includes(fieldName)) {
+            continue;
+        }
+        // Get field definition for type conversion
+        const definition = inputDefinitions?.[fieldName];
+        if (definition) {
+            // Convert based on type definition
+            result[fieldName] = convertValue(value, definition.type);
+        }
+        else {
+            // No definition, pass through as-is
+            result[fieldName] = value;
+        }
+    }
+    return result;
+}
+
+// Fabric a service as a Commander command
+/**
+ * Fabric a service as a Commander.js command
+ *
+ * This function creates a command from a service, automatically:
+ * - Creating the command with the service's alias (or custom name)
+ * - Adding a description from the service's description (or custom)
+ * - Converting input definitions to Commander options
+ * - Wiring up the action to call the service with parsed input
+ *
+ * Error handling:
+ * - Services can call context.onError() for recoverable errors
+ * - Services can call context.onFatal() for fatal errors
+ * - Any error that throws out of the service is treated as fatal
+ *
+ * @param config - Configuration including service, program, and optional overrides
+ * @returns An object containing the created command
+ *
+ * @example
+ * ```typescript
+ * import { Command } from "commander";
+ * import { fabricService } from "@jaypie/fabric";
+ * import { fabricCommand } from "@jaypie/fabric/commander";
+ *
+ * const myService = fabricService({
+ *   alias: "greet",
+ *   description: "Greet a user",
+ *   input: {
+ *     userName: { type: String, description: "User name" },
+ *     loud: { type: Boolean, description: "Shout greeting" },
+ *   },
+ *   service: ({ userName, loud }) => {
+ *     const greeting = `Hello, ${userName}!`;
+ *     return loud ? greeting.toUpperCase() : greeting;
+ *   },
+ * });
+ *
+ * const program = new Command();
+ * fabricCommand({ program, service: myService });
+ * program.parse();
+ * ```
+ */
+function fabricCommand({ alias, description, exclude, input, name, onComplete, onError, onFatal, onMessage, overrides, program, service: serviceOrFunction, }) {
+    // Resolve inline service or apply overrides to pre-instantiated service
+    const service = resolveService({
+        alias,
+        description,
+        input,
+        service: serviceOrFunction,
+    });
+    // Determine command name (priority: name > service.alias > "command")
+    const commandName = name ?? service.alias ?? "command";
+    // Determine command description
+    const commandDescription = service.description;
+    // Create the command
+    const command = program.command(commandName);
+    // Add description if available
+    if (commandDescription) {
+        command.description(commandDescription);
+    }
+    // Create and add options from service input
+    if (service.input) {
+        const { options } = createCommanderOptions(service.input, {
+            exclude,
+            overrides,
+        });
+        options.forEach((opt) => command.addOption(opt));
+    }
+    // Wire up the action
+    command.action(async (options) => {
+        // Parse Commander options to service input format
+        const input = parseCommanderOptions(options, {
+            exclude,
+            input: service.input,
+        });
+        // Create context callbacks that wrap the registration callbacks with error swallowing
+        // Callback failures should never halt service execution
+        const sendMessage = onMessage
+            ? async (message) => {
+                try {
+                    await onMessage(message);
+                }
+                catch {
+                    // Swallow errors - messaging failures should not halt execution
+                }
+            }
+            : undefined;
+        const contextOnError = onError
+            ? async (error) => {
+                try {
+                    await onError(error);
+                }
+                catch {
+                    // Swallow errors - callback failures should not halt execution
+                }
+            }
+            : undefined;
+        const contextOnFatal = onFatal
+            ? async (error) => {
+                try {
+                    await onFatal(error);
+                }
+                catch {
+                    // Swallow errors - callback failures should not halt execution
+                }
+            }
+            : undefined;
+        // Create context for the service
+        const context = {
+            onError: contextOnError,
+            onFatal: contextOnFatal,
+            sendMessage,
+        };
+        try {
+            // Call the service with context
+            const response = await service(input, context);
+            // Call onComplete callback if provided
+            if (onComplete) {
+                await onComplete(response);
+            }
+        }
+        catch (error) {
+            // Any error that escapes the service is treated as fatal
+            // Services should catch recoverable errors and call context.onError() explicitly
+            if (onFatal) {
+                await onFatal(error);
+            }
+            else if (onError) {
+                // Fall back to onError if onFatal not provided
+                await onError(error);
+            }
+            else {
+                // No error callbacks provided, re-throw
+                throw error;
+            }
+        }
+    });
+    return { command, onMessage };
+}
+
+// FabricCommander - Convenient wrapper for multi-command CLIs
+/**
+ * Type guard to check if config is an array of services
+ */
+function isServicesArray(config) {
+    return Array.isArray(config);
+}
+/**
+ * Type guard to check if a service entry is an inline definition
+ */
+function isInlineDefinition(entry) {
+    return (typeof entry === "object" &&
+        entry !== null &&
+        "alias" in entry &&
+        "service" in entry &&
+        !("$fabric" in entry));
+}
+/**
+ * FabricCommander - Convenient wrapper for creating multi-command CLIs
+ *
+ * Creates a Commander program with multiple service commands in a single call.
+ *
+ * @example
+ * ```typescript
+ * // Array form - simple list of services
+ * const cli = new FabricCommander([greetService, farewellService]);
+ * cli.parse();
+ *
+ * // Config form - with description and version
+ * const cli = new FabricCommander({
+ *   name: "my-cli",
+ *   description: "My CLI application",
+ *   version: "1.0.0",
+ *   services: [greetService, farewellService],
+ * });
+ * cli.parse();
+ *
+ * // With inline service definitions
+ * const cli = new FabricCommander({
+ *   description: "My CLI",
+ *   version: "1.0.0",
+ *   services: [
+ *     existingService,
+ *     {
+ *       alias: "greet",
+ *       description: "Greet a user",
+ *       input: { name: { type: String } },
+ *       service: ({ name }) => `Hello, ${name}!`,
+ *     },
+ *   ],
+ * });
+ * cli.parse();
+ * ```
+ */
+class FabricCommander {
+    constructor(config) {
+        this.command = new Command();
+        // Normalize config
+        const normalizedConfig = isServicesArray(config)
+            ? { services: config }
+            : config;
+        const { description, name, onComplete, onError, onFatal, onMessage, services, version, } = normalizedConfig;
+        // Set program metadata
+        if (name) {
+            this.command.name(name);
+        }
+        if (version) {
+            this.command.version(version);
+        }
+        if (description) {
+            this.command.description(description);
+        }
+        // Register each service as a command
+        for (const entry of services) {
+            if (isInlineDefinition(entry)) {
+                // Inline service definition
+                fabricCommand({
+                    alias: entry.alias,
+                    description: entry.description,
+                    input: entry.input,
+                    onComplete,
+                    onError,
+                    onFatal,
+                    onMessage,
+                    program: this.command,
+                    service: entry.service,
+                });
+            }
+            else {
+                // Pre-instantiated Service
+                fabricCommand({
+                    onComplete,
+                    onError,
+                    onFatal,
+                    onMessage,
+                    program: this.command,
+                    service: entry,
+                });
+            }
+        }
+    }
+    /**
+     * Parse command-line arguments
+     * Delegates to Commander's parse method
+     */
+    parse(argv) {
+        this.command.parse(argv);
+        return this;
+    }
+    /**
+     * Parse command-line arguments asynchronously
+     * Delegates to Commander's parseAsync method
+     */
+    async parseAsync(argv) {
+        await this.command.parseAsync(argv);
+        return this;
+    }
+}
+
+export { FabricCommander, createCommanderOptions, fabricCommand, parseCommanderOptions };
+//# sourceMappingURL=index.js.map