@metabase/client 0.0.0-stage → 0.1.1

package/dist/transport-HP7cyo9N.js

@@ -0,0 +1,397 @@
+import { SessionProperties } from "./domain/session-properties.js";
+import { NetworkError, ResponseShapeError, TimeoutError, ValidationError, errorMessage, isNonInterruptFailure } from "./errors.js";
+import { JSON_CONTENT_TYPE, parseJson } from "./json.js";
+import { combineAborts, throwIfAborted, untilAborted } from "./signal.js";
+import { normalizeUrl } from "./url.js";
+import { a as HttpError, p as isRetryableStatus } from "./errors-DdMlaXqq.js";
+import { CapabilityError } from "./version/capability-error.js";
+import { createServerProfile } from "./version/profile.js";
+import { PROBE_PATH, probeBudget, serverInfoFromProperties } from "./version/probe.js";
+import { featureFailures } from "./version/requirement-check.js";
+import { assertCredentialHeaderSafe, credentialAuthHeader, credentialSecrets } from "./auth/credential.js";
+import { n as isConnectionClosed, t as buildNetworkError } from "./network-error-5g4U1iul.js";
+import { backoffDelay, runWithRetries } from "./http/retry.js";
+//#region 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 src/http/transport.ts
+const DEFAULT_METHOD = "GET";
+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 inForce = options.server ?? null;
+	let newest = null;
+	let probesStarted = 0;
+	let applied = null;
+	const inFlight = /* @__PURE__ */ new Set();
+	const getServerTag = options.getServerTag ?? (async () => tagOf(inForce));
+	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 === 401) {
+				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)
+		};
+	}
+	async function readJson(path, opts = {}) {
+		const chosenFor = inForce;
+		const { response, prepared } = await executeWithAuthRefresh(path, {
+			...opts,
+			expectContentType: "json"
+		});
+		return {
+			text: await response.text(),
+			context: {
+				method: prepared.method,
+				url: prepared.url,
+				status: response.status,
+				...namingOf(chosenFor)
+			}
+		};
+	}
+	function namingOf(profile) {
+		if (profile === null) return {
+			getServerTag,
+			serverSkew: null
+		};
+		return {
+			getServerTag: async () => profile.version.tag,
+			serverSkew: profile.skew
+		};
+	}
+	async function runProbe(order, budget) {
+		const read = await readJson(PROBE_PATH, probeBudget(budget));
+		const properties = await parseJsonResponse(read.text, SessionProperties, read.context);
+		const info = serverInfoFromProperties(properties);
+		const profile = createServerProfile(info);
+		if (applied === null || applied.order < order) {
+			options.onServerProbed?.(info, profile);
+			applied = {
+				order,
+				profile
+			};
+			inForce = profile;
+		}
+		return {
+			properties,
+			profile,
+			read
+		};
+	}
+	function startProbe(budget) {
+		probesStarted += 1;
+		const probed = runProbe(probesStarted, budget);
+		newest = probed;
+		inFlight.add(probed);
+		probed.then(() => {
+			inFlight.delete(probed);
+		}, () => {
+			inFlight.delete(probed);
+			if (newest === probed) newest = null;
+		});
+		return probed;
+	}
+	function appliedProfile() {
+		return applied === null ? null : applied.profile;
+	}
+	function verifying() {
+		const settled = appliedProfile();
+		if (newest === null && settled !== null) return Promise.resolve(settled);
+		return (newest ?? startProbe({})).then((probed) => probed.profile, fallBackTo(appliedProfile));
+	}
+	function profileInForce() {
+		const current = inForce;
+		if (current === null) return verifying();
+		if (newest === null) return Promise.resolve(current);
+		return newest.then((probed) => probed.profile, fallBackTo(() => inForce));
+	}
+	async function server(wait = {}) {
+		throwIfAborted(wait.signal);
+		return untilAborted(profileInForce(), wait.signal);
+	}
+	async function verifiedServer(wait = {}) {
+		throwIfAborted(wait.signal);
+		return untilAborted(verifying(), wait.signal);
+	}
+	async function probe(reader, read = {}) {
+		const { signal, ...budget } = read;
+		throwIfAborted(signal);
+		const probed = await untilAborted(startProbe(budget), signal);
+		const context = {
+			...probed.read.context,
+			...namingOf(probed.profile)
+		};
+		return parseJsonResponse(probed.read.text, reader, context);
+	}
+	async function probesSettled() {
+		while (inFlight.size > 0) await Promise.allSettled(inFlight);
+	}
+	async function requireFeatures(features, wait = {}) {
+		if (features.length === 0) return;
+		const profile = await preflightServer(wait);
+		if (profile === null) return;
+		for (const failure of featureFailures(features, profile)) refuseBeforeSending(new CapabilityError(failure));
+	}
+	async function preflightServer(wait = {}) {
+		try {
+			return await verifiedServer(wait);
+		} catch (error) {
+			if (!isNonInterruptFailure(error)) throw error;
+			skipOrThrow({
+				kind: "unverified",
+				failure: error
+			});
+			return null;
+		}
+	}
+	function refuseBeforeSending(refusal) {
+		skipOrThrow({
+			kind: "refused",
+			refusal
+		});
+	}
+	function skipOrThrow(skipped) {
+		const hook = options.onPreflightSkipped;
+		if (hook === void 0) throw skippedError(skipped);
+		hook(skipped);
+	}
+	return {
+		server,
+		verifiedServer,
+		probe,
+		requireFeatures,
+		preflightServer,
+		refuseBeforeSending,
+		probesSettled,
+		async requestRaw(path, opts) {
+			return (await executeWithAuthRefresh(path, opts ?? {})).response;
+		},
+		async requestParsed(schema, path, opts) {
+			const read = await readJson(path, opts);
+			return parseJsonResponse(read.text, schema, read.context);
+		},
+		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;
+		}
+	};
+}
+function skippedError(skipped) {
+	return skipped.kind === "refused" ? skipped.refusal : skipped.failure;
+}
+function fallBackTo(fallback) {
+	return (error) => {
+		const profile = fallback();
+		if (profile !== null && isNonInterruptFailure(error)) return profile;
+		throw error;
+	};
+}
+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 { DEFAULT_TIMEOUT_MS as n, createTransport as r, DEFAULT_METHOD as t };

