@lightdash/common 0.1478.7 → 0.1479.0

package/dist/index.d.ts

@@ -135,6 +135,7 @@ export * from './utils/additionalMetrics';
 export * from './utils/api';
 export { default as assertUnreachable } from './utils/assertUnreachable';
 export * from './utils/catalogMetricsTree';
+export * from './utils/charts';
 export * from './utils/conditionalFormatting';
 export * from './utils/convertToDbt';
 export * from './utils/dashboard';
@@ -564,3 +565,4 @@ export declare function formatRows(rows: {
 export declare const removeEmptyProperties: (object: Record<string, AnyType>) => Record<string, any>;
 export declare const deepEqual: (object1: Record<string, AnyType>, object2: Record<string, AnyType>) => boolean;
 export declare const getProjectDirectory: (dbtConnection?: DbtProjectConfig) => string | undefined;
+export declare function isNotNull<T>(arg: T): arg is Exclude<T, null>;

package/dist/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectDirectory = exports.deepEqual = exports.removeEmptyProperties = exports.formatRows = exports.itemsInMetricQuery = exports.getTableCalculationsFromItemsMap = exports.getMetricsFromItemsMap = exports.getFilterableDimensionsFromItemsMap = exports.getDimensionsFromItemsMap = exports.getItemMap = exports.getFieldMap = exports.getAxisName = exports.getDateGroupLabel = exports.getResultValueArray = exports.DbtProjectTypeLabels = exports.sensitiveDbtCredentialsFieldNames = exports.DBFieldTypes = exports.LightdashInstallType = exports.isLightdashMode = exports.LightdashMode = exports.isApiError = exports.hasInviteCode = exports.TableSelectionType = exports.hasSpecialCharacters = exports.snakeCaseName = exports.findFieldByIdInExplore = exports.getVisibleFields = exports.SEED_GROUP = exports.SEED_SPACE = exports.SEED_PROJECT = exports.SEED_EMBED_SECRET = exports.SEED_ORG_2_ADMIN_PASSWORD = exports.SEED_ORG_2_ADMIN_EMAIL = exports.SEED_ORG_2_ADMIN = exports.SEED_ORG_2 = exports.SEED_ORG_1_ADMIN_PASSWORD = exports.SEED_ORG_1_ADMIN_EMAIL = exports.SEED_ORG_1_ADMIN = exports.SEED_ORG_1 = exports.hexToRGB = exports.replaceStringInArray = exports.toggleArrayValue = exports.hasIntersection = exports.validatePassword = exports.getPasswordSchema = exports.getEmailSchema = exports.validateEmail = exports.assertUnreachable = exports.lightdashProjectConfigSchema = exports.lightdashDbtYamlSchema = void 0;
+exports.isNotNull = void 0;
 const tslib_1 = require("tslib");
 const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
 const utc_1 = tslib_1.__importDefault(require("dayjs/plugin/utc"));
@@ -103,6 +104,7 @@ tslib_1.__exportStar(require("./utils/api"), exports);
 var assertUnreachable_1 = require("./utils/assertUnreachable");
 Object.defineProperty(exports, "assertUnreachable", { enumerable: true, get: function () { return tslib_1.__importDefault(assertUnreachable_1).default; } });
 tslib_1.__exportStar(require("./utils/catalogMetricsTree"), exports);
+tslib_1.__exportStar(require("./utils/charts"), exports);
 tslib_1.__exportStar(require("./utils/conditionalFormatting"), exports);
 tslib_1.__exportStar(require("./utils/convertToDbt"), exports);
 tslib_1.__exportStar(require("./utils/dashboard"), exports);
@@ -497,3 +499,7 @@ const getProjectDirectory = (dbtConnection) => {
     }
 };
 exports.getProjectDirectory = getProjectDirectory;
+function isNotNull(arg) {
+    return arg !== null;
+}
+exports.isNotNull = isNotNull;

package/dist/types/featureFlags.d.ts

@@ -23,7 +23,11 @@ export declare enum FeatureFlags {
     /**
      * Enable dashboard comments
      */
-    DashboardComments = "dashboard-comments-enabled"
+    DashboardComments = "dashboard-comments-enabled",
+    /**
+     * Enable scheduler task that replaces custom metrics after project compile
+     */
+    ReplaceCustomMetricsOnCompile = "replace-custom-metrics-on-compile"
 }
 export type FeatureFlag = {
     id: string;

package/dist/types/featureFlags.js

@@ -33,4 +33,8 @@ var FeatureFlags;
      * Enable dashboard comments
      */
     FeatureFlags["DashboardComments"] = "dashboard-comments-enabled";
+    /**
+     * Enable scheduler task that replaces custom metrics after project compile
+     */
+    FeatureFlags["ReplaceCustomMetricsOnCompile"] = "replace-custom-metrics-on-compile";
 })(FeatureFlags = exports.FeatureFlags || (exports.FeatureFlags = {}));

