@metabase/cli 0.3.2-alpha.fix-transform-test-ee-path.8ac2a7a → 0.3.2

package/dist/transform-test-BjjCQ2xm.mjs

@@ -1,169 +0,0 @@
-import { z } from "zod";
-//#region ../client/src/domain/transform-test.ts
-const TransformTestTable = z.object({
-	schema: z.string().min(1).nullable().optional(),
-	name: z.string().min(1)
-}).loose();
-const TransformTestColumn = z.object({
-	name: z.string().min(1),
-	cast_type: z.string().min(1)
-}).loose();
-const TransformTestCell = z.union([
-	z.boolean(),
-	z.number(),
-	z.string(),
-	z.null()
-]);
-const TransformTestRow = z.record(z.string(), TransformTestCell);
-const TransformTestSqlInput = z.object({
-	table: TransformTestTable,
-	format: z.literal("sql"),
-	sql: z.string().min(1)
-}).loose();
-const TransformTestRowsInput = z.object({
-	table: TransformTestTable,
-	format: z.literal("rows"),
-	columns: z.array(TransformTestColumn).min(1),
-	rows: z.array(TransformTestRow)
-}).loose();
-const TransformTestInput = z.discriminatedUnion("format", [TransformTestSqlInput, TransformTestRowsInput]);
-const TransformTestEqualsSqlExpectation = z.object({
-	type: z.literal("equals"),
-	name: z.string().min(1),
-	format: z.literal("sql"),
-	sql: z.string().min(1)
-}).loose();
-const TransformTestEqualsRowsExpectation = z.object({
-	type: z.literal("equals"),
-	name: z.string().min(1),
-	format: z.literal("rows"),
-	columns: z.array(TransformTestColumn).min(1),
-	rows: z.array(TransformTestRow)
-}).loose();
-const TransformTestEqualsExpectation = z.discriminatedUnion("format", [TransformTestEqualsSqlExpectation, TransformTestEqualsRowsExpectation]);
-const TransformTestEmptyExpectation = z.object({
-	type: z.literal("empty"),
-	name: z.string().min(1),
-	sql: z.string().min(1)
-}).loose();
-const TransformTestExpectation = z.discriminatedUnion("type", [TransformTestEqualsExpectation, TransformTestEmptyExpectation]);
-const TransformTest = z.object({
-	id: z.number().int(),
-	entity_id: z.string(),
-	transform_id: z.number().int(),
-	creator_id: z.number().int(),
-	name: z.string(),
-	description: z.string().nullable(),
-	inputs: z.array(TransformTestInput),
-	expectations: z.array(TransformTestExpectation),
-	created_at: z.string(),
-	updated_at: z.string()
-}).loose();
-const TransformTestCompact = TransformTest.pick({
-	id: true,
-	transform_id: true,
-	name: true,
-	description: true
-}).strip();
-/**
-* The server closes this map, so an unrecognized key is a 400 there. Refusing it here names the key
-* instead: a body cloned from `get` has to shed `id`, `entity_id`, `creator_id`, `created_at` and
-* `updated_at` before it can be sent back.
-*/
-const TransformTestCreateInput = z.object({
-	transform_id: z.number().int().positive(),
-	name: z.string().min(1),
-	description: z.string().nullable().optional(),
-	inputs: z.array(TransformTestInput),
-	expectations: z.array(TransformTestExpectation)
-}).strict();
-/** Closed for the same reason as [[TransformTestCreateInput]]; every field is optional. */
-const TransformTestUpdateInput = z.object({
-	transform_id: z.number().int().positive().optional(),
-	name: z.string().min(1).optional(),
-	description: z.string().nullable().optional(),
-	inputs: z.array(TransformTestInput).optional(),
-	expectations: z.array(TransformTestExpectation).optional()
-}).strict();
-const TransformTestResultColumn = z.object({
-	name: z.string(),
-	database_type: z.string()
-}).loose();
-const TransformTestExpectationError = z.object({
-	type: z.string(),
-	message: z.string()
-}).loose();
-const TransformTestCellMismatch = z.object({
-	column: z.string(),
-	expected: TransformTestCell,
-	actual: TransformTestCell
-}).loose();
-const TransformTestRowCounts = z.object({
-	actual: z.number().int(),
-	expected: z.number().int()
-}).loose();
-const TransformTestEqualsFindings = z.object({
-	name: z.string(),
-	type: z.literal("equals"),
-	status: z.enum(["passed", "failed"]),
-	columns: z.array(TransformTestResultColumn),
-	"row-counts": TransformTestRowCounts,
-	"extra-rows": z.array(TransformTestRow),
-	"missing-rows": z.array(TransformTestRow),
-	"cell-mismatches": z.array(TransformTestCellMismatch),
-	truncated: z.number().int()
-}).loose();
-const TransformTestEqualsError = z.object({
-	name: z.string(),
-	type: z.literal("equals"),
-	status: z.literal("error"),
-	error: TransformTestExpectationError
-}).loose();
-const TransformTestEqualsResult = z.discriminatedUnion("status", [TransformTestEqualsFindings, TransformTestEqualsError]);
-const TransformTestEmptyPassed = z.object({
-	name: z.string(),
-	type: z.literal("empty"),
-	status: z.literal("passed")
-}).loose();
-const TransformTestEmptyFailed = z.object({
-	name: z.string(),
-	type: z.literal("empty"),
-	status: z.literal("failed"),
-	columns: z.array(TransformTestResultColumn),
-	sample: z.array(TransformTestRow),
-	truncated: z.number().int()
-}).loose();
-const TransformTestEmptyError = z.object({
-	name: z.string(),
-	type: z.literal("empty"),
-	status: z.literal("error"),
-	error: TransformTestExpectationError
-}).loose();
-const TransformTestEmptyResult = z.discriminatedUnion("status", [
-	TransformTestEmptyPassed,
-	TransformTestEmptyFailed,
-	TransformTestEmptyError
-]);
-const TransformTestExpectationResult = z.discriminatedUnion("type", [TransformTestEqualsResult, TransformTestEmptyResult]);
-const TransformTestRunResult = z.object({
-	status: z.enum(["passed", "failed"]),
-	expectations: z.array(TransformTestExpectationResult),
-	tables: z.record(z.string(), z.string())
-}).loose();
-z.enum([
-	"transform-test.unknown-column",
-	"transform-test.ambiguous-column",
-	"transform-test.missing-inputs",
-	"transform-test.unused-inputs",
-	"transform-test.duplicate-input-table",
-	"transform-test.unparseable-source",
-	"transform-test.unremapped-reference",
-	"transform-test.unsupported-transform",
-	"transform-test.unsupported-driver",
-	"transform-test.transform-failed",
-	"transform-test.setup-failed",
-	"transform-test.expectation-failed",
-	"transform-test.unsupported-format"
-]);
-//#endregion
-export { TransformTestUpdateInput as a, TransformTestRunResult as i, TransformTestCompact as n, TransformTestCreateInput as r, TransformTest as t };