package/dist/upload-B5YjVkSW.d.ts

@@ -0,0 +1,12 @@
+import { f as RequestOptions, h as Transport } from "./transport-BsXqRujn.js";
+import { t as UploadResult } from "./upload-UPfZFdbH.js";
+import { t as CsvFile } from "./csv-upload--K35QedP.js";
+//#region src/resources/upload.d.ts
+interface UploadCsvParams {
+  collection_id: string;
+}
+declare function uploadResource(transport: Transport): {
+  createFromCsv: (file: CsvFile, params: UploadCsvParams, options?: RequestOptions) => Promise<UploadResult>;
+};
+//#endregion
+export { uploadResource as n, UploadCsvParams as t };

package/dist/upload-UPfZFdbH.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+//#region src/domain/upload.d.ts
+declare const UploadResult: z.ZodObject<{
+  model_id: z.ZodNumber;
+  table_id: z.ZodNumber;
+}, z.core.$strip>;
+type UploadResult = z.infer<typeof UploadResult>;
+declare const UploadUpdateAction: z.ZodEnum<{
+  replace: "replace";
+  append: "append";
+}>;
+type UploadUpdateAction = z.infer<typeof UploadUpdateAction>;
+declare const UploadUpdateResult: z.ZodObject<{
+  table_id: z.ZodNumber;
+  action: z.ZodEnum<{
+    replace: "replace";
+    append: "append";
+  }>;
+}, z.core.$strip>;
+type UploadUpdateResult = z.infer<typeof UploadUpdateResult>;
+//#endregion
+export { UploadUpdateAction as n, UploadUpdateResult as r, UploadResult as t };

package/dist/url-CI0pxHOc.d.ts

@@ -0,0 +1,7 @@
+//#region src/url.d.ts
+declare function normalizeUrl(input: string): string;
+declare function displayUrl(input: string): string;
+declare function isLoopbackHost(hostname: string): boolean;
+declare function assertEndpointOrigin(endpoint: string, baseUrl: string, label: string): void;
+//#endregion
+export { normalizeUrl as i, displayUrl as n, isLoopbackHost as r, assertEndpointOrigin as t };

package/dist/url.d.ts

@@ -0,0 +1,2 @@
+import { i as normalizeUrl, n as displayUrl, r as isLoopbackHost, t as assertEndpointOrigin } from "./url-CI0pxHOc.js";
+export { assertEndpointOrigin, displayUrl, isLoopbackHost, normalizeUrl };

package/dist/url.js

