@metabase/client 0.0.0-stage → 0.1.0

package/dist/resources/segment.d.ts

@@ -0,0 +1,2 @@
+import { n as segmentResource, t as SegmentArchiveParams } from "../segment-D2i34X9l.js";
+export { SegmentArchiveParams, segmentResource };

package/dist/resources/segment.js

@@ -0,0 +1,55 @@
+import { Segment } from "../domain/segment.js";
+import { z } from "zod";
+//#region src/resources/segment.ts
+const SegmentApiList = z.array(Segment);
+function segmentResource(transport) {
+	/** List every segment the caller can see. */
+	async function list(options = {}) {
+		return {
+			data: await transport.requestParsed(SegmentApiList, "/api/segment", { ...options }),
+			total: null
+		};
+	}
+	/** Get one segment by id. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(Segment, `/api/segment/${id}`, { ...options });
+	}
+	/** Create a segment — a reusable row filter over one table — from a full segment body. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(Segment, "/api/segment", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a segment by id, patching only the fields the body carries. `revision_message` is
+	* required: Metabase records every segment change in its revision history.
+	*/
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(Segment, `/api/segment/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a segment by id. Metabase models this as an update, so it carries the
+	* same required `revision_message`.
+	*/
+	async function archive(id, params, options = {}) {
+		return update(id, {
+			archived: true,
+			revision_message: params.revision_message
+		}, options);
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive
+	};
+}
+//#endregion
+export { segmentResource };

package/dist/resources/setting.d.ts

@@ -0,0 +1,11 @@
+import { f as RequestOptions, h as Transport } from "../transport-E0ZaPNWJ.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+import { t as Setting } from "../setting-DXuQGXGF.js";
+//#region src/resources/setting.d.ts
+declare function settingResource(transport: Transport): {
+  list: (options?: RequestOptions) => Promise<ListResult<Setting>>;
+  get: (key: string, options?: RequestOptions) => Promise<unknown>;
+  set: (key: string, value: unknown, options?: RequestOptions) => Promise<void>;
+};
+//#endregion
+export { settingResource };

package/dist/resources/setting.js

@@ -0,0 +1,43 @@
+import { ConfigError, errorMessage } from "../errors.js";
+import { fetchOptionalParsed } from "./optional-parsed.js";
+import { Setting } from "../domain/setting.js";
+import { z } from "zod";
+//#region src/resources/setting.ts
+const SettingApiList = z.array(Setting);
+const UNKNOWN_SETTING_PREFIX = "Unknown setting:";
+function rethrowSettingError(error, key) {
+	if (errorMessage(error).startsWith(UNKNOWN_SETTING_PREFIX)) throw new ConfigError(`unknown setting: ${key}`);
+	throw error;
+}
+function settingResource(transport) {
+	/** Get all settings and their values, with descriptions and environment-variable names. */
+	async function list(options = {}) {
+		return {
+			data: await transport.requestParsed(SettingApiList, "/api/setting", { ...options }),
+			total: null
+		};
+	}
+	/**
+	* Fetch a single setting's value by key. An unset setting answers 204 rather than 404, which
+	* reaches the caller as `null`; a string-typed setting answers bare text rather than JSON.
+	*/
+	async function get(key, options = {}) {
+		return fetchOptionalParsed(transport, `/api/setting/${encodeURIComponent(key)}`, z.unknown(), options).catch((error) => rethrowSettingError(error, key));
+	}
+	/** Set a single setting's value by key. The endpoint answers 204 with no body. */
+	async function set(key, value, options = {}) {
+		await transport.requestRaw(`/api/setting/${encodeURIComponent(key)}`, {
+			...options,
+			method: "PUT",
+			body: { value },
+			expectContentType: "binary"
+		}).catch((error) => rethrowSettingError(error, key));
+	}
+	return {
+		list,
+		get,
+		set
+	};
+}
+//#endregion
+export { settingResource };

package/dist/resources/setup.d.ts

@@ -0,0 +1,8 @@
+import { f as RequestOptions, h as Transport } from "../transport-E0ZaPNWJ.js";
+import { n as SetupResult, t as SetupInput } from "../setup-Ez_U7GmM.js";
+//#region src/resources/setup.d.ts
+declare function setupResource(transport: Transport): {
+  create: (params: SetupInput, options?: RequestOptions) => Promise<SetupResult>;
+};
+//#endregion
+export { setupResource };

package/dist/resources/setup.js

@@ -0,0 +1,18 @@
+import { SetupResult } from "../domain/setup.js";
+//#region src/resources/setup.ts
+function setupResource(transport) {
+	/**
+	* Complete the initial setup wizard on a fresh instance, creating its first admin user and
+	* applying the instance preferences. The setup token is single-use.
+	*/
+	async function create(params, options = {}) {
+		return transport.requestParsed(SetupResult, "/api/setup", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return { create };
+}
+//#endregion
+export { setupResource };

package/dist/resources/snippet.d.ts

@@ -0,0 +1,2 @@
+import { n as snippetResource, t as SnippetListParams } from "../snippet-RnnWa4TL.js";
+export { SnippetListParams, snippetResource };

package/dist/resources/snippet.js

@@ -0,0 +1,52 @@
+import { Snippet } from "../domain/snippet.js";
+import { z } from "zod";
+//#region src/resources/snippet.ts
+const SnippetApiList = z.array(Snippet);
+function snippetResource(transport) {
+	/** List native query snippets. `archived` swaps the listing to archived snippets. */
+	async function list(params = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(SnippetApiList, "/api/native-query-snippet", {
+				...options,
+				query: { archived: params.archived }
+			}),
+			total: null
+		};
+	}
+	/** Get one native query snippet by id. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(Snippet, `/api/native-query-snippet/${id}`, { ...options });
+	}
+	/** Create a native query snippet from a name, its SQL fragment, and an optional collection. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(Snippet, "/api/native-query-snippet", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a native query snippet by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(Snippet, `/api/native-query-snippet/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a native query snippet by id. Metabase models this as an update, not its
+	* own endpoint.
+	*/
+	async function archive(id, options = {}) {
+		return update(id, { archived: true }, options);
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive
+	};
+}
+//#endregion
+export { snippetResource };

package/dist/resources/table.d.ts

@@ -0,0 +1,2 @@
+import { n as tableResource, t as TableListParams } from "../table-B_lfuaHc.js";
+export { TableListParams, tableResource };

package/dist/resources/table.js

@@ -0,0 +1,275 @@
+import { PartialWriteError } from "../errors.js";
+import { CapabilityError } from "../version/capability-error.js";
+import { supersedingFeature } from "../version/requirement-check.js";
+import { Table, TableDataLayerTier, TableForeignKey, TableQueryMetadata, TableSelectors } from "../domain/table.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { buildCsvFormData } from "./csv-upload.js";
+import { fetchOptionalParsed } from "./optional-parsed.js";
+import { parseRequestBody } from "./request-body.js";
+import { z } from "zod";
+//#region src/resources/table.ts
+const TableApiList = z.array(Table);
+const TableApiFks = z.array(TableForeignKey);
+const SyncSchemaResponse = z.object({ status: z.literal("ok") });
+const FieldValuesResponse = z.object({ status: z.literal("success") });
+const BulkEditResponse = z.object({});
+const BULK_EDIT_PATH = "/api/data-studio/table/edit";
+const BULK_SYNC_SCHEMA_PATH = "/api/data-studio/table/sync-schema";
+const BULK_RESCAN_VALUES_PATH = "/api/data-studio/table/rescan-values";
+const BULK_DISCARD_VALUES_PATH = "/api/data-studio/table/discard-values";
+const LIST_PARAM_FEATURES = [
+	["can-query", "tableListAccessFilters"],
+	["can-write", "tableListAccessFilters"],
+	["include-transform-targets", "tableListTransformTargets"],
+	["unused-only", "tableUnusedFilter"],
+	["published-only", "tableListPublishedFilter"]
+];
+function listParamFeatures(params) {
+	return LIST_PARAM_FEATURES.filter(([param]) => params[param] === true).map(([, feature]) => feature);
+}
+function dataLayerFeatures(value, field) {
+	return isTierName(value) ? [{
+		feature: "tableDataLayerTiers",
+		fields: [field]
+	}] : [];
+}
+function isTierName(value) {
+	return value !== null && value !== void 0 && TableDataLayerTier.safeParse(value).success;
+}
+const UPLOAD_UPDATE_PATHS = {
+	append: "append-csv",
+	replace: "replace-csv"
+};
+function tableResource(transport) {
+	const { explain } = explainer(transport, "table");
+	/**
+	* List every table the caller can see, across all databases. `term` matches names and display
+	* names; `can-query` and `can-write` keep only the tables the caller may query or edit the
+	* metadata of; `include-transform-targets` adds tables a transform writes to; `unused-only` keeps
+	* tables nothing depends on; `published-only` keeps tables published to the library.
+	*/
+	async function list(params = {}, options = {}) {
+		await transport.requireFeatures(listParamFeatures(params), options);
+		return {
+			data: await transport.requestParsed(TableApiList, "/api/table", {
+				...options,
+				query: {
+					term: params.term,
+					"visibility-type": params["visibility-type"],
+					"data-layer": params["data-layer"],
+					"data-source": params["data-source"],
+					"owner-user-id": params["owner-user-id"],
+					"owner-email": params["owner-email"],
+					"orphan-only": params["orphan-only"],
+					"unused-only": params["unused-only"],
+					"published-only": params["published-only"],
+					"can-query": params["can-query"],
+					"can-write": params["can-write"],
+					"include-transform-targets": params["include-transform-targets"]
+				}
+			}),
+			total: null
+		};
+	}
+	/** Get one table by id, without its fields. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(Table, `/api/table/${id}`, { ...options });
+	}
+	/** Update a table by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		await refuseRewrittenDataLayer(params.data_layer, options);
+		await requireDataAuthorityNull(params.data_authority, options);
+		const path = `/api/table/${id}`;
+		const updated = await transport.requestParsed(Table, path, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+		assertCollectionWritten(path, params.collection_id, updated);
+		return updated;
+	}
+	async function refuseRewrittenDataLayer(value, options) {
+		if (value === null || value === void 0 || isTierName(value)) return;
+		const profile = await transport.preflightServer(options);
+		if (profile === null) return;
+		const failure = supersedingFeature("tableDataLayerTiers", profile, `data_layer "${value}" is a medallion name; this server names a table's layer ${TableDataLayerTier.options.join(", ")} and would map it onto one of those without a word`);
+		if (failure !== null) transport.refuseBeforeSending(new CapabilityError(failure));
+	}
+	/** Get a table by id with its fields hydrated — the metadata the query builder runs on. */
+	async function queryMetadata(id, options = {}) {
+		return transport.requestParsed(TableQueryMetadata, `/api/table/${id}/query_metadata`, { ...options });
+	}
+	/**
+	* Get every foreign key whose destination is a field of this table. A table with no active
+	* fields answers no content, which is the same empty list.
+	*/
+	async function fks(id, options = {}) {
+		return {
+			data: await fetchOptionalParsed(transport, `/api/table/${id}/fks`, TableApiFks, { ...options }) ?? [],
+			total: null
+		};
+	}
+	/**
+	* Trigger a sync of this table: its columns, their fingerprints and its cached field values. It
+	* never discovers new tables. The sync runs after the call returns; a warehouse the server cannot
+	* connect to is a 422.
+	*/
+	async function syncSchema(id, options = {}) {
+		return {
+			id,
+			status: (await transport.requestParsed(SyncSchemaResponse, `/api/table/${id}/sync_schema`, {
+				...options,
+				method: "POST"
+			})).status
+		};
+	}
+	/**
+	* Trigger an update of the field values of every eligible field of this table that already has a
+	* cached set. The scan runs after the call returns.
+	*/
+	async function rescanValues(id, options = {}) {
+		return {
+			id,
+			status: (await transport.requestParsed(FieldValuesResponse, `/api/table/${id}/rescan_values`, {
+				...options,
+				method: "POST"
+			})).status
+		};
+	}
+	/**
+	* Discard the cached field values of every field of this table, custom display values included.
+	* No scan recreates a discarded set; the server rebuilds it, without the display values, the next
+	* time the field's values are read.
+	*/
+	async function discardValues(id, options = {}) {
+		return {
+			id,
+			status: (await transport.requestParsed(FieldValuesResponse, `/api/table/${id}/discard_values`, {
+				...options,
+				method: "POST"
+			})).status
+		};
+	}
+	/**
+	* Set the same metadata on every table the selectors pick out. A table leaving the `hidden` data
+	* layer is re-synced after the call returns. The server answers the same whether or not the
+	* selectors matched a table.
+	*/
+	async function bulkEdit(params, options = {}) {
+		await requireDataAuthorityNull(params.data_authority, options);
+		await transport.requestParsed(BulkEditResponse, BULK_EDIT_PATH, {
+			...options,
+			method: "POST",
+			body: params
+		});
+		return {
+			accepted: true,
+			...params
+		};
+	}
+	async function requireDataAuthorityNull(value, options) {
+		if (value === null) await transport.requireFeatures(["tableUserValueWithdrawal"], options);
+	}
+	async function postSelection(path, selectors, options) {
+		const body = parseRequestBody(TableSelectors, selectors, "table selectors");
+		await transport.requestRaw(path, {
+			...options,
+			method: "POST",
+			body,
+			expectContentType: "binary"
+		});
+		return {
+			accepted: true,
+			...body
+		};
+	}
+	/**
+	* Trigger a sync of every table the selectors pick out: its columns, their fingerprints and its
+	* cached field values. Every database behind them must answer a connection test first, or the
+	* call is a 422; the syncs run after it returns.
+	*/
+	async function bulkSyncSchema(selectors, options = {}) {
+		return postSelection(BULK_SYNC_SCHEMA_PATH, selectors, options);
+	}
+	/**
+	* Trigger a field-values rescan of every table the selectors pick out, refreshing the sets that
+	* are already cached. The scans run after the call returns.
+	*/
+	async function bulkRescanValues(selectors, options = {}) {
+		return postSelection(BULK_RESCAN_VALUES_PATH, selectors, options);
+	}
+	/**
+	* Discard the cached field values of every table the selectors pick out, custom display values
+	* included. No scan recreates a discarded set.
+	*/
+	async function bulkDiscardValues(selectors, options = {}) {
+		return postSelection(BULK_DISCARD_VALUES_PATH, selectors, options);
+	}
+	async function updateFromCsv(id, action, file, options) {
+		await transport.requestRaw(`/api/table/${id}/${UPLOAD_UPDATE_PATHS[action]}`, {
+			...options,
+			method: "POST",
+			body: buildCsvFormData(file),
+			expectContentType: "binary"
+		});
+		return {
+			table_id: id,
+			action
+		};
+	}
+	/**
+	* Inserts the rows of an uploaded CSV file into the table identified by `id`. The table must have
+	* been created by uploading a CSV file.
+	*
+	* The file may be at most 50 MB; larger uploads are rejected with a 413 response.
+	*/
+	async function appendCsv(id, file, options = {}) {
+		return updateFromCsv(id, "append", file, options);
+	}
+	/**
+	* Replaces the contents of the table identified by `id` with the rows of an uploaded CSV file.
+	* The table must have been created by uploading a CSV file.
+	*
+	* The file may be at most 50 MB; larger uploads are rejected with a 413 response.
+	*/
+	async function replaceCsv(id, file, options = {}) {
+		return updateFromCsv(id, "replace", file, options);
+	}
+	return {
+		list: explain("list", list, (params) => dataLayerFeatures(params?.["data-layer"], "data-layer")),
+		get,
+		update: explain("update", update, (_id, params) => dataLayerFeatures(params.data_layer, "data_layer")),
+		queryMetadata,
+		fks,
+		syncSchema,
+		rescanValues,
+		discardValues,
+		bulkEdit: explain("bulkEdit", bulkEdit),
+		bulkSyncSchema: explain("bulkSyncSchema", bulkSyncSchema),
+		bulkRescanValues: explain("bulkRescanValues", bulkRescanValues),
+		bulkDiscardValues: explain("bulkDiscardValues", bulkDiscardValues),
+		appendCsv,
+		replaceCsv
+	};
+}
+function assertCollectionWritten(path, requested, table) {
+	if (requested === void 0 || table.collection_id === requested) return;
+	const answered = table.collection_id === void 0 ? { kind: "unreported" } : {
+		kind: "reported",
+		value: table.collection_id
+	};
+	throw new PartialWriteError(`the server applied the rest of the update to table ${table.id} but not collection_id: ${describeCollectionAnswer(answered)}, because this server does not move a table to a collection through an update`, {
+		method: "PUT",
+		path,
+		field: "collection_id",
+		requested,
+		answered
+	});
+}
+function describeCollectionAnswer(answered) {
+	if (answered.kind === "unreported") return "it answered the table without reporting a collection";
+	if (answered.value === null) return "the table stays in no collection";
+	return `the table stays in collection ${answered.value}`;
+}
+//#endregion
+export { tableResource };

package/dist/resources/timeline-event.d.ts

@@ -0,0 +1,12 @@
+import { f as RequestOptions, h as Transport } from "../transport-E0ZaPNWJ.js";
+import { i as TimelineEvent, o as TimelineEventCreateInput, s as TimelineEventUpdateInput } from "../timeline-folD3mQ_.js";
+//#region src/resources/timeline-event.d.ts
+declare function timelineEventResource(transport: Transport): {
+  get: (id: number, options?: RequestOptions) => Promise<TimelineEvent>;
+  create: (params: TimelineEventCreateInput, options?: RequestOptions) => Promise<TimelineEvent>;
+  update: (id: number, params: TimelineEventUpdateInput, options?: RequestOptions) => Promise<TimelineEvent>;
+  archive: (id: number, options?: RequestOptions) => Promise<TimelineEvent>;
+  delete: (id: number, options?: RequestOptions) => Promise<void>;
+};
+//#endregion
+export { timelineEventResource };

package/dist/resources/timeline-event.js

@@ -0,0 +1,51 @@
+import { TimelineEvent } from "../domain/timeline.js";
+//#region src/resources/timeline-event.ts
+function timelineEventResource(transport) {
+	/** Get one timeline event by id. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(TimelineEvent, `/api/timeline-event/${id}`, { ...options });
+	}
+	/** Create a timeline event on an existing timeline. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(TimelineEvent, "/api/timeline-event", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a timeline event by id, patching only the fields the body carries. `timeline_id` moves
+	* the event to another timeline.
+	*/
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(TimelineEvent, `/api/timeline-event/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a timeline event by id. Metabase models this as an update, not its own
+	* endpoint.
+	*/
+	async function archive(id, options = {}) {
+		return update(id, { archived: true }, options);
+	}
+	/** Permanently delete a timeline event by id. The server answers with no body. */
+	async function remove(id, options = {}) {
+		await transport.requestRaw(`/api/timeline-event/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		get,
+		create,
+		update,
+		archive,
+		delete: remove
+	};
+}
+//#endregion
+export { timelineEventResource };

package/dist/resources/timeline.d.ts

@@ -0,0 +1,2 @@
+import { n as TimelineListParams, r as timelineResource, t as TimelineEventsParams } from "../timeline-C2IEcRlP.js";
+export { TimelineEventsParams, TimelineListParams, timelineResource };

package/dist/resources/timeline.js

@@ -0,0 +1,82 @@
+import { Timeline } from "../domain/timeline.js";
+import { z } from "zod";
+//#region src/resources/timeline.ts
+const TimelineApiList = z.array(Timeline);
+const TimelineWithEvents = Timeline.required({ events: true });
+function timelineResource(transport) {
+	/** List timelines. `archived` swaps the active listing for the archived one. */
+	async function list(params = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(TimelineApiList, "/api/timeline", {
+				...options,
+				query: { archived: params.archived }
+			}),
+			total: null
+		};
+	}
+	/** Get one timeline by id, without its events. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(Timeline, `/api/timeline/${id}`, { ...options });
+	}
+	/**
+	* List the events on one timeline. Metabase has no endpoint of its own for these: the same
+	* timeline read hydrates them on request, and `archived` chooses which of them come back.
+	*/
+	async function events(id, params = {}, options = {}) {
+		return {
+			data: (await transport.requestParsed(TimelineWithEvents, `/api/timeline/${id}`, {
+				...options,
+				query: {
+					include: "events",
+					archived: params.archived
+				}
+			})).events,
+			total: null
+		};
+	}
+	/** Create a timeline from a full timeline body. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(Timeline, "/api/timeline", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a timeline by id, patching only the fields the body carries. Changing `archived`
+	* cascades to every event on the timeline.
+	*/
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(Timeline, `/api/timeline/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a timeline and all its events by id. Metabase models this as an update,
+	* not its own endpoint.
+	*/
+	async function archive(id, options = {}) {
+		return update(id, { archived: true }, options);
+	}
+	/** Permanently delete a timeline and all its events by id. The server answers with no body. */
+	async function remove(id, options = {}) {
+		await transport.requestRaw(`/api/timeline/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		list,
+		get,
+		events,
+		create,
+		update,
+		archive,
+		delete: remove
+	};
+}
+//#endregion
+export { timelineResource };

package/dist/resources/transform-dag-run.d.ts

@@ -0,0 +1,22 @@
+import { f as RequestOptions, h as Transport } from "../transport-E0ZaPNWJ.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+//#region src/resources/transform-dag-run.d.ts
+declare function transformDagRunResource(transport: Transport): {
+  transformRuns: (runId: number, options?: RequestOptions | undefined) => Promise<ListResult<{
+    [x: string]: unknown;
+    id: number;
+    transform_id: number | null;
+    run_method: "manual" | "cron";
+    status: "timeout" | "failed" | "started" | "succeeded" | "canceled" | "canceling";
+    is_active: boolean | null;
+    start_time: string;
+    message: string | null;
+    user_id: number | null;
+    job_run_id: number | null;
+    dag_run_id: number | null;
+    end_time?: string | null | undefined;
+  }>>;
+  cancel: (runId: number, options?: RequestOptions | undefined) => Promise<void>;
+};
+//#endregion
+export { transformDagRunResource };