@lightdash/common 0.1397.2 → 0.1399.0

package/dist/types/catalog.d.ts

@@ -1,5 +1,5 @@
-import { type CompiledExploreJoin, type CompiledTable, type Explore, type ExploreError, type InlineError } from './explore';
-import { type CompiledDimension, type CompiledMetric, type Dimension, type Field, type FieldType } from './field';
+import { type CompiledExploreJoin, type Explore, type ExploreError, type InlineError } from './explore';
+import { DimensionType, type CompiledDimension, type CompiledMetric, type Dimension, type Field, type FieldType } from './field';
 import type { KnexPaginatedData } from './knex-paginate';
 import { type ChartSummary } from './savedCharts';
 import { type TableBase } from './table';
@@ -70,7 +70,14 @@ export type ApiMetricsCatalog = {
     status: 'ok';
     results: KnexPaginatedData<ApiMetricsCatalogResults>;
 };
-export type MetricWithAssociatedTimeDimension = CompiledMetric & Pick<CompiledTable, 'defaultTimeDimension'>;
+export type MetricWithAssociatedTimeDimension = CompiledMetric & {
+    timeDimension: (CompiledMetric['defaultTimeDimension'] & {
+        table: string;
+    }) | undefined;
+    availableTimeDimensions?: (CompiledDimension & {
+        type: DimensionType.DATE | DimensionType.TIMESTAMP;
+    })[];
+};
 export type ApiGetMetricPeek = {
     status: 'ok';
     results: MetricWithAssociatedTimeDimension;

package/dist/types/metricsExplorer.d.ts

@@ -1,3 +1,4 @@
+import { type MetricWithAssociatedTimeDimension } from './catalog';
 import type { ItemsMap } from './field';
 import type { ResultRow } from './results';
 export declare enum MetricExplorerComparison {
@@ -13,6 +14,7 @@ export type MetricExplorerComparisonType = {
     type: MetricExplorerComparison.PREVIOUS_PERIOD;
 } | {
     type: MetricExplorerComparison.DIFFERENT_METRIC;
+    metricTable: string;
     metricName: string;
 };
 export type MetricExploreDataPoint = {
@@ -21,6 +23,7 @@ export type MetricExploreDataPoint = {
     compareMetric: unknown;
 };
 export type MetricsExplorerQueryResults = {
+    metric: MetricWithAssociatedTimeDimension;
     rows: ResultRow[];
     comparisonRows: ResultRow[] | undefined;
     fields: ItemsMap;

package/dist/utils/metricsExplorer.d.ts

@@ -1,10 +1,12 @@
 import type { MetricWithAssociatedTimeDimension } from '../types/catalog';
 import { ConditionalOperator } from '../types/conditionalRule';
+import { type CompiledTable } from '../types/explore';
 import type { Dimension } from '../types/field';
+import { DimensionType, type CompiledDimension, type CompiledMetric } from '../types/field';
 import { type DateFilterSettings, type FieldTarget, type FilterRule } from '../types/filter';
-import type { MetricExploreDataPoint, MetricExplorerDateRange } from '../types/metricsExplorer';
+import { type MetricExploreDataPoint, type MetricExplorerComparisonType, type MetricExplorerDateRange } from '../types/metricsExplorer';
 import type { ResultRow } from '../types/results';
-import { TimeFrames } from '../types/timeFrames';
+import { TimeFrames, type DefaultTimeDimension } from '../types/timeFrames';
 type DateFilter = FilterRule<ConditionalOperator, FieldTarget, unknown, DateFilterSettings>;
 type ImpelemntedTimeframe = TimeFrames.DAY | TimeFrames.WEEK | TimeFrames.MONTH | TimeFrames.YEAR;
 export declare const getFieldIdForDateDimension: (fieldId: string, timeframe: TimeFrames) => string;
@@ -13,7 +15,7 @@ export declare const oneYearForward: (date: Date) => Date;
 export declare const getGrainForDateRange: (dateRange: [Date, Date]) => ImpelemntedTimeframe;
 export declare const getMetricExplorerDateRangeFilters: (exploreName: string, dimensionName: string, dateRange: MetricExplorerDateRange) => DateFilter[];
 export declare const getMetricExplorerDataPoints: (dimension: Dimension, metric: MetricWithAssociatedTimeDimension, metricRows: ResultRow[]) => Array<MetricExploreDataPoint>;
-export declare const getMetricExplorerDataPointsWithCompare: (dimension: Dimension, metric: MetricWithAssociatedTimeDimension, metricRows: ResultRow[], compareMetricRows: ResultRow[], offsetFunction?: (date: Date) => Date) => Array<MetricExploreDataPoint>;
+export declare const getMetricExplorerDataPointsWithCompare: (dimension: Dimension, metric: MetricWithAssociatedTimeDimension, metricRows: ResultRow[], compareMetricRows: ResultRow[], comparison: MetricExplorerComparisonType) => Array<MetricExploreDataPoint>;
 /**
  * Get the date range for a given time interval, based on the current date and the time interval
  * Time grain Year: -> past 5 years (i.e. 5 completed years + this uncompleted year)
@@ -24,4 +26,17 @@ export declare const getMetricExplorerDataPointsWithCompare: (dimension: Dimensi
  * @returns The date range
  */
 export declare const getDefaultDateRangeFromInterval: (timeInterval: TimeFrames) => MetricExplorerDateRange;
+/**
+ * Default time interval to use when no time interval is provided.
+ * For example, when there is no default time dimension defined for a metric or table.
+ */
+export declare const DEFAULT_METRICS_EXPLORER_TIME_INTERVAL = TimeFrames.MONTH;
+export type TimeDimensionConfig = DefaultTimeDimension & {
+    table: string;
+};
+export declare const getFirstAvailableTimeDimension: (metric: MetricWithAssociatedTimeDimension) => TimeDimensionConfig | undefined;
+export declare const getDefaultTimeDimension: (metric: CompiledMetric, table?: CompiledTable) => DefaultTimeDimension | undefined;
+export declare const getAvailableTimeDimensionsFromTables: (tables: Record<string, CompiledTable>) => (CompiledDimension & {
+    type: DimensionType.DATE | DimensionType.TIMESTAMP;
+})[];
 export {};

package/dist/utils/metricsExplorer.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultDateRangeFromInterval = exports.getMetricExplorerDataPointsWithCompare = exports.getMetricExplorerDataPoints = exports.getMetricExplorerDateRangeFilters = exports.getGrainForDateRange = exports.oneYearForward = exports.oneYearBack = exports.getFieldIdForDateDimension = void 0;
+exports.getAvailableTimeDimensionsFromTables = exports.getDefaultTimeDimension = exports.getFirstAvailableTimeDimension = exports.DEFAULT_METRICS_EXPLORER_TIME_INTERVAL = exports.getDefaultDateRangeFromInterval = exports.getMetricExplorerDataPointsWithCompare = exports.getMetricExplorerDataPoints = exports.getMetricExplorerDateRangeFilters = exports.getGrainForDateRange = exports.oneYearForward = exports.oneYearBack = exports.getFieldIdForDateDimension = void 0;
 const tslib_1 = require("tslib");
 const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
 const lodash_1 = require("lodash");
 const uuid_1 = require("uuid");
 const conditionalRule_1 = require("../types/conditionalRule");
+const field_1 = require("../types/field");
+const metricsExplorer_1 = require("../types/metricsExplorer");
 const timeFrames_1 = require("../types/timeFrames");
 const assertUnreachable_1 = tslib_1.__importDefault(require("./assertUnreachable"));
 const item_1 = require("./item");
@@ -105,22 +107,33 @@ const getMetricExplorerDataPoints = (dimension, metric, metricRows) => {
     }));
 };
 exports.getMetricExplorerDataPoints = getMetricExplorerDataPoints;
-const getMetricExplorerDataPointsWithCompare = (dimension, metric, metricRows, compareMetricRows, offsetFunction = exports.oneYearForward) => {
+const getMetricExplorerDataPointsWithCompare = (dimension, metric, metricRows, compareMetricRows, comparison) => {
+    if (comparison.type === metricsExplorer_1.MetricExplorerComparison.NONE) {
+        throw new Error('Comparison type is required');
+    }
     const dimensionId = (0, item_1.getItemId)(dimension);
     const metricId = (0, item_1.getItemId)(metric);
     const mapDateField = (row) => new Date(String(row[dimensionId].value.raw)).toString();
     const groupByMetricRows = (0, lodash_1.groupBy)(metricRows, (row) => mapDateField(row));
     const groupByCompareMetricRows = (0, lodash_1.groupBy)(compareMetricRows, (row) => mapDateField(row));
-    const offsetGroupByCompareMetricRows = (0, lodash_1.mapKeys)(groupByCompareMetricRows, (_, date) => offsetFunction(new Date(date)).toString());
+    const offsetGroupByCompareMetricRows = (0, lodash_1.mapKeys)(groupByCompareMetricRows, (_, date) => comparison.type === metricsExplorer_1.MetricExplorerComparison.PREVIOUS_PERIOD
+        ? (0, exports.oneYearForward)(new Date(date)).toString()
+        : date);
     const dates = new Set([
         ...Object.keys(groupByMetricRows),
         ...Object.keys(offsetGroupByCompareMetricRows),
     ]);
+    const compareMetricId = comparison.type === metricsExplorer_1.MetricExplorerComparison.PREVIOUS_PERIOD
+        ? metricId
+        : (0, item_1.getItemId)({
+            table: comparison.metricTable,
+            name: comparison.metricName,
+        });
     return Array.from(dates).map((date) => ({
         date: new Date(date),
         metric: groupByMetricRows[date]?.[0]?.[metricId]?.value.raw ?? null,
-        compareMetric: offsetGroupByCompareMetricRows[date]?.[0]?.[metricId]?.value.raw ??
-            null,
+        compareMetric: offsetGroupByCompareMetricRows[date]?.[0]?.[compareMetricId]?.value
+            .raw ?? null,
     }));
 };
 exports.getMetricExplorerDataPointsWithCompare = getMetricExplorerDataPointsWithCompare;
@@ -161,3 +174,50 @@ const getDefaultDateRangeFromInterval = (timeInterval) => {
     }
 };
 exports.getDefaultDateRangeFromInterval = getDefaultDateRangeFromInterval;
+/**
+ * Default time interval to use when no time interval is provided.
+ * For example, when there is no default time dimension defined for a metric or table.
+ */
+exports.DEFAULT_METRICS_EXPLORER_TIME_INTERVAL = timeFrames_1.TimeFrames.MONTH;
+const getFirstAvailableTimeDimension = (metric) => {
+    if (metric.availableTimeDimensions &&
+        metric.availableTimeDimensions.length > 0) {
+        return {
+            table: metric.availableTimeDimensions[0].table,
+            field: metric.availableTimeDimensions[0].name,
+            interval: exports.DEFAULT_METRICS_EXPLORER_TIME_INTERVAL,
+        };
+    }
+    return undefined;
+};
+exports.getFirstAvailableTimeDimension = getFirstAvailableTimeDimension;
+const getDefaultTimeDimension = (metric, table) => {
+    // Priority 1: Use metric-level default time dimension if defined in yml
+    if (metric.defaultTimeDimension) {
+        return metric.defaultTimeDimension;
+    }
+    // Priority 2: Use model-level default time dimension if defined in yml
+    if (table?.defaultTimeDimension) {
+        return table.defaultTimeDimension;
+    }
+    // Priority 3: Use the only time dimension if there's exactly one
+    if (table?.dimensions) {
+        const timeDimensions = Object.values(table.dimensions).filter((dim) => (dim.type === field_1.DimensionType.DATE ||
+            dim.type === field_1.DimensionType.TIMESTAMP) &&
+            !!dim.isIntervalBase &&
+            !dim.hidden);
+        if (timeDimensions.length === 1) {
+            return {
+                field: timeDimensions[0].name,
+                interval: exports.DEFAULT_METRICS_EXPLORER_TIME_INTERVAL,
+            };
+        }
+    }
+    return undefined;
+};
+exports.getDefaultTimeDimension = getDefaultTimeDimension;
+const getAvailableTimeDimensionsFromTables = (tables) => Object.values(tables).flatMap((table) => Object.values(table.dimensions).filter((dim) => (dim.type === field_1.DimensionType.DATE ||
+    dim.type === field_1.DimensionType.TIMESTAMP) &&
+    !!dim.isIntervalBase &&
+    !dim.hidden));
+exports.getAvailableTimeDimensionsFromTables = getAvailableTimeDimensionsFromTables;

package/package.json

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