medusa-stats 1.0.5

package/.medusa/server/src/workflows/statistics/steps/create-statistics-options.d.ts

@@ -0,0 +1,117 @@
+export interface CreateStatisticsOptionsInput {
+    options: Array<{
+        provider_option_name: string;
+        local_option_name: string;
+        data: Record<string, any>;
+        provider_id: string;
+    }>;
+}
+export declare const createStatisticsOptionsStep: import("@medusajs/framework/workflows-sdk").StepFunction<CreateStatisticsOptionsInput, {
+    id: string;
+    provider_option_name: string;
+    local_option_name: string;
+    data: Record<string, unknown>;
+    visualization_config: Record<string, unknown> | null;
+    cache_options: Record<string, unknown> | null;
+    parameter_config: Record<string, unknown> | null;
+    preset: boolean;
+    provider: {
+        id: string;
+        display_name: string;
+        is_enabled: boolean;
+        options: /*elided*/ any[];
+        created_at: Date;
+        updated_at: Date;
+        deleted_at: Date | null;
+    };
+    alerts: {
+        id: string;
+        name: string;
+        description: string | null;
+        option: /*elided*/ any;
+        condition: Record<string, unknown>;
+        period: Record<string, unknown> | null;
+        interval: number;
+        severity: "info" | "warning" | "critical";
+        is_enabled: boolean;
+        metadata: Record<string, unknown> | null;
+        logs: {
+            id: string;
+            alert: /*elided*/ any;
+            triggered_at: Date;
+            evaluation_data: Record<string, unknown>;
+            evaluation_hash: string;
+            metadata: Record<string, unknown> | null;
+            created_at: Date;
+            updated_at: Date;
+            deleted_at: Date | null;
+            alert_id: string;
+        }[];
+        created_at: Date;
+        updated_at: Date;
+        deleted_at: Date | null;
+        option_id: string;
+    }[];
+    charts: {
+        id: string;
+        name: string;
+        description: string | null;
+        visualization_config: Record<string, unknown> | null;
+        layout: Record<string, unknown> | null;
+        view: {
+            id: string;
+            name: string;
+            description: string | null;
+            charts: /*elided*/ any[];
+            stats_data: Record<string, unknown> | null;
+            period_type: "rolling" | "calendar" | "custom" | null;
+            period_config: Record<string, unknown> | null;
+            interval: number | null;
+            cache_options: Record<string, unknown> | null;
+            layout_config: Record<string, unknown>;
+            metadata: Record<string, unknown>;
+            raw_interval: Record<string, unknown> | null;
+            created_at: Date;
+            updated_at: Date;
+            deleted_at: Date | null;
+        };
+        statistics: /*elided*/ any[];
+        metadata: Record<string, unknown>;
+        created_at: Date;
+        updated_at: Date;
+        deleted_at: Date | null;
+        view_id: string;
+    }[];
+    input_dependencies: {
+        id: string;
+        composite_option: /*elided*/ any;
+        input_option: /*elided*/ any;
+        parameter_name: string | null;
+        order: number | null;
+        metadata: Record<string, unknown> | null;
+        raw_order: Record<string, unknown> | null;
+        created_at: Date;
+        updated_at: Date;
+        deleted_at: Date | null;
+        composite_option_id: string;
+        input_option_id: string;
+    }[];
+    dependent_composites: {
+        id: string;
+        composite_option: /*elided*/ any;
+        input_option: /*elided*/ any;
+        parameter_name: string | null;
+        order: number | null;
+        metadata: Record<string, unknown> | null;
+        raw_order: Record<string, unknown> | null;
+        created_at: Date;
+        updated_at: Date;
+        deleted_at: Date | null;
+        composite_option_id: string;
+        input_option_id: string;
+    }[];
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date | null;
+    provider_id: string;
+}[]>;

