@metabase/cli 0.3.2 → 0.4.0-alpha.release-65-integration-branch.31ca6bb

package/dist/dependency-DzLH3J8P.mjs

@@ -0,0 +1,165 @@
+import { s as CardType } from "./card-P5mBknsl.mjs";
+import { i as CollectionAuthorityLevel, s as CollectionId } from "./collection-D3KXhvnc.mjs";
+import { z } from "zod";
+//#region ../client/src/domain/dependency.ts
+const DependencyType = z.enum([
+	"table",
+	"card",
+	"snippet",
+	"transform",
+	"dashboard",
+	"document",
+	"sandbox",
+	"segment",
+	"measure"
+]);
+const DependencyUsageType = z.enum([
+	"table",
+	"snippet",
+	"transform",
+	"dashboard",
+	"document",
+	"sandbox",
+	"segment",
+	"question",
+	"model",
+	"metric",
+	"measure"
+]);
+const DependencyFindingErrorType = z.enum([
+	"missing-column",
+	"missing-table-alias",
+	"missing-table",
+	"missing-card",
+	"duplicate-column",
+	"syntax-error",
+	"validation-exception-error"
+]);
+const DependencyErrorSourceType = z.enum([
+	"table",
+	"card",
+	"transform"
+]);
+const DependentsSortColumn = z.enum([
+	"name",
+	"location",
+	"view-count"
+]);
+const DependencyItemsSortColumn = z.enum([
+	"name",
+	"location",
+	"dependents-with-errors",
+	"dependents-errors"
+]);
+const DependencyCollectionRef = z.object({
+	id: CollectionId,
+	name: z.string(),
+	authority_level: CollectionAuthorityLevel.nullable(),
+	is_personal: z.boolean().optional()
+}).loose();
+const DependencyContainerRef = z.object({
+	id: z.number().int(),
+	name: z.string()
+}).loose();
+const DependencyDatabaseRef = z.object({
+	id: z.number().int(),
+	name: z.string()
+}).loose();
+const DependencyTableRef = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	display_name: z.string()
+}).loose();
+const DependencyEntityData = z.object({
+	name: z.string().nullable().optional(),
+	display_name: z.string().nullable().optional(),
+	description: z.string().nullable().optional(),
+	type: CardType.nullable().optional(),
+	display: z.string().nullable().optional(),
+	database_id: z.number().int().nullable().optional(),
+	db_id: z.number().int().nullable().optional(),
+	schema: z.string().nullable().optional(),
+	collection_id: CollectionId.nullable().optional(),
+	collection: DependencyCollectionRef.nullable().optional(),
+	dashboard_id: z.number().int().nullable().optional(),
+	dashboard: DependencyContainerRef.nullable().optional(),
+	document_id: z.number().int().nullable().optional(),
+	document: DependencyContainerRef.nullable().optional(),
+	db: DependencyDatabaseRef.nullable().optional(),
+	table_id: z.number().int().nullable().optional(),
+	table: DependencyTableRef.nullable().optional(),
+	view_count: z.number().int().nullable().optional()
+}).loose();
+const DependencyEntity = z.object({
+	id: z.number().int(),
+	type: DependencyType,
+	data: DependencyEntityData
+}).loose();
+const DependencyEntityDataCompact = DependencyEntityData.pick({
+	name: true,
+	display_name: true,
+	description: true,
+	type: true,
+	database_id: true,
+	db_id: true,
+	schema: true,
+	table_id: true,
+	collection_id: true,
+	dashboard_id: true,
+	document_id: true,
+	view_count: true
+}).strip().extend({
+	db: DependencyDatabaseRef.pick({
+		id: true,
+		name: true
+	}).strip().nullable().optional(),
+	table: DependencyTableRef.pick({
+		id: true,
+		name: true,
+		display_name: true
+	}).strip().nullable().optional(),
+	collection: DependencyCollectionRef.pick({
+		id: true,
+		name: true,
+		authority_level: true,
+		is_personal: true
+	}).strip().nullable().optional(),
+	dashboard: DependencyContainerRef.pick({
+		id: true,
+		name: true
+	}).strip().nullable().optional(),
+	document: DependencyContainerRef.pick({
+		id: true,
+		name: true
+	}).strip().nullable().optional()
+});
+const DependencyEntityCompact = DependencyEntity.pick({
+	id: true,
+	type: true
+}).strip().extend({ data: DependencyEntityDataCompact });
+const DependencyNode = DependencyEntity.extend({ dependents_count: z.partialRecord(DependencyUsageType, z.number().int()).nullable() });
+const DependencyNodeCompact = DependencyEntityCompact.extend({ dependents_count: DependencyNode.shape.dependents_count });
+const DependencyFindingError = z.object({
+	id: z.number().int(),
+	analyzed_entity_type: DependencyType,
+	analyzed_entity_id: z.number().int(),
+	error_type: DependencyFindingErrorType,
+	error_detail: z.string().nullable().optional(),
+	source_entity_type: DependencyErrorSourceType.nullable().optional(),
+	source_entity_id: z.number().int().nullable().optional()
+}).loose();
+const BreakingSource = DependencyNode.extend({ dependents_errors: z.array(DependencyFindingError).nullable().optional() });
+const BreakingSourceCompact = DependencyNodeCompact.extend({ dependents_errors: BreakingSource.shape.dependents_errors });
+const DependencyEdge = z.object({
+	from_entity_type: DependencyType,
+	from_entity_id: z.number().int(),
+	to_entity_type: DependencyType,
+	to_entity_id: z.number().int()
+}).loose();
+const DependencyGraph = z.object({
+	nodes: z.array(DependencyNode),
+	edges: z.array(DependencyEdge)
+}).loose();
+const DependencyGraphCompact = DependencyGraph.pick({ edges: true }).strip().extend({ nodes: z.array(DependencyNodeCompact) });
+//#endregion
+export { DependencyEntityCompact as a, DependencyGraphCompact as c, DependencyNodeCompact as d, DependencyType as f, DependencyEntity as i, DependencyItemsSortColumn as l, BreakingSourceCompact as n, DependencyEntityData as o, DependentsSortColumn as p, DependencyEdge as r, DependencyGraph as s, BreakingSource as t, DependencyNode as u };

