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

package/dist/table-BvAr2ixC.mjs

@@ -0,0 +1,75 @@
+import { Field } from "./field-QwBMAWsq.mjs";
+import { z } from "zod";
+
+//#region src/domain/table.ts
+const TableEntityType = z.enum([
+	"entity/GenericTable",
+	"entity/UserTable",
+	"entity/CompanyTable",
+	"entity/TransactionTable",
+	"entity/ProductTable",
+	"entity/SubscriptionTable",
+	"entity/EventTable"
+]);
+const TableVisibilityType = z.enum([
+	"details-only",
+	"hidden",
+	"normal",
+	"retired",
+	"sensitive",
+	"technical",
+	"cruft"
+]);
+const Table = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	display_name: z.string(),
+	description: z.string().nullable(),
+	db_id: z.number().int(),
+	schema: z.string().nullable(),
+	entity_type: TableEntityType.nullable(),
+	visibility_type: TableVisibilityType.nullable(),
+	active: z.boolean(),
+	fields: z.array(Field).optional()
+}).loose();
+const TableCompact = Table.pick({
+	id: true,
+	name: true,
+	display_name: true,
+	description: true,
+	db_id: true,
+	schema: true,
+	entity_type: true
+}).strip();
+const tableView = {
+	compactPick: TableCompact,
+	tableColumns: [
+		{
+			key: "id",
+			label: "ID"
+		},
+		{
+			key: "db_id",
+			label: "DB"
+		},
+		{
+			key: "schema",
+			label: "Schema"
+		},
+		{
+			key: "name",
+			label: "Name"
+		},
+		{
+			key: "display_name",
+			label: "Display Name"
+		},
+		{
+			key: "description",
+			label: "Description"
+		}
+	]
+};
+
+//#endregion
+export { Table, TableCompact, tableView };

package/dist/table-D-Mb5Nvw.mjs

@@ -0,0 +1,16 @@
+import { defineCommand } from "citty";
+
+//#region src/commands/table/index.ts
+var table_default = defineCommand({
+	meta: {
+		name: "table",
+		description: "Inspect Metabase tables"
+	},
+	subCommands: {
+		list: () => import("./list-OBx5B3gd.mjs").then((m) => m.default),
+		get: () => import("./get-DDWpubE8.mjs").then((m) => m.default)
+	}
+});
+
+//#endregion
+export { table_default as default };

package/dist/transform-CqxZwhGs.mjs

@@ -0,0 +1,21 @@
+import { defineCommand } from "citty";
+
+//#region src/commands/transform/index.ts
+var transform_default = defineCommand({
+	meta: {
+		name: "transform",
+		description: "Manage Metabase transforms"
+	},
+	subCommands: {
+		list: () => import("./list-qetY9OIN.mjs").then((mod) => mod.default),
+		get: () => import("./get-qPOsuTPw.mjs").then((mod) => mod.default),
+		create: () => import("./create-_UOeEXAj.mjs").then((mod) => mod.default),
+		update: () => import("./update-CDtm71m2.mjs").then((mod) => mod.default),
+		delete: () => import("./delete-DRBTgyus.mjs").then((mod) => mod.default),
+		"delete-table": () => import("./delete-table-9Is631O_.mjs").then((mod) => mod.default),
+		run: () => import("./run-D4NgvaRh.mjs").then((mod) => mod.default)
+	}
+});
+
+//#endregion
+export { transform_default as default };

package/dist/transform-DfVkUttP.mjs

