@neog-cloud/neog-api-client 0.1.2 → 0.1.4

package/dist/auth/AuthProvider.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { AuthContextType, AuthState } from "./types";
+import { AuthContextType, AuthState, UserInfo } from "./types";
 import { NeogAuthOptions } from "./options";
 export type AuthProviderFactory = {
     AuthProvider: React.FC<{
@@ -7,6 +7,7 @@ export type AuthProviderFactory = {
     }>;
     useAuth: () => AuthContextType;
     getToken: () => string | null;
+    getUser: () => UserInfo;
     setToken: (token: string | null, refreshToken?: string | null, user?: AuthState["user"]) => void;
     logout: () => void;
     refreshAccessToken: () => Promise<string | null>;

package/dist/auth/options.d.ts

@@ -2,6 +2,7 @@ export type NeogAuthOptions = {
     baseUrl: string;
     authBaseUrl?: string;
     authRealm?: string;
+    userInfoEndpoint?: string;
     authEndpoint: string;
     authRequestFormat?: "json" | "form";
     authGrantType?: string;

package/dist/auth/storage.d.ts

@@ -1,12 +1,9 @@
+import { UserInfo } from "./types";
 export interface StoredAuthState {
     accessToken: string | null;
     refreshToken?: string | null;
     expiresAt?: number | null;
-    user?: {
-        id: string;
-        name?: string;
-        email?: string;
-    } | null;
+    user?: UserInfo;
 }
 export declare const saveAuthState: (storageKey: string, state: StoredAuthState) => void;
 export declare const loadAuthState: (storageKey: string) => StoredAuthState | null;

package/dist/auth/types.d.ts

@@ -1,27 +1,40 @@
+export type ApiLocation = {
+    host: string;
+    api_url: string;
+};
+export type NeogApiUrl = {
+    location?: ApiLocation[];
+    url?: string;
+};
+export type UserInfo = {
+    id?: string;
+    sub?: string;
+    name?: string;
+    email?: string;
+    preferred_username?: string;
+    given_name?: string;
+    family_name?: string;
+    comp_refid?: string;
+    permissions?: unknown;
+    neog_api_url?: NeogApiUrl;
+    [key: string]: unknown;
+} | null;
 export interface AuthContextType {
     token: string | null;
     refreshToken?: string | null;
-    user?: {
-        id: string;
-        name?: string;
-        email?: string;
-    } | null;
+    user?: UserInfo;
     isAuthenticated: boolean;
     loading: boolean;
     error?: string | null;
     login: (username: string, password: string) => Promise<void>;
     logout: () => void;
     getToken: () => string | null;
-    setToken?: (token: string, refreshToken?: string) => void;
+    setToken?: (token: string | null, refreshToken?: string | null, user?: UserInfo) => void;
 }
 export type AuthState = {
     token: string | null;
     refreshToken?: string | null;
-    user?: {
-        id: string;
-        name?: string;
-        email?: string;
-    } | null;
+    user?: UserInfo;
     isAuthenticated: boolean;
 };
 export type TokenResponse = {
@@ -29,9 +42,5 @@ export type TokenResponse = {
     refresh_token?: string;
     expires_in?: number;
     expires_at?: number;
-    user?: {
-        id: string;
-        name?: string;
-        email?: string;
-    } | null;
+    user?: UserInfo;
 };

package/dist/client/neogClient.d.ts

@@ -5,6 +5,7 @@ export type GetTokenHandler = () => string | null;
 export type LogoutHandler = () => void;
 export type CreateClientDeps = {
     baseUrl: string;
+    baseUrlResolver?: () => string;
     getToken: GetTokenHandler;
     refreshToken: RefreshTokenHandler;
     logout: LogoutHandler;

package/dist/index.cjs

@@ -1391,6 +1391,8 @@ const getErrorMessage = (error, fallback = "Erro ao processar a requisição") =
     return fallback;
 };
 
+const USERINFO_ERROR_MESSAGE = "Nao foi possivel carregar dados do usuario";
+const USERINFO_RETRY_DELAY_MS = 500;
 const resolveExpiresAt = (data) => {
     if (data.expires_at)
         return data.expires_at;
@@ -1398,18 +1400,24 @@ const resolveExpiresAt = (data) => {
         return Date.now() + data.expires_in * 1000;
     return null;
 };
+const resolveEndpoint = (template, realm) => {
+    if (!realm)
+        return template;
+    return template.replace("{realm}", realm).replace(":realm", realm);
+};
 const createAuthProvider = (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     const storageKey = (_a = options.storageKey) !== null && _a !== void 0 ? _a : "neog_auth";
     const authBaseUrl = (_b = options.authBaseUrl) !== null && _b !== void 0 ? _b : options.baseUrl;
     const authRequestFormat = (_c = options.authRequestFormat) !== null && _c !== void 0 ? _c : "form";
     const authGrantType = (_d = options.authGrantType) !== null && _d !== void 0 ? _d : "password";
     const authScope = (_e = options.authScope) !== null && _e !== void 0 ? _e : "openid profile email";
+    const userInfoEndpoint = (_f = options.userInfoEndpoint) !== null && _f !== void 0 ? _f : "/realms/{realm}/protocol/openid-connect/userinfo";
     const stored = loadAuthState(storageKey);
     const initialState = {
-        token: (_f = stored === null || stored === void 0 ? void 0 : stored.accessToken) !== null && _f !== void 0 ? _f : null,
-        refreshToken: (_g = stored === null || stored === void 0 ? void 0 : stored.refreshToken) !== null && _g !== void 0 ? _g : null,
-        user: (_h = stored === null || stored === void 0 ? void 0 : stored.user) !== null && _h !== void 0 ? _h : null,
+        token: (_g = stored === null || stored === void 0 ? void 0 : stored.accessToken) !== null && _g !== void 0 ? _g : null,
+        refreshToken: (_h = stored === null || stored === void 0 ? void 0 : stored.refreshToken) !== null && _h !== void 0 ? _h : null,
+        user: (_j = stored === null || stored === void 0 ? void 0 : stored.user) !== null && _j !== void 0 ? _j : null,
         isAuthenticated: Boolean(stored === null || stored === void 0 ? void 0 : stored.accessToken),
     };
     const AuthContext = require$$0.createContext(undefined);
@@ -1427,6 +1435,7 @@ const createAuthProvider = (options) => {
         saveAuthState(storageKey, payload);
     };
     const getToken = () => authRef.current.token;
+    const getUser = () => { var _a; return (_a = authRef.current.user) !== null && _a !== void 0 ? _a : null; };
     const setToken = (token, refreshToken, user) => {
         var _a, _b, _c, _d, _e;
         authRef.current = {
@@ -1444,6 +1453,32 @@ const createAuthProvider = (options) => {
         clearAuthState(storageKey);
         (_a = stateSetterRef.current) === null || _a === void 0 ? void 0 : _a.call(stateSetterRef, authRef.current);
     };
+    const fetchUserInfo = async (accessToken) => {
+        var _a, _b;
+        const endpoint = resolveEndpoint(userInfoEndpoint, options.authRealm);
+        const url = `${authBaseUrl}${endpoint}`;
+        try {
+            const response = await axios.get(url, {
+                headers: { Authorization: `Bearer ${accessToken}` },
+                timeout: options.requestTimeoutMs,
+            });
+            return response.data;
+        }
+        catch (err) {
+            const message = getErrorMessage(err, "Falha ao carregar userinfo");
+            const status = axios.isAxiosError(err) ? (_a = err.response) === null || _a === void 0 ? void 0 : _a.status : undefined;
+            (_b = options.onErrorLog) === null || _b === void 0 ? void 0 : _b.call(options, { url, status, message });
+            return null;
+        }
+    };
+    const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const fetchUserInfoWithRetry = async (accessToken) => {
+        const info = await fetchUserInfo(accessToken);
+        if (info)
+            return info;
+        await wait(USERINFO_RETRY_DELAY_MS);
+        return fetchUserInfo(accessToken);
+    };
     const refreshAccessToken = async () => {
         if (!options.tokenRefreshEndpoint)
             return null;
@@ -1565,8 +1600,36 @@ const createAuthProvider = (options) => {
             }
             void handleRefreshIfExpired();
         }, [handleRefreshIfExpired]);
+        require$$0.useEffect(() => {
+            if (!state.token || state.user)
+                return;
+            let cancelled = false;
+            void (async () => {
+                var _a, _b;
+                const info = await fetchUserInfoWithRetry(state.token);
+                if (cancelled)
+                    return;
+                if (!info) {
+                    handleLogout();
+                    if (isMounted.current) {
+                        setError(USERINFO_ERROR_MESSAGE);
+                    }
+                    return;
+                }
+                const nextState = {
+                    token: authRef.current.token,
+                    refreshToken: authRef.current.refreshToken,
+                    user: info,
+                    isAuthenticated: Boolean(authRef.current.token),
+                };
+                syncState(nextState, (_b = (_a = loadAuthState(storageKey)) === null || _a === void 0 ? void 0 : _a.expiresAt) !== null && _b !== void 0 ? _b : null);
+            })();
+            return () => {
+                cancelled = true;
+            };
+        }, [state.token, state.user, syncState, handleLogout]);
         const login = require$$0.useCallback(async (username, password) => {
-            var _a, _b, _c;
+            var _a, _b;
             setLoading(true);
             setError(null);
             try {
@@ -1600,7 +1663,13 @@ const createAuthProvider = (options) => {
                 const token = data.access_token;
                 const refreshToken = (_b = data.refresh_token) !== null && _b !== void 0 ? _b : null;
                 const expiresAt = resolveExpiresAt(data);
-                const user = (_c = data.user) !== null && _c !== void 0 ? _c : null;
+                const userInfo = token ? await fetchUserInfoWithRetry(token) : null;
+                if (token && !userInfo) {
+                    handleLogout();
+                    setError(USERINFO_ERROR_MESSAGE);
+                    throw new Error(USERINFO_ERROR_MESSAGE);
+                }
+                const user = userInfo !== null && userInfo !== void 0 ? userInfo : null;
                 const nextState = {
                     token,
                     refreshToken,
@@ -1629,6 +1698,7 @@ const createAuthProvider = (options) => {
             authRequestFormat,
             authGrantType,
             authScope,
+            handleLogout,
         ]);
         const contextValue = require$$0.useMemo(() => {
             var _a, _b;
@@ -1642,12 +1712,12 @@ const createAuthProvider = (options) => {
                 login,
                 logout: handleLogout,
                 getToken: () => authRef.current.token,
-                setToken: (token, refreshToken) => {
+                setToken: (token, refreshToken, user) => {
                     var _a, _b, _c;
                     const nextState = {
                         token,
                         refreshToken: refreshToken !== null && refreshToken !== void 0 ? refreshToken : null,
-                        user: (_a = authRef.current.user) !== null && _a !== void 0 ? _a : null,
+                        user: (_a = user !== null && user !== void 0 ? user : authRef.current.user) !== null && _a !== void 0 ? _a : null,
                         isAuthenticated: Boolean(token),
                     };
                     syncState(nextState, (_c = (_b = loadAuthState(storageKey)) === null || _b === void 0 ? void 0 : _b.expiresAt) !== null && _c !== void 0 ? _c : null);
@@ -1667,6 +1737,7 @@ const createAuthProvider = (options) => {
         AuthProvider,
         useAuth,
         getToken,
+        getUser,
         setToken,
         logout,
         refreshAccessToken,
@@ -1689,7 +1760,7 @@ const shouldRetry = (config) => {
 const createNeogClient = (deps, opts) => {
     var _a;
     const instance = axios.create({
-        baseURL: deps.baseUrl,
+        baseURL: deps.baseUrlResolver ? deps.baseUrlResolver() : deps.baseUrl,
         timeout: (_a = opts === null || opts === void 0 ? void 0 : opts.timeoutMs) !== null && _a !== void 0 ? _a : deps.requestTimeoutMs,
         headers: {
             ...deps.defaultHeaders,
@@ -1697,13 +1768,16 @@ const createNeogClient = (deps, opts) => {
         },
     });
     instance.interceptors.request.use((config) => {
-        var _a, _b;
+        var _a, _b, _c;
+        if (deps.baseUrlResolver) {
+            config.baseURL = (_a = deps.baseUrlResolver()) !== null && _a !== void 0 ? _a : deps.baseUrl;
+        }
         if (config.url && config.method) {
-            (_a = deps.onRequestLog) === null || _a === void 0 ? void 0 : _a.call(deps, { url: config.url, method: config.method });
+            (_b = deps.onRequestLog) === null || _b === void 0 ? void 0 : _b.call(deps, { url: config.url, method: config.method });
         }
         const token = deps.getToken();
         if (token) {
-            const headers = axios.AxiosHeaders.from(((_b = config.headers) !== null && _b !== void 0 ? _b : {}));
+            const headers = axios.AxiosHeaders.from(((_c = config.headers) !== null && _c !== void 0 ? _c : {}));
             headers.set("Authorization", `Bearer ${token}`);
             config.headers = headers;
         }
@@ -1764,10 +1838,41 @@ const createNeogClient = (deps, opts) => {
     };
 };
 
+const getHostname = () => {
+    if (typeof window === "undefined")
+        return null;
+    return window.location.hostname;
+};
+const getApiUrl = (user, defaultUrl) => {
+    try {
+        if (!(user === null || user === void 0 ? void 0 : user.neog_api_url)) {
+            return defaultUrl;
+        }
+        const currentHostname = getHostname();
+        if (currentHostname && Array.isArray(user.neog_api_url.location)) {
+            const matchingLocation = user.neog_api_url.location.find((location) => location.host === currentHostname);
+            if (matchingLocation === null || matchingLocation === void 0 ? void 0 : matchingLocation.api_url) {
+                return matchingLocation.api_url;
+            }
+        }
+        if (user.neog_api_url.url) {
+            return user.neog_api_url.url;
+        }
+        return defaultUrl;
+    }
+    catch (error) {
+        if (typeof console !== "undefined") {
+            console.warn("Error determining API URL, using default:", error);
+        }
+        return defaultUrl;
+    }
+};
+
 function createNeogAuth(options) {
-    const { AuthProvider, useAuth, getToken, logout, refreshAccessToken } = createAuthProvider(options);
+    const { AuthProvider, useAuth, getToken, getUser, logout, refreshAccessToken } = createAuthProvider(options);
     const createNeogClient$1 = (opts) => createNeogClient({
         baseUrl: options.baseUrl,
+        baseUrlResolver: () => getApiUrl(getUser(), options.baseUrl),
         getToken,
         refreshToken: refreshAccessToken,
         logout,