@metabase/cli 0.1.0 → 0.1.1

package/dist/predicates-DiIiS3k7.mjs

@@ -0,0 +1,153 @@
+import { ZodError, core } from "zod";
+import { isCancel } from "@clack/prompts";
+
+//#region src/core/json-pointer.ts
+function escapeJsonPointerSegment(key) {
+	if (typeof key === "number") return String(key);
+	const segment = typeof key === "symbol" ? key.toString() : key;
+	return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+
+//#endregion
+//#region src/core/errors.ts
+const VERBOSE_ENV = "METABASE_VERBOSE";
+var MetabaseError = class extends Error {
+	get userMessage() {
+		return this.message;
+	}
+};
+var NetworkError = class extends MetabaseError {
+	category = "network";
+	isRetryable = true;
+	exitCode = 1;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "NetworkError";
+		this.developerDetail = developerDetail;
+	}
+};
+var TimeoutError = class extends MetabaseError {
+	category = "timeout";
+	isRetryable = true;
+	exitCode = 1;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "TimeoutError";
+		this.developerDetail = developerDetail;
+	}
+};
+var ValidationError = class extends MetabaseError {
+	category = "validation";
+	isRetryable = false;
+	exitCode = 1;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "ValidationError";
+		this.developerDetail = developerDetail;
+	}
+	get userMessage() {
+		const issues = this.developerDetail.zodIssues;
+		if (issues.length === 0) return this.message;
+		return `${this.message}\n${formatZodIssueList(issues)}`;
+	}
+};
+const MAX_ISSUES_PRINTED = 10;
+function formatZodIssueList(issues) {
+	const head = issues.slice(0, MAX_ISSUES_PRINTED).map(formatZodIssueLine);
+	const overflow = issues.length - MAX_ISSUES_PRINTED;
+	if (overflow > 0) head.push(`  ... and ${overflow} more`);
+	return head.join("\n");
+}
+function formatZodIssueLine(issue) {
+	return `  ${formatZodIssuePointer(issue.path)}: ${issue.message}`;
+}
+function formatZodIssuePointer(path) {
+	if (path.length === 0) return "/";
+	return path.map((key) => `/${escapeJsonPointerSegment(key)}`).join("");
+}
+var ConfigError = class extends MetabaseError {
+	category = "config";
+	isRetryable = false;
+	exitCode = 2;
+	developerDetail = null;
+	constructor(message) {
+		super(message);
+		this.name = "ConfigError";
+	}
+};
+var AbortError = class extends MetabaseError {
+	category = "abort";
+	isRetryable = false;
+	exitCode = 130;
+	developerDetail = null;
+	constructor(message = "aborted") {
+		super(message);
+		this.name = "AbortError";
+	}
+};
+var ChainedRequestError = class extends MetabaseError {
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.name = "ChainedRequestError";
+		this.cause = cause;
+	}
+	get category() {
+		return this.cause.category;
+	}
+	get isRetryable() {
+		return this.cause.isRetryable;
+	}
+	get exitCode() {
+		return this.cause.exitCode;
+	}
+	get developerDetail() {
+		return this.cause.developerDetail;
+	}
+};
+var UnknownError = class extends MetabaseError {
+	category = "unknown";
+	isRetryable = false;
+	exitCode = 1;
+	developerDetail;
+	constructor(input) {
+		super(input.originalMessage);
+		this.name = "UnknownError";
+		this.developerDetail = input;
+	}
+};
+function toMetabaseError(error) {
+	if (error instanceof MetabaseError) return error;
+	if (isCancel(error)) return new AbortError();
+	if (error instanceof ZodError) return new ConfigError(error.issues.map(formatZodIssue).join("; "));
+	if (error instanceof Error) return new UnknownError({
+		originalMessage: error.message,
+		stack: error.stack ?? null
+	});
+	return new UnknownError({
+		originalMessage: String(error),
+		stack: null
+	});
+}
+function formatZodIssue(issue) {
+	const path = core.toDotPath(issue.path);
+	return path === "" ? issue.message : `${path}: ${issue.message}`;
+}
+function isNotFoundError(value) {
+	return value instanceof Error && "code" in value && value.code === "ENOENT";
+}
+function errorMessage(value) {
+	return value instanceof Error ? value.message : String(value);
+}
+
+//#endregion
+//#region src/runtime/predicates.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+export { AbortError, ChainedRequestError, ConfigError, MetabaseError, NetworkError, TimeoutError, VERBOSE_ENV, ValidationError, errorMessage, escapeJsonPointerSegment, isNotFoundError, isPlainObject, toMetabaseError };