package/dist/transform-test-C1Oqtfb-.mjs

@@ -1,16 +0,0 @@
-import { t as defineCommandGroup } from "./group-YQQ5GIcP.mjs";
-//#region src/commands/transform-test/index.ts
-var transform_test_default = defineCommandGroup({
-	name: "transform-test",
-	description: "Manage transform tests — fixtures and expectations run against temp tables",
-	subCommands: {
-		list: () => import("./list-Cuhf2lKL.mjs").then((mod) => mod.default),
-		get: () => import("./get-i0KInCw9.mjs").then((mod) => mod.default),
-		create: () => import("./create-DiJ8bUb-.mjs").then((mod) => mod.default),
-		update: () => import("./update-l3PyNQKG.mjs").then((mod) => mod.default),
-		delete: () => import("./delete-Bsdwqh7H.mjs").then((mod) => mod.default),
-		run: () => import("./run-FmRruANb.mjs").then((mod) => mod.default)
-	}
-});
-//#endregion
-export { transform_test_default as default };

package/dist/transform-test-gzDcbypy.mjs

@@ -1,25 +0,0 @@
-import { n as TransformTestCompact } from "./transform-test-BjjCQ2xm.mjs";
-//#region src/output/views/transform-test.ts
-const transformTestView = {
-	compactPick: TransformTestCompact,
-	tableColumns: [
-		{
-			key: "id",
-			label: "ID"
-		},
-		{
-			key: "transform_id",
-			label: "Transform"
-		},
-		{
-			key: "name",
-			label: "Name"
-		},
-		{
-			key: "description",
-			label: "Description"
-		}
-	]
-};
-//#endregion
-export { transformTestView as t };

package/dist/transport-CyVo29u7.mjs

