@metabase/cli 0.1.0-alpha.workspaces-commands.818a8f1

package/dist/query-BnGVGeM3.mjs

@@ -0,0 +1,100 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { ConfigError, connectionFlags, defineMetabaseCommand, outputFlags, parseJson, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import { CardQueryResult, cardQueryView } from "./card-C31pGtBZ.mjs";
+import { z } from "zod";
+import { Writable } from "node:stream";
+
+//#region src/output/stream.ts
+async function pipeToStdout(stream) {
+	await stream.pipeTo(Writable.toWeb(process.stdout));
+}
+
+//#endregion
+//#region src/commands/card/query.ts
+const ExportFormat = z.enum(["csv", "xlsx"]);
+const QueryParameters = z.array(z.unknown());
+var query_default = defineMetabaseCommand({
+	meta: {
+		name: "query",
+		description: "Run a saved card and return results (json envelope, CSV, or XLSX)"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		id: {
+			type: "positional",
+			description: "Card id",
+			required: true
+		},
+		"export-format": {
+			type: "string",
+			description: `Bypass JSON envelope and stream raw export: ${ExportFormat.options.join(" | ")}`
+		},
+		parameters: {
+			type: "string",
+			description: "JSON array of Metabase parameter objects to pass with the query"
+		},
+		limit: {
+			type: "string",
+			description: "Cap rows kept in the JSON envelope (no effect on csv/xlsx exports)"
+		}
+	},
+	outputSchema: CardQueryResult,
+	examples: [
+		"metabase card query 1",
+		"metabase card query 1 --json --limit 20",
+		"metabase card query 1 --export-format csv > results.csv",
+		"metabase card query 1 --parameters '[{\"type\":\"category\",\"value\":\"A\",\"target\":[\"variable\",[\"template-tag\",\"c\"]]}]'"
+	],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const parameters = parseParameters(args.parameters);
+		const client = await getClient();
+		const exportFormatRaw = args["export-format"];
+		if (exportFormatRaw !== void 0 && exportFormatRaw !== "") {
+			const exportFormat = parseExportFormat(exportFormatRaw);
+			await streamExport(client, id, exportFormat, parameters);
+			return;
+		}
+		const result = await client.requestParsed(CardQueryResult, `/api/card/${id}/query`, {
+			method: "POST",
+			body: { parameters }
+		});
+		const limit = args.limit === void 0 || args.limit === "" ? null : parseId(args.limit, "limit");
+		renderItem(applyLimit(result, limit), cardQueryView, ctx);
+	}
+});
+function parseParameters(raw) {
+	if (raw === void 0 || raw === "") return [];
+	return parseJson(raw, QueryParameters, { source: "--parameters" });
+}
+function parseExportFormat(raw) {
+	const result = ExportFormat.safeParse(raw);
+	if (!result.success) throw new ConfigError(`invalid --export-format: "${raw}" (expected: ${ExportFormat.options.join(", ")})`);
+	return result.data;
+}
+function applyLimit(result, limit) {
+	if (limit === null || result.status !== "completed" || result.data.rows.length <= limit) return result;
+	return {
+		...result,
+		data: {
+			...result.data,
+			rows: result.data.rows.slice(0, limit)
+		}
+	};
+}
+async function streamExport(client, id, format, parameters) {
+	const body = new URLSearchParams({ parameters: JSON.stringify(parameters) });
+	const stream = await client.requestStream(`/api/card/${id}/query/${format}`, {
+		method: "POST",
+		body
+	});
+	await pipeToStdout(stream);
+}
+
+//#endregion
+export { query_default as default };

package/dist/remove-Bx48o-0S.mjs

