@metabase/client 0.0.0-stage → 0.1.1

package/dist/erd-CbV7xvAc.d.ts

@@ -0,0 +1,51 @@
+import { f as RequestOptions, h as Transport } from "./transport-BsXqRujn.js";
+//#region src/resources/erd.d.ts
+interface ErdParams {
+  "database-id": number;
+  "table-ids"?: readonly number[] | undefined;
+  schema?: string | undefined;
+}
+declare function erdResource(transport: Transport): {
+  get: (params: ErdParams, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    nodes: {
+      [x: string]: unknown;
+      table_id: number;
+      name: string;
+      display_name: string;
+      description: string | null;
+      owner: {
+        [x: string]: unknown;
+        email: string;
+        id?: number | undefined;
+        first_name?: string | null | undefined;
+        last_name?: string | null | undefined;
+      } | null;
+      schema: string | null;
+      visibility_type: "hidden" | "technical" | "cruft" | null;
+      db_id: number;
+      fields: {
+        [x: string]: unknown;
+        id: number;
+        name: string;
+        display_name: string;
+        database_type: string;
+        base_type: "type/*" | "type/field-values-unsupported" | "type/fingerprint-unsupported" | "type/Large" | "type/Number" | "type/Integer" | "type/BigInteger" | "type/Float" | "type/Double" | "type/Decimal" | "type/Text" | "type/UUID" | "type/OracleCLOB" | "type/Temporal" | "type/HasDate" | "type/HasTime" | "type/Date" | "type/Time" | "type/TimeWithTZ" | "type/TimeWithLocalTZ" | "type/TimeWithZoneOffset" | "type/DateTime" | "type/DateTimeWithTZ" | "type/DateTimeWithLocalTZ" | "type/DateTimeWithZoneOffset" | "type/DateTimeWithZoneID" | "type/Instant" | "type/Interval" | "type/Boolean" | "type/DruidHyperUnique" | "type/SnowflakeVariant" | "type/TextLike" | "type/MongoBSONID" | "type/MongoBinData" | "type/MySQLEnum" | "type/PostgresEnum" | "type/PostgresBitString" | "type/IPAddress" | "type/Collection" | "type/Dictionary" | "type/Array" | "type/Structured" | "type/JSON" | "type/DruidJSON" | "type/XML" | "type/AvatarURL" | "type/Birthdate" | "type/CancelationDate" | "type/CancelationTime" | "type/CancelationTimestamp" | "type/City" | "type/Comment" | "type/Coordinate" | "type/Cost" | "type/Country" | "type/CreationDate" | "type/CreationTime" | "type/CreationTimestamp" | "type/Currency" | "type/DeletionDate" | "type/DeletionTime" | "type/DeletionTimestamp" | "type/Description" | "type/Discount" | "type/Duration" | "type/Email" | "type/GrossMargin" | "type/ImageURL" | "type/Income" | "type/JoinDate" | "type/JoinTime" | "type/JoinTimestamp" | "type/Latitude" | "type/Longitude" | "type/Name" | "type/Percentage" | "type/Price" | "type/Quantity" | "type/Score" | "type/SerializedJSON" | "type/Share" | "type/State" | "type/Title" | "type/URL" | "type/UpdatedDate" | "type/UpdatedTime" | "type/UpdatedTimestamp" | "type/ZipCode" | null;
+        effective_type: "type/*" | "type/field-values-unsupported" | "type/fingerprint-unsupported" | "type/Large" | "type/Number" | "type/Integer" | "type/BigInteger" | "type/Float" | "type/Double" | "type/Decimal" | "type/Text" | "type/UUID" | "type/OracleCLOB" | "type/Temporal" | "type/HasDate" | "type/HasTime" | "type/Date" | "type/Time" | "type/TimeWithTZ" | "type/TimeWithLocalTZ" | "type/TimeWithZoneOffset" | "type/DateTime" | "type/DateTimeWithTZ" | "type/DateTimeWithLocalTZ" | "type/DateTimeWithZoneOffset" | "type/DateTimeWithZoneID" | "type/Instant" | "type/Interval" | "type/Boolean" | "type/DruidHyperUnique" | "type/SnowflakeVariant" | "type/TextLike" | "type/MongoBSONID" | "type/MongoBinData" | "type/MySQLEnum" | "type/PostgresEnum" | "type/PostgresBitString" | "type/IPAddress" | "type/Collection" | "type/Dictionary" | "type/Array" | "type/Structured" | "type/JSON" | "type/DruidJSON" | "type/XML" | "type/AvatarURL" | "type/Birthdate" | "type/CancelationDate" | "type/CancelationTime" | "type/CancelationTimestamp" | "type/City" | "type/Comment" | "type/Coordinate" | "type/Cost" | "type/Country" | "type/CreationDate" | "type/CreationTime" | "type/CreationTimestamp" | "type/Currency" | "type/DeletionDate" | "type/DeletionTime" | "type/DeletionTimestamp" | "type/Description" | "type/Discount" | "type/Duration" | "type/Email" | "type/GrossMargin" | "type/ImageURL" | "type/Income" | "type/JoinDate" | "type/JoinTime" | "type/JoinTimestamp" | "type/Latitude" | "type/Longitude" | "type/Name" | "type/Percentage" | "type/Price" | "type/Quantity" | "type/Score" | "type/SerializedJSON" | "type/Share" | "type/State" | "type/Title" | "type/URL" | "type/UpdatedDate" | "type/UpdatedTime" | "type/UpdatedTimestamp" | "type/ZipCode" | null;
+        semantic_type: "type/IPAddress" | "type/Structured" | "type/JSON" | "type/DruidJSON" | "type/XML" | "type/AvatarURL" | "type/Birthdate" | "type/CancelationDate" | "type/CancelationTime" | "type/CancelationTimestamp" | "type/City" | "type/Comment" | "type/Coordinate" | "type/Cost" | "type/Country" | "type/CreationDate" | "type/CreationTime" | "type/CreationTimestamp" | "type/Currency" | "type/DeletionDate" | "type/DeletionTime" | "type/DeletionTimestamp" | "type/Description" | "type/Discount" | "type/Duration" | "type/Email" | "type/GrossMargin" | "type/ImageURL" | "type/Income" | "type/JoinDate" | "type/JoinTime" | "type/JoinTimestamp" | "type/Latitude" | "type/Longitude" | "type/Name" | "type/Percentage" | "type/Price" | "type/Quantity" | "type/Score" | "type/SerializedJSON" | "type/Share" | "type/State" | "type/Title" | "type/URL" | "type/UpdatedDate" | "type/UpdatedTime" | "type/UpdatedTimestamp" | "type/ZipCode" | "Semantic/*" | "Relation/*" | "type/Location" | "type/Address" | "type/Category" | "type/Enum" | "type/Product" | "type/Company" | "type/Subscription" | "type/Source" | "type/CreationTemporal" | "type/JoinTemporal" | "type/CancelationTemporal" | "type/DeletionTemporal" | "type/UpdatedTemporal" | "type/User" | "type/Author" | "type/Owner" | "type/FK" | "type/PK" | null;
+        fk_target_field_id: number | null;
+        fk_target_table_id: number | null;
+      }[];
+    }[];
+    edges: {
+      [x: string]: unknown;
+      source_table_id: number;
+      source_field_id: number;
+      target_table_id: number;
+      target_field_id: number;
+      relationship: "one-to-one" | "many-to-one";
+    }[];
+  }>;
+};
+//#endregion
+export { erdResource as n, ErdParams as t };