@@ -0,0 +1,137 @@
+import { z } from "zod";
+
+//#region src/domain/transform.ts
+const TransformSourceType = z.enum([
+	"native",
+	"mbql",
+	"python"
+]);
+const TransformRunStatus = z.enum([
+	"started",
+	"succeeded",
+	"failed",
+	"timeout",
+	"canceled",
+	"canceling"
+]);
+const TransformRunMethod = z.enum(["manual", "cron"]);
+const TransformRunTrigger = z.enum(["none", "global-schedule"]);
+const TransformQuerySource = z.object({
+	type: z.literal("query"),
+	query: z.unknown()
+}).loose();
+const TransformPythonSource = z.object({
+	type: z.literal("python"),
+	body: z.string()
+}).loose();
+const TransformSource = z.discriminatedUnion("type", [TransformQuerySource, TransformPythonSource]);
+const TransformTableTarget = z.object({
+	type: z.literal("table"),
+	database: z.number().int().optional(),
+	schema: z.string().nullable().optional(),
+	name: z.string()
+}).loose();
+const TransformTableIncrementalTarget = z.object({
+	type: z.literal("table-incremental"),
+	database: z.number().int().optional(),
+	schema: z.string().nullable().optional(),
+	name: z.string()
+}).loose();
+const TransformTarget = z.discriminatedUnion("type", [TransformTableTarget, TransformTableIncrementalTarget]);
+const TransformLastRun = z.object({
+	id: z.number().int(),
+	transform_id: z.number().int(),
+	run_method: TransformRunMethod,
+	status: TransformRunStatus,
+	start_time: z.string(),
+	end_time: z.string().nullable().optional(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable()
+}).loose();
+const TransformRun = z.object({
+	id: z.number().int(),
+	transform_id: z.number().int().nullable(),
+	run_method: TransformRunMethod,
+	status: TransformRunStatus,
+	is_active: z.boolean().nullable(),
+	start_time: z.string(),
+	end_time: z.string().nullable().optional(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable()
+}).loose();
+const Transform = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	source: TransformSource,
+	target: TransformTarget,
+	source_type: TransformSourceType,
+	source_database_id: z.number().int().nullable().optional(),
+	target_db_id: z.number().int().nullable().optional(),
+	target_table_id: z.number().int().nullable().optional(),
+	entity_id: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string(),
+	creator_id: z.number().int(),
+	collection_id: z.number().int().nullable(),
+	run_trigger: TransformRunTrigger.nullable().optional(),
+	last_run: TransformLastRun.nullable().optional(),
+	tag_ids: z.array(z.number().int()).optional()
+}).loose();
+const TransformCompact = Transform.pick({
+	id: true,
+	name: true,
+	description: true,
+	source_type: true,
+	target_db_id: true
+}).strip();
+const transformView = {
+	compactPick: TransformCompact,
+	tableColumns: [
+		{
+			key: "id",
+			label: "ID"
+		},
+		{
+			key: "name",
+			label: "Name"
+		},
+		{
+			key: "source_type",
+			label: "Source"
+		},
+		{
+			key: "target_db_id",
+			label: "Target DB"
+		},
+		{
+			key: "description",
+			label: "Description"
+		}
+	]
+};
+const TransformCreateInput = z.object({
+	name: z.string().min(1),
+	description: z.string().nullable().optional(),
+	source: TransformSource,
+	target: TransformTarget,
+	run_trigger: TransformRunTrigger.optional(),
+	tag_ids: z.array(z.number().int().positive()).optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	owner_user_id: z.number().int().positive().nullable().optional(),
+	owner_email: z.string().nullable().optional()
+}).loose();
+const TransformUpdateInput = z.object({
+	name: z.string().min(1).optional(),
+	description: z.string().nullable().optional(),
+	source: TransformSource.optional(),
+	target: TransformTarget.optional(),
+	run_trigger: TransformRunTrigger.optional(),
+	tag_ids: z.array(z.number().int().positive()).optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	owner_user_id: z.number().int().positive().nullable().optional(),
+	owner_email: z.string().nullable().optional()
+}).loose();
+
+//#endregion
+export { Transform, TransformCompact, TransformCreateInput, TransformRun, TransformUpdateInput, transformView };

package/dist/transform-job-DuB_OjhO.mjs

