everything-dev/dist/ui/auth.mjs

A consolidated product package for building Module Federation apps with oRPC APIs.

import { getRuntimeConfig } from "./runtime.mjs";
import { pluginHref, pluginPath, pluginSearch } from "./plugin-path.mjs";
import { clearAuthenticatedQueries, requireAdmin, requireSession } from "./auth-guards.mjs";
import { useRouter } from "@tanstack/react-router";
import { apiKeyClient } from "@better-auth/api-key/client";
import { passkeyClient } from "@better-auth/passkey/client";
import { useQuery } from "@tanstack/react-query";
import { adminClient, anonymousClient, deviceAuthorizationClient, inferAdditionalFields, organizationClient, phoneNumberClient } from "better-auth/client/plugins";
import { createAuthClient as createAuthClient$1 } from "better-auth/react";
import { DEFAULT_DEVICE_LINK_CLIENT_ID, siwnClient } from "better-near-auth/client";

//#region src/ui/auth.ts
function hasAuthVariables(auth) {
	return !!auth && typeof auth === "object" && typeof auth.variables === "object";
}
function readRuntimeConfig(config) {
	if (config) return config;
	if (typeof window === "undefined") return void 0;
	try {
		return getRuntimeConfig();
	} catch {
		return;
	}
}
function getAuthVariables(config) {
	const runtimeConfig = readRuntimeConfig(config);
	if (!runtimeConfig || !hasAuthVariables(runtimeConfig.auth)) throw new Error("Missing auth runtime configuration");
	return runtimeConfig.auth.variables;
}
function getSiwnClientConfig(options) {
	const runtimeConfig = readRuntimeConfig(options.runtimeConfig);
	const siwn = getAuthVariables(options.runtimeConfig).siwn;
	const mainnetRecipient = siwn.recipients?.mainnet ?? siwn.recipient;
	if (!mainnetRecipient) throw new Error("Missing auth SIWN recipient");
	const networkId = runtimeConfig?.networkId ?? (mainnetRecipient.endsWith(".testnet") ? "testnet" : "mainnet");
	const testnetRecipient = siwn.recipients?.testnet;
	if (testnetRecipient) return {
		recipients: {
			mainnet: mainnetRecipient,
			testnet: testnetRecipient
		},
		networkId,
		cspNonce: options.cspNonce
	};
	return {
		recipient: mainnetRecipient,
		networkId,
		cspNonce: options.cspNonce
	};
}
function getHostUrl(config) {
	const runtimeConfig = readRuntimeConfig(config);
	if (runtimeConfig?.hostUrl) return runtimeConfig.hostUrl;
	if (typeof window !== "undefined") return window.location.origin;
	return "";
}
function getDeviceLinkClientId(config) {
	return (readRuntimeConfig(config)?.auth?.variables)?.deviceLink?.clientId ?? DEFAULT_DEVICE_LINK_CLIENT_ID;
}
function createAuthClient(options = {}) {
	const nearAuthConfig = getSiwnClientConfig(options);
	return createAuthClient$1({
		baseURL: getHostUrl(options.runtimeConfig),
		fetchOptions: {
			credentials: "include",
			...options.headers ? { headers: options.headers } : {}
		},
		plugins: [
			inferAdditionalFields({ user: { locale: {
				type: "string",
				required: false,
				input: true
			} } }),
			siwnClient(nearAuthConfig),
			adminClient(),
			anonymousClient(),
			phoneNumberClient(),
			passkeyClient(),
			organizationClient({ teams: { enabled: true } }),
			apiKeyClient(),
			deviceAuthorizationClient()
		]
	});
}
function useAuthClient() {
	return useRouter().options.context.authClient;
}
const sessionQueryKey = ["session"];
function sessionQueryOptions(authClient) {
	return {
		queryKey: sessionQueryKey,
		queryFn: async () => {
			const { data: session, error } = await authClient.getSession({ query: { disableCookieCache: true } });
			if (error) throw new Error(error.message || "Unable to load your session");
			return session ?? null;
		},
		staleTime: 6e4,
		gcTime: 6e5
	};
}
async function refreshSessionCache(authClient, queryClient) {
	return queryClient.fetchQuery({
		...sessionQueryOptions(authClient),
		staleTime: 0
	});
}
/**
* Resolves the session for the root route: the query cache wins (it is kept
* authoritative by the single sessionQueryOptions read path), and a populated
* router-context session — the host's SSR resolution — seeds an empty cache so
* the dehydrated state carries it to the client.
*/
function resolveSessionFromCache(queryClient, contextSession) {
	if (!queryClient) return contextSession;
	const cachedSession = queryClient.getQueryData(sessionQueryKey);
	if (cachedSession !== void 0) return cachedSession;
	if (contextSession !== void 0) queryClient.setQueryData(sessionQueryKey, contextSession);
	return contextSession;
}
function useRelayHistory(session, authClient) {
	return useQuery({
		queryKey: ["relay-history"],
		queryFn: async () => {
			return (await authClient.near.relayHistory())?.data?.transactions ?? [];
		},
		enabled: !!session,
		refetchInterval: 2e3
	});
}
const UNSUPPORTED_AUTHENTICATOR_CODES = /* @__PURE__ */ new Set([
	"PASSKEY_UNSUPPORTED_AUTHENTICATOR",
	"ERROR_AUTHENTICATOR_NO_SUPPORTED_PUBKEYCREDPARAMS_ALG",
	"ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT",
	"ERROR_AUTHENTICATOR_MISSING_USER_VERIFICATION_SUPPORT"
]);
function isUnsupportedAuthenticatorError(error) {
	if (!(error instanceof Error) || !("code" in error)) return false;
	return typeof error.code === "string" && UNSUPPORTED_AUTHENTICATOR_CODES.has(error.code);
}
function toPasskeyError(error, fallback) {
	return Object.assign(new Error(error?.message || fallback), { code: error?.code });
}
async function isPasskeyAutofillAvailable() {
	if (typeof window === "undefined" || !window.PublicKeyCredential) return false;
	try {
		return await window.PublicKeyCredential.isConditionalMediationAvailable?.() === true;
	} catch {
		return false;
	}
}
async function createAccountWithPasskey(authClient, options) {
	try {
		const { data, error } = await authClient.passkey.addPasskey();
		if (error || !data) {
			options?.onError?.(toPasskeyError(error, "Could not create your account"));
			return;
		}
		const { passkeyWallet } = data;
		options?.onSuccess?.({ passkeyWallet });
	} catch (error) {
		options?.onError?.(toPasskeyError(error instanceof Error ? error : null, "Could not create your account"));
	}
}
async function signInWithPasskey(authClient, options) {
	try {
		const { data, error } = await authClient.signIn.passkey({ autoFill: options?.autoFill });
		if (error || !data) {
			options?.onError?.(toPasskeyError(error, "Passkey sign-in failed"));
			return;
		}
		options?.onSuccess?.();
	} catch (error) {
		options?.onError?.(toPasskeyError(error instanceof Error ? error : null, "Passkey sign-in failed"));
	}
}

//#endregion
export { clearAuthenticatedQueries, createAccountWithPasskey, createAuthClient, getDeviceLinkClientId, isPasskeyAutofillAvailable, isUnsupportedAuthenticatorError, pluginHref, pluginPath, pluginSearch, refreshSessionCache, requireAdmin, requireSession, resolveSessionFromCache, sessionQueryKey, sessionQueryOptions, signInWithPasskey, useAuthClient, useRelayHistory };
//# sourceMappingURL=auth.mjs.map