package/.medusa/server/src/workflows/statistics/steps/create-statistics-options.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatisticsOptionsStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const statistics_1 = require("../../../modules/statistics");
+exports.createStatisticsOptionsStep = (0, workflows_sdk_1.createStep)("create-statistics-options", async (input, { container }) => {
+    const statisticsService = container.resolve(statistics_1.STATISTICS_MODULE);
+    const createdOptions = await statisticsService.createStatisticsOptions(input.options);
+    return new workflows_sdk_1.StepResponse(createdOptions, createdOptions.map((opt) => opt.id));
+}, async (optionIds, { container }) => {
+    if (!optionIds || optionIds.length === 0)
+        return;
+    const statisticsService = container.resolve(statistics_1.STATISTICS_MODULE);
+    await statisticsService.deleteStatisticsOptions(optionIds);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLXN0YXRpc3RpY3Mtb3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3Mvc3RhdGlzdGljcy9zdGVwcy9jcmVhdGUtc3RhdGlzdGljcy1vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFFQUE2RTtBQUM3RSw0REFBZ0U7QUFZbkQsUUFBQSwyQkFBMkIsR0FBRyxJQUFBLDBCQUFVLEVBQ2pELDJCQUEyQixFQUMzQixLQUFLLEVBQUUsS0FBbUMsRUFBRSxFQUFFLFNBQVMsRUFBRSxFQUFFLEVBQUU7SUFDekQsTUFBTSxpQkFBaUIsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFvQiw4QkFBaUIsQ0FBQyxDQUFDO0lBRWxGLE1BQU0sY0FBYyxHQUFHLE1BQU0saUJBQWlCLENBQUMsdUJBQXVCLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBRXRGLE9BQU8sSUFBSSw0QkFBWSxDQUNuQixjQUFjLEVBQ2QsY0FBYyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQVEsRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUMzQyxDQUFDO0FBQ04sQ0FBQyxFQUNELEtBQUssRUFBRSxTQUFtQixFQUFFLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRTtJQUN6QyxJQUFJLENBQUMsU0FBUyxJQUFJLFNBQVMsQ0FBQyxNQUFNLEtBQUssQ0FBQztRQUFFLE9BQU87SUFFakQsTUFBTSxpQkFBaUIsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFvQiw4QkFBaUIsQ0FBQyxDQUFDO0lBQ2xGLE1BQU0saUJBQWlCLENBQUMsdUJBQXVCLENBQUMsU0FBUyxDQUFDLENBQUM7QUFDL0QsQ0FBQyxDQUNKLENBQUMifQ==

package/.medusa/server/src/workflows/statistics/steps/create-statistics-view.d.ts

@@ -0,0 +1,119 @@
+export interface CreateStatisticsViewInput {
+    name: string;
+    description?: string;
+    stats_data?: Record<string, any>;
+    layout_config?: Record<string, any>;
+    metadata?: Record<string, any>;
+    period_type?: "rolling" | "calendar" | "custom";
+    period_config?: Record<string, any>;
+    interval?: number;
+}
+export declare const createStatisticsViewStep: import("@medusajs/framework/workflows-sdk").StepFunction<CreateStatisticsViewInput, {
+    id: string;
+    name: string;
+    description: string | null;
+    charts: {
+        id: string;
+        name: string;
+        description: string | null;
+        visualization_config: Record<string, unknown> | null;
+        layout: Record<string, unknown> | null;
+        view: /*elided*/ any;
+        statistics: {
+            id: string;
+            provider_option_name: string;
+            local_option_name: string;
+            data: Record<string, unknown>;
+            visualization_config: Record<string, unknown> | null;
+            cache_options: Record<string, unknown> | null;
+            parameter_config: Record<string, unknown> | null;
+            preset: boolean;
+            provider: {
+                id: string;
+                display_name: string;
+                is_enabled: boolean;
+                options: /*elided*/ any[];
+                created_at: Date;
+                updated_at: Date;
+                deleted_at: Date | null;
+            };
+            alerts: {
+                id: string;
+                name: string;
+                description: string | null;
+                option: /*elided*/ any;
+                condition: Record<string, unknown>;
+                period: Record<string, unknown> | null;
+                interval: number;
+                severity: "info" | "warning" | "critical";
+                is_enabled: boolean;
+                metadata: Record<string, unknown> | null;
+                logs: {
+                    id: string;
+                    alert: /*elided*/ any;
+                    triggered_at: Date;
+                    evaluation_data: Record<string, unknown>;
+                    evaluation_hash: string;
+                    metadata: Record<string, unknown> | null;
+                    created_at: Date;
+                    updated_at: Date;
+                    deleted_at: Date | null;
+                    alert_id: string;
+                }[];
+                created_at: Date;
+                updated_at: Date;
+                deleted_at: Date | null;
+                option_id: string;
+            }[];
+            charts: /*elided*/ any[];
+            input_dependencies: {
+                id: string;
+                composite_option: /*elided*/ any;
+                input_option: /*elided*/ any;
+                parameter_name: string | null;
+                order: number | null;
+                metadata: Record<string, unknown> | null;
+                raw_order: Record<string, unknown> | null;
+                created_at: Date;
+                updated_at: Date;
+                deleted_at: Date | null;
+                composite_option_id: string;
+                input_option_id: string;
+            }[];
+            dependent_composites: {
+                id: string;
+                composite_option: /*elided*/ any;
+                input_option: /*elided*/ any;
+                parameter_name: string | null;
+                order: number | null;
+                metadata: Record<string, unknown> | null;
+                raw_order: Record<string, unknown> | null;
+                created_at: Date;
+                updated_at: Date;
+                deleted_at: Date | null;
+                composite_option_id: string;
+                input_option_id: string;
+            }[];
+            created_at: Date;
+            updated_at: Date;
+            deleted_at: Date | null;
+            provider_id: string;
+        }[];
+        metadata: Record<string, unknown>;
+        created_at: Date;
+        updated_at: Date;
+        deleted_at: Date | null;
+        view_id: string;
+    }[];
+    stats_data: Record<string, unknown> | null;
+    period_type: "rolling" | "calendar" | "custom" | null;
+    period_config: Record<string, unknown> | null;
+    interval: number | null;
+    cache_options: Record<string, unknown> | null;
+    layout_config: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    raw_interval: Record<string, unknown> | null;
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date | null;
+}>;

package/.medusa/server/src/workflows/statistics/steps/create-statistics-view.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatisticsViewStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const statistics_1 = require("../../../modules/statistics");
+exports.createStatisticsViewStep = (0, workflows_sdk_1.createStep)("create-statistics-view", async (input, { container }) => {
+    const statisticsService = container.resolve(statistics_1.STATISTICS_MODULE);
+    const view = await statisticsService.createStatisticsViews(input);
+    return new workflows_sdk_1.StepResponse(view, view.id);
+}, async (viewId, { container }) => {
+    if (!viewId)
+        return;
+    const statisticsService = container.resolve(statistics_1.STATISTICS_MODULE);
+    await statisticsService.deleteStatisticsViews(viewId);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLXN0YXRpc3RpY3Mtdmlldy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3Mvc3RhdGlzdGljcy9zdGVwcy9jcmVhdGUtc3RhdGlzdGljcy12aWV3LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFFQUE2RTtBQUM3RSw0REFBZ0U7QUFjbkQsUUFBQSx3QkFBd0IsR0FBRyxJQUFBLDBCQUFVLEVBQzlDLHdCQUF3QixFQUN4QixLQUFLLEVBQUUsS0FBZ0MsRUFBRSxFQUFFLFNBQVMsRUFBRSxFQUFFLEVBQUU7SUFDdEQsTUFBTSxpQkFBaUIsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFvQiw4QkFBaUIsQ0FBQyxDQUFDO0lBRWxGLE1BQU0sSUFBSSxHQUFHLE1BQU0saUJBQWlCLENBQUMscUJBQXFCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFFbEUsT0FBTyxJQUFJLDRCQUFZLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztBQUMzQyxDQUFDLEVBQ0QsS0FBSyxFQUFFLE1BQWMsRUFBRSxFQUFFLFNBQVMsRUFBRSxFQUFFLEVBQUU7SUFDcEMsSUFBSSxDQUFDLE1BQU07UUFBRSxPQUFPO0lBRXBCLE1BQU0saUJBQWlCLEdBQUcsU0FBUyxDQUFDLE9BQU8sQ0FBb0IsOEJBQWlCLENBQUMsQ0FBQztJQUNsRixNQUFNLGlCQUFpQixDQUFDLHFCQUFxQixDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQzFELENBQUMsQ0FDSixDQUFDIn0=

package/.medusa/server/src/workflows/statistics/steps/dedupe-alerts.d.ts

@@ -0,0 +1,22 @@
+export interface DedupeAlertsInput {
+    alerts: any[];
+    evaluation_results: Array<{
+        alert_id: string;
+        triggered: boolean;
+        current_value: number;
+        reference_value: number | null;
+        compare_value: number | [number, number];
+        operator: string;
+        comparison_type: string;
+    }>;
+    evaluation_scope?: {
+        periodStart?: Date;
+        periodEnd?: Date;
+        interval?: number;
+    };
+}
+export interface AllowedAlertEvaluation {
+    alert_id: string;
+    evaluation_hash: string;
+}
+export declare const dedupeAlertsStep: import("@medusajs/framework/workflows-sdk").StepFunction<DedupeAlertsInput, AllowedAlertEvaluation[]>;

package/.medusa/server/src/workflows/statistics/steps/dedupe-alerts.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dedupeAlertsStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const statistics_1 = require("../../../modules/statistics");
+const framework_1 = require("@medusajs/framework");
+exports.dedupeAlertsStep = (0, workflows_sdk_1.createStep)("check-cooldown-period", async (input, { container }) => {
+    const statisticsService = container.resolve(statistics_1.STATISTICS_MODULE);
+    const allowedAlerts = [];
+    for (const result of input.evaluation_results) {
+        if (!result.triggered) {
+            continue;
+        }
+        const alert = input.alerts.find(a => a.id === result.alert_id);
+        if (!alert) {
+            continue;
+        }
+        const evaluationData = {
+            current_value: result.current_value,
+            reference_value: result.reference_value,
+            compare_value: result.compare_value,
+            threshold: alert.condition?.threshold ?? null,
+            operator: result.operator,
+            comparison_type: result.comparison_type,
+            condition: alert.condition,
+        };
+        const evaluationScope = {
+            periodStart: input.evaluation_scope?.periodStart
+                ? new Date(input.evaluation_scope.periodStart).toISOString()
+                : null,
+            periodEnd: input.evaluation_scope?.periodEnd
+                ? new Date(input.evaluation_scope.periodEnd).toISOString()
+                : null,
+            interval: input.evaluation_scope?.interval ?? null,
+        };
+        const evaluationHash = JSON.stringify({
+            alert_id: alert.id,
+            evaluationScope,
+            evaluationData,
+        });
+        try {
+            const existingLogs = await statisticsService.listStatisticsAlertLogs({
+                alert_id: alert.id,
+                evaluation_hash: evaluationHash,
+            }, {
+                select: ["id"],
+                take: 1,
+            });
+            if (existingLogs.length > 0) {
+                continue;
+            }
+        }
+        catch (error) {
+            framework_1.logger.error(`Error checking duplicate evaluation hash for alert ${alert.id}: ${error}`);
+            continue;
+        }
+        allowedAlerts.push({
+            alert_id: result.alert_id,
+            evaluation_hash: evaluationHash,
+        });
+    }
+    return new workflows_sdk_1.StepResponse(allowedAlerts);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/statistics/steps/delete-chart.d.ts

@@ -0,0 +1,6 @@
+export interface DeleteChartInput {
+    id: string;
+}
+export declare const deleteChartStep: import("@medusajs/framework/workflows-sdk").StepFunction<DeleteChartInput, {
+    success: boolean;
+}>;

package/.medusa/server/src/workflows/statistics/steps/delete-chart.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteChartStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const statistics_1 = require("../../../modules/statistics");
+exports.deleteChartStep = (0, workflows_sdk_1.createStep)("delete-chart", async (input, { container }) => {
+    const statisticsService = container.resolve(statistics_1.STATISTICS_MODULE);
+    const [chart] = await statisticsService.listStatisticsCharts({ id: input.id });
+    await statisticsService.deleteStatisticsCharts(input.id);
+    return new workflows_sdk_1.StepResponse({ success: true }, chart);
+}, async (originalChart, { container }) => {
+    if (!originalChart)
+        return;
+    const statisticsService = container.resolve(statistics_1.STATISTICS_MODULE);
+    await statisticsService.createStatisticsCharts(originalChart);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZXRlLWNoYXJ0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL3dvcmtmbG93cy9zdGF0aXN0aWNzL3N0ZXBzL2RlbGV0ZS1jaGFydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxRUFBNkU7QUFDN0UsNERBQWdFO0FBT25ELFFBQUEsZUFBZSxHQUFHLElBQUEsMEJBQVUsRUFDckMsY0FBYyxFQUNkLEtBQUssRUFBRSxLQUF1QixFQUFFLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRTtJQUM3QyxNQUFNLGlCQUFpQixHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQW9CLDhCQUFpQixDQUFDLENBQUM7SUFHbEYsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLE1BQU0saUJBQWlCLENBQUMsb0JBQW9CLENBQUMsRUFBRSxFQUFFLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFFL0UsTUFBTSxpQkFBaUIsQ0FBQyxzQkFBc0IsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUM7SUFFekQsT0FBTyxJQUFJLDRCQUFZLENBQUMsRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLEVBQUUsS0FBSyxDQUFDLENBQUM7QUFDdEQsQ0FBQyxFQUNELEtBQUssRUFBRSxhQUFrQixFQUFFLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRTtJQUN4QyxJQUFJLENBQUMsYUFBYTtRQUFFLE9BQU87SUFFM0IsTUFBTSxpQkFBaUIsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFvQiw4QkFBaUIsQ0FBQyxDQUFDO0lBQ2xGLE1BQU0saUJBQWlCLENBQUMsc0JBQXNCLENBQUMsYUFBYSxDQUFDLENBQUM7QUFDbEUsQ0FBQyxDQUNKLENBQUMifQ==

package/.medusa/server/src/workflows/statistics/steps/emit-alert-events.d.ts

@@ -0,0 +1,17 @@
+import type { ExtractedAlertValues } from "./extract-alert-values";
+import type { AllowedAlertEvaluation } from "./dedupe-alerts";
+export interface EmitAlertEventsInput {
+    alerts: any[];
+    evaluation_results: Array<{
+        alert_id: string;
+        triggered: boolean;
+        current_value: number;
+        reference_value: number | null;
+        compare_value: number | [number, number];
+        operator: string;
+        comparison_type: string;
+    }>;
+    allowed_alerts: AllowedAlertEvaluation[];
+    extracted_values: Record<string, ExtractedAlertValues>;
+}
+export declare const emitAlertEventsStep: import("@medusajs/framework/workflows-sdk").StepFunction<EmitAlertEventsInput, string[]>;

package/.medusa/server/src/workflows/statistics/steps/emit-alert-events.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitAlertEventsStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_1 = require("@medusajs/framework/utils");
+exports.emitAlertEventsStep = (0, workflows_sdk_1.createStep)("emit-alert-events", async (input, { container }) => {
+    const eventBus = container.resolve(utils_1.Modules.EVENT_BUS);
+    const emittedEventIds = [];
+    for (const allowed of input.allowed_alerts) {
+        const alert_id = allowed.alert_id;
+        const alert = input.alerts.find(a => a.id === alert_id);
+        const evaluation = input.evaluation_results.find(e => e.alert_id === alert_id);
+        const extracted = input.extracted_values[alert_id];
+        if (!alert || !evaluation || !extracted) {
+            continue;
+        }
+        const channels = Array.isArray(alert.metadata?.channels)
+            ? alert.metadata.channels
+            : [];
+        await eventBus.emit([
+            {
+                name: "statistics.alert",
+                data: {
+                    alert_id: alert.id,
+                    alert_name: alert.name,
+                    severity: alert.severity,
+                    option_id: alert.option_id,
+                    option_name: alert.option?.local_option_name,
+                    current_value: evaluation.current_value,
+                    reference_value: evaluation.reference_value,
+                    compare_value: evaluation.compare_value,
+                    operator: evaluation.operator,
+                    comparison_type: evaluation.comparison_type,
+                }
+            }
+        ]);
+        emittedEventIds.push(alert_id);
+    }
+    return new workflows_sdk_1.StepResponse(emittedEventIds);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/statistics/steps/evaluate-each-condition.d.ts

@@ -0,0 +1,15 @@
+import type { ExtractedAlertValues } from "./extract-alert-values";
+export interface EvaluateConditionsInput {
+    alerts: any[];
+    extracted_values: Record<string, ExtractedAlertValues>;
+}
+export interface AlertEvaluationResult {
+    alert_id: string;
+    triggered: boolean;
+    current_value: number;
+    reference_value: number | null;
+    compare_value: number | [number, number];
+    operator: string;
+    comparison_type: string;
+}
+export declare const evaluateEachConditionStep: import("@medusajs/framework/workflows-sdk").StepFunction<EvaluateConditionsInput, AlertEvaluationResult[]>;

package/.medusa/server/src/workflows/statistics/steps/evaluate-each-condition.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateEachConditionStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+exports.evaluateEachConditionStep = (0, workflows_sdk_1.createStep)("evaluate-each-condition", async (input, { container }) => {
+    const logger = container.resolve("logger");
+    const evaluationResults = [];
+    for (const alert of input.alerts) {
+        const { condition } = alert;
+        const extracted = input.extracted_values[alert.id];
+        if (!extracted) {
+            logger.warn(`[Alert ${alert.id}] No extracted values, skipping evaluation`);
+            continue;
+        }
+        const current = extracted.current;
+        let compareValue;
+        let triggered = false;
+        if (condition.comparisonType === 'absolute') {
+            compareValue = condition.threshold;
+        }
+        else if (condition.comparisonType === 'relative') {
+            if (!extracted.canDoRelative || extracted.reference === null) {
+                logger.warn(`[Alert ${alert.id}] Cannot perform relative comparison. ` +
+                    `Skipping evaluation.`);
+                continue;
+            }
+            const changeType = condition.changeType || 'absolute';
+            if (changeType === 'percentage') {
+                if (extracted.reference === 0) {
+                    logger.warn(`[Alert ${alert.id}] Cannot calculate percentage change with reference value of 0`);
+                    continue;
+                }
+                const percentageChange = ((current - extracted.reference) / extracted.reference) * 100;
+                compareValue = condition.threshold || 0;
+                triggered = evaluateOperator(percentageChange, compareValue, condition.operator);
+                evaluationResults.push({
+                    alert_id: alert.id,
+                    triggered,
+                    current_value: current,
+                    reference_value: extracted.reference,
+                    compare_value: percentageChange,
+                    operator: condition.operator,
+                    comparison_type: 'relative_percentage'
+                });
+                continue;
+            }
+            else {
+                compareValue = extracted.reference;
+            }
+        }
+        else {
+            logger.error(`[Alert ${alert.id}] Invalid comparisonType: ${condition.comparisonType}`);
+            continue;
+        }
+        triggered = evaluateOperator(current, compareValue, condition.operator);
+        evaluationResults.push({
+            alert_id: alert.id,
+            triggered,
+            current_value: current,
+            reference_value: extracted.reference,
+            compare_value: compareValue,
+            operator: condition.operator,
+            comparison_type: condition.comparisonType
+        });
+    }
+    return new workflows_sdk_1.StepResponse(evaluationResults);
+});
+function evaluateOperator(value, compareValue, operator) {
+    switch (operator) {
+        case "gt":
+            if (Array.isArray(compareValue)) {
+                return false;
+            }
+            return value > compareValue;
+        case "lt":
+            if (Array.isArray(compareValue)) {
+                return false;
+            }
+            return value < compareValue;
+        case "gte":
+            if (Array.isArray(compareValue)) {
+                return false;
+            }
+            return value >= compareValue;
+        case "lte":
+            if (Array.isArray(compareValue)) {
+                return false;
+            }
+            return value <= compareValue;
+        case "eq":
+            if (Array.isArray(compareValue)) {
+                return false;
+            }
+            return value === compareValue;
+        case "neq":
+            if (Array.isArray(compareValue)) {
+                return false;
+            }
+            return value !== compareValue;
+        case "between":
+            if (!Array.isArray(compareValue) || compareValue.length !== 2) {
+                return false;
+            }
+            return value >= compareValue[0] && value <= compareValue[1];
+        default:
+            return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/statistics/steps/extract-alert-values.d.ts

@@ -0,0 +1,12 @@
+export interface ExtractAlertValuesInput {
+    alerts: any[];
+    current_values: Record<string, any>;
+}
+export interface ExtractedAlertValues {
+    alert_id: string;
+    current: number;
+    reference: number | null;
+    valueType: 'timeseries' | 'single';
+    canDoRelative: boolean;
+}
+export declare const extractAlertValuesStep: import("@medusajs/framework/workflows-sdk").StepFunction<ExtractAlertValuesInput, Record<string, ExtractedAlertValues>>;