@@ -0,0 +1,62 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { ConfigError, clearLicense, defineMetabaseCommand, outputFlags } from "./runtime-DUgFfYkN.mjs";
+import { promptConfirm } from "./prompt-fXeNtj0M.mjs";
+import { z } from "zod";
+
+//#region src/commands/license/remove.ts
+const LicenseRemoveResult = z.object({
+	removed: z.boolean(),
+	aborted: z.boolean()
+});
+const licenseRemoveView = {
+	compactPick: LicenseRemoveResult,
+	tableColumns: [{
+		key: "removed",
+		label: "Removed"
+	}, {
+		key: "aborted",
+		label: "Aborted"
+	}]
+};
+var remove_default = defineMetabaseCommand({
+	meta: {
+		name: "remove",
+		description: "Remove the stored license token"
+	},
+	args: {
+		...outputFlags,
+		yes: {
+			type: "boolean",
+			description: "Skip confirmation",
+			default: false
+		}
+	},
+	outputSchema: LicenseRemoveResult,
+	examples: ["metabase license remove --yes"],
+	async run({ args, ctx }) {
+		if (!args.yes) {
+			if (!process.stdin.isTTY) throw new ConfigError("--yes required to remove license non-interactively");
+			const ok = await promptConfirm({
+				message: "Remove stored license token?",
+				initialValue: false
+			});
+			if (!ok) {
+				renderItem({
+					removed: false,
+					aborted: true
+				}, licenseRemoveView, ctx);
+				return;
+			}
+		}
+		const removed = await clearLicense();
+		renderItem({
+			removed,
+			aborted: false
+		}, licenseRemoveView, ctx);
+	}
+});
+
+//#endregion
+export { remove_default as default };

package/dist/remove-DecoZzNd.mjs

@@ -0,0 +1,97 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { defineMetabaseCommand, outputFlags } from "./runtime-DUgFfYkN.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import { promptConfirm } from "./prompt-fXeNtj0M.mjs";
+import "./poll-D2sXM5rc.mjs";
+import { checkDockerReady, containerNameFor, removeContainer, removeVolume, volumeNameFor } from "./docker-QWVMG2gl.mjs";
+import { z } from "zod";
+
+//#region src/commands/workspace/remove.ts
+const RemoveResult = z.object({
+	workspace_id: z.number().int().positive(),
+	container_name: z.string(),
+	volume_name: z.string(),
+	removed_container: z.boolean(),
+	removed_volume: z.boolean()
+});
+const removeResultView = {
+	compactPick: RemoveResult.pick({
+		workspace_id: true,
+		removed_container: true,
+		removed_volume: true
+	}).strip(),
+	tableColumns: [
+		{
+			key: "workspace_id",
+			label: "ID"
+		},
+		{
+			key: "container_name",
+			label: "Container"
+		},
+		{
+			key: "volume_name",
+			label: "Volume"
+		},
+		{
+			key: "removed_container",
+			label: "Removed Container"
+		},
+		{
+			key: "removed_volume",
+			label: "Removed Volume"
+		}
+	]
+};
+var remove_default = defineMetabaseCommand({
+	meta: {
+		name: "remove",
+		description: "Stop and remove the local container + app-db volume (does not affect remote)"
+	},
+	args: {
+		...outputFlags,
+		id: {
+			type: "positional",
+			description: "Workspace id",
+			required: true
+		},
+		"keep-volume": {
+			type: "boolean",
+			description: "Keep the workspace's app-db volume (faster restart, app-db survives)",
+			default: false
+		},
+		yes: {
+			type: "boolean",
+			description: "Skip the confirmation prompt",
+			default: false
+		}
+	},
+	outputSchema: RemoveResult,
+	examples: ["metabase workspace remove 1 --yes", "metabase workspace remove 1 --keep-volume --yes"],
+	async run({ args, ctx }) {
+		const workspaceId = parseId(args.id);
+		const containerName = containerNameFor(workspaceId);
+		const volumeName = volumeNameFor(workspaceId);
+		const shouldRemoveVolume = args["keep-volume"] !== true;
+		await checkDockerReady();
+		if (!args.yes) {
+			const confirmed = await promptConfirm({ message: shouldRemoveVolume ? `Remove container ${containerName} and its app-db volume ${volumeName}?` : `Remove container ${containerName}? (volume ${volumeName} will be kept)` });
+			if (!confirmed) return;
+		}
+		const removedContainer = await removeContainer(containerName);
+		const removedVolume = shouldRemoveVolume ? await removeVolume(volumeName) : false;
+		const result = {
+			workspace_id: workspaceId,
+			container_name: containerName,
+			volume_name: volumeName,
+			removed_container: removedContainer,
+			removed_volume: removedVolume
+		};
+		renderItem(result, removeResultView, ctx);
+	}
+});
+
+//#endregion
+export { remove_default as default };

package/dist/render-DlBijc5i.mjs

