@vendure/dashboard 3.3.8 → 3.4.0

package/dist/plugin/dashboard.plugin.js

@@ -0,0 +1,168 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var DashboardPlugin_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardPlugin = void 0;
+const core_1 = require("@vendure/core");
+const express_1 = __importDefault(require("express"));
+const express_rate_limit_1 = require("express-rate-limit");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const api_extensions_js_1 = require("./api/api-extensions.js");
+const metrics_resolver_js_1 = require("./api/metrics.resolver.js");
+const constants_js_1 = require("./constants.js");
+const metrics_service_js_1 = require("./service/metrics.service.js");
+/**
+ * @description
+ * This plugin serves the static files of the Vendure Dashboard and provides the
+ * GraphQL extensions needed for the order metrics on the dashboard index page.
+ *
+ * ## Installation
+ *
+ * `npm install \@vendure/dashboard`
+ *
+ * ## Usage
+ *
+ * First you need to set up compilation of the Dashboard, using the Vite configuration
+ * described in the [Dashboard Getting Started Guide](/guides/extending-the-dashboard/getting-started/)
+ *
+ * Once set up, you run `npx vite build` to build the production version of the dashboard app.
+ *
+ * The built app files will be output to the location specified by `build.outDir` in your Vite
+ * config file. This should then be passed to the `appDir` init option, as in the example below:
+ *
+ * @example
+ * ```ts
+ * import { DashboardPlugin } from '\@vendure/dashboard/plugin';
+ *
+ * const config: VendureConfig = {
+ *   // Add an instance of the plugin to the plugins array
+ *   plugins: [
+ *     DashboardPlugin.init({
+ *       route: 'dashboard',
+ *       appDir: './dist/dashboard',
+ *     }),
+ *   ],
+ * };
+ * ```
+ *
+ * ## Metrics
+ *
+ * This plugin defines a `metricSummary` query which is used by the Dashboard UI to
+ * display the order metrics on the dashboard.
+ *
+ * If you are building a stand-alone version of the Dashboard UI app, and therefore
+ * don't need this plugin to serve the Dashboard UI, you can still use the
+ * `metricSummary` query by adding the `DashboardPlugin` to the `plugins` array,
+ * but without calling the `init()` method:
+ *
+ * @example
+ * ```ts
+ * import { DashboardPlugin } from '\@vendure/dashboard-plugin';
+ *
+ * const config: VendureConfig = {
+ *   plugins: [
+ *     DashboardPlugin, // <-- no call to .init()
+ *   ],
+ *   // ...
+ * };
+ * ```
+ *
+ * @docsCategory core plugins/DashboardPlugin
+ */
+let DashboardPlugin = DashboardPlugin_1 = class DashboardPlugin {
+    constructor(processContext) {
+        this.processContext = processContext;
+    }
+    /**
+     * @description
+     * Set the plugin options
+     */
+    static init(options) {
+        this.options = options;
+        return DashboardPlugin_1;
+    }
+    configure(consumer) {
+        if (this.processContext.isWorker) {
+            return;
+        }
+        if (!DashboardPlugin_1.options) {
+            core_1.Logger.info(`DashboardPlugin's init() method was not called. The Dashboard UI will not be served.`, constants_js_1.loggerCtx);
+            return;
+        }
+        const { route, appDir } = DashboardPlugin_1.options;
+        const dashboardPath = appDir || this.getDashboardPath();
+        core_1.Logger.info('Creating dashboard middleware', constants_js_1.loggerCtx);
+        consumer.apply(this.createStaticServer(dashboardPath)).forRoutes(route);
+        (0, core_1.registerPluginStartupMessage)('Dashboard UI', route);
+    }
+    createStaticServer(dashboardPath) {
+        const limiter = (0, express_rate_limit_1.rateLimit)({
+            windowMs: 60 * 1000,
+            limit: process.env.NODE_ENV === 'production' ? 500 : 2000,
+            standardHeaders: true,
+            legacyHeaders: false,
+        });
+        const dashboardServer = express_1.default.Router();
+        // This is a workaround for a type mismatch between express v5 (Vendure core)
+        // and express v4 (several transitive dependencies). Can be removed once the
+        // ecosystem has more significantly shifted to v5.
+        dashboardServer.use(limiter);
+        dashboardServer.use(express_1.default.static(dashboardPath));
+        dashboardServer.use((req, res) => {
+            res.sendFile('index.html', { root: dashboardPath });
+        });
+        return dashboardServer;
+    }
+    getDashboardPath() {
+        // First, try to find the dashboard dist directory in the @vendure/dashboard package
+        try {
+            const dashboardPackageJson = require.resolve('@vendure/dashboard/package.json');
+            const dashboardPackageRoot = path_1.default.dirname(dashboardPackageJson);
+            const dashboardDistPath = path_1.default.join(dashboardPackageRoot, 'dist');
+            if (fs_extra_1.default.existsSync(dashboardDistPath)) {
+                core_1.Logger.info(`Found dashboard UI at ${dashboardDistPath}`, constants_js_1.loggerCtx);
+                return dashboardDistPath;
+            }
+        }
+        catch (e) {
+            // Dashboard package not found, continue to fallback
+        }
+        // Fallback to default path
+        core_1.Logger.warn(`Could not find @vendure/dashboard dist directory. Falling back to default path: ${constants_js_1.DEFAULT_APP_PATH}`, constants_js_1.loggerCtx);
+        return constants_js_1.DEFAULT_APP_PATH;
+    }
+};
+exports.DashboardPlugin = DashboardPlugin;
+exports.DashboardPlugin = DashboardPlugin = DashboardPlugin_1 = __decorate([
+    (0, core_1.VendurePlugin)({
+        imports: [core_1.PluginCommonModule],
+        adminApiExtensions: {
+            schema: api_extensions_js_1.adminApiExtensions,
+            resolvers: [metrics_resolver_js_1.MetricsResolver],
+        },
+        providers: [metrics_service_js_1.MetricsService],
+        configuration: config => {
+            config.settingsStoreFields['vendure.dashboard'] = [
+                {
+                    name: 'userSettings',
+                    scope: core_1.SettingsStoreScopes.user,
+                },
+            ];
+            return config;
+        },
+        compatibility: '^3.0.0',
+    }),
+    __metadata("design:paramtypes", [core_1.ProcessContext])
+], DashboardPlugin);

