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
import {
getSearchField,
getSharedRemappedField,
} from "metabase-lib/v1/metadata/utils/remapping";
import { isFuzzyOperator } from "metabase-lib/v1/operators/utils";
import type {
ParameterField,
ParameterWithTemplateTagTarget,
} from "metabase-lib/v1/parameters/types";
import type {
Parameter,
ValuesQueryType,
ValuesSourceConfig,
ValuesSourceType,
} from "metabase-types/api";
import { deriveFieldOperatorFromParameter } from "./operators";
import { getFields } from "./parameter-fields";
import { getParameterType } from "./parameter-type";
export const getQueryType = (
parameter: ParameterWithTemplateTagTarget,
): ValuesQueryType => {
return parameter.values_query_type ?? getDefaultQueryType(parameter);
};
const getDefaultQueryType = (
parameter: ParameterWithTemplateTagTarget,
): ValuesQueryType => {
if (parameter.hasVariableTemplateTagTarget) {
return "none";
} else {
const operator = deriveFieldOperatorFromParameter(parameter);
return operator != null && isFuzzyOperator(operator) ? "none" : "list";
}
};
export const getSourceType = (parameter: Parameter): ValuesSourceType => {
return parameter.values_source_type ?? null;
};
export const getSourceConfig = (parameter: Parameter): ValuesSourceConfig => {
return parameter.values_source_config ?? {};
};
/**
* Whether the parameter's selected values can be remapped to human-readable
* labels. True when a connected field has a remapping, when a static list
* includes [value, label] pairs, or when a card/question source configures a
* label column.
*/
export const hasRemappedParameterValues = (
parameter: Parameter | null | undefined,
fields: ParameterField[],
): boolean => {
if (getSharedRemappedField(fields) != null) {
return true;
}
if (parameter == null) {
return false;
}
const sourceType = getSourceType(parameter);
const sourceConfig = getSourceConfig(parameter);
const sourceLabelField = sourceConfig.label_field;
const sourceValues = sourceConfig.values ?? [];
return (
(sourceType === "static-list" &&
sourceValues.some((value) => Array.isArray(value) && value.length > 1)) ||
(sourceType === "card" && sourceLabelField != null)
);
};
export const canUseCustomSource = (parameter: Parameter) => {
const type = getParameterType(parameter);
switch (type) {
case "string":
case "location":
case "category":
case "number":
case "id":
return true;
default:
return false;
}
};
export const isValidSourceConfig = (
sourceType: ValuesSourceType,
{ card_id, value_field, values }: ValuesSourceConfig,
) => {
switch (sourceType) {
case "card":
return card_id != null && value_field != null;
case "static-list":
return values != null && values.length > 0;
default:
return true;
}
};
export const getSourceConfigForType = (
sourceType: ValuesSourceType,
{ card_id, value_field, label_field, values }: ValuesSourceConfig,
): ValuesSourceConfig => {
switch (sourceType) {
case "card":
return { card_id, value_field, label_field };
case "static-list":
return { values };
default:
return {};
}
};
export const canListParameterValues = (parameter: Parameter) => {
const queryType = getQueryType(parameter);
const sourceType = getSourceType(parameter);
const fields = getFields(parameter);
const canListFields = canListFieldValues(fields);
return sourceType
? queryType === "list"
: queryType !== "none" && canListFields;
};
export const canListFieldValues = (fields: ParameterField[]) => {
const hasFields = fields.length > 0;
const hasFieldValues = fields
.filter((field) => typeof field.id === "number")
.every((field) => field.has_field_values === "list");
return hasFields && hasFieldValues;
};
export const canSearchParameterValues = (
parameter: Parameter,
disablePKRemapping = false,
) => {
const operator = deriveFieldOperatorFromParameter(parameter);
if (operator && isFuzzyOperator(operator) && !canUseCustomSource(parameter)) {
return false;
}
const queryType = getQueryType(parameter);
const sourceType = getSourceType(parameter);
const fields = getFields(parameter);
const canSearchFields = canSearchFieldValues(fields, disablePKRemapping);
return sourceType
? queryType === "search"
: queryType !== "none" && canSearchFields;
};
export const canSearchFieldValues = (
fields: ParameterField[],
disablePKRemapping = false,
) => {
const hasFields = fields.length > 0;
const canSearch = fields.every((field) =>
getSearchField(field, disablePKRemapping),
);
const hasFieldValues = fields.some(
(field) =>
field.has_field_values === "search" ||
(field.has_field_values === "list" && field.has_more_values === true),
);
return hasFields && canSearch && hasFieldValues;
};