@ductape/sdk 0.1.6 → 0.1.8

package/dist/resilience/healthcheck.service.js

@@ -1,1012 +0,0 @@
-"use strict";
-/**
- * Healthcheck Service
- *
- * Code-first API for defining and managing healthchecks.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HealthcheckService = exports.HealthcheckError = void 0;
-const types_1 = require("./types");
-const resilienceApi_service_1 = require("../api/services/resilienceApi.service");
-const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
-const processor_utils_1 = require("../processor/utils/processor.utils");
-const products_service_1 = __importDefault(require("../products/services/products.service"));
-/**
- * Error class for healthcheck operations
- */
-class HealthcheckError extends Error {
-    constructor(message, code, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = 'HealthcheckError';
-    }
-}
-exports.HealthcheckError = HealthcheckError;
-/**
- * Recording context that captures healthcheck configuration during handler execution
- */
-class RecordingHealthcheckContext {
-    constructor() {
-        this._probe = null;
-        this._interval = 60000;
-        this._retries = 2;
-        this._envs = [];
-        this._onFailure = null;
-    }
-    probe() {
-        return new RecordingProbeBuilder(this);
-    }
-    setProbe(probe) {
-        this._probe = probe;
-    }
-    interval(ms) {
-        this._interval = ms;
-    }
-    retries(count) {
-        this._retries = count;
-    }
-    env(slug, options) {
-        const envConfig = Object.assign({ slug }, options);
-        this._envs.push(envConfig);
-    }
-    onFailure() {
-        if (!this._onFailure) {
-            this._onFailure = {
-                notifications: [],
-                webhooks: [],
-                emit: [],
-            };
-        }
-        return new RecordingFailureNotificationBuilder(this._onFailure);
-    }
-    auth(field) {
-        return `$Auth{${field}}`;
-    }
-    token(key) {
-        return `$Secret{${key}}`;
-    }
-    variable(app, key) {
-        return `$Variable{${app}}{${key}}`;
-    }
-    constant(app, key) {
-        return `$Constant{${app}}{${key}}`;
-    }
-    /**
-     * Build the healthcheck schema from recorded configuration
-     */
-    build(tag, name, description) {
-        if (!this._probe) {
-            throw new HealthcheckError('Healthcheck probe not configured', 'PROBE_NOT_CONFIGURED');
-        }
-        if (this._envs.length === 0) {
-            throw new HealthcheckError('At least one environment must be configured', 'NO_ENVS_CONFIGURED');
-        }
-        return {
-            tag,
-            name,
-            description,
-            probe: this._probe,
-            interval: this._interval,
-            retries: this._retries,
-            onFailure: this._onFailure || undefined,
-            envs: this._envs,
-        };
-    }
-}
-/**
- * Probe builder that records probe configuration
- */
-class RecordingProbeBuilder {
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    app(tag) {
-        return new RecordingAppProbeBuilder(this.ctx, tag);
-    }
-    database(tag) {
-        return new RecordingDatabaseProbeBuilder(this.ctx, tag);
-    }
-    workflow(tag) {
-        return new RecordingWorkflowProbeBuilder(this.ctx, tag);
-    }
-    graph(tag) {
-        return new RecordingGraphProbeBuilder(this.ctx, tag);
-    }
-    messageBroker(tag) {
-        return new RecordingMessageBrokerProbeBuilder(this.ctx, tag);
-    }
-    storage(tag) {
-        return new RecordingStorageProbeBuilder(this.ctx, tag);
-    }
-}
-class RecordingAppProbeBuilder {
-    constructor(ctx, appTag) {
-        this.ctx = ctx;
-        this.appTag = appTag;
-    }
-    action(event) {
-        return new RecordingAppProbeActionBuilder(this.ctx, this.appTag, event);
-    }
-}
-class RecordingAppProbeActionBuilder {
-    constructor(ctx, appTag, event) {
-        this.ctx = ctx;
-        this.appTag = appTag;
-        this.event = event;
-        // Set probe immediately (input is optional)
-        this.ctx.setProbe({
-            type: types_1.ProbeType.APP,
-            app: this.appTag,
-            event: this.event,
-        });
-    }
-    input(data) {
-        this.ctx.setProbe({
-            type: types_1.ProbeType.APP,
-            app: this.appTag,
-            event: this.event,
-            input: data,
-        });
-    }
-}
-class RecordingDatabaseProbeBuilder {
-    constructor(ctx, dbTag) {
-        this.ctx = ctx;
-        this.dbTag = dbTag;
-    }
-    action(event) {
-        return new RecordingDatabaseProbeActionBuilder(this.ctx, this.dbTag, event);
-    }
-}
-class RecordingDatabaseProbeActionBuilder {
-    constructor(ctx, dbTag, event) {
-        this.ctx = ctx;
-        this.dbTag = dbTag;
-        this.event = event;
-        // Set probe immediately (input is optional)
-        this.ctx.setProbe({
-            type: types_1.ProbeType.DATABASE,
-            database: this.dbTag,
-            event: this.event,
-        });
-    }
-    input(data) {
-        this.ctx.setProbe({
-            type: types_1.ProbeType.DATABASE,
-            database: this.dbTag,
-            event: this.event,
-            input: data,
-        });
-    }
-}
-class RecordingWorkflowProbeBuilder {
-    constructor(ctx, workflowTag) {
-        this.ctx = ctx;
-        this.workflowTag = workflowTag;
-    }
-    input(data) {
-        this.ctx.setProbe({
-            type: types_1.ProbeType.WORKFLOW,
-            workflow: this.workflowTag,
-            input: data,
-        });
-    }
-}
-class RecordingGraphProbeBuilder {
-    constructor(ctx, graphTag) {
-        this.ctx = ctx;
-        this.graphTag = graphTag;
-    }
-    action(event) {
-        return new RecordingGraphProbeActionBuilder(this.ctx, this.graphTag, event);
-    }
-}
-class RecordingGraphProbeActionBuilder {
-    constructor(ctx, graphTag, event) {
-        this.ctx = ctx;
-        this.graphTag = graphTag;
-        this.event = event;
-        // Set probe immediately (input is optional)
-        this.ctx.setProbe({
-            type: types_1.ProbeType.GRAPH,
-            graph: this.graphTag,
-            event: this.event,
-        });
-    }
-    input(data) {
-        this.ctx.setProbe({
-            type: types_1.ProbeType.GRAPH,
-            graph: this.graphTag,
-            event: this.event,
-            input: data,
-        });
-    }
-}
-class RecordingMessageBrokerProbeBuilder {
-    constructor(ctx, brokerTag) {
-        this.ctx = ctx;
-        this.brokerTag = brokerTag;
-    }
-    action(event) {
-        return new RecordingMessageBrokerProbeActionBuilder(this.ctx, this.brokerTag, event);
-    }
-}
-class RecordingMessageBrokerProbeActionBuilder {
-    constructor(ctx, brokerTag, event) {
-        this.ctx = ctx;
-        this.brokerTag = brokerTag;
-        this.event = event;
-        // Set probe immediately (input is optional)
-        this.ctx.setProbe({
-            type: types_1.ProbeType.MESSAGE_BROKER,
-            messageBroker: this.brokerTag,
-            event: this.event,
-        });
-    }
-    input(data) {
-        this.ctx.setProbe({
-            type: types_1.ProbeType.MESSAGE_BROKER,
-            messageBroker: this.brokerTag,
-            event: this.event,
-            input: data,
-        });
-    }
-}
-class RecordingStorageProbeBuilder {
-    constructor(ctx, storageTag) {
-        this.ctx = ctx;
-        this.storageTag = storageTag;
-    }
-    action(event) {
-        return new RecordingStorageProbeActionBuilder(this.ctx, this.storageTag, event);
-    }
-}
-class RecordingStorageProbeActionBuilder {
-    constructor(ctx, storageTag, event) {
-        this.ctx = ctx;
-        this.storageTag = storageTag;
-        this.event = event;
-        // Set probe immediately (input is optional)
-        this.ctx.setProbe({
-            type: types_1.ProbeType.STORAGE,
-            storage: this.storageTag,
-            event: this.event,
-        });
-    }
-    input(data) {
-        this.ctx.setProbe({
-            type: types_1.ProbeType.STORAGE,
-            storage: this.storageTag,
-            event: this.event,
-            input: data,
-        });
-    }
-}
-/**
- * Failure notification builder
- */
-class RecordingFailureNotificationBuilder {
-    constructor(onFailure) {
-        this.onFailure = onFailure;
-    }
-    notification(tag) {
-        return new RecordingNotificationMessageBuilder(this.onFailure, tag);
-    }
-    webhook(config) {
-        this.onFailure.webhooks = this.onFailure.webhooks || [];
-        this.onFailure.webhooks.push(config);
-        return this;
-    }
-    emit(config) {
-        this.onFailure.emit = this.onFailure.emit || [];
-        this.onFailure.emit.push(config);
-        return this;
-    }
-}
-class RecordingNotificationMessageBuilder {
-    constructor(onFailure, notificationTag) {
-        this.onFailure = onFailure;
-        this.notificationTag = notificationTag;
-    }
-    message(event) {
-        return new RecordingNotificationChannelBuilder(this.onFailure, this.notificationTag, event);
-    }
-}
-class RecordingNotificationChannelBuilder {
-    constructor(onFailure, notificationTag, message) {
-        this.parentOnFailure = onFailure;
-        this.currentNotification = {
-            notification: notificationTag,
-            message,
-            channels: {},
-        };
-        this.parentOnFailure.notifications = this.parentOnFailure.notifications || [];
-        this.parentOnFailure.notifications.push(this.currentNotification);
-    }
-    notification(tag) {
-        return new RecordingNotificationMessageBuilder(this.parentOnFailure, tag);
-    }
-    webhook(config) {
-        this.parentOnFailure.webhooks = this.parentOnFailure.webhooks || [];
-        this.parentOnFailure.webhooks.push(config);
-        return this;
-    }
-    emit(config) {
-        this.parentOnFailure.emit = this.parentOnFailure.emit || [];
-        this.parentOnFailure.emit.push(config);
-        return this;
-    }
-    push(config) {
-        this.currentNotification.channels.push = config || {};
-        return this;
-    }
-    email(config) {
-        this.currentNotification.channels.email = config;
-        return this;
-    }
-    sms(config) {
-        this.currentNotification.channels.sms = config;
-        return this;
-    }
-    callback(config) {
-        this.currentNotification.channels.callback = config || {};
-        return this;
-    }
-}
-/**
- * Healthcheck Service
- *
- * Provides code-first API for defining, creating, and managing healthchecks.
- */
-class HealthcheckService {
-    constructor(config) {
-        this.productBuilders = new Map();
-        this.config = config;
-        this._privateKey = config.private_key;
-        this._accessKey = config.access_key;
-        this.apiService = new resilienceApi_service_1.ResilienceApiService({
-            token: config.token,
-            env_type: config.env_type,
-            base_url: config.base_url,
-        });
-    }
-    /** Get or create a ProductBuilder for the product (resolves tag to product id for components API) */
-    async getProductBuilder(productTag) {
-        let builder = this.productBuilders.get(productTag);
-        if (!builder) {
-            builder = new products_service_1.default({
-                workspace_id: this.config.workspace_id,
-                public_key: this.config.public_key,
-                user_id: this.config.user_id,
-                token: this.config.token,
-                env_type: this.config.env_type,
-                redis_client: this.config.redis_client,
-                queues: this.config.queues,
-                access_key: this.config.access_key,
-            });
-            await builder.initializeProductByTag(productTag);
-            this.productBuilders.set(productTag, builder);
-        }
-        return builder;
-    }
-    /**
-     * Creates a ProcessorService instance for local execution
-     */
-    createProcessor() {
-        return new processor_service_1.default({
-            workspace_id: this.config.workspace_id,
-            public_key: this.config.public_key,
-            user_id: this.config.user_id,
-            token: this.config.token,
-            env_type: this.config.env_type,
-            redis_client: this.config.redis_client,
-            queues: this.config.queues,
-            private_key: this._privateKey,
-        });
-    }
-    /**
-     * Define a healthcheck using code-first API
-     *
-     * @example
-     * ```ts
-     * const healthcheck = await healthcheckService.define({
-     *   product: 'my-product',
-     *   tag: 'stripe-health',
-     *   name: 'Stripe API Health',
-     *   handler: async (ctx) => {
-     *     ctx.probe().app('stripe-app').action('health');
-     *     ctx.interval(30000);
-     *     ctx.retries(2);
-     *     ctx.env('prd');
-     *     ctx.env('stg');
-     *   },
-     * });
-     * ```
-     */
-    async define(options) {
-        const ctx = new RecordingHealthcheckContext();
-        // Execute the handler to record the configuration
-        await options.handler(ctx);
-        // Build the schema
-        const schema = ctx.build(options.tag, options.name, options.description);
-        const definedHealthcheck = {
-            tag: options.tag,
-            name: options.name,
-            description: options.description,
-            compile: () => schema,
-        };
-        // If product is specified, register immediately
-        if (options.product) {
-            await this.create(options.product, definedHealthcheck);
-        }
-        return definedHealthcheck;
-    }
-    /**
-     * Create a healthcheck from a defined healthcheck or schema.
-     * Persists as product component so processor healthcheck workers and health.list/fetch see it.
-     */
-    async create(product, healthcheck) {
-        var _a, _b, _c;
-        const schema = 'compile' in healthcheck ? healthcheck.compile() : healthcheck;
-        const builder = await this.getProductBuilder(product);
-        await builder.createHealthcheckFromSchema({
-            tag: schema.tag,
-            name: schema.name,
-            description: schema.description,
-            probe: schema.probe,
-            interval: (_a = schema.interval) !== null && _a !== void 0 ? _a : 60000,
-            retries: (_b = schema.retries) !== null && _b !== void 0 ? _b : 2,
-            envs: (_c = schema.envs) !== null && _c !== void 0 ? _c : [],
-            onFailure: schema.onFailure,
-        });
-        return schema;
-    }
-    /**
-     * Update an existing healthcheck
-     */
-    async update(product, tag, healthcheck) {
-        if ('handler' in healthcheck && healthcheck.handler) {
-            const ctx = new RecordingHealthcheckContext();
-            await healthcheck.handler(ctx);
-            const schema = ctx.build(tag, healthcheck.name, healthcheck.description);
-            return await this.apiService.updateHealthcheck(product, tag, schema);
-        }
-        return await this.apiService.updateHealthcheck(product, tag, healthcheck);
-    }
-    /**
-     * Fetch a healthcheck by tag (uses product components API)
-     */
-    async fetch(product, tag) {
-        const builder = await this.getProductBuilder(product);
-        const list = await builder.fetchProductHealthchecks();
-        const found = list === null || list === void 0 ? void 0 : list.find((h) => h.tag === tag);
-        if (!found)
-            throw new HealthcheckError(`Healthcheck "${tag}" not found`, 'NOT_FOUND');
-        return found;
-    }
-    /**
-     * Fetch all healthchecks for a product (uses product components API)
-     */
-    async fetchAll(product) {
-        const builder = await this.getProductBuilder(product);
-        const list = await builder.fetchProductHealthchecks();
-        return (list !== null && list !== void 0 ? list : []);
-    }
-    /**
-     * Delete a healthcheck
-     */
-    async delete(product, tag) {
-        await this.apiService.deleteHealthcheck(product, tag);
-    }
-    /**
-     * Get the current status of a healthcheck
-     */
-    async getStatus(options) {
-        return await this.apiService.getHealthcheckStatus(options.product, options.tag, options.env);
-    }
-    /**
-     * Alias for getStatus - check the health of a service
-     *
-     * @example
-     * ```ts
-     * const status = await resilience.healthcheck.check({
-     *   product: 'my-product',
-     *   env: 'prd',
-     *   tag: 'stripe-health',
-     * });
-     * console.log(status.status); // 'healthy' | 'unhealthy' | 'degraded'
-     * ```
-     */
-    async check(options) {
-        return await this.getStatus(options);
-    }
-    /**
-     * Manually trigger a healthcheck
-     *
-     * Executes the healthcheck locally using the ProcessorService and caches
-     * the result in Redis for status tracking. On failure, triggers configured
-     * notifications, webhooks, and event emissions.
-     *
-     * Supports the following probe types:
-     * - APP: Executes an app action (supports OAuth auto-refresh)
-     * - DATABASE: Tests database connection
-     * - GRAPH: Tests graph database connection
-     * - MESSAGE_BROKER: Tests message broker connection
-     * - STORAGE: Tests object storage connection
-     * - WORKFLOW: Executes a workflow and checks completion status
-     */
-    async run(options) {
-        var _a, _b, _c, _d, _e, _f;
-        // Fetch the healthcheck configuration
-        const healthcheck = await this.fetch(options.product, options.tag);
-        // Find the environment configuration
-        const envConfig = (_a = healthcheck.envs) === null || _a === void 0 ? void 0 : _a.find((e) => e.slug === options.env);
-        // Execute via processor
-        const processor = this.createProcessor();
-        const startTime = Date.now();
-        // Infer probe type from probe shape when type is missing (e.g. API returns probe without type)
-        const probe = healthcheck.probe;
-        const probeType = ((_b = healthcheck.probe) === null || _b === void 0 ? void 0 : _b.type) ||
-            ((probe === null || probe === void 0 ? void 0 : probe.app) ? types_1.ProbeType.APP : undefined) ||
-            ((probe === null || probe === void 0 ? void 0 : probe.database) ? types_1.ProbeType.DATABASE : undefined) ||
-            ((probe === null || probe === void 0 ? void 0 : probe.workflow) ? types_1.ProbeType.WORKFLOW : undefined) ||
-            ((probe === null || probe === void 0 ? void 0 : probe.graph) ? types_1.ProbeType.GRAPH : undefined) ||
-            ((probe === null || probe === void 0 ? void 0 : probe.messageBroker) ? types_1.ProbeType.MESSAGE_BROKER : undefined) ||
-            ((probe === null || probe === void 0 ? void 0 : probe.storage) ? types_1.ProbeType.STORAGE : undefined) ||
-            types_1.ProbeType.APP;
-        let result;
-        if (probeType === types_1.ProbeType.DATABASE) {
-            // Database healthcheck - test connection
-            result = await this.executeDatabaseProbe(healthcheck, options.product, options.env, startTime);
-        }
-        else if (probeType === types_1.ProbeType.GRAPH) {
-            // Graph healthcheck - test connection
-            result = await this.executeGraphProbe(healthcheck, options.product, options.env, startTime);
-        }
-        else if (probeType === types_1.ProbeType.MESSAGE_BROKER) {
-            // Message broker healthcheck - test connection
-            result = await this.executeMessageBrokerProbe(healthcheck, options.product, options.env, startTime);
-        }
-        else if (probeType === types_1.ProbeType.APP) {
-            // App healthcheck - execute app action; ensure input is always an object (decrypt env input if stored encrypted)
-            let input = {};
-            const rawInput = (_c = envConfig === null || envConfig === void 0 ? void 0 : envConfig.input) !== null && _c !== void 0 ? _c : (_d = healthcheck.probe) === null || _d === void 0 ? void 0 : _d.input;
-            if (rawInput != null) {
-                if (typeof rawInput === 'string') {
-                    try {
-                        const builder = await this.getProductBuilder(options.product);
-                        const privateKey = builder.fetchPrivateKey();
-                        const raw = (0, processor_utils_1.decrypt)(rawInput, privateKey);
-                        input = ((raw === null || raw === void 0 ? void 0 : raw.trim()) ? JSON.parse(raw) : {});
-                    }
-                    catch (_g) {
-                        input = {};
-                    }
-                }
-                else if (typeof rawInput === 'object' && !Array.isArray(rawInput)) {
-                    input = rawInput;
-                }
-            }
-            const actionData = {
-                env: options.env,
-                product: options.product,
-                app: ((_e = healthcheck.probe) === null || _e === void 0 ? void 0 : _e.app) || healthcheck.app,
-                input,
-                action: ((_f = healthcheck.probe) === null || _f === void 0 ? void 0 : _f.event) || healthcheck.event,
-                retries: healthcheck.retries || 0,
-            };
-            result = await processor.processAction(actionData);
-            result = {
-                status: result ? 'available' : 'unavailable',
-                latency: Date.now() - startTime,
-            };
-        }
-        else if (probeType === types_1.ProbeType.WORKFLOW) {
-            // Workflow healthcheck - execute workflow
-            result = await this.executeWorkflowProbe(healthcheck, options.product, options.env, startTime);
-        }
-        else if (probeType === types_1.ProbeType.STORAGE) {
-            // Storage healthcheck - test connection
-            result = await this.executeStorageProbe(healthcheck, options.product, options.env, startTime);
-        }
-        // Build cache data with healthcheck tag for Redis key
-        const cacheData = {
-            healthcheck: options.tag,
-            env: options.env,
-            product: options.product,
-        };
-        // Determine if healthcheck failed
-        const isFailure = !result || result.status === 'unavailable' || result.status === 'error' || result.status === 'unknown';
-        // Write result to Redis cache
-        const healthcheckResult = Object.assign({ status: (result === null || result === void 0 ? void 0 : result.status) || 'unknown', checkedAt: new Date().toISOString(), latency: (result === null || result === void 0 ? void 0 : result.latency) || 0 }, result);
-        await processor.writeHealthcheckResultToCache(cacheData, healthcheckResult);
-        // Handle failure notifications if configured
-        if (isFailure && healthcheck.onFailure) {
-            await this.handleFailureNotifications(processor, healthcheck.onFailure, options, healthcheckResult);
-        }
-        return healthcheckResult;
-    }
-    /**
-     * Handles failure notifications for a healthcheck
-     */
-    async handleFailureNotifications(processor, onFailure, options, result) {
-        const failureContext = {
-            healthcheck: options.tag,
-            product: options.product,
-            env: options.env,
-            status: result.status,
-            timestamp: result.checkedAt,
-        };
-        // Process notifications via processor service
-        if (onFailure.notifications && onFailure.notifications.length > 0) {
-            for (const notification of onFailure.notifications) {
-                try {
-                    // Build notification input with channel-specific recipients
-                    const notificationInput = Object.assign({}, failureContext);
-                    // Add channel-specific data
-                    if (notification.channels.email) {
-                        notificationInput.email = notification.channels.email;
-                    }
-                    if (notification.channels.sms) {
-                        notificationInput.sms = notification.channels.sms;
-                    }
-                    if (notification.channels.push) {
-                        notificationInput.push = notification.channels.push;
-                    }
-                    if (notification.channels.callback) {
-                        notificationInput.callback = notification.channels.callback;
-                    }
-                    await processor.processNotification({
-                        env: options.env,
-                        product: options.product,
-                        event: `${notification.notification}:${notification.message}`,
-                        input: notificationInput,
-                        retries: 2,
-                    });
-                }
-                catch (error) {
-                    // Log but don't throw - notification failures shouldn't break the healthcheck
-                    console.error(`Failed to send notification for healthcheck ${options.tag}:`, error);
-                }
-            }
-        }
-        // Process webhooks
-        if (onFailure.webhooks && onFailure.webhooks.length > 0) {
-            for (const webhook of onFailure.webhooks) {
-                try {
-                    const axios = (await Promise.resolve().then(() => __importStar(require('axios')))).default;
-                    await axios({
-                        method: webhook.method || 'POST',
-                        url: webhook.url,
-                        headers: webhook.headers,
-                        data: Object.assign(Object.assign({}, failureContext), webhook.body),
-                        timeout: 10000,
-                    });
-                }
-                catch (error) {
-                    // Log but don't throw - webhook failures shouldn't break the healthcheck
-                    console.error(`Failed to call webhook for healthcheck ${options.tag}:`, error);
-                }
-            }
-        }
-        // Process event emissions (emit to message broker if configured)
-        if (onFailure.emit && onFailure.emit.length > 0) {
-            for (const emission of onFailure.emit) {
-                try {
-                    // Emit events via message broker if available
-                    await processor.processMessageBrokerPublish({
-                        env: options.env,
-                        product: options.product,
-                        event: emission.event,
-                        input: {
-                            message: Object.assign(Object.assign({}, failureContext), emission.data),
-                        },
-                    });
-                }
-                catch (error) {
-                    // Log but don't throw - emit failures shouldn't break the healthcheck
-                    console.error(`Failed to emit event for healthcheck ${options.tag}:`, error);
-                }
-            }
-        }
-    }
-    /**
-     * Execute a database healthcheck probe by testing the connection
-     */
-    async executeDatabaseProbe(healthcheck, product, env, startTime) {
-        var _a;
-        const databaseTag = (_a = healthcheck.probe) === null || _a === void 0 ? void 0 : _a.database;
-        if (!databaseTag) {
-            throw new HealthcheckError('Database healthcheck requires a database tag in the probe configuration', 'MISSING_DATABASE_TAG');
-        }
-        try {
-            // Dynamically import DatabaseService to avoid circular dependencies
-            const { DatabaseService } = await Promise.resolve().then(() => __importStar(require('../database/databases.service')));
-            const dbService = new DatabaseService({
-                workspace_id: this.config.workspace_id,
-                public_key: this.config.public_key,
-                user_id: this.config.user_id,
-                token: this.config.token,
-                env_type: this.config.env_type,
-                private_key: this._privateKey,
-                access_key: this.config.access_key,
-            });
-            // Test the database connection
-            const connectionResult = await dbService.testConnection({
-                product,
-                env,
-                database: databaseTag,
-            });
-            const latency = Date.now() - startTime;
-            if (connectionResult.connected) {
-                return {
-                    status: 'available',
-                    latency,
-                };
-            }
-            else {
-                return {
-                    status: 'unavailable',
-                    latency,
-                };
-            }
-        }
-        catch (error) {
-            const latency = Date.now() - startTime;
-            return {
-                status: 'unavailable',
-                latency,
-            };
-        }
-    }
-    /**
-     * Execute a graph healthcheck probe by testing the connection
-     */
-    async executeGraphProbe(healthcheck, product, env, startTime) {
-        var _a;
-        const graphTag = (_a = healthcheck.probe) === null || _a === void 0 ? void 0 : _a.graph;
-        if (!graphTag) {
-            throw new HealthcheckError('Graph healthcheck requires a graph tag in the probe configuration', 'MISSING_GRAPH_TAG');
-        }
-        try {
-            // Dynamically import GraphService to avoid circular dependencies
-            const { GraphService } = await Promise.resolve().then(() => __importStar(require('../graph/graphs.service')));
-            const graphService = new GraphService({
-                workspace_id: this.config.workspace_id,
-                public_key: this.config.public_key,
-                user_id: this.config.user_id,
-                token: this.config.token,
-                env_type: this.config.env_type,
-                private_key: this._privateKey,
-                access_key: this.config.access_key,
-            });
-            // Test the graph connection
-            const connectionResult = await graphService.testConnection({
-                product,
-                env,
-                graph: graphTag,
-            });
-            const latency = Date.now() - startTime;
-            if (connectionResult.connected) {
-                return {
-                    status: 'available',
-                    latency,
-                };
-            }
-            else {
-                return {
-                    status: 'unavailable',
-                    latency,
-                };
-            }
-        }
-        catch (error) {
-            const latency = Date.now() - startTime;
-            return {
-                status: 'unavailable',
-                latency,
-            };
-        }
-    }
-    /**
-     * Execute a message broker healthcheck probe by testing the connection
-     */
-    async executeMessageBrokerProbe(healthcheck, product, env, startTime) {
-        var _a;
-        const brokerTag = (_a = healthcheck.probe) === null || _a === void 0 ? void 0 : _a.messageBroker;
-        if (!brokerTag) {
-            throw new HealthcheckError('Message broker healthcheck requires a messageBroker tag in the probe configuration', 'MISSING_MESSAGE_BROKER_TAG');
-        }
-        try {
-            // Dynamically import BrokersService to avoid circular dependencies
-            const { BrokersService } = await Promise.resolve().then(() => __importStar(require('../brokers/brokers.service')));
-            const brokersService = new BrokersService({
-                workspace_id: this.config.workspace_id,
-                public_key: this.config.public_key,
-                user_id: this.config.user_id,
-                token: this.config.token,
-                env_type: this.config.env_type,
-            });
-            // Test the broker connection by attempting to get broker config
-            // This validates broker exists and credentials are correct
-            const connectionResult = await brokersService.testConnection({
-                product,
-                env,
-                broker: brokerTag,
-            });
-            const latency = Date.now() - startTime;
-            if (connectionResult.connected) {
-                return {
-                    status: 'available',
-                    latency,
-                };
-            }
-            else {
-                return {
-                    status: 'unavailable',
-                    latency,
-                };
-            }
-        }
-        catch (error) {
-            const latency = Date.now() - startTime;
-            return {
-                status: 'unavailable',
-                latency,
-            };
-        }
-    }
-    /**
-     * Execute a workflow healthcheck probe by running the workflow
-     *
-     * Workflow healthchecks execute the workflow with the provided input
-     * and check if it completes successfully. This is useful for testing
-     * end-to-end workflow functionality.
-     */
-    async executeWorkflowProbe(healthcheck, product, env, startTime) {
-        var _a, _b;
-        const workflowTag = (_a = healthcheck.probe) === null || _a === void 0 ? void 0 : _a.workflow;
-        if (!workflowTag) {
-            throw new HealthcheckError('Workflow healthcheck requires a workflow tag in the probe configuration', 'MISSING_WORKFLOW_TAG');
-        }
-        try {
-            // Dynamically import WorkflowService to avoid circular dependencies
-            const { WorkflowService } = await Promise.resolve().then(() => __importStar(require('../workflows/workflows.service')));
-            const workflowService = new WorkflowService({
-                workspace_id: this.config.workspace_id,
-                public_key: this.config.public_key,
-                user_id: this.config.user_id,
-                token: this.config.token,
-                env_type: this.config.env_type,
-                private_key: this._privateKey,
-                access_key: this.config.access_key,
-            });
-            // Execute the workflow with the configured input
-            const input = ((_b = healthcheck.probe) === null || _b === void 0 ? void 0 : _b.input) || {};
-            const result = await workflowService.execute({
-                product,
-                env,
-                tag: workflowTag,
-                input,
-            });
-            const latency = Date.now() - startTime;
-            // Check if workflow completed successfully
-            if (result.status === 'completed') {
-                return {
-                    status: 'available',
-                    latency,
-                };
-            }
-            else {
-                return {
-                    status: 'unavailable',
-                    latency,
-                };
-            }
-        }
-        catch (error) {
-            const latency = Date.now() - startTime;
-            return {
-                status: 'unavailable',
-                latency,
-            };
-        }
-    }
-    /**
-     * Execute a storage healthcheck probe by testing the connection
-     *
-     * Storage healthchecks attempt to list objects (with limit 1) to verify
-     * connectivity and credentials are working correctly.
-     */
-    async executeStorageProbe(healthcheck, product, env, startTime) {
-        var _a;
-        const storageTag = (_a = healthcheck.probe) === null || _a === void 0 ? void 0 : _a.storage;
-        if (!storageTag) {
-            throw new HealthcheckError('Storage healthcheck requires a storage tag in the probe configuration', 'MISSING_STORAGE_TAG');
-        }
-        try {
-            // Dynamically import StorageService to avoid circular dependencies
-            const { StorageService } = await Promise.resolve().then(() => __importStar(require('../storage/storage.service')));
-            const storageService = new StorageService({
-                workspace_id: this.config.workspace_id,
-                public_key: this.config.public_key,
-                user_id: this.config.user_id,
-                token: this.config.token,
-                env_type: this.config.env_type,
-                private_key: this._privateKey,
-            });
-            // Test the storage connection
-            const connectionResult = await storageService.testConnection({
-                product,
-                env,
-                storage: storageTag,
-            });
-            const latency = Date.now() - startTime;
-            if (connectionResult.connected) {
-                return {
-                    status: 'available',
-                    latency,
-                };
-            }
-            else {
-                return {
-                    status: 'unavailable',
-                    latency,
-                };
-            }
-        }
-        catch (error) {
-            const latency = Date.now() - startTime;
-            return {
-                status: 'unavailable',
-                latency,
-            };
-        }
-    }
-    /**
-     * @deprecated Use run() instead
-     */
-    async runNow(options) {
-        return await this.run(options);
-    }
-}
-exports.HealthcheckService = HealthcheckService;
-exports.default = HealthcheckService;
-//# sourceMappingURL=healthcheck.service.js.map