@wilshop/dashboard 3.5.2

package/dist/plugin/service/metrics.service.js

@@ -0,0 +1,129 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const crypto_1 = require("crypto");
+const date_fns_1 = require("date-fns");
+const metrics_strategies_js_1 = require("../config/metrics-strategies.js");
+const constants_js_1 = require("../constants.js");
+let MetricsService = class MetricsService {
+    constructor(connection, cacheService) {
+        this.connection = connection;
+        this.cacheService = cacheService;
+        this.metricCalculations = [
+            new metrics_strategies_js_1.AverageOrderValueMetric(),
+            new metrics_strategies_js_1.OrderCountMetric(),
+            new metrics_strategies_js_1.OrderTotalMetric(),
+        ];
+    }
+    async getMetrics(ctx, { types, refresh, startDate, endDate }) {
+        const calculatedStartDate = (0, date_fns_1.startOfDay)(new Date(startDate));
+        const calculatedEndDate = (0, date_fns_1.endOfDay)(new Date(endDate));
+        // Check if we have cached result
+        const hash = (0, crypto_1.createHash)('sha1')
+            .update(JSON.stringify({
+            startDate: calculatedStartDate,
+            endDate: calculatedEndDate,
+            types: types.sort(),
+            channel: ctx.channel.token,
+        }))
+            .digest('base64');
+        const cacheKey = `MetricsService:${hash}`;
+        const cachedMetricList = await this.cacheService.get(cacheKey);
+        if (cachedMetricList && refresh !== true) {
+            core_1.Logger.verbose(`Returning cached metrics for channel ${ctx.channel.token}`, constants_js_1.loggerCtx);
+            return cachedMetricList;
+        }
+        // No cache, calculating new metrics
+        core_1.Logger.verbose(`No cache hit, calculating metrics from ${calculatedStartDate.toISOString()} to ${calculatedEndDate.toISOString()} for channel ${ctx.channel.token} for all orders`, constants_js_1.loggerCtx);
+        const data = await this.loadData(ctx, calculatedStartDate, calculatedEndDate);
+        const metrics = [];
+        for (const type of types) {
+            const metric = this.metricCalculations.find(m => m.type === type);
+            if (!metric) {
+                continue;
+            }
+            // Calculate entries for each day
+            const entries = [];
+            data.forEach(dataPerDay => {
+                entries.push(metric.calculateEntry(ctx, dataPerDay));
+            });
+            // Create metric with calculated entries
+            metrics.push({
+                title: metric.getTitle(ctx),
+                type: metric.type,
+                entries,
+            });
+        }
+        await this.cacheService.set(cacheKey, metrics, { ttl: 1000 * 60 * 60 * 2 }); // 2 hours
+        return metrics;
+    }
+    async loadData(ctx, startDate, endDate) {
+        const orderRepo = this.connection.getRepository(ctx, core_1.Order);
+        // Calculate number of days between start and end
+        const diffTime = Math.abs(endDate.getTime() - startDate.getTime());
+        const nrOfDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24)) + 1;
+        // Get orders in a loop until we have all
+        let skip = 0;
+        const take = 1000;
+        let hasMoreOrders = true;
+        const orders = [];
+        while (hasMoreOrders) {
+            const query = orderRepo
+                .createQueryBuilder('order')
+                .leftJoin('order.channels', 'orderChannel')
+                .where('orderChannel.id=:channelId', { channelId: ctx.channelId })
+                .andWhere('order.orderPlacedAt >= :startDate', {
+                startDate: startDate.toISOString(),
+            })
+                .andWhere('order.orderPlacedAt <= :endDate', {
+                endDate: endDate.toISOString(),
+            })
+                .skip(skip)
+                .take(take);
+            const [items, nrOfOrders] = await query.getManyAndCount();
+            orders.push(...items);
+            core_1.Logger.verbose(`Fetched orders ${skip}-${skip + take} for channel ${ctx.channel.token} for date range metrics`, constants_js_1.loggerCtx);
+            skip += items.length;
+            if (orders.length >= nrOfOrders) {
+                hasMoreOrders = false;
+            }
+        }
+        core_1.Logger.verbose(`Finished fetching all ${orders.length} orders for channel ${ctx.channel.token} for date range metrics`, constants_js_1.loggerCtx);
+        const dataPerDay = new Map();
+        // Create a map entry for each day in the range
+        for (let i = 0; i < nrOfDays; i++) {
+            const currentDate = new Date(startDate);
+            currentDate.setDate(startDate.getDate() + i);
+            const dateKey = currentDate.toISOString().split('T')[0]; // YYYY-MM-DD format
+            // Filter orders for this specific day
+            const ordersForDay = orders.filter(order => {
+                if (!order.orderPlacedAt)
+                    return false;
+                const orderDate = new Date(order.orderPlacedAt).toISOString().split('T')[0];
+                return orderDate === dateKey;
+            });
+            dataPerDay.set(dateKey, {
+                orders: ordersForDay,
+                date: currentDate,
+            });
+        }
+        return dataPerDay;
+    }
+};
+exports.MetricsService = MetricsService;
+exports.MetricsService = MetricsService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.TransactionalConnection,
+        core_1.CacheService])
+], MetricsService);