@@ -0,0 +1,34 @@
+import { ConfigError } from "./errors.js";
+//#region src/url.ts
+function normalizeUrl(input) {
+	const trimmed = input.trim().replace(/\/+$/, "");
+	if (!/^https?:\/\//i.test(trimmed)) throw new ConfigError("URL must start with http:// or https://");
+	return trimmed;
+}
+function displayUrl(input) {
+	const parsed = new URL(input);
+	const path = parsed.pathname.replace(/\/+$/, "");
+	return `${parsed.origin}${path}`;
+}
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"[::1]"
+]);
+function isLoopbackHost(hostname) {
+	return LOOPBACK_HOSTS.has(hostname.toLowerCase());
+}
+function assertEndpointOrigin(endpoint, baseUrl, label) {
+	let parsed;
+	try {
+		parsed = new URL(endpoint);
+	} catch {
+		throw new ConfigError(`OAuth ${label} is not a valid URL: ${endpoint}`);
+	}
+	const base = new URL(baseUrl);
+	if (parsed.protocol !== "https:" && !isLoopbackHost(parsed.hostname)) throw new ConfigError(`OAuth ${label} must use https: ${endpoint}`);
+	if (parsed.origin !== base.origin) throw new ConfigError(`OAuth ${label} origin (${parsed.origin}) does not match the Metabase URL (${base.origin})`);
+}
+//#endregion
+export { assertEndpointOrigin, displayUrl, isLoopbackHost, normalizeUrl };

package/dist/user-Sqqv7rqh.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+//#region src/domain/user.d.ts
+declare const CurrentUser: z.ZodObject<{
+  id: z.ZodNumber;
+  email: z.ZodString;
+  common_name: z.ZodString;
+  is_superuser: z.ZodBoolean;
+}, z.core.$loose>;
+type CurrentUser = z.infer<typeof CurrentUser>;
+declare const CurrentUserCompact: z.ZodObject<{
+  id: z.ZodNumber;
+  email: z.ZodString;
+  common_name: z.ZodString;
+  is_superuser: z.ZodBoolean;
+}, z.core.$strip>;
+type CurrentUserCompact = z.infer<typeof CurrentUserCompact>;
+//#endregion
+export { CurrentUserCompact as n, CurrentUser as t };

package/dist/version/capability-error.d.ts

@@ -0,0 +1,2 @@
+import { C as versionTooOldMessage, S as missingTokenFeatureMessage, b as RequirementFailure, x as RequirementReason, y as CapabilityError } from "../transport-BsXqRujn.js";
+export { CapabilityError, RequirementFailure, RequirementReason, missingTokenFeatureMessage, versionTooOldMessage };

package/dist/version/capability-error.js

@@ -0,0 +1,42 @@
+import { MetabaseError } from "../errors.js";
+import "../errors-DdMlaXqq.js";
+import { FEATURE_NAMES } from "./features.js";
+import { z } from "zod";
+//#region src/version/capability-error.ts
+const RequirementReason = z.enum([
+	"version-too-old",
+	"missing-token-feature",
+	"superseded-by-feature"
+]);
+const RequirementFailure = z.object({
+	reason: RequirementReason,
+	detail: z.string(),
+	feature: z.enum(FEATURE_NAMES),
+	since: z.number().int(),
+	tokenFeature: z.string().nullable(),
+	serverVersion: z.string()
+});
+function versionTooOldMessage(since, serverVersion) {
+	return `This operation requires Metabase v${since}+ (this server is ${serverVersion}). Upgrade Metabase to use it.`;
+}
+function missingTokenFeatureMessage(tokenFeature) {
+	return `This operation requires the '${tokenFeature}' premium feature (not enabled on this server).`;
+}
+var CapabilityError = class extends MetabaseError {
+	category = "capability";
+	isRetryable = false;
+	developerDetail;
+	constructor(failure, refusal = null) {
+		super(capabilityMessage(failure, refusal), refusal === null ? void 0 : { cause: refusal });
+		this.name = "CapabilityError";
+		this.developerDetail = failure;
+	}
+};
+function capabilityMessage(failure, refusal) {
+	if (refusal === null || refusal.status !== 400) return failure.detail;
+	const said = refusal.serverMessage;
+	if (said === null) return failure.detail;
+	return `${failure.detail}\nMetabase answered ${refusal.status}: ${said}`;
+}
+//#endregion
+export { CapabilityError, RequirementFailure, RequirementReason, missingTokenFeatureMessage, versionTooOldMessage };

package/dist/version/features.d.ts

@@ -0,0 +1,2 @@
+import { a as FeatureRule, c as TokenGap, d as featureAvailability, f as isFeatureName, i as FeatureName, l as VersionGap, n as FEATURE_RULES, o as Features, p as ruleGap, r as FeatureGap, s as RuleMajor, t as FEATURE_NAMES, u as evaluateFeatures } from "../features-SMSfJhB6.js";
+export { FEATURE_NAMES, FEATURE_RULES, FeatureGap, FeatureName, FeatureRule, Features, RuleMajor, TokenGap, VersionGap, evaluateFeatures, featureAvailability, isFeatureName, ruleGap };