fix(dashboard-plugin): Rename GraphQL types to avoid conflicts

- Rename all GraphQL types with 'Dashboard' prefix
- metricSummary -> dashboardMetricSummary
- MetricSummary -> DashboardMetricSummary
- MetricInterval -> DashboardMetricInterval
- MetricType -> DashboardMetricType
- MetricSummaryEntry -> DashboardMetricSummaryEntry
- MetricSummaryInput -> DashboardMetricSummaryInput

This allows both dashboard-plugin and admin-ui-plugin to run
simultaneously without GraphQL schema conflicts.

packages/dashboard-plugin/src/api/api-extensions.ts

@@ -1,33 +1,33 @@
 import gql from 'graphql-tag';
 
 export const adminApiExtensions = gql`
-    type MetricSummary {
-        interval: MetricInterval!
-        type: MetricType!
+    type DashboardMetricSummary {
+        interval: DashboardMetricInterval!
+        type: DashboardMetricType!
         title: String!
-        entries: [MetricSummaryEntry!]!
+        entries: [DashboardMetricSummaryEntry!]!
     }
-    enum MetricInterval {
+    enum DashboardMetricInterval {
         Daily
     }
-    enum MetricType {
+    enum DashboardMetricType {
         OrderCount
         OrderTotal
         AverageOrderValue
     }
-    type MetricSummaryEntry {
+    type DashboardMetricSummaryEntry {
         label: String!
         value: Float!
     }
-    input MetricSummaryInput {
-        interval: MetricInterval!
-        types: [MetricType!]!
+    input DashboardMetricSummaryInput {
+        interval: DashboardMetricInterval!
+        types: [DashboardMetricType!]!
         refresh: Boolean
     }
     extend type Query {
         """
-        Get metrics for the given interval and metric types.
+        Get dashboard metrics for the given interval and metric types.
         """
-        metricSummary(input: MetricSummaryInput): [MetricSummary!]!
+        dashboardMetricSummary(input: DashboardMetricSummaryInput): [DashboardMetricSummary!]!
     }
 `;

packages/dashboard-plugin/src/api/metrics.resolver.ts

@@ -2,7 +2,7 @@ import { Args, Query, Resolver } from '@nestjs/graphql';
 import { Allow, Ctx, Permission, RequestContext } from '@vendure/core';
 
 import { MetricsService } from '../service/metrics.service';