package/dist/plugin/types.d.ts

@@ -0,0 +1,20 @@
+export type DashboardMetricSummary = {
+    type: DashboardMetricType;
+    title: string;
+    entries: DashboardMetricSummaryEntry[];
+};
+export declare enum DashboardMetricType {
+    OrderCount = "OrderCount",
+    OrderTotal = "OrderTotal",
+    AverageOrderValue = "AverageOrderValue"
+}
+export type DashboardMetricSummaryEntry = {
+    label: string;
+    value: number;
+};
+export interface DashboardMetricSummaryInput {
+    types: DashboardMetricType[];
+    refresh?: boolean;
+    startDate: string;
+    endDate: string;
+}

package/dist/plugin/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardMetricType = void 0;
+var DashboardMetricType;
+(function (DashboardMetricType) {
+    DashboardMetricType["OrderCount"] = "OrderCount";
+    DashboardMetricType["OrderTotal"] = "OrderTotal";
+    DashboardMetricType["AverageOrderValue"] = "AverageOrderValue";
+})(DashboardMetricType || (exports.DashboardMetricType = DashboardMetricType = {}));

package/dist/vite/constants.d.ts

@@ -0,0 +1,5 @@
+import { LanguageCode } from '@vendure/core';
+export declare const defaultLanguage = LanguageCode.en;
+export declare const defaultLocale: undefined;
+export declare const defaultAvailableLanguages: LanguageCode[];
+export declare const defaultAvailableLocales: string[];

package/dist/vite/constants.js

@@ -0,0 +1,278 @@
+import { LanguageCode } from '@vendure/core';
+export const defaultLanguage = LanguageCode.en;
+export const defaultLocale = undefined;
+export const defaultAvailableLanguages = [
+    LanguageCode.he,
+    LanguageCode.ar,
+    LanguageCode.de,
+    LanguageCode.en,
+    LanguageCode.es,
+    LanguageCode.pl,
+    LanguageCode.zh_Hans,
+    LanguageCode.zh_Hant,
+    LanguageCode.pt_BR,
+    LanguageCode.pt_PT,
+    LanguageCode.cs,
+    LanguageCode.fr,
+    LanguageCode.ru,
+    LanguageCode.uk,
+    LanguageCode.it,
+    LanguageCode.fa,
+    LanguageCode.ne,
+    LanguageCode.hr,
+    LanguageCode.sv,
+    LanguageCode.nb,
+    LanguageCode.tr,
+    LanguageCode.bg,
+];
+export const defaultAvailableLocales = [
+    'AF',
+    'AL',
+    'DZ',
+    'AS',
+    'AD',
+    'AO',
+    'AI',
+    'AQ',
+    'AG',
+    'AR',
+    'AM',
+    'AW',
+    'AU',
+    'AT',
+    'AZ',
+    'BS',
+    'BH',
+    'BD',
+    'BB',
+    'BY',
+    'BE',
+    'BZ',
+    'BJ',
+    'BM',
+    'BT',
+    'BO',
+    'BQ',
+    'BA',
+    'BW',
+    'BV',
+    'BR',
+    'IO',
+    'BN',
+    'BG',
+    'BF',
+    'BI',
+    'CV',
+    'KH',
+    'CM',
+    'CA',
+    'KY',
+    'CF',
+    'TD',
+    'CL',
+    'CN',
+    'CX',
+    'CC',
+    'CO',
+    'KM',
+    'CD',
+    'CG',
+    'CK',
+    'CR',
+    'HR',
+    'CU',
+    'CW',
+    'CY',
+    'CZ',
+    'CI',
+    'DK',
+    'DJ',
+    'DM',
+    'DO',
+    'EC',
+    'EG',
+    'SV',
+    'GQ',
+    'ER',
+    'EE',
+    'SZ',
+    'ET',
+    'FK',
+    'FO',
+    'FJ',
+    'FI',
+    'FR',
+    'GF',
+    'PF',
+    'TF',
+    'GA',
+    'GM',
+    'GE',
+    'DE',
+    'GH',
+    'GI',
+    'GR',
+    'GL',
+    'GD',
+    'GP',
+    'GU',
+    'GT',
+    'GG',
+    'GN',
+    'GW',
+    'GY',
+    'HT',
+    'HM',
+    'VA',
+    'HN',
+    'HK',
+    'HU',
+    'IS',
+    'IN',
+    'ID',
+    'IR',
+    'IQ',
+    'IE',
+    'IM',
+    'IL',
+    'IT',
+    'JM',
+    'JP',
+    'JE',
+    'JO',
+    'KZ',
+    'KE',
+    'KI',
+    'KP',
+    'KR',
+    'KW',
+    'KG',
+    'LA',
+    'LV',
+    'LB',
+    'LS',
+    'LR',
+    'LY',
+    'LI',
+    'LT',
+    'LU',
+    'MO',
+    'MG',
+    'MW',
+    'MY',
+    'MV',
+    'ML',
+    'MT',
+    'MH',
+    'MQ',
+    'MR',
+    'MU',
+    'YT',
+    'MX',
+    'FM',
+    'MD',
+    'MC',
+    'MN',
+    'ME',
+    'MS',
+    'MA',
+    'MZ',
+    'MM',
+    'NA',
+    'NR',
+    'NP',
+    'NL',
+    'NC',
+    'NZ',
+    'NI',
+    'NE',
+    'NG',
+    'NU',
+    'NF',
+    'MK',
+    'MP',
+    'NO',
+    'OM',
+    'PK',
+    'PW',
+    'PS',
+    'PA',
+    'PG',
+    'PY',
+    'PE',
+    'PH',
+    'PN',
+    'PL',
+    'PT',
+    'PR',
+    'QA',
+    'RO',
+    'RU',
+    'RW',
+    'RE',
+    'BL',
+    'SH',
+    'KN',
+    'LC',
+    'MF',
+    'PM',
+    'VC',
+    'WS',
+    'SM',
+    'ST',
+    'SA',
+    'SN',
+    'RS',
+    'SC',
+    'SL',
+    'SG',
+    'SX',
+    'SK',
+    'SI',
+    'SB',
+    'SO',
+    'ZA',
+    'GS',
+    'SS',
+    'ES',
+    'LK',
+    'SD',
+    'SR',
+    'SJ',
+    'SE',
+    'CH',
+    'SY',
+    'TW',
+    'TJ',
+    'TZ',
+    'TH',
+    'TL',
+    'TG',
+    'TK',
+    'TO',
+    'TT',
+    'TN',
+    'TR',
+    'TM',
+    'TC',
+    'TV',
+    'UG',
+    'UA',
+    'AE',
+    'GB',
+    'UM',
+    'US',
+    'UY',
+    'UZ',
+    'VU',
+    'VE',
+    'VN',
+    'VG',
+    'VI',
+    'WF',
+    'EH',
+    'YE',
+    'ZM',
+    'ZW',
+    'AX',
+];