@@ -0,0 +1,91 @@
+import { z } from "zod";
+
+//#region src/domain/transform-job.ts
+const JobUiDisplayType = z.enum(["cron/raw", "cron/builder"]);
+const JobRunStatus = z.enum([
+	"started",
+	"succeeded",
+	"failed",
+	"timeout"
+]);
+const JobRunMethod = z.enum(["manual", "cron"]);
+const JobLastRun = z.object({
+	id: z.number().int(),
+	job_id: z.number().int(),
+	run_method: JobRunMethod,
+	status: JobRunStatus,
+	start_time: z.string(),
+	end_time: z.string().nullable().optional(),
+	message: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const JobNextRun = z.object({ start_time: z.string() }).loose();
+const TransformJob = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	schedule: z.string(),
+	ui_display_type: JobUiDisplayType,
+	entity_id: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string(),
+	built_in_type: z.string().nullable().optional(),
+	tag_ids: z.array(z.number().int()).optional(),
+	last_run: JobLastRun.nullable().optional(),
+	next_run: JobNextRun.nullable().optional()
+}).loose();
+const TransformJobCompact = TransformJob.pick({
+	id: true,
+	name: true,
+	description: true,
+	schedule: true,
+	ui_display_type: true,
+	built_in_type: true
+}).strip();
+const transformJobView = {
+	compactPick: TransformJobCompact,
+	tableColumns: [
+		{
+			key: "id",
+			label: "ID"
+		},
+		{
+			key: "name",
+			label: "Name"
+		},
+		{
+			key: "schedule",
+			label: "Schedule"
+		},
+		{
+			key: "ui_display_type",
+			label: "Display"
+		},
+		{
+			key: "built_in_type",
+			label: "Built-in"
+		},
+		{
+			key: "description",
+			label: "Description"
+		}
+	]
+};
+const TransformJobCreateInput = z.object({
+	name: z.string().min(1),
+	description: z.string().min(1).nullable().optional(),
+	schedule: z.string().min(1),
+	ui_display_type: JobUiDisplayType.optional(),
+	tag_ids: z.array(z.number().int().positive()).optional()
+}).loose();
+const TransformJobUpdateInput = z.object({
+	name: z.string().min(1).optional(),
+	description: z.string().min(1).nullable().optional(),
+	schedule: z.string().min(1).optional(),
+	ui_display_type: JobUiDisplayType.optional(),
+	tag_ids: z.array(z.number().int().positive()).optional()
+}).loose();
+
+//#endregion
+export { TransformJob, TransformJobCompact, TransformJobCreateInput, TransformJobUpdateInput, transformJobView };

package/dist/transform-job-HjbqjEoP.mjs

@@ -0,0 +1,19 @@
+import { defineCommand } from "citty";
+
+//#region src/commands/transform-job/index.ts
+var transform_job_default = defineCommand({
+	meta: {
+		name: "transform-job",
+		description: "Manage Metabase transform jobs"
+	},
+	subCommands: {
+		list: () => import("./list-C5MGydGU.mjs").then((mod) => mod.default),
+		get: () => import("./get-DhIoNeOp.mjs").then((mod) => mod.default),
+		create: () => import("./create-DpnjQvPw.mjs").then((mod) => mod.default),
+		update: () => import("./update-DxKlQ0hP.mjs").then((mod) => mod.default),
+		delete: () => import("./delete-DUC_stoL.mjs").then((mod) => mod.default)
+	}
+});
+
+//#endregion
+export { transform_job_default as default };

package/dist/translate-DJxDVAE4.mjs

