@geekapps/auth-nextjs 0.1.0

package/dist/client.js

@@ -0,0 +1,745 @@
+"use client";
+
+// src/client.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState
+} from "react";
+
+// src/actions.ts
+import { cookies } from "next/headers";
+function env(name) {
+  const value = process.env[name];
+  return value && value.trim().length > 0 ? value : void 0;
+}
+function normalizeBaseUrl(url) {
+  return url.replace(/\/$/, "");
+}
+function resolveIssuer() {
+  return normalizeBaseUrl(
+    env("GEEKAPPS_AUTH_ISSUER") ?? env("GEEKAPPS_AUTH_API_URL") ?? "http://localhost:3020"
+  );
+}
+function getServerClientHeaders() {
+  const clientId = env("GEEKAPPS_AUTH_CLIENT_ID");
+  const clientSecret = env("GEEKAPPS_AUTH_CLIENT_SECRET");
+  return clientId && clientSecret ? {
+    "x-geekapps-client-id": clientId,
+    "x-geekapps-client-secret": clientSecret
+  } : {};
+}
+function hashClientId(clientId) {
+  let h = 5381;
+  for (let i = 0; i < clientId.length; i++) {
+    h = (h << 5) + h ^ clientId.charCodeAt(i) & 255;
+    h = h >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function deriveCookiePrefix() {
+  const clientId = env("GEEKAPPS_AUTH_CLIENT_ID") ?? "";
+  if (!clientId) return "gk";
+  return `gk_${hashClientId(clientId)}`;
+}
+function decodeMeta(value) {
+  try {
+    const m = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    return m.id ? m : null;
+  } catch {
+    return null;
+  }
+}
+async function getCookieNames() {
+  const prefix = deriveCookiePrefix();
+  return {
+    active: `${prefix}_active`,
+    count: `${prefix}_count`,
+    activeOrganizationId: `${prefix}_ao`,
+    slotMeta: (n) => `${prefix}_m${n}`,
+    slotAt: (n) => `${prefix}_at${n}`,
+    slotRt: (n) => `${prefix}_rt${n}`
+  };
+}
+async function getActiveAccessToken() {
+  const cookieStore = await cookies();
+  const cn = await getCookieNames();
+  const raw = cookieStore.get(cn.active)?.value;
+  const activeIdx = raw ? Number.parseInt(raw, 10) : 0;
+  const countRaw = cookieStore.get(cn.count)?.value;
+  const count = countRaw ? Number.parseInt(countRaw, 10) : 0;
+  if (count === 0) return null;
+  const idx = activeIdx >= 1 && activeIdx <= count ? activeIdx : 1;
+  return cookieStore.get(cn.slotAt(idx))?.value ?? null;
+}
+async function getActiveRefreshToken() {
+  const cookieStore = await cookies();
+  const cn = await getCookieNames();
+  const raw = cookieStore.get(cn.active)?.value;
+  const activeIdx = raw ? Number.parseInt(raw, 10) : 0;
+  const countRaw = cookieStore.get(cn.count)?.value;
+  const count = countRaw ? Number.parseInt(countRaw, 10) : 0;
+  if (count === 0) return null;
+  const idx = activeIdx >= 1 && activeIdx <= count ? activeIdx : 1;
+  return cookieStore.get(cn.slotRt(idx))?.value ?? null;
+}
+async function refreshAndSaveTokens() {
+  const refreshToken = await getActiveRefreshToken();
+  const clientId = env("GEEKAPPS_AUTH_CLIENT_ID") ?? "";
+  const clientSecret = env("GEEKAPPS_AUTH_CLIENT_SECRET") ?? "";
+  if (!refreshToken || !clientId) return null;
+  const basicAuth = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");
+  const response = await fetch(`${resolveIssuer()}/auth/refresh`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/x-www-form-urlencoded",
+      authorization: `Basic ${basicAuth}`
+    },
+    body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: refreshToken }),
+    cache: "no-store"
+  });
+  if (!response.ok) return null;
+  const data = await response.json().catch(() => null);
+  if (!data) return null;
+  const newAccessToken = data.accessToken ?? data.access_token;
+  const newRefreshToken = data.refreshToken ?? data.refresh_token;
+  if (!newAccessToken) return null;
+  const cookieStore = await cookies();
+  const cn = await getCookieNames();
+  const raw = cookieStore.get(cn.active)?.value;
+  const activeIdx = raw ? Number.parseInt(raw, 10) : 1;
+  const opts = {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax",
+    path: "/",
+    maxAge: 60 * 60 * 24 * 30
+  };
+  cookieStore.set(cn.slotAt(activeIdx), newAccessToken, opts);
+  if (newRefreshToken) cookieStore.set(cn.slotRt(activeIdx), newRefreshToken, opts);
+  cookieStore.set(`${deriveCookiePrefix()}_tp`, newAccessToken, {
+    httpOnly: false,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax",
+    path: "/",
+    maxAge: 60 * 60 * 24 * 30
+  });
+  return newAccessToken;
+}
+async function authFetch(path) {
+  let accessToken = await getActiveAccessToken();
+  if (!accessToken) throw new Error("Not authenticated");
+  const issuer = resolveIssuer();
+  const doFetch = (token) => fetch(`${issuer}${path}`, {
+    headers: {
+      authorization: `Bearer ${token}`,
+      ...getServerClientHeaders()
+    },
+    cache: "no-store"
+  });
+  let response = await doFetch(accessToken);
+  if (response.status === 401) {
+    const newToken = await refreshAndSaveTokens();
+    if (!newToken) throw new Error("Session expired");
+    response = await doFetch(newToken);
+  }
+  if (!response.ok) {
+    const err = await response.json().catch(() => null);
+    throw new Error(err?.error_description ?? err?.error ?? err?.message ?? `Auth error ${response.status}`);
+  }
+  if (response.status === 204) return null;
+  return response.json();
+}
+async function getMe() {
+  try {
+    const data = await authFetch("/auth/me");
+    if (!data) return { user: null };
+    if (typeof data === "object" && "user" in data) return data;
+    return { user: data };
+  } catch {
+    return { user: null };
+  }
+}
+async function getAccounts() {
+  const cookieStore = await cookies();
+  const cn = await getCookieNames();
+  const countRaw = cookieStore.get(cn.count)?.value;
+  const count = countRaw ? Number.parseInt(countRaw, 10) : 0;
+  const activeRaw = cookieStore.get(cn.active)?.value;
+  const activeIdx = activeRaw ? Number.parseInt(activeRaw, 10) : 0;
+  const accounts = [];
+  for (let i = 1; i <= count; i++) {
+    const at = cookieStore.get(cn.slotAt(i))?.value;
+    if (!at) continue;
+    const meta = decodeMeta(cookieStore.get(cn.slotMeta(i))?.value ?? "");
+    if (!meta) continue;
+    accounts.push({
+      id: meta.id,
+      sessionId: meta.sid ?? meta.id,
+      isActive: i === activeIdx,
+      user: {
+        id: meta.id,
+        name: meta.n ?? null,
+        email: meta.e ?? null,
+        imageUrl: meta.p ?? null,
+        phone: null
+      }
+    });
+  }
+  return { accounts };
+}
+async function getOrganizations() {
+  try {
+    const cookieStore = await cookies();
+    const cn = await getCookieNames();
+    const activeOrgId = cookieStore.get(cn.activeOrganizationId)?.value ?? null;
+    const data = await authFetch("/organizations");
+    const organizations = Array.isArray(data) ? data : data.organizations;
+    const resolvedOrgId = activeOrgId ?? organizations[0]?.id ?? null;
+    return { organizations, currentOrgId: resolvedOrgId };
+  } catch (err) {
+    console.error("[getOrganizations] error:", err);
+    return { organizations: [] };
+  }
+}
+
+// src/client.tsx
+import { jsx } from "react/jsx-runtime";
+function normalizeBasePath(basePath) {
+  return basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+}
+function buildUrl(basePath, path) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${normalizeBasePath(basePath)}${normalizedPath}`;
+}
+async function parseError(response) {
+  const data = await response.json().catch(() => null);
+  return data?.error_description ?? data?.error ?? data?.message ?? `Request failed with status ${response.status}`;
+}
+function redirectTo(path) {
+  window.location.assign(path);
+}
+function isMouseEvent(value) {
+  return Boolean(value && typeof value === "object" && "preventDefault" in value);
+}
+function normalizeSignInOptions(input) {
+  if (!input) return void 0;
+  if (isMouseEvent(input)) {
+    input.preventDefault();
+    return void 0;
+  }
+  return input;
+}
+async function clientRequest(path, options = {}, basePath = "/api/auth") {
+  const response = await fetch(buildUrl(basePath, path), {
+    body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+    credentials: "include",
+    headers: options.body === void 0 ? void 0 : {
+      "content-type": "application/json"
+    },
+    method: options.method ?? "GET"
+  });
+  if (!response.ok) {
+    throw new Error(await parseError(response));
+  }
+  if (response.status === 204) {
+    return null;
+  }
+  return await response.json();
+}
+async function toStandaloneAuthResult(fn) {
+  try {
+    return {
+      success: true,
+      data: await fn()
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Auth request failed"
+    };
+  }
+}
+async function loginWithPassword(params, options) {
+  return toStandaloneAuthResult(async () => {
+    const data = await clientRequest(
+      "/login/password",
+      {
+        body: params,
+        method: "POST"
+      },
+      options?.basePath
+    );
+    if (params.redirectTo ?? data.redirectTo) {
+      redirectTo(params.redirectTo ?? data.redirectTo);
+    }
+    return data;
+  });
+}
+async function registerWithPassword(params, options) {
+  return toStandaloneAuthResult(async () => {
+    const data = await clientRequest(
+      "/register/password",
+      {
+        body: params,
+        method: "POST"
+      },
+      options?.basePath
+    );
+    if (params.redirectTo) {
+      redirectTo(params.redirectTo);
+    }
+    return data;
+  });
+}
+function startGoogleLogin(params, options) {
+  const basePath = options?.basePath ?? "/api/auth";
+  const url = new URL(buildUrl(basePath, "/login/google"), window.location.origin);
+  if (params?.callbackUrl) {
+    url.searchParams.set("callbackUrl", params.callbackUrl);
+  }
+  if (params?.redirectTo) {
+    url.searchParams.set("redirectTo", params.redirectTo);
+  }
+  if (params?.authorizationFlowId) {
+    url.searchParams.set("flow_id", params.authorizationFlowId);
+  }
+  redirectTo(url.toString());
+}
+async function requestPasswordlessLink(params, options) {
+  return toStandaloneAuthResult(
+    () => clientRequest(
+      "/passwordless/link",
+      {
+        body: params,
+        method: "POST"
+      },
+      options?.basePath
+    )
+  );
+}
+var GeekappsAuthContext = createContext(null);
+function GeekappsAuthProvider({
+  children,
+  basePath = "/api/auth",
+  initialUser = null,
+  initialOrganizations = [],
+  initialCurrentOrgId = null
+}) {
+  const [user, setUser] = useState(initialUser);
+  const [isLoading, setIsLoading] = useState(true);
+  const [accounts, setAccounts] = useState([]);
+  const [isLoadingAccounts, setIsLoadingAccounts] = useState(true);
+  const [organizations, setOrganizations] = useState(initialOrganizations);
+  const [currentOrgId, setCurrentOrgId] = useState(initialCurrentOrgId);
+  const [isLoadingOrganizations, setIsLoadingOrganizations] = useState(true);
+  const request = useCallback(
+    async (path, options = {}) => {
+      const response = await fetch(buildUrl(basePath, path), {
+        method: options.method ?? "GET",
+        credentials: "include",
+        headers: options.body === void 0 ? void 0 : {
+          "content-type": "application/json"
+        },
+        body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+      });
+      if (!response.ok) {
+        throw new Error(await parseError(response));
+      }
+      if (response.status === 204) {
+        return null;
+      }
+      return await response.json();
+    },
+    [basePath]
+  );
+  const refreshUser = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      const { user: u } = await getMe();
+      setUser(u);
+    } catch {
+      setUser(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const refreshAccounts = useCallback(async () => {
+    setIsLoadingAccounts(true);
+    try {
+      const { accounts: a } = await getAccounts();
+      setAccounts(a);
+    } catch {
+      setAccounts([]);
+    } finally {
+      setIsLoadingAccounts(false);
+    }
+  }, []);
+  const refreshOrganizations = useCallback(async () => {
+    setIsLoadingOrganizations(true);
+    try {
+      const { organizations: orgs, currentOrgId: nextCurrentOrgId } = await getOrganizations();
+      setOrganizations(orgs);
+      setCurrentOrgId((current) => {
+        if (nextCurrentOrgId !== void 0) return nextCurrentOrgId ?? null;
+        if (current && orgs.some((org) => org.id === current)) return current;
+        return orgs[0]?.id ?? null;
+      });
+    } catch {
+      setOrganizations([]);
+      setCurrentOrgId(null);
+    } finally {
+      setIsLoadingOrganizations(false);
+    }
+  }, []);
+  useEffect(() => {
+    void refreshUser();
+    void refreshAccounts();
+    void refreshOrganizations();
+  }, [refreshAccounts, refreshOrganizations, refreshUser]);
+  const currentOrg = useMemo(
+    () => organizations.find((organization) => organization.id === currentOrgId) ?? null,
+    [currentOrgId, organizations]
+  );
+  const setCurrentOrg = useCallback(
+    async (organizationId) => {
+      await request("/organizations/active", {
+        method: "POST",
+        body: { organizationId }
+      });
+      setCurrentOrgId(organizationId);
+    },
+    [request]
+  );
+  const signIn = useCallback(
+    async (input) => {
+      const options = normalizeSignInOptions(input);
+      const url = new URL(buildUrl(basePath, "/sign-in"), window.location.origin);
+      if (options?.redirectTo) url.searchParams.set("redirectTo", options.redirectTo);
+      if (options?.authorizationFlowId) url.searchParams.set("flow_id", options.authorizationFlowId);
+      redirectTo(url.toString());
+    },
+    [basePath]
+  );
+  const signUp = useCallback(
+    async (input) => {
+      const options = normalizeSignInOptions(input);
+      const url = new URL(buildUrl(basePath, "/sign-up"), window.location.origin);
+      if (options?.redirectTo) url.searchParams.set("redirectTo", options.redirectTo);
+      if (options?.authorizationFlowId) url.searchParams.set("flow_id", options.authorizationFlowId);
+      redirectTo(url.toString());
+    },
+    [basePath]
+  );
+  const addAccount = useCallback(
+    async (input) => {
+      const options = normalizeSignInOptions(input);
+      const url = new URL(buildUrl(basePath, "/add-account"), window.location.origin);
+      if (options?.redirectTo) url.searchParams.set("redirectTo", options.redirectTo);
+      redirectTo(url.toString());
+    },
+    [basePath]
+  );
+  const signOut = useCallback(async () => {
+    await request("/sign-out", { method: "POST" });
+    setUser(null);
+    await refreshAccounts();
+  }, [refreshAccounts, request]);
+  const signOutAll = useCallback(async () => {
+    await request("/sign-out-all", { method: "POST" });
+    setUser(null);
+    setAccounts([]);
+  }, [request]);
+  const switchAccount = useCallback(
+    async (sessionId, options) => {
+      await request("/accounts/switch", {
+        method: "POST",
+        body: { sessionId }
+      });
+      await Promise.all([refreshUser(), refreshAccounts(), refreshOrganizations()]);
+      if (options?.redirectTo) redirectTo(options.redirectTo);
+    },
+    [refreshAccounts, refreshOrganizations, refreshUser, request]
+  );
+  async function toAuthResult(fn) {
+    try {
+      return { success: true, data: await fn() };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : "Unexpected error" };
+    }
+  }
+  const value = useMemo(
+    () => ({
+      basePath,
+      user,
+      isLoading,
+      accounts,
+      isLoadingAccounts,
+      organizations,
+      currentOrg,
+      currentOrgId,
+      isLoadingOrganizations,
+      request,
+      signIn,
+      signUp,
+      addAccount,
+      signOut,
+      signOutAll,
+      refreshUser,
+      refreshAccounts,
+      switchAccount,
+      loginWithPassword: (params) => toAuthResult(async () => {
+        const data = await request("/login/password", { method: "POST", body: params });
+        await Promise.all([refreshUser(), refreshAccounts(), refreshOrganizations()]);
+        if (params.redirectTo ?? data.redirectTo) redirectTo(params.redirectTo ?? data.redirectTo);
+        return data;
+      }),
+      registerWithPassword: (params) => toAuthResult(async () => {
+        const data = await request("/register/password", { method: "POST", body: params });
+        await Promise.all([refreshUser(), refreshAccounts(), refreshOrganizations()]);
+        if (params.redirectTo) redirectTo(params.redirectTo);
+        return data;
+      }),
+      startGoogleLogin: (params) => {
+        const url = new URL(buildUrl(basePath, "/login/google"), window.location.origin);
+        if (params?.callbackUrl) url.searchParams.set("callbackUrl", params.callbackUrl);
+        if (params?.redirectTo) url.searchParams.set("redirectTo", params.redirectTo);
+        if (params?.authorizationFlowId) url.searchParams.set("flow_id", params.authorizationFlowId);
+        redirectTo(url.toString());
+      },
+      requestPasswordlessLink: (params) => toAuthResult(() => request("/passwordless/link", { method: "POST", body: params })),
+      refreshOrganizations,
+      setCurrentOrg,
+      createOrganization: (input) => toAuthResult(async () => {
+        const organization = await request("/organizations", { method: "POST", body: input });
+        await refreshOrganizations();
+        setCurrentOrgId(organization.id);
+        return organization;
+      }),
+      updateOrganization: (id, input) => toAuthResult(async () => {
+        const organization = await request(`/organizations/${id}`, { method: "PATCH", body: input });
+        await refreshOrganizations();
+        return organization;
+      }),
+      deleteOrganization: (id) => toAuthResult(async () => {
+        await request(`/organizations/${id}`, { method: "DELETE" });
+        await refreshOrganizations();
+        return null;
+      }),
+      hasPermission: async (options) => {
+        try {
+          const data = await request("/permissions/check", {
+            method: "POST",
+            body: options
+          });
+          return data.allowed;
+        } catch {
+          return false;
+        }
+      },
+      listUsers: (params) => {
+        const query = new URLSearchParams();
+        if (params?.organizationId) query.set("organizationId", params.organizationId);
+        return request(`/users${query.size ? `?${query.toString()}` : ""}`);
+      },
+      getUser: (id) => request(`/users/${id}`),
+      createUser: (input) => toAuthResult(() => request("/users", { method: "POST", body: input })),
+      updateUser: (id, input) => toAuthResult(() => request(`/users/${id}`, { method: "PATCH", body: input })),
+      deleteUser: (id) => toAuthResult(async () => {
+        await request(`/users/${id}`, { method: "DELETE" });
+        return null;
+      }),
+      listRoles: (params) => {
+        const query = new URLSearchParams();
+        if (params?.organizationId) query.set("organizationId", params.organizationId);
+        if (params?.applicationId) query.set("applicationId", params.applicationId);
+        if (params?.type) query.set("type", params.type);
+        return request(`/roles${query.size ? `?${query.toString()}` : ""}`);
+      },
+      getRole: (id, type) => request(type === "custom" ? `/roles/custom/${id}` : `/roles/definitions/${id}`),
+      createRole: (input) => toAuthResult(() => request("/roles", { method: "POST", body: input })),
+      updateRole: (id, input) => toAuthResult(() => request(`/roles/custom/${id}`, { method: "PATCH", body: input })),
+      deleteRole: (id) => toAuthResult(async () => {
+        await request(`/roles/custom/${id}`, { method: "DELETE" });
+        return null;
+      }),
+      listPermissions: (params) => {
+        const query = new URLSearchParams();
+        if (params?.applicationId) query.set("applicationId", params.applicationId);
+        if (params?.roleId) query.set("roleId", params.roleId);
+        return request(`/permissions${query.size ? `?${query.toString()}` : ""}`);
+      },
+      createPermission: (input) => toAuthResult(() => request("/permissions", { method: "POST", body: input })),
+      updatePermission: (id, input) => toAuthResult(() => request(`/permissions/${id}`, { method: "PATCH", body: input })),
+      deletePermission: (id) => toAuthResult(async () => {
+        await request(`/permissions/${id}`, { method: "DELETE" });
+        return null;
+      }),
+      listUserSessions: (params) => {
+        const query = new URLSearchParams();
+        if (params?.userId) query.set("userId", params.userId);
+        if (params?.organizationId) query.set("organizationId", params.organizationId);
+        return request(`/sessions${query.size ? `?${query.toString()}` : ""}`);
+      },
+      revokeUserSession: (sessionId) => toAuthResult(async () => {
+        await request(`/sessions/${sessionId}`, { method: "DELETE" });
+        return null;
+      })
+    }),
+    [
+      accounts,
+      addAccount,
+      basePath,
+      currentOrg,
+      currentOrgId,
+      isLoading,
+      isLoadingAccounts,
+      isLoadingOrganizations,
+      organizations,
+      refreshAccounts,
+      refreshOrganizations,
+      refreshUser,
+      request,
+      setCurrentOrg,
+      signIn,
+      signOut,
+      signOutAll,
+      signUp,
+      switchAccount,
+      user
+    ]
+  );
+  return /* @__PURE__ */ jsx(GeekappsAuthContext.Provider, { value, children });
+}
+function useAuth() {
+  const context = useContext(GeekappsAuthContext);
+  if (!context) throw new Error("useAuth must be used inside GeekappsAuthProvider");
+  return context;
+}
+function useOrg() {
+  const context = useAuth();
+  return {
+    organizations: context.organizations,
+    currentOrg: context.currentOrg,
+    currentOrgId: context.currentOrgId,
+    isLoadingOrganizations: context.isLoadingOrganizations,
+    refreshOrganizations: context.refreshOrganizations,
+    setCurrentOrg: context.setCurrentOrg,
+    createOrganization: context.createOrganization,
+    updateOrganization: context.updateOrganization,
+    deleteOrganization: context.deleteOrganization,
+    hasPermission: context.hasPermission
+  };
+}
+function useAccounts() {
+  const context = useAuth();
+  return {
+    accounts: context.accounts,
+    addAccount: context.addAccount,
+    isLoadingAccounts: context.isLoadingAccounts,
+    refreshAccounts: context.refreshAccounts,
+    switchAccount: context.switchAccount
+  };
+}
+function useUsers() {
+  const context = useAuth();
+  return {
+    listUsers: context.listUsers,
+    getUser: context.getUser,
+    createUser: context.createUser,
+    updateUser: context.updateUser,
+    deleteUser: context.deleteUser
+  };
+}
+function useRoles() {
+  const context = useAuth();
+  return {
+    listRoles: context.listRoles,
+    getRole: context.getRole,
+    createRole: context.createRole,
+    updateRole: context.updateRole,
+    deleteRole: context.deleteRole
+  };
+}
+function usePermissions() {
+  const context = useAuth();
+  return {
+    listPermissions: context.listPermissions,
+    createPermission: context.createPermission,
+    updatePermission: context.updatePermission,
+    deletePermission: context.deletePermission
+  };
+}
+function useSessions() {
+  const context = useAuth();
+  return {
+    listUserSessions: context.listUserSessions,
+    revokeUserSession: context.revokeUserSession
+  };
+}
+function useServiceAccount() {
+  const { request } = useAuth();
+  const listServiceAccounts = useCallback(
+    (params) => {
+      const query = new URLSearchParams({ organizationId: params.organizationId });
+      if (params.applicationId) query.set("applicationId", params.applicationId);
+      return request(`/service-accounts?${query.toString()}`);
+    },
+    [request]
+  );
+  const createServiceAccount = useCallback(
+    (input) => request("/service-accounts", { method: "POST", body: input }),
+    [request]
+  );
+  const updateServiceAccountRole = useCallback(
+    async (id, roleId) => {
+      await request(`/service-accounts/${id}`, { method: "PATCH", body: { roleId } });
+    },
+    [request]
+  );
+  const revokeServiceAccount = useCallback(
+    async (id) => {
+      await request(`/service-accounts/${id}/revoke`, { method: "POST" });
+    },
+    [request]
+  );
+  const rotateServiceAccountSecret = useCallback(
+    (id) => request(`/service-accounts/${id}/rotate-secret`, {
+      method: "POST"
+    }),
+    [request]
+  );
+  const deleteServiceAccount = useCallback(
+    async (id) => {
+      await request(`/service-accounts/${id}`, { method: "DELETE" });
+    },
+    [request]
+  );
+  return {
+    listServiceAccounts,
+    createServiceAccount,
+    updateServiceAccountRole,
+    revokeServiceAccount,
+    rotateServiceAccountSecret,
+    deleteServiceAccount
+  };
+}
+export {
+  GeekappsAuthProvider,
+  loginWithPassword,
+  registerWithPassword,
+  requestPasswordlessLink,
+  startGoogleLogin,
+  useAccounts,
+  useAuth,
+  useOrg,
+  usePermissions,
+  useRoles,
+  useServiceAccount,
+  useSessions,
+  useUsers
+};
+//# sourceMappingURL=client.js.map