@leav/ui 0.0.1-alpha-1 → 0.0.1-alpha-2

package/src/hooks/useLang/__mocks__/useLang.tsx

@@ -0,0 +1,13 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+
+const mockUseLang = () => {
+    return {
+        lang: ['fr', 'en'],
+        availableLangs: ['fr', 'en'],
+        defaultLang: 'fr'
+    };
+};
+
+export default mockUseLang;

package/src/hooks/useLang/index.ts

@@ -0,0 +1,5 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import useLang from './useLang';
+export default useLang;

package/src/hooks/useLang/useLang.test.tsx

@@ -0,0 +1,34 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {renderHook} from '_ui/_tests/testUtils';
+import useLang from '.';
+import {MockedLangContextProvider} from '../../testing';
+
+describe('useLang', () => {
+    const CompWithLang = () => {
+        const lang = useLang();
+
+        return <div className="lang">{lang.lang[0]}</div>;
+    };
+
+    test('Return user data from context', async () => {
+        const hook = renderHook(() => useLang(), {
+            wrapper: ({children}) => <MockedLangContextProvider>{children as JSX.Element}</MockedLangContextProvider>
+        });
+
+        expect(hook.result.current.lang).toEqual(['fr']);
+    });
+
+    test('Throw if no context provided', async () => {
+        const errorLogger = console.error;
+        console.error = jest.fn();
+        try {
+            renderHook(() => useLang());
+        } catch (e) {
+            expect(e).toBeDefined();
+        }
+
+        console.error = errorLogger;
+    });
+});

package/src/hooks/useLang/useLang.tsx

@@ -0,0 +1,17 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {useContext} from 'react';
+import {ILangContext, LangContext} from '../../contexts/LangContext';
+
+function useLang(): ILangContext {
+    const lang = useContext(LangContext);
+
+    if (!lang) {
+        throw new Error('useLang must be used inside a <LangContext.Provider />');
+    }
+
+    return lang;
+}
+
+export default useLang;

package/src/hooks/useLibraryVersionTrees/index.ts

@@ -0,0 +1,4 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+export {default} from './useLibraryVersionTrees';

package/src/hooks/useLibraryVersionTrees/useLibraryVersionTrees.test.tsx

