@etohq/connector-engine 1.5.1-alpha.4

package/dist/engine/connector-engine.js

@@ -0,0 +1,694 @@
+"use strict";
+/**
+ * @fileoverview Universal Connector Engine
+ * @description Plugin-first connector engine with operation groups and full type safety
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniversalConnectorEngine = void 0;
+exports.ConnectorEngine = ConnectorEngine;
+const utils_1 = require("@etohq/framework/utils");
+class PluginRegistryImpl {
+    constructor() {
+        this.plugins = new Map();
+    }
+    register(name, plugin) {
+        if (!this.validate(plugin)) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Plugin ${name} failed validation`);
+        }
+        this.plugins.set(name, plugin);
+    }
+    get(name) {
+        return this.plugins.get(name);
+    }
+    list() {
+        return Array.from(this.plugins.keys());
+    }
+    validate(plugin) {
+        return (typeof plugin.getName === 'function' &&
+            typeof plugin.getVersion === 'function' &&
+            typeof plugin.getCapabilities === 'function' &&
+            typeof plugin.initialize === 'function' &&
+            typeof plugin.destroy === 'function' &&
+            typeof plugin.healthCheck === 'function');
+    }
+    getOperations(pluginName) {
+        const plugin = this.get(pluginName);
+        if (!plugin) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_FOUND, `Plugin ${pluginName} not found`);
+        }
+        return Object.getOwnPropertyNames(plugin)
+            .filter(name => typeof plugin[name] === 'function' &&
+            !['getName', 'getVersion', 'getCapabilities', 'initialize', 'destroy', 'healthCheck', 'parseWebhook', 'validateWebhook'].includes(name));
+    }
+}
+// ===== PLUGIN-FIRST CONNECTOR ENGINE FACTORY =====
+function ConnectorEngine(plugins, operationGroups) {
+    as `execute${Capitalize}${Capitalize}`;
+    ;
+}
+[keyof, TPlugins];
+`execute${Capitalize}${Capitalize}`;
+;
+[(operation_groups_1.ExtractGroupNames)];
+{ }
+;
+class ConnectorEngineImpl {
+    constructor() {
+        this.plugins = plugins;
+        this.operationGroups = operationGroups || {};
+        this.pluginRegistry = new PluginRegistryImpl();
+        // ✅ Validate plugins against operation groups
+        this.validatePluginConfiguration();
+        // ✅ Register all plugins
+        this.registerPlugins();
+        // ✅ Generate dynamic methods
+        this.generateDynamicMethods();
+    }
+    // ✅ Generate dynamic methods: execute<Domain><Operation> and execute<GroupName><Operation>
+    generateDynamicMethods() {
+        // Generate domain methods: executeCalendarCreateEvent, executeNotificationSendEmail
+        this.generateDomainMethods();
+        // Generate group methods: executeBookingCreateEvent, executeBookingSendEmail
+        this.generateGroupMethods();
+    }
+    // ✅ Generate execute<Domain><Operation> methods
+    generateDomainMethods() {
+        for (const [domain, plugin] of Object.entries(this.plugins)) {
+            const operations = this.pluginRegistry.getOperations(domain);
+            for (const operation of operations) {
+                // Pattern: execute<Domain><Operation>
+                const methodName = `execute${capitalize(domain)}${capitalize(operation)}`;
+                this[methodName] = async (input, sharedContext) => {
+                    return await this.executeDomainOperation(domain, operation, input, sharedContext);
+                };
+            }
+        }
+    }
+    // ✅ Generate execute<GroupName><Operation> methods
+    generateGroupMethods() {
+        if (!this.operationGroups)
+            return;
+        for (const [groupName, groupConfig] of Object.entries(this.operationGroups)) {
+            for (const operation of groupConfig.operations) {
+                // Pattern: execute<GroupName><Operation>
+                const methodName = `execute${capitalize(groupName)}${capitalize(operation)}`;
+                this[methodName] = async (input, sharedContext) => {
+                    return await this.executeGroupOperation(groupName, operation, input, sharedContext);
+                };
+            }
+        }
+    }
+    // ✅ Execute single domain operation (like EtoInternalService method)
+    async executeDomainOperation(domain, operation, input, sharedContext) {
+        const plugin = this.plugins[domain];
+        if (!plugin) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_FOUND, `Plugin not found for domain: ${String(domain)}`);
+        }
+        const pluginMethod = plugin[operation];
+        if (!pluginMethod || typeof pluginMethod !== 'function') {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_FOUND, `Operation ${operation} not supported by plugin for domain ${String(domain)}`);
+        }
+        try {
+            // ✅ Call plugin method - can return value or workflow step
+            const result = await pluginMethod.call(plugin, {}, // config
+            input, { container: this.getContainerFromContext(sharedContext) });
+            // ✅ Handle both normal methods and workflow steps
+            if (this.isStepDefinition(result)) {
+                return await result.run(input, { container: this.getContainerFromContext(sharedContext) });
+            }
+            return result;
+        }
+        catch (error) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.UNKNOWN_ERROR, `Plugin operation ${String(domain)}.${operation} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // ✅ Execute operation group by group ID
+    async executeGroupOperation(groupId, operation, input, sharedContext) {
+        const groupConfig = this.operationGroups[groupId];
+        if (!groupConfig) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_FOUND, `Operation group '${String(groupId)}' not found`);
+        }
+        if (!groupConfig.operations.includes(operation)) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_FOUND, `Operation '${operation}' not supported by group '${String(groupId)}'`);
+        }
+        const { behavior } = groupConfig.options;
+        const startTime = Date.now();
+        switch (behavior) {
+            case 'execute_all':
+                return await this.executeAllDomains(groupConfig.domains, operation, input, sharedContext, String(groupId), startTime);
+            case 'route_by_domain':
+                return await this.routeByDomain(groupConfig.domains, operation, input, groupConfig.options, sharedContext, String(groupId), startTime);
+            case 'first_success':
+                return await this.executeFirstSuccess(groupConfig.domains, operation, input, sharedContext, String(groupId), startTime);
+            default:
+                throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Unsupported behavior: ${behavior}`);
+        }
+    }
+    // ===== PRIVATE HELPER METHODS =====
+    // ✅ Register all plugins in the registry
+    registerPlugins() {
+        for (const [domain, plugin] of Object.entries(this.plugins)) {
+            this.pluginRegistry.register(domain, plugin);
+        }
+    }
+    // ✅ Extract container from ETO shared context
+    getContainerFromContext(sharedContext) {
+        // In ETO, container is available in shared context
+        return sharedContext?.__container__ || {};
+    }
+    // ✅ Execute all domains in parallel
+    async executeAllDomains(domains, operation, input, sharedContext, groupName, startTime) {
+        const results = {};
+        const errors = {};
+        // Execute all domains in parallel
+        const domainPromises = domains.map(async (domain) => {
+            try {
+                const result = await this.executeDomainOperation(domain, operation, input, sharedContext);
+                results[domain] = result;
+            }
+            catch (error) {
+                errors[domain] = error instanceof Error ? error : new Error(String(error));
+            }
+        });
+        await Promise.all(domainPromises);
+        return {
+            groupName,
+            executedDomains: domains,
+            results,
+            metadata: {
+                behavior: 'execute_all',
+                executionTime: Date.now() - startTime,
+                errors: Object.keys(errors).length > 0 ? errors : undefined
+            }
+        };
+    }
+    // ✅ Route to specific domain
+    async routeByDomain(groupDomains, operation, input, options, sharedContext, groupName, startTime) {
+        // ✅ Domain precedence: options.connectorId > first group domain
+        const targetDomain = options.connectorId || groupDomains[0];
+        // ✅ Validate domain is supported by this group
+        if (!groupDomains.includes(targetDomain)) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Domain '${targetDomain}' not supported by group '${groupName}'. Supported domains: ${groupDomains.join(', ')}`);
+        }
+        try {
+            const result = await this.executeDomainOperation(targetDomain, operation, input, sharedContext);
+            return {
+                groupName,
+                executedDomains: [targetDomain],
+                results: { [targetDomain]: result },
+                metadata: {
+                    behavior: 'route_by_domain',
+                    connectorId: options.connectorId,
+                    executionTime: Date.now() - startTime,
+                    domainSource: options.connectorId ? 'options' : 'group_default'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                groupName,
+                executedDomains: [targetDomain],
+                results: {},
+                metadata: {
+                    behavior: 'route_by_domain',
+                    connectorId: options.connectorId,
+                    executionTime: Date.now() - startTime,
+                    domainSource: options.connectorId ? 'options' : 'group_default',
+                    errors: { [targetDomain]: error instanceof Error ? error : new Error(String(error)) }
+                }
+            };
+        }
+    }
+    // ✅ Execute domains until first success
+    async executeFirstSuccess(domains, operation, input, sharedContext, groupName, startTime) {
+        const errors = {};
+        for (const domain of domains) {
+            try {
+                const result = await this.executeDomainOperation(domain, operation, input, sharedContext);
+                return {
+                    groupName,
+                    executedDomains: [domain],
+                    results: { [domain]: result },
+                    metadata: {
+                        behavior: 'first_success',
+                        executionTime: Date.now() - startTime
+                    }
+                };
+            }
+            catch (error) {
+                errors[domain] = error instanceof Error ? error : new Error(String(error));
+                continue; // Try next domain
+            }
+        }
+        // All domains failed
+        throw new utils_1.EtoError(utils_1.EtoError.Types.UNKNOWN_ERROR, `All domains failed for operation ${operation} in group ${groupName}. Errors: ${JSON.stringify(errors)}`);
+    }
+    // ===== PRIVATE HELPER METHODS =====
+    // ✅ Register all plugins in the registry
+    registerPlugins() {
+        for (const [domain, plugin] of Object.entries(this.plugins)) {
+            this.pluginRegistry.register(domain, plugin);
+        }
+    }
+    // ✅ Extract container from ETO shared context
+    getContainerFromContext(sharedContext) {
+        // In ETO, container is available in shared context
+        return sharedContext?.__container__ || {};
+    }
+    // ✅ Execute all domains in parallel
+    async executeAllDomains(domains, operation, input, sharedContext, groupName, startTime) {
+        const results = {};
+        const errors = {};
+        // Execute all domains in parallel
+        const domainPromises = domains.map(async (domain) => {
+            try {
+                const result = await this.executeDomainOperation(domain, operation, input, sharedContext);
+                results[domain] = result;
+            }
+            catch (error) {
+                errors[domain] = error instanceof Error ? error : new Error(String(error));
+            }
+        });
+        await Promise.all(domainPromises);
+        return {
+            groupName,
+            executedDomains: domains,
+            results,
+            metadata: {
+                behavior: 'execute_all',
+                executionTime: Date.now() - startTime,
+                errors: Object.keys(errors).length > 0 ? errors : undefined
+            }
+        };
+    }
+    // ✅ Route to specific domain
+    async routeByDomain(groupDomains, operation, input, options, sharedContext, groupName, startTime) {
+        // ✅ Domain precedence: options.connectorId > first group domain
+        const targetDomain = options.connectorId || groupDomains[0];
+        // ✅ Validate domain is supported by this group
+        if (!groupDomains.includes(targetDomain)) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Domain '${targetDomain}' not supported by group '${groupName}'. Supported domains: ${groupDomains.join(', ')}`);
+        }
+        try {
+            const result = await this.executeDomainOperation(targetDomain, operation, input, sharedContext);
+            return {
+                groupName,
+                executedDomains: [targetDomain],
+                results: { [targetDomain]: result },
+                metadata: {
+                    behavior: 'route_by_domain',
+                    connectorId: options.connectorId,
+                    executionTime: Date.now() - startTime,
+                    domainSource: options.connectorId ? 'options' : 'group_default'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                groupName,
+                executedDomains: [targetDomain],
+                results: {},
+                metadata: {
+                    behavior: 'route_by_domain',
+                    connectorId: options.connectorId,
+                    executionTime: Date.now() - startTime,
+                    domainSource: options.connectorId ? 'options' : 'group_default',
+                    errors: { [targetDomain]: error instanceof Error ? error : new Error(String(error)) }
+                }
+            };
+        }
+    }
+    // ✅ Execute domains until first success
+    async executeFirstSuccess(domains, operation, input, sharedContext, groupName, startTime) {
+        const errors = {};
+        for (const domain of domains) {
+            try {
+                const result = await this.executeDomainOperation(domain, operation, input, sharedContext);
+                return {
+                    groupName,
+                    executedDomains: [domain],
+                    results: { [domain]: result },
+                    metadata: {
+                        behavior: 'first_success',
+                        executionTime: Date.now() - startTime
+                    }
+                };
+            }
+            catch (error) {
+                errors[domain] = error instanceof Error ? error : new Error(String(error));
+                continue; // Try next domain
+            }
+        }
+        // All domains failed
+        throw new utils_1.EtoError(utils_1.EtoError.Types.UNKNOWN_ERROR, `All domains failed for operation ${operation} in group ${groupName}. Errors: ${JSON.stringify(errors)}`);
+    }
+    // ✅ Validate that operation groups reference valid plugins and operations
+    validatePluginConfiguration() {
+        if (!this.operationGroups)
+            return;
+        for (const [groupName, groupConfig] of Object.entries(this.operationGroups)) {
+            // Validate domains exist in plugins
+            for (const domain of groupConfig.domains) {
+                if (!this.plugins[domain]) {
+                    throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Operation group '${groupName}' references unknown domain '${domain}'. Available domains: ${Object.keys(this.plugins).join(', ')}`);
+                }
+            }
+            // Validate operations exist in domain plugins
+            for (const domain of groupConfig.domains) {
+                const plugin = this.plugins[domain];
+                for (const operation of groupConfig.operations) {
+                    const pluginMethod = plugin[operation];
+                    if (!pluginMethod || typeof pluginMethod !== 'function') {
+                        throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Operation group '${groupName}' references unknown operation '${operation}' for domain '${domain}'`);
+                    }
+                }
+            }
+        }
+    }
+    // ✅ Generate ETO-style methods dynamically
+    generateEtoStyleMethods() {
+        // Generate individual plugin methods (like EtoInternalService)
+        this.generatePluginMethods();
+        // Generate operation group methods based on group configuration
+        this.generateOperationGroupMethods();
+    }
+    // ✅ Generate individual plugin methods (domain.operation -> operationDomain)
+    generatePluginMethods() {
+        for (const [domain, plugin] of Object.entries(this.plugins)) {
+            const operations = this.pluginRegistry.getOperations(domain);
+            for (const operation of operations) {
+                // ETO-style method naming: createCalendar, updateCalendar, etc.
+                const methodName = `${operation}${capitalize(domain)}`;
+                this[methodName] = async (input, sharedContext) => {
+                    return await this.executeSingleOperation(domain, operation, input, sharedContext);
+                };
+            }
+        }
+    }
+    // ✅ Generate operation group methods based on group behavior
+    generateOperationGroupMethods() {
+        if (!this.operationGroups)
+            return;
+        for (const [groupName, groupConfig] of Object.entries(this.operationGroups)) {
+            for (const operation of groupConfig.operations) {
+                // ETO-style method naming based on group behavior
+                const methodName = this.getGroupMethodName(operation, groupName, groupConfig.options.behavior);
+                this[methodName] = async (input, sharedContext) => {
+                    return await this.executeOperationGroup(groupName, operation, input, groupConfig, sharedContext);
+                };
+            }
+        }
+    }
+    // ✅ Determine method name based on group behavior
+    getGroupMethodName(operation, groupName, behavior) {
+        switch (behavior) {
+            case 'execute_all':
+                // createBookingAll, updateBookingAll
+                return `${operation}${capitalize(groupName)}All`;
+            case 'route_by_domain':
+                // createBooking, updateBooking (routes to appropriate domain)
+                return `${operation}${capitalize(groupName)}`;
+            case 'first_success':
+                // createBookingFirstSuccess, updateBookingFirstSuccess
+                return `${operation}${capitalize(groupName)}FirstSuccess`;
+            default:
+                return `${operation}${capitalize(groupName)}`;
+        }
+    }
+    // ✅ Execute single plugin operation (like EtoInternalService method)
+    async executeSingleOperation(domain, operation, input, sharedContext) {
+        const plugin = this.plugins[domain];
+        if (!plugin) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_FOUND, `Plugin not found for domain: ${domain}`);
+        }
+        const pluginMethod = plugin[operation];
+        if (!pluginMethod || typeof pluginMethod !== 'function') {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_FOUND, `Operation ${operation} not supported by plugin for domain ${domain}`);
+        }
+        try {
+            // ✅ Call plugin method directly (like EtoInternalService)
+            const result = await pluginMethod.call(plugin, {}, // config
+            input, { container: this.getContainerFromContext(sharedContext) });
+            if (this.isStepDefinition(result)) {
+                return await result.run(input, { container: this.getContainerFromContext(sharedContext) });
+            }
+            return result;
+        }
+        catch (error) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.UNKNOWN_ERROR, `Plugin operation ${domain}.${operation} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // ✅ Execute operation group based on behavior
+    async executeOperationGroup(groupName, operation, input, groupConfig, sharedContext) {
+        const { behavior } = groupConfig.options;
+        switch (behavior) {
+            case 'execute_all':
+                return await this.executeAllDomains(groupConfig.domains, operation, input, sharedContext);
+            case 'route_by_domain':
+                return await this.routeByDomain(groupConfig.domains, operation, input, groupConfig.options, sharedContext);
+            case 'first_success':
+                return await this.executeFirstSuccess(groupConfig.domains, operation, input, sharedContext);
+            default:
+                throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Unsupported behavior: ${behavior}`);
+        }
+    }
+    // ✅ Extract container from ETO shared context
+    getContainerFromContext(sharedContext) {
+        // In ETO, container is available in shared context
+        return sharedContext?.__container__ || {};
+    }
+    // ✅ Execute all domains in parallel with type safety
+    async executeAllDomains(domains, operation, input) {
+        const results = {};
+        const errors = {};
+        const startTime = Date.now();
+        // Execute all domains in parallel
+        const domainPromises = domains.map(async (domain) => {
+            try {
+                const result = await this.executeDomainOperation(domain, operation, input);
+                results[domain] = result;
+            }
+            catch (error) {
+                errors[domain] = error instanceof Error ? error : new Error(String(error));
+            }
+        });
+        await Promise.all(domainPromises);
+        return {
+            groupName: '', // Will be set by caller
+            executedDomains: domains,
+            results,
+            metadata: {
+                behavior: 'execute_all',
+                executionTime: Date.now() - startTime,
+                errors: Object.keys(errors).length > 0 ? errors : undefined
+            }
+        };
+    }
+    // ✅ Route to specific domain based on input or group configuration
+    async routeByDomain(groupDomains, operation, input, options) {
+        const startTime = Date.now();
+        // ✅ Domain precedence: options.connectorId > first group domain
+        const targetDomain = options.connectorId || groupDomains[0];
+        // ✅ Validate domain is supported by this group
+        if (!groupDomains.includes(targetDomain)) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Domain '${targetDomain}' not supported by this operation group. ` +
+                `Supported domains: ${groupDomains.join(', ')}`);
+        }
+        try {
+            const result = await this.executeDomainOperation(targetDomain, operation, input);
+            return {
+                groupName: '', // Will be set by caller
+                executedDomains: [targetDomain],
+                results: { [targetDomain]: result },
+                metadata: {
+                    behavior: 'route_by_domain',
+                    connectorId: options.connectorId,
+                    executionTime: Date.now() - startTime,
+                    domainSource: options.connectorId ? 'options' : 'group_default'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                groupName: '',
+                executedDomains: [targetDomain],
+                results: {},
+                metadata: {
+                    behavior: 'route_by_domain',
+                    connectorId: options.connectorId,
+                    executionTime: Date.now() - startTime,
+                    domainSource: options.connectorId ? 'options' : 'group_default',
+                    errors: { [targetDomain]: error instanceof Error ? error : new Error(String(error)) }
+                }
+            };
+        }
+    }
+    // ✅ Execute domains until first success
+    async executeFirstSuccess(domains, operation, input) {
+        const startTime = Date.now();
+        const errors = {};
+        for (const domain of domains) {
+            try {
+                const result = await this.executeDomainOperation(domain, operation, input);
+                return {
+                    groupName: '',
+                    executedDomains: [domain],
+                    results: { [domain]: result },
+                    metadata: {
+                        behavior: 'first_success',
+                        executionTime: Date.now() - startTime
+                    }
+                };
+            }
+            catch (error) {
+                errors[domain] = error instanceof Error ? error : new Error(String(error));
+                continue; // Try next domain
+            }
+        }
+        // All domains failed
+        throw new utils_1.EtoError(utils_1.EtoError.Types.UNKNOWN_ERROR, `All domains failed for operation ${operation}. Errors: ${JSON.stringify(errors)}`);
+    }
+    // ===== TYPE GUARDS =====
+    isStepDefinition(value) {
+        return value !== null &&
+            typeof value === 'object' &&
+            'run' in value &&
+            typeof value.run === 'function' &&
+            'stepId' in value &&
+            typeof value.stepId === 'string';
+    }
+    // ===== HEALTH MONITORING =====
+    async getSystemHealth() {
+        const pluginHealths = {};
+        let healthyCount = 0;
+        let totalCount = 0;
+        for (const [domain, plugin] of Object.entries(this.plugins)) {
+            totalCount++;
+            try {
+                pluginHealths[domain] = await plugin.healthCheck();
+                if (pluginHealths[domain].status === 'healthy') {
+                    healthyCount++;
+                }
+            }
+            catch (error) {
+                pluginHealths[domain] = {
+                    status: 'unhealthy',
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                    lastChecked: new Date()
+                };
+            }
+        }
+        const healthRatio = totalCount > 0 ? healthyCount / totalCount : 1;
+        const overall = healthRatio === 1 ? 'healthy' : healthRatio >= 0.5 ? 'degraded' : 'unhealthy';
+        return { overall, plugins: pluginHealths };
+    }
+    // ===== PUBLIC API =====
+    getAvailableDomains() {
+        return Object.keys(this.plugins);
+    }
+    getAvailableOperations(domain) {
+        return this.pluginRegistry.getOperations(domain);
+    }
+    getOperationGroups() {
+        return this.operationGroups;
+    }
+    // ✅ Validate that operation groups reference valid plugins and operations
+    validatePluginConfiguration() {
+        if (!this.operationGroups)
+            return;
+        for (const [groupName, groupConfig] of Object.entries(this.operationGroups)) {
+            // Validate domains exist in plugins
+            for (const domain of groupConfig.domains) {
+                if (!this.plugins[domain]) {
+                    throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Operation group '${groupName}' references unknown domain '${domain}'. Available domains: ${Object.keys(this.plugins).join(', ')}`);
+                }
+            }
+            // Validate operations exist in domain plugins
+            for (const domain of groupConfig.domains) {
+                const plugin = this.plugins[domain];
+                for (const operation of groupConfig.operations) {
+                    const pluginMethod = plugin[operation];
+                    if (!pluginMethod || typeof pluginMethod !== 'function') {
+                        throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `Operation group '${groupName}' references unknown operation '${operation}' for domain '${domain}'`);
+                    }
+                }
+            }
+        }
+    }
+    // ===== TYPE GUARDS =====
+    isStepDefinition(value) {
+        return value !== null &&
+            typeof value === 'object' &&
+            'run' in value &&
+            typeof value.run === 'function' &&
+            'stepId' in value &&
+            typeof value.stepId === 'string';
+    }
+    // ===== HEALTH MONITORING =====
+    async getSystemHealth() {
+        const pluginHealths = {};
+        let healthyCount = 0;
+        let totalCount = 0;
+        for (const [domain, plugin] of Object.entries(this.plugins)) {
+            totalCount++;
+            try {
+                pluginHealths[domain] = await plugin.healthCheck();
+                if (pluginHealths[domain].status === 'healthy') {
+                    healthyCount++;
+                }
+            }
+            catch (error) {
+                pluginHealths[domain] = {
+                    status: 'unhealthy',
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                    lastChecked: new Date()
+                };
+            }
+        }
+        const healthRatio = totalCount > 0 ? healthyCount / totalCount : 1;
+        const overall = healthRatio === 1 ? 'healthy' : healthRatio >= 0.5 ? 'degraded' : 'unhealthy';
+        return { overall, plugins: pluginHealths };
+    }
+    // ===== PUBLIC API =====
+    getAvailableDomains() {
+        return Object.keys(this.plugins);
+    }
+    getAvailableOperations(domain) {
+        return this.pluginRegistry.getOperations(domain);
+    }
+    getOperationGroups() {
+        return this.operationGroups;
+    }
+    getPluginRegistry() {
+        return this.pluginRegistry;
+    }
+    // ✅ Get list of generated dynamic methods
+    getGeneratedMethods() {
+        const domainMethods = [];
+        const groupMethods = [];
+        // Domain methods
+        for (const [domain, plugin] of Object.entries(this.plugins)) {
+            const operations = this.pluginRegistry.getOperations(domain);
+            for (const operation of operations) {
+                domainMethods.push(`execute${capitalize(domain)}${capitalize(operation)}`);
+            }
+        }
+        // Group methods
+        if (this.operationGroups) {
+            for (const [groupName, groupConfig] of Object.entries(this.operationGroups)) {
+                for (const operation of groupConfig.operations) {
+                    groupMethods.push(`execute${capitalize(groupName)}${capitalize(operation)}`);
+                }
+            }
+        }
+        return { domainMethods, groupMethods };
+    }
+}
+exports.UniversalConnectorEngine = ConnectorEngineImpl;
+return ConnectorEngineImpl;
+return ConnectorEngineImpl;
+// ===== UTILITY FUNCTIONS =====
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+//# sourceMappingURL=connector-engine.js.map