@metabase/client 0.0.0-stage → 0.1.0

package/dist/resources/dependency.js

@@ -0,0 +1,150 @@
+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 graphTypeFeatures(type) {
+	return type === "measure" ? [{
+		feature: "measureDependencyGraph",
+		fields: ["type"]
+	}] : [];
+}
+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`.
+	*/
+	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, graphTypeFeatures),
+		dependents: explain("dependents", dependents),
+		broken: explain("broken", broken),
+		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-E0ZaPNWJ.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+import { a as DocumentUpdateInput, i as DocumentCreateInput, t as Document } from "../document-oZNDbDfx.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-E0ZaPNWJ.js";
+import { a as EidTranslateResult, i as EidTranslateInput } from "../eid-translation-nuhr8St2.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-BujD227Y.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-Bqn10Fq_.js";
+export { FieldRemappingParams, FieldSearchBounded, FieldSearchByValue, FieldSearchParams, FieldSetDataSensitivityParams, fieldResource };

package/dist/resources/field.js

@@ -0,0 +1,98 @@
+import { FieldSearchMatches, FieldValues, FieldWithDataSensitivity, fieldDetailSchema, fieldRemappedValueSchema } from "../domain/field.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { fetchOptionalParsed } from "./optional-parsed.js";
+import { z } from "zod";
+//#region src/resources/field.ts
+const FieldApiSummary = z.tuple([z.tuple([z.literal("count"), z.number().int()]), z.tuple([z.literal("distincts"), z.number().int()])]);
+function fieldResource(transport) {
+	const { refuse } = explainer(transport, "field");
+	/**
+	* Get one field by id. A server that labels data sensitivity answers `data_sensitivity`, `null`
+	* for an unlabelled field; any other answers the field without the key (`hasDataSensitivity`).
+	*/
+	async function get(id, options = {}) {
+		const { features } = await transport.server(options);
+		return transport.requestParsed(fieldDetailSchema(features), `/api/field/${id}`, { ...options });
+	}
+	/**
+	* Update a field by id, patching only the fields the body carries. A `data_sensitivity` label is
+	* a person's call the server's classifier never overwrites, and `null` withdraws it so the
+	* classifier's own applies again; a server without the column would drop the key silently, so
+	* the label is refused there before the wire. Answers the field the way `get` does.
+	*/
+	async function update(id, params, options = {}) {
+		await transport.requireFeatures(params.data_sensitivity === void 0 ? [] : ["fieldDataSensitivity"], options);
+		const { features } = await transport.server(options);
+		return transport.requestParsed(fieldDetailSchema(features), `/api/field/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Label a field's data sensitivity by hand. A person's label is never overwritten by the server's
+	* classifier; `null` withdraws it, so whatever label the classifier wrote shows again. A server
+	* without the column drops the key silently, so the label is refused there before the wire.
+	* Answers the field with the label it now carries.
+	*/
+	async function setDataSensitivity(id, params, options = {}) {
+		return transport.requestParsed(FieldWithDataSensitivity, `/api/field/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Search the values of `searchId` that contain `value`, case-insensitively, answering the
+	* matching values of `id` paired with them, ordered by value, at most `limit` of them. An FK on
+	* either side is followed to the PK it points at, and a field that resolves to the same field as
+	* `searchId` answers each value alone. Without `value`, the first `limit` values. A field with
+	* custom display values answers every mapped value with its display value instead, matching
+	* `value` against the display value, ignoring both `searchId` and `limit`.
+	*/
+	async function search(id, searchId, params, options = {}) {
+		return transport.requestParsed(FieldSearchMatches, `/api/field/${id}/search/${searchId}`, {
+			...options,
+			query: {
+				value: params.value,
+				limit: params.limit
+			}
+		});
+	}
+	/**
+	* The value of `remappedId` on the one row where `id` equals `value`, as `[value, remapped]`,
+	* or `null` when no row matches. For a numeric field the server reads the leading number of
+	* `value` and ignores any text after it, refusing only a `value` that has none.
+	*/
+	async function remapping(id, remappedId, params, options = {}) {
+		const { features } = await transport.server(options);
+		return fetchOptionalParsed(transport, `/api/field/${id}/remapping/${remappedId}`, fieldRemappedValueSchema(features, id === remappedId), {
+			...options,
+			query: { value: params.value }
+		});
+	}
+	/** Get the row count and the distinct-value count for a field. */
+	async function summary(id, options = {}) {
+		const [[, count], [, distincts]] = await transport.requestParsed(FieldApiSummary, `/api/field/${id}/summary`, { ...options });
+		return {
+			field_id: id,
+			count,
+			distincts
+		};
+	}
+	/** Get the cached distinct values Metabase holds for a field. */
+	async function values(id, options = {}) {
+		return transport.requestParsed(FieldValues, `/api/field/${id}/values`, { ...options });
+	}
+	return {
+		get,
+		update,
+		setDataSensitivity: refuse("setDataSensitivity", setDataSensitivity),
+		search,
+		remapping,
+		summary,
+		values
+	};
+}
+//#endregion
+export { fieldResource };

package/dist/resources/git-sync.d.ts

@@ -0,0 +1,2 @@
+import { a as SyncRemoteChangesParams, c as SyncWaitParams, i as SyncImportParams, l as gitSyncResource, n as SyncExportParams, o as SyncScopeCollection, r as SyncExportPreflightParams, s as SyncStashParams, t as SyncCreateBranchParams } from "../git-sync-gAMKsZgN.js";
+export { SyncCreateBranchParams, SyncExportParams, SyncExportPreflightParams, SyncImportParams, SyncRemoteChangesParams, SyncScopeCollection, SyncStashParams, SyncWaitParams, gitSyncResource };