package/dist/plugin/index.d.ts

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

package/dist/plugin/index.js

@@ -1 +1,18 @@
-export { vendureDashboardPlugin } from './vite-plugin-vendure-dashboard.js';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dashboard.plugin.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist/plugin/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/plugin/service/metrics.service.d.ts

@@ -0,0 +1,15 @@
+import { CacheService, Order, RequestContext, TransactionalConnection } from '@vendure/core';
+import { MetricCalculation } from '../config/metrics-strategies.js';
+import { MetricInterval, MetricSummary, MetricSummaryInput } from '../types.js';
+export type MetricData = {
+    date: Date;
+    orders: Order[];
+};
+export declare class MetricsService {
+    private connection;
+    private cacheService;
+    metricCalculations: MetricCalculation[];
+    constructor(connection: TransactionalConnection, cacheService: CacheService);
+    getMetrics(ctx: RequestContext, { interval, types, refresh }: MetricSummaryInput): Promise<MetricSummary[]>;
+    loadData(ctx: RequestContext, interval: MetricInterval, endDate: Date): Promise<Map<number, MetricData>>;
+}

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

@@ -0,0 +1,145 @@
+"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 shared_utils_1 = require("@vendure/common/lib/shared-utils");
+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");
+const types_js_1 = require("../types.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, { interval, types, refresh }) {
+        // Set 23:59:59.999 as endDate
+        const endDate = (0, date_fns_1.endOfDay)(new Date());
+        // Check if we have cached result
+        const hash = (0, crypto_1.createHash)('sha1')
+            .update(JSON.stringify({
+            endDate,
+            types: types.sort(),
+            interval,
+            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 ${interval} metrics until ${endDate.toISOString()} for channel ${ctx.channel.token} for all orders`, constants_js_1.loggerCtx);
+        const data = await this.loadData(ctx, interval, endDate);
+        const metrics = [];
+        for (const type of types) {
+            const metric = this.metricCalculations.find(m => m.type === type);
+            if (!metric) {
+                continue;
+            }
+            // Calculate entry (month or week)
+            const entries = [];
+            data.forEach(dataPerTick => {
+                entries.push(metric.calculateEntry(ctx, interval, dataPerTick));
+            });
+            // Create metric with calculated entries
+            metrics.push({
+                interval,
+                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, interval, endDate) {
+        let nrOfEntries;
+        let backInTimeAmount;
+        const orderRepo = this.connection.getRepository(ctx, core_1.Order);
+        // What function to use to get the current Tick of a date (i.e. the week or month number)
+        let getTickNrFn;
+        let maxTick;
+        switch (interval) {
+            case types_js_1.MetricInterval.Daily: {
+                nrOfEntries = 30;
+                backInTimeAmount = { days: nrOfEntries };
+                getTickNrFn = date_fns_1.getDayOfYear;
+                maxTick = 365;
+                break;
+            }
+            default:
+                (0, shared_utils_1.assertNever)(interval);
+        }
+        const startDate = (0, date_fns_1.startOfDay)((0, date_fns_1.sub)(endDate, backInTimeAmount));
+        const startTick = getTickNrFn(startDate);
+        // 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(),
+            })
+                .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 ${interval} 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 ${interval} metrics`, constants_js_1.loggerCtx);
+        const dataPerInterval = new Map();
+        const ticks = [];
+        for (let i = 1; i <= nrOfEntries; i++) {
+            if (startTick + i >= maxTick) {
+                // make sure we don't go over month 12 or week 52
+                ticks.push(startTick + i - maxTick);
+            }
+            else {
+                ticks.push(startTick + i);
+            }
+        }
+        ticks.forEach(tick => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const ordersInCurrentTick = orders.filter(order => getTickNrFn(order.orderPlacedAt) === tick);
+            dataPerInterval.set(tick, {
+                orders: ordersInCurrentTick,
+                date: (0, date_fns_1.setDayOfYear)(endDate, tick),
+            });
+        });
+        return dataPerInterval;
+    }
+};
+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

@@ -1,40 +1,23 @@
-export type Logger = {
-    info: (message: string) => void;
-    warn: (message: string) => void;
-    debug: (message: string) => void;
-    error: (message: string) => void;
+export type MetricSummary = {
+    interval: MetricInterval;
+    type: MetricType;
+    title: string;
+    entries: MetricSummaryEntry[];
 };
-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 declare enum MetricType {
+    OrderCount = "OrderCount",
+    OrderTotal = "OrderTotal",
+    AverageOrderValue = "AverageOrderValue"
+}
+export declare enum MetricInterval {
+    Daily = "Daily"
+}
+export type MetricSummaryEntry = {
+    label: string;
+    value: number;
 };
-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.
- */
-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;
+export interface MetricSummaryInput {
+    interval: MetricInterval;
+    types: MetricType[];
+    refresh?: boolean;
 }

package/dist/plugin/types.js

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

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[];