Skip to content

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

6.0 KB
Raw Blame
import fetchMock from "fetch-mock";
import _ from "underscore";

import { shouldSchemaBePassedAsQueryParam } from "metabase/api";
import { SAVED_QUESTIONS_DATABASE } from "metabase/databases/constants";
import { isTypePK } from "metabase-lib/v1/types/utils/isa";
import type {
  Database,
  DatabaseId,
  DatabaseUsageInfo,
  Engine,
  SchemaName,
} from "metabase-types/api";

import { PERMISSION_ERROR } from "./constants";
import { setupTableEndpoints } from "./table";

export function setupDatabaseEndpoints(db: Database) {
  fetchMock.get(`path:/api/database/${db.id}`, db);
  fetchMock.post(
    `path:/api/database/${db.id}/sync_schema`,
    {},
    { name: `database-${db.id}-sync-schema` },
  );
  fetchMock.post(
    `path:/api/database/${db.id}/rescan_values`,
    {},
    { name: `database-${db.id}-rescan-values` },
  );
  fetchMock.post(`path:/api/database/${db.id}/discard_values`, {});
  fetchMock.get(
    `path:/api/database/${db.id}/healthcheck`,
    {
      body: { status: "ok" },
    },
    { name: `database-${db.id}-healthcheck` },
  );
  setupSchemaEndpoints(db);
  setupDatabaseIdFieldsEndpoints({ database: db });
  db.tables?.forEach((table) => setupTableEndpoints({ ...table, db }));
  setupUpdateDatabaseEndpoint(db);
}

export function setupDatabaseMetadataEndpoint(db: Database) {
  fetchMock.get(`path:/api/database/${db.id}/metadata`, db, {
    name: `database-${db.id}-metadata`,
  });
}

export function setupDatabaseMetadataErrorEndpoint(databaseId: DatabaseId) {
  fetchMock.get(`path:/api/database/${databaseId}/metadata`, 500, {
    name: `database-${databaseId}-metadata`,
  });
}

export function setupUpdateDatabaseEndpoint(db: Database) {
  fetchMock.put(`path:/api/database/${db.id}`, async (call) => {
    const body = await call?.request?.json();
    return { ...db, ...body };
  });
}

export function setupUpdateDatabaseEndpointError(databaseId: Database["id"]) {
  fetchMock.put(`path:/api/database/${databaseId}`, { status: 500 });
}

export function setupDatabaseNotFoundEndpoint(databaseId: DatabaseId) {
  fetchMock.get(`path:/api/database/${databaseId}`, {
    status: 404,
    body: "Not found.",
  });
}

export function setupCreateDatabaseEndpointError({
  status,
  body,
}: {
  status: number;
  body: string | Record<string, unknown>;
}) {
  fetchMock.post(
    "path:/api/database",
    { status, body },
    { name: "create-database" },
  );
}

export function setupDatabaseHealthcheckEndpoint(databaseId: Database["id"]) {
  fetchMock.get(`path:/api/database/${databaseId}/healthcheck`, {
    body: { status: "ok" },
  });
}

export function setupDatabaseUsageInfoEndpoint(
  db: Database,
  usageInfo: DatabaseUsageInfo,
) {
  fetchMock.get(`path:/api/database/${db.id}/usage_info`, usageInfo);
}

export function setupEnginesEndpoint(engines: Record<string, Engine>) {
  fetchMock.get("path:/api/setting/engines", engines);
}

export function setupDatabaseListEndpoint(databases: Database[]) {
  fetchMock.get(
    "path:/api/database",
    { data: databases, total: databases.length },
    { name: "database-list" },
  );
}

export function setupDatabaseListEndpointError({
  status,
  body,
}: {
  status: number;
  body: Record<string, unknown>;
}) {
  fetchMock.get(
    "path:/api/database",
    { status, body },
    { name: "database-list" },
  );
}

export function setupDatabasesEndpoints(
  databases: Database[],
  { hasSavedQuestions = true } = {},
  query: object = { saved: true },
) {
  const databasesWithSavedQuestions = hasSavedQuestions
    ? [...databases, SAVED_QUESTIONS_DATABASE]
    : databases;
  fetchMock.get({
    url: "path:/api/database",
    query,
    response: {
      data: databasesWithSavedQuestions,
      total: databasesWithSavedQuestions.length,
    },
    name: "database-list-with-query",
  });
  setupDatabaseListEndpoint(databases);
  fetchMock.post(
    "path:/api/database",
    async (call) => {
      return await call?.request?.json();
    },
    { name: "database-post" },
  );

  databases.forEach((db) => setupDatabaseEndpoints(db));
}

export const setupSchemaEndpoints = (db: Database) => {
  const schemas = _.groupBy(db.tables ?? [], (table) => table.schema);
  const schemaNames = Object.keys(schemas);
  fetchMock.get(`path:/api/database/${db.id}/schemas`, schemaNames);
  fetchMock.get(`path:/api/database/${db.id}/syncable_schemas`, schemaNames);

  schemaNames.forEach((schema) => {
    const isQueryParam = shouldSchemaBePassedAsQueryParam(schema);
    fetchMock.get({
      url: isQueryParam
        ? `path:/api/database/${db.id}/schema/`
        : `path:/api/database/${db.id}/schema/${encodeURIComponent(schema)}`,
      ...(isQueryParam && { query: { schema } }),
      response: schemas[schema],
      name: `database-${db.id}-schema-${schema}`,
    });
  });
};

export const setupListDatabaseSchemasEndpoint = (
  databaseId: DatabaseId,
  schemaNames: SchemaName[],
) => {
  fetchMock.get(`path:/api/database/${databaseId}/schemas`, schemaNames);
};

export function setupDatabaseIdFieldsEndpoints({
  database: { id, tables = [] },
}: {
  database: Database;
}) {
  const fields = tables.flatMap((table) =>
    (table.fields ?? [])
      .filter((field) => isTypePK(field.semantic_type))
      .map((field) => ({ ...field, table })),
  );

  const name = `database-${id}-idfields`;
  fetchMock.removeRoute(name);

  fetchMock.get(`path:/api/database/${id}/idfields`, fields, {
    name,
  });
}

export const setupUnauthorizedSchemaEndpoints = (db: Database) => {
  fetchMock.get(`path:/api/database/${db.id}/schemas`, {
    status: 403,
    body: PERMISSION_ERROR,
  });
};

export function setupUnauthorizedDatabaseEndpoints(db: Database) {
  fetchMock.get(`path:/api/database/${db.id}`, {
    status: 403,
    body: PERMISSION_ERROR,
  });

  setupUnauthorizedSchemaEndpoints(db);
}

export function setupUnauthorizedDatabasesEndpoints(dbs: Database[]) {
  dbs.forEach((db) => setupUnauthorizedDatabaseEndpoints(db));
}

export function setupDatabaseDismissSpinnerEndpoint(db: Database) {
  fetchMock.post(`path:/api/database/${db.id}/dismiss_spinner`, {
    status: 204,
  });
}