@sanity/sdk 3.0.0 → 3.1.0

package/dist/{authStore-CtE9bLHW.js → clientStore-gUALQ0qW.js}

@@ -1,9 +1,185 @@
-import { t as __exportAll } from "./rolldown-runtime-vyAXikos.js";
-import { a as defineStore, i as bindActionGlobally, t as createStateSourceAction } from "./createStateSourceAction-BOKtqFNm.js";
-import { n as createLogger } from "./logger-DAtJb5RQ.js";
+import { a as createStateSourceAction, c as bindActionGlobally, f as isCanvasResource, i as pickProperties, l as defineStore, m as isMediaLibraryResource, p as isDatasetResource } from "./object-BwynGPRZ.js";
 import { createClient } from "@sanity/client";
 import { EMPTY, Observable, catchError, defer, distinctUntilChanged, exhaustMap, filter, fromEvent, map, switchMap, takeWhile, timer } from "rxjs";
 import "@sanity/types";
+var __defProp = Object.defineProperty, __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: !0
+	});
+	return no_symbols || __defProp(target, Symbol.toStringTag, { value: "Module" }), target;
+};
+const LOG_LEVEL_PRIORITY = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3,
+	trace: 4
+}, DEFAULT_CONFIG = {
+	level: "warn",
+	namespaces: [],
+	internal: !1,
+	timestamps: !0,
+	enableInProduction: !1,
+	handler: {
+		error: console.error.bind(console),
+		warn: console.warn.bind(console),
+		info: console.info.bind(console),
+		debug: console.debug.bind(console),
+		trace: console.debug.bind(console)
+	}
+};
+/**
+* Parse DEBUG environment variable for automatic logging configuration
+*
+* Supports patterns similar to Sanity CLI/Studio:
+* - DEBUG=sanity:* (all namespaces, debug level)
+* - DEBUG=sanity:auth,sanity:document (specific namespaces)
+* - DEBUG=sanity:trace:* (all namespaces, trace level)
+* - DEBUG=sanity:*:internal (enable internal logs)
+*
+* @internal
+*/
+function parseDebugEnvVar() {
+	if (typeof process > "u" || !process.env?.DEBUG) return null;
+	let debug = process.env.DEBUG;
+	if (!debug.includes("sanity")) return null;
+	let config = {}, levelMatch = debug.match(/sanity:(trace|debug|info|warn|error):/), hasLevelSpecifier = !!levelMatch;
+	if (config.level = levelMatch ? levelMatch[1] : "debug", debug === "sanity") config.namespaces = ["*"];
+	else if (hasLevelSpecifier && debug.match(/sanity:(trace|debug|info|warn|error):\*/)) config.namespaces = ["*"];
+	else if (!hasLevelSpecifier && debug.includes("sanity:*")) config.namespaces = ["*"];
+	else {
+		let namespaces = debug.split(",").filter((s) => s.includes("sanity:")).map((s) => {
+			let cleaned = s.replace(/^sanity:/, "");
+			return hasLevelSpecifier && cleaned.match(/^(trace|debug|info|warn|error):/) ? cleaned.split(":").slice(1).join(":") : cleaned.split(":")[0];
+		}).filter(Boolean).filter((ns) => ns !== "*");
+		namespaces.length > 0 && (config.namespaces = namespaces);
+	}
+	return debug.includes(":internal") && (config.internal = !0), config;
+}
+const envConfig = parseDebugEnvVar();
+let globalConfig = {
+	...DEFAULT_CONFIG,
+	...envConfig ?? {}
+};
+/* c8 ignore next 14 */
+envConfig && ([
+	"info",
+	"debug",
+	"trace"
+].includes(globalConfig.level) || globalConfig.level === "warn") && console.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [sdk] Logging auto-configured from DEBUG environment variable`, {
+	level: globalConfig.level,
+	namespaces: globalConfig.namespaces,
+	internal: globalConfig.internal,
+	source: "env:DEBUG",
+	value: typeof process < "u" ? process.env?.DEBUG : void 0
+});
+/**
+* Configure the global logging system
+* @public
+*/
+function configureLogging(config) {
+	globalConfig = {
+		...globalConfig,
+		...config,
+		handler: config.handler ?? globalConfig.handler
+	};
+}
+/**
+* Check if logging is enabled in the current environment
+* @internal
+*/
+function isLoggingEnabled() {
+	return typeof process < "u" && process.env?.NODE_ENV === "production" ? globalConfig.enableInProduction : !0;
+}
+/**
+* Check if a namespace is enabled
+* @internal
+*/
+function isNamespaceEnabled(namespace) {
+	return isLoggingEnabled() ? globalConfig.namespaces.includes("*") ? !0 : globalConfig.namespaces.includes(namespace) : !1;
+}
+/**
+* Check if a log level is enabled
+* @internal
+*/
+function isLevelEnabled(level) {
+	return isLoggingEnabled() ? LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[globalConfig.level] : !1;
+}
+/**
+* Format a log message with timestamp, namespace, and instance context
+* @internal
+*/
+function formatMessage(namespace, level, message, context) {
+	let parts = [];
+	if (globalConfig.timestamps) {
+		let timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		parts.push(`[${timestamp}]`);
+	}
+	parts.push(`[${level.toUpperCase()}]`), parts.push(`[${namespace}]`);
+	let instanceContext = context?.instanceContext;
+	return instanceContext && (instanceContext.projectId && parts.push(`[project:${instanceContext.projectId}]`), instanceContext.dataset && parts.push(`[dataset:${instanceContext.dataset}]`), instanceContext.instanceId && parts.push(`[instance:${instanceContext.instanceId.slice(0, 8)}]`)), parts.push(message), [parts.join(" "), context];
+}
+/**
+* Sanitize context for logging (remove sensitive data)
+* @internal
+* @remarks
+* This performs shallow sanitization only - it redacts top-level keys that contain
+* sensitive names (token, password, secret, apiKey, authorization).
+* Nested sensitive data (e.g., `\{auth: \{token: 'secret'\}\}`) will NOT be redacted.
+* If deep sanitization is needed in the future, this can be enhanced to recursively
+* traverse nested objects.
+*/
+function sanitizeContext(context) {
+	if (!context || Object.keys(context).length === 0) return;
+	let sanitized = { ...context }, sensitiveKeys = [
+		"token",
+		"password",
+		"secret",
+		"apiKey",
+		"authorization"
+	];
+	for (let key of Object.keys(sanitized)) sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive)) && (sanitized[key] = "[REDACTED]");
+	return sanitized;
+}
+/**
+* Create a logger for a specific namespace
+* @param namespace - A string identifier for the logging domain (e.g., 'auth', 'document')
+* @param baseContext - Optional base context to include in all log messages
+* @remarks
+* If baseContext includes an `instanceContext` property (with projectId, dataset, instanceId),
+* it will be automatically formatted into the log output for easier debugging of
+* multi-instance scenarios.
+* @public
+*/
+function createLogger(namespace, baseContext) {
+	let logAtLevel = (level, message, context) => {
+		if (!isNamespaceEnabled(namespace) || !isLevelEnabled(level) || context?.internal && !globalConfig.internal) return;
+		let [formatted, finalContext] = formatMessage(namespace, level, message, sanitizeContext({
+			...baseContext,
+			...context
+		}));
+		globalConfig.handler[level](formatted, finalContext);
+	};
+	return {
+		namespace,
+		error: (message, context) => logAtLevel("error", message, context),
+		warn: (message, context) => logAtLevel("warn", message, context),
+		info: (message, context) => logAtLevel("info", message, context),
+		debug: (message, context) => logAtLevel("debug", message, context),
+		trace: (message, context) => logAtLevel("trace", message, {
+			...context,
+			internal: !0
+		}),
+		isLevelEnabled: (level) => isNamespaceEnabled(namespace) && isLevelEnabled(level),
+		child: (childContext) => createLogger(namespace, {
+			...baseContext,
+			...childContext
+		}),
+		getInstanceContext: () => baseContext?.instanceContext
+	};
+}
 /**
 * Returns the staging API host if the `__SANITY_STAGING__` build-time flag is
 * set to `true` (mirroring how Sanity Studio detects staging builds).
@@ -33,7 +209,7 @@ function getAuthLogger(instance) {
 		dataset: instance.config.dataset
 	} }), loggers.set(instance, logger)), logger;
 }
-const DEFAULT_BASE = "http://localhost", DEFAULT_API_VERSION = "2021-06-07", REQUEST_TAG_PREFIX = "sanity.sdk.auth";
+const DEFAULT_BASE = "http://localhost", DEFAULT_API_VERSION$1 = "2021-06-07", REQUEST_TAG_PREFIX = "sanity.sdk.auth";
 /**
 * Determines the auth mode from instance config and environment.
 *
@@ -84,7 +260,7 @@ const REFRESH_INTERVAL = 432e5;
 function createTokenRefreshStream(token, clientFactory, apiHost) {
 	return new Observable((subscriber) => {
 		let subscription = clientFactory({
-			apiVersion: DEFAULT_API_VERSION,
+			apiVersion: DEFAULT_API_VERSION$1,
 			requestTagPrefix: REQUEST_TAG_PREFIX,
 			useProjectHostname: !1,
 			useCdn: !1,
@@ -92,7 +268,7 @@ function createTokenRefreshStream(token, clientFactory, apiHost) {
 			ignoreBrowserTokenWarning: !0,
 			...apiHost && { apiHost }
 		}).observable.request({
-			uri: "auth/refresh-token",
+			url: "auth/refresh-token",
 			method: "POST",
 			tag: "refresh-token",
 			body: { token }
@@ -170,7 +346,7 @@ const refreshStampedToken = ({ state, instance }) => {
 		token: value.authState.token,
 		authMethod: value.authMethod
 	})), distinctUntilChanged((prev, curr) => prev.token === curr.token && prev.authMethod === curr.authMethod)).pipe(map(({ token, authMethod }) => clientFactory({
-		apiVersion: DEFAULT_API_VERSION,
+		apiVersion: DEFAULT_API_VERSION$1,
 		requestTagPrefix: REQUEST_TAG_PREFIX,
 		token: authMethod === "cookie" ? void 0 : token,
 		ignoreBrowserTokenWarning: !0,
@@ -180,7 +356,7 @@ const refreshStampedToken = ({ state, instance }) => {
 		...useProjectHostname && projectId ? { projectId } : {},
 		...apiHost && { apiHost }
 	})), switchMap((client) => client.observable.request({
-		uri: "/users/me",
+		url: "/users/me",
 		method: "GET",
 		tag: "users.get-current"
 	}).pipe(
@@ -484,7 +660,7 @@ async function checkForCookieAuth(projectId, clientFactory) {
 			requestTagPrefix: REQUEST_TAG_PREFIX,
 			timeout: 1e4
 		}).request({
-			uri: "/users/me",
+			url: "/users/me",
 			withCredentials: !0,
 			tag: "users.get-current"
 		});
@@ -749,6 +925,88 @@ const authStore = defineStore({
 		isDestroyingSession: !1
 	} }));
 });
-export { REQUEST_TAG_PREFIX as C, DEFAULT_API_VERSION as S, getStagingApiHost as T, getDefaultLocation as _, getCurrentUserState as a, AuthStateType as b, getLoginUrlState as c, createLoggedInAuthState as d, getAuthCode as f, getClientErrorApiType as g, getClientErrorApiDescription as h, getAuthState as i, getTokenState as l, getClientErrorApiBody as m, authStore_exports as n, getDashboardOrganizationId as o, getCleanedUrl as p, getAuthMethodState as r, getIsInDashboardState as s, authStore as t, setAuthToken as u, getTokenFromLocation as v, getAuthLogger as w, isStudioConfig as x, isProjectUserNotFoundClientError as y };
+var clientStore_exports = /* @__PURE__ */ __exportAll({
+	getClient: () => getClient,
+	getClientState: () => getClientState
+});
+const allowedKeys = Object.keys({
+	apiHost: null,
+	useCdn: null,
+	token: null,
+	perspective: null,
+	proxy: null,
+	withCredentials: null,
+	timeout: null,
+	maxRetries: null,
+	dataset: null,
+	projectId: null,
+	scope: null,
+	apiVersion: null,
+	requestTagPrefix: null,
+	useProjectHostname: null,
+	resource: null
+}), DEFAULT_CLIENT_CONFIG = {
+	apiVersion: "2024-11-12",
+	useCdn: !1,
+	ignoreBrowserTokenWarning: !0,
+	allowReconfigure: !1,
+	requestTagPrefix: "sanity.sdk"
+}, clientStore = defineStore({
+	name: "clientStore",
+	getInitialState: (instance) => ({
+		clients: {},
+		token: getTokenState(instance).getCurrent()
+	}),
+	initialize(context) {
+		let subscription = listenToToken(context), authMethodSubscription = listenToAuthMethod(context);
+		return () => {
+			subscription.unsubscribe(), authMethodSubscription.unsubscribe();
+		};
+	}
+}), listenToToken = ({ instance, state }) => getTokenState(instance).observable.subscribe((token) => {
+	state.set("setTokenAndResetClients", {
+		token,
+		clients: {}
+	});
+}), listenToAuthMethod = ({ instance, state }) => getAuthMethodState(instance).observable.subscribe((authMethod) => {
+	state.set("setAuthMethod", { authMethod });
+}), getClientConfigKey = (options) => JSON.stringify(pickProperties(options, allowedKeys)), getClient = bindActionGlobally(clientStore, ({ state, instance }, options) => {
+	if (!options || typeof options != "object") throw Error("getClient() requires a configuration object with at least an \"apiVersion\" property. Example: getClient(instance, { apiVersion: \"2024-11-12\" })");
+	let disallowedKeys = Object.keys(options).filter((key) => !allowedKeys.includes(key));
+	if (disallowedKeys.length > 0) {
+		let listFormatter = new Intl.ListFormat("en", {
+			style: "long",
+			type: "conjunction"
+		});
+		throw Error(`The client options provided contains unsupported properties: ${listFormatter.format(disallowedKeys)}. Allowed keys are: ${listFormatter.format(allowedKeys)}.`);
+	}
+	let tokenFromState = state.get().token, { clients, authMethod } = state.get(), projectId = options.projectId ?? instance.config.projectId, dataset = options.dataset ?? instance.config.dataset, resource;
+	options.resource && (isMediaLibraryResource(options.resource) ? resource = {
+		type: "media-library",
+		id: options.resource.mediaLibraryId
+	} : isCanvasResource(options.resource) ? resource = {
+		type: "canvas",
+		id: options.resource.canvasId
+	} : isDatasetResource(options.resource) && (projectId = options.resource.projectId, dataset = options.resource.dataset));
+	let apiHost = options.apiHost ?? instance.config.auth?.apiHost ?? getStagingApiHost(), effectiveOptions = {
+		...DEFAULT_CLIENT_CONFIG,
+		...(options.scope === "global" || !projectId || resource) && { useProjectHostname: !1 },
+		token: authMethod === "cookie" ? void 0 : tokenFromState ?? void 0,
+		...options,
+		...projectId && { projectId },
+		...dataset && { dataset },
+		...resource ? { resource } : { resource: void 0 },
+		...apiHost && { apiHost }
+	};
+	resource && (delete effectiveOptions.projectId, delete effectiveOptions.dataset), effectiveOptions.token === null || effectiveOptions.token === void 0 ? (delete effectiveOptions.token, authMethod === "cookie" && (effectiveOptions.withCredentials = !0)) : delete effectiveOptions.withCredentials;
+	let key = getClientConfigKey(effectiveOptions);
+	if (clients[key]) return clients[key];
+	let client = createClient(effectiveOptions);
+	return state.set("addClient", (prev) => ({ clients: {
+		...prev.clients,
+		[key]: client
+	} })), client;
+}), getClientState = bindActionGlobally(clientStore, createStateSourceAction(({ instance }, options) => getClient(instance, options)));
+export { isStudioConfig as C, configureLogging as D, getAuthLogger as E, createLogger as O, AuthStateType as S, REQUEST_TAG_PREFIX as T, getClientErrorApiDescription as _, authStore_exports as a, getTokenFromLocation as b, getDashboardOrganizationId as c, getTokenState as d, setAuthToken as f, getClientErrorApiBody as g, getCleanedUrl as h, authStore as i, __exportAll as k, getIsInDashboardState as l, getAuthCode as m, getClient as n, getAuthState as o, createLoggedInAuthState as p, getClientState as r, getCurrentUserState as s, clientStore_exports as t, getLoginUrlState as u, getClientErrorApiType as v, DEFAULT_API_VERSION$1 as w, isProjectUserNotFoundClientError as x, getDefaultLocation as y };
 
-//# sourceMappingURL=authStore-CtE9bLHW.js.map
+//# sourceMappingURL=clientStore-gUALQ0qW.js.map