package/dist/errors-DdMlaXqq.js

@@ -0,0 +1,330 @@
+import { ChainedRequestError, MetabaseError } from "./errors.js";
+import { parseJsonResult } from "./json.js";
+import { isPlainObject } from "./predicates.js";
+import { z } from "zod";
+//#region src/http/sanitize.ts
+const SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
+	"authorization",
+	"x-api-key",
+	"x-metabase-session",
+	"cookie",
+	"set-cookie",
+	"proxy-authorization"
+]);
+const REDACTED = "[REDACTED]";
+function redactHeaders(headers) {
+	const result = {};
+	const entries = headers instanceof Headers ? headers.entries() : Object.entries(headers);
+	for (const [key, value] of entries) result[key] = SECRET_HEADER_NAMES.has(key.toLowerCase()) ? REDACTED : value;
+	return result;
+}
+function redactBody(body, ctx) {
+	let result = body;
+	for (const secret of ctx.knownSecrets) {
+		if (secret.length === 0) continue;
+		result = result.replaceAll(secret, REDACTED);
+	}
+	return result;
+}
+//#endregion
+//#region src/http/errors.ts
+const BAD_REQUEST_STATUS = 400;
+const UNAUTHORIZED_STATUS = 401;
+const PAYMENT_REQUIRED_STATUS = 402;
+const FORBIDDEN_STATUS = 403;
+const NOT_FOUND_STATUS = 404;
+const CONFLICT_STATUS = 409;
+const TOO_MANY_REQUESTS_STATUS = 429;
+const INTERNAL_SERVER_ERROR_STATUS = 500;
+const SERVER_ERROR_STATUSES_START = 500;
+const SERVER_ERROR_STATUSES_END = 600;
+const TEXT_CONTENT_TYPE = "text/plain";
+const ROUTE_MISSING_LITERAL = "API endpoint does not exist.";
+const RESOURCE_MISSING_LITERAL = "Not found.";
+const STATUS_CLASSIFICATIONS = {
+	401: { retryable: false },
+	403: {
+		retryable: false,
+		message: "The request was refused (403): the signed-in user is not allowed to do this."
+	},
+	404: { retryable: false },
+	409: {
+		retryable: false,
+		message: "The request was refused (409): it conflicts with what already exists."
+	},
+	408: {
+		retryable: true,
+		message: "Metabase timed out responding."
+	},
+	425: { retryable: true },
+	429: {
+		retryable: true,
+		message: "Metabase rate-limited the request."
+	},
+	500: { retryable: true },
+	502: { retryable: true },
+	503: { retryable: true },
+	504: {
+		retryable: true,
+		message: "Metabase timed out responding."
+	}
+};
+const ErrorEnvelope = z.object({
+	message: z.string().optional(),
+	error: z.string().optional(),
+	"error-message": z.string().optional(),
+	via: z.array(z.object({ message: z.string().optional() }).loose()).optional(),
+	"specific-errors": z.unknown().optional(),
+	errors: z.unknown().optional(),
+	"error-code": z.string().optional(),
+	"non-remote-synced-models": z.unknown().optional(),
+	"remote-synced-models": z.unknown().optional()
+}).loose();
+const NonRemoteSyncedDependencies = z.array(z.number().int()).min(1);
+const RemoteSyncedDependent = z.record(z.string(), z.number().int());
+const RemoteSyncedDependents = z.array(RemoteSyncedDependent).min(1);
+const MAX_LISTED_REMOTE_SYNC_ENTRIES = 20;
+const REMOTE_SYNC_ENTRY_SEPARATOR = ", ";
+const NON_REMOTE_SYNCED_REMEDY = "Move that content into a synced collection first, or move the collection that holds it.";
+const REMOTE_SYNCED_REMEDY = "Update that content so it no longer uses this first, or move it out of sync along with this.";
+const FieldErrorNodeSchema = z.lazy(() => z.union([
+	z.string(),
+	z.array(z.string()),
+	z.record(z.string(), FieldErrorNodeSchema)
+]));
+const FieldErrorTree = z.record(z.string(), FieldErrorNodeSchema);
+const FIELD_MESSAGE_SEPARATOR = "; ";
+const FIELD_PATH_SEPARATOR = ".";
+const MAX_EXTRACTED_MESSAGE_LEN = 500;
+const ELLIPSIS = "…";
+const GOT_VALUE_PATTERN = /got: ((?:[^"\\]|\\.)*)/g;
+const MAX_GOT_VALUE_LEN = 60;
+var HttpError = class extends MetabaseError {
+	category = "http";
+	status;
+	kind;
+	serverMessage;
+	developerDetail;
+	constructor(input) {
+		const sanitizedBody = sanitizeBody(input.rawBody, input.redactionContext);
+		const redactedHeaders = redactHeaders(input.responseHeaders);
+		const kind = classifyKind(input.status, sanitizedBody, redactedHeaders);
+		const said = {
+			envelope: parseEnvelopeMessage(sanitizedBody),
+			text: plainTextMessage(sanitizedBody, redactedHeaders)
+		};
+		super(input.overrideUserMessage ?? buildUserMessage(kind, input, said));
+		const fields = extractEnvelopeViews(sanitizedBody);
+		this.name = "HttpError";
+		this.status = input.status;
+		this.kind = kind;
+		this.serverMessage = said.envelope ?? said.text;
+		this.developerDetail = {
+			status: input.status,
+			statusText: input.statusText,
+			method: input.method,
+			url: input.url,
+			responseHeaders: redactedHeaders,
+			body: sanitizedBody,
+			fieldErrors: fields.fieldErrors,
+			specificFieldErrors: fields.specificFieldErrors,
+			errorCode: fields.errorCode,
+			nonRemoteSyncedDependencies: fields.nonRemoteSyncedDependencies,
+			remoteSyncedDependents: fields.remoteSyncedDependents
+		};
+	}
+	get isRetryable() {
+		return isRetryableStatus(this.status);
+	}
+	get fieldErrors() {
+		return this.developerDetail.fieldErrors;
+	}
+	get specificFieldErrors() {
+		return this.developerDetail.specificFieldErrors;
+	}
+	get errorCode() {
+		return this.developerDetail.errorCode;
+	}
+	get nonRemoteSyncedDependencies() {
+		return this.developerDetail.nonRemoteSyncedDependencies;
+	}
+	get remoteSyncedDependents() {
+		return this.developerDetail.remoteSyncedDependents;
+	}
+};
+function isHttpNotFound(error) {
+	return error instanceof HttpError && error.status === 404;
+}
+function chainRequestFailure(cause, message) {
+	if (cause instanceof HttpError) return new HttpError({
+		status: cause.status,
+		statusText: cause.developerDetail.statusText,
+		method: cause.developerDetail.method,
+		url: cause.developerDetail.url,
+		responseHeaders: cause.developerDetail.responseHeaders,
+		rawBody: cause.developerDetail.body,
+		overrideUserMessage: message
+	});
+	return new ChainedRequestError(message, cause);
+}
+function isRetryableStatus(status) {
+	return STATUS_CLASSIFICATIONS[status]?.retryable === true;
+}
+function sanitizeBody(rawBody, ctx) {
+	if (rawBody === null) return null;
+	if (ctx === void 0) return rawBody;
+	return redactBody(rawBody, ctx);
+}
+function classifyKind(status, sanitizedBody, redactedHeaders) {
+	if (status === 401) return "auth";
+	if (status === 403) return "forbidden";
+	if (status === 409) return "conflict";
+	if (status === 404) return isRouteMissingResponse(sanitizedBody, redactedHeaders) ? "route-missing" : "resource-missing";
+	if (status === 429) return "rate-limit";
+	if (status >= SERVER_ERROR_STATUSES_START && status < SERVER_ERROR_STATUSES_END) return "server-error";
+	return "generic";
+}
+function isRouteMissingResponse(sanitizedBody, redactedHeaders) {
+	if (sanitizedBody?.includes(ROUTE_MISSING_LITERAL)) return true;
+	if (sanitizedBody?.includes(RESOURCE_MISSING_LITERAL)) return false;
+	if (redactedHeaders["content-type"]?.includes("application/json")) return false;
+	if (sanitizedBody === null || sanitizedBody.trim() === "") return true;
+	return parseEnvelope(sanitizedBody) === null;
+}
+function buildUserMessage(kind, input, said) {
+	if (kind === "route-missing") return buildRouteMissingMessage(input);
+	if (kind === "resource-missing") return `Not found: ${input.method} ${pathFromUrl(input.url)}.`;
+	if (said.envelope !== null) return said.envelope;
+	if (kind === "auth") return `Invalid or unauthorized API key (host: ${hostFromUrl(input.url)}).`;
+	if (said.text !== null) return said.text;
+	return defaultMessageForStatus(input.status);
+}
+function plainTextMessage(sanitizedBody, redactedHeaders) {
+	if (sanitizedBody === null || !redactedHeaders["content-type"]?.includes(TEXT_CONTENT_TYPE)) return null;
+	const trimmed = sanitizedBody.trim();
+	return trimmed === "" ? null : condenseMessage(trimmed);
+}
+function buildRouteMissingMessage(input) {
+	const path = pathFromUrl(input.url);
+	if (!input.serverTag) return `This endpoint is not available on the connected Metabase: ${input.method} ${path}.`;
+	return `This endpoint is not available on Metabase ${input.serverTag}: ${input.method} ${path}. It may require a newer Metabase major version.`;
+}
+function pathFromUrl(url) {
+	const parsed = new URL(url);
+	return parsed.pathname + parsed.search;
+}
+function hostFromUrl(url) {
+	return new URL(url).host;
+}
+function parseEnvelope(sanitizedBody) {
+	if (!sanitizedBody) return null;
+	const result = parseJsonResult(sanitizedBody, ErrorEnvelope);
+	return result.ok ? result.value : null;
+}
+const NO_ENVELOPE_VIEWS = {
+	fieldErrors: null,
+	specificFieldErrors: null,
+	errorCode: null,
+	nonRemoteSyncedDependencies: null,
+	remoteSyncedDependents: null
+};
+function extractEnvelopeViews(sanitizedBody) {
+	const envelope = parseEnvelope(sanitizedBody);
+	if (envelope === null) return NO_ENVELOPE_VIEWS;
+	return {
+		fieldErrors: parseFieldErrors(envelope.errors),
+		specificFieldErrors: parseFieldErrors(envelope["specific-errors"]),
+		errorCode: envelope["error-code"] ?? null,
+		nonRemoteSyncedDependencies: parseOrNull(NonRemoteSyncedDependencies, envelope["non-remote-synced-models"]),
+		remoteSyncedDependents: parseOrNull(RemoteSyncedDependents, envelope["remote-synced-models"])
+	};
+}
+function parseOrNull(schema, value) {
+	const parsed = schema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+function parseFieldErrors(value) {
+	const parsed = FieldErrorTree.safeParse(value);
+	if (!parsed.success) return null;
+	const entries = collectLeafEntries(parsed.data, []);
+	if (entries.length === 0) return null;
+	return Object.fromEntries(entries.map((entry) => [entry.path, entry.message]));
+}
+function parseEnvelopeMessage(sanitizedBody) {
+	const envelope = parseEnvelope(sanitizedBody);
+	if (envelope === null) return null;
+	const topLevel = envelope.message ?? envelope.error ?? envelope["error-message"];
+	if (topLevel) return appendRemoteSyncConflict(condenseMessage(topLevel), envelope);
+	const viaMessage = envelope.via?.find((entry) => entry.message)?.message;
+	if (viaMessage) return condenseMessage(viaMessage);
+	const specific = formatErrorTree(envelope["specific-errors"]);
+	if (specific) return condenseMessage(specific);
+	const generic = formatErrorTree(envelope.errors);
+	if (generic) return condenseMessage(generic);
+	return null;
+}
+function appendRemoteSyncConflict(message, envelope) {
+	const dependencies = parseOrNull(NonRemoteSyncedDependencies, envelope["non-remote-synced-models"]);
+	if (dependencies !== null) {
+		const ids = listRemoteSyncEntries(dependencies.map(String));
+		return `${withoutTrailingPeriod(message)}: ids ${ids}. ${NON_REMOTE_SYNCED_REMEDY}`;
+	}
+	const dependents = parseOrNull(RemoteSyncedDependents, envelope["remote-synced-models"]);
+	if (dependents !== null) {
+		const named = listRemoteSyncEntries([...new Set(dependents.map(formatRemoteSyncedDependent))]);
+		return `${withoutTrailingPeriod(message)}: ${named}. ${REMOTE_SYNCED_REMEDY}`;
+	}
+	return message;
+}
+function formatRemoteSyncedDependent(dependent) {
+	return Object.entries(dependent).map(([model, id]) => `${model} ${id}`).join(" / ");
+}
+function listRemoteSyncEntries(entries) {
+	const listed = entries.slice(0, MAX_LISTED_REMOTE_SYNC_ENTRIES).join(REMOTE_SYNC_ENTRY_SEPARATOR);
+	const unlisted = entries.length - MAX_LISTED_REMOTE_SYNC_ENTRIES;
+	return unlisted > 0 ? `${listed}${REMOTE_SYNC_ENTRY_SEPARATOR}and ${unlisted} more` : listed;
+}
+function withoutTrailingPeriod(message) {
+	return message.endsWith(".") ? message.slice(0, -1) : message;
+}
+function formatErrorTree(value) {
+	const entries = collectLeafEntries(value, []);
+	if (entries.length === 0) return null;
+	return entries.map(formatLeafEntry).join(FIELD_MESSAGE_SEPARATOR);
+}
+function formatLeafEntry(entry) {
+	return entry.path === "" ? entry.message : `${entry.path}: ${entry.message}`;
+}
+function collectLeafEntries(value, path) {
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		return trimmed === "" ? [] : [{
+			path: path.join("."),
+			message: trimmed
+		}];
+	}
+	if (Array.isArray(value)) {
+		const messages = value.filter((entry) => typeof entry === "string" && entry.trim() !== "");
+		if (messages.length === 0) return [];
+		return [{
+			path: path.join("."),
+			message: messages.join(FIELD_MESSAGE_SEPARATOR)
+		}];
+	}
+	if (isPlainObject(value)) return Object.entries(value).flatMap(([key, child]) => collectLeafEntries(child, [...path, key]));
+	return [];
+}
+function condenseMessage(message) {
+	const trimmed = message.replace(GOT_VALUE_PATTERN, trimGotValue);
+	if (trimmed.length <= MAX_EXTRACTED_MESSAGE_LEN) return trimmed;
+	return trimmed.slice(0, MAX_EXTRACTED_MESSAGE_LEN - 1) + ELLIPSIS;
+}
+function trimGotValue(match, value) {
+	if (value.length <= MAX_GOT_VALUE_LEN) return match;
+	return `got: ${value.slice(0, MAX_GOT_VALUE_LEN)}${ELLIPSIS}`;
+}
+function defaultMessageForStatus(status) {
+	return STATUS_CLASSIFICATIONS[status]?.message ?? `Metabase returned ${status}.`;
+}
+//#endregion
+export { HttpError as a, PAYMENT_REQUIRED_STATUS as c, chainRequestFailure as d, isHttpNotFound as f, FORBIDDEN_STATUS as i, TOO_MANY_REQUESTS_STATUS as l, CONFLICT_STATUS as n, INTERNAL_SERVER_ERROR_STATUS as o, isRetryableStatus as p, FIELD_PATH_SEPARATOR as r, NOT_FOUND_STATUS as s, BAD_REQUEST_STATUS as t, UNAUTHORIZED_STATUS as u };

package/dist/errors.d.ts

@@ -0,0 +1,2 @@
+import { $ as PartialWriteAnswer, G as DecodedResponseShapeDetail, H as AbortError, J as HttpTimeoutDetail, K as ErrorCategory, Q as NetworkErrorDetail, U as ChainedRequestError, W as ConfigError, X as MetabaseError, Y as InternalError, Z as NetworkError, _t as isNonInterruptFailure, at as ResponseShapeError, ct as TimeoutErrorDetail, dt as ValidationError, et as PartialWriteDetail, ft as ValidationErrorDetail, gt as isFileNotFoundError, ht as formatZodIssue, it as PollingTimeoutDetail, lt as UnknownError, mt as errorMessage, nt as PartialWriteReported, ot as ResponseShapeErrorDetail, pt as ZodResponseShapeDetail, q as FailedResultError, rt as PartialWriteUnreported, st as TimeoutError, tt as PartialWriteError, ut as UnknownErrorDetail, vt as toMetabaseError } from "./transport-BsXqRujn.js";
+export { AbortError, ChainedRequestError, ConfigError, DecodedResponseShapeDetail, ErrorCategory, FailedResultError, HttpTimeoutDetail, InternalError, MetabaseError, NetworkError, NetworkErrorDetail, PartialWriteAnswer, PartialWriteDetail, PartialWriteError, PartialWriteReported, PartialWriteUnreported, PollingTimeoutDetail, ResponseShapeError, ResponseShapeErrorDetail, TimeoutError, TimeoutErrorDetail, UnknownError, UnknownErrorDetail, ValidationError, ValidationErrorDetail, ZodResponseShapeDetail, errorMessage, formatZodIssue, isFileNotFoundError, isNonInterruptFailure, toMetabaseError };

package/dist/errors.js

@@ -0,0 +1,189 @@
+import { escapeJsonPointerSegment } from "./json-pointer.js";
+import { KNOWN_RANGE } from "./version/known-range.js";
+import { ZodError, core } from "zod";
+//#region src/errors.ts
+var MetabaseError = class extends Error {
+	get userMessage() {
+		return this.message;
+	}
+};
+var NetworkError = class extends MetabaseError {
+	category = "network";
+	isRetryable = true;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "NetworkError";
+		this.developerDetail = developerDetail;
+	}
+};
+var TimeoutError = class extends MetabaseError {
+	category = "timeout";
+	isRetryable = true;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "TimeoutError";
+		this.developerDetail = developerDetail;
+	}
+};
+var ValidationError = class extends MetabaseError {
+	category = "validation";
+	isRetryable = false;
+	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${formatIssueLines(issues, VALIDATION_ISSUE_FORMAT)}`;
+	}
+};
+const VALIDATION_MAX_ISSUES = 10;
+const RESPONSE_SHAPE_MAX_ISSUES = 5;
+const VALIDATION_ISSUE_FORMAT = {
+	max: VALIDATION_MAX_ISSUES,
+	formatIssue: (issue) => `${formatZodIssuePointer(issue.path)}: ${issue.message}`
+};
+const RESPONSE_SHAPE_ISSUE_FORMAT = {
+	max: RESPONSE_SHAPE_MAX_ISSUES,
+	formatIssue: formatZodIssue
+};
+function formatIssueLines(issues, format) {
+	const head = issues.slice(0, format.max).map(format.formatIssue);
+	const overflow = issues.length - format.max;
+	if (overflow > 0) head.push(`... and ${overflow} more`);
+	return head.map((line) => `  ${line}`).join("\n");
+}
+function formatZodIssuePointer(path) {
+	if (path.length === 0) return "/";
+	return path.map((key) => `/${escapeJsonPointerSegment(key)}`).join("");
+}
+const RESPONSE_SHAPE_LEAD_UNKNOWN_VERSION = "Metabase returned unexpected response shape";
+var ResponseShapeError = class ResponseShapeError extends MetabaseError {
+	category = "response-shape";
+	isRetryable = false;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "ResponseShapeError";
+		this.developerDetail = developerDetail;
+	}
+	static fromZodIssues(developerDetail) {
+		return new ResponseShapeError(formatResponseShapeMessage(developerDetail), developerDetail);
+	}
+};
+function formatResponseShapeMessage(detail) {
+	const { zodIssues: issues, serverTag, serverSkew } = detail;
+	const lead = serverTag === null ? RESPONSE_SHAPE_LEAD_UNKNOWN_VERSION : `On Metabase ${describeServer(serverTag, serverSkew)} the response shape was unexpected`;
+	if (issues.length === 0) return lead;
+	return `${lead}:\n${formatIssueLines(issues, RESPONSE_SHAPE_ISSUE_FORMAT)}`;
+}
+function describeServer(tag, skew) {
+	if (skew === "newer-than-known") return `${tag} (newer than this client supports, up to v${KNOWN_RANGE.max})`;
+	if (skew === "development") return `development build ${tag} (newer than every release)`;
+	return tag;
+}
+var ConfigError = class extends MetabaseError {
+	category = "config";
+	isRetryable = false;
+	developerDetail = null;
+	constructor(message) {
+		super(message);
+		this.name = "ConfigError";
+	}
+};
+var InternalError = class extends MetabaseError {
+	category = "internal";
+	isRetryable = false;
+	developerDetail = null;
+	constructor(message) {
+		super(message);
+		this.name = "InternalError";
+	}
+};
+var FailedResultError = class extends MetabaseError {
+	category = "failed";
+	isRetryable = false;
+	developerDetail = null;
+	constructor(message) {
+		super(message);
+		this.name = "FailedResultError";
+	}
+};
+var AbortError = class extends MetabaseError {
+	category = "abort";
+	isRetryable = false;
+	developerDetail = null;
+	constructor(message = "aborted") {
+		super(message);
+		this.name = "AbortError";
+	}
+};
+function isNonInterruptFailure(error) {
+	return error instanceof MetabaseError && !(error instanceof 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 developerDetail() {
+		return this.cause.developerDetail;
+	}
+};
+var UnknownError = class extends MetabaseError {
+	category = "unknown";
+	isRetryable = false;
+	developerDetail;
+	constructor(input) {
+		super(input.originalMessage);
+		this.name = "UnknownError";
+		this.developerDetail = input;
+	}
+};
+var PartialWriteError = class extends MetabaseError {
+	category = "partial-write";
+	isRetryable = false;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "PartialWriteError";
+		this.developerDetail = developerDetail;
+	}
+};
+function toMetabaseError(error) {
+	if (error instanceof MetabaseError) return error;
+	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 isFileNotFoundError(value) {
+	return value instanceof Error && "code" in value && value.code === "ENOENT";
+}
+function errorMessage(value) {
+	return value instanceof Error ? value.message : String(value);
+}
+//#endregion
+export { AbortError, ChainedRequestError, ConfigError, FailedResultError, InternalError, MetabaseError, NetworkError, PartialWriteError, ResponseShapeError, TimeoutError, UnknownError, ValidationError, errorMessage, formatZodIssue, isFileNotFoundError, isNonInterruptFailure, toMetabaseError };