@intra-mart/smartlime 2.1.1 → 2.2.0-dev.20250408

package/lib/packages/Me/type.d.ts

@@ -54,6 +54,7 @@ export interface Me {
     calendarId: string;
     firstDayOfWeek: 1 | 2 | 3 | 4 | 5 | 6 | 7;
     locale: string;
+    roleIds: string[];
     tenantId: string;
     timeZone: string;
     userCd: string;

package/lib/packages/Session/index.js

@@ -37,25 +37,30 @@ const useSessionStateRef = (renderTarget) => {
 };
 const useLogout = () => {
     const imFetch = useIMFetch({ noValidate: true });
-    return useCallback((cookie) => {
-        imFetch('/logout', {
+    return useCallback(async (cookie) => {
+        const headers = cookie
+            ? { Cookie: cookie }
+            : {};
+        await imFetch('/logout', {
             credentials: 'include',
-            headers: {
-                Cookie: cookie,
-            },
+            headers: headers,
             method: 'GET',
         });
-    }, []);
+    }, [imFetch]);
 };
 const makeEncodeParams = (clientTypeId = 'pc') => {
     return `${`clientTypeId=${encodeURIComponent(clientTypeId)}`}`;
 };
-const useRequest = (setter, getter) => {
+const useRequest = (setter, getter, logout) => {
     const imFetch = useIMFetch();
-    const logout = useLogout();
     const request = useCallback(async (clientTypeId) => {
         try {
             const currentCookies = getter()?.cookies;
+            const cookie = currentCookies ? makeCookie(currentCookies) : null;
+            // previous session may still be active, so execute the logout process
+            await logout();
+            if (cookie)
+                await logout(cookie);
             const params = makeEncodeParams(clientTypeId);
             const response = await imFetch(`api/bearer/smacolow/session?${params}`, {
                 credentials: 'include',
@@ -71,8 +76,6 @@ const useRequest = (setter, getter) => {
                     const cookie = response.headers.get('Set-Cookie');
                     if (cookie) {
                         setter(cookie);
-                        if (currentCookies)
-                            logout(makeCookie(currentCookies));
                         return { status: 'success' };
                     }
                     throw new IMSessionError('could not find sessionid from Set-Cookie in response header.');
@@ -86,20 +89,18 @@ const useRequest = (setter, getter) => {
     }, [imFetch]);
     return request;
 };
-const useDestroy = (renderTarget, setter, getter) => {
-    const logout = useLogout();
-    return useCallback(() => {
+const useDestroy = (renderTarget, setter, getter, logout) => {
+    return useCallback(async () => {
         const { cookies } = getter();
         if (cookies) {
-            logout(makeCookie(cookies));
+            await logout(makeCookie(cookies));
         }
         setter(null);
         renderTarget.dispatch();
     }, []);
 };
-const useGetSessionAsync = (request, destroy, getter) => {
+const useGetSessionAsync = (request, destroy, getter, logout) => {
     const imFetch = useIMFetch({ noValidate: true });
-    const logout = useLogout();
     const reRequest = async (count) => {
         const { status } = await request();
         if (status === 'success') {
@@ -127,7 +128,7 @@ const useGetSessionAsync = (request, destroy, getter) => {
                 return getter();
             }
             else {
-                logout(makeCookie(cookies));
+                await logout(makeCookie(cookies));
             }
         }
         const status = await reRequest(0);
@@ -137,8 +138,7 @@ const useGetSessionAsync = (request, destroy, getter) => {
         throw new IMSessionError('failed to get session.');
     }, [request]);
 };
-const unmountEffect = (getter) => {
-    const logout = useLogout();
+const unmountEffect = (getter, logout) => {
     const { cookies } = getter();
     useEffect(() => {
         return () => {
@@ -153,10 +153,11 @@ export const IMSession = ({ children, sessionContext }) => {
     const contextRef = useRef();
     const sessionStateRenderTarget = useRenderTarget();
     const [, setSession, getSession] = useSessionStateRef(sessionStateRenderTarget);
-    const request = useRequest(setSession, getSession);
-    const destroy = useDestroy(sessionStateRenderTarget, setSession, getSession);
-    const getSessionAsync = useGetSessionAsync(request, destroy, getSession);
-    unmountEffect(getSession);
+    const logout = useLogout();
+    const request = useRequest(setSession, getSession, logout);
+    const destroy = useDestroy(sessionStateRenderTarget, setSession, getSession, logout);
+    const getSessionAsync = useGetSessionAsync(request, destroy, getSession, logout);
+    unmountEffect(getSession, logout);
     contextRef.current = {
         getSession,
         getSessionAsync,

package/lib/packages/Tenant/Context.d.ts

@@ -1,12 +1,20 @@
-import { FetchModuleState, Moudles } from '.';
 import { RenderTarget } from '../../_shared/renderTarget';
+import { ModuleIds } from './modulesType';
+export interface IMModule {
+    moduleId: ModuleIds[number];
+    version: string;
+    enabled: boolean;
+    others: unknown;
+}
+export type IMModules = {
+    [key in ModuleIds[number]]: IMModule;
+};
 export interface TenantContext {
     getBaseUrl: () => string;
     getTenantId: () => string | undefined;
-    getFetchModuleState: () => FetchModuleState;
-    getModuleInfo: () => Moudles | undefined;
-    destroyModuleInfo: () => Promise<void>;
-    fetchModuleInfo: () => Promise<void>;
+    getModules: () => IMModules | undefined;
+    setModules: (state: IMModules, silent?: boolean) => void;
+    destroyModule: () => Promise<void>;
     modulesStateRenderTarget: RenderTarget;
 }
 export declare const Context: import("react").Context<TenantContext | null>;

package/lib/packages/Tenant/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const IM_MODULE_STORAGE_KEY = "IM_MODULE_STORAGE_KEY";
+export declare const createStorageKey: (baseUrl: string) => string;

package/lib/packages/Tenant/constants.js

@@ -0,0 +1,4 @@
+export const IM_MODULE_STORAGE_KEY = 'IM_MODULE_STORAGE_KEY';
+export const createStorageKey = (baseUrl) => {
+    return `${baseUrl}_${IM_MODULE_STORAGE_KEY}`;
+};

package/lib/packages/Tenant/hooks/index.d.ts

@@ -1,3 +1,3 @@
 export * from './useIMBaseUrl';
-export * from './useIMFetchModuleState';
-export * from './useIMModuleInfo';
+export * from './useIMModules';
+export * from './useIMModulesState';

package/lib/packages/Tenant/hooks/index.js

@@ -1,3 +1,3 @@
 export * from './useIMBaseUrl';
-export * from './useIMFetchModuleState';
-export * from './useIMModuleInfo';
+export * from './useIMModules';
+export * from './useIMModulesState';

package/lib/packages/Tenant/hooks/useIMModules.d.ts

@@ -0,0 +1,6 @@
+import { Context as DefaultContext, IMModules } from '../Context';
+export declare const useIMModules: (Context?: typeof DefaultContext) => {
+    request: () => Promise<void>;
+    getModules: () => IMModules | undefined;
+    destroy: () => Promise<void>;
+};

package/lib/packages/Tenant/hooks/useIMModules.js

@@ -0,0 +1,73 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { useContext, useMemo } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { createStorageKey } from '../constants';
+import { Context as DefaultContext } from '../Context';
+import { IMTenantError } from '../IMTenantError';
+import { MODULE_IDS } from '../modulesType';
+const saveModuleStorage = async (storageKey, Modules) => {
+    return await AsyncStorage.setItem(storageKey, JSON.stringify(Modules));
+};
+const getModuleStorage = async (storageKey) => {
+    const state = await AsyncStorage.getItem(storageKey);
+    if (state == null)
+        return;
+    const result = JSON.parse(state);
+    return result;
+};
+const createInitialModule = () => {
+    const initState = MODULE_IDS.reduce((acc, moduleId) => {
+        acc[moduleId] = {
+            moduleId: moduleId,
+            version: '',
+            enabled: false,
+            others: {},
+        };
+        return acc;
+    }, {});
+    return initState;
+};
+const useRequestModule = (baseUrl, setModules) => {
+    const IMFetch = useIMFetch();
+    return async () => {
+        const storageKey = createStorageKey(baseUrl);
+        const storageState = await getModuleStorage(storageKey);
+        if (storageState) {
+            setModules(storageState);
+        }
+        else {
+            const response = await IMFetch('api/smacolow/modules');
+            if (response.status !== 200) {
+                throw new IMTenantError('failed to fetch module status.');
+            }
+            const result = await response.json();
+            const state = result.data.modules.reduce((acc, module) => {
+                const { moduleId, moduleVersion } = module;
+                acc[moduleId] = {
+                    moduleId: moduleId,
+                    version: moduleVersion,
+                    enabled: true,
+                    others: {},
+                };
+                return acc;
+            }, createInitialModule());
+            saveModuleStorage(storageKey, state);
+            setModules(state);
+        }
+    };
+};
+export const useIMModules = (Context) => {
+    const tenantContext = useContext(Context || DefaultContext);
+    if (tenantContext == null) {
+        throw new IMTenantError('useIMModules requires either a Context provide or an ancestor element with a IMTenantProvider.');
+    }
+    const requestModule = useRequestModule(tenantContext.getBaseUrl(), tenantContext.setModules);
+    return useMemo(() => {
+        const { getModules, destroyModule } = tenantContext;
+        return {
+            request: requestModule,
+            getModules,
+            destroy: destroyModule,
+        };
+    }, [tenantContext]);
+};

package/lib/packages/Tenant/hooks/useIMModulesState.d.ts

@@ -0,0 +1,2 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useIMModulesState: (Context?: typeof DefaultContext) => import("../Context").IMModules | undefined;

package/lib/packages/Tenant/hooks/{useIMFetchModuleState.js → useIMModulesState.js}

@@ -1,12 +1,12 @@
 import { useContext, useEffect, useReducer, useRef } from 'react';
 import { Context as DefaultContext } from '../Context';
 import { IMTenantError } from '../IMTenantError';
-export const useIMFetchModuleState = (Context) => {
+export const useIMModulesState = (Context) => {
     const initRef = useRef(true);
     const [, forceRender] = useReducer((s) => s + 1, 0);
     const tenantContext = useContext(Context || DefaultContext);
     if (tenantContext == null) {
-        throw new IMTenantError('useIMFetchModuleState requires either a Context provide or an ancestor element with a IMTenantProvider.');
+        throw new IMTenantError('useIMModulesState requires either a Context provide or an ancestor element with a IMTenantProvider.');
     }
     if (initRef.current) {
         initRef.current = false;
@@ -17,6 +17,5 @@ export const useIMFetchModuleState = (Context) => {
             tenantContext.modulesStateRenderTarget.removeEventListener(forceRender);
         };
     }, []);
-    const state = tenantContext.getFetchModuleState();
-    return state;
+    return tenantContext.getModules();
 };

package/lib/packages/Tenant/index.d.ts

@@ -1,24 +1,12 @@
-import { Context as DefaultContext } from './Context';
-import { ModuleIds } from './modulesType';
+import { Context as DefaultContext, IMModules } from './Context';
 interface IMTenantProps {
     children: JSX.Element;
     baseUrl: string;
     tenantId?: string;
     tenantContext?: typeof DefaultContext;
-    useModuleInfo?: boolean;
 }
-export interface ModuleInfo<T extends ModuleIds[number]> {
-    moduleKey: T;
-    enabled: boolean;
-    othes: unknown;
-}
-export type Moudles = {
-    [key in ModuleIds[number]]: ModuleInfo<key>;
-};
-export type FetchModuleState = 'notRequired' | 'notFetched' | 'fetched';
 export interface ModuleState {
-    fetchModuleState: FetchModuleState;
-    modules?: Moudles;
+    modules?: IMModules;
 }
-export declare const IMTenant: ({ children, baseUrl, tenantId, tenantContext, useModuleInfo, }: IMTenantProps) => import("react").JSX.Element;
+export declare const IMTenant: ({ children, baseUrl, tenantId, tenantContext, }: IMTenantProps) => import("react").JSX.Element;
 export {};

package/lib/packages/Tenant/index.js

@@ -1,40 +1,20 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { useCallback, useRef } from 'react';
 import { useRenderTarget } from '../../_shared/renderTarget';
-import { join } from '../../utils/path';
 import { Context as DefaultContext } from './Context';
-import { IMTenantError } from './IMTenantError';
-import { HYBRID_SSO_KEY, MODULE_IDS } from './modulesType';
+import { createStorageKey } from './constants';
 const useGetBaseUrl = (baseUrl) => {
     return useCallback(() => baseUrl, [baseUrl]);
 };
 const useGetTenantId = (tenantId) => {
     return useCallback(() => tenantId, [tenantId]);
 };
-const createInitFetchModuleState = (useModuleInfo) => {
-    return useModuleInfo ? 'notFetched' : 'notRequired';
-};
-const createStorageKey = (baseUrl, moduleKey) => {
-    return `${baseUrl}_${moduleKey}`;
-};
-const saveModuleInfoStorage = async (storageKey, ModuleInfo) => {
-    return await AsyncStorage.setItem(storageKey, JSON.stringify(ModuleInfo));
-};
-const deleteModuleInfoStorage = async (storageKey) => {
+const deleteModuleStorage = async (storageKey) => {
     return await AsyncStorage.removeItem(storageKey);
 };
-const getModuleInfoStorage = async (storageKey) => {
-    const state = await AsyncStorage.getItem(storageKey);
-    if (state == null)
-        return;
-    const result = JSON.parse(state);
-    return result;
-};
-const useFetchModuleStateRef = (renderTarget, useModuleInfo) => {
-    const ref = useRef(createInitFetchModuleState(useModuleInfo));
+const useModuleRef = (baseUrl, renderTarget) => {
+    const ref = useRef();
     const setter = useCallback((state, silent) => {
-        if (!useModuleInfo)
-            throw new IMTenantError('useModuleInfo is not enabled');
         if (ref.current === state)
             return;
         ref.current = state;
@@ -42,74 +22,27 @@ const useFetchModuleStateRef = (renderTarget, useModuleInfo) => {
             renderTarget.dispatch();
     }, []);
     const getter = useCallback(() => ref.current, []);
-    return [ref, setter, getter];
-};
-const useModuleInfoRef = (baseUrl, fetchModuleStateSetter, useModuleInfo) => {
-    const ref = useRef();
-    const setter = useCallback((state, silent) => {
-        if (!useModuleInfo)
-            throw new IMTenantError('useModuleInfo is not enabled');
-        if (ref.current === state)
-            return;
-        ref.current = state;
-        fetchModuleStateSetter('fetched', silent);
-    }, [fetchModuleStateSetter, useModuleInfo]);
-    const getter = useCallback(() => ref.current, []);
     const destroy = useCallback(async () => {
-        for (let i = 0; i < MODULE_IDS.length; i++) {
-            const key = MODULE_IDS[i];
-            if (key) {
-                const storageKey = createStorageKey(baseUrl, key);
-                await deleteModuleInfoStorage(storageKey);
-            }
-        }
+        const storageKey = createStorageKey(baseUrl);
+        await deleteModuleStorage(storageKey);
         ref.current = undefined;
-        fetchModuleStateSetter('notFetched');
-    }, [fetchModuleStateSetter, baseUrl]);
+        renderTarget.dispatch();
+    }, [baseUrl]);
     return [ref, setter, getter, destroy];
 };
-const createCheckHybridSSOUrl = (baseUrl) => {
-    return join(baseUrl, '/im_hybrid_sso/logout');
-};
-const useFetchModuleInfo = (baseUrl, setModuleInfo) => {
-    return useCallback(async () => {
-        const hybridSSOUrl = createCheckHybridSSOUrl(baseUrl);
-        const storageKey = createStorageKey(baseUrl, HYBRID_SSO_KEY);
-        const storageState = await getModuleInfoStorage(storageKey);
-        if (storageState) {
-            setModuleInfo({
-                [HYBRID_SSO_KEY]: storageState,
-            });
-        }
-        else {
-            const response = await fetch(hybridSSOUrl);
-            const hasHyBridSSO = response.status !== 404;
-            const state = {
-                moduleKey: HYBRID_SSO_KEY,
-                enabled: hasHyBridSSO,
-                othes: {},
-            };
-            saveModuleInfoStorage(storageKey, state);
-            setModuleInfo({ [HYBRID_SSO_KEY]: state });
-        }
-    }, [setModuleInfo, baseUrl]);
-};
-export const IMTenant = ({ children, baseUrl, tenantId, tenantContext, useModuleInfo, }) => {
+export const IMTenant = ({ children, baseUrl, tenantId, tenantContext, }) => {
     const Context = tenantContext || DefaultContext;
     const contextRef = useRef();
     const modulesStateRenderTarget = useRenderTarget();
     const getBaseUrl = useGetBaseUrl(baseUrl);
     const getTenantId = useGetTenantId(tenantId);
-    const [, setFetchModuleState, getFetchModuleState] = useFetchModuleStateRef(modulesStateRenderTarget, useModuleInfo);
-    const [, setModuleInfo, getModuleInfo, destroyModuleInfo] = useModuleInfoRef(baseUrl, setFetchModuleState, useModuleInfo);
-    const fetchModuleInfo = useFetchModuleInfo(baseUrl, setModuleInfo);
+    const [, setModules, getModules, destroyModule] = useModuleRef(baseUrl, modulesStateRenderTarget);
     contextRef.current = {
         getBaseUrl,
         getTenantId,
-        getFetchModuleState,
-        getModuleInfo,
-        destroyModuleInfo,
-        fetchModuleInfo,
+        getModules,
+        setModules,
+        destroyModule,
         modulesStateRenderTarget,
     };
     return (<Context.Provider value={contextRef.current}>{children}</Context.Provider>);