@jaypie/fabric 0.1.1 → 0.1.2

package/dist/cjs/ServiceSuite.d.ts

@@ -0,0 +1,58 @@
+import type { Service } from "./types.js";
+/**
+ * Describes a single input parameter for a service
+ */
+export interface ServiceInput {
+    name: string;
+    type: string;
+    required: boolean;
+    description: string;
+    enum?: string[];
+}
+/**
+ * Describes a service's metadata for discovery and documentation
+ */
+export interface ServiceMeta {
+    /** Service name (from alias) */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Category for grouping (e.g., "record", "aws", "docs") */
+    category: string;
+    /** Input parameter definitions */
+    inputs: ServiceInput[];
+    /** Whether the service can be executed with no inputs */
+    executable?: boolean;
+}
+/**
+ * A collection of services with metadata and execution capabilities
+ */
+export interface ServiceSuite {
+    /** Suite name (e.g., "nostrus", "jaypie") */
+    name: string;
+    /** Suite version */
+    version: string;
+    /** Available categories */
+    categories: string[];
+    /** All registered services */
+    services: ServiceMeta[];
+    /** Get a service by name */
+    getService(name: string): ServiceMeta | undefined;
+    /** Get services by category */
+    getServicesByCategory(category: string): ServiceMeta[];
+    /** Execute a service by name */
+    execute(name: string, inputs: Record<string, unknown>): Promise<unknown>;
+    /** Register a fabricService into the suite */
+    register(service: Service<any, any>, category: string): void;
+}
+/**
+ * Configuration for creating a ServiceSuite
+ */
+export interface CreateServiceSuiteConfig {
+    name: string;
+    version: string;
+}
+/**
+ * Create a ServiceSuite instance
+ */
+export declare function createServiceSuite(config: CreateServiceSuiteConfig): ServiceSuite;

package/dist/cjs/index.cjs

@@ -1566,6 +1566,156 @@ function resolveService(config) {
     });
 }
 
+// ServiceSuite for @jaypie/fabric
+// Groups fabricService instances for discovery, metadata export, and direct execution
+/**
+ * Derive type string from InputFieldDefinition.type
+ */
+function deriveTypeString(type) {
+    // Handle constructors
+    if (type === String || type === "string")
+        return "string";
+    if (type === Number || type === "number")
+        return "number";
+    if (type === Boolean || type === "boolean")
+        return "boolean";
+    if (type === Object || type === "object")
+        return "object";
+    if (type === Array || type === "array")
+        return "array";
+    if (type === Date)
+        return "string"; // Dates are passed as strings
+    // Handle typed arrays: [String], [Number], etc.
+    if (Array.isArray(type)) {
+        if (type.length === 0)
+            return "array";
+        const first = type[0];
+        // If it's a type constructor, it's a typed array
+        if (first === String ||
+            first === Number ||
+            first === Boolean ||
+            first === Object ||
+            first === "string" ||
+            first === "number" ||
+            first === "boolean" ||
+            first === "object" ||
+            first === "") {
+            return "array";
+        }
+        // If all elements are strings (or RegExp), it's a validated string enum
+        if (type.every((item) => typeof item === "string" || item instanceof RegExp)) {
+            return "string";
+        }
+        // If all elements are numbers, it's a validated number enum
+        if (type.every((item) => typeof item === "number")) {
+            return "number";
+        }
+        return "array";
+    }
+    // Handle RegExp (validated string)
+    if (type instanceof RegExp) {
+        return "string";
+    }
+    return "string"; // Default fallback
+}
+/**
+ * Extract enum values if the type is a validated string/number array
+ */
+function extractEnumValues(type) {
+    if (!Array.isArray(type))
+        return undefined;
+    if (type.length === 0)
+        return undefined;
+    // Check if it's a validated string enum (array of strings, possibly with RegExp)
+    const stringValues = type.filter((item) => typeof item === "string");
+    if (stringValues.length > 0 && stringValues.length === type.filter((item) => typeof item === "string").length) {
+        // All non-RegExp items are strings
+        return stringValues;
+    }
+    // Check if it's a validated number enum
+    if (type.every((item) => typeof item === "number")) {
+        return type.map((n) => String(n));
+    }
+    return undefined;
+}
+/**
+ * Convert fabricService input definitions to ServiceInput array
+ */
+function extractInputs(inputDefinitions) {
+    if (!inputDefinitions)
+        return [];
+    return Object.entries(inputDefinitions).map(([name, def]) => {
+        const required = def.required !== false && def.default === undefined;
+        const enumValues = extractEnumValues(def.type);
+        return {
+            name,
+            type: deriveTypeString(def.type),
+            required,
+            description: def.description || "",
+            ...(enumValues && { enum: enumValues }),
+        };
+    });
+}
+/**
+ * Check if a service has any required inputs
+ */
+function hasRequiredInputs(inputs) {
+    return inputs.some((input) => input.required);
+}
+/**
+ * Create a ServiceSuite instance
+ */
+function createServiceSuite(config) {
+    const { name, version } = config;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const serviceRegistry = new Map();
+    const categorySet = new Set();
+    const suite = {
+        name,
+        version,
+        get categories() {
+            return Array.from(categorySet).sort();
+        },
+        get services() {
+            return Array.from(serviceRegistry.values()).map((entry) => entry.meta);
+        },
+        getService(serviceName) {
+            return serviceRegistry.get(serviceName)?.meta;
+        },
+        getServicesByCategory(category) {
+            return Array.from(serviceRegistry.values())
+                .filter((entry) => entry.meta.category === category)
+                .map((entry) => entry.meta);
+        },
+        async execute(serviceName, inputs) {
+            const entry = serviceRegistry.get(serviceName);
+            if (!entry) {
+                throw new Error(`Service "${serviceName}" not found in suite "${name}"`);
+            }
+            return entry.service(inputs);
+        },
+        register(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        service, category) {
+            const serviceName = service.alias;
+            if (!serviceName) {
+                throw new Error("Service must have an alias to be registered");
+            }
+            const inputs = extractInputs(service.input);
+            const meta = {
+                name: serviceName,
+                description: service.description || "",
+                category,
+                inputs,
+                executable: !hasRequiredInputs(inputs),
+            };
+            serviceRegistry.set(serviceName, { service, meta });
+            categorySet.add(category);
+        },
+    };
+    return suite;
+}
+
 /**
  * Status Type for @jaypie/fabric
  *
@@ -1637,6 +1787,7 @@ exports.calculateScope = calculateScope;
 exports.clearRegistry = clearRegistry;
 exports.computeResolvedName = computeResolvedName;
 exports.createFabricModelInput = createFabricModelInput;
+exports.createServiceSuite = createServiceSuite;
 exports.fabric = fabric;
 exports.fabricArray = fabricArray;
 exports.fabricBoolean = fabricBoolean;