@jaypie/fabric 0.1.0

package/dist/cjs/commander/FabricCommander.d.ts

@@ -0,0 +1,94 @@
+import { Command } from "commander";
+import type { InputFieldDefinition, Service, ServiceFunction } from "../types.js";
+import type { OnCompleteCallback, OnErrorCallback, OnFatalCallback, OnMessageCallback } from "./types.js";
+/**
+ * Inline service definition for FabricCommander
+ * Allows defining services directly in the services array
+ */
+export interface InlineServiceDefinition {
+    /** Service alias (used as command name) */
+    alias: string;
+    /** Service description */
+    description?: string;
+    /** Input field definitions */
+    input?: Record<string, InputFieldDefinition>;
+    /** The service function */
+    service: ServiceFunction<Record<string, unknown>, unknown>;
+}
+/**
+ * Service entry - either a pre-instantiated Service or an inline definition
+ */
+export type ServiceEntry = Service | InlineServiceDefinition;
+/**
+ * Configuration for FabricCommander
+ */
+export interface FabricCommanderConfig {
+    /** CLI description */
+    description?: string;
+    /** CLI name (defaults to process.argv script name) */
+    name?: string;
+    /** Default callback called when any command completes successfully */
+    onComplete?: OnCompleteCallback;
+    /** Default callback called when any command encounters an error */
+    onError?: OnErrorCallback;
+    /** Default callback called when any command encounters a fatal error */
+    onFatal?: OnFatalCallback;
+    /** Default callback called to report progress messages */
+    onMessage?: OnMessageCallback;
+    /** Services to register as commands */
+    services: ServiceEntry[];
+    /** CLI version */
+    version?: string;
+}
+/**
+ * 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();
+ * ```
+ */
+export declare class FabricCommander {
+    /** The underlying Commander Command instance */
+    readonly command: Command;
+    constructor(config: ServiceEntry[] | FabricCommanderConfig);
+    /**
+     * Parse command-line arguments
+     * Delegates to Commander's parse method
+     */
+    parse(argv?: readonly string[]): this;
+    /**
+     * Parse command-line arguments asynchronously
+     * Delegates to Commander's parseAsync method
+     */
+    parseAsync(argv?: readonly string[]): Promise<this>;
+}

package/dist/cjs/commander/createCommanderOptions.d.ts

@@ -0,0 +1,25 @@
+import type { InputFieldDefinition } from "../types.js";
+import type { CreateCommanderOptionsConfig, CreateCommanderOptionsResult } from "./types.js";
+/**
+ * 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));
+ * ```
+ */
+export declare function createCommanderOptions(input?: Record<string, InputFieldDefinition>, config?: CreateCommanderOptionsConfig): CreateCommanderOptionsResult;

package/dist/cjs/commander/fabricCommand.d.ts

@@ -0,0 +1,43 @@
+import type { FabricCommandConfig, FabricCommandResult } from "./types.js";
+/**
+ * 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();
+ * ```
+ */
+export declare function fabricCommand({ alias, description, exclude, input, name, onComplete, onError, onFatal, onMessage, overrides, program, service: serviceOrFunction, }: FabricCommandConfig): FabricCommandResult;