package/dist/dependency-zElFM-os.mjs

@@ -0,0 +1,111 @@
+import { _ as MALFORMED_CELL, v as formatScalar } from "./cli.mjs";
+import { a as DependencyEntityCompact, c as DependencyGraphCompact, d as DependencyNodeCompact, n as BreakingSourceCompact, o as DependencyEntityData, r as DependencyEdge } from "./dependency-DzLH3J8P.mjs";
+import { z } from "zod";
+//#region src/output/views/dependency.ts
+const DependentsCount = DependencyNodeCompact.shape.dependents_count;
+const DependentsErrors = BreakingSourceCompact.shape.dependents_errors;
+const GraphNodes = z.array(DependencyNodeCompact);
+const GraphEdges = z.array(DependencyEdge);
+const GRAPH_ITEM_SEPARATOR = "; ";
+function formatEntityName(value) {
+	const parsed = DependencyEntityData.safeParse(value);
+	if (!parsed.success) return MALFORMED_CELL;
+	return formatScalar(parsed.data.display_name ?? parsed.data.name);
+}
+function entityLocation({ type, data }) {
+	switch (type) {
+		case "card": return (data.dashboard ?? data.document ?? data.collection)?.name ?? null;
+		case "table": return data.db?.name ?? null;
+		case "segment":
+		case "measure": return data.table?.display_name ?? null;
+		case "snippet":
+		case "dashboard":
+		case "document": return data.collection?.name ?? null;
+		case "transform":
+		case "sandbox": return null;
+	}
+}
+function formatDependentsCount(value) {
+	const parsed = DependentsCount.safeParse(value);
+	if (!parsed.success) return MALFORMED_CELL;
+	if (parsed.data === null) return "";
+	return Object.entries(parsed.data).map(([usage, count]) => `${usage}: ${count}`).join(", ");
+}
+function formatDependentsErrors(value) {
+	const parsed = DependentsErrors.safeParse(value);
+	if (!parsed.success) return MALFORMED_CELL;
+	if (parsed.data === null || parsed.data === void 0) return "";
+	return parsed.data.map(formatFindingError).join("; ");
+}
+function formatFindingError(error) {
+	return `${error.analyzed_entity_type} ${error.analyzed_entity_id}: ${error.error_type}`;
+}
+function formatGraphNodes(value) {
+	const parsed = GraphNodes.safeParse(value);
+	if (!parsed.success) return MALFORMED_CELL;
+	return parsed.data.map((node) => `${node.type} ${node.id} ${formatEntityName(node.data)}`.trimEnd()).join(GRAPH_ITEM_SEPARATOR);
+}
+function formatGraphEdges(value) {
+	const parsed = GraphEdges.safeParse(value);
+	if (!parsed.success) return MALFORMED_CELL;
+	return parsed.data.map((edge) => `${edge.from_entity_type} ${edge.from_entity_id} -> ${edge.to_entity_type} ${edge.to_entity_id}`).join(GRAPH_ITEM_SEPARATOR);
+}
+const entityColumns = [
+	{
+		key: "id",
+		label: "ID"
+	},
+	{
+		key: "type",
+		label: "Type"
+	},
+	{
+		key: "data",
+		label: "Name",
+		format: formatEntityName
+	},
+	{
+		key: "data",
+		label: "Location",
+		value: entityLocation
+	}
+];
+const dependentsCountColumn = {
+	key: "dependents_count",
+	label: "Dependents",
+	format: formatDependentsCount
+};
+const dependencyEntityView = {
+	compactPick: DependencyEntityCompact,
+	tableColumns: entityColumns
+};
+const dependencyNodeView = {
+	compactPick: DependencyNodeCompact,
+	tableColumns: [...entityColumns, dependentsCountColumn]
+};
+const breakingSourceView = {
+	compactPick: BreakingSourceCompact,
+	tableColumns: [
+		...entityColumns,
+		dependentsCountColumn,
+		{
+			key: "dependents_errors",
+			label: "Errors",
+			format: formatDependentsErrors
+		}
+	]
+};
+const dependencyGraphView = {
+	compactPick: DependencyGraphCompact,
+	tableColumns: [{
+		key: "nodes",
+		label: "Nodes",
+		format: formatGraphNodes
+	}, {
+		key: "edges",
+		label: "Edges",
+		format: formatGraphEdges
+	}]
+};
+//#endregion
+export { dependencyNodeView as i, dependencyEntityView as n, dependencyGraphView as r, breakingSourceView as t };