@@ -0,0 +1,110 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { ConfigError, connectionFlags, defineMetabaseCommand, outputFlags, parseCsv, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import "./input-BNqSFl38.mjs";
+import { readBody } from "./body-DwU2s6Pg.mjs";
+import { bodyInputFlags } from "./body-flags-7oqLhu5j.mjs";
+import { requireBothOrNeither } from "./flag-pair-CWvvzDJ_.mjs";
+import { z } from "zod";
+
+//#region src/domain/eid-translation.ts
+const EID_MODELS = [
+	"action",
+	"card",
+	"collection",
+	"dashboard",
+	"dashboard-card",
+	"dashboard-tab",
+	"dataset",
+	"dimension",
+	"document",
+	"measure",
+	"metric",
+	"permissions-group",
+	"pulse",
+	"pulse-card",
+	"pulse-channel",
+	"segment",
+	"snippet",
+	"timeline",
+	"transform",
+	"user"
+];
+const EidModel = z.enum(EID_MODELS);
+const EidTranslateInput = z.object({ entity_ids: z.partialRecord(EidModel, z.array(z.string().min(1)).min(1)) }).loose();
+const EidTranslateEntry = z.object({
+	status: z.string(),
+	type: EidModel,
+	id: z.number().int().optional()
+}).loose();
+const EidTranslateResult = z.object({ entity_ids: z.record(z.string(), EidTranslateEntry) }).loose();
+const EidTranslateResultCompact = EidTranslateResult.pick({ entity_ids: true }).strip();
+const eidTranslateView = {
+	compactPick: EidTranslateResultCompact,
+	tableColumns: [{
+		key: "entity_ids",
+		label: "Translated"
+	}]
+};
+
+//#endregion
+//#region src/commands/eid/translate.ts
+var translate_default = defineMetabaseCommand({
+	meta: {
+		name: "translate",
+		description: "Translate entity ids (EIDs) to numeric ids"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags,
+		model: {
+			type: "string",
+			description: `Entity model for shortcut form: ${EID_MODELS.join(" | ")}`
+		},
+		eids: {
+			type: "string",
+			description: "Comma-separated EIDs (used with --model as a shortcut)"
+		}
+	},
+	outputSchema: EidTranslateResult,
+	examples: [
+		"metabase eid translate --model card --eids abc123XYZ,def456ABC",
+		"metabase eid translate --file translate.json",
+		"metabase eid translate --body '{\"entity_ids\":{\"card\":[\"abc123XYZ\"]}}'"
+	],
+	async run({ args, ctx, getClient }) {
+		const pair = requireBothOrNeither({
+			name: "--model",
+			value: args.model
+		}, {
+			name: "--eids",
+			value: args.eids
+		});
+		const body = pair ? EidTranslateInput.parse({ entity_ids: { [parseModel(pair.first)]: parseEids(pair.second) } }) : await readBody({
+			flag: args.body,
+			file: args.file
+		}, EidTranslateInput);
+		const client = await getClient();
+		const result = await client.requestParsed(EidTranslateResult, "/api/eid-translation/translate", {
+			method: "POST",
+			body
+		});
+		renderItem(result, eidTranslateView, ctx);
+	}
+});
+function parseModel(raw) {
+	const result = EidModel.safeParse(raw);
+	if (!result.success) throw new ConfigError(`invalid --model: "${raw}" (expected one of: ${EID_MODELS.join(", ")})`);
+	return result.data;
+}
+function parseEids(raw) {
+	const parts = parseCsv(raw);
+	if (parts.length === 0) throw new ConfigError("--eids must contain at least one EID");
+	return parts;
+}
+
+//#endregion
+export { translate_default as default };

package/dist/update-CDtm71m2.mjs

@@ -0,0 +1,50 @@
+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 "./input-BNqSFl38.mjs";
+import { readBody } from "./body-DwU2s6Pg.mjs";
+import { bodyInputFlags } from "./body-flags-7oqLhu5j.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import { Transform, TransformUpdateInput, transformView } from "./transform-DfVkUttP.mjs";
+
+//#region src/commands/transform/update.ts
+var update_default = defineMetabaseCommand({
+	meta: {
+		name: "update",
+		description: "Update a transform by id"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags,
+		id: {
+			type: "positional",
+			description: "Transform id",
+			required: true
+		}
+	},
+	outputSchema: Transform,
+	examples: [
+		"cat patch.json | metabase transform update 1",
+		"metabase transform update 1 --file patch.json",
+		"metabase transform update 1 --body '{\"name\":\"renamed\"}'"
+	],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const body = await readBody({
+			flag: args.body,
+			file: args.file
+		}, TransformUpdateInput);
+		const client = await getClient();
+		const updated = await client.requestParsed(Transform, `/api/transform/${id}`, {
+			method: "PUT",
+			body
+		});
+		renderItem(updated, transformView, ctx);
+	}
+});
+
+//#endregion
+export { update_default as default };

package/dist/update-DYVeVjk2.mjs

