medusa-stats 1.0.5

package/.medusa/server/src/modules/statistics/providers/provider.d.ts

@@ -0,0 +1,254 @@
+import { z } from "zod";
+export type ParameterFieldType = "text" | "number" | "select" | "multiselect" | "boolean" | "date" | "daterange" | "currency" | "json" | "entity" | "entities" | "custom" | "stat";
+export interface EntityReference {
+    entity: string;
+}
+export interface ParameterFieldDefinition {
+    name: string;
+    label: string;
+    description?: string;
+    placeholder?: string;
+    schema?: z.ZodType<any>;
+    fieldType: ParameterFieldType;
+    options?: Array<{
+        value: string | number | boolean;
+        label: string;
+        description?: string;
+        disabled?: boolean;
+    }> | ((context: Record<string, any>) => Promise<Array<any>> | Array<any>);
+    entityReference?: EntityReference;
+    dependsOn?: Array<{
+        field: string;
+        condition: (value: any, allValues: Record<string, any>) => boolean;
+        effect?: "show" | "hide" | "enable" | "disable" | "require";
+    }>;
+}
+export interface AvailableStatistic {
+    id: string;
+    name: string;
+    description?: string;
+    parameters: {
+        fields: ParameterFieldDefinition[];
+        defaults?: Record<string, any>;
+    };
+    display: {
+        visualization?: {
+            preferredChartType?: "line" | "bar" | "area" | "pie" | "gauge" | "number" | string;
+            xAxisType?: "time" | "category";
+            [key: string]: any;
+        };
+    };
+    metadata?: Record<string, any>;
+}
+export interface CalculateStatisticInput {
+    id: string;
+    parameters: Record<string, any>;
+    fields: ParameterFieldDefinition[];
+    periodStart: Date;
+    periodEnd: Date;
+    interval: number;
+    metadata?: Record<string, any>;
+}
+export type TimeSeries = Array<{
+    x: Date;
+    value: any;
+}>;
+export type CategoricalSeries = Array<{
+    x: string | number;
+    value: any;
+}>;
+export type GaugeValue = {
+    value: number;
+};
+export interface StatisticResult {
+    value: TimeSeries | CategoricalSeries | GaugeValue | any;
+    metadata?: Record<string, any>;
+}
+/**
+ * Builder class for constructing AvailableStatistic objects with a fluent API.
+ *
+ * @example
+ * const statistic = new StatBuilder("total_revenue", "Total Revenue")
+ *   .description("Calculate total revenue for the period")
+ *   .field({
+ *     name: "currency_code",
+ *     label: "Currency",
+ *     fieldType: "select",
+ *     options: [{ value: "usd", label: "USD" }]
+ *   })
+ *   .chart("line")
+ *   .dimension("time")
+ *   .build();
+ */
+export declare class StatBuilder {
+    private statistic;
+    constructor(id: string, name: string);
+    /**
+     * Set the description for this statistic
+     */
+    description(description: string): this;
+    /**
+     * Add a single parameter field to this statistic
+     */
+    field(field: ParameterFieldDefinition, defaultValue?: any): this;
+    /**
+     * Set the preferred chart type for visualization
+     */
+    chart(chartType: "line" | "bar" | "area" | "pie" | "gauge" | "number" | string): this;
+    /**
+     * Set the X-axis type for time series or categorical data
+     */
+    dimension(type: "time" | "category"): this;
+    /**
+     * Set visualization configuration (merges with existing config)
+     */
+    visualization(config: Partial<AvailableStatistic['display']['visualization']>): this;
+    /**
+     * Set metadata for this statistic
+     */
+    metadata(metadata: Record<string, any>): this;
+    /**
+     * Build and return the final AvailableStatistic object
+     */
+    build(): AvailableStatistic;
+}
+/**
+ * Helper: Group an array of data by a property or function result
+ *
+ * @param data - Array of data items to group
+ * @param keySelector - Property name or function to extract grouping key
+ * @param aggregator - Optional function to aggregate grouped values
+ * @returns Map of grouped data
+ *
+ * @example
+ *
+ * const byDate = groupBy(orders, 'created_at')
+ *
+ * @example
+ *
+ * const revenueByDay = groupBy(
+ *   orders,
+ *   (order) => order.created_at.toISOString().split('T')[0],
+ *   (items) => items.reduce((sum, item) => sum + item.total, 0)
+ * )
+ */
+export declare function groupBy<T, K extends string | number = string>(data: T[], keySelector: keyof T | ((item: T) => K), aggregator?: (items: T[], key: K) => any): Map<K, any>;
+/**
+ * Helper: Generate interval timestamps for a period
+ *
+ * @param periodStart - Start date of the period
+ * @param periodEnd - End date of the period
+ * @param interval - Interval in seconds (3600 = hourly, 86400 = daily, 604800 = weekly)
+ * @returns Array of timestamps at each interval
+ *
+ * @example
+ * const intervals = generateIntervals(
+ *   new Date('2024-01-01'),
+ *   new Date('2024-01-31'),
+ *   604800
+ * )
+ */
+export declare function generateIntervals(periodStart: Date, periodEnd: Date, interval: number): Date[];
+/**
+ * Helper: Get the interval bucket for a given date
+ *
+ * @param date - Date to bucket
+ * @param periodStart - Start of the period
+ * @param interval - Interval in seconds
+ * @returns The bucket date (start of interval)
+ *
+ * @example
+ * const bucketDate = getIntervalBucket(
+ *   new Date('2024-01-05'),
+ *   new Date('2024-01-01'),
+ *   604800
+ * )
+ */
+export declare function getIntervalBucket(date: Date, periodStart: Date, interval: number): Date;
+/**
+ * Creates a time series by efficiently mapping data to time intervals.
+ * Generates intervals internally and processes data in a single pass.
+ *
+ * @param data - Array of data items to aggregate
+ * @param periodStart - Start of the time period
+ * @param periodEnd - End of the time period
+ * @param intervalSeconds - Duration of each interval in seconds
+ * @param accumulator - Function to aggregate items within each interval
+ * @param options - Optional configuration
+ * @param options.timestampField - Field name or function to extract timestamp (defaults to 'created_at')
+ * @returns Array of time series points with x (Date) and value (number)
+ */
+export declare function createTimeSeries<T extends Record<string, any>>(data: T[], periodStart: Date, periodEnd: Date, intervalSeconds: number, accumulator: (items: T[]) => number, options?: {
+    timestampField?: string | ((item: T) => number);
+}): Array<{
+    x: Date;
+    value: number;
+}>;
+/**
+ * Creates a count accumulator that returns the number of items.
+ *
+ * @returns Accumulator function that counts items
+ *
+ * @example
+ * createTimeSeries(orders, start, end, interval, count())
+ */
+export declare function count<T>(): (items: T[]) => number;
+/**
+ * Creates a sum accumulator that sums values of a specific field.
+ *
+ * @param field - Name of the field to sum
+ * @returns Accumulator function that sums field values
+ *
+ * @example
+ * createTimeSeries(orders, start, end, interval, sum('total'))
+ */
+export declare function sum<T extends Record<string, any>>(field: string): (items: T[]) => number;
+/**
+ * Creates an average accumulator that calculates mean of a specific field.
+ * Optionally excludes outliers using IQR method (requires at least 3 data points).
+ *
+ * @param field - Name of the field to average
+ * @param options - Optional configuration
+ * @param options.excludeOutliers - If true, excludes outliers using IQR method
+ * @returns Accumulator function that calculates average
+ *
+ * @example
+ * createTimeSeries(orders, start, end, interval, average('total'))
+ * createTimeSeries(orders, start, end, interval, average('total', { excludeOutliers: true }))
+ */
+export declare function average<T extends Record<string, any>>(field: string, options?: {
+    excludeOutliers?: boolean;
+}): (items: T[]) => number;
+/**
+ * Abstract provider for calculating statistics.
+ * Extend this class to implement custom statistics providers.
+ */
+export declare abstract class AbstractStatisticsProvider {
+    protected readonly container: any;
+    static identifier: string;
+    static displayName: string;
+    protected query: any;
+    constructor(container: any);
+    /**
+     * Get available statistics for a given sales channel.
+     *
+     * @param input - Input parameters
+     * @param input.sales_channel_id - Optional sales channel ID to filter statistics
+     * @returns Array of available statistics with their configuration
+     */
+    abstract getAvailableStatistics(): Promise<AvailableStatistic[]> | AvailableStatistic[];
+    /**
+     * Calculate a specific statistic for a given period.
+     *
+     * @param input - Input parameters
+     * @param input.id - The statistic ID to calculate
+     * @param input.parameters - Validated and merged parameter values
+     * @param input.fields - Field definitions for reference
+     * @param input.periodStart - Start date of the period
+     * @param input.periodEnd - End date of the period
+     * @param input.interval - Interval in seconds (3600 = hourly, 86400 = daily, 604800 = weekly)
+     * @param input.metadata - Additional calculation metadata
+     * @returns The calculated statistic with rendering configuration
+     */
+    abstract calculateStatistic(input: CalculateStatisticInput): Promise<StatisticResult> | StatisticResult;
+}