package/dist/preflight-CC_g6EWU.mjs

@@ -0,0 +1,91 @@
+import { writeJson } from "./render-DXv-D6fU.mjs";
+import { ChainedRequestError, ConfigError, MetabaseError } from "./predicates-DiIiS3k7.mjs";
+import { HttpError } from "./runtime-D7jihh81.mjs";
+import { Card } from "./card-CAEZWixN.mjs";
+import { z } from "zod";
+
+//#region src/commands/dashboard/preflight.ts
+const PreflightDashcard = z.looseObject({ card_id: z.number().int().nullable().optional() });
+function collectDashcardCardReferences(dashcards) {
+	if (dashcards === void 0) return [];
+	const refs = [];
+	dashcards.forEach((dashcard, index) => {
+		const parsed = PreflightDashcard.safeParse(dashcard);
+		if (!parsed.success) return;
+		const cardId = parsed.data.card_id;
+		if (typeof cardId === "number" && cardId > 0) refs.push({
+			cardId,
+			path: `/dashcards/${index}/card_id`
+		});
+	});
+	return refs;
+}
+async function preflightDashcardCardReferences(client, dashcards) {
+	const references = collectDashcardCardReferences(dashcards);
+	if (references.length === 0) return;
+	const grouped = new Map();
+	for (const ref of references) {
+		const list = grouped.get(ref.cardId);
+		if (list === void 0) grouped.set(ref.cardId, [ref]);
+		else list.push(ref);
+	}
+	const checks = await Promise.all(Array.from(grouped.entries()).map(async ([cardId, refs]) => ({
+		refs,
+		result: await classifyCardReference(client, cardId)
+	})));
+	const errors = [];
+	for (const check of checks) {
+		if (check.result.status === "ok") continue;
+		for (const ref of check.refs) errors.push({
+			path: ref.path,
+			message: check.result.message
+		});
+	}
+	if (errors.length === 0) return;
+	const outcome = {
+		ok: false,
+		errors
+	};
+	writeJson(outcome);
+	throw new ConfigError(`dashboard card-reference pre-flight failed: ${errors.length} error(s) — fix the dashcard card_id values listed above`);
+}
+function wrapChainedDashboardWriteError(error, dashboardId) {
+	if (!(error instanceof MetabaseError)) return error;
+	const prefix = `dashboard ${dashboardId} created but follow-up PUT /api/dashboard/${dashboardId} failed`;
+	const suffix = "dashcards not applied";
+	const message = `${prefix}: ${error.userMessage}; ${suffix}`;
+	if (error instanceof HttpError) return new HttpError({
+		status: error.status,
+		statusText: error.developerDetail.statusText,
+		method: error.developerDetail.method,
+		url: error.developerDetail.url,
+		responseHeaders: error.developerDetail.responseHeaders,
+		rawBody: error.developerDetail.body,
+		overrideUserMessage: message
+	});
+	return new ChainedRequestError(message, error);
+}
+async function classifyCardReference(client, cardId) {
+	try {
+		const card = await client.requestParsed(Card, `/api/card/${cardId}`);
+		if (card.archived) return {
+			status: "error",
+			message: `card ${cardId} is archived`
+		};
+		return { status: "ok" };
+	} catch (error) {
+		if (!(error instanceof HttpError)) throw error;
+		if (error.status === 404) return {
+			status: "error",
+			message: `card ${cardId} not found`
+		};
+		if (error.status === 401 || error.status === 403) return {
+			status: "error",
+			message: `card ${cardId} is not readable: ${error.userMessage}`
+		};
+		throw error;
+	}
+}
+
+//#endregion
+export { preflightDashcardCardReferences, wrapChainedDashboardWriteError };

package/dist/{prompt-DpT8yAVy.mjs → prompt-Bf3DQ-qE.mjs}

@@ -1,4 +1,4 @@
-import { AbortError, ConfigError } from "./runtime-C9CEZhcn.mjs";
+import { AbortError, ConfigError } from "./predicates-DiIiS3k7.mjs";
 import { confirm, isCancel, password, text } from "@clack/prompts";
 
 //#region src/output/prompt.ts

package/dist/provision-BUgWJWAV.mjs

