medusa-stats 1.0.5

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

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

package/.medusa/server/src/providers/composite/index.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const medusa_stats_1 = require("medusa-stats");
+const zod_1 = require("zod");
+class CompositeStatisticsProvider extends medusa_stats_1.AbstractStatisticsProvider {
+    async getAvailableStatistics() {
+        return [
+            new medusa_stats_1.StatBuilder("moving_average", "Moving Average")
+                .description("Smooth a time series by averaging values over a rolling window.")
+                .field({
+                name: "input_series",
+                label: "Input Series",
+                description: "Dependency result to analyze.",
+                schema: zod_1.z.array(zod_1.z.object({
+                    x: zod_1.z.union([zod_1.z.string(), zod_1.z.date(), zod_1.z.number()]),
+                    value: zod_1.z.number()
+                })).default([]),
+                fieldType: "stat"
+            }, [])
+                .field({
+                name: "window_size",
+                label: "Window Size",
+                description: "Number of points in each rolling average window.",
+                schema: zod_1.z.number().int().min(2).max(365).default(7),
+                fieldType: "number"
+            }, 7)
+                .chart("line")
+                .dimension("time")
+                .build(),
+            new medusa_stats_1.StatBuilder("rate_of_change", "Rate of Change")
+                .description("Measures momentum as change versus N periods ago.")
+                .field({
+                name: "input_series",
+                label: "Input Series",
+                description: "Dependency result to analyze.",
+                schema: zod_1.z.array(zod_1.z.object({
+                    x: zod_1.z.union([zod_1.z.string(), zod_1.z.date(), zod_1.z.number()]),
+                    value: zod_1.z.number()
+                })).default([]),
+                fieldType: "stat"
+            }, [])
+                .field({
+                name: "periods",
+                label: "Lookback Periods",
+                description: "Compare each point against the value this many points back.",
+                schema: zod_1.z.number().int().min(1).max(365).default(1),
+                fieldType: "number"
+            }, 1)
+                .field({
+                name: "as_percentage",
+                label: "As Percentage",
+                description: "Return percent change (true) or decimal ratio (false).",
+                schema: zod_1.z.boolean().default(true),
+                fieldType: "boolean"
+            }, true)
+                .chart("line")
+                .dimension("time")
+                .build()
+        ];
+    }
+    async calculateStatistic(input) {
+        const { id, parameters } = input;
+        const inputSeries = normalizeSeries(parameters.input_series);
+        if (inputSeries.length === 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, `${id} requires dependency input. Add an input dependency and map parameter_name to 'input_series'.`);
+        }
+        switch (id) {
+            case "moving_average": {
+                const windowSize = Number(parameters.window_size || 7);
+                const values = inputSeries.map((point) => point.value);
+                const movingAverage = inputSeries.map((point, index) => {
+                    const start = Math.max(0, index - windowSize + 1);
+                    const window = values.slice(start, index + 1);
+                    const avg = window.reduce((sum, value) => sum + value, 0) / window.length;
+                    return {
+                        x: point.x,
+                        value: Number(avg.toFixed(6))
+                    };
+                });
+                return {
+                    value: movingAverage,
+                    metadata: {
+                        points: movingAverage.length,
+                        windowSize,
+                        calculatedAt: new Date()
+                    }
+                };
+            }
+            case "rate_of_change": {
+                const periods = Number(parameters.periods || 1);
+                const asPercentage = parameters.as_percentage !== false;
+                const roc = inputSeries.map((point, index) => {
+                    if (index < periods) {
+                        return { x: point.x, value: 0 };
+                    }
+                    const previous = inputSeries[index - periods].value;
+                    if (previous === 0) {
+                        return { x: point.x, value: 0 };
+                    }
+                    const change = (point.value - previous) / Math.abs(previous);
+                    const value = asPercentage ? change * 100 : change;
+                    return {
+                        x: point.x,
+                        value: Number(value.toFixed(6))
+                    };
+                });
+                return {
+                    value: roc,
+                    metadata: {
+                        points: roc.length,
+                        periods,
+                        asPercentage,
+                        calculatedAt: new Date()
+                    }
+                };
+            }
+            default:
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, `Unknown statistic: ${id}`);
+        }
+    }
+}
+CompositeStatisticsProvider.identifier = "composite-statistics";
+CompositeStatisticsProvider.displayName = "Composite Statistics Provider";
+const normalizeSeries = (rawSeries) => {
+    if (!Array.isArray(rawSeries)) {
+        return [];
+    }
+    return rawSeries
+        .map((point) => {
+        const value = Number(point?.value);
+        if (!Number.isFinite(value)) {
+            return null;
+        }
+        const x = point?.x instanceof Date ? point.x : new Date(point?.x);
+        if (Number.isNaN(x.getTime())) {
+            return null;
+        }
+        return { x, value };
+    })
+        .filter((point) => Boolean(point))
+        .sort((a, b) => a.x.getTime() - b.x.getTime());
+};
+exports.default = (0, utils_1.ModuleProvider)("statistics", {
+    services: [CompositeStatisticsProvider]
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+export interface CalculateSingleStatisticInput {
+    option_id: string;
+    periodStart: Date;
+    periodEnd: Date;
+    interval: number;
+    runtimeParameters?: Record<string, any>;
+    metadata?: Record<string, any>;
+    cache_options_override?: {
+        enabled?: boolean;
+        ttl?: number;
+    } | null;
+}
+export declare const calculateSingleStatisticWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<CalculateSingleStatisticInput, {
+    result: any;
+}, []>;

package/.medusa/server/src/workflows/statistics/calculate-single-statistic.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateSingleStatisticWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_1 = require("@medusajs/framework/utils");
+const calculate_statistics_1 = require("./steps/calculate-statistics");
+exports.calculateSingleStatisticWorkflow = (0, workflows_sdk_1.createWorkflow)("calculate-single-statistic", function (input) {
+    const calculation = (0, calculate_statistics_1.calculateStatisticsStep)({
+        options: [{ id: input.option_id }],
+        sharedCacheOptions: input.cache_options_override || undefined,
+        runtimeParameters: input.runtimeParameters || {},
+        periodStart: input.periodStart,
+        periodEnd: input.periodEnd,
+        interval: input.interval,
+    });
+    const result = (0, workflows_sdk_1.transform)({ calculation, input }, (data) => {
+        const value = data.calculation.results?.[data.input.option_id];
+        if (value !== undefined) {
+            return value;
+        }
+        const error = data.calculation.errors?.[data.input.option_id];
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, error || `Failed to calculate option ${data.input.option_id}`);
+    });
+    return new workflows_sdk_1.WorkflowResponse({
+        result,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLXNpbmdsZS1zdGF0aXN0aWMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0YXRpc3RpY3MvY2FsY3VsYXRlLXNpbmdsZS1zdGF0aXN0aWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscUVBQXNHO0FBQ3RHLHFEQUF3RDtBQUN4RCx1RUFBdUU7QUFhMUQsUUFBQSxnQ0FBZ0MsR0FBRyxJQUFBLDhCQUFjLEVBQzFELDRCQUE0QixFQUM1QixVQUFVLEtBQW9DO0lBQzFDLE1BQU0sV0FBVyxHQUFHLElBQUEsOENBQXVCLEVBQUM7UUFDeEMsT0FBTyxFQUFFLENBQUMsRUFBRSxFQUFFLEVBQUUsS0FBSyxDQUFDLFNBQVMsRUFBRSxDQUFDO1FBQ2xDLGtCQUFrQixFQUFFLEtBQUssQ0FBQyxzQkFBc0IsSUFBSSxTQUFTO1FBQzdELGlCQUFpQixFQUFFLEtBQUssQ0FBQyxpQkFBaUIsSUFBSSxFQUFFO1FBQ2hELFdBQVcsRUFBRSxLQUFLLENBQUMsV0FBVztRQUM5QixTQUFTLEVBQUUsS0FBSyxDQUFDLFNBQVM7UUFDMUIsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRO0tBQzNCLENBQUMsQ0FBQztJQUVILE1BQU0sTUFBTSxHQUFHLElBQUEseUJBQVMsRUFBQyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDLElBQUksRUFBRSxFQUFFO1FBQ3RELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUUvRCxJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztZQUN0QixPQUFPLEtBQUssQ0FBQztRQUNqQixDQUFDO1FBRUQsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBRTlELE1BQU0sSUFBSSxtQkFBVyxDQUNqQixtQkFBVyxDQUFDLEtBQUssQ0FBQyxZQUFZLEVBQzlCLEtBQUssSUFBSSw4QkFBOEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsQ0FDaEUsQ0FBQztJQUNOLENBQUMsQ0FBQyxDQUFDO0lBRUgsT0FBTyxJQUFJLGdDQUFnQixDQUFDO1FBQ3hCLE1BQU07S0FDVCxDQUFDLENBQUM7QUFDUCxDQUFDLENBQ0osQ0FBQyJ9

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

@@ -0,0 +1,20 @@
+import { type CalculateStatisticsInput } from "./steps/calculate-statistics";
+export type CalculateStatisticsWorkflowInput = CalculateStatisticsInput;
+export declare const calculateStatisticsWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<CalculateStatisticsInput, {
+    results: (Record<string, any> | import("@medusajs/framework/workflows-sdk").WorkflowData<Record<string, any>>) & Record<string, any>;
+    errors: ((Record<string, string> | import("@medusajs/framework/workflows-sdk").WorkflowData<Record<string, string> | undefined>) & Record<string, string>) | undefined;
+    metadata: (Record<string, {
+        fromCache: boolean;
+        cachedAt?: string;
+        calculationTime: number;
+    }> | import("@medusajs/framework/workflows-sdk").WorkflowData<Record<string, {
+        fromCache: boolean;
+        cachedAt?: string;
+        calculationTime: number;
+    }>>) & Record<string, {
+        fromCache: boolean;
+        cachedAt?: string;
+        calculationTime: number;
+    }>;
+    duration: (number | import("@medusajs/framework/workflows-sdk").WorkflowData<number>) & number;
+}, []>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateStatisticsWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const calculate_statistics_1 = require("./steps/calculate-statistics");
+exports.calculateStatisticsWorkflow = (0, workflows_sdk_1.createWorkflow)("calculate-statistics-workflow", function (input) {
+    const calculation = (0, calculate_statistics_1.calculateStatisticsStep)(input);
+    return new workflows_sdk_1.WorkflowResponse({
+        results: calculation.results,
+        errors: calculation.errors,
+        metadata: calculation.metadata,
+        duration: calculation.duration,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLXN0YXRpc3RpY3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0YXRpc3RpY3MvY2FsY3VsYXRlLXN0YXRpc3RpY3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscUVBQXFGO0FBQ3JGLHVFQUdzQztBQUl6QixRQUFBLDJCQUEyQixHQUFHLElBQUEsOEJBQWMsRUFDckQsK0JBQStCLEVBQy9CLFVBQVUsS0FBdUM7SUFDN0MsTUFBTSxXQUFXLEdBQUcsSUFBQSw4Q0FBdUIsRUFBQyxLQUFLLENBQUMsQ0FBQztJQUVuRCxPQUFPLElBQUksZ0NBQWdCLENBQUM7UUFDeEIsT0FBTyxFQUFFLFdBQVcsQ0FBQyxPQUFPO1FBQzVCLE1BQU0sRUFBRSxXQUFXLENBQUMsTUFBTTtRQUMxQixRQUFRLEVBQUUsV0FBVyxDQUFDLFFBQVE7UUFDOUIsUUFBUSxFQUFFLFdBQVcsQ0FBQyxRQUFRO0tBQ2pDLENBQUMsQ0FBQztBQUNQLENBQUMsQ0FDSixDQUFDIn0=

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

@@ -0,0 +1,31 @@
+export interface CalculateViewInput {
+    view_id: string;
+    periodStart: Date;
+    periodEnd: Date;
+    interval: number;
+}
+export declare const calculateViewWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<CalculateViewInput, {
+    results: (Record<string, any> | import("@medusajs/framework/workflows-sdk").WorkflowData<Record<string, any>>) & Record<string, any>;
+    errors: ((Record<string, string> | import("@medusajs/framework/workflows-sdk").WorkflowData<Record<string, string> | undefined>) & Record<string, string>) | undefined;
+    definitions: ({
+        [k: string]: any[];
+    } | import("@medusajs/framework/workflows-sdk").WorkflowData<{
+        [k: string]: any[];
+    }>) & {
+        [k: string]: any[];
+    };
+    metadata: (Record<string, {
+        fromCache: boolean;
+        cachedAt?: string;
+        calculationTime: number;
+    }> | import("@medusajs/framework/workflows-sdk").WorkflowData<Record<string, {
+        fromCache: boolean;
+        cachedAt?: string;
+        calculationTime: number;
+    }>>) & Record<string, {
+        fromCache: boolean;
+        cachedAt?: string;
+        calculationTime: number;
+    }>;
+    duration: (number | import("@medusajs/framework/workflows-sdk").WorkflowData<number>) & number;
+}, []>;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateViewWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const fetch_view_with_options_1 = require("./steps/fetch-view-with-options");
+const calculate_statistics_1 = require("./steps/calculate-statistics");
+exports.calculateViewWorkflow = (0, workflows_sdk_1.createWorkflow)("calculate-view", (input) => {
+    const view = (0, fetch_view_with_options_1.fetchViewWithOptionsStep)({ view_id: input.view_id });
+    const calculationContext = (0, workflows_sdk_1.transform)({ view }, ({ view }) => ({
+        options: view.statistics || [],
+        sharedStatsData: view.stats_data,
+        sharedCacheOptions: view.cache_options,
+    }));
+    const calculationResult = (0, calculate_statistics_1.calculateStatisticsStep)({
+        options: calculationContext.options,
+        sharedStatsData: calculationContext.sharedStatsData,
+        sharedCacheOptions: calculationContext.sharedCacheOptions,
+        periodStart: input.periodStart,
+        periodEnd: input.periodEnd,
+        interval: input.interval,
+    });
+    return new workflows_sdk_1.WorkflowResponse({
+        results: calculationResult.results,
+        errors: calculationResult.errors,
+        definitions: calculationResult.definitions,
+        metadata: calculationResult.metadata,
+        duration: calculationResult.duration,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLXZpZXcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0YXRpc3RpY3MvY2FsY3VsYXRlLXZpZXcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscUVBQXNHO0FBQ3RHLDZFQUEyRTtBQUMzRSx1RUFBdUU7QUFRMUQsUUFBQSxxQkFBcUIsR0FBRyxJQUFBLDhCQUFjLEVBQy9DLGdCQUFnQixFQUNoQixDQUFDLEtBQXlCLEVBQUUsRUFBRTtJQUUxQixNQUFNLElBQUksR0FBRyxJQUFBLGtEQUF3QixFQUFDLEVBQUUsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO0lBRWxFLE1BQU0sa0JBQWtCLEdBQUcsSUFBQSx5QkFBUyxFQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQzFELE9BQU8sRUFBRyxJQUFZLENBQUMsVUFBVSxJQUFJLEVBQUU7UUFDdkMsZUFBZSxFQUFHLElBQVksQ0FBQyxVQUFVO1FBQ3pDLGtCQUFrQixFQUFHLElBQVksQ0FBQyxhQUFhO0tBQ2xELENBQUMsQ0FBQyxDQUFDO0lBR0osTUFBTSxpQkFBaUIsR0FBRyxJQUFBLDhDQUF1QixFQUFDO1FBQzlDLE9BQU8sRUFBRSxrQkFBa0IsQ0FBQyxPQUFPO1FBQ25DLGVBQWUsRUFBRSxrQkFBa0IsQ0FBQyxlQUFlO1FBQ25ELGtCQUFrQixFQUFFLGtCQUFrQixDQUFDLGtCQUFrQjtRQUN6RCxXQUFXLEVBQUUsS0FBSyxDQUFDLFdBQVc7UUFDOUIsU0FBUyxFQUFFLEtBQUssQ0FBQyxTQUFTO1FBQzFCLFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUTtLQUMzQixDQUFDLENBQUM7SUFFSCxPQUFPLElBQUksZ0NBQWdCLENBQUM7UUFDeEIsT0FBTyxFQUFFLGlCQUFpQixDQUFDLE9BQU87UUFDbEMsTUFBTSxFQUFFLGlCQUFpQixDQUFDLE1BQU07UUFDaEMsV0FBVyxFQUFFLGlCQUFpQixDQUFDLFdBQVc7UUFDMUMsUUFBUSxFQUFFLGlCQUFpQixDQUFDLFFBQVE7UUFDcEMsUUFBUSxFQUFFLGlCQUFpQixDQUFDLFFBQVE7S0FDdkMsQ0FBQyxDQUFDO0FBQ1AsQ0FBQyxDQUNKLENBQUMifQ==

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

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

package/.medusa/server/src/workflows/statistics/clone-view.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneViewWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const clone_view_1 = require("./steps/clone-view");
+exports.cloneViewWorkflow = (0, workflows_sdk_1.createWorkflow)("clone-view", (input) => {
+    const result = (0, clone_view_1.cloneViewStep)(input);
+    return new workflows_sdk_1.WorkflowResponse(result);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xvbmUtdmlldy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3Mvc3RhdGlzdGljcy9jbG9uZS12aWV3LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFFQUFxRjtBQUNyRixtREFBbUQ7QUFVdEMsUUFBQSxpQkFBaUIsR0FBRyxJQUFBLDhCQUFjLEVBQzNDLFlBQVksRUFDWixDQUFDLEtBQXFCLEVBQUUsRUFBRTtJQUN0QixNQUFNLE1BQU0sR0FBRyxJQUFBLDBCQUFhLEVBQUMsS0FBSyxDQUFDLENBQUM7SUFFcEMsT0FBTyxJQUFJLGdDQUFnQixDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQ3hDLENBQUMsQ0FDSixDQUFDIn0=