medusa-stats 1.0.5

package/.medusa/server/src/workflows/statistics/update-view-configuration.d.ts

@@ -0,0 +1,128 @@
+export interface UpdateViewConfigurationInput {
+    id: string;
+    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;
+}
+/**
+ * Updates a statistics view configuration.
+ *
+ * Note: Cached statistics are not automatically invalidated when view configuration changes.
+ * Cache invalidation requires specific state parameters (periodStart, periodEnd, interval).
+ * Cached data will expire naturally via TTL (600s), or can be manually invalidated via
+ * the cache invalidation endpoint with specific state parameters if immediate refresh is needed.
+ */
+export declare const updateViewConfigurationWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<UpdateViewConfigurationInput, {
+    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;
+} | null, []>;

package/.medusa/server/src/workflows/statistics/update-view-configuration.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateViewConfigurationWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const update_view_1 = require("./steps/update-view");
+/**
+ * Updates a statistics view configuration.
+ *
+ * Note: Cached statistics are not automatically invalidated when view configuration changes.
+ * Cache invalidation requires specific state parameters (periodStart, periodEnd, interval).
+ * Cached data will expire naturally via TTL (600s), or can be manually invalidated via
+ * the cache invalidation endpoint with specific state parameters if immediate refresh is needed.
+ */
+exports.updateViewConfigurationWorkflow = (0, workflows_sdk_1.createWorkflow)("update-stat-view-configuration", (input) => {
+    const updatedViewResult = (0, update_view_1.updateViewStep)(input);
+    return new workflows_sdk_1.WorkflowResponse(updatedViewResult.length ? updatedViewResult[0] : null);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLXZpZXctY29uZmlndXJhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3Mvc3RhdGlzdGljcy91cGRhdGUtdmlldy1jb25maWd1cmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFFQUFxRjtBQUVyRixxREFBcUQ7QUFjckQ7Ozs7Ozs7R0FPRztBQUNVLFFBQUEsK0JBQStCLEdBQUcsSUFBQSw4QkFBYyxFQUN6RCxnQ0FBZ0MsRUFDaEMsQ0FBQyxLQUFtQyxFQUFFLEVBQUU7SUFFcEMsTUFBTSxpQkFBaUIsR0FBRyxJQUFBLDRCQUFjLEVBQUMsS0FBSyxDQUFDLENBQUM7SUFFaEQsT0FBTyxJQUFJLGdDQUFnQixDQUFDLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ3hGLENBQUMsQ0FDSixDQUFDIn0=

package/.medusa/server/src/workflows/statistics/utils/cache-utils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Configuration for statistics cache
+ */
+export declare const STATISTICS_CACHE_CONFIG: {
+    readonly DEFAULT_TTL: 300;
+    readonly KEY_PREFIX: "stats:";
+};
+/**
+ * Generates cache key data for a single statistic calculation
+ * To be used with cacheService.computeKey()
+ */
+export declare function getStatisticCacheKeyData(params: {
+    option_id: string;
+    periodStart: Date;
+    periodEnd: Date;
+    interval: number;
+    parameters: Record<string, any>;
+}): {
+    prefix: "stats:";
+    type: string;
+    option_id: string;
+    periodStart: string;
+    periodEnd: string;
+    interval: number;
+    parameters: Record<string, any>;
+};
+/**
+ * Helper to build cache key for a statistic option
+ * Uses cacheService.computeKey internally
+ */
+export declare function generateStatisticCacheKey(cacheService: any, params: {
+    option_id: string;
+    periodStart: Date;
+    periodEnd: Date;
+    interval: number;
+    parameters: Record<string, any>;
+}): Promise<string>;
+/**
+ * Check if caching is enabled for an option
+ * Checks both option-level and view-level cache_options
+ * If cache_options is not set or enabled is not specified, caching is enabled by default
+ */
+export declare function isCachingEnabled(optionCacheOptions?: {
+    enabled?: boolean;
+    ttl?: number;
+} | null, viewCacheOptions?: {
+    enabled?: boolean;
+    ttl?: number;
+} | null): boolean;
+/**
+ * Determine effective TTL for a statistic calculation
+ * Priority: option.cache_options.ttl > view.cache_options.ttl > default TTL
+ */
+export declare function getEffectiveCacheTTL(optionCacheOptions?: {
+    enabled?: boolean;
+    ttl?: number;
+} | null, viewCacheOptions?: {
+    enabled?: boolean;
+    ttl?: number;
+} | null): number;

package/.medusa/server/src/workflows/statistics/utils/cache-utils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATISTICS_CACHE_CONFIG = void 0;
+exports.getStatisticCacheKeyData = getStatisticCacheKeyData;
+exports.generateStatisticCacheKey = generateStatisticCacheKey;
+exports.isCachingEnabled = isCachingEnabled;
+exports.getEffectiveCacheTTL = getEffectiveCacheTTL;
+/**
+ * Configuration for statistics cache
+ */
+exports.STATISTICS_CACHE_CONFIG = {
+    DEFAULT_TTL: 300,
+    KEY_PREFIX: "stats:",
+};
+/**
+ * Generates cache key data for a single statistic calculation
+ * To be used with cacheService.computeKey()
+ */
+function getStatisticCacheKeyData(params) {
+    const { option_id, periodStart, periodEnd, interval, parameters } = params;
+    return {
+        prefix: exports.STATISTICS_CACHE_CONFIG.KEY_PREFIX,
+        type: "single",
+        option_id,
+        periodStart: new Date(periodStart).toISOString(),
+        periodEnd: new Date(periodEnd).toISOString(),
+        interval,
+        parameters
+    };
+}
+/**
+ * Helper to build cache key for a statistic option
+ * Uses cacheService.computeKey internally
+ */
+async function generateStatisticCacheKey(cacheService, params) {
+    const keyData = getStatisticCacheKeyData(params);
+    return cacheService.computeKey(keyData);
+}
+/**
+ * Check if caching is enabled for an option
+ * Checks both option-level and view-level cache_options
+ * If cache_options is not set or enabled is not specified, caching is enabled by default
+ */
+function isCachingEnabled(optionCacheOptions, viewCacheOptions) {
+    if (optionCacheOptions?.enabled !== undefined) {
+        return optionCacheOptions.enabled;
+    }
+    if (viewCacheOptions?.enabled !== undefined) {
+        return viewCacheOptions.enabled;
+    }
+    return true;
+}
+/**
+ * Determine effective TTL for a statistic calculation
+ * Priority: option.cache_options.ttl > view.cache_options.ttl > default TTL
+ */
+function getEffectiveCacheTTL(optionCacheOptions, viewCacheOptions) {
+    if (optionCacheOptions?.ttl !== undefined && optionCacheOptions.ttl > 0) {
+        return optionCacheOptions.ttl;
+    }
+    if (viewCacheOptions?.ttl !== undefined && viewCacheOptions.ttl > 0) {
+        return viewCacheOptions.ttl;
+    }
+    return exports.STATISTICS_CACHE_CONFIG.DEFAULT_TTL;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0YXRpc3RpY3MvdXRpbHMvY2FjaGUtdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBYUEsNERBa0JDO0FBTUQsOERBWUM7QUFPRCw0Q0FnQkM7QUFNRCxvREFnQkM7QUE5RkQ7O0dBRUc7QUFDVSxRQUFBLHVCQUF1QixHQUFHO0lBRW5DLFdBQVcsRUFBRSxHQUFHO0lBQ2hCLFVBQVUsRUFBRSxRQUFRO0NBQ2QsQ0FBQztBQUVYOzs7R0FHRztBQUNILFNBQWdCLHdCQUF3QixDQUFDLE1BTXhDO0lBQ0csTUFBTSxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLFFBQVEsRUFBRSxVQUFVLEVBQUUsR0FBRyxNQUFNLENBQUM7SUFFM0UsT0FBTztRQUNILE1BQU0sRUFBRSwrQkFBdUIsQ0FBQyxVQUFVO1FBQzFDLElBQUksRUFBRSxRQUFRO1FBQ2QsU0FBUztRQUNULFdBQVcsRUFBRSxJQUFJLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxXQUFXLEVBQUU7UUFDaEQsU0FBUyxFQUFFLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLFdBQVcsRUFBRTtRQUM1QyxRQUFRO1FBQ1IsVUFBVTtLQUNiLENBQUM7QUFDTixDQUFDO0FBRUQ7OztHQUdHO0FBQ0ksS0FBSyxVQUFVLHlCQUF5QixDQUMzQyxZQUFpQixFQUNqQixNQU1DO0lBRUQsTUFBTSxPQUFPLEdBQUcsd0JBQXdCLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDakQsT0FBTyxZQUFZLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0FBQzVDLENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsU0FBZ0IsZ0JBQWdCLENBQzVCLGtCQUErRCxFQUMvRCxnQkFBNkQ7SUFHN0QsSUFBSSxrQkFBa0IsRUFBRSxPQUFPLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDNUMsT0FBTyxrQkFBa0IsQ0FBQyxPQUFPLENBQUM7SUFDdEMsQ0FBQztJQUdELElBQUksZ0JBQWdCLEVBQUUsT0FBTyxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQzFDLE9BQU8sZ0JBQWdCLENBQUMsT0FBTyxDQUFDO0lBQ3BDLENBQUM7SUFHRCxPQUFPLElBQUksQ0FBQztBQUNoQixDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsU0FBZ0Isb0JBQW9CLENBQ2hDLGtCQUErRCxFQUMvRCxnQkFBNkQ7SUFHN0QsSUFBSSxrQkFBa0IsRUFBRSxHQUFHLEtBQUssU0FBUyxJQUFJLGtCQUFrQixDQUFDLEdBQUcsR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUN0RSxPQUFPLGtCQUFrQixDQUFDLEdBQUcsQ0FBQztJQUNsQyxDQUFDO0lBR0QsSUFBSSxnQkFBZ0IsRUFBRSxHQUFHLEtBQUssU0FBUyxJQUFJLGdCQUFnQixDQUFDLEdBQUcsR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUNsRSxPQUFPLGdCQUFnQixDQUFDLEdBQUcsQ0FBQztJQUNoQyxDQUFDO0lBR0QsT0FBTywrQkFBdUIsQ0FBQyxXQUFXLENBQUM7QUFDL0MsQ0FBQyJ9

package/.medusa/server/src/workflows/statistics/utils/dependency-graph.d.ts

@@ -0,0 +1,51 @@
+import StatisticsService from "../../../modules/statistics/service";
+/**
+ * Represents a node in the dependency graph
+ */
+export interface DependencyNode {
+    id: string;
+    name: string;
+    provider_option_name: string;
+    parameter_name?: string;
+    dependencies: DependencyNode[];
+    depth: number;
+}
+/**
+ * Result of dependency resolution
+ */
+export interface DependencyResolution {
+    calculationOrder: string[];
+    dependencyTree: DependencyNode;
+    hasCycles: boolean;
+    cycleNodes?: string[];
+}
+/**
+ * Utility class for dependency graph operations
+ */
+export declare class DependencyGraphUtils {
+    /**
+     * Build complete dependency tree for an option
+     */
+    static buildDependencyTree(optionId: string, statisticsService: StatisticsService, visited?: Set<string>, depth?: number): Promise<DependencyNode>;
+    /**
+     * Get calculation order using topological sort
+     * Dependencies must be calculated before their dependents
+     */
+    static getCalculationOrder(tree: DependencyNode): string[];
+    /**
+     * Detect circular dependencies in the graph
+     */
+    static detectCycles(optionId: string, allDependencies: Map<string, string[]>, visited?: Set<string>, recursionStack?: Set<string>): string[] | null;
+    /**
+     * Validate dependency integrity
+     * Checks for cycles and validates all dependencies exist
+     */
+    static validateDependencies(optionId: string, statisticsService: StatisticsService): Promise<{
+        isValid: boolean;
+        errors: string[];
+    }>;
+    /**
+     * Flatten dependency tree to list of all option IDs
+     */
+    static flattenTree(tree: DependencyNode): string[];
+}

package/.medusa/server/src/workflows/statistics/utils/dependency-graph.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyGraphUtils = void 0;
+const dependency_option_map_1 = require("../../../modules/statistics/utils/dependency-option-map");
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Utility class for dependency graph operations
+ */
+class DependencyGraphUtils {
+    /**
+     * Build complete dependency tree for an option
+     */
+    static async buildDependencyTree(optionId, statisticsService, visited = new Set(), depth = 0) {
+        const optionMap = await (0, dependency_option_map_1.buildDependencyOptionMap)([optionId], [], async (idsToFetch) => {
+            const options = await Promise.all(idsToFetch.map((id) => statisticsService.retrieveStatisticsOption(id, {
+                relations: ["input_dependencies", "input_dependencies.input_option"],
+            })));
+            return options;
+        });
+        const buildNode = (currentId, currentDepth, path) => {
+            if (path.has(currentId)) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Circular dependency detected at option: ${currentId}`);
+            }
+            const option = optionMap.get(currentId);
+            if (!option) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Option not found in dependency graph: ${currentId}`);
+            }
+            const nextPath = new Set(path);
+            nextPath.add(currentId);
+            const node = {
+                id: option.id,
+                name: option.local_option_name,
+                provider_option_name: option.provider_option_name,
+                depth: currentDepth,
+                dependencies: [],
+            };
+            if (option.input_dependencies?.length) {
+                for (const dep of option.input_dependencies) {
+                    const inputId = dep.input_option?.id || dep.input_option_id;
+                    if (!inputId) {
+                        continue;
+                    }
+                    const childNode = buildNode(inputId, currentDepth + 1, nextPath);
+                    childNode.parameter_name = dep.parameter_name;
+                    node.dependencies.push(childNode);
+                }
+            }
+            return node;
+        };
+        return buildNode(optionId, depth, new Set(visited));
+    }
+    /**
+     * Get calculation order using topological sort
+     * Dependencies must be calculated before their dependents
+     */
+    static getCalculationOrder(tree) {
+        const order = [];
+        const visited = new Set();
+        const visit = (node) => {
+            if (visited.has(node.id)) {
+                return;
+            }
+            for (const dep of node.dependencies) {
+                visit(dep);
+            }
+            visited.add(node.id);
+            order.push(node.id);
+        };
+        visit(tree);
+        return order;
+    }
+    /**
+     * Detect circular dependencies in the graph
+     */
+    static detectCycles(optionId, allDependencies, visited = new Set(), recursionStack = new Set()) {
+        visited.add(optionId);
+        recursionStack.add(optionId);
+        const dependencies = allDependencies.get(optionId) || [];
+        for (const depId of dependencies) {
+            if (!visited.has(depId)) {
+                const cycle = this.detectCycles(depId, allDependencies, visited, recursionStack);
+                if (cycle) {
+                    return [optionId, ...cycle];
+                }
+            }
+            else if (recursionStack.has(depId)) {
+                return [optionId, depId];
+            }
+        }
+        recursionStack.delete(optionId);
+        return null;
+    }
+    /**
+     * Validate dependency integrity
+     * Checks for cycles and validates all dependencies exist
+     */
+    static async validateDependencies(optionId, statisticsService) {
+        const errors = [];
+        try {
+            await this.buildDependencyTree(optionId, statisticsService);
+        }
+        catch (error) {
+            if (error.message.includes("Circular dependency")) {
+                errors.push(error.message);
+            }
+            else {
+                errors.push(`Failed to build dependency tree: ${error.message}`);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Flatten dependency tree to list of all option IDs
+     */
+    static flattenTree(tree) {
+        const ids = new Set();
+        const collect = (node) => {
+            ids.add(node.id);
+            for (const dep of node.dependencies) {
+                collect(dep);
+            }
+        };
+        collect(tree);
+        return Array.from(ids);
+    }
+}
+exports.DependencyGraphUtils = DependencyGraphUtils;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/statistics/utils/parameter-utils.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { ParameterFieldDefinition } from "../../../modules/statistics/providers/provider";
+interface ValidateParameterDataOptions {
+    partial?: boolean;
+}
+interface ValidateParameterDataResult {
+    isValid: boolean;
+    errors: string[];
+    isComplete: boolean;
+}
+/**
+ * Parse selector syntax: "selector:paramName" or just "paramName"
+ */
+export declare function parseSelector(key: string): [string | null, string];
+/**
+ * Simple wildcard matching (* supported)
+ */
+export declare function wildcardMatch(value: string, pattern: string): boolean;
+/**
+ * Check if selector matches the option
+ */
+export declare function selectorMatches(selector: string, localOptionName: string, providerOptionName: string, providerId: string): boolean;
+/**
+ * Merge parameters from option, view (with selectors), and runtime
+ */
+export declare function mergeParameters(optionData: Record<string, any>, viewData: Record<string, any>, runtimeData: Record<string, any>, localOptionName: string, providerOptionName: string, providerId: string): Record<string, any>;
+/**
+ * Validate parameters against field definitions
+ */
+export declare function validateParameters(parameters: Record<string, any>, fields: ParameterFieldDefinition[]): Record<string, any>;
+/**
+ * Build Zod schema from parameter field definitions
+ */
+export declare function buildParameterSchema(fields: ParameterFieldDefinition[], partial?: boolean): z.ZodObject<Record<string, z.ZodType<any, z.ZodTypeDef, any>>, "strip", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;
+/**
+ * Validate parameter data and return formatted validation state
+ */
+export declare function validateParameterData(parameters: Record<string, any>, fields: ParameterFieldDefinition[], options?: ValidateParameterDataOptions): ValidateParameterDataResult;
+/**
+ * Resolve provider statistic definition by provider/option identifiers
+ */
+export declare function resolveStatisticDefinition(availableStatistics: Record<string, any[]>, providerId: string, providerOptionName: string): {
+    statDefinition: any | null;
+    error: string | null;
+};
+/**
+ * Check if option data is complete (has all required values)
+ */
+export declare function hasCompleteData(data: Record<string, any> | null | undefined): boolean;
+export {};

package/.medusa/server/src/workflows/statistics/utils/parameter-utils.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSelector = parseSelector;
+exports.wildcardMatch = wildcardMatch;
+exports.selectorMatches = selectorMatches;
+exports.mergeParameters = mergeParameters;
+exports.validateParameters = validateParameters;
+exports.buildParameterSchema = buildParameterSchema;
+exports.validateParameterData = validateParameterData;
+exports.resolveStatisticDefinition = resolveStatisticDefinition;
+exports.hasCompleteData = hasCompleteData;
+const zod_1 = require("zod");
+/**
+ * Parse selector syntax: "selector:paramName" or just "paramName"
+ */
+function parseSelector(key) {
+    const parts = key.split(':');
+    if (parts.length === 1) {
+        return [null, key];
+    }
+    return [parts[0], parts[1]];
+}
+/**
+ * Simple wildcard matching (* supported)
+ */
+function wildcardMatch(value, pattern) {
+    const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+    return regex.test(value);
+}
+/**
+ * Check if selector matches the option
+ */
+function selectorMatches(selector, localOptionName, providerOptionName, providerId) {
+    if (selector.startsWith('@')) {
+        const pattern = selector.slice(1);
+        return wildcardMatch(localOptionName, pattern);
+    }
+    else if (selector.includes('.') || selector.includes('*')) {
+        const [providerPattern, optionPattern] = selector.split(':');
+        if (optionPattern) {
+            return wildcardMatch(providerId, providerPattern) &&
+                wildcardMatch(providerOptionName, optionPattern);
+        }
+        else {
+            return wildcardMatch(providerId, providerPattern);
+        }
+    }
+    return false;
+}
+/**
+ * Merge parameters from option, view (with selectors), and runtime
+ */
+function mergeParameters(optionData, viewData, runtimeData, localOptionName, providerOptionName, providerId) {
+    const merged = { ...optionData };
+    for (const [key, value] of Object.entries(viewData)) {
+        const [selector, paramName] = parseSelector(key);
+        if (!paramName) {
+            merged[key] = value;
+        }
+        else if (selector && selectorMatches(selector, localOptionName, providerOptionName, providerId)) {
+            merged[paramName] = value;
+        }
+    }
+    Object.assign(merged, runtimeData);
+    return merged;
+}
+/**
+ * Validate parameters against field definitions
+ */
+function validateParameters(parameters, fields) {
+    const schema = buildParameterSchema(fields);
+    return schema.parse(parameters);
+}
+/**
+ * Build Zod schema from parameter field definitions
+ */
+function buildParameterSchema(fields, partial = false) {
+    const schema = zod_1.z.object(fields.reduce((acc, field) => {
+        if (field.schema) {
+            acc[field.name] = field.schema;
+        }
+        return acc;
+    }, {}));
+    return partial ? schema.partial() : schema;
+}
+/**
+ * Validate parameter data and return formatted validation state
+ */
+function validateParameterData(parameters, fields, options = {}) {
+    const schema = buildParameterSchema(fields, options.partial ?? false);
+    try {
+        schema.parse(parameters);
+        return {
+            isValid: true,
+            errors: [],
+            isComplete: true,
+        };
+    }
+    catch (error) {
+        if (!(error instanceof zod_1.z.ZodError)) {
+            return {
+                isValid: false,
+                errors: ["Unknown validation error"],
+                isComplete: false,
+            };
+        }
+        const errors = error.errors.map((validationError) => `${validationError.path.join(".")}: ${validationError.message}`);
+        const missingRequiredValues = error.errors.some((validationError) => validationError.code === "invalid_type");
+        return {
+            isValid: false,
+            errors,
+            isComplete: !missingRequiredValues,
+        };
+    }
+}
+/**
+ * Resolve provider statistic definition by provider/option identifiers
+ */
+function resolveStatisticDefinition(availableStatistics, providerId, providerOptionName) {
+    const providerStats = availableStatistics[providerId];
+    if (!providerStats) {
+        return {
+            statDefinition: null,
+            error: `Provider ${providerId} not found or has no available statistics`,
+        };
+    }
+    const statDefinition = providerStats.find((statistic) => statistic.id === providerOptionName);
+    if (!statDefinition) {
+        return {
+            statDefinition: null,
+            error: `Statistic ${providerOptionName} not found in provider ${providerId}`,
+        };
+    }
+    return {
+        statDefinition,
+        error: null,
+    };
+}
+/**
+ * Check if option data is complete (has all required values)
+ */
+function hasCompleteData(data) {
+    if (!data)
+        return false;
+    return Object.values(data).every(value => value !== null && value !== undefined);
+}
+//# sourceMappingURL=data:application/json;base64,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