@@ -0,0 +1,77 @@
+import "./package-DBsS7a5x.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import { ConfigError } from "./predicates-DiIiS3k7.mjs";
+import "./input-ikCiip6x.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-D7jihh81.mjs";
+import { readBody } from "./body-DRBgxS6-.mjs";
+import { bodyInputFlags } from "./body-flags-BK7J6Daz.mjs";
+import { parseId } from "./parse-id-BUOZQqjp.mjs";
+import "./poll-DMmmZWvi.mjs";
+import { parseWaitFlags, waitFlags } from "./wait-flags-DO3ar2tf.mjs";
+import { Workspace, WorkspaceProvisionInput, workspaceView } from "./workspace-DVuqKJGG.mjs";
+import { waitForDatabaseProvisioned } from "./wait-CWizX_sR.mjs";
+import { parseSchemasCsv } from "./parse-schemas-BnW4T1_I.mjs";
+
+//#region src/commands/workspace/database/provision.ts
+var provision_default = defineMetabaseCommand({
+	meta: {
+		name: "provision",
+		description: "Provision a database into a workspace"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags,
+		...waitFlags,
+		"database-id": {
+			type: "string",
+			description: "Database id (alternative to --body / --file)"
+		},
+		schemas: {
+			type: "string",
+			description: "Comma-separated input schemas (alternative to --body / --file)"
+		},
+		id: {
+			type: "positional",
+			description: "Workspace id",
+			required: true
+		}
+	},
+	outputSchema: Workspace,
+	examples: [
+		"metabase workspace database provision 1 --database-id 5 --schemas analytics,github",
+		"metabase workspace database provision 1 --database-id 5 --schemas analytics --wait",
+		"metabase workspace database provision 1 --file provision.json"
+	],
+	async run({ args, ctx, getClient }) {
+		const workspaceId = parseId(args.id);
+		const databaseIdFlag = args["database-id"];
+		const schemasFlag = args.schemas;
+		const wait = parseWaitFlags(args);
+		let body;
+		if (databaseIdFlag !== void 0 && databaseIdFlag !== "") {
+			const databaseId = parseId(databaseIdFlag, "--database-id");
+			if (schemasFlag === void 0 || schemasFlag === "") throw new ConfigError("--schemas is required when using --database-id");
+			const input_schemas = parseSchemasCsv(schemasFlag);
+			body = WorkspaceProvisionInput.parse({
+				database_id: databaseId,
+				input_schemas
+			});
+		} else body = await readBody({
+			flag: args.body,
+			file: args.file
+		}, WorkspaceProvisionInput);
+		const client = await getClient();
+		const initial = await client.requestParsed(Workspace, `/api/ee/workspace-manager/${workspaceId}/database`, {
+			method: "POST",
+			body
+		});
+		const final = wait.enabled ? await waitForDatabaseProvisioned(client, workspaceId, body.database_id, wait.schedule) : initial;
+		renderItem(final, workspaceView, ctx);
+	}
+});
+
+//#endregion
+export { provision_default as default };

package/dist/ps-BUNHygf-.mjs

@@ -0,0 +1,10 @@
+import "./package-DBsS7a5x.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import "./runtime-D7jihh81.mjs";
+import "./poll-DMmmZWvi.mjs";
+import "./docker-D-ieBsP7.mjs";
+import { LocalWorkspace, LocalWorkspaceCompact, LocalWorkspaceListEnvelope, LocalWorkspaceState, localWorkspaceView, ps_default } from "./ps-Yv0JjLVN.mjs";
+
+export { ps_default as default };

package/dist/ps-Yv0JjLVN.mjs