@@ -1,313 +0,0 @@
-import { it as TimeoutError, n as methodRequirements, nt as NetworkError, ot as ValidationError, rt as ResponseShapeError, st as errorMessage } from "./cli.mjs";
-import { $ as createServerProfile, B as JSON_CONTENT_TYPE, F as buildNetworkError, G as credentialSecrets, I as isConnectionClosed, J as normalizeUrl, L as HttpError, U as assertCredentialHeaderSafe, V as parseJson, W as credentialAuthHeader, Z as checkFeatures, et as probeServer, tt as CapabilityError, z as isRetryableStatus } from "./runtime-Dtb93zKy.mjs";
-import { n as throwIfAborted, r as untilAborted, t as combineAborts } from "./signal-Csom0mt5.mjs";
-import { setTimeout } from "node:timers/promises";
-//#region ../client/src/http/response-shape.ts
-async function parseJsonResponse(text, schema, context) {
-	try {
-		return parseJson(text, schema, { source: context.url });
-	} catch (error) {
-		if (error instanceof ValidationError) throw ResponseShapeError.fromZodIssues({
-			kind: "zod",
-			method: context.method,
-			url: context.url,
-			status: context.status,
-			zodIssues: error.developerDetail.zodIssues,
-			serverTag: await context.getServerTag(),
-			serverSkew: context.serverSkew
-		});
-		throw error;
-	}
-}
-//#endregion
-//#region ../client/src/http/retry.ts
-const BASE_DELAY_MS = 250;
-const MAX_DELAY_MS = 8e3;
-const MS_PER_SECOND = 1e3;
-function backoffDelay({ attempt, retryAfterHeader }) {
-	const fromHeader = parseRetryAfter(retryAfterHeader);
-	if (fromHeader !== null) return fromHeader;
-	return Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt);
-}
-function parseRetryAfter(header) {
-	if (!header) return null;
-	const numeric = Number(header);
-	if (Number.isFinite(numeric) && numeric >= 0) return Math.round(numeric * MS_PER_SECOND);
-	const dateMs = Date.parse(header);
-	if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());
-	return null;
-}
-function sleep(ms, signal) {
-	return setTimeout(ms, void 0, { signal });
-}
-async function runWithRetries(attempt, signal) {
-	let attemptIndex = 0;
-	while (true) {
-		const outcome = await attempt(attemptIndex);
-		if (outcome.kind === "success") return outcome.response;
-		await sleep(outcome.delayMs, signal);
-		attemptIndex += 1;
-	}
-}
-//#endregion
-//#region ../client/src/http/transport.ts
-const UNAUTHORIZED_STATUS = 401;
-const DEFAULT_TIMEOUT_MS = 3e4;
-const OCTET_STREAM_CONTENT_TYPE = "application/octet-stream";
-const TEXT_CONTENT_TYPE_PREFIX = "text/";
-const ERROR_BODY_BYTE_CAP = 64 * 1024;
-const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
-	"GET",
-	"HEAD",
-	"OPTIONS"
-]);
-function createTransport(config, options) {
-	const baseUrl = normalizeUrl(config.url);
-	assertCredentialHeaderSafe(config.credential);
-	const fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
-	let settledProfile = options.server ?? null;
-	const getServerTag = options.getServerTag ?? (async () => tagOf(settledProfile));
-	const serverSkew = () => settledProfile === null ? null : settledProfile.skew;
-	const refreshCredential = options.refreshCredential;
-	let credential = config.credential;
-	const knownSecrets = new Set(credentialSecrets(credential));
-	const redactionContext = { knownSecrets };
-	let refreshInFlight = null;
-	function tryRefreshCredential() {
-		const refresh = refreshCredential;
-		if (credential.kind !== "oauth" || refresh === void 0) return Promise.resolve(false);
-		refreshInFlight ??= refreshOnce(refresh).finally(() => {
-			refreshInFlight = null;
-		});
-		return refreshInFlight;
-	}
-	async function refreshOnce(refresh) {
-		const next = await refresh();
-		if (next === null) return false;
-		credential = next;
-		for (const secret of credentialSecrets(next)) knownSecrets.add(secret);
-		return true;
-	}
-	async function attemptOnce(prepared, attempt) {
-		const hasRetriesLeft = attempt < prepared.retries;
-		const timeoutSignal = AbortSignal.timeout(prepared.timeoutMs);
-		const combined = combineAborts(timeoutSignal, prepared.cancelSignal);
-		let response;
-		try {
-			response = await fetchImpl(prepared.url, {
-				method: prepared.method,
-				headers: prepared.headers,
-				body: prepared.body,
-				signal: combined
-			});
-		} catch (error) {
-			throwIfAborted(prepared.cancelSignal);
-			const isStaleSocketFirstTry = attempt === 0 && isConnectionClosed(error);
-			if (prepared.idempotent && (hasRetriesLeft || isStaleSocketFirstTry)) return {
-				kind: "retry",
-				delayMs: backoffDelay({ attempt })
-			};
-			if (timeoutSignal.aborted) throw new TimeoutError(`Request timed out after ${prepared.timeoutMs}ms`, {
-				kind: "http",
-				method: prepared.method,
-				url: prepared.url,
-				timeoutMs: prepared.timeoutMs
-			});
-			throw buildNetworkError(error, prepared.method, prepared.url);
-		}
-		const canRetryStatus = hasRetriesLeft && prepared.idempotent;
-		if (!response.ok && isRetryableStatus(response.status) && canRetryStatus) {
-			const retryAfter = response.headers.get("Retry-After");
-			response.body?.cancel().catch(() => void 0);
-			return {
-				kind: "retry",
-				delayMs: backoffDelay({
-					attempt,
-					retryAfterHeader: retryAfter
-				})
-			};
-		}
-		if (!response.ok) {
-			const rawBody = await readBodyForError(response);
-			const serverTag = await getServerTag();
-			throw new HttpError({
-				status: response.status,
-				statusText: response.statusText,
-				method: prepared.method,
-				url: prepared.url,
-				responseHeaders: response.headers,
-				rawBody,
-				serverTag,
-				redactionContext
-			});
-		}
-		assertContentType(response, prepared);
-		return {
-			kind: "success",
-			response
-		};
-	}
-	async function executeRaw(prepared) {
-		try {
-			return await runWithRetries((attempt) => attemptOnce(prepared, attempt), prepared.cancelSignal);
-		} catch (error) {
-			throwIfAborted(prepared.cancelSignal);
-			throw error;
-		}
-	}
-	async function executeWithAuthRefresh(path, opts) {
-		const prepared = prepare(path, opts);
-		try {
-			return {
-				response: await executeRaw(prepared),
-				prepared
-			};
-		} catch (error) {
-			if (error instanceof HttpError && error.status === UNAUTHORIZED_STATUS) {
-				if (await tryRefreshCredential()) {
-					const retried = prepare(path, opts);
-					return {
-						response: await executeRaw(retried),
-						prepared: retried
-					};
-				}
-			}
-			throw error;
-		}
-	}
-	function prepare(path, opts = {}) {
-		const method = opts.method ?? "GET";
-		const expectContentType = opts.expectContentType ?? "json";
-		const url = buildUrl(baseUrl, path, opts.query);
-		const headers = new Headers();
-		const auth = credentialAuthHeader(credential);
-		headers.set(auth.name, auth.value);
-		headers.set("accept", acceptHeader(expectContentType));
-		headers.set("user-agent", options.userAgent);
-		let body = null;
-		if (opts.body !== void 0 && opts.body !== null) if (typeof opts.body === "string" || opts.body instanceof URLSearchParams) body = opts.body;
-		else if (opts.body instanceof FormData || opts.body instanceof ReadableStream) body = opts.body;
-		else if (opts.body instanceof Uint8Array) {
-			body = opts.body;
-			headers.set("content-type", OCTET_STREAM_CONTENT_TYPE);
-		} else {
-			body = JSON.stringify(opts.body);
-			headers.set("content-type", JSON_CONTENT_TYPE);
-		}
-		return {
-			url,
-			method,
-			headers,
-			body,
-			expectContentType,
-			retries: opts.retries ?? 3,
-			idempotent: opts.idempotent ?? IDEMPOTENT_METHODS.has(method),
-			timeoutMs: opts.timeoutMs ?? 3e4,
-			cancelSignal: combineAborts(opts.signal, options.signal)
-		};
-	}
-	let serverProfile = options.server === void 0 ? null : Promise.resolve(options.server);
-	async function server(wait = {}) {
-		throwIfAborted(wait.signal);
-		if (serverProfile === null) {
-			const probe = probeServer(transport).then((info) => {
-				settledProfile = createServerProfile(info);
-				return settledProfile;
-			});
-			probe.catch(() => {
-				serverProfile = null;
-			});
-			serverProfile = probe;
-		}
-		return untilAborted(serverProfile, wait.signal);
-	}
-	const enforceRequirements = options.enforceRequirements ?? true;
-	async function requireFeatures(features, wait = {}) {
-		if (!enforceRequirements || features.length === 0) return;
-		const failure = checkFeatures(features, await server(wait));
-		if (failure !== null) throw new CapabilityError(failure);
-	}
-	async function requireMethod(key, wait = {}) {
-		return requireFeatures(methodRequirements(key), wait);
-	}
-	const transport = {
-		server,
-		require: requireMethod,
-		requireFeatures,
-		async requestRaw(path, opts) {
-			return (await executeWithAuthRefresh(path, opts ?? {})).response;
-		},
-		async requestParsed(schema, path, opts) {
-			const { response, prepared } = await executeWithAuthRefresh(path, {
-				...opts,
-				expectContentType: "json"
-			});
-			return parseJsonResponse(await response.text(), schema, {
-				method: prepared.method,
-				url: prepared.url,
-				status: response.status,
-				getServerTag,
-				serverSkew: serverSkew()
-			});
-		},
-		async requestStream(path, opts) {
-			const { response, prepared } = await executeWithAuthRefresh(path, {
-				...opts,
-				expectContentType: opts?.expectContentType ?? "binary"
-			});
-			if (!response.body) throw new NetworkError("Response had no body to stream", {
-				method: prepared.method,
-				url: prepared.url,
-				cause: "missing body"
-			});
-			return response.body;
-		}
-	};
-	return transport;
-}
-function tagOf(profile) {
-	return profile === null ? null : profile.version.tag;
-}
-function buildUrl(baseUrl, path, query) {
-	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-	const target = new URL(baseUrl + normalizedPath);
-	if (query) for (const [key, value] of Object.entries(query)) {
-		if (value === void 0) continue;
-		if (Array.isArray(value)) for (const entry of value) target.searchParams.append(key, String(entry));
-		else target.searchParams.append(key, String(value));
-	}
-	return target.toString();
-}
-function acceptHeader(expected) {
-	if (expected === "json") return JSON_CONTENT_TYPE;
-	if (expected === "text") return "text/*";
-	return "*/*";
-}
-function assertContentType(response, prepared) {
-	if (prepared.expectContentType === "binary") return;
-	const contentType = response.headers.get("content-type");
-	if (contentType === null) throwContentTypeMismatch(response, prepared, prepared.expectContentType);
-	if (prepared.expectContentType === "json" && !contentType.includes("application/json")) throwContentTypeMismatch(response, prepared, "json");
-	if (prepared.expectContentType === "text" && !contentType.startsWith(TEXT_CONTENT_TYPE_PREFIX)) throwContentTypeMismatch(response, prepared, "text");
-}
-function throwContentTypeMismatch(response, prepared, expected) {
-	const actual = response.headers.get("content-type") ?? "no content-type";
-	throw new HttpError({
-		status: response.status,
-		statusText: response.statusText,
-		method: prepared.method,
-		url: prepared.url,
-		responseHeaders: response.headers,
-		rawBody: null,
-		overrideUserMessage: `Expected ${expected} response but got ${actual}`
-	});
-}
-async function readBodyForError(response) {
-	try {
-		return Buffer.from(await response.arrayBuffer()).subarray(0, ERROR_BODY_BYTE_CAP).toString("utf8");
-	} catch (error) {
-		return `[body read failed: ${errorMessage(error)}]`;
-	}
-}
-//#endregion
-export { createTransport as n, DEFAULT_TIMEOUT_MS as t };