package/dist/vite/index.d.ts

@@ -0,0 +1 @@
+export { vendureDashboardPlugin } from './vite-plugin-vendure-dashboard.js';

package/dist/vite/index.js

@@ -0,0 +1 @@
+export { vendureDashboardPlugin } from './vite-plugin-vendure-dashboard.js';

package/dist/vite/types.d.ts

@@ -0,0 +1,79 @@
+export type Logger = {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    debug: (message: string) => void;
+    error: (message: string) => void;
+};
+export type PluginInfo = {
+    name: string;
+    pluginPath: string;
+    dashboardEntryPath: string | undefined;
+    /** The original source path of the plugin, only set for local plugins that are compiled */
+    sourcePluginPath?: string;
+};
+export type GetCompiledConfigPathFn = (params: {
+    inputRootDir: string;
+    outputPath: string;
+    configFileName: string;
+}) => string;
+export type TransformTsConfigPathMappingsFn = (params: {
+    phase: 'compiling' | 'loading';
+    alias: string;
+    patterns: string[];
+}) => string[];
+/**
+ * @description
+ * The PathAdapter interface allows customization of how paths are handled
+ * when compiling the Vendure config and its imports.
+ *
+ * It enables support for more complex repository structures, such as
+ * monorepos, where the Vendure server configuration file may not
+ * be located in the root directory of the project.
+ *
+ * If you get compilation errors like "Error loading Vendure config: Cannot find module",
+ * you probably need to provide a custom `pathAdapter` to resolve the paths correctly.
+ *
+ * This can take some trial-and-error. Try logging values from the functions to figure out
+ * the exact settings that you need for your repo setup.
+ *
+ * @example
+ * ```ts
+ * vendureDashboardPlugin({
+ *     pathAdapter: {
+ *         getCompiledConfigPath: ({ inputRootDir, outputPath, configFileName }) => {
+ *             const projectName = inputRootDir.split('/libs/')[1].split('/')[0];
+ *             const pathAfterProject = inputRootDir.split(`/libs/${projectName}`)[1];
+ *             const compiledConfigFilePath = `${outputPath}/${projectName}${pathAfterProject}`;
+ *             return path.join(compiledConfigFilePath, configFileName);
+ *         },
+ *         transformTsConfigPathMappings: ({ phase, patterns }) => {
+ *             // "loading" phase is when the compiled Vendure code is being loaded by
+ *             // the plugin, in order to introspect the configuration of your app.
+ *             if (phase === 'loading') {
+ *                 return patterns.map((p) =>
+ *                     p.replace('libs/', '').replace(/.ts$/, '.js'),
+ *                 );
+ *             }
+ *             return patterns;
+ *         },
+ *     },
+ *     // ...
+ * }),
+ * ```
+ *
+ * @docsCategory vite-plugin
+ * @docsPage vendureDashboardPlugin
+ * @since 3.4.0
+ */
+export interface PathAdapter {
+    /**
+     * @description
+     * A function to determine the path to the compiled Vendure config file.
+     */
+    getCompiledConfigPath?: GetCompiledConfigPathFn;
+    /**
+     * If your project makes use of the TypeScript `paths` configuration, the compiler will
+     * attempt to use these paths when compiling the Vendure config and its imports.
+     */
+    transformTsConfigPathMappings?: TransformTsConfigPathMappingsFn;
+}