@@ -0,0 +1,78 @@
+import { renderList } from "./render-DXv-D6fU.mjs";
+import { defineMetabaseCommand, listEnvelopeSchema, localUrl, outputFlags, wrapList } from "./runtime-D7jihh81.mjs";
+import { CONTAINER_STATES, checkDockerReady, listWorkspaceContainers } from "./docker-D-ieBsP7.mjs";
+import { z } from "zod";
+
+//#region src/commands/workspace/ps.ts
+const LocalWorkspaceState = z.enum(CONTAINER_STATES);
+const LocalWorkspace = z.object({
+	workspace_id: z.number().int().positive(),
+	workspace_name: z.string(),
+	container_name: z.string(),
+	state: LocalWorkspaceState,
+	status: z.string(),
+	image: z.string(),
+	profile: z.string().nullable(),
+	parent_url: z.string().nullable(),
+	host_port: z.number().int().positive().nullable(),
+	url: z.string().nullable()
+});
+const LocalWorkspaceCompact = LocalWorkspace.pick({
+	workspace_id: true,
+	workspace_name: true,
+	state: true,
+	url: true
+}).strip();
+const localWorkspaceView = {
+	compactPick: LocalWorkspaceCompact,
+	tableColumns: [
+		{
+			key: "workspace_id",
+			label: "ID"
+		},
+		{
+			key: "workspace_name",
+			label: "Name"
+		},
+		{
+			key: "state",
+			label: "State"
+		},
+		{
+			key: "url",
+			label: "URL",
+			format: (value) => typeof value === "string" ? value : "—"
+		}
+	]
+};
+const LocalWorkspaceListEnvelope = listEnvelopeSchema(LocalWorkspaceCompact);
+var ps_default = defineMetabaseCommand({
+	meta: {
+		name: "ps",
+		description: "List workspaces with a local container (running or stopped)"
+	},
+	args: { ...outputFlags },
+	outputSchema: LocalWorkspaceListEnvelope,
+	examples: ["metabase workspace ps", "metabase workspace ps --json"],
+	async run({ ctx }) {
+		await checkDockerReady();
+		const summaries = await listWorkspaceContainers();
+		const items = summaries.map((summary) => ({
+			workspace_id: summary.workspaceId,
+			workspace_name: summary.workspaceName,
+			container_name: summary.name,
+			state: summary.state,
+			status: summary.status,
+			image: summary.image,
+			profile: summary.profile,
+			parent_url: summary.parentUrl,
+			host_port: summary.hostPort,
+			url: summary.hostPort !== null && summary.state === "running" ? localUrl(summary.hostPort) : null
+		}));
+		items.sort((a, b) => a.workspace_id - b.workspace_id);
+		renderList(wrapList(items), localWorkspaceView, ctx);
+	}
+});
+
+//#endregion
+export { LocalWorkspace, LocalWorkspaceCompact, LocalWorkspaceListEnvelope, LocalWorkspaceState, localWorkspaceView, ps_default };

package/dist/{query-PihYi-UZ.mjs → query-CzfbuG8a.mjs}

@@ -1,8 +1,11 @@
-import "./package-BGfw4ZWJ.mjs";
+import "./package-DBsS7a5x.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { ConfigError, connectionFlags, defineMetabaseCommand, outputFlags, parseJson, profileFlag, renderItem } from "./runtime-C9CEZhcn.mjs";
-import { CardQueryResult, cardQueryView } from "./card-CsXk8T6A.mjs";
-import { parseId } from "./parse-id-BhmmfyCP.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import { ConfigError } from "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, parseJson, profileFlag } from "./runtime-D7jihh81.mjs";
+import { parseId } from "./parse-id-BUOZQqjp.mjs";
+import "./field-DciLbuv-.mjs";
+import { CardQueryResult, cardQueryView } from "./card-CAEZWixN.mjs";
 import { z } from "zod";
 import { Writable } from "node:stream";
 
