@metabase/client 0.0.0-stage → 0.1.1

package/dist/refusal-B9aeHMc9.js

@@ -0,0 +1,130 @@
+import { InternalError, isNonInterruptFailure } from "./errors.js";
+import { isPlainObject } from "./predicates.js";
+import { a as HttpError } from "./errors-DdMlaXqq.js";
+import { CapabilityError } from "./version/capability-error.js";
+import { profileFromProperties } from "./version/probe.js";
+import { checkFeatures, featureFailures } from "./version/requirement-check.js";
+import { isMethodKey, methodRequirements } from "./version/requirements.js";
+//#region src/version/refusal.ts
+const REFUSAL_STATUSES = /* @__PURE__ */ new Set([
+	400,
+	402,
+	404
+]);
+function explainer(transport, namespace) {
+	function explain(name, method, parameters) {
+		const key = methodKey(namespace, name);
+		return async (...args) => {
+			try {
+				return await method(...args);
+			} catch (error) {
+				throw await explainRefusal(transport, callRequirement(key, parameters, args), error);
+			}
+		};
+	}
+	function explainWalk(name, method, parameters) {
+		const key = methodKey(namespace, name);
+		return async function* (...args) {
+			try {
+				yield* method(...args);
+			} catch (error) {
+				throw await explainRefusal(transport, callRequirement(key, parameters, args), error);
+			}
+		};
+	}
+	function refuse(name, method) {
+		const key = methodKey(namespace, name);
+		return async (...args) => {
+			await transport.requireFeatures(methodRequirements(key), trailingWait(args));
+			return method(...args);
+		};
+	}
+	function refuseAfterReading(name, reader, method) {
+		const key = methodKey(namespace, name);
+		return async (options = {}) => {
+			const properties = await transport.probe(reader, options);
+			const profile = profileFromProperties(properties);
+			for (const failure of featureFailures(methodRequirements(key), profile)) transport.refuseBeforeSending(new CapabilityError(failure));
+			return method(properties);
+		};
+	}
+	return {
+		explain,
+		explainWalk,
+		refuse,
+		refuseAfterReading
+	};
+}
+function trailingWait(args) {
+	const last = args.at(-1);
+	if (isPlainObject(last) && last["signal"] instanceof AbortSignal) return { signal: last["signal"] };
+	return {};
+}
+function methodKey(namespace, name) {
+	const key = `${namespace}.${name}`;
+	if (!isMethodKey(key)) throw new InternalError(`no requirements entry for ${key}`);
+	return key;
+}
+function callRequirement(key, parameters, args) {
+	return {
+		parameters: parameters === void 0 ? [] : parameters(...args),
+		method: methodRequirements(key)
+	};
+}
+/**
+* The error a call failed with, as a `CapabilityError` carrying the server's answer when the server
+* refused it for lacking one of the features `call` needs, and unchanged otherwise. The server's own
+* refusal is the verdict; the profile only names what was missing. The explaining probe is bounded
+* by its own timeout and the client's signal; the error stands when the probe fails, and an
+* interrupt surfaces as one.
+*/
+async function explainRefusal(transport, call, error) {
+	if (!mayBeRefusal(call, error)) return error;
+	let profile;
+	try {
+		profile = await transport.verifiedServer();
+	} catch (probeError) {
+		if (isNonInterruptFailure(probeError)) return error;
+		throw probeError;
+	}
+	const failure = explainedFailure(call, profile, error);
+	return failure === null ? error : new CapabilityError(failure, error);
+}
+/** Every feature `call` needs, parameters first, since a parameter's floor sits above its method's. */
+function callFeatures(call) {
+	return [...call.parameters.map((parameter) => parameter.feature), ...call.method];
+}
+/**
+* Whether `error` may be the server refusing `call` for a feature it lacks. A call that needs no
+* feature cannot be, and neither can a 404 for a missing row, which comes from a route the server
+* serves.
+*/
+function mayBeRefusal(call, error) {
+	if (callFeatures(call).length === 0) return false;
+	if (!(error instanceof HttpError) || error.kind === "resource-missing") return false;
+	return REFUSAL_STATUSES.has(error.status);
+}
+/**
+* The feature `profile` lacks that explains `refusal` of `call`, or `null` when the server has every
+* feature the call needs, so it failed for some other reason, or when the refusal points elsewhere.
+*/
+function explainedFailure(call, profile, refusal) {
+	const failure = checkFeatures(callFeatures(call), profile);
+	if (failure === null || pointsElsewhere(call, profile, refusal)) return null;
+	return failure;
+}
+function pointsElsewhere(call, profile, refusal) {
+	if (refusal.status !== 400 || checkFeatures(call.method, profile) !== null) return false;
+	const named = rejectedFields(refusal);
+	const gated = new Set(call.parameters.filter((parameter) => checkFeatures([parameter.feature], profile) !== null).flatMap((parameter) => parameter.fields));
+	return named.some((field) => !gated.has(field));
+}
+function rejectedFields(refusal) {
+	return [refusal.fieldErrors, refusal.specificFieldErrors].flatMap((errors) => errors === null ? [] : Object.keys(errors).map(topLevelField));
+}
+function topLevelField(path) {
+	const end = path.indexOf(".");
+	return end === -1 ? path : path.slice(0, end);
+}
+//#endregion
+export { explainer as t };