package/dist/vite/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vite/utils/ast-utils.d.ts

@@ -0,0 +1,5 @@
+import ts from 'typescript';
+/**
+ * Given the AST of a TypeScript file, finds the name of the variable exported as VendureConfig.
+ */
+export declare function findConfigExport(sourceFile: ts.SourceFile): string | undefined;

package/dist/vite/utils/ast-utils.js

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+/**
+ * Given the AST of a TypeScript file, finds the name of the variable exported as VendureConfig.
+ */
+export function findConfigExport(sourceFile) {
+    let exportedSymbolName;
+    function visit(node) {
+        var _a;
+        if (ts.isVariableStatement(node) &&
+            ((_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.ExportKeyword))) {
+            node.declarationList.declarations.forEach(declaration => {
+                if (ts.isVariableDeclaration(declaration)) {
+                    const typeNode = declaration.type;
+                    if (typeNode && ts.isTypeReferenceNode(typeNode)) {
+                        const typeName = typeNode.typeName;
+                        if (ts.isIdentifier(typeName) && typeName.text === 'VendureConfig') {
+                            if (ts.isIdentifier(declaration.name)) {
+                                exportedSymbolName = declaration.name.text;
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return exportedSymbolName;
+}

package/dist/vite/utils/ast-utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vite/utils/ast-utils.spec.js

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+import { findConfigExport } from './ast-utils.js';
+describe('findConfigExport', () => {
+    it('should return undefined when no VendureConfig export is found', { timeout: 30000 }, () => {
+        const sourceText = `
+            export const notConfig = {
+                some: 'value'
+            };
+        `;
+        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
+        const result = findConfigExport(sourceFile);
+        expect(result).toBeUndefined();
+    });
+    it('should find exported variable with VendureConfig type', { timeout: 30000 }, () => {
+        const sourceText = `
+            import { VendureConfig } from '@vendure/core';
+
+            export const config: VendureConfig = {
+                authOptions: {
+                    tokenMethod: 'bearer'
+                }
+            };
+        `;
+        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
+        const result = findConfigExport(sourceFile);
+        expect(result).toBe('config');
+    });
+    it('should find exported variable with VendureConfig type among other exports', { timeout: 30000 }, () => {
+        const sourceText = `
+            import { VendureConfig } from '@vendure/core';
+
+            export const otherExport = 'value';
+            export const config: VendureConfig = {
+                authOptions: {
+                    tokenMethod: 'bearer'
+                }
+            };
+            export const anotherExport = 123;
+        `;
+        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
+        const result = findConfigExport(sourceFile);
+        expect(result).toBe('config');
+    });
+});

package/dist/vite/utils/compiler.d.ts

@@ -0,0 +1,23 @@
+import { VendureConfig } from '@vendure/core';
+import { Logger, PathAdapter, PluginInfo } from '../types.js';
+export interface PackageScannerConfig {
+    nodeModulesRoot?: string;
+}
+export interface CompilerOptions {
+    vendureConfigPath: string;
+    outputPath: string;
+    pathAdapter?: PathAdapter;
+    logger?: Logger;
+    pluginPackageScanner?: PackageScannerConfig;
+    module?: 'commonjs' | 'esm';
+}
+export interface CompileResult {
+    vendureConfig: VendureConfig;
+    exportedSymbolName: string;
+    pluginInfo: PluginInfo[];
+}
+/**
+ * Compiles TypeScript files and discovers Vendure plugins in both the compiled output
+ * and in node_modules.
+ */
+export declare function compile(options: CompilerOptions): Promise<CompileResult>;