@@ -13,12 +16,16 @@ async function pipeToStdout(stream) {
 
 //#endregion
 //#region src/commands/card/query.ts
-const ExportFormat = z.enum(["csv", "xlsx"]);
+const ExportFormat = z.enum([
+	"csv",
+	"json",
+	"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)"
+		description: "Run a saved card and return results (json envelope, or stream CSV/JSON/XLSX via --export-format)"
 	},
 	args: {
 		...outputFlags,
@@ -39,7 +46,17 @@ var query_default = defineMetabaseCommand({
 		},
 		limit: {
 			type: "string",
-			description: "Cap rows kept in the JSON envelope (no effect on csv/xlsx exports)"
+			description: "Cap rows kept in the JSON envelope (no effect on streamed exports)"
+		},
+		"format-rows": {
+			type: "boolean",
+			description: "Streamed exports only: apply visualization-settings formatting to values (default false)",
+			default: false
+		},
+		"pivot-results": {
+			type: "boolean",
+			description: "Streamed exports only: emit the pivoted output for pivot questions (default false)",
+			default: false
 		}
 	},
 	outputSchema: CardQueryResult,
@@ -55,8 +72,12 @@ var query_default = defineMetabaseCommand({
 		const client = await getClient();
 		const exportFormatRaw = args["export-format"];
 		if (exportFormatRaw !== void 0 && exportFormatRaw !== "") {
-			const exportFormat = parseExportFormat(exportFormatRaw);
-			await streamExport(client, id, exportFormat, parameters);
+			await streamExport(client, id, {
+				format: parseExportFormat(exportFormatRaw),
+				parameters,
+				formatRows: args["format-rows"],
+				pivotResults: args["pivot-results"]
+			});
 			return;
 		}
 		const result = await client.requestParsed(CardQueryResult, `/api/card/${id}/query`, {
@@ -77,7 +98,7 @@ function parseExportFormat(raw) {
 	return result.data;
 }
 function applyLimit(result, limit) {
-	if (limit === null || result.status !== "completed" || result.data.rows.length <= limit) return result;
+	if (limit === null || result.data === void 0 || result.data.rows.length <= limit) return result;
 	return {
 		...result,
 		data: {
@@ -86,9 +107,13 @@ function applyLimit(result, 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}`, {
+async function streamExport(client, id, options) {
+	const body = new URLSearchParams({
+		parameters: JSON.stringify(options.parameters),
+		format_rows: String(options.formatRows),
+		pivot_results: String(options.pivotResults)
+	});
+	const stream = await client.requestStream(`/api/card/${id}/query/${options.format}`, {
 		method: "POST",
 		body
 	});

package/dist/query-UIebHmbT.mjs

@@ -0,0 +1,90 @@
+import "./package-DBsS7a5x.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem, writeJson } from "./render-DXv-D6fU.mjs";
+import { ConfigError } from "./predicates-DiIiS3k7.mjs";
+import "./input-ikCiip6x.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-D7jihh81.mjs";
+import { readBody } from "./body-DRBgxS6-.mjs";
+import { bodyInputFlags } from "./body-flags-BK7J6Daz.mjs";
+import "./field-DciLbuv-.mjs";
+import { CardQueryResult, cardQueryView } from "./card-CAEZWixN.mjs";
+import { assertNotLegacyEnvelopeWrappingMbql5, getQuerySchemaBundle, isMbql5Query, validateQuery } from "./validate-DCYx6jdL.mjs";
+import { skipValidateFlag } from "./validate-query-B07oGG4K.mjs";
+import { z } from "zod";
+
+//#region src/commands/query.ts
+const QueryBody = z.unknown();
+const QUERY_ENDPOINT = "/api/dataset";
+var query_default = defineMetabaseCommand({
+	meta: {
+		name: "query",
+		description: "Run an MBQL 5 query (validates against the bundled schema first); --print-schema emits the schema for agent discovery, --dry-run validates without sending. Any non-MBQL 5 body — legacy MBQL 4 ({type:\"query\", …}), legacy native ({type:\"native\", …}), or any other non-{lib/type:\"mbql/query\"} shape — skips pre-flight automatically and is normalized server-side by lib-be/normalize-query. The bundled schema only models MBQL 5. Every clause options object carries a `lib/uuid` (UUID v4); mint these via `metabase uuid` — never author them by hand."
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags,
+		"dry-run": {
+			type: "boolean",
+			description: "Validate the body and exit without sending the query"
+		},
+		"print-schema": {
+			type: "boolean",
+			description: "Emit the bundled MBQL 5 query JSON Schema and exit; no body required"
+		},
+		...skipValidateFlag
+	},
+	outputSchema: CardQueryResult,
+	examples: [
+		"metabase query --print-schema",
+		"cat q.json | metabase query --dry-run",
+		"metabase query --file q.json",
+		"metabase query --file q.json --skip-validate"
+	],
+	async run({ args, ctx, getClient }) {
+		if (args["print-schema"] === true) {
+			writeJson(getQuerySchemaBundle());
+			return;
+		}
+		const dryRun = args["dry-run"] === true;
+		const explicitSkip = args["skip-validate"] === true;
+		if (dryRun && explicitSkip) throw new ConfigError("--skip-validate cannot be combined with --dry-run");
+		const body = await readBody({
+			flag: args.body,
+			file: args.file
+		}, QueryBody);
+		if (!explicitSkip) assertNotLegacyEnvelopeWrappingMbql5(body, {
+			contextLabel: "query",
+			bodyNoun: "the body"
+		});
+		const skipValidation = explicitSkip || !isMbql5Query(body);
+		if (!skipValidation) {
+			const outcome = validateQuery(body);
+			if (!outcome.ok) {
+				writeJson(outcome);
+				const hint = dryRun ? "" : " — pass --dry-run to validate without sending";
+				throw new ConfigError(`validation failed: ${outcome.errors.length} error(s)${hint}`);
+			}
+			if (dryRun) {
+				writeJson(outcome);
+				return;
+			}
+		} else if (dryRun) {
+			writeJson({
+				ok: true,
+				errors: []
+			});
+			return;
+		}
+		const client = await getClient();
+		const queryResult = await client.requestParsed(CardQueryResult, QUERY_ENDPOINT, {
+			method: "POST",
+			body
+		});
+		renderItem(queryResult, cardQueryView, ctx);
+	}
+});
+
+//#endregion
+export { query_default as default };