@ductape/sdk 0.0.4-v6 → 0.0.4-v61

package/dist/resilience/healthcheck.service.js

@@ -0,0 +1,943 @@
+"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"));
+/**
+ * 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.config = config;
+        this._privateKey = config.private_key;
+        this.apiService = new resilienceApi_service_1.ResilienceApiService({
+            token: config.token,
+            env_type: config.env_type,
+            base_url: config.base_url,
+        });
+    }
+    /**
+     * 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
+     */
+    async create(product, healthcheck) {
+        const schema = 'compile' in healthcheck ? healthcheck.compile() : healthcheck;
+        return await this.apiService.createHealthcheck(product, 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
+     */
+    async fetch(product, tag) {
+        return await this.apiService.getHealthcheck(product, tag);
+    }
+    /**
+     * Fetch all healthchecks for a product
+     */
+    async fetchAll(product) {
+        return await this.apiService.listHealthchecks(product);
+    }
+    /**
+     * 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;
+        // 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();
+        // Determine probe type and execute accordingly
+        let result;
+        const probeType = ((_b = healthcheck.probe) === null || _b === void 0 ? void 0 : _b.type) || types_1.ProbeType.APP;
+        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
+            const actionData = {
+                env: options.env,
+                product: options.product,
+                app: ((_c = healthcheck.probe) === null || _c === void 0 ? void 0 : _c.app) || healthcheck.app,
+                input: (envConfig === null || envConfig === void 0 ? void 0 : envConfig.input) || ((_d = healthcheck.probe) === null || _d === void 0 ? void 0 : _d.input) || {},
+                action: ((_e = healthcheck.probe) === null || _e === void 0 ? void 0 : _e.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