-import { MetricSummary, MetricSummaryInput } from '../types';
+import { DashboardMetricSummary, DashboardMetricSummaryInput } from '../types';
 
 @Resolver()
 export class MetricsResolver {
@@ -10,10 +10,10 @@ export class MetricsResolver {
 
     @Query()
     @Allow(Permission.ReadOrder)
-    async metricSummary(
+    async dashboardMetricSummary(
         @Ctx() ctx: RequestContext,
-        @Args('input') input: MetricSummaryInput,
-    ): Promise<MetricSummary[]> {
+        @Args('input') input: DashboardMetricSummaryInput,
+    ): Promise<DashboardMetricSummary[]> {
         return this.service.getMetrics(ctx, input);
     }
 }

packages/dashboard-plugin/src/config/metrics-strategies.ts

@@ -1,7 +1,7 @@
 import { RequestContext } from '@vendure/core';
 
 import { MetricData } from '../service/metrics.service';
-import { MetricInterval, MetricSummaryEntry, MetricType } from '../types';
+import { DashboardMetricInterval, DashboardMetricSummaryEntry, DashboardMetricType } from '../types';
 
 /**
  * Calculate your metric data based on the given input.
@@ -10,11 +10,15 @@ import { MetricInterval, MetricSummaryEntry, MetricType } from '../types';
  *
  */
 export interface MetricCalculation {
-    type: MetricType;
+    type: DashboardMetricType;
 
     getTitle(ctx: RequestContext): string;
 
-    calculateEntry(ctx: RequestContext, interval: MetricInterval, data: MetricData): MetricSummaryEntry;
+    calculateEntry(
+        ctx: RequestContext,
+        interval: DashboardMetricInterval,
+        data: MetricData,
+    ): DashboardMetricSummaryEntry;
 }
 
 export function getMonthName(monthNr: number): string {
@@ -26,13 +30,17 @@ export function getMonthName(monthNr: number): string {
  * Calculates the average order value per month/week
  */
 export class AverageOrderValueMetric implements MetricCalculation {
-    readonly type = MetricType.AverageOrderValue;
+    readonly type = DashboardMetricType.AverageOrderValue;
 
     getTitle(ctx: RequestContext): string {
         return 'average-order-value';
     }
 
-    calculateEntry(ctx: RequestContext, interval: MetricInterval, data: MetricData): MetricSummaryEntry {
+    calculateEntry(
+        ctx: RequestContext,
+        interval: DashboardMetricInterval,
+        data: MetricData,
+    ): DashboardMetricSummaryEntry {
         const label = data.date.toISOString();
         if (!data.orders.length) {
             return {
@@ -53,13 +61,17 @@ export class AverageOrderValueMetric implements MetricCalculation {
  * Calculates number of orders
  */
 export class OrderCountMetric implements MetricCalculation {
-    readonly type = MetricType.OrderCount;
+    readonly type = DashboardMetricType.OrderCount;
 
     getTitle(ctx: RequestContext): string {
         return 'order-count';
     }
 
-    calculateEntry(ctx: RequestContext, interval: MetricInterval, data: MetricData): MetricSummaryEntry {
+    calculateEntry(
+        ctx: RequestContext,
+        interval: DashboardMetricInterval,
+        data: MetricData,
+    ): DashboardMetricSummaryEntry {
         const label = data.date.toISOString();
         return {
             label,
@@ -71,13 +83,17 @@ export class OrderCountMetric implements MetricCalculation {
  * Calculates order total
  */
 export class OrderTotalMetric implements MetricCalculation {
-    readonly type = MetricType.OrderTotal;
+    readonly type = DashboardMetricType.OrderTotal;
 
     getTitle(ctx: RequestContext): string {
         return 'order-totals';
     }
 
-    calculateEntry(ctx: RequestContext, interval: MetricInterval, data: MetricData): MetricSummaryEntry {
+    calculateEntry(
+        ctx: RequestContext,
+        interval: DashboardMetricInterval,
+        data: MetricData,
+    ): DashboardMetricSummaryEntry {
         const label = data.date.toISOString();
         return {
             label,

packages/dashboard-plugin/src/service/metrics.service.ts

@@ -20,7 +20,12 @@ import {
     OrderTotalMetric,
 } from '../config/metrics-strategies';
 import { loggerCtx } from '../constants';
-import { MetricInterval, MetricSummary, MetricSummaryEntry, MetricSummaryInput } from '../types';
+import {
+    DashboardMetricInterval,
+    DashboardMetricSummary,
+    DashboardMetricSummaryEntry,
+    DashboardMetricSummaryInput,
+} from '../types';
 
 export type MetricData = {
     date: Date;
@@ -44,8 +49,8 @@ export class MetricsService {
 
     async getMetrics(
         ctx: RequestContext,
-        { interval, types, refresh }: MetricSummaryInput,
-    ): Promise<MetricSummary[]> {
+        { interval, types, refresh }: DashboardMetricSummaryInput,
+    ): Promise<DashboardMetricSummary[]> {
         // Set 23:59:59.999 as endDate
         const endDate = endOfDay(new Date());
         // Check if we have cached result
@@ -60,7 +65,7 @@ export class MetricsService {
             )
             .digest('base64');
         const cacheKey = `MetricsService:${hash}`;
-        const cachedMetricList = await this.cacheService.get<MetricSummary[]>(cacheKey);
+        const cachedMetricList = await this.cacheService.get<DashboardMetricSummary[]>(cacheKey);
         if (cachedMetricList && refresh !== true) {
             Logger.verbose(`Returning cached metrics for channel ${ctx.channel.token}`, loggerCtx);
             return cachedMetricList;
@@ -73,14 +78,14 @@ export class MetricsService {
             loggerCtx,
         );
         const data = await this.loadData(ctx, interval, endDate);
-        const metrics: MetricSummary[] = [];
+        const metrics: DashboardMetricSummary[] = [];
         for (const type of types) {
             const metric = this.metricCalculations.find(m => m.type === type);
             if (!metric) {
                 continue;
             }
             // Calculate entry (month or week)
-            const entries: MetricSummaryEntry[] = [];
+            const entries: DashboardMetricSummaryEntry[] = [];
             data.forEach(dataPerTick => {
                 entries.push(metric.calculateEntry(ctx, interval, dataPerTick));
             });
@@ -98,7 +103,7 @@ export class MetricsService {
 
     async loadData(
         ctx: RequestContext,
-        interval: MetricInterval,
+        interval: DashboardMetricInterval,
         endDate: Date,
     ): Promise<Map<number, MetricData>> {
         let nrOfEntries: number;
@@ -108,7 +113,7 @@ export class MetricsService {
         let getTickNrFn: typeof getMonth | typeof getISOWeek;
         let maxTick: number;
         switch (interval) {
-            case MetricInterval.Daily: {
+            case DashboardMetricInterval.Daily: {
                 nrOfEntries = 30;
                 backInTimeAmount = { days: nrOfEntries };
                 getTickNrFn = getDayOfYear;

packages/dashboard-plugin/src/types.ts

@@ -1,27 +1,27 @@
-export type MetricSummary = {
-    interval: MetricInterval;
-    type: MetricType;
+export type DashboardMetricSummary = {
+    interval: DashboardMetricInterval;
+    type: DashboardMetricType;
     title: string;
-    entries: MetricSummaryEntry[];
+    entries: DashboardMetricSummaryEntry[];
 };
 
-export enum MetricType {
+export enum DashboardMetricType {
     OrderCount = 'OrderCount',
     OrderTotal = 'OrderTotal',
     AverageOrderValue = 'AverageOrderValue',
 }
 
-export enum MetricInterval {
+export enum DashboardMetricInterval {
     Daily = 'Daily',
 }
 
-export type MetricSummaryEntry = {
+export type DashboardMetricSummaryEntry = {
     label: string;
     value: number;
 };
 
-export interface MetricSummaryInput {
-    interval: MetricInterval;
-    types: MetricType[];
+export interface DashboardMetricSummaryInput {
+    interval: DashboardMetricInterval;
+    types: DashboardMetricType[];
     refresh?: boolean;
 }