The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
/* eslint-disable metabase/no-unjustified-type-casts */
import * as LibMetric from "cljs/metabase.lib_metric.js";
import { type Dayjs, dayjs } from "metabase/dayjs";
import type { Metadata } from "metabase-lib";
import type {
ConcreteTableId,
JsMetricDefinition,
MeasureId,
MetricDimension,
MetricId,
SegmentId,
} from "metabase-types/api";
import type {
BinningStrategy,
BinningStrategyDisplayInfo,
BooleanFilterParts,
Clause,
ClauseDisplayInfo,
CoordinateFilterParts,
DefaultFilterParts,
DimensionDisplayInfo,
DimensionMetadata,
DimensionValuesInfo,
DisplayInfo,
Displayable,
ExcludeDateFilterParts,
FilterClause,
FilterParts,
MeasureDisplayInfo,
MeasureMetadata,
MetadataProvider,
MetadataProviderable,
MetricDefinition,
MetricDisplayInfo,
MetricMetadata,
NumberFilterParts,
ProjectionClause,
RelativeDateFilterParts,
SegmentDisplayInfo,
SegmentMetadata,
SourceInstance,
SpecificDateFilterParts,
StringFilterParts,
TemporalBucket,
TemporalBucketDisplayInfo,
TimeFilterParts,
} from "./types";
export function metadataProvider(jsMetadata: Metadata): MetadataProvider {
return LibMetric.metadataProvider(jsMetadata) as MetadataProvider;
}
export function metricMetadata(
metadataProvider: MetadataProviderable,
metricId: MetricId,
): MetricMetadata | null {
return LibMetric.metricMetadata(
metadataProvider,
metricId,
) as MetricMetadata | null;
}
export function measureMetadata(
metadataProvider: MetadataProviderable,
measureId: MeasureId,
): MeasureMetadata | null {
return LibMetric.measureMetadata(
metadataProvider,
measureId,
) as MeasureMetadata | null;
}
export function fromMetricMetadata(
metadataProvider: MetadataProviderable,
metricMetadata: MetricMetadata,
): MetricDefinition {
return LibMetric.fromMetricMetadata(
metadataProvider,
metricMetadata,
) as MetricDefinition;
}
export function fromMeasureMetadata(
metadataProvider: MetadataProviderable,
measureMetadata: MeasureMetadata,
): MetricDefinition {
return LibMetric.fromMeasureMetadata(
metadataProvider,
measureMetadata,
) as MetricDefinition;
}
export function fromJsMetricDefinition(
metadataProvider: MetadataProviderable,
jsDefinition: JsMetricDefinition,
): MetricDefinition {
return LibMetric.fromJsMetricDefinition(
metadataProvider,
jsDefinition,
) as MetricDefinition;
}
export function toJsMetricDefinition(
definition: MetricDefinition,
): JsMetricDefinition {
return LibMetric.toJsMetricDefinition(definition) as JsMetricDefinition;
}
export function sourceMetricId(definition: MetricDefinition): MetricId | null {
return LibMetric.sourceMetricId(definition) as MetricId | null;
}
export function sourceMetricMetadata(
definition: MetricDefinition,
): MetricMetadata | null {
const metricId = sourceMetricId(definition);
return metricId != null ? metricMetadata(definition, metricId) : null;
}
export function sourceMeasureId(
definition: MetricDefinition,
): MeasureId | null {
return LibMetric.sourceMeasureId(definition) as MeasureId | null;
}
export function sourceMeasureTableId(
definition: MetricDefinition,
): ConcreteTableId | null {
return LibMetric.sourceMeasureTableId(definition) as ConcreteTableId | null;
}
export function sourceMeasureMetadata(
definition: MetricDefinition,
): MeasureMetadata | null {
const measureId = sourceMeasureId(definition);
return measureId != null ? measureMetadata(definition, measureId) : null;
}
export function sourceMetricOrMeasureMetadata(
definition: MetricDefinition,
): MetricMetadata | MeasureMetadata | null {
return sourceMetricMetadata(definition) ?? sourceMeasureMetadata(definition);
}
export function sourceInstances(
definition: MetricDefinition,
): SourceInstance[] {
return LibMetric.sourceInstances(definition) as SourceInstance[];
}
export function filters(definition: MetricDefinition): FilterClause[];
export function filters(
definition: MetricDefinition,
sourceInstance: SourceInstance,
): FilterClause[];
export function filters(
definition: MetricDefinition,
sourceInstance?: SourceInstance,
): FilterClause[] {
if (sourceInstance !== undefined) {
return LibMetric.filters(definition, sourceInstance) as FilterClause[];
}
return LibMetric.filters(definition) as FilterClause[];
}
export function filterableDimensions(
definition: MetricDefinition,
): DimensionMetadata[];
export function filterableDimensions(
definition: MetricDefinition,
sourceInstance: SourceInstance,
): DimensionMetadata[];
export function filterableDimensions(
definition: MetricDefinition,
sourceInstance?: SourceInstance,
): DimensionMetadata[] {
if (sourceInstance !== undefined) {
return LibMetric.filterableDimensions(
definition,
sourceInstance,
) as DimensionMetadata[];
}
return LibMetric.filterableDimensions(definition) as DimensionMetadata[];
}
export function filter(
definition: MetricDefinition,
filterClause: FilterClause,
): MetricDefinition;
export function filter(
definition: MetricDefinition,
filterClause: FilterClause,
sourceInstance: SourceInstance,
): MetricDefinition;
export function filter(
definition: MetricDefinition,
filterClause: FilterClause,
sourceInstance?: SourceInstance,
): MetricDefinition {
if (sourceInstance !== undefined) {
return LibMetric.filter(
definition,
filterClause,
sourceInstance,
) as MetricDefinition;
}
return LibMetric.filter(definition, filterClause) as MetricDefinition;
}
export function availableSegments(
definition: MetricDefinition,
): SegmentMetadata[] {
return LibMetric.availableSegments(definition) as SegmentMetadata[];
}
export function addSegmentFilter(
definition: MetricDefinition,
segment: SegmentMetadata,
): MetricDefinition {
return LibMetric.addSegmentFilter(definition, segment) as MetricDefinition;
}
export function isSegmentFilter(filterClause: FilterClause): boolean {
return Boolean(LibMetric.isSegmentFilter(filterClause));
}
export function segmentMetadataForFilter(
definition: MetricDefinition,
filterClause: FilterClause,
): SegmentMetadata | null {
return LibMetric.segmentMetadataForFilter(
definition,
filterClause,
) as SegmentMetadata | null;
}
export function segmentMetadataId(segment: SegmentMetadata): SegmentId {
return LibMetric.segmentMetadataId(segment) as SegmentId;
}
export function stringFilterClause(parts: StringFilterParts): FilterClause {
return LibMetric.stringFilterClause(parts) as FilterClause;
}
export function stringFilterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): StringFilterParts | null {
return LibMetric.stringFilterParts(
definition,
filterClause,
) as StringFilterParts | null;
}
export function numberFilterClause(parts: NumberFilterParts): FilterClause {
return LibMetric.numberFilterClause(parts) as FilterClause;
}
export function numberFilterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): NumberFilterParts | null {
return LibMetric.numberFilterParts(
definition,
filterClause,
) as NumberFilterParts | null;
}
export function coordinateFilterClause(
parts: CoordinateFilterParts,
): FilterClause {
return LibMetric.coordinateFilterClause(parts) as FilterClause;
}
export function coordinateFilterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): CoordinateFilterParts | null {
return LibMetric.coordinateFilterParts(
definition,
filterClause,
) as CoordinateFilterParts | null;
}
export function booleanFilterClause(parts: BooleanFilterParts): FilterClause {
return LibMetric.booleanFilterClause(parts) as FilterClause;
}
export function booleanFilterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): BooleanFilterParts | null {
return LibMetric.booleanFilterParts(
definition,
filterClause,
) as BooleanFilterParts | null;
}
export function specificDateFilterClause(
parts: SpecificDateFilterParts,
): FilterClause {
return LibMetric.specificDateFilterClause(parts) as FilterClause;
}
export function specificDateFilterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): SpecificDateFilterParts | null {
return LibMetric.specificDateFilterParts(
definition,
filterClause,
) as SpecificDateFilterParts | null;
}
export function relativeDateFilterClause(
parts: RelativeDateFilterParts,
): FilterClause {
return LibMetric.relativeDateFilterClause(parts) as FilterClause;
}
export function relativeDateFilterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): RelativeDateFilterParts | null {
return LibMetric.relativeDateFilterParts(
definition,
filterClause,
) as RelativeDateFilterParts | null;
}
export function excludeDateFilterClause(
parts: ExcludeDateFilterParts,
): FilterClause {
return LibMetric.excludeDateFilterClause(parts) as FilterClause;
}
export function excludeDateFilterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): ExcludeDateFilterParts | null {
return LibMetric.excludeDateFilterParts(
definition,
filterClause,
) as ExcludeDateFilterParts | null;
}
export function timeFilterClause(parts: TimeFilterParts): FilterClause {
return LibMetric.timeFilterClause({
...parts,
values: parts.values.map((value) => dayjs(value)),
}) as FilterClause;
}
export function timeFilterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): TimeFilterParts | null {
const filterParts = LibMetric.timeFilterParts(definition, filterClause);
if (!filterParts) {
return null;
}
return {
...filterParts,
values: filterParts.values.map((value: Dayjs) => value.toDate()),
};
}
export function defaultFilterClause(parts: DefaultFilterParts): FilterClause {
return LibMetric.defaultFilterClause(parts) as FilterClause;
}
export function defaultFilterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): DefaultFilterParts | null {
return LibMetric.defaultFilterParts(
definition,
filterClause,
) as DefaultFilterParts | null;
}
export function filterParts(
definition: MetricDefinition,
filterClause: FilterClause,
): FilterParts | null {
return (
stringFilterParts(definition, filterClause) ??
numberFilterParts(definition, filterClause) ??
coordinateFilterParts(definition, filterClause) ??
booleanFilterParts(definition, filterClause) ??
specificDateFilterParts(definition, filterClause) ??
relativeDateFilterParts(definition, filterClause) ??
excludeDateFilterParts(definition, filterClause) ??
timeFilterParts(definition, filterClause) ??
defaultFilterParts(definition, filterClause)
);
}
export function projections(definition: MetricDefinition): ProjectionClause[];
export function projections(
definition: MetricDefinition,
sourceInstance: SourceInstance,
): ProjectionClause[];
export function projections(
definition: MetricDefinition,
sourceInstance?: SourceInstance,
): ProjectionClause[] {
if (sourceInstance !== undefined) {
return LibMetric.projections(
definition,
sourceInstance,
) as ProjectionClause[];
}
return LibMetric.projections(definition) as ProjectionClause[];
}
export function defaultBreakoutDimensions(
definition: MetricDefinition,
): DimensionMetadata[] {
return LibMetric.defaultBreakoutDimensions(definition) as DimensionMetadata[];
}
export function projectionableDimensions(
definition: MetricDefinition,
): DimensionMetadata[];
export function projectionableDimensions(
definition: MetricDefinition,
sourceInstance: SourceInstance,
): DimensionMetadata[];
export function projectionableDimensions(
definition: MetricDefinition,
sourceInstance?: SourceInstance,
): DimensionMetadata[] {
if (sourceInstance !== undefined) {
return LibMetric.projectionableDimensions(
definition,
sourceInstance,
) as DimensionMetadata[];
}
return LibMetric.projectionableDimensions(definition) as DimensionMetadata[];
}
export function dimensionReference(
dimension: DimensionMetadata,
): ProjectionClause {
return LibMetric.dimensionReference(dimension) as ProjectionClause;
}
export function project(
definition: MetricDefinition,
dimensionRef: ProjectionClause,
): MetricDefinition;
export function project(
definition: MetricDefinition,
dimensionRef: ProjectionClause,
sourceInstance: SourceInstance,
): MetricDefinition;
export function project(
definition: MetricDefinition,
dimensionRef: ProjectionClause,
sourceInstance?: SourceInstance,
): MetricDefinition {
if (sourceInstance !== undefined) {
return LibMetric.project(
definition,
dimensionRef,
sourceInstance,
) as MetricDefinition;
}
return LibMetric.project(definition, dimensionRef) as MetricDefinition;
}
/** Projects a dimension using its default temporal bucket or binning strategy. */
export function projectDimension(
definition: MetricDefinition,
dimension: DimensionMetadata,
): MetricDefinition {
return LibMetric.projectDimension(definition, dimension) as MetricDefinition;
}
export function projectionDimension(
definition: MetricDefinition,
dimension: ProjectionClause | DimensionMetadata,
): DimensionMetadata | null {
return LibMetric.projectionDimension(
definition,
dimension,
) as DimensionMetadata | null;
}
export function replaceClause(
definition: MetricDefinition,
targetClause: Clause,
newClause: Clause,
): MetricDefinition {
return LibMetric.replaceClause(
definition,
targetClause,
newClause,
) as MetricDefinition;
}
export function removeClause(
definition: MetricDefinition,
clause: Clause,
): MetricDefinition {
return LibMetric.removeClause(definition, clause) as MetricDefinition;
}
export function swapClauses(
definition: MetricDefinition,
sourceClause: Clause,
targetClause: Clause,
): MetricDefinition {
return LibMetric.swapClauses(
definition,
sourceClause,
targetClause,
) as MetricDefinition;
}
export function temporalBucket(
projection: Clause | DimensionMetadata,
): TemporalBucket | null {
return LibMetric.temporalBucket(projection) as TemporalBucket | null;
}
export function availableTemporalBuckets(
definition: MetricDefinition,
dimension: DimensionMetadata,
): TemporalBucket[] {
return LibMetric.availableTemporalBuckets(
definition,
dimension,
) as TemporalBucket[];
}
export function isTemporalBucketable(
definition: MetricDefinition,
dimension: DimensionMetadata,
): boolean {
return availableTemporalBuckets(definition, dimension).length > 0;
}
export function withTemporalBucket(
projection: Clause | DimensionMetadata,
bucket: TemporalBucket | null,
): ProjectionClause {
return LibMetric.withTemporalBucket(projection, bucket) as ProjectionClause;
}
export function withDefaultTemporalBucket(
definition: MetricDefinition,
projection: ProjectionClause,
): ProjectionClause {
const dimension = projectionDimension(definition, projection);
if (!dimension) {
return projection;
}
const bucket = defaultTemporalBucket(definition, dimension);
return bucket ? withTemporalBucket(projection, bucket) : projection;
}
export function defaultTemporalBucket(
definition: MetricDefinition,
dimension: DimensionMetadata,
): TemporalBucket | null {
const buckets = availableTemporalBuckets(definition, dimension);
const bucket = buckets.find((b) => displayInfo(definition, b).default);
return bucket ?? null;
}
export function binning(
projection: Clause | DimensionMetadata,
): BinningStrategy | null {
return LibMetric.binning(projection) as BinningStrategy | null;
}
export function availableBinningStrategies(
definition: MetricDefinition,
dimension: DimensionMetadata,
): BinningStrategy[] {
return LibMetric.availableBinningStrategies(
definition,
dimension,
) as BinningStrategy[];
}
export function isBinnable(
definition: MetricDefinition,
dimension: DimensionMetadata,
): boolean {
return availableBinningStrategies(definition, dimension).length > 0;
}
export function withBinning(
projection: Clause | DimensionMetadata,
binningStrategy: BinningStrategy | null,
): ProjectionClause {
return LibMetric.withBinning(projection, binningStrategy) as ProjectionClause;
}
export function withDefaultBinning(
definition: MetricDefinition,
projection: ProjectionClause,
): ProjectionClause {
const dimension = projectionDimension(definition, projection);
if (!dimension) {
return projection;
}
const strategies = availableBinningStrategies(definition, dimension);
const defaultStrategy = strategies.find(
(strategy) => displayInfo(definition, strategy).default,
);
return defaultStrategy
? withBinning(projection, defaultStrategy)
: projection;
}
type TypeFn = (dimension: DimensionMetadata) => boolean;
export const isBoolean: TypeFn = (dimension) => {
return LibMetric.isBoolean(dimension) as boolean;
};
export const isCoordinate: TypeFn = (dimension) => {
return LibMetric.isCoordinate(dimension) as boolean;
};
export const isTemporal: TypeFn = (dimension) => {
return LibMetric.isTemporal(dimension) as boolean;
};
export const isDateOrDateTime: TypeFn = (dimension) => {
return LibMetric.isDateOrDateTime(dimension) as boolean;
};
export const isForeignKey: TypeFn = (dimension) => {
return LibMetric.isForeignKey(dimension) as boolean;
};
export const isLocation: TypeFn = (dimension) => {
return LibMetric.isLocation(dimension) as boolean;
};
export const isLatitude: TypeFn = (dimension) => {
return LibMetric.isLatitude(dimension) as boolean;
};
export const isLongitude: TypeFn = (dimension) => {
return LibMetric.isLongitude(dimension) as boolean;
};
export const isNumeric: TypeFn = (dimension) => {
return LibMetric.isNumeric(dimension) as boolean;
};
export const isPrimaryKey: TypeFn = (dimension) => {
return LibMetric.isPrimaryKey(dimension) as boolean;
};
export const isStringLike: TypeFn = (dimension) => {
return LibMetric.isStringLike(dimension) as boolean;
};
export const isStringOrStringLike: TypeFn = (dimension) => {
return LibMetric.isStringOrStringLike(dimension) as boolean;
};
export const isTime: TypeFn = (dimension) => {
return LibMetric.isTime(dimension) as boolean;
};
export const isCategory: TypeFn = (dimension) => {
return LibMetric.isCategory(dimension) as boolean;
};
export const isID: TypeFn = (dimension) => {
return LibMetric.isID(dimension) as boolean;
};
export const isURL: TypeFn = (dimension) => {
return LibMetric.isURL(dimension) as boolean;
};
export const isEntityName: TypeFn = (dimension) => {
return LibMetric.isEntityName(dimension) as boolean;
};
export const isTitle: TypeFn = (dimension) => {
return LibMetric.isTitle(dimension) as boolean;
};
export const isState: TypeFn = (dimension) => {
return LibMetric.isState(dimension) as boolean;
};
export const isCountry: TypeFn = (dimension) => {
return LibMetric.isCountry(dimension) as boolean;
};
export const isCity: TypeFn = (dimension) => {
return LibMetric.isCity(dimension) as boolean;
};
export function displayInfo(
definition: MetricDefinition,
metric: MetricMetadata,
): MetricDisplayInfo;
export function displayInfo(
definition: MetricDefinition,
measure: MeasureMetadata,
): MeasureDisplayInfo;
export function displayInfo(
definition: MetricDefinition,
clause: Clause,
): ClauseDisplayInfo;
export function displayInfo(
definition: MetricDefinition,
dimension: DimensionMetadata,
): DimensionDisplayInfo;
export function displayInfo(
definition: MetricDefinition,
temporalBucket: TemporalBucket,
): TemporalBucketDisplayInfo;
export function displayInfo(
definition: MetricDefinition,
binningStrategy: BinningStrategy,
): BinningStrategyDisplayInfo;
export function displayInfo(
definition: MetricDefinition,
segment: SegmentMetadata,
): SegmentDisplayInfo;
export function displayInfo(
definition: MetricDefinition,
filterParts: Displayable,
): DisplayInfo;
export function displayInfo(
definition: MetricDefinition,
source: Displayable,
): DisplayInfo {
return LibMetric.displayInfo(definition, source) as DisplayInfo;
}
export function dimensionValuesInfo(
definition: MetricDefinition,
dimension: DimensionMetadata,
): DimensionValuesInfo {
return LibMetric.dimensionValuesInfo(
definition,
dimension,
) as DimensionValuesInfo;
}
export function isSameSource(
dimension1: DimensionMetadata,
dimension2: DimensionMetadata,
): boolean {
return LibMetric.isSameSource(dimension1, dimension2) as boolean;
}
export function fromMetricDimension(
dimension: MetricDimension,
): DimensionMetadata {
return LibMetric.fromMetricDimension(dimension) as DimensionMetadata;
}
export function toMetricDimension(
dimension: DimensionMetadata,
): MetricDimension {
return LibMetric.toMetricDimension(dimension) as MetricDimension;
}
export function groupDimensionsBySource(
dimensions: DimensionMetadata[],
): DimensionMetadata[][] {
return LibMetric.groupDimensionsBySource(dimensions) as DimensionMetadata[][];
}
export function isCompatibleType(
dimension1: DimensionMetadata,
dimension2: DimensionMetadata,
): boolean {
return LibMetric.isCompatibleType(dimension1, dimension2) as boolean;
}