medusa-stats 1.0.5

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createViewWithOptionsWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const validate_view_input_1 = require("./steps/validate-view-input");
+const create_statistics_view_1 = require("./steps/create-statistics-view");
+const fetch_available_statistics_1 = require("./steps/fetch-available-statistics");
+const validate_option_parameters_1 = require("./steps/validate-option-parameters");
+const create_statistics_options_1 = require("./steps/create-statistics-options");
+exports.createViewWithOptionsWorkflow = (0, workflows_sdk_1.createWorkflow)("create-view-with-options", (input) => {
+    (0, validate_view_input_1.validateViewInputStep)(input.view);
+    const view = (0, create_statistics_view_1.createStatisticsViewStep)(input.view);
+    const providerIds = (0, workflows_sdk_1.transform)(input.options, (input) => {
+        return [...new Set(input.map(opt => opt.provider_id))];
+    });
+    const availableStatistics = (0, fetch_available_statistics_1.fetchAvailableStatisticsStep)({});
+    (0, validate_option_parameters_1.validateOptionParametersStep)({
+        options: input.options,
+        availableStatistics
+    });
+    const createdOptions = (0, create_statistics_options_1.createStatisticsOptionsStep)({
+        options: input.options
+    });
+    return new workflows_sdk_1.WorkflowResponse({
+        view,
+        options: createdOptions
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLXZpZXctd2l0aC1vcHRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL3dvcmtmbG93cy9zdGF0aXN0aWNzL2NyZWF0ZS12aWV3LXdpdGgtb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxRUFBZ0c7QUFDaEcscUVBQW9FO0FBQ3BFLDJFQUEwRTtBQUMxRSxtRkFBa0Y7QUFDbEYsbUZBQWtGO0FBQ2xGLGlGQUFnRjtBQXFCbkUsUUFBQSw2QkFBNkIsR0FBRyxJQUFBLDhCQUFjLEVBQ3ZELDBCQUEwQixFQUMxQixDQUFDLEtBQWlDLEVBQUUsRUFBRTtJQUVsQyxJQUFBLDJDQUFxQixFQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUdsQyxNQUFNLElBQUksR0FBRyxJQUFBLGlEQUF3QixFQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUdsRCxNQUFNLFdBQVcsR0FBRyxJQUFBLHlCQUFTLEVBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDLEtBQUssRUFBRSxFQUFFO1FBQ25ELE9BQU8sQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzNELENBQUMsQ0FBQyxDQUFDO0lBRUgsTUFBTSxtQkFBbUIsR0FBRyxJQUFBLHlEQUE0QixFQUFDLEVBQUUsQ0FBQyxDQUFDO0lBRzdELElBQUEseURBQTRCLEVBQUM7UUFDekIsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO1FBQ3RCLG1CQUFtQjtLQUN0QixDQUFDLENBQUM7SUFHSCxNQUFNLGNBQWMsR0FBRyxJQUFBLHVEQUEyQixFQUFDO1FBQy9DLE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTztLQUN6QixDQUFDLENBQUM7SUFFSCxPQUFPLElBQUksZ0NBQWdCLENBQUM7UUFDeEIsSUFBSTtRQUNKLE9BQU8sRUFBRSxjQUFjO0tBQzFCLENBQUMsQ0FBQztBQUNQLENBQUMsQ0FDSixDQUFDIn0=

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

@@ -0,0 +1,10 @@
+export interface DeleteChartInput {
+    id: string;
+}
+/**
+ * Deletes a chart.
+ * Associated statistics (series) are not deleted, only unlinked from the chart.
+ */
+export declare const deleteChartWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<DeleteChartInput, {
+    success: boolean;
+}, []>;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteChartWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const delete_chart_1 = require("./steps/delete-chart");
+/**
+ * Deletes a chart.
+ * Associated statistics (series) are not deleted, only unlinked from the chart.
+ */
+exports.deleteChartWorkflow = (0, workflows_sdk_1.createWorkflow)("delete-chart", (input) => {
+    const result = (0, delete_chart_1.deleteChartStep)(input);
+    return new workflows_sdk_1.WorkflowResponse(result);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZXRlLWNoYXJ0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL3dvcmtmbG93cy9zdGF0aXN0aWNzL2RlbGV0ZS1jaGFydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxRUFBcUY7QUFDckYsdURBQXVEO0FBTXZEOzs7R0FHRztBQUNVLFFBQUEsbUJBQW1CLEdBQUcsSUFBQSw4QkFBYyxFQUM3QyxjQUFjLEVBQ2QsQ0FBQyxLQUF1QixFQUFFLEVBQUU7SUFDeEIsTUFBTSxNQUFNLEdBQUcsSUFBQSw4QkFBZSxFQUFDLEtBQUssQ0FBQyxDQUFDO0lBRXRDLE9BQU8sSUFBSSxnQ0FBZ0IsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUN4QyxDQUFDLENBQ0osQ0FBQyJ9

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

@@ -0,0 +1,28 @@
+export interface EvaluateAlertsInput {
+    option_id: string;
+    calculated_value: any;
+    evaluation_scope?: {
+        periodStart?: Date;
+        periodEnd?: Date;
+        interval?: number;
+    };
+}
+/**
+ * Workflow: Evaluate Alerts After Calculation
+ *
+ * Purpose: Check alert conditions after statistic calculation and trigger notifications
+ *
+ * Steps:
+ * - fetch-active-alerts-for-option - Get all enabled alerts for calculated option
+ * - extract-alert-values - Extract current and reference values from calculated result
+ * - evaluate-each-condition - Check if alert conditions are met
+ * - check-cooldown-period - Verify alert hasn't fired recently (rate limiting)
+ * - emit-alert-triggered-events - Emit events for each triggered alert
+ * - create-alert-log-entries - Record alert triggers and delivery status
+ */
+export declare const evaluateAlertsWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<EvaluateAlertsInput, {
+    alerts_evaluated: number;
+    alerts_triggered: number;
+    alert_logs: any[];
+    events_emitted: number;
+}, []>;

package/.medusa/server/src/workflows/statistics/evaluate-alerts.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateAlertsWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const fetch_active_alerts_for_option_1 = require("./steps/fetch-active-alerts-for-option");
+const extract_alert_values_1 = require("./steps/extract-alert-values");
+const evaluate_each_condition_1 = require("./steps/evaluate-each-condition");
+const dedupe_alerts_1 = require("./steps/dedupe-alerts");
+const create_alert_log_entries_1 = require("./steps/create-alert-log-entries");
+const emit_alert_events_1 = require("./steps/emit-alert-events");
+/**
+ * Workflow: Evaluate Alerts After Calculation
+ *
+ * Purpose: Check alert conditions after statistic calculation and trigger notifications
+ *
+ * Steps:
+ * - fetch-active-alerts-for-option - Get all enabled alerts for calculated option
+ * - extract-alert-values - Extract current and reference values from calculated result
+ * - evaluate-each-condition - Check if alert conditions are met
+ * - check-cooldown-period - Verify alert hasn't fired recently (rate limiting)
+ * - emit-alert-triggered-events - Emit events for each triggered alert
+ * - create-alert-log-entries - Record alert triggers and delivery status
+ */
+exports.evaluateAlertsWorkflow = (0, workflows_sdk_1.createWorkflow)("evaluate-alerts", (input) => {
+    const alerts = (0, fetch_active_alerts_for_option_1.fetchActiveAlertsForOptionStep)({ option_id: input.option_id });
+    const shouldContinue = (0, workflows_sdk_1.transform)({ alerts }, (data) => {
+        return data.alerts && data.alerts.length > 0;
+    });
+    const current_values = (0, workflows_sdk_1.transform)({ input }, (data) => {
+        return { [data.input.option_id]: data.input.calculated_value };
+    });
+    const extracted_values = (0, extract_alert_values_1.extractAlertValuesStep)({
+        alerts,
+        current_values
+    });
+    const evaluation_results = (0, evaluate_each_condition_1.evaluateEachConditionStep)({
+        alerts,
+        extracted_values
+    });
+    const allowed_alerts = (0, dedupe_alerts_1.dedupeAlertsStep)({
+        alerts,
+        evaluation_results,
+        evaluation_scope: input.evaluation_scope,
+    });
+    const emitted_event_ids = (0, emit_alert_events_1.emitAlertEventsStep)({
+        alerts,
+        evaluation_results,
+        allowed_alerts,
+        extracted_values
+    });
+    const alert_logs = (0, create_alert_log_entries_1.createAlertLogEntriesStep)({
+        alerts,
+        evaluation_results,
+        allowed_alerts,
+        extracted_values
+    });
+    const summary = (0, workflows_sdk_1.transform)({ alerts, allowed_alerts, alert_logs, emitted_event_ids }, (data) => {
+        return {
+            alerts_evaluated: data.alerts?.length || 0,
+            alerts_triggered: data.allowed_alerts?.length || 0,
+            alert_logs: data.alert_logs,
+            events_emitted: data.emitted_event_ids?.length || 0
+        };
+    });
+    return new workflows_sdk_1.WorkflowResponse(summary);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/statistics/get-available-statistics.d.ts

@@ -0,0 +1,5 @@
+export interface GetAvailableStatisticsInput {
+    provider_id?: string;
+    sales_channel_id?: string;
+}
+export declare const getAvailableStatisticsWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<GetAvailableStatisticsInput, Record<string, any[]>, []>;

package/.medusa/server/src/workflows/statistics/get-available-statistics.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableStatisticsWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const fetch_available_statistics_1 = require("./steps/fetch-available-statistics");
+exports.getAvailableStatisticsWorkflow = (0, workflows_sdk_1.createWorkflow)("get-available-statistics", (input) => {
+    const result = (0, fetch_available_statistics_1.fetchAvailableStatisticsStep)(input);
+    return new workflows_sdk_1.WorkflowResponse(result);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWF2YWlsYWJsZS1zdGF0aXN0aWNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL3dvcmtmbG93cy9zdGF0aXN0aWNzL2dldC1hdmFpbGFibGUtc3RhdGlzdGljcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxRUFBcUY7QUFDckYsbUZBQWtGO0FBT3JFLFFBQUEsOEJBQThCLEdBQUcsSUFBQSw4QkFBYyxFQUN4RCwwQkFBMEIsRUFDMUIsQ0FBQyxLQUFrQyxFQUFFLEVBQUU7SUFDbkMsTUFBTSxNQUFNLEdBQUcsSUFBQSx5REFBNEIsRUFBQyxLQUFLLENBQUMsQ0FBQztJQUVuRCxPQUFPLElBQUksZ0NBQWdCLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDeEMsQ0FBQyxDQUNKLENBQUMifQ==

package/.medusa/server/src/workflows/statistics/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./create-view-with-options";
+export * from "./calculate-view";
+export * from "./calculate-statistics";
+export * from "./calculate-single-statistic";
+export * from "./update-view-configuration";
+export * from "./validate-option-configuration";
+export * from "./clone-view";
+export * from "./create-alert";
+export * from "./get-available-statistics";
+export * from "./evaluate-alerts";
+export * from "./create-chart";
+export * from "./update-chart";
+export * from "./delete-chart";
+export * from "./manage-chart-statistics";

package/.medusa/server/src/workflows/statistics/index.js

@@ -0,0 +1,31 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./create-view-with-options"), exports);
+__exportStar(require("./calculate-view"), exports);
+__exportStar(require("./calculate-statistics"), exports);
+__exportStar(require("./calculate-single-statistic"), exports);
+__exportStar(require("./update-view-configuration"), exports);
+__exportStar(require("./validate-option-configuration"), exports);
+__exportStar(require("./clone-view"), exports);
+__exportStar(require("./create-alert"), exports);
+__exportStar(require("./get-available-statistics"), exports);
+__exportStar(require("./evaluate-alerts"), exports);
+__exportStar(require("./create-chart"), exports);
+__exportStar(require("./update-chart"), exports);
+__exportStar(require("./delete-chart"), exports);
+__exportStar(require("./manage-chart-statistics"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0YXRpc3RpY3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDZEQUEyQztBQUMzQyxtREFBaUM7QUFDakMseURBQXVDO0FBQ3ZDLCtEQUE2QztBQUM3Qyw4REFBNEM7QUFDNUMsa0VBQWdEO0FBQ2hELCtDQUE2QjtBQUM3QixpREFBK0I7QUFDL0IsNkRBQTJDO0FBQzNDLG9EQUFrQztBQUNsQyxpREFBK0I7QUFDL0IsaURBQStCO0FBQy9CLGlEQUErQjtBQUMvQiw0REFBMEMifQ==

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

@@ -0,0 +1,12 @@
+export interface ManageChartStatisticsInput {
+    chart_id: string;
+    add_statistic_ids?: string[];
+    remove_statistic_ids?: string[];
+}
+/**
+ * Manages statistics (series) in a chart.
+ * Can add and/or remove statistics in a single operation.
+ */
+export declare const manageChartStatisticsWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<ManageChartStatisticsInput, {
+    success: boolean;
+}, []>;

package/.medusa/server/src/workflows/statistics/manage-chart-statistics.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageChartStatisticsWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const manage_chart_statistics_1 = require("./steps/manage-chart-statistics");
+/**
+ * Manages statistics (series) in a chart.
+ * Can add and/or remove statistics in a single operation.
+ */
+exports.manageChartStatisticsWorkflow = (0, workflows_sdk_1.createWorkflow)("manage-chart-statistics", (input) => {
+    const result = (0, manage_chart_statistics_1.manageChartStatisticsStep)(input);
+    return new workflows_sdk_1.WorkflowResponse(result);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFuYWdlLWNoYXJ0LXN0YXRpc3RpY3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0YXRpc3RpY3MvbWFuYWdlLWNoYXJ0LXN0YXRpc3RpY3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscUVBQXFGO0FBQ3JGLDZFQUE0RTtBQVE1RTs7O0dBR0c7QUFDVSxRQUFBLDZCQUE2QixHQUFHLElBQUEsOEJBQWMsRUFDdkQseUJBQXlCLEVBQ3pCLENBQUMsS0FBaUMsRUFBRSxFQUFFO0lBQ2xDLE1BQU0sTUFBTSxHQUFHLElBQUEsbURBQXlCLEVBQUMsS0FBSyxDQUFDLENBQUM7SUFFaEQsT0FBTyxJQUFJLGdDQUFnQixDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQ3hDLENBQUMsQ0FDSixDQUFDIn0=

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

@@ -0,0 +1,37 @@
+type OptionInput = {
+    id: string;
+    provider?: {
+        id: string;
+    };
+    provider_option_name?: string;
+    local_option_name?: string;
+    data?: Record<string, any>;
+    cache_options?: Record<string, any> | null;
+    input_dependencies?: any[];
+    parameter_config?: Record<string, any> | null;
+};
+export interface CalculateStatisticsInput {
+    options: Array<OptionInput | {
+        id: string;
+    }>;
+    sharedStatsData?: Record<string, any> | null;
+    sharedCacheOptions?: Record<string, any> | null;
+    runtimeParameters?: Record<string, any>;
+    periodStart: Date;
+    periodEnd: Date;
+    interval: number;
+}
+export declare const calculateStatisticsStep: import("@medusajs/framework/workflows-sdk").StepFunction<CalculateStatisticsInput, {
+    results: Record<string, any>;
+    errors: Record<string, string> | undefined;
+    definitions: {
+        [k: string]: any[];
+    };
+    metadata: Record<string, {
+        fromCache: boolean;
+        cachedAt?: string;
+        calculationTime: number;
+    }>;
+    duration: number;
+}>;
+export {};

package/.medusa/server/src/workflows/statistics/steps/calculate-statistics.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateStatisticsStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const statistics_1 = require("../../../modules/statistics");
+const utils_1 = require("@medusajs/framework/utils");
+const framework_1 = require("@medusajs/framework");
+const parameter_utils_1 = require("../utils/parameter-utils");
+const cache_utils_1 = require("../utils/cache-utils");
+const dependency_graph_1 = require("../utils/dependency-graph");
+exports.calculateStatisticsStep = (0, workflows_sdk_1.createStep)("calculate-statistics", async (input, { container }) => {
+    const statisticsService = container.resolve(statistics_1.STATISTICS_MODULE);
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    let cacheService;
+    try {
+        cacheService = container.resolve(utils_1.Modules.CACHING);
+    }
+    catch {
+        cacheService = undefined;
+    }
+    const { options: inputOptions, sharedStatsData, sharedCacheOptions, runtimeParameters = {}, periodStart, periodEnd, interval, } = input;
+    const operationStartTime = Date.now();
+    const results = {};
+    const errors = {};
+    const metadata = {};
+    const providerStatsMap = new Map();
+    for (const optionInput of inputOptions || []) {
+        const optionId = optionInput?.id;
+        if (!optionId) {
+            continue;
+        }
+        try {
+            const statStartTime = Date.now();
+            const fullOption = await statisticsService.retrieveStatisticsOption(optionId, {
+                relations: ["provider", "input_dependencies"],
+            });
+            const hasDependencies = !!fullOption.input_dependencies &&
+                fullOption.input_dependencies.length > 0;
+            if (hasDependencies) {
+                const dependencyTree = await dependency_graph_1.DependencyGraphUtils.buildDependencyTree(fullOption.id, statisticsService);
+                const calculationOrder = dependency_graph_1.DependencyGraphUtils.getCalculationOrder(dependencyTree);
+                const calculatedResults = new Map();
+                let finalFromCache = false;
+                let finalCachedAt;
+                for (const depOptionId of calculationOrder) {
+                    if (calculatedResults.has(depOptionId)) {
+                        continue;
+                    }
+                    const depOption = await statisticsService.retrieveStatisticsOption(depOptionId, {
+                        relations: ["provider", "input_dependencies"],
+                    });
+                    if (!depOption.provider) {
+                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Statistics option ${depOptionId} has no associated provider`);
+                    }
+                    const providerInstance = statisticsService.getProvider(depOption.provider.id, query);
+                    let availableStats = providerStatsMap.get(depOption.provider.id);
+                    if (!availableStats) {
+                        availableStats = await providerInstance.getAvailableStatistics();
+                        providerStatsMap.set(depOption.provider.id, availableStats);
+                    }
+                    const statDefinition = availableStats.find(s => s.id === depOption.provider_option_name);
+                    if (!statDefinition) {
+                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Statistic definition not found: ${depOption.provider_option_name}`);
+                    }
+                    let parameters = (0, parameter_utils_1.mergeParameters)(depOption.data || {}, sharedStatsData || {}, runtimeParameters, depOption.local_option_name, depOption.provider_option_name, depOption.provider.id);
+                    if (depOption.input_dependencies && depOption.input_dependencies.length > 0) {
+                        const dependencyResults = {};
+                        for (const dep of depOption.input_dependencies) {
+                            const inputId = dep.input_option?.id || dep.input_option_id;
+                            const paramName = dep.parameter_name;
+                            const value = calculatedResults.get(inputId);
+                            if (value === undefined) {
+                                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Dependency result not found for ${inputId}`);
+                            }
+                            dependencyResults[paramName] = value;
+                        }
+                        if (depOption.parameter_config) {
+                            for (const [paramName, config] of Object.entries(depOption.parameter_config)) {
+                                if (config.locked) {
+                                    parameters[paramName] = config.value;
+                                }
+                            }
+                        }
+                        parameters = { ...parameters, ...dependencyResults };
+                    }
+                    const validatedParameters = (0, parameter_utils_1.validateParameters)(parameters, statDefinition.parameters.fields);
+                    const cachingEnabled = !!cacheService && (0, cache_utils_1.isCachingEnabled)(depOption.cache_options, sharedCacheOptions);
+                    let value = null;
+                    let cacheKey = null;
+                    if (cachingEnabled) {
+                        cacheKey = await (0, cache_utils_1.generateStatisticCacheKey)(cacheService, {
+                            option_id: depOption.id,
+                            periodStart,
+                            periodEnd,
+                            interval,
+                            parameters: validatedParameters,
+                        });
+                        const cached = await cacheService.get({ key: cacheKey });
+                        if (cached) {
+                            value = cached.data || cached;
+                            if (depOption.id === optionId) {
+                                finalFromCache = true;
+                                finalCachedAt = cached.cachedAt || new Date().toISOString();
+                            }
+                        }
+                    }
+                    if (value === null) {
+                        value = await providerInstance.calculateStatistic({
+                            id: depOption.provider_option_name,
+                            parameters: validatedParameters,
+                            fields: statDefinition.parameters.fields,
+                            periodStart: new Date(periodStart),
+                            periodEnd: new Date(periodEnd),
+                            interval
+                        });
+                        if (cachingEnabled && cacheKey) {
+                            const effectiveTTL = (0, cache_utils_1.getEffectiveCacheTTL)(depOption.cache_options, sharedCacheOptions);
+                            const cachedAt = new Date().toISOString();
+                            await cacheService.set({
+                                key: cacheKey,
+                                data: {
+                                    data: value,
+                                    cachedAt
+                                },
+                                ttl: effectiveTTL
+                            });
+                        }
+                    }
+                    calculatedResults.set(depOption.id, value);
+                }
+                const finalValue = calculatedResults.get(optionId);
+                if (finalValue === undefined) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to calculate composite statistic ${optionId}`);
+                }
+                results[optionId] = finalValue;
+                metadata[optionId] = {
+                    fromCache: finalFromCache,
+                    cachedAt: finalCachedAt,
+                    calculationTime: Date.now() - statStartTime,
+                };
+                continue;
+            }
+            if (!fullOption.provider) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Statistics option ${optionId} has no associated provider`);
+            }
+            const providerInstance = statisticsService.getProvider(fullOption.provider.id, query);
+            let availableStats = providerStatsMap.get(fullOption.provider.id);
+            if (!availableStats) {
+                availableStats = await providerInstance.getAvailableStatistics();
+                providerStatsMap.set(fullOption.provider.id, availableStats);
+            }
+            const statDefinition = availableStats.find(s => s.id === fullOption.provider_option_name);
+            if (!statDefinition) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Statistic definition not found: ${fullOption.provider_option_name}`);
+            }
+            const mergedParameters = (0, parameter_utils_1.mergeParameters)(fullOption.data || {}, sharedStatsData || {}, runtimeParameters, fullOption.local_option_name, fullOption.provider_option_name, fullOption.provider.id);
+            const validatedParameters = (0, parameter_utils_1.validateParameters)(mergedParameters, statDefinition.parameters.fields);
+            const cachingEnabled = !!cacheService && (0, cache_utils_1.isCachingEnabled)(fullOption.cache_options, sharedCacheOptions);
+            let cachedResult = null;
+            let cacheKey = null;
+            if (cachingEnabled) {
+                cacheKey = await (0, cache_utils_1.generateStatisticCacheKey)(cacheService, {
+                    option_id: fullOption.id,
+                    periodStart,
+                    periodEnd,
+                    interval,
+                    parameters: validatedParameters
+                });
+                cachedResult = await cacheService.get({
+                    key: cacheKey
+                });
+                if (cachedResult) {
+                    results[fullOption.id] = cachedResult.data || cachedResult;
+                    metadata[fullOption.id] = {
+                        fromCache: true,
+                        cachedAt: cachedResult.cachedAt || new Date().toISOString(),
+                        calculationTime: Date.now() - statStartTime
+                    };
+                    continue;
+                }
+            }
+            const result = await providerInstance.calculateStatistic({
+                id: fullOption.provider_option_name,
+                parameters: validatedParameters,
+                fields: statDefinition.parameters.fields,
+                periodStart: new Date(periodStart),
+                periodEnd: new Date(periodEnd),
+                interval
+            });
+            const statCalculationTime = Date.now() - statStartTime;
+            metadata[fullOption.id] = {
+                fromCache: false,
+                calculationTime: statCalculationTime
+            };
+            if (cachingEnabled && cacheKey) {
+                const effectiveTTL = (0, cache_utils_1.getEffectiveCacheTTL)(fullOption.cache_options, sharedCacheOptions);
+                const cachedAt = new Date().toISOString();
+                await cacheService.set({
+                    key: cacheKey,
+                    data: {
+                        data: result,
+                        cachedAt
+                    },
+                    ttl: effectiveTTL
+                });
+            }
+            results[fullOption.id] = result;
+        }
+        catch (error) {
+            framework_1.logger.error(`Error calculating statistic for option ${optionId}: ${error}`);
+        }
+    }
+    const totalDuration = (Date.now() - operationStartTime) / 1000;
+    return new workflows_sdk_1.StepResponse({
+        results,
+        errors: Object.keys(errors).length > 0 ? errors : undefined,
+        definitions: Object.fromEntries(providerStatsMap.entries()),
+        metadata,
+        duration: totalDuration
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calculate-statistics.js","sourceRoot":"","sources":["../../../../../../src/workflows/statistics/steps/calculate-statistics.ts"],"names":[],"mappings":"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"}