package/dist/update-l3PyNQKG.mjs

@@ -1,41 +0,0 @@
-import { H as outputFlags, U as profileFlag, p as renderSummary, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
-import { t as parseId } from "./parse-id-DtM6q9HU.mjs";
-import { t as readBody } from "./body-CshgcV6U.mjs";
-import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
-import { a as TransformTestUpdateInput, t as TransformTest } from "./transform-test-BjjCQ2xm.mjs";
-import { t as transformTestView } from "./transform-test-gzDcbypy.mjs";
-//#region src/commands/transform-test/update.ts
-var update_default = defineMetabaseCommand({
-	meta: {
-		name: "update",
-		description: "Update a transform test from JSON"
-	},
-	details: "Only the fields the body carries are patched. `inputs` and `expectations` replace what is stored rather than merging into it. The body is closed at every level: a test read back with `get --full` has to shed `id`, `entity_id`, `creator_id`, `created_at` and `updated_at` before it can be sent.",
-	requires: ["transformTest.update"],
-	args: {
-		...outputFlags,
-		...profileFlag,
-		...connectionFlags,
-		...bodyInputFlags,
-		id: {
-			type: "positional",
-			description: "Transform test id",
-			required: true
-		}
-	},
-	inputSchema: TransformTestUpdateInput,
-	outputSchema: TransformTest,
-	examples: ["cat patch.json | mb transform-test update 1", "mb transform-test update 1 --file patch.json"],
-	async run({ args, ctx, getClient }) {
-		const id = parseId(args.id);
-		const body = await readBody({
-			flag: args.body,
-			file: args.file
-		}, TransformTestUpdateInput);
-		const updated = await (await getClient()).transformTest.update(id, body);
-		renderSummary(updated, transformTestView, `Updated transform test ${updated.id}.`, ctx);
-	}
-});
-//#endregion
-export { update_default as default };