@metabase/client 0.0.0-stage → 0.1.1

package/dist/resources/data-app.js

@@ -0,0 +1,75 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { DataApp, DataAppEntry } from "../domain/data-app.js";
+import { z } from "zod";
+//#region src/resources/data-app.ts
+const DATA_APPS_PATH = "/api/ee/apps";
+function appPath(slug) {
+	return `${DATA_APPS_PATH}/${encodeURIComponent(slug)}`;
+}
+function dataAppResource(transport) {
+	const { explain } = explainer(transport, "dataApp");
+	/** List the data apps; `available` keeps only the enabled ones that aren't outdated. `GET /api/ee/apps` answers a bare array. */
+	async function list(filter = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(z.array(DataAppEntry), DATA_APPS_PATH, {
+				...options,
+				query: { available: filter.available }
+			}),
+			total: null
+		};
+	}
+	/** Get one data app by slug; admins read disabled apps too. */
+	async function get(slug, options = {}) {
+		return transport.requestParsed(DataAppEntry, appPath(slug), { ...options });
+	}
+	/** Create a data app with its resource collection and an empty bundle; it is disabled unless the body says otherwise. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(DataApp, DATA_APPS_PATH, {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a data app's fields, or enable or disable it. */
+	async function update(slug, params, options = {}) {
+		return transport.requestParsed(DataApp, appPath(slug), {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Replace a data app's bundle with the text of a built bundle. */
+	async function replaceBundle(slug, bundle, options = {}) {
+		return transport.requestParsed(DataApp, `${appPath(slug)}/bundle`, {
+			...options,
+			method: "PUT",
+			body: { bundle }
+		});
+	}
+	/** The TypeScript module of the app's queries and actions: a `defineQuery` or `defineAction` call per question and action in its collection. */
+	async function typedSchema(slug, options = {}) {
+		return (await transport.requestRaw(`${appPath(slug)}/typed-schema`, {
+			...options,
+			expectContentType: "text"
+		})).text();
+	}
+	/** Delete a data app with its bundle, its collection and its group assignments. */
+	async function remove(slug, options = {}) {
+		await transport.requestRaw(appPath(slug), {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		list: explain("list", list),
+		get: explain("get", get),
+		create: explain("create", create),
+		update: explain("update", update),
+		replaceBundle: explain("replaceBundle", replaceBundle),
+		typedSchema: explain("typedSchema", typedSchema),
+		delete: explain("delete", remove)
+	};
+}
+//#endregion
+export { dataAppResource };

package/dist/resources/database.d.ts

@@ -0,0 +1,2 @@
+import { i as databaseResource, n as DatabaseListParams, r as DatabaseSyncSchemaParams, t as DatabaseGetParams } from "../database-B0JNZjDN.js";
+export { DatabaseGetParams, DatabaseListParams, DatabaseSyncSchemaParams, databaseResource };

package/dist/resources/database.js

@@ -0,0 +1,103 @@
+import { Table } from "../domain/table.js";
+import { Database, DatabaseWithSettings } from "../domain/database.js";
+import { pollUntil } from "../poll.js";
+import { z } from "zod";
+//#region src/resources/database.ts
+const DatabaseApiList = z.object({
+	data: z.array(Database),
+	total: z.number().int().nonnegative()
+}).loose();
+const DatabaseTaskAck = z.object({ status: z.literal("ok") });
+const DatabaseApiSchemaList = z.array(z.string());
+const DatabaseApiSchemaTableList = z.array(Table);
+const SYNC_COMPLETE = "complete";
+function databaseResource(transport) {
+	/** List databases. `include` hydrates each database's tables; `saved` adds the Saved Questions virtual database. */
+	async function list(params = {}, options = {}) {
+		const response = await transport.requestParsed(DatabaseApiList, "/api/database", {
+			...options,
+			query: {
+				include: params.include,
+				saved: params.saved
+			}
+		});
+		return {
+			data: response.data,
+			total: response.total
+		};
+	}
+	/** Get one database by id. `include` hydrates its tables, and `tables.fields` their fields too. */
+	async function get(id, params = {}, options = {}) {
+		return transport.requestParsed(Database, `/api/database/${id}`, {
+			...options,
+			query: { include: params.include }
+		});
+	}
+	/** Update a database's settings by id; the server merges them into the ones it holds. */
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(DatabaseWithSettings, `/api/database/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** List the schema names in a database. */
+	async function schemas(id, options = {}) {
+		return {
+			data: await transport.requestParsed(DatabaseApiSchemaList, `/api/database/${id}/schemas`, { ...options }),
+			total: null
+		};
+	}
+	/** List the tables one schema of a database holds. */
+	async function schemaTables(id, schema, options = {}) {
+		return {
+			data: await transport.requestParsed(DatabaseApiSchemaTableList, `/api/database/${id}/schema/${encodeURIComponent(schema)}`, { ...options }),
+			total: null
+		};
+	}
+	/**
+	* Trigger a manual schema sync for a database. The endpoint queues the sync and returns at once;
+	* pass `wait` to poll the database until it reports its initial sync complete.
+	*/
+	async function syncSchema(id, params = {}, options = {}) {
+		const ack = await transport.requestParsed(DatabaseTaskAck, `/api/database/${id}/sync_schema`, {
+			...options,
+			method: "POST"
+		});
+		const wait = params.wait;
+		if (wait === void 0) return {
+			id,
+			status: ack.status
+		};
+		const database = await pollUntil(async (signal) => transport.requestParsed(Database, `/api/database/${id}`, {
+			...options,
+			signal
+		}), (candidate) => candidate.initial_sync_status === SYNC_COMPLETE, wait);
+		return {
+			id,
+			status: ack.status,
+			initial_sync_status: database.initial_sync_status ?? null
+		};
+	}
+	/** Trigger a rescan of the cached field values across a database. */
+	async function rescanValues(id, options = {}) {
+		return {
+			id,
+			status: (await transport.requestParsed(DatabaseTaskAck, `/api/database/${id}/rescan_values`, {
+				...options,
+				method: "POST"
+			})).status
+		};
+	}
+	return {
+		list,
+		get,
+		update,
+		schemas,
+		schemaTables,
+		syncSchema,
+		rescanValues
+	};
+}
+//#endregion
+export { databaseResource };

package/dist/resources/dataset.d.ts

@@ -0,0 +1,2 @@
+import { n as DatasetNativeParams, r as datasetResource, t as DatasetExportParams } from "../dataset-BUirJ1rO.js";
+export { DatasetExportParams, DatasetNativeParams, datasetResource };

package/dist/resources/dataset.js

@@ -0,0 +1,81 @@
+import { CardQueryResult } from "../domain/card.js";
+import { CompiledQuery, QueryMetadata } from "../domain/dataset.js";
+import { assertPivotedExport } from "./pivot-export.js";
+//#region src/resources/dataset.ts
+function datasetResource(transport) {
+	/**
+	* Run an ad-hoc query and return its result envelope. The body is a whole query — MBQL 5, legacy
+	* MBQL, or native — rather than a reference to a saved one, so nothing here is a card.
+	*/
+	async function query(body, options = {}) {
+		return transport.requestParsed(CardQueryResult, "/api/dataset", {
+			...options,
+			method: "POST",
+			body
+		});
+	}
+	/**
+	* Fetch a native version of an MBQL query. `pretty` rides in the same body as the query and
+	* defaults server-side to true.
+	*/
+	async function native(datasetQuery, params = {}, options = {}) {
+		return transport.requestParsed(CompiledQuery, "/api/dataset/native", {
+			...options,
+			method: "POST",
+			body: {
+				...datasetQuery,
+				pretty: params.pretty
+			}
+		});
+	}
+	/**
+	* Get all of the required query metadata for an ad-hoc query: the databases, tables, fields and
+	* snippets it references. `{ settings: { "include-sensitive-fields": true } }` inside the query
+	* widens the field filter.
+	*/
+	async function queryMetadata(datasetQuery, options = {}) {
+		return transport.requestParsed(QueryMetadata, "/api/dataset/query_metadata", {
+			...options,
+			method: "POST",
+			body: datasetQuery
+		});
+	}
+	/**
+	* Execute a query and download the result data as a file in the specified format. Unlike
+	* `query`, this endpoint answers bytes, so a caller consumes the stream rather than a value.
+	* `visualization_settings` drive `format_rows` column formatting and, through
+	* `pivot_table.column_split`, the layout `pivot_results` lays the rows out in. The server only
+	* computes that layout for a query it runs as a pivot, which it reads from the query's own
+	* `was-pivot`, so `pivot_results` sets it. A pivot the server would answer with plain rows (a
+	* JSON export, or pivoted exports turned off) is refused. `csv_include_bom` opens a CSV with a
+	* UTF-8 byte order mark; a server without it drops the key silently, so asking for one is refused
+	* there before the wire.
+	*/
+	async function exportQuery(format, params, options = {}) {
+		if (params.pivot_results) await assertPivotedExport(transport, format, options);
+		await transport.requireFeatures(params.csv_include_bom ? ["exportCsvByteOrderMark"] : [], options);
+		const exported = params.pivot_results ? {
+			...params.query,
+			"was-pivot": true
+		} : params.query;
+		return transport.requestStream(`/api/dataset/${format}`, {
+			...options,
+			method: "POST",
+			body: {
+				query: exported,
+				visualization_settings: params.visualization_settings,
+				format_rows: params.format_rows,
+				pivot_results: params.pivot_results,
+				csv_include_bom: params.csv_include_bom
+			}
+		});
+	}
+	return {
+		query,
+		native,
+		queryMetadata,
+		exportQuery
+	};
+}
+//#endregion
+export { datasetResource };

package/dist/resources/dependency.d.ts

@@ -0,0 +1,2 @@
+import { a as dependencyResource, i as DependencyItemPageOptions, n as DependencyDependentsParams, r as DependencyItemListParams, t as DependencyBrokenParams } from "../dependency-CzpXmeu7.js";
+export { DependencyBrokenParams, DependencyDependentsParams, DependencyItemListParams, DependencyItemPageOptions, dependencyResource };

package/dist/resources/dependency.js

@@ -0,0 +1,156 @@
+import { paginatePages } from "../paginate.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { BreakingSource, DependencyEntity, DependencyGraph, DependencyNode } from "../domain/dependency.js";
+import { z } from "zod";
+//#region src/resources/dependency.ts
+const DependencyNodeApiList = z.array(DependencyNode);
+const DependencyEntityApiList = z.array(DependencyEntity);
+function entityTypeFeatures(type) {
+	if (type === "measure") return [{
+		feature: "measureDependencyGraph",
+		fields: ["type"]
+	}];
+	if (type === "action") return [{
+		feature: "actionDependencyGraph",
+		fields: ["type"]
+	}];
+	return [];
+}
+function dependencyResource(transport) {
+	const { explain, explainWalk } = explainer(transport, "dependency");
+	/**
+	* The upstream dependency graph of one entity. `nodes` holds the starting entity plus every
+	* entity it depends on, directly or transitively; each edge runs from the dependent to what it
+	* depends on. A measure starts a graph only on a server with `measureDependencyGraph`, and an
+	* action only on one with `actionDependencyGraph`.
+	*/
+	async function graph(type, id, options = {}) {
+		return transport.requestParsed(DependencyGraph, "/api/ee/dependencies/graph", {
+			...options,
+			query: {
+				type,
+				id
+			}
+		});
+	}
+	/**
+	* The entities that depend directly on one entity. `dependent-types` and `dependent-card-types`
+	* narrow which kinds are listed, `broken` keeps only those whose query the entity has broken,
+	* `query` matches against names and locations, `include-personal-collections` admits content in
+	* personal collections, and `sort-column` / `sort-direction` order the result.
+	*/
+	async function dependents(type, id, params = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(DependencyNodeApiList, "/api/ee/dependencies/graph/dependents", {
+				...options,
+				query: {
+					type,
+					id,
+					"dependent-types": params["dependent-types"],
+					"dependent-card-types": params["dependent-card-types"],
+					broken: params.broken,
+					query: params.query,
+					"include-personal-collections": params["include-personal-collections"],
+					"sort-column": params["sort-column"],
+					"sort-direction": params["sort-direction"]
+				}
+			}),
+			total: null
+		};
+	}
+	/**
+	* The dependents of one entity whose queries it has broken, as bare entities without a
+	* dependents count. `dependent-types` and `dependent-card-types` narrow which kinds are listed,
+	* `include-personal-collections` admits content in personal collections, and `sort-column` /
+	* `sort-direction` order the result.
+	*/
+	async function broken(type, id, params = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(DependencyEntityApiList, "/api/ee/dependencies/graph/broken", {
+				...options,
+				query: {
+					type,
+					id,
+					"dependent-types": params["dependent-types"],
+					"dependent-card-types": params["dependent-card-types"],
+					"include-personal-collections": params["include-personal-collections"],
+					"sort-column": params["sort-column"],
+					"sort-direction": params["sort-direction"]
+				}
+			}),
+			total: null
+		};
+	}
+	/**
+	* Walk the entities that no readable, unarchived dependent depends on, one page at a time: an
+	* entity used only by archived content, or by content the caller cannot read, is listed. `types`
+	* and `card-types` narrow which kinds are listed, `query` matches against names and locations,
+	* `include-personal-collections` admits content in personal collections, and `sort-column` /
+	* `sort-direction` order the result. A `query` leaves sandboxes out, since they have no name or
+	* location to match, so sandboxes alone with a `query` answer one empty page without a request.
+	* This endpoint pages on the server, so the caller consumes pages and decides how far to pull.
+	*/
+	async function* unreferencedPages(params = {}, options = {}) {
+		if (queryLeavesNoKind(params)) {
+			yield {
+				items: [],
+				total: 0
+			};
+			return;
+		}
+		yield* paginatePages(transport, "/api/ee/dependencies/graph/unreferenced", DependencyNode, {
+			query: itemListQuery(params),
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	}
+	/**
+	* Walk the entities whose dependents carry analysis errors, one page at a time, each with the
+	* `dependents_errors` rows found downstream of it. The server lists cards and tables unless
+	* `types` says otherwise; `card-types`, `query`, `include-personal-collections`, `sort-column`
+	* and `sort-direction` read as on `unreferencedPages`. This endpoint pages on the server, so the
+	* caller consumes pages and decides how far to pull.
+	*/
+	async function* breakingPages(params = {}, options = {}) {
+		if (queryLeavesNoKind(params)) {
+			yield {
+				items: [],
+				total: 0
+			};
+			return;
+		}
+		yield* paginatePages(transport, "/api/ee/dependencies/graph/breaking", BreakingSource, {
+			query: itemListQuery(params),
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	}
+	return {
+		graph: explain("graph", graph, entityTypeFeatures),
+		dependents: explain("dependents", dependents, entityTypeFeatures),
+		broken: explain("broken", broken, entityTypeFeatures),
+		unreferencedPages: explainWalk("unreferencedPages", unreferencedPages),
+		breakingPages: explainWalk("breakingPages", breakingPages)
+	};
+}
+function queryLeavesNoKind(params) {
+	const { query, types } = params;
+	if (query === void 0 || types === void 0 || types.length === 0) return false;
+	return types.every((type) => type === "sandbox");
+}
+function itemListQuery(params) {
+	return {
+		types: params.types === void 0 ? void 0 : [...new Set(params.types)],
+		"card-types": params["card-types"],
+		query: params.query,
+		"include-personal-collections": params["include-personal-collections"],
+		"sort-column": params["sort-column"],
+		"sort-direction": params["sort-direction"]
+	};
+}
+//#endregion
+export { dependencyResource };

package/dist/resources/document.d.ts

@@ -0,0 +1,55 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+import { a as DocumentUpdateInput, i as DocumentCreateInput, t as Document } from "../document-tLd6pYWe.js";
+//#region src/resources/document.d.ts
+declare function documentResource(transport: Transport): {
+  list: (options?: RequestOptions) => Promise<ListResult<Document>>;
+  get: (id: number, options?: RequestOptions) => Promise<Document>;
+  create: (params: DocumentCreateInput, options?: RequestOptions) => Promise<Document>;
+  update: (id: number, params: DocumentUpdateInput, options?: RequestOptions) => Promise<Document>;
+  archive: (id: number, options?: RequestOptions) => Promise<Document>;
+  copy: (id: number, params?: {
+    name?: string | null | undefined;
+    collection_id?: number | null | undefined;
+    collection_position?: number | null | undefined;
+  } | undefined, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    document: {
+      [x: string]: unknown;
+      type: string;
+      text?: string | undefined;
+      attrs?: Record<string, unknown> | undefined;
+      marks?: Record<string, unknown>[] | undefined;
+      content?: {
+        [x: string]: unknown;
+        type: string;
+        text?: string | undefined;
+        attrs?: Record<string, unknown> | undefined;
+        marks?: Record<string, unknown>[] | undefined;
+        content?: /*elided*/ any[] | undefined;
+      }[] | undefined;
+    } | null;
+    entity_id: string | null;
+    collection_id: number | null;
+    creator_id: number;
+    archived: boolean;
+    created_at: string;
+    updated_at: string;
+    collection_position?: number | null | undefined;
+    creator?: {
+      [x: string]: unknown;
+      id: number;
+      email: string;
+      first_name: string | null;
+      last_name: string | null;
+    } | null | undefined;
+    can_write?: boolean | undefined;
+    can_delete?: boolean | undefined;
+    can_restore?: boolean | undefined;
+    is_remote_synced?: boolean | undefined;
+  }>;
+};
+//#endregion
+export { documentResource };

package/dist/resources/document.js

@@ -0,0 +1,60 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { Document } from "../domain/document.js";
+import { z } from "zod";
+//#region src/resources/document.ts
+const DocumentApiList = z.object({ items: z.array(Document) }).loose();
+function documentResource(transport) {
+	const { explain } = explainer(transport, "document");
+	/** Get existing documents. */
+	async function list(options = {}) {
+		return {
+			data: (await transport.requestParsed(DocumentApiList, "/api/document", { ...options })).items,
+			total: null
+		};
+	}
+	/** Return an existing document by id. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(Document, `/api/document/${id}`, { ...options });
+	}
+	/** Create a new document. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(Document, "/api/document", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update an existing document by id. */
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(Document, `/api/document/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Archive (soft-delete) a document by id. Metabase models this as an update, not its own endpoint. */
+	async function archive(id, options = {}) {
+		return update(id, { archived: true }, options);
+	}
+	/**
+	* Copy a document into `collection_id` (root when absent), duplicating the cards saved inside
+	* it. An archived source is not found.
+	*/
+	async function copy(id, params = {}, options = {}) {
+		return transport.requestParsed(Document, `/api/document/${id}/copy`, {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive,
+		copy: explain("copy", copy)
+	};
+}
+//#endregion
+export { documentResource };

package/dist/resources/eid-translation.d.ts

@@ -0,0 +1,8 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.js";
+import { a as EidTranslateResult, i as EidTranslateInput } from "../eid-translation-CH6NPWd-.js";
+//#region src/resources/eid-translation.d.ts
+declare function eidTranslationResource(transport: Transport): {
+  translate: (params: EidTranslateInput, options?: RequestOptions) => Promise<EidTranslateResult>;
+};
+//#endregion
+export { eidTranslationResource };

package/dist/resources/eid-translation.js

@@ -0,0 +1,19 @@
+import { EidTranslateResult } from "../domain/eid-translation.js";
+//#region src/resources/eid-translation.ts
+function eidTranslationResource(transport) {
+	/**
+	* Translate entity ids to the numeric ids of the rows they name. The request groups the entity
+	* ids by model; the response is keyed by entity id, each entry carrying its model and — when the
+	* lookup succeeded — the numeric id.
+	*/
+	async function translate(params, options = {}) {
+		return transport.requestParsed(EidTranslateResult, "/api/eid-translation/translate", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return { translate };
+}
+//#endregion
+export { eidTranslationResource };

package/dist/resources/erd.d.ts

@@ -0,0 +1,2 @@
+import { n as erdResource, t as ErdParams } from "../erd-CbV7xvAc.js";
+export { ErdParams, erdResource };

package/dist/resources/erd.js

@@ -0,0 +1,26 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { Erd } from "../domain/erd.js";
+//#region src/resources/erd.ts
+const ERD_PATH = "/api/ee/erd";
+function erdResource(transport) {
+	const { explain } = explainer(transport, "erd");
+	/**
+	* Get the entity relationship diagram of a database: the readable tables as nodes, each with its
+	* fields, and the foreign keys between them as edges. `table-ids` makes those tables the focal
+	* points and draws their neighbours; `schema` keeps one schema, the empty string the tables with
+	* none.
+	*/
+	async function get(params, options = {}) {
+		return transport.requestParsed(Erd, ERD_PATH, {
+			...options,
+			query: {
+				"database-id": params["database-id"],
+				"table-ids": params["table-ids"],
+				schema: params.schema
+			}
+		});
+	}
+	return { get: explain("get", get) };
+}
+//#endregion
+export { erdResource };

package/dist/resources/field.d.ts

@@ -0,0 +1,2 @@
+import { a as FieldSetDataSensitivityParams, i as FieldSearchParams, n as FieldSearchBounded, o as fieldResource, r as FieldSearchByValue, t as FieldRemappingParams } from "../field-D1Pfk-0S.js";
+export { FieldRemappingParams, FieldSearchBounded, FieldSearchByValue, FieldSearchParams, FieldSetDataSensitivityParams, fieldResource };