@jaypie/fabric 0.1.1 → 0.1.3

package/dist/cjs/index.cjs

@@ -1452,6 +1452,13 @@ async function processField(fieldName, value, definition) {
     }
     return convertedValue;
 }
+/**
+ * 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;
+}
 /**
  * Fabric a service function
  *
@@ -1504,13 +1511,6 @@ function fabricService(config) {
 }
 
 // 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
  *
@@ -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;
@@ -1659,6 +1810,7 @@ exports.isElementaryType = isElementaryType;
 exports.isFabricModel = isFabricModel;
 exports.isFieldDefinition = isFieldDefinition;
 exports.isModelRegistered = isModelRegistered;
+exports.isService = isService;
 exports.isStatus = isStatus;
 exports.isTimestampField = isTimestampField;
 exports.isValidDate = isValidDate;