@@ -0,0 +1,179 @@
+import { ConfigError } from "./runtime-DUgFfYkN.mjs";
+import Table from "cli-table3";
+
+//#region src/output/cap.ts
+function capListEnvelope(envelope, maxBytes) {
+	if (maxBytes <= 0) return envelope;
+	const fullBytes = jsonByteLength(envelope);
+	if (fullBytes <= maxBytes) return envelope;
+	let lo = 0;
+	let hi = envelope.data.length;
+	while (lo < hi) {
+		const mid = Math.ceil((lo + hi) / 2);
+		if (jsonByteLength(truncate(envelope, mid, fullBytes)) <= maxBytes) lo = mid;
+		else hi = mid - 1;
+	}
+	return truncate(envelope, lo, fullBytes);
+}
+function truncate(envelope, count, originalBytes) {
+	return {
+		...envelope,
+		data: envelope.data.slice(0, count),
+		returned: count,
+		truncated: {
+			reason: "max_bytes",
+			bytes: originalBytes
+		}
+	};
+}
+function jsonByteLength(value) {
+	return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+
+//#endregion
+//#region src/output/notice.ts
+function warn(message) {
+	process.stderr.write(message + "\n");
+}
+function listTruncationNotice(bytes) {
+	return `… cut at ${bytes} bytes; rerun with --max-bytes 0`;
+}
+function itemOversizeNotice(bytes) {
+	return `… item is ${bytes} bytes (exceeds --max-bytes); narrow with --fields, or pass --max-bytes 0`;
+}
+
+//#endregion
+//#region src/output/projection.ts
+function applyProjection(value, view, full, fields) {
+	if (fields !== void 0) {
+		if (fields.length === 0) throw new ConfigError("--fields requires at least one path");
+		return projectFields(value, fields);
+	}
+	if (full) return value;
+	const parsed = view.compactPick.safeParse(value);
+	if (parsed.success) return parsed.data;
+	throw new ConfigError(`compact projection failed: ${parsed.error.message}`);
+}
+function projectFields(value, fields) {
+	const out = {};
+	for (const path of fields) {
+		if (path.length === 0) throw new ConfigError(`empty field path`);
+		const parts = path.split(".");
+		if (parts.some((part) => part.length === 0)) throw new ConfigError(`invalid field path: "${path}"`);
+		setPath(out, parts, pickPath(value, parts));
+	}
+	return out;
+}
+function pickPath(value, parts) {
+	let cursor = value;
+	for (const part of parts) {
+		if (!isPlainObject(cursor) || !Object.hasOwn(cursor, part)) throw new ConfigError(`unknown field path: "${parts.join(".")}"`);
+		cursor = Reflect.get(cursor, part);
+	}
+	return cursor;
+}
+function setPath(target, parts, value) {
+	let cursor = target;
+	const lastIndex = parts.length - 1;
+	for (const [index, part] of parts.entries()) {
+		if (index === lastIndex) {
+			cursor[part] = value;
+			return;
+		}
+		const existing = cursor[part];
+		if (isPlainObject(existing)) cursor = existing;
+		else {
+			const next = {};
+			cursor[part] = next;
+			cursor = next;
+		}
+	}
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/output/table.ts
+function renderTable(rows, columns) {
+	const head = columns.map((column) => column.label ?? column.key);
+	const widths = columns.map((column) => column.width ?? null);
+	const hasWidth = widths.some((width) => width !== null);
+	const table = new Table(hasWidth ? {
+		head,
+		colWidths: widths
+	} : { head });
+	for (const row of rows) table.push(columns.map((column) => formatCell(row, column)));
+	return table.toString();
+}
+function formatCell(row, column) {
+	const value = row[column.key];
+	if (column.format !== void 0) return column.format(value);
+	return formatScalar(value);
+}
+function formatScalar(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+
+//#endregion
+//#region src/output/render.ts
+function renderItem(item, view, opts) {
+	const projected = applyProjection(item, view, opts.full, opts.fields);
+	const body = renderItemBody(item, view, projected, opts) + "\n";
+	process.stdout.write(body);
+	emitItemOversizeNotice(body, opts.maxBytes);
+}
+function renderList(envelope, view, opts) {
+	if (opts.format === "json" || opts.fields !== void 0) {
+		renderJsonEnvelope(envelope, view, opts);
+		return;
+	}
+	if (envelope.data.length === 0) {
+		process.stdout.write("(no results)\n");
+		return;
+	}
+	const capped = capListEnvelope(envelope, opts.maxBytes);
+	process.stdout.write(renderTable(capped.data, view.tableColumns) + "\n");
+	if (capped.truncated !== void 0) warn(listTruncationNotice(capped.truncated.bytes));
+}
+function renderJsonEnvelope(envelope, view, opts) {
+	const projectedItems = envelope.data.map((item) => applyProjection(item, view, opts.full, opts.fields));
+	const projectedEnvelope = {
+		...envelope,
+		data: projectedItems
+	};
+	const capped = capListEnvelope(projectedEnvelope, opts.maxBytes);
+	process.stdout.write(JSON.stringify(capped, null, 2) + "\n");
+	if (capped.truncated !== void 0) warn(listTruncationNotice(capped.truncated.bytes));
+}
+function renderItemBody(item, view, projected, opts) {
+	if (opts.format === "json" || opts.fields !== void 0) return JSON.stringify(projected, null, 2);
+	if (!opts.full) return renderKeyValueLines(columnPairs(item, view.tableColumns));
+	return renderKeyValueLines(objectPairs(projected));
+}
+function columnPairs(item, columns) {
+	return columns.map((column) => [column.label ?? column.key, formatCell(item, column)]);
+}
+function objectPairs(value) {
+	if (!isPlainObject(value)) {
+		const scalar = formatScalar(value);
+		return scalar === "" ? [] : [["", scalar]];
+	}
+	return Object.entries(value).map(([key, raw]) => [key, formatScalar(raw)]);
+}
+function renderKeyValueLines(pairs) {
+	if (pairs.length === 0) return "";
+	const padding = Math.max(...pairs.map(([label]) => label.length));
+	return pairs.map(([label, value]) => `${label.padEnd(padding)}  ${value}`).join("\n");
+}
+function emitItemOversizeNotice(body, maxBytes) {
+	if (maxBytes <= 0) return;
+	const bytes = Buffer.byteLength(body, "utf8");
+	if (bytes <= maxBytes) return;
+	warn(itemOversizeNotice(bytes));
+}
+
+//#endregion
+export { renderItem, renderList, warn };

package/dist/run-D4NgvaRh.mjs

@@ -0,0 +1,87 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import { pollUntil } from "./poll-D2sXM5rc.mjs";
+import { TransformRun } from "./transform-DfVkUttP.mjs";
+import { parseWaitFlags, waitFlags } from "./wait-flags-CjW4ogUJ.mjs";
+import { z } from "zod";
+
+//#region src/commands/transform/run.ts
+const RUN_TERMINAL_STATUSES = new Set([
+	"succeeded",
+	"failed",
+	"timeout",
+	"canceled"
+]);
+const RUN_FAILURE_STATUSES = new Set([
+	"failed",
+	"timeout",
+	"canceled"
+]);
+const TransformRunKickoff = z.object({
+	message: z.string(),
+	run_id: z.number().int().positive().nullable()
+});
+const TransformRunResult = z.object({
+	message: z.string(),
+	run_id: z.number().int().positive().nullable(),
+	final: TransformRun.nullable().optional()
+});
+const transformRunView = {
+	compactPick: TransformRunResult,
+	tableColumns: [{
+		key: "run_id",
+		label: "Run ID"
+	}, {
+		key: "message",
+		label: "Message"
+	}]
+};
+var run_default = defineMetabaseCommand({
+	meta: {
+		name: "run",
+		description: "Trigger a transform run by id"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...waitFlags,
+		id: {
+			type: "positional",
+			description: "Transform id",
+			required: true
+		}
+	},
+	outputSchema: TransformRunResult,
+	examples: ["metabase transform run 1", "metabase transform run 1 --wait --json"],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const wait = parseWaitFlags(args);
+		const client = await getClient();
+		const kickoff = await client.requestParsed(TransformRunKickoff, `/api/transform/${id}/run`, { method: "POST" });
+		if (!wait.enabled || kickoff.run_id === null) {
+			renderItem({
+				message: kickoff.message,
+				run_id: kickoff.run_id
+			}, transformRunView, ctx);
+			return;
+		}
+		const runId = kickoff.run_id;
+		const final = await pollUntil(async () => client.requestParsed(TransformRun, `/api/transform/run/${runId}`), (run) => RUN_TERMINAL_STATUSES.has(run.status), wait.schedule);
+		renderItem({
+			message: kickoff.message,
+			run_id: runId,
+			final
+		}, transformRunView, ctx);
+		if (RUN_FAILURE_STATUSES.has(final.status)) {
+			const detail = final.message ? `: ${final.message}` : "";
+			throw new Error(`transform run ${runId} ${final.status}${detail}`);
+		}
+	}
+});
+
+//#endregion
+export { run_default as default };