@@ -0,0 +1,95 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {MockedProvider} from '@apollo/client/testing';
+import {mockAttributeSimple} from '_ui/__mocks__/common/attribute';
+import {mockVersionProfile} from '_ui/__mocks__/common/versionProfile';
+import useLibraryVersionTrees from '.';
+import {getVersionableAttributesByLibraryQuery} from '../../_queries/attributes/getVersionableAttributesByLibrary';
+import {renderHook, waitFor} from '../../_tests/testUtils';
+
+describe('useLibraryVersionTrees', () => {
+    test("Return deduped list of trees usable in versions by library's attributes", async () => {
+        const mockSimpleTree = {
+            id: 'my_tree',
+            label: {
+                fr: 'Mon arbre',
+                en: 'My tree'
+            }
+        };
+
+        const mockSimpleTree2 = {
+            id: 'my_tree2',
+            label: {
+                fr: 'Mon arbre 2',
+                en: 'My tree 2'
+            }
+        };
+
+        const mockProfileBase = {
+            ...mockVersionProfile,
+            trees: [mockSimpleTree]
+        };
+
+        const mocks = [
+            {
+                request: {
+                    query: getVersionableAttributesByLibraryQuery,
+                    variables: {libraryId: 'my_lib'}
+                },
+                result: {
+                    data: {
+                        attributes: {
+                            list: [
+                                {
+                                    ...mockAttributeSimple,
+                                    id: 'attrA',
+                                    versions_conf: {
+                                        versionable: true,
+                                        profile: {
+                                            ...mockProfileBase,
+                                            id: 'profileA'
+                                        }
+                                    }
+                                },
+                                {
+                                    ...mockAttributeSimple,
+                                    id: 'attrB',
+                                    versions_conf: {
+                                        versionable: true,
+                                        profile: {
+                                            ...mockProfileBase,
+                                            id: 'profileA'
+                                        }
+                                    }
+                                },
+                                {
+                                    ...mockAttributeSimple,
+                                    id: 'attrC',
+                                    versions_conf: {
+                                        versionable: true,
+                                        profile: {
+                                            ...mockProfileBase,
+                                            id: 'profileB',
+                                            trees: [mockSimpleTree2]
+                                        }
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        ];
+
+        const {result} = renderHook(() => useLibraryVersionTrees('my_lib'), {
+            wrapper: ({children}) => <MockedProvider mocks={mocks}>{children as JSX.Element}</MockedProvider>
+        });
+
+        expect(result.current.loading).toBe(true);
+
+        await waitFor(() => expect(result.current.loading).toBe(false));
+        expect(result.current.error).toBeUndefined();
+        expect(result.current.trees).toEqual([mockSimpleTree, mockSimpleTree2]);
+    });
+});

package/src/hooks/useLibraryVersionTrees/useLibraryVersionTrees.ts

@@ -0,0 +1,35 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {ApolloError} from '@apollo/client';
+import {GetVersionableAttributesByLibraryQuery, useGetVersionableAttributesByLibraryQuery} from '_ui/_gqlTypes';
+
+type ProfileTree = GetVersionableAttributesByLibraryQuery['attributes']['list'][0]['versions_conf']['profile']['trees'][0];
+
+export interface IUseLibraryVersionProfilesHook {
+    loading: boolean;
+    error: ApolloError;
+    trees: ProfileTree[];
+}
+
+export default (libraryId: string): IUseLibraryVersionProfilesHook => {
+    const {loading, error, data} = useGetVersionableAttributesByLibraryQuery({
+        variables: {libraryId}
+    });
+    let trees: ProfileTree[] = [];
+
+    if ((data?.attributes?.list ?? []).length) {
+        const treesById = (data?.attributes?.list ?? []).reduce((allTrees, attribute) => {
+            const profile = attribute.versions_conf?.profile;
+            for (const tree of profile?.trees ?? []) {
+                allTrees[tree.id] = tree;
+            }
+
+            return allTrees;
+        }, {});
+
+        trees = Object.values(treesById);
+    }
+
+    return {loading, error, trees};
+};

package/src/hooks/useLocalStorage/index.ts

@@ -0,0 +1,4 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+export {default} from './useLocalStorage';

package/src/hooks/useLocalStorage/useLocalStorage.ts

@@ -0,0 +1,23 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {useEffect, useState} from 'react';
+
+function useLocalStorage<T>(key: string, defaultValue: T): [T, (value: T) => void] {
+    const _getStorageValue = (): T => {
+        // getting stored value
+        const saved = localStorage.getItem(key);
+        const initial = JSON.parse(saved);
+        return initial || defaultValue;
+    };
+
+    const [value, setValue] = useState<T>(() => _getStorageValue());
+
+    useEffect(() => {
+        localStorage.setItem(key, JSON.stringify(value));
+    }, [key, value]);
+
+    return [value, setValue];
+}
+
+export default useLocalStorage;

package/src/hooks/useRecordsConsultationHistory/index.ts

@@ -0,0 +1,5 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import useRecordsConsultationHistory from './useRecordsConsultationHistory';
+export default useRecordsConsultationHistory;

package/src/hooks/useRecordsConsultationHistory/useRecordsConsultationHistory.ts

@@ -0,0 +1,38 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {useGetUserDataQuery, useSaveUserDataMutation} from '_ui/_gqlTypes';
+
+const RECORDS_CONSULTATION_KEY = 'records_consultation';
+const HISTORY_LENGTH = 10;
+
+export default async function (libraryId: string | null, recordId: string | null) {
+    const historyKey = `${RECORDS_CONSULTATION_KEY}_${libraryId}`;
+    const [updatingRecordsConsultationMutation] = useSaveUserDataMutation();
+
+    useGetUserDataQuery({
+        skip: !libraryId || !recordId,
+        variables: {keys: [historyKey]},
+        onCompleted: async data => {
+            const history = data.userData.data[historyKey] ? [...data.userData.data[historyKey]] : [];
+
+            const idx = history.indexOf(recordId);
+
+            if (idx !== -1) {
+                history.splice(idx, 1);
+            } else if (history.length >= HISTORY_LENGTH) {
+                history.pop();
+            }
+
+            history.unshift(recordId);
+
+            await updatingRecordsConsultationMutation({
+                variables: {
+                    key: historyKey,
+                    value: history,
+                    global: false
+                }
+            });
+        }
+    });
+}

package/src/hooks/useRefreshFieldValues/index.ts

@@ -0,0 +1,4 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+export {default as useRefreshFieldValues} from './useRefreshFieldValues';

package/src/hooks/useRefreshFieldValues/useRefreshFieldValues.test.tsx

@@ -0,0 +1,75 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+
+import {MockedProvider} from '@apollo/client/testing';
+import {getRecordPropertiesQuery} from '_ui/_queries/records/getRecordPropertiesQuery';
+import {act, renderHook} from '_ui/_tests/testUtils';
+import useRefreshFieldValues from './useRefreshFieldValues';
+
+describe('useRefetchFieldValues', () => {
+    test('Fetch values and return it', async () => {
+        const mocks = [
+            {
+                request: {
+                    query: getRecordPropertiesQuery([
+                        {
+                            attributeId: 'my_attribute'
+                        }
+                    ]),
+                    variables: {
+                        library: 'test_lib',
+                        recordId: '123456',
+                        version: null
+                    }
+                },
+                result: {
+                    data: {
+                        records: {
+                            list: [
+                                {
+                                    _id: '123456',
+                                    my_attribute: [
+                                        {
+                                            __typename: 'Value',
+                                            value: 'my_value',
+                                            raw_value: 'my_value',
+                                            id_value: null,
+                                            created_at: null,
+                                            created_by: null,
+                                            modified_at: null,
+                                            modified_by: null,
+                                            version: null
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        ];
+
+        const {result} = renderHook(() => useRefreshFieldValues('test_lib', 'my_attribute', '123456'), {
+            wrapper: ({children}) => <MockedProvider mocks={mocks}>{children as JSX.Element}</MockedProvider>
+        });
+
+        let values;
+        await act(async () => {
+            values = await result.current.fetchValues();
+        });
+
+        expect(values).toEqual([
+            {
+                id_value: null,
+                created_at: null,
+                created_by: null,
+                modified_at: null,
+                modified_by: null,
+                version: {},
+                value: 'my_value',
+                raw_value: 'my_value'
+            }
+        ]);
+    });
+});

package/src/hooks/useRefreshFieldValues/useRefreshFieldValues.ts

@@ -0,0 +1,63 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {useLazyQuery} from '@apollo/client';
+import {objectToNameValueArray} from '@leav/utils';
+import {IValueVersion} from '_ui/types/values';
+import {
+    getRecordPropertiesQuery,
+    IGetRecordProperties,
+    IGetRecordPropertiesVariables,
+    RecordProperty
+} from '_ui/_queries/records/getRecordPropertiesQuery';
+import {arrayValueVersionToObject} from '_ui/_utils';
+
+export interface IUseRefetchFieldValuesHook {
+    fetchValues: (version?: IValueVersion) => Promise<RecordProperty[]>;
+}
+
+const useRefreshFieldValues = (
+    libraryId: string,
+    attributeId: string,
+    recordId: string
+): IUseRefetchFieldValuesHook => {
+    const [getRecordProperty] = useLazyQuery<IGetRecordProperties, IGetRecordPropertiesVariables>(
+        getRecordPropertiesQuery([
+            {
+                attributeId
+            }
+        ]),
+        {
+            fetchPolicy: 'network-only'
+        }
+    );
+
+    return {
+        fetchValues: async (version?: IValueVersion) => {
+            const res = await getRecordProperty({
+                variables: {
+                    library: libraryId,
+                    recordId,
+                    version: version
+                        ? objectToNameValueArray(version).map(v => ({treeId: v.name, treeNodeId: v.value.id}))
+                        : null
+                }
+            });
+
+            if (!res.data.records.list.length) {
+                return null;
+            }
+
+            const values = res.data.records.list[0][attributeId].map(value => {
+                const {__typename, ...valueData} = value; // Clear off __typename
+                return {
+                    ...valueData,
+                    version: arrayValueVersionToObject(value.version ?? [])
+                };
+            });
+            return values;
+        }
+    };
+};
+
+export default useRefreshFieldValues;

package/src/hooks/useRefreshToken/index.ts

@@ -0,0 +1,4 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+export {default} from './useRefreshToken';

package/src/hooks/useRefreshToken/useRefreshToken.ts

@@ -0,0 +1,34 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+export default function useRefreshToken() {
+    const REFRESH_TOKEN_KEY = 'refreshToken';
+
+    return {
+        setRefreshToken: (token: string) => {
+            localStorage.setItem(REFRESH_TOKEN_KEY, token);
+        },
+        refreshToken: async () => {
+            const refreshToken = localStorage.getItem(REFRESH_TOKEN_KEY);
+
+            if (!refreshToken) {
+                throw new Error('No refresh token available');
+            }
+
+            const res = await fetch('/auth/refresh', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({refreshToken})
+            });
+
+            // make the promise be rejected if we didn't get a 2xx response
+            if (!res.ok) {
+                throw new Error(res.statusText, {cause: res});
+            }
+
+            res.json().then(data => {
+                localStorage.setItem(REFRESH_TOKEN_KEY, data.refreshToken);
+            });
+        }
+    };
+}

package/src/hooks/useSharedTranslation/__mocks__/index.ts

@@ -0,0 +1,4 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+export {default as useSharedTranslation} from './useSharedTranslation';

package/src/hooks/useSharedTranslation/__mocks__/useSharedTranslation.ts

@@ -0,0 +1,21 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {Mockify} from '@leav/utils';
+import {TFunction, i18n} from 'i18next';
+
+const mockI18n: Mockify<i18n> = {
+    language: 'fr',
+    options: {
+        fallbackLng: ['en']
+    },
+    changeLanguage: jest.fn()
+};
+
+const mockT = (arg, variables) => `${[arg, ...(!!variables ? Object.values(variables) : [])].join('|')}`;
+
+export default () => {
+    const mock = {t: mockT as TFunction<any>, i18n: mockI18n as i18n, ready: true};
+
+    return mock;
+};

package/src/hooks/useSharedTranslation/index.ts

@@ -0,0 +1,4 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+export {default as useSharedTranslation} from './useSharedTranslation';

package/src/hooks/useSharedTranslation/useSharedTranslation.ts

@@ -0,0 +1,45 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import i18next from 'i18next';
+import LanguageDetector from 'i18next-browser-languagedetector';
+import {useContext, useMemo} from 'react';
+import {initReactI18next, useTranslation} from 'react-i18next';
+import {LangContext} from '../../contexts';
+import en from '../../locales/en/shared.json';
+import fr from '../../locales/fr/shared.json';
+
+const useSharedTranslation = () => {
+    const langContext = useContext(LangContext);
+
+    const i18n = useMemo(
+        () =>
+            i18next
+                .use(initReactI18next)
+                .use(LanguageDetector)
+                .createInstance(
+                    {
+                        fallbackLng: langContext.defaultLang,
+                        ns: ['shared'],
+                        defaultNS: 'shared',
+                        resources: {
+                            fr: {shared: fr},
+                            en: {shared: en}
+                        },
+                        react: {
+                            useSuspense: true
+                        }
+                    },
+                    (err, t) => {
+                        if (err) {
+                            return console.error('Something went wrong loading', err);
+                        }
+                    }
+                ),
+        [langContext.lang]
+    );
+
+    return useTranslation('shared', {i18n});
+};
+
+export default useSharedTranslation;

package/src/hooks/useUser/index.ts

@@ -0,0 +1 @@
+export {useUser} from './useUser';

package/src/hooks/useUser/useUser.test.tsx

@@ -0,0 +1,28 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import MockedUserContextProvider from '_ui/testing/MockedUserContextProvider';
+import {renderHook} from '_ui/_tests/testUtils';
+import {useUser} from './useUser';
+
+describe('useUser', () => {
+    test('Return user data from context', async () => {
+        const hook = renderHook(() => useUser(), {
+            wrapper: ({children}) => <MockedUserContextProvider>{children as JSX.Element}</MockedUserContextProvider>
+        });
+
+        expect(hook.result.current.userData.userId).toEqual('123');
+    });
+
+    test('Throw if no context provided', async () => {
+        const errorLogger = console.error;
+        console.error = jest.fn();
+        try {
+            renderHook(() => useUser());
+        } catch (e) {
+            expect(e).toBeDefined();
+        }
+
+        console.error = errorLogger;
+    });
+});

package/src/hooks/useUser/useUser.ts

@@ -0,0 +1,15 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {useContext} from 'react';
+import {UserContext} from '_ui/contexts/UserContext';
+
+export const useUser = () => {
+    const userContext = useContext(UserContext);
+
+    if (!userContext) {
+        throw new Error('useUser must be used inside a <UserContext.Provider />');
+    }
+
+    return userContext;
+};

package/src/hooks/useValuesCacheUpdate/index.ts

@@ -0,0 +1,4 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+export {default as useValuesCacheUpdate} from './useValuesCacheUpdate';

package/src/hooks/useValuesCacheUpdate/useValuesCacheUpdate.ts

@@ -0,0 +1,56 @@
+// Copyright LEAV Solutions 2017
+// This file is released under LGPL V3
+// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
+import {useApolloClient} from '@apollo/client';
+import {IRecordIdentityWhoAmI} from '_ui/types/records';
+import {
+    ValueDetailsFragment,
+    ValueDetailsLinkValueFragment,
+    ValueDetailsTreeValueFragment,
+    ValueDetailsValueFragment
+} from '_ui/_gqlTypes';
+import {getPropertyCacheFieldName} from '_ui/_utils';
+
+export type IValuesCacheUpdateHook = (record: IRecordIdentityWhoAmI, savedValues: ValueDetailsFragment[]) => void;
+
+export default function (): IValuesCacheUpdateHook {
+    const {cache} = useApolloClient();
+
+    return (record, savedValues) => {
+        const recordWithTypename = {id: record.id, whoAmI: {...record}, __typename: 'Record'};
+        for (const savedValue of savedValues) {
+            const propertyCacheFieldName = getPropertyCacheFieldName(savedValue.attribute.id);
+
+            const _updateCacheValue = (cacheValue: ValueDetailsFragment | ValueDetailsFragment[]) => {
+                const valueToCache =
+                    (savedValue as ValueDetailsValueFragment).value ??
+                    (savedValue as ValueDetailsLinkValueFragment).linkValue ??
+                    (savedValue as ValueDetailsTreeValueFragment).treeValue ??
+                    null;
+
+                if (Array.isArray(cacheValue)) {
+                    const newCacheValue = [...cacheValue];
+                    const cacheIndex = cacheValue.findIndex(val => val.id_value === savedValue.id_value);
+
+                    if (cacheIndex !== -1) {
+                        newCacheValue[cacheIndex] = valueToCache;
+                    } else {
+                        newCacheValue.push(valueToCache);
+                    }
+                } else {
+                    // Update the cache value
+                    return valueToCache;
+                }
+            };
+
+            cache.modify<ValueDetailsFragment>({
+                id: cache.identify(recordWithTypename),
+                broadcast: true,
+                fields: {
+                    [propertyCacheFieldName]: _updateCacheValue,
+                    [savedValue.attribute.id]: _updateCacheValue
+                }
+            });
+        }
+    };
+}