@capxul/sdk-react 0.2.0-alpha.4 → 1.0.0-alpha.6

package/dist/index.mjs

@@ -0,0 +1,568 @@
+"use client";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { QueryClient, QueryClientProvider, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { createCapxulClient, isSettingUpLifecycle } from "@capxul/sdk";
+import { jsx } from "react/jsx-runtime";
+import { Errors } from "@capxul/config";
+//#region src/internal/capxul-bootstrap-context.tsx
+const CapxulBootstrapContext = createContext(null);
+function CapxulBootstrapProvider({ value, children }) {
+	return /* @__PURE__ */ jsx(CapxulBootstrapContext.Provider, {
+		value,
+		children
+	});
+}
+function useCapxul() {
+	const state = useContext(CapxulBootstrapContext);
+	if (state === null) throw new Error("useCapxul must be used within <CapxulProvider>");
+	return state;
+}
+//#endregion
+//#region src/internal/capxul-client-context.tsx
+const MISSING_CAPXUL_CLIENT_PROVIDER = Symbol("MISSING_CAPXUL_CLIENT_PROVIDER");
+const CapxulClientContext = createContext(MISSING_CAPXUL_CLIENT_PROVIDER);
+function CapxulClientProvider({ client, children }) {
+	return /* @__PURE__ */ jsx(CapxulClientContext.Provider, {
+		value: client,
+		children
+	});
+}
+function useCapxulClient() {
+	const client = useCapxulClientOrNull();
+	if (client === null) throw new Error("useCapxulClient called before <CapxulProvider> bootstrap resolved");
+	return client;
+}
+/**
+* Returns the client, or `null` while `<CapxulProvider>` is still bootstrapping.
+* Data hooks use this so they can sit in `isPending` (disabled query) until the
+* client resolves, rather than throwing during bootstrap.
+*/
+function useCapxulClientOrNull() {
+	const client = useContext(CapxulClientContext);
+	if (client === MISSING_CAPXUL_CLIENT_PROVIDER) throw new Error("useCapxulClient must be used within <CapxulProvider>");
+	return client;
+}
+//#endregion
+//#region src/provider.tsx
+function makeDefaultQueryClient() {
+	return new QueryClient({ defaultOptions: {
+		queries: {
+			retry: 2,
+			staleTime: 3e4
+		},
+		mutations: { retry: 0 }
+	} });
+}
+function isCapxulQueryKey(queryKey) {
+	return queryKey[0] === "capxul";
+}
+function clearClientScopedQueries(queryClient, ownsQueryClient) {
+	if (ownsQueryClient) {
+		queryClient.clear();
+		return;
+	}
+	queryClient.removeQueries({ predicate: (query) => isCapxulQueryKey(query.queryKey) });
+}
+function CapxulProvider(props) {
+	const { publishableKey, client: injectedClient, requirement, signer, queryClient, children } = props;
+	const [resolvedQueryClient] = useState(() => queryClient ?? makeDefaultQueryClient());
+	const [ownsQueryClient] = useState(() => queryClient === void 0);
+	const [client, setClient] = useState(injectedClient ?? null);
+	const previousClientRef = useRef(injectedClient ?? null);
+	const [status, setStatus] = useState(injectedClient === void 0 ? "bootstrapping" : "ready");
+	const [error, setError] = useState(null);
+	const [attempt, setAttempt] = useState(0);
+	const retry = useCallback(() => {
+		setAttempt((n) => n + 1);
+	}, []);
+	useEffect(() => {
+		if (publishableKey === void 0) return;
+		let cancelled = false;
+		let created = null;
+		setStatus("bootstrapping");
+		setError(null);
+		setClient(null);
+		(async () => {
+			const result = await createCapxulClient({
+				publishableKey,
+				...requirement === void 0 ? {} : { requirement },
+				...signer === void 0 ? {} : { signer }
+			});
+			if (cancelled) {
+				if (result.ok) await result.value._internal.close?.();
+				return;
+			}
+			if (result.ok) {
+				created = result.value;
+				setClient(result.value);
+				setStatus("ready");
+			} else {
+				setError(result.error);
+				setStatus("error");
+			}
+		})();
+		return () => {
+			cancelled = true;
+			created?._internal.close?.();
+		};
+	}, [
+		publishableKey,
+		requirement,
+		signer,
+		attempt
+	]);
+	useEffect(() => {
+		if (injectedClient === void 0) return;
+		setClient(injectedClient);
+		setStatus("ready");
+		setError(null);
+	}, [injectedClient]);
+	useEffect(() => {
+		const previous = previousClientRef.current;
+		if (previous !== null && previous !== client) clearClientScopedQueries(resolvedQueryClient, ownsQueryClient);
+		previousClientRef.current = client;
+	}, [
+		client,
+		ownsQueryClient,
+		resolvedQueryClient
+	]);
+	const bootstrapState = useMemo(() => ({
+		status,
+		error,
+		retry
+	}), [
+		status,
+		error,
+		retry
+	]);
+	if (publishableKey === void 0 === (injectedClient === void 0)) throw new Error("CapxulProvider requires exactly one of `publishableKey` or `client`");
+	return /* @__PURE__ */ jsx(QueryClientProvider, {
+		client: resolvedQueryClient,
+		children: /* @__PURE__ */ jsx(CapxulBootstrapProvider, {
+			value: bootstrapState,
+			children: /* @__PURE__ */ jsx(CapxulClientProvider, {
+				client,
+				children
+			})
+		})
+	});
+}
+//#endregion
+//#region src/internal/require-bootstrapped-client.ts
+/**
+* Narrow the bootstrap-nullable client to a ready client inside a query /
+* mutation function (sdk-provider-owned-bootstrap.md). Data hooks gate their
+* queries on `enabled: client !== null`, so this only ever throws for a mutation
+* triggered while `<CapxulProvider>` is still bootstrapping.
+*/
+function requireBootstrappedClient(client, method) {
+	if (client === null) throw Errors.wrongState({
+		method,
+		currentState: "bootstrapping",
+		validStates: ["ready"]
+	});
+	return client;
+}
+//#endregion
+//#region src/internal/reactivity-keys.ts
+const capxulKeys = {
+	session: ["capxul", "session"],
+	profile: ["capxul", "profile"],
+	account: ["capxul", "account"],
+	accountLifecycle: ["capxul", "accountLifecycle"],
+	provisioning: ["capxul", "provisioning"],
+	binding: ["capxul", "binding"],
+	accountBalance: ["capxul", "accountBalance"],
+	subAccounts: (accountId) => [
+		"capxul",
+		"subAccounts",
+		accountId ?? "pending"
+	],
+	orgs: ["capxul", "orgs"],
+	org: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending"
+	],
+	orgMembers: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"members"
+	],
+	orgRoles: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"roles"
+	],
+	orgTreasury: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"treasury"
+	]
+};
+//#endregion
+//#region src/internal/unwrap-capxul-result.ts
+/** Unwrap a `CapxulResult` for TanStack query/mutation functions — throws into error paths. */
+function unwrapCapxulResult(result) {
+	if (result.ok) return result.value;
+	throw result.error;
+}
+//#endregion
+//#region src/hooks/use-capxul-session.ts
+function useCapxulSession() {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.session,
+		queryFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "auth.getSession").auth.getSession()),
+		enabled: client !== null
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-profile.ts
+function useCapxulProfile() {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.profile,
+		queryFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "identity.loadCurrent").identity.loadCurrent()),
+		enabled: client !== null
+	});
+}
+//#endregion
+//#region src/internal/is-vitest-runtime.ts
+/** True under Vitest — disables hook polling intervals that fight fake timers. */
+function isVitestRuntime() {
+	return typeof process !== "undefined" && process.env["VITEST"] === "true";
+}
+//#endregion
+//#region src/internal/invalidate-auth-boundary.ts
+/** Background refetch after verifyOtp — avoids hard reset cancel errors in UI. */
+async function invalidateAuthBoundary(queryClient) {
+	await Promise.all([
+		queryClient.invalidateQueries({ queryKey: capxulKeys.session }),
+		queryClient.invalidateQueries({ queryKey: capxulKeys.profile }),
+		queryClient.invalidateQueries({ queryKey: capxulKeys.accountLifecycle }),
+		queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance })
+	]);
+}
+/** Hard reset after signOut — drop cached authenticated rows immediately. */
+async function resetAuthBoundary(queryClient) {
+	await queryClient.cancelQueries({ queryKey: capxulKeys.accountBalance });
+	await Promise.all([
+		queryClient.resetQueries({ queryKey: capxulKeys.session }),
+		queryClient.resetQueries({ queryKey: capxulKeys.profile }),
+		queryClient.resetQueries({ queryKey: capxulKeys.accountLifecycle }),
+		queryClient.resetQueries({ queryKey: capxulKeys.accountBalance })
+	]);
+}
+//#endregion
+//#region src/hooks/use-capxul-account-lifecycle.ts
+const LOADING_LIFECYCLE = { status: "loading" };
+function useCapxulAccountLifecycle() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	const query = useQuery({
+		queryKey: capxulKeys.accountLifecycle,
+		queryFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "account.getLifecycle").account.getLifecycle()),
+		enabled: client !== null,
+		refetchInterval: (q) => {
+			if (isVitestRuntime()) return false;
+			const data = q.state.data;
+			if (data === void 0) return false;
+			if (data.status === "loading" || isSettingUpLifecycle(data)) return 2e3;
+			return false;
+		}
+	});
+	const retryMutation = useMutation({
+		mutationFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "account.retrySetup").account.retrySetup()),
+		onSuccess: async () => {
+			await invalidateAuthBoundary(queryClient);
+		}
+	});
+	const lifecycle = query.data ?? LOADING_LIFECYCLE;
+	const failedError = lifecycle.status === "failed" ? lifecycle.error : null;
+	return {
+		lifecycle,
+		isSettingUp: isSettingUpLifecycle(lifecycle),
+		error: failedError ?? (query.isError ? query.error : null),
+		isLoading: query.isLoading,
+		isFetching: query.isFetching,
+		isError: query.isError,
+		retry: retryMutation.mutateAsync,
+		isRetrying: retryMutation.isPending
+	};
+}
+//#endregion
+//#region src/hooks/use-capxul-account-balance.ts
+function useCapxulAccountBalance(options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.accountBalance,
+		queryFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "accounts.read").accounts.read()),
+		enabled: client !== null && (options?.enabled ?? true)
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-account-fund.ts
+function useCapxulAccountFund() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (amount) => unwrapCapxulResult(await requireBootstrappedClient(client, "_internal.accounts.fund")._internal.accounts.fund(amount)),
+		onSuccess: async () => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-sign-in.ts
+function useCapxulSignIn() {
+	const client = useCapxulClientOrNull();
+	return useMutation({ mutationFn: async (input) => unwrapCapxulResult(await requireBootstrappedClient(client, "auth.signIn").auth.signIn(input)) });
+}
+//#endregion
+//#region src/hooks/use-capxul-verify-otp.ts
+function useCapxulVerifyOtp() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => unwrapCapxulResult(await requireBootstrappedClient(client, "auth.verifyOtp").auth.verifyOtp(input)),
+		onSuccess: async () => {
+			await invalidateAuthBoundary(queryClient);
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-sign-out.ts
+function useCapxulSignOut() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: async () => {
+			await queryClient.cancelQueries({ queryKey: capxulKeys.accountBalance });
+		},
+		mutationFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "auth.signOut").auth.signOut()),
+		onSuccess: () => resetAuthBoundary(queryClient)
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-sub-accounts.ts
+function useCapxulSubAccountsList(accountId, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.subAccounts(accountId),
+		queryFn: async () => {
+			if (accountId === void 0) throw Errors.invalidInput("accountId", "required for subAccounts.list");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "subAccounts.list").subAccounts.list(accountId));
+		},
+		enabled: client !== null && (options?.enabled ?? true) && accountId !== void 0
+	});
+}
+function useCapxulSubAccountCreate() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => unwrapCapxulResult(await requireBootstrappedClient(client, "subAccounts.create").subAccounts.create(input.accountId, { name: input.name })),
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.subAccounts(variables.accountId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+function useCapxulSubAccountRename() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => unwrapCapxulResult(await requireBootstrappedClient(client, "subAccounts.rename").subAccounts.rename(input.subAccountId, input.name)),
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.subAccounts(variables.accountId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+function useCapxulSubAccountDelete() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => unwrapCapxulResult(await requireBootstrappedClient(client, "subAccounts.delete").subAccounts.delete(input.subAccountId)),
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.subAccounts(variables.accountId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+function useCapxulTransfer() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async ({ from, to, amount }) => unwrapCapxulResult(await requireBootstrappedClient(client, "subAccounts.transfer").subAccounts.transfer({
+			from,
+			to,
+			amount
+		})),
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.subAccounts(variables.accountId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-orgs.ts
+function useCapxulOrgs(options) {
+	const client = useCapxulClient();
+	return useQuery({
+		queryKey: capxulKeys.orgs,
+		queryFn: async () => unwrapCapxulResult(await client.orgs()),
+		enabled: options?.enabled ?? true
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org.ts
+function useCapxulOrg(orgId, options) {
+	const client = useCapxulClient();
+	return useQuery({
+		queryKey: capxulKeys.org(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrg");
+			return unwrapCapxulResult(await client.orgs()).find((org) => org.id === orgId) ?? null;
+		},
+		enabled: (options?.enabled ?? true) && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org-members.ts
+function useCapxulOrgMembers(orgId, options) {
+	const client = useCapxulClient();
+	return useQuery({
+		queryKey: capxulKeys.orgMembers(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgMembers");
+			return unwrapCapxulResult(await client.org(orgId).members());
+		},
+		enabled: (options?.enabled ?? true) && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org-roles.ts
+function useCapxulOrgRoles(orgId, options) {
+	const client = useCapxulClient();
+	return useQuery({
+		queryKey: capxulKeys.orgRoles(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgRoles");
+			return unwrapCapxulResult(await client.org(orgId).roles());
+		},
+		enabled: (options?.enabled ?? true) && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org-deploy-roles.ts
+function useCapxulOrgDeployRoles() {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (orgId) => {
+			return unwrapCapxulResult(await client.org(orgId).deployRoles());
+		},
+		onSuccess: async (_roles, orgId) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgRoles(orgId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.org(orgId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgs });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org-treasury.ts
+function useCapxulOrgTreasury(orgId, options) {
+	const client = useCapxulClient();
+	return useQuery({
+		queryKey: capxulKeys.orgTreasury(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgTreasury");
+			return unwrapCapxulResult(await client.org(orgId).treasury());
+		},
+		enabled: (options?.enabled ?? true) && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-create-org.ts
+function useCapxulCreateOrg() {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => unwrapCapxulResult(await client.createOrg(input)),
+		onSuccess: async () => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgs });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-invite-member.ts
+function useCapxulInviteMember(orgId) {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulInviteMember");
+			return unwrapCapxulResult(await client.org(orgId).invite(input));
+		},
+		onSuccess: async () => {
+			if (orgId === void 0) return;
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgMembers(orgId) });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-remove-member.ts
+function useCapxulRemoveMember(orgId) {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulRemoveMember");
+			return unwrapCapxulResult(await client.org(orgId).removeMember(input));
+		},
+		onSuccess: async () => {
+			if (orgId === void 0) return;
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgMembers(orgId) });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-assign-role.ts
+function useCapxulAssignRole(orgId) {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulAssignRole");
+			return unwrapCapxulResult(await client.org(orgId).assignRole(input));
+		},
+		onSuccess: async () => {
+			if (orgId === void 0) return;
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgMembers(orgId) });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org-spend.ts
+function useCapxulOrgSpend(orgId) {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "org is not selected");
+			return unwrapCapxulResult(await client.org(orgId).spend(input));
+		},
+		onSuccess: async () => {
+			if (orgId === void 0) return;
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgTreasury(orgId) });
+		}
+	});
+}
+//#endregion
+export { CapxulProvider, useCapxul, useCapxulAccountBalance, useCapxulAccountFund, useCapxulAccountLifecycle, useCapxulAssignRole, useCapxulCreateOrg, useCapxulInviteMember, useCapxulOrg, useCapxulOrgDeployRoles, useCapxulOrgMembers, useCapxulOrgRoles, useCapxulOrgSpend, useCapxulOrgTreasury, useCapxulOrgs, useCapxulProfile, useCapxulRemoveMember, useCapxulSession, useCapxulSignIn, useCapxulSignOut, useCapxulSubAccountCreate, useCapxulSubAccountDelete, useCapxulSubAccountRename, useCapxulSubAccountsList, useCapxulTransfer, useCapxulVerifyOtp };
+
+//# sourceMappingURL=index.mjs.map