package/dist/dependents-Dv6tLdSs.mjs

@@ -0,0 +1,52 @@
+import { G as listFlags, H as connectionFlags, J as profileFlag, X as listEnvelopeSchema, d as renderList, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { n as windowList } from "./window-CI_QD04s.mjs";
+import { d as DependencyNodeCompact } from "./dependency-DzLH3J8P.mjs";
+import { t as parseOptionalText } from "./parse-text-T0lTXzTZ.mjs";
+import { i as dependencyNodeView } from "./dependency-zElFM-os.mjs";
+import { i as readDependentFilters, r as queryFlag, t as dependentFilterFlags } from "./filter-flags-BIFcA2TT.mjs";
+import { n as parseDependencyType, t as entityArgs } from "./entity-DWp9WJbU.mjs";
+//#region src/commands/dependency/dependents.ts
+const DependencyDependentsListEnvelope = listEnvelopeSchema(DependencyNodeCompact);
+var dependents_default = defineMetabaseCommand({
+	meta: {
+		name: "dependents",
+		description: "List the entities that depend directly on an entity"
+	},
+	details: "Each row is a dependent with its own `dependents_count` by kind, so a chain can be followed one hop at a time. `--broken` keeps only the dependents whose query analysis failed, whatever the cause, and each row's `dependents_count` then counts only its broken dependents. The server sorts and filters; the window is applied here.",
+	requires: ["dependency.dependents"],
+	args: {
+		...outputFlags,
+		...listFlags,
+		...profileFlag,
+		...connectionFlags,
+		...entityArgs,
+		...dependentFilterFlags,
+		...queryFlag,
+		broken: {
+			type: "boolean",
+			description: "Only the dependents whose query analysis failed, whatever the cause"
+		}
+	},
+	outputSchema: DependencyDependentsListEnvelope,
+	examples: [
+		"mb dependency dependents table 12",
+		"mb dependency dependents card 1 --dependent-types card,dashboard --json",
+		"mb dependency dependents table 12 --broken --json",
+		"mb dependency dependents card 1 --sort-column view-count --sort-direction desc"
+	],
+	async run({ args, ctx, getClient }) {
+		const type = parseDependencyType(args.type);
+		const id = parseId(args.id);
+		const filters = readDependentFilters(args);
+		const { data } = await (await getClient()).dependency.dependents(type, id, {
+			...filters,
+			broken: args.broken ? true : void 0,
+			query: parseOptionalText(args.query, "--query")
+		});
+		renderList(windowList(data, ctx.range), dependencyNodeView, ctx);
+	}
+});
+//#endregion
+export { dependents_default as default };

package/dist/{dirty-U51bMoCP.mjs → dirty-CZORg0i0.mjs}

@@ -1,8 +1,8 @@
-import { B as listFlags, G as listEnvelopeSchema, H as outputFlags, U as profileFlag, d as renderList, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-nCPku2nN.mjs";
-import { n as windowList } from "./window-DSb1tqSe.mjs";
-import { r as SyncDirtyItemCompact } from "./git-sync-BwBRmEhE.mjs";
-import { n as syncDirtyItemView } from "./git-sync-TjX1r_wF.mjs";
+import { G as listFlags, H as connectionFlags, J as profileFlag, X as listEnvelopeSchema, d as renderList, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { n as windowList } from "./window-CI_QD04s.mjs";
+import { r as SyncDirtyItemCompact } from "./git-sync-COokpYgc.mjs";
+import { r as syncDirtyItemView } from "./git-sync-DspFahwV.mjs";
 //#region src/commands/git-sync/dirty.ts
 const SyncDirtyListEnvelope = listEnvelopeSchema(SyncDirtyItemCompact);
 var dirty_default = defineMetabaseCommand({

package/dist/discard-values-DKnP-JHr.mjs

@@ -0,0 +1,55 @@
+import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { r as confirmDestructive } from "./delete-runtime-BbmRg_in.mjs";
+import { l as tableValuesDiscardResultView, n as TableValuesDiscardResult } from "./table-CxvaDiIZ.mjs";
+//#region src/commands/table/discard-values.ts
+var discard_values_default = defineMetabaseCommand({
+	meta: {
+		name: "discard-values",
+		description: "Discard the cached field values of one table"
+	},
+	details: "Deletes the cached distinct values behind this table's filter dropdowns, and with them any custom display values set on those values. No scan recreates a discarded set, neither `mb table rescan-values` nor the database's scheduled scan; Metabase rebuilds a set, without its display values, the next time it is read (a filter dropdown, `mb field values <id>`). Asks for confirmation on a terminal; pass --yes to skip it, which a non-interactive run must. To discard a set of tables use `mb table bulk-discard-values`.",
+	requires: ["table.discardValues"],
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		yes: {
+			type: "boolean",
+			description: "Skip confirmation",
+			default: false
+		},
+		id: {
+			type: "positional",
+			description: "Table id",
+			required: true
+		}
+	},
+	outputSchema: TableValuesDiscardResult,
+	examples: ["mb table discard-values 42 --yes", "mb table discard-values 42"],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const client = await getClient();
+		if (!await confirmDestructive({
+			yes: args.yes,
+			action: `discard the field values of table ${id}`,
+			promptMessage: `Discard the cached field values of table ${id}, custom display values included?`
+		})) {
+			renderSummary({
+				id,
+				discarded: false,
+				aborted: true
+			}, tableValuesDiscardResultView, `Aborted; the field values of table ${id} were not discarded.`, ctx);
+			return;
+		}
+		await client.table.discardValues(id);
+		renderSummary({
+			id,
+			discarded: true,
+			aborted: false
+		}, tableValuesDiscardResultView, `Cached field values discarded for table ${id}.`, ctx);
+	}
+});
+//#endregion
+export { discard_values_default as default };

package/dist/{document-CA0Q6lqu.mjs → document-C18b5rM6.mjs}

@@ -1,4 +1,4 @@
-import { n as DocumentCompact } from "./document-BHpLJbKU.mjs";
+import { n as DocumentCompact } from "./document-DFCj1Az_.mjs";
 //#region src/output/views/document.ts
 const documentView = {
 	compactPick: DocumentCompact,

package/dist/{document-BHpLJbKU.mjs → document-DFCj1Az_.mjs}

@@ -1,3 +1,4 @@
+import { t as NonBlankText } from "./text-DaNkPRwt.mjs";
 import { z } from "zod";
 //#region ../client/src/domain/document.ts
 const TipTapNode = z.looseObject({
@@ -85,7 +86,7 @@ const DocumentUpdateInput = z.object({
 	cards: z.record(z.string().regex(/^-?\d+$/), DocumentCardInput).nullable().optional().describe("cards keyed by card id; negative ids create new cards")
 }).loose();
 z.object({
-	name: DocumentName.nullable().optional(),
+	name: NonBlankText.nullable().optional(),
 	collection_id: z.number().int().positive().nullable().optional(),
 	collection_position: z.number().int().positive().nullable().optional()
 }).strict();

package/dist/document-uxz96Lah.mjs

@@ -0,0 +1,20 @@
+import { t as defineCommandGroup } from "./group-bpD_KcjA.mjs";
+//#region src/commands/document/index.ts
+var document_default = defineCommandGroup({
+	name: "document",
+	description: "Manage Metabase documents",
+	skills: [{
+		skill: "document",
+		purpose: "author the ProseMirror document body"
+	}],
+	subCommands: {
+		list: () => import("./list-DW4-u7eO.mjs").then((mod) => mod.default),
+		get: () => import("./get-DXBXhPrU.mjs").then((mod) => mod.default),
+		create: () => import("./create-zpJIRn9j.mjs").then((mod) => mod.default),
+		update: () => import("./update-DK77vtFF.mjs").then((mod) => mod.default),
+		copy: () => import("./copy-CbDfVZRC.mjs").then((mod) => mod.default),
+		archive: () => import("./archive-CpCSY4RT.mjs").then((mod) => mod.default)
+	}
+});
+//#endregion
+export { document_default as default };

package/dist/{download-BJA6k-e6.mjs → download-BImtTll0.mjs}

@@ -1,5 +1,5 @@
-import { U as profileFlag, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-nCPku2nN.mjs";
+import { H as connectionFlags, J as profileFlag } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
 import { t as pipeToStdout } from "./stream-McixcoUl.mjs";
 import { z } from "zod";
 //#region src/commands/content-translation/download.ts

package/dist/{eid-BtlRU1E0.mjs → eid-D0FxhT9H.mjs}

@@ -1,6 +1,7 @@
-import { H as outputFlags, Q as ConfigError, U as profileFlag, p as renderSummary, z as connectionFlags } from "./cli.mjs";
-import { n as parseCsv, t as defineMetabaseCommand } from "./runtime-nCPku2nN.mjs";
-import { t as readBody } from "./body-Cu94pH4P.mjs";
+import { H as connectionFlags, J as profileFlag, at as ConfigError, et as parseCsv, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { r as givenValue } from "./input-D8qW-KtR.mjs";
+import { t as readBody } from "./body-CB2eDFFb.mjs";
 import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
 import { a as EidTranslateResultCompact, i as EidTranslateResult, n as EidModel, r as EidTranslateInput, t as EID_MODELS } from "./eid-translation-zEHtr5Oc.mjs";
 //#region src/output/views/eid-translation.ts
@@ -14,14 +15,14 @@ const eidTranslateView = {
 //#endregion
 //#region src/commands/flag-pair.ts
 function requireBothOrNeither(first, second) {
-	const firstSet = first.value !== void 0 && first.value !== "";
-	const secondSet = second.value !== void 0 && second.value !== "";
-	if (!firstSet && !secondSet) return null;
-	if (!firstSet) throw new ConfigError(`${first.name} is required when using ${second.name}`);
-	if (!secondSet) throw new ConfigError(`${second.name} is required when using ${first.name}`);
+	const firstValue = givenValue(first.value);
+	const secondValue = givenValue(second.value);
+	if (firstValue === null && secondValue === null) return null;
+	if (firstValue === null) throw new ConfigError(`${first.name} is required when using ${second.name}`);
+	if (secondValue === null) throw new ConfigError(`${second.name} is required when using ${first.name}`);
 	return {
-		first: first.value,
-		second: second.value
+		first: firstValue,
+		second: secondValue
 	};
 }
 //#endregion

package/dist/entity-DWp9WJbU.mjs

@@ -0,0 +1,20 @@
+import { f as DependencyType } from "./dependency-DzLH3J8P.mjs";
+import { t as parseEnumFlag } from "./parse-enum-CLIXMsd8.mjs";
+//#region src/commands/dependency/entity.ts
+const entityArgs = {
+	type: {
+		type: "positional",
+		description: `Entity kind (${DependencyType.options.join(" | ")})`,
+		required: true
+	},
+	id: {
+		type: "positional",
+		description: "Entity id",
+		required: true
+	}
+};
+function parseDependencyType(value) {
+	return parseEnumFlag(value, DependencyType, "type");
+}
+//#endregion
+export { parseDependencyType as n, entityArgs as t };

package/dist/entry-flags-3sDWwa90.mjs

@@ -0,0 +1,42 @@
+import { at as ConfigError } from "./cli.mjs";
+import { r as givenValue } from "./input-D8qW-KtR.mjs";
+import { t as readBody } from "./body-CB2eDFFb.mjs";
+import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
+import { r as GlossaryCreateInput } from "./glossary-BlNCrYbw.mjs";
+//#region src/commands/glossary/entry-flags.ts
+const entryFlags = {
+	...bodyInputFlags,
+	term: {
+		type: "string",
+		description: "The term (used with --definition)"
+	},
+	definition: {
+		type: "string",
+		description: "The definition (used with --term)"
+	}
+};
+/**
+* The flag pair and a body are alternatives, so a `--body` or `--file` beside the flags is refused
+* rather than dropped. A body piped on stdin is not read while the flags are given: telling an
+* idle inherited pipe from one still to send would cost every flag-driven call the stdin wait.
+*/
+async function readEntryInput(args) {
+	if (args.term === void 0 && args.definition === void 0) return readBody({
+		flag: args.body,
+		file: args.file
+	}, GlossaryCreateInput);
+	if (givenValue(args.body) !== null || givenValue(args.file) !== null) throw new ConfigError("--term, --definition cannot be combined with --body or --file");
+	if (args.term === void 0) throw new ConfigError("--term is required when using --definition");
+	if (args.definition === void 0) throw new ConfigError("--definition is required when using --term");
+	return {
+		term: parseFlag(GlossaryCreateInput.shape.term, args.term, "--term"),
+		definition: parseFlag(GlossaryCreateInput.shape.definition, args.definition, "--definition")
+	};
+}
+function parseFlag(schema, value, flag) {
+	const parsed = schema.safeParse(value);
+	if (!parsed.success) throw new ConfigError(`${flag} ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+	return parsed.data;
+}
+//#endregion
+export { readEntryInput as n, entryFlags as t };

package/dist/{events-B5rnOo-L.mjs → events-BzCjVA3-.mjs}

@@ -1,7 +1,7 @@
-import { B as listFlags, G as listEnvelopeSchema, H as outputFlags, U as profileFlag, d as renderList, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-nCPku2nN.mjs";
-import { t as parseId } from "./parse-id-whJX4DAb.mjs";
-import { n as windowList } from "./window-DSb1tqSe.mjs";
+import { G as listFlags, H as connectionFlags, J as profileFlag, X as listEnvelopeSchema, d as renderList, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { n as windowList } from "./window-CI_QD04s.mjs";
 import { a as TimelineEventCompact } from "./timeline-CCSU2qOS.mjs";
 import { t as timelineEventView } from "./timeline-uDCmwGFT.mjs";
 //#region src/commands/timeline/events.ts

package/dist/execute-BhHbkBqf.mjs

@@ -0,0 +1,45 @@
+import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { t as readBody } from "./body-CB2eDFFb.mjs";
+import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
+import { a as DataActionExecuteResult, i as DataActionExecuteInput } from "./data-action-DZxVB_hD.mjs";
+import { t as dataActionExecuteResultView } from "./data-action-R9qxJDPA.mjs";
+//#region src/commands/data-action/execute.ts
+var execute_default = defineMetabaseCommand({
+	meta: {
+		name: "execute",
+		description: "Run a data action by id"
+	},
+	details: "The JSON body is `{\"parameters\": {...}}`, keyed by the data action's parameter ids. The data action writes to its database, so a run cannot be undone by the CLI.",
+	skills: [{
+		skill: "data-action",
+		purpose: "the parameter values a data action takes"
+	}],
+	requires: ["dataAction.execute"],
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags,
+		id: {
+			type: "positional",
+			description: "Data action id",
+			required: true
+		}
+	},
+	inputSchema: DataActionExecuteInput,
+	outputSchema: DataActionExecuteResult,
+	examples: ["mb data-action execute 1 --body '{\"parameters\":{\"id\":1,\"note\":\"rush\"}}'", "mb data-action execute 1 --file values.json"],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const body = await readBody({
+			flag: args.body,
+			file: args.file
+		}, DataActionExecuteInput);
+		const result = await (await getClient()).dataAction.execute(id, body);
+		renderSummary(result, dataActionExecuteResultView, `Ran data action ${id}; ${result["rows-affected"]} rows affected.`, ctx);
+	}
+});
+//#endregion
+export { execute_default as default };