Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

4.7 KB
Raw Blame
import * as ML from "cljs/metabase.lib.js";
import { type Metadata, metadataProvider } from "metabase-lib";
import type {
  CardId,
  CardType,
  ConcreteTableId,
  DatasetQuery,
  FieldId,
  LegacyDatasetQuery,
  OpaqueDatasetQuery,
  TableId,
  TestNativeQuerySpec,
  TestQuerySpec,
} from "metabase-types/api";

import type {
  CardMetadata,
  Clause,
  ClauseType,
  ColumnMetadata,
  Join,
  MeasureMetadata,
  MetadataProvider,
  MetricMetadata,
  Query,
  SegmentMetadata,
  TableMetadata,
} from "./types";

/**
 * Use this in combination with Lib.metadataProvider(databaseId, legacyMetadata) and
 Lib.tableOrCardMetadata(metadataProvider, tableOrCardId);
 */
export function queryFromTableOrCardMetadata(
  metadataProvider: MetadataProvider,
  tableOrCardMetadata: TableMetadata | CardMetadata,
): Query {
  return ML.query(metadataProvider, tableOrCardMetadata);
}

export function toLegacyQuery(query: Query): LegacyDatasetQuery {
  return ML.legacy_query(query);
}

export function suggestedName(query: Query): string {
  return ML.suggestedName(query);
}

export function stageCount(query: Query): number {
  return ML.stage_count(query);
}

export function stageIndexes(query: Query): number[] {
  return Array.from(
    { length: stageCount(query) },
    (_, stageIndex) => stageIndex,
  );
}

export const hasClauses = (query: Query, stageIndex: number): boolean => {
  return ML.has_clauses(query, stageIndex);
};

export function appendStage(query: Query): Query {
  return ML.append_stage(query);
}

export function dropStage(query: Query): Query {
  return ML.drop_stage(query);
}

export function dropEmptyStages(query: Query): Query {
  return ML.drop_empty_stages(query);
}

export function ensureFilterStage(query: Query): Query {
  return ML.ensure_filter_stage(query);
}

export function removeClause(
  query: Query,
  stageIndex: number,
  targetClause: Clause | Join,
): Query {
  return ML.remove_clause(query, stageIndex, targetClause);
}

export function replaceClause(
  query: Query,
  stageIndex: number,
  targetClause: Clause | Join,
  newClause:
    | Clause
    | ColumnMetadata
    | MeasureMetadata
    | MetricMetadata
    | SegmentMetadata
    | Join,
): Query {
  return ML.replace_clause(query, stageIndex, targetClause, newClause);
}

export function swapClauses(
  query: Query,
  stageIndex: number,
  sourceClause: Clause,
  targetClause: Clause,
): Query {
  return ML.swap_clauses(query, stageIndex, sourceClause, targetClause);
}

export function sourceTableOrCardId(query: Query): TableId | null {
  return ML.source_table_or_card_id(query);
}

export function allSourceTableIds(query: Query): ConcreteTableId[] {
  return ML.all_source_table_ids(query);
}

export function allSourceCardIds(query: Query): CardId[] {
  return ML.all_source_card_ids(query);
}

export function allFieldIds(query: Query): FieldId[] {
  return ML.all_field_ids(query);
}

export function canRun(query: Query, cardType: CardType): boolean {
  return ML.can_run(query, cardType);
}

export function canSave(query: Query, cardType: CardType): boolean {
  return ML.can_save(query, cardType);
}

export function asReturned(
  query: Query,
  stageIndex: number,
  cardId: CardId | undefined,
): { query: Query; stageIndex: number } {
  return ML.as_returned(query, stageIndex, cardId);
}

export function previewQuery(
  query: Query,
  stageIndex: number,
  clauseType: ClauseType,
  clauseIndex: number | null,
): Query | null {
  return ML.preview_query(query, stageIndex, clauseType, clauseIndex);
}

export function fromJsQuery(
  metadataProvider: MetadataProvider,
  jsQuery: OpaqueDatasetQuery | DatasetQuery,
): Query {
  return ML.from_js_query(metadataProvider, jsQuery);
}

export function fromJsQueryAndMetadata(
  metadata: Metadata,
  jsQuery: OpaqueDatasetQuery | DatasetQuery,
): Query {
  return fromJsQuery(metadataProvider(jsQuery.database, metadata), jsQuery);
}

export function toJsQuery(query: Query): OpaqueDatasetQuery {
  return ML.to_js_query(query);
}

export function createTestQuery(
  metadataProvider: MetadataProvider,
  querySpec: TestQuerySpec,
): Query {
  return ML.test_query(metadataProvider, querySpec);
}

export function createTestNativeQuery(
  metadataProvider: MetadataProvider,
  nativeQuerySpec: TestNativeQuerySpec,
): Query {
  return ML.test_native_query(metadataProvider, nativeQuerySpec);
}

export function createTestJsQuery(
  metadataProvider: MetadataProvider,
  querySpec: TestQuerySpec,
): OpaqueDatasetQuery {
  return toJsQuery(createTestQuery(metadataProvider, querySpec));
}

export function createTestJsNativeQuery(
  metadataProvider: MetadataProvider,
  nativeQuerySpec: TestNativeQuerySpec,
): OpaqueDatasetQuery {
  return toJsQuery(createTestNativeQuery(metadataProvider, nativeQuerySpec));
}