@@ -0,0 +1,76 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { ConfigError, connectionFlags, defineMetabaseCommand, outputFlags, parseCsv, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import "./input-BNqSFl38.mjs";
+import { readBody } from "./body-DwU2s6Pg.mjs";
+import { bodyInputFlags } from "./body-flags-7oqLhu5j.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import "./poll-D2sXM5rc.mjs";
+import { parseWaitFlags, waitFlags } from "./wait-flags-CjW4ogUJ.mjs";
+import { Workspace, WorkspaceUpdateDatabaseInput, workspaceView } from "./workspace-Dr9lWU3D.mjs";
+import { waitForDatabaseProvisioned } from "./wait-DwZN3ZwR.mjs";
+
+//#region src/commands/workspace/database/update.ts
+var update_default = defineMetabaseCommand({
+	meta: {
+		name: "update",
+		description: "Update a workspace's database (deprovisions then re-provisions with new input schemas)"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags,
+		...waitFlags,
+		schemas: {
+			type: "string",
+			description: "Comma-separated input schemas (alternative to --body / --file)"
+		},
+		id: {
+			type: "positional",
+			description: "Workspace id",
+			required: true
+		},
+		"db-id": {
+			type: "positional",
+			description: "Database id",
+			required: true
+		}
+	},
+	outputSchema: Workspace,
+	examples: [
+		"metabase workspace database update 1 5 --schemas analytics,github",
+		"metabase workspace database update 1 5 --schemas analytics --wait",
+		"metabase workspace database update 1 5 --file update.json"
+	],
+	async run({ args, ctx, getClient }) {
+		const workspaceId = parseId(args.id);
+		const databaseId = parseId(args["db-id"], "db-id");
+		const schemasFlag = args.schemas;
+		const wait = parseWaitFlags(args);
+		let body;
+		if (schemasFlag !== void 0 && schemasFlag !== "") {
+			const schemas = parseSchemas(schemasFlag);
+			body = WorkspaceUpdateDatabaseInput.parse({ input_schemas: schemas });
+		} else body = await readBody({
+			flag: args.body,
+			file: args.file
+		}, WorkspaceUpdateDatabaseInput);
+		const client = await getClient();
+		const initial = await client.requestParsed(Workspace, `/api/ee/workspace-manager/${workspaceId}/database/${databaseId}`, {
+			method: "PUT",
+			body
+		});
+		const final = wait.enabled ? await waitForDatabaseProvisioned(client, workspaceId, databaseId, wait.schedule) : initial;
+		renderItem(final, workspaceView, ctx);
+	}
+});
+function parseSchemas(raw) {
+	const parts = parseCsv(raw);
+	if (parts.length === 0) throw new ConfigError("--schemas must contain at least one schema name");
+	return parts;
+}
+
+//#endregion
+export { update_default as default };

package/dist/update-DxKlQ0hP.mjs

@@ -0,0 +1,50 @@
+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 "./input-BNqSFl38.mjs";
+import { readBody } from "./body-DwU2s6Pg.mjs";
+import { bodyInputFlags } from "./body-flags-7oqLhu5j.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import { TransformJob, TransformJobUpdateInput, transformJobView } from "./transform-job-DuB_OjhO.mjs";
+
+//#region src/commands/transform-job/update.ts
+var update_default = defineMetabaseCommand({
+	meta: {
+		name: "update",
+		description: "Update a transform job by id"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags,
+		id: {
+			type: "positional",
+			description: "Transform job id",
+			required: true
+		}
+	},
+	outputSchema: TransformJob,
+	examples: [
+		"cat patch.json | metabase transform-job update 1",
+		"metabase transform-job update 1 --file patch.json",
+		"metabase transform-job update 1 --body '{\"schedule\":\"0 0 6 * * ?\"}'"
+	],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const body = await readBody({
+			flag: args.body,
+			file: args.file
+		}, TransformJobUpdateInput);
+		const client = await getClient();
+		const updated = await client.requestParsed(TransformJob, `/api/transform-job/${id}`, {
+			method: "PUT",
+			body
+		});
+		renderItem(updated, transformJobView, ctx);
+	}
+});
+
+//#endregion
+export { update_default as default };