package/dist/types/savedCharts.d.ts

@@ -1,7 +1,7 @@
 import { type ViewStatistics } from './analytics';
 import { type ConditionalFormattingConfig } from './conditionalFormatting';
 import { type ChartSourceType } from './content';
-import { type CompactOrAlias } from './field';
+import { type CompactOrAlias, type FieldId } from './field';
 import { type MetricQuery, type MetricQueryRequest } from './metricQuery';
 import { type SpaceShare } from './space';
 import { type LightdashUser, type UpdatedByUser } from './user';
@@ -197,6 +197,7 @@ export type Series = {
     showSymbol?: boolean;
     smooth?: boolean;
     markLine?: MarkLine;
+    isFilteredOut?: boolean;
 };
 export type EchartsLegend = {
     show?: boolean;
@@ -381,4 +382,44 @@ export type ApiCalculateTotalResponse = {
     status: 'ok';
     results: Record<string, number>;
 };
+export type ReplaceableFieldMatchMap = {
+    [fieldId: string]: {
+        fieldId: string;
+        label: string;
+        match: {
+            fieldId: FieldId;
+            fieldLabel: string;
+        } | null;
+        suggestedMatches: Array<{
+            fieldId: FieldId;
+            fieldLabel: string;
+        }>;
+    };
+};
+export type ReplaceableCustomFields = {
+    [chartUuid: string]: {
+        uuid: string;
+        label: string;
+        customMetrics: ReplaceableFieldMatchMap;
+    };
+};
+export type ReplaceCustomFields = {
+    [chartUuid: string]: {
+        customMetrics: {
+            [customMetricId: string]: {
+                replaceWithFieldId: string;
+            };
+        };
+    };
+};
+export type SkippedReplaceCustomFields = {
+    [chartUuid: string]: {
+        customMetrics: {
+            [customMetricId: string]: {
+                replaceWithFieldId: string;
+                reason: string;
+            };
+        };
+    };
+};
 export {};

package/dist/types/scheduler.d.ts

@@ -35,8 +35,9 @@ export declare enum JobPriority {
     MEDIUM = 1,
     LOW = 2
 }
+export declare const ReplaceCustomFieldsTask: "replaceCustomFields";
 export type SchedulerLog = {
-    task: 'handleScheduledDelivery' | 'sendEmailNotification' | 'sendSlackNotification' | 'uploadGsheets' | 'downloadCsv' | 'uploadGsheetFromQuery' | 'createProjectWithCompile' | 'compileProject' | 'testAndCompileProject' | 'validateProject' | 'sqlRunner' | 'sqlRunnerPivotQuery' | 'semanticLayer' | 'indexCatalog';
+    task: 'handleScheduledDelivery' | 'sendEmailNotification' | 'sendSlackNotification' | 'uploadGsheets' | 'downloadCsv' | 'uploadGsheetFromQuery' | 'createProjectWithCompile' | 'compileProject' | 'testAndCompileProject' | 'validateProject' | 'sqlRunner' | 'sqlRunnerPivotQuery' | 'semanticLayer' | typeof ReplaceCustomFieldsTask | 'indexCatalog';
     schedulerUuid?: string;
     jobId: string;
     jobGroup?: string;
@@ -267,6 +268,11 @@ export type CompileProjectPayload = {
     jobUuid: string;
     isPreview: boolean;
 };
+export type ReplaceCustomFieldsPayload = {
+    createdByUserUuid: string;
+    organizationUuid: string;
+    projectUuid: string;
+};
 export type ValidateProjectPayload = {
     projectUuid: string;
     context: 'lightdash_app' | 'dbt_refresh' | 'test_and_compile' | 'cli';

package/dist/types/scheduler.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LightdashPage = exports.getSchedulerUuid = exports.hasSchedulerUuid = exports.isCreateScheduler = exports.isSchedulerGsheetsOptions = exports.isSchedulerImageOptions = exports.isSchedulerCsvOptions = exports.isCreateSchedulerSlackTarget = exports.isEmailTarget = exports.isSlackTarget = exports.isChartScheduler = exports.isUpdateSchedulerEmailTarget = exports.isUpdateSchedulerSlackTarget = exports.getSchedulerTargetUuid = exports.isDashboardScheduler = exports.operatorActionValue = exports.NotificationFrequency = exports.ThresholdOperator = exports.JobPriority = exports.SchedulerFormat = exports.SchedulerJobStatus = void 0;
+exports.LightdashPage = exports.getSchedulerUuid = exports.hasSchedulerUuid = exports.isCreateScheduler = exports.isSchedulerGsheetsOptions = exports.isSchedulerImageOptions = exports.isSchedulerCsvOptions = exports.isCreateSchedulerSlackTarget = exports.isEmailTarget = exports.isSlackTarget = exports.isChartScheduler = exports.isUpdateSchedulerEmailTarget = exports.isUpdateSchedulerSlackTarget = exports.getSchedulerTargetUuid = exports.isDashboardScheduler = exports.operatorActionValue = exports.NotificationFrequency = exports.ThresholdOperator = exports.ReplaceCustomFieldsTask = exports.JobPriority = exports.SchedulerFormat = exports.SchedulerJobStatus = void 0;
 const tslib_1 = require("tslib");
 const assertUnreachable_1 = tslib_1.__importDefault(require("../utils/assertUnreachable"));
 var SchedulerJobStatus;
@@ -22,6 +22,7 @@ var JobPriority;
     JobPriority[JobPriority["MEDIUM"] = 1] = "MEDIUM";
     JobPriority[JobPriority["LOW"] = 2] = "LOW";
 })(JobPriority = exports.JobPriority || (exports.JobPriority = {}));
+exports.ReplaceCustomFieldsTask = 'replaceCustomFields';
 var ThresholdOperator;
 (function (ThresholdOperator) {
     ThresholdOperator["GREATER_THAN"] = "greaterThan";

package/dist/utils/charts.d.ts

@@ -0,0 +1,9 @@
+import { type CreateSavedChartVersion, type ReplaceCustomFields, type SkippedReplaceCustomFields } from '../types/savedCharts';
+export declare function maybeReplaceFieldsInChartVersion({ fieldsToReplace, chartVersion, }: {
+    fieldsToReplace: ReplaceCustomFields[string];
+    chartVersion: CreateSavedChartVersion;
+}): {
+    hasChanges: boolean;
+    chartVersion: CreateSavedChartVersion;
+    skippedFields: SkippedReplaceCustomFields[string];
+};

package/dist/utils/charts.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeReplaceFieldsInChartVersion = void 0;
+const item_1 = require("./item");
+function maybeReplaceFieldsInChartVersion({ fieldsToReplace, chartVersion, }) {
+    let hasChanges = false;
+    const skippedFields = {
+        customMetrics: {},
+    };
+    const newChartData = { ...chartVersion };
+    // Replace custom metrics
+    const customMetricsToReplace = Object.entries(fieldsToReplace.customMetrics);
+    customMetricsToReplace.forEach(([customMetricToReplace, replaceWith]) => {
+        if (customMetricToReplace === replaceWith.replaceWithFieldId) {
+            const foundCustomMetric = !!chartVersion.metricQuery.additionalMetrics?.find((additionalMetric) => (0, item_1.getItemId)(additionalMetric) === customMetricToReplace);
+            if (foundCustomMetric) {
+                hasChanges = true;
+                // remove custom metric
+                newChartData.metricQuery.additionalMetrics =
+                    newChartData.metricQuery.additionalMetrics?.filter((additionalMetric) => (0, item_1.getItemId)(additionalMetric) !==
+                        customMetricToReplace);
+            }
+            else {
+                skippedFields.customMetrics[customMetricToReplace] = {
+                    reason: `Custom metric ${customMetricToReplace} not found in chart version.`,
+                    replaceWithFieldId: replaceWith.replaceWithFieldId,
+                };
+            }
+        }
+        else {
+            skippedFields.customMetrics[customMetricToReplace] = {
+                reason: 'Replacing custom metrics with a metric with a different ID is not supported yet.',
+                replaceWithFieldId: replaceWith.replaceWithFieldId,
+            };
+        }
+    });
+    return {
+        hasChanges,
+        skippedFields,
+        chartVersion: newChartData || chartVersion,
+    };
+}
+exports.maybeReplaceFieldsInChartVersion = maybeReplaceFieldsInChartVersion;

package/dist/utils/fields.d.ts

@@ -1,7 +1,20 @@
 import { type Explore } from '../types/explore';
-import { type CompiledDimension, type CompiledField, type CompiledMetric, type ItemsMap } from '../types/field';
-import { type MetricQuery } from '../types/metricQuery';
+import { type CompiledDimension, type CompiledField, type CompiledMetric, type ItemsMap, type Metric } from '../types/field';
+import { type AdditionalMetric, type MetricQuery } from '../types/metricQuery';
+import { type ReplaceableCustomFields, type ReplaceableFieldMatchMap, type ReplaceCustomFields } from '../types/savedCharts';
 export declare const getDimensions: (explore: Explore) => CompiledDimension[];
 export declare const getMetrics: (explore: Explore) => CompiledMetric[];
 export declare const getFields: (explore: Explore) => CompiledField[];
 export declare const getFieldsFromMetricQuery: (metricQuery: MetricQuery, explore: Explore) => ItemsMap;
+export declare function compareMetricAndCustomMetric({ metric, customMetric, }: {
+    metric: Metric;
+    customMetric: AdditionalMetric;
+}): {
+    isExactMatch: boolean;
+    isSuggestedMatch: boolean;
+};
+export declare function findReplaceableCustomMetrics({ customMetrics, metrics, }: {
+    customMetrics: AdditionalMetric[];
+    metrics: Metric[];
+}): ReplaceableFieldMatchMap;
+export declare function convertReplaceableFieldMatchMapToReplaceCustomFields(replaceableCustomFields: ReplaceableCustomFields): ReplaceCustomFields;

package/dist/utils/fields.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFieldsFromMetricQuery = exports.getFields = exports.getMetrics = exports.getDimensions = void 0;
+exports.convertReplaceableFieldMatchMapToReplaceCustomFields = exports.findReplaceableCustomMetrics = exports.compareMetricAndCustomMetric = exports.getFieldsFromMetricQuery = exports.getFields = exports.getMetrics = exports.getDimensions = void 0;
 const additionalMetrics_1 = require("./additionalMetrics");
 const item_1 = require("./item");
 // Helper function to get a list of all dimensions in an explore
@@ -54,3 +54,125 @@ const getFieldsFromMetricQuery = (metricQuery, explore) => {
     };
 };
 exports.getFieldsFromMetricQuery = getFieldsFromMetricQuery;
+function compareMetricAndCustomMetric({ metric, customMetric, }) {
+    const conditions = {
+        fieldIdMatch: {
+            isMatch: (0, item_1.getItemId)(metric) === (0, item_1.getItemId)(customMetric),
+            requiredForSuggestion: false,
+        },
+        labelMatch: {
+            isMatch: metric.label === customMetric.label,
+            requiredForSuggestion: false,
+        },
+        sqlMatch: {
+            isMatch: metric.sql === customMetric.sql,
+            requiredForSuggestion: true,
+        },
+        baseDimensionMatch: {
+            isMatch: metric.dimensionReference ===
+                `${customMetric.table}_${customMetric.baseDimensionName}`,
+            requiredForSuggestion: true,
+        },
+        metricTypeMatch: {
+            isMatch: metric.type === customMetric.type,
+            requiredForSuggestion: true,
+        },
+        formatMatch: {
+            // NOTE: We don't support format matching yet. Only match if both are undefined/null
+            isMatch: !metric.formatOptions &&
+                !metric.format &&
+                (!customMetric.formatOptions ||
+                    customMetric.formatOptions.type === 'default') &&
+                !customMetric.format,
+            requiredForSuggestion: true,
+        },
+        percentileMatch: {
+            // NOTE: We don't support percentile matching yet. Only match if both are undefined/null
+            isMatch: !metric.percentile && !customMetric.percentile,
+            requiredForSuggestion: true,
+        },
+        filtersMatch: {
+            isMatch: (customMetric.filters || []).length ===
+                (metric.filters || []).length &&
+                (metric.filters || []).every((filter) => customMetric.filters?.find((customFilter) => {
+                    const fieldRefMatch = customFilter.target.fieldRef ===
+                        filter.target.fieldRef;
+                    const operatorMatch = customFilter.operator === filter.operator;
+                    const valuesMatch = customFilter.values === filter.values ||
+                        customFilter.values?.every((value) => filter.values?.includes(value));
+                    return fieldRefMatch && operatorMatch && valuesMatch;
+                })),
+            requiredForSuggestion: true,
+        },
+    };
+    const isExactMatch = Object.values(conditions).every((condition) => condition.isMatch);
+    const isSuggestedMatch = Object.values(conditions)
+        .filter((condition) => condition.requiredForSuggestion)
+        .every((condition) => condition.isMatch);
+    return {
+        isExactMatch,
+        isSuggestedMatch,
+    };
+}
+exports.compareMetricAndCustomMetric = compareMetricAndCustomMetric;
+function findReplaceableCustomMetrics({ customMetrics, metrics, }) {
+    return customMetrics.reduce((acc, customMetric) => {
+        let match = null;
+        const suggestedMatches = [];
+        metrics.forEach((metric) => {
+            const fieldId = (0, item_1.getItemId)(metric);
+            const fieldLabel = metric.label;
+            const { isExactMatch, isSuggestedMatch } = compareMetricAndCustomMetric({
+                metric,
+                customMetric,
+            });
+            if (isExactMatch) {
+                match = {
+                    fieldId,
+                    fieldLabel,
+                };
+            }
+            else if (isSuggestedMatch) {
+                suggestedMatches.push({
+                    fieldId,
+                    fieldLabel,
+                });
+            }
+        });
+        if (match !== null || suggestedMatches.length > 0) {
+            return {
+                ...acc,
+                [(0, item_1.getItemId)(customMetric)]: {
+                    fieldId: customMetric.name,
+                    label: customMetric.label || customMetric.name,
+                    match,
+                    suggestedMatches,
+                },
+            };
+        }
+        return acc;
+    }, {});
+}
+exports.findReplaceableCustomMetrics = findReplaceableCustomMetrics;
+function convertReplaceableFieldMatchMapToReplaceCustomFields(replaceableCustomFields) {
+    return Object.entries(replaceableCustomFields).reduce((acc, [chartUuid, customFields]) => {
+        const customMetrics = Object.entries(customFields.customMetrics).reduce((acc2, [customFieldId, customField]) => {
+            if (customField.match) {
+                return {
+                    ...acc2,
+                    [customFieldId]: {
+                        replaceWithFieldId: customField.match.fieldId,
+                    },
+                };
+            }
+            return acc2;
+        }, {});
+        if (Object.keys(customMetrics).length > 0) {
+            acc[chartUuid] = {
+                customMetrics,
+            };
+        }
+        return acc;
+    }, {});
+}
+exports.convertReplaceableFieldMatchMapToReplaceCustomFields = convertReplaceableFieldMatchMapToReplaceCustomFields;

package/dist/utils/fields.mock.d.ts

@@ -1,5 +1,12 @@
-import { type Explore, type MetricQuery } from '../index';
+import { FilterOperator, type AdditionalMetric, type Explore, type Metric, type MetricFilterRule, type MetricQuery } from '../index';
 export declare const metricQuery: MetricQuery;
 export declare const explore: Explore;
 export declare const emptyExplore: Explore;
 export declare const emptyMetricQuery: MetricQuery;
+export declare const customMetric: AdditionalMetric;
+export declare const metric: Metric;
+export declare const metricFilterRule: (args?: {
+    fieldRef?: string;
+    values?: unknown[];
+    operator?: FilterOperator;
+}) => MetricFilterRule;

package/dist/utils/fields.mock.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.emptyMetricQuery = exports.emptyExplore = exports.explore = exports.metricQuery = void 0;
+exports.metricFilterRule = exports.metric = exports.customMetric = exports.emptyMetricQuery = exports.emptyExplore = exports.explore = exports.metricQuery = void 0;
 const index_1 = require("../index");
 exports.metricQuery = {
     exploreName: 'table1',
@@ -123,3 +123,32 @@ exports.emptyMetricQuery = {
     limit: 500,
     tableCalculations: [],
 };
+exports.customMetric = {
+    type: index_1.MetricType.AVERAGE,
+    sql: '${TABLE}.dim1',
+    table: 'a',
+    name: 'average_dim1',
+    label: 'Average dim1',
+    baseDimensionName: 'dim1',
+};
+exports.metric = {
+    fieldType: index_1.FieldType.METRIC,
+    type: index_1.MetricType.AVERAGE,
+    name: 'average_dim1',
+    label: 'Average dim1',
+    table: 'a',
+    tableLabel: 'a',
+    sql: '${TABLE}.dim1',
+    isAutoGenerated: false,
+    hidden: false,
+    dimensionReference: 'a_dim1',
+};
+const metricFilterRule = (args) => ({
+    id: 'uuid',
+    operator: args?.operator || index_1.FilterOperator.GREATER_THAN_OR_EQUAL,
+    target: {
+        fieldRef: args?.fieldRef || 'a_dim1',
+    },
+    values: args?.values || [14],
+});
+exports.metricFilterRule = metricFilterRule;

package/dist/utils/fields.test.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const field_1 = require("../types/field");
+const filter_1 = require("../types/filter");
 const fields_1 = require("./fields");
 const fields_mock_1 = require("./fields.mock");
 describe('getFieldsFromMetricQuery', () => {
@@ -42,3 +43,133 @@ describe('getFieldsFromMetricQuery', () => {
         ]);
     });
 });
+describe('compareMetricAndCustomMetric', () => {
+    test('should return exact match for simple custom metric', async () => {
+        const result = (0, fields_1.compareMetricAndCustomMetric)({
+            customMetric: fields_mock_1.customMetric,
+            metric: fields_mock_1.metric,
+        });
+        expect(result.isExactMatch).toEqual(true);
+        expect(result.isSuggestedMatch).toEqual(true);
+    });
+    const mismatchButSuggestCases = [
+        ['name', 'diff_name'],
+        ['label', 'diff label'],
+    ];
+    test.each(mismatchButSuggestCases)('should not match but suggest when %s has different value', (key, value) => {
+        const result = (0, fields_1.compareMetricAndCustomMetric)({
+            customMetric: {
+                ...fields_mock_1.customMetric,
+                [key]: value,
+            },
+            metric: fields_mock_1.metric,
+        });
+        expect(result.isExactMatch).toEqual(false);
+        expect(result.isSuggestedMatch).toEqual(true);
+    });
+    const mismatchCases = [
+        ['sql', 'diff_sql'],
+        ['baseDimensionName', 'diff_baseDimensionName'],
+        ['table', 'diff_table'],
+        ['type', 'max'],
+    ];
+    test.each(mismatchCases)('should not match or suggest when %s has different value', (key, value) => {
+        const result = (0, fields_1.compareMetricAndCustomMetric)({
+            customMetric: {
+                ...fields_mock_1.customMetric,
+                [key]: value,
+            },
+            metric: fields_mock_1.metric,
+        });
+        expect(result.isExactMatch).toEqual(false);
+        expect(result.isSuggestedMatch).toEqual(false);
+    });
+    test('should return exact match with multiple filters', async () => {
+        const filters = [
+            (0, fields_mock_1.metricFilterRule)(),
+            (0, fields_mock_1.metricFilterRule)({
+                fieldRef: 'b_dim2',
+                values: ['2', '4'],
+                operator: filter_1.FilterOperator.IN_BETWEEN,
+            }),
+        ];
+        const result = (0, fields_1.compareMetricAndCustomMetric)({
+            customMetric: {
+                ...fields_mock_1.customMetric,
+                filters,
+            },
+            metric: {
+                ...fields_mock_1.metric,
+                filters,
+            },
+        });
+        expect(result.isExactMatch).toEqual(true);
+        expect(result.isSuggestedMatch).toEqual(true);
+    });
+    test('should not match or suggest when filter has different value', async () => {
+        // Different filters length
+        const result = (0, fields_1.compareMetricAndCustomMetric)({
+            customMetric: {
+                ...fields_mock_1.customMetric,
+                filters: [(0, fields_mock_1.metricFilterRule)(), (0, fields_mock_1.metricFilterRule)()],
+            },
+            metric: {
+                ...fields_mock_1.metric,
+                filters: [(0, fields_mock_1.metricFilterRule)()],
+            },
+        });
+        expect(result.isExactMatch).toEqual(false);
+        expect(result.isSuggestedMatch).toEqual(false);
+        // Different operator
+        const result2 = (0, fields_1.compareMetricAndCustomMetric)({
+            customMetric: {
+                ...fields_mock_1.customMetric,
+                filters: [(0, fields_mock_1.metricFilterRule)()],
+            },
+            metric: {
+                ...fields_mock_1.metric,
+                filters: [
+                    (0, fields_mock_1.metricFilterRule)({
+                        operator: filter_1.FilterOperator.NOT_EQUALS,
+                    }),
+                ],
+            },
+        });
+        expect(result2.isExactMatch).toEqual(false);
+        expect(result2.isSuggestedMatch).toEqual(false);
+        // Different values
+        const result3 = (0, fields_1.compareMetricAndCustomMetric)({
+            customMetric: {
+                ...fields_mock_1.customMetric,
+                filters: [(0, fields_mock_1.metricFilterRule)()],
+            },
+            metric: {
+                ...fields_mock_1.metric,
+                filters: [
+                    (0, fields_mock_1.metricFilterRule)({
+                        values: ['2'],
+                    }),
+                ],
+            },
+        });
+        expect(result3.isExactMatch).toEqual(false);
+        expect(result3.isSuggestedMatch).toEqual(false);
+        // Different fieldRef
+        const result4 = (0, fields_1.compareMetricAndCustomMetric)({
+            customMetric: {
+                ...fields_mock_1.customMetric,
+                filters: [(0, fields_mock_1.metricFilterRule)()],
+            },
+            metric: {
+                ...fields_mock_1.metric,
+                filters: [
+                    (0, fields_mock_1.metricFilterRule)({
+                        fieldRef: 'b_dim2',
+                    }),
+                ],
+            },
+        });
+        expect(result4.isExactMatch).toEqual(false);
+        expect(result4.isSuggestedMatch).toEqual(false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightdash/common",
-  "version": "0.1478.7",
+  "version": "0.1479.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [