medusa-stats 1.0.5

package/.medusa/server/src/modules/statistics/service.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const models_1 = require("./models");
+const framework_1 = require("@medusajs/framework");
+class StatisticsService extends (0, utils_1.MedusaService)({
+    StatisticsView: models_1.StatisticsView,
+    StatisticsOption: models_1.StatisticsOption,
+    StatisticsProvider: models_1.StatisticsProvider,
+    StatisticsAlert: models_1.StatisticsAlert,
+    StatisticsAlertLog: models_1.StatisticsAlertLog,
+    StatisticsChart: models_1.StatisticsChart,
+    StatisticOptionInput: models_1.StatisticOptionInput
+}) {
+    constructor({ statisticsProviderRepository, ...container }) {
+        super(...arguments);
+        this.providerRepository_ = statisticsProviderRepository;
+        this.container_ = container;
+    }
+    async upsertStatisticsProviders(data, context) {
+        return this.providerRepository_.upsert(data, context);
+    }
+    /**
+     * Get provider instance with QueryModule injected via child container
+     */
+    getProvider(providerId, query) {
+        const ProviderClass = this.container_[providerId];
+        if (!ProviderClass) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Provider ${providerId} not found`);
+        }
+        const childContainer = {
+            ...framework_1.container,
+            [utils_1.ContainerRegistrationKeys.QUERY]: query,
+        };
+        return new ProviderClass(childContainer);
+    }
+    /**
+     * Add statistics (series) to a chart
+     */
+    async addStatisticsToChart(chartId, statisticIds) {
+        const chart = await this.retrieveStatisticsChart(chartId, { relations: ["statistics"] });
+        const updatedChart = await this.updateStatisticsCharts({
+            id: chartId,
+            statistics: [
+                ...(chart.statistics.map(s => s.id) || []),
+                ...statisticIds.map(id => (id))
+            ]
+        });
+        return { chart: updatedChart };
+    }
+    /**
+     * Remove statistics (series) from a chart
+     */
+    async removeStatisticsFromChart(chartId, statisticIds) {
+        const chart = await this.retrieveStatisticsChart(chartId, { relations: ["statistics"] });
+        const updatedChart = await this.updateStatisticsCharts({
+            id: chartId,
+            statistics: [
+                ...(chart.statistics.map(s => s.id) || []).filter(id => !statisticIds.includes(id))
+            ]
+        });
+        return { chart: updatedChart };
+    }
+    /**
+     * Validate if an option can be deleted (check dependencies)
+     * Throws error if option is used as input by other composite statistics
+     */
+    async validateOptionDeletion(ids) {
+        const idArray = Array.isArray(ids) ? ids : [ids];
+        for (const id of idArray) {
+            const option = await this.retrieveStatisticsOption(id, {
+                relations: ["dependent_composites"],
+            });
+            if (option.dependent_composites && option.dependent_composites.length > 0) {
+                const dependentNames = option.dependent_composites
+                    .map((c) => c.local_option_name)
+                    .join(", ");
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Cannot delete option "${option.local_option_name}" because it is used as input by the following composite statistics: ${dependentNames}`);
+            }
+        }
+    }
+    /**
+     * Clone a statistics option with all its configuration and dependencies
+     * Creates an independent copy that can be customized
+     */
+    async cloneOption(sourceId, overrides = {}) {
+        const clonedIdBySourceId = new Map();
+        const cloningStack = new Set();
+        const cloneRecursive = async (optionId, isRoot = false) => {
+            const existingCloneId = clonedIdBySourceId.get(optionId);
+            if (existingCloneId) {
+                return this.retrieveStatisticsOption(existingCloneId, {
+                    relations: ["input_dependencies", "provider"],
+                });
+            }
+            if (cloningStack.has(optionId)) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Circular dependency detected while cloning option ${optionId}`);
+            }
+            cloningStack.add(optionId);
+            const source = await this.retrieveStatisticsOption(optionId, {
+                relations: ["input_dependencies", "provider"],
+            });
+            const clonedInputDependencies = [];
+            if (source.input_dependencies && source.input_dependencies.length > 0) {
+                for (const dep of source.input_dependencies) {
+                    const sourceInputId = dep.input_option?.id || dep.input_option_id;
+                    if (!sourceInputId) {
+                        continue;
+                    }
+                    const clonedInput = await cloneRecursive(sourceInputId, false);
+                    clonedInputDependencies.push({
+                        input_option_id: clonedInput.id,
+                        parameter_name: dep.parameter_name,
+                        order: dep.order,
+                        metadata: dep.metadata,
+                    });
+                }
+            }
+            const cloneData = {
+                provider_option_name: source.provider_option_name,
+                local_option_name: isRoot
+                    ? (overrides.local_option_name || source.local_option_name)
+                    : source.local_option_name,
+                data: source.data,
+                visualization_config: source.visualization_config,
+                cache_options: source.cache_options,
+                parameter_config: isRoot
+                    ? (overrides.parameter_config ?? source.parameter_config)
+                    : source.parameter_config,
+                preset: isRoot
+                    ? (overrides.preset !== undefined ? overrides.preset : false)
+                    : false,
+                provider: source.provider?.id,
+            };
+            if (clonedInputDependencies.length > 0) {
+                cloneData.input_dependencies = clonedInputDependencies;
+            }
+            const clone = await this.createStatisticsOptions(cloneData);
+            clonedIdBySourceId.set(optionId, clone.id);
+            cloningStack.delete(optionId);
+            return clone;
+        };
+        return await cloneRecursive(sourceId, true);
+    }
+    /**
+     * Get complete dependency graph for an option
+     * Recursively builds tree structure for visualization
+     */
+    async getDependencyGraph(optionId) {
+        const visited = new Set();
+        const buildTree = async (id, depth = 0) => {
+            if (visited.has(id)) {
+                return { id, circular: true, depth };
+            }
+            visited.add(id);
+            const option = await this.retrieveStatisticsOption(id, {
+                relations: ["input_dependencies", "input_dependencies.input_option"],
+            });
+            const node = {
+                id: option.id,
+                name: option.local_option_name,
+                provider_option_name: option.provider_option_name,
+                depth,
+                dependencies: [],
+            };
+            if (option.input_dependencies && option.input_dependencies.length > 0) {
+                for (const dep of option.input_dependencies) {
+                    const inputId = dep.input_option?.id || dep.input_option_id;
+                    const paramName = dep.parameter_name;
+                    const childNode = await buildTree(inputId, depth + 1);
+                    node.dependencies.push({
+                        parameter_name: paramName,
+                        ...childNode,
+                    });
+                }
+            }
+            return node;
+        };
+        return buildTree(optionId);
+    }
+    /**
+     * List preset options available for cloning
+     * Convenience method for filtering preset options
+     */
+    async listPresets(filters = {}, config = {}) {
+        return this.listStatisticsOptions({ ...filters, preset: true }, config);
+    }
+}
+exports.default = StatisticsService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/statistics/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/modules/statistics/utils/dependency-option-map.d.ts

@@ -0,0 +1,13 @@
+type DependencyEdge = {
+    input_option_id?: string | null;
+    input_option?: {
+        id?: string | null;
+    } | null;
+};
+export type DependencyOptionLike = {
+    id: string;
+    input_dependencies?: DependencyEdge[];
+};
+export declare const buildDependencyOptionMap: <T extends DependencyOptionLike>(rootIds: string[], seedOptions: T[], fetchByIds: (ids: string[]) => Promise<T[]>) => Promise<Map<string, T>>;
+export declare const hydrateDependencyInputOptions: <T extends DependencyOptionLike>(optionMap: Map<string, T>) => void;
+export {};

package/.medusa/server/src/modules/statistics/utils/dependency-option-map.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hydrateDependencyInputOptions = exports.buildDependencyOptionMap = void 0;
+const getDependencyIds = (option) => {
+    if (!option.input_dependencies?.length) {
+        return [];
+    }
+    return option.input_dependencies
+        .map((dep) => dep?.input_option?.id || dep?.input_option_id)
+        .filter((id) => Boolean(id));
+};
+const buildDependencyOptionMap = async (rootIds, seedOptions, fetchByIds) => {
+    const optionMap = new Map();
+    const pendingIds = new Set();
+    seedOptions.forEach((option) => {
+        if (!option?.id) {
+            return;
+        }
+        optionMap.set(option.id, option);
+        getDependencyIds(option).forEach((dependencyId) => {
+            if (!optionMap.has(dependencyId)) {
+                pendingIds.add(dependencyId);
+            }
+        });
+    });
+    rootIds.forEach((id) => {
+        if (id && !optionMap.has(id)) {
+            pendingIds.add(id);
+        }
+    });
+    while (pendingIds.size > 0) {
+        const idsToFetch = Array.from(pendingIds).filter((id) => !optionMap.has(id));
+        pendingIds.clear();
+        if (idsToFetch.length === 0) {
+            break;
+        }
+        const fetchedOptions = await fetchByIds(idsToFetch);
+        fetchedOptions.forEach((option) => {
+            if (!option?.id) {
+                return;
+            }
+            optionMap.set(option.id, option);
+        });
+        fetchedOptions.forEach((option) => {
+            getDependencyIds(option).forEach((dependencyId) => {
+                if (!optionMap.has(dependencyId)) {
+                    pendingIds.add(dependencyId);
+                }
+            });
+        });
+    }
+    return optionMap;
+};
+exports.buildDependencyOptionMap = buildDependencyOptionMap;
+const hydrateDependencyInputOptions = (optionMap) => {
+    optionMap.forEach((option) => {
+        if (!option.input_dependencies) {
+            return;
+        }
+        option.input_dependencies = option.input_dependencies.map((dep) => ({
+            ...dep,
+            input_option: optionMap.get(dep.input_option?.id || dep.input_option_id || "") || dep.input_option || null,
+        }));
+    });
+};
+exports.hydrateDependencyInputOptions = hydrateDependencyInputOptions;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/modules/statistics/utils/period-utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Utility functions for calculating date ranges from period strategies
+ */
+export type PeriodType = 'calendar' | 'custom';
+export interface CalendarPeriodConfig {
+    reference: 'today' | 'yesterday' | 'wtd' | 'lastweek' | 'mtd' | 'lastmonth' | 'qtd' | 'lastquarter' | 'ytd' | 'lastyear';
+}
+export interface CustomPeriodConfig {
+    start: string | Date;
+    end: string | Date;
+}
+export interface PeriodStrategy {
+    type: PeriodType;
+    config: CalendarPeriodConfig | CustomPeriodConfig;
+}
+export interface DateRange {
+    start: Date;
+    end: Date;
+}
+/**
+ * Calculate date range from a period strategy
+ */
+export declare function calculateDatesFromPeriod(period: PeriodStrategy, referenceDate?: Date): DateRange;

package/.medusa/server/src/modules/statistics/utils/period-utils.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Utility functions for calculating date ranges from period strategies
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDatesFromPeriod = calculateDatesFromPeriod;
+/**
+ * Calculate date range from a period strategy
+ */
+function calculateDatesFromPeriod(period, referenceDate = new Date()) {
+    const now = new Date(referenceDate);
+    let start = new Date(now);
+    let end = new Date(now);
+    if (period.type === 'calendar') {
+        const config = period.config;
+        switch (config.reference) {
+            case 'today':
+                start.setHours(0, 0, 0, 0);
+                end.setHours(23, 59, 59, 999);
+                break;
+            case 'yesterday':
+                start.setDate(now.getDate() - 1);
+                start.setHours(0, 0, 0, 0);
+                end.setDate(now.getDate() - 1);
+                end.setHours(23, 59, 59, 999);
+                break;
+            case 'wtd':
+                const dayOfWeek = now.getDay();
+                const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+                start.setDate(now.getDate() - daysToMonday);
+                start.setHours(0, 0, 0, 0);
+                break;
+            case 'lastweek':
+                const lastWeekStart = new Date(now);
+                const lastWeekDay = lastWeekStart.getDay();
+                const daysToLastMonday = lastWeekDay === 0 ? 13 : lastWeekDay + 6;
+                lastWeekStart.setDate(now.getDate() - daysToLastMonday);
+                lastWeekStart.setHours(0, 0, 0, 0);
+                start = lastWeekStart;
+                end = new Date(lastWeekStart);
+                end.setDate(lastWeekStart.getDate() + 6);
+                end.setHours(23, 59, 59, 999);
+                break;
+            case 'mtd':
+                start = new Date(now.getFullYear(), now.getMonth(), 1);
+                break;
+            case 'lastmonth':
+                start = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+                end = new Date(now.getFullYear(), now.getMonth(), 0, 23, 59, 59, 999);
+                break;
+            case 'qtd':
+                const quarter = Math.floor(now.getMonth() / 3);
+                start = new Date(now.getFullYear(), quarter * 3, 1);
+                break;
+            case 'lastquarter':
+                const lastQuarter = Math.floor(now.getMonth() / 3) - 1;
+                const lastQuarterYear = lastQuarter < 0 ? now.getFullYear() - 1 : now.getFullYear();
+                const lastQuarterMonth = lastQuarter < 0 ? 9 : lastQuarter * 3;
+                start = new Date(lastQuarterYear, lastQuarterMonth, 1);
+                end = new Date(lastQuarterYear, lastQuarterMonth + 3, 0, 23, 59, 59, 999);
+                break;
+            case 'ytd':
+                start = new Date(now.getFullYear(), 0, 1);
+                break;
+            case 'lastyear':
+                start = new Date(now.getFullYear() - 1, 0, 1);
+                end = new Date(now.getFullYear() - 1, 11, 31, 23, 59, 59, 999);
+                break;
+        }
+    }
+    else if (period.type === 'custom') {
+        const config = period.config;
+        start = new Date(config.start);
+        end = new Date(config.end);
+    }
+    return { start, end };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/modules/statistics/utils/time-series-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility functions for creating and aggregating time series data.
+ * These helpers optimize performance by sorting data once and iterating sequentially (O(n+m))
+ * instead of repeatedly filtering (O(n*m)).
+ */
+export {};

package/.medusa/server/src/modules/statistics/utils/time-series-utils.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Utility functions for creating and aggregating time series data.
+ * These helpers optimize performance by sorting data once and iterating sequentially (O(n+m))
+ * instead of repeatedly filtering (O(n*m)).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZS1zZXJpZXMtdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9zdGF0aXN0aWNzL3V0aWxzL3RpbWUtc2VyaWVzLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7OztHQUlHIn0=

package/.medusa/server/src/providers/common/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@medusajs/types").ModuleProviderExports;
+export default _default;