package/.medusa/server/src/modules/statistics/providers/provider.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractStatisticsProvider = exports.StatBuilder = void 0;
+exports.groupBy = groupBy;
+exports.generateIntervals = generateIntervals;
+exports.getIntervalBucket = getIntervalBucket;
+exports.createTimeSeries = createTimeSeries;
+exports.count = count;
+exports.sum = sum;
+exports.average = average;
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Builder class for constructing AvailableStatistic objects with a fluent API.
+ *
+ * @example
+ * const statistic = new StatBuilder("total_revenue", "Total Revenue")
+ *   .description("Calculate total revenue for the period")
+ *   .field({
+ *     name: "currency_code",
+ *     label: "Currency",
+ *     fieldType: "select",
+ *     options: [{ value: "usd", label: "USD" }]
+ *   })
+ *   .chart("line")
+ *   .dimension("time")
+ *   .build();
+ */
+class StatBuilder {
+    constructor(id, name) {
+        this.statistic = {
+            id,
+            name,
+            parameters: {
+                fields: []
+            },
+            display: {}
+        };
+    }
+    /**
+     * Set the description for this statistic
+     */
+    description(description) {
+        this.statistic.description = description;
+        return this;
+    }
+    /**
+     * Add a single parameter field to this statistic
+     */
+    field(field, defaultValue) {
+        this.statistic.parameters.fields.push(field);
+        if (defaultValue !== undefined) {
+            if (!this.statistic.parameters.defaults) {
+                this.statistic.parameters.defaults = {};
+            }
+            this.statistic.parameters.defaults[field.name] = defaultValue;
+        }
+        return this;
+    }
+    /**
+     * Set the preferred chart type for visualization
+     */
+    chart(chartType) {
+        if (!this.statistic.display.visualization) {
+            this.statistic.display.visualization = {};
+        }
+        this.statistic.display.visualization.preferredChartType = chartType;
+        return this;
+    }
+    /**
+     * Set the X-axis type for time series or categorical data
+     */
+    dimension(type) {
+        if (!this.statistic.display.visualization) {
+            this.statistic.display.visualization = {};
+        }
+        this.statistic.display.visualization.xAxisType = type;
+        return this;
+    }
+    /**
+     * Set visualization configuration (merges with existing config)
+     */
+    visualization(config) {
+        this.statistic.display.visualization = {
+            ...this.statistic.display.visualization,
+            ...config
+        };
+        return this;
+    }
+    /**
+     * Set metadata for this statistic
+     */
+    metadata(metadata) {
+        this.statistic.metadata = metadata;
+        return this;
+    }
+    /**
+     * Build and return the final AvailableStatistic object
+     */
+    build() {
+        if (!this.statistic.id || !this.statistic.name) {
+            throw new Error("AvailableStatistic requires 'id' and 'name'");
+        }
+        return { ...this.statistic };
+    }
+}
+exports.StatBuilder = StatBuilder;
+/**
+ * Helper: Group an array of data by a property or function result
+ *
+ * @param data - Array of data items to group
+ * @param keySelector - Property name or function to extract grouping key
+ * @param aggregator - Optional function to aggregate grouped values
+ * @returns Map of grouped data
+ *
+ * @example
+ *
+ * const byDate = groupBy(orders, 'created_at')
+ *
+ * @example
+ *
+ * const revenueByDay = groupBy(
+ *   orders,
+ *   (order) => order.created_at.toISOString().split('T')[0],
+ *   (items) => items.reduce((sum, item) => sum + item.total, 0)
+ * )
+ */
+function groupBy(data, keySelector, aggregator) {
+    const groups = new Map();
+    for (const item of data) {
+        const key = typeof keySelector === 'function'
+            ? keySelector(item)
+            : item[keySelector];
+        if (!groups.has(key)) {
+            groups.set(key, []);
+        }
+        groups.get(key).push(item);
+    }
+    if (aggregator) {
+        const result = new Map();
+        for (const [key, items] of groups.entries()) {
+            result.set(key, aggregator(items, key));
+        }
+        return result;
+    }
+    return groups;
+}
+/**
+ * Helper: Generate interval timestamps for a period
+ *
+ * @param periodStart - Start date of the period
+ * @param periodEnd - End date of the period
+ * @param interval - Interval in seconds (3600 = hourly, 86400 = daily, 604800 = weekly)
+ * @returns Array of timestamps at each interval
+ *
+ * @example
+ * const intervals = generateIntervals(
+ *   new Date('2024-01-01'),
+ *   new Date('2024-01-31'),
+ *   604800
+ * )
+ */
+function generateIntervals(periodStart, periodEnd, interval) {
+    const intervals = [];
+    const current = new Date(periodStart);
+    const end = new Date(periodEnd);
+    const intervalMs = interval * 1000;
+    while (current <= end) {
+        intervals.push(new Date(current));
+        current.setTime(current.getTime() + intervalMs);
+    }
+    return intervals;
+}
+/**
+ * Helper: Get the interval bucket for a given date
+ *
+ * @param date - Date to bucket
+ * @param periodStart - Start of the period
+ * @param interval - Interval in seconds
+ * @returns The bucket date (start of interval)
+ *
+ * @example
+ * const bucketDate = getIntervalBucket(
+ *   new Date('2024-01-05'),
+ *   new Date('2024-01-01'),
+ *   604800
+ * )
+ */
+function getIntervalBucket(date, periodStart, interval) {
+    const msSinceStart = date.getTime() - periodStart.getTime();
+    const secondsSinceStart = Math.floor(msSinceStart / 1000);
+    const bucketIndex = Math.floor(secondsSinceStart / interval);
+    const bucketDate = new Date(periodStart);
+    bucketDate.setTime(bucketDate.getTime() + bucketIndex * interval * 1000);
+    return bucketDate;
+}
+/**
+ * Creates a time series by efficiently mapping data to time intervals.
+ * Generates intervals internally and processes data in a single pass.
+ *
+ * @param data - Array of data items to aggregate
+ * @param periodStart - Start of the time period
+ * @param periodEnd - End of the time period
+ * @param intervalSeconds - Duration of each interval in seconds
+ * @param accumulator - Function to aggregate items within each interval
+ * @param options - Optional configuration
+ * @param options.timestampField - Field name or function to extract timestamp (defaults to 'created_at')
+ * @returns Array of time series points with x (Date) and value (number)
+ */
+function createTimeSeries(data, periodStart, periodEnd, intervalSeconds, accumulator, options = {}) {
+    let getTimestamp;
+    if (typeof options.timestampField === 'function') {
+        getTimestamp = options.timestampField;
+    }
+    else {
+        const field = options.timestampField || 'created_at';
+        getTimestamp = (item) => new Date(item[field]).getTime();
+    }
+    const sorted = [...data]
+        .map(item => ({ item, timestamp: getTimestamp(item) }))
+        .sort((a, b) => a.timestamp - b.timestamp);
+    const result = [];
+    const startMs = periodStart.getTime();
+    const endMs = periodEnd.getTime();
+    const intervalMs = intervalSeconds * 1000;
+    let dataIdx = 0;
+    for (let currentMs = startMs; currentMs < endMs; currentMs += intervalMs) {
+        const nextMs = Math.min(currentMs + intervalMs, endMs);
+        const itemsInInterval = [];
+        const startIdx = dataIdx;
+        while (dataIdx < sorted.length && sorted[dataIdx].timestamp < nextMs) {
+            if (sorted[dataIdx].timestamp >= currentMs) {
+                itemsInInterval.push(sorted[dataIdx].item);
+            }
+            dataIdx++;
+        }
+        dataIdx = startIdx;
+        result.push({
+            x: new Date(currentMs),
+            value: accumulator(itemsInInterval)
+        });
+    }
+    return result;
+}
+/**
+ * Creates a count accumulator that returns the number of items.
+ *
+ * @returns Accumulator function that counts items
+ *
+ * @example
+ * createTimeSeries(orders, start, end, interval, count())
+ */
+function count() {
+    return (items) => items.length;
+}
+/**
+ * Creates a sum accumulator that sums values of a specific field.
+ *
+ * @param field - Name of the field to sum
+ * @returns Accumulator function that sums field values
+ *
+ * @example
+ * createTimeSeries(orders, start, end, interval, sum('total'))
+ */
+function sum(field) {
+    return (items) => items.reduce((sum, item) => sum + (Number(item[field]) || 0), 0);
+}
+/**
+ * Creates an average accumulator that calculates mean of a specific field.
+ * Optionally excludes outliers using IQR method (requires at least 3 data points).
+ *
+ * @param field - Name of the field to average
+ * @param options - Optional configuration
+ * @param options.excludeOutliers - If true, excludes outliers using IQR method
+ * @returns Accumulator function that calculates average
+ *
+ * @example
+ * createTimeSeries(orders, start, end, interval, average('total'))
+ * createTimeSeries(orders, start, end, interval, average('total', { excludeOutliers: true }))
+ */
+function average(field, options = {}) {
+    return (items) => {
+        if (items.length === 0)
+            return 0;
+        const values = items.map(item => Number(item[field]) || 0);
+        if (options.excludeOutliers && values.length > 2) {
+            const sorted = [...values].sort((a, b) => a - b);
+            const q1 = sorted[Math.floor(sorted.length * 0.25)];
+            const q3 = sorted[Math.floor(sorted.length * 0.75)];
+            const iqr = q3 - q1;
+            const filtered = values.filter(v => v >= q1 - 1.5 * iqr && v <= q3 + 1.5 * iqr);
+            return filtered.reduce((sum, v) => sum + v, 0) / filtered.length;
+        }
+        return values.reduce((sum, v) => sum + v, 0) / values.length;
+    };
+}
+/**
+ * Abstract provider for calculating statistics.
+ * Extend this class to implement custom statistics providers.
+ */
+class AbstractStatisticsProvider {
+    constructor(container) {
+        this.container = container;
+        this.query = container[utils_1.ContainerRegistrationKeys.QUERY];
+    }
+}
+exports.AbstractStatisticsProvider = AbstractStatisticsProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../../../../../src/modules/statistics/providers/provider.ts"],"names":[],"mappings":"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"}