@ludo.ninja/components 2.0.0 → 2.0.2

package/build/api/server-galleries/queries/useFetchMyGalleries/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchMyGalleriesV2 = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const GalleryEntityV2_1 = __importDefault(require("@/dto/GalleryEntityV2"));
+const maxUserFavoritesLength = 1000;
+const useFetchMyGalleriesV2 = () => {
+    const [galleries, setGalleries] = (0, react_1.useState)([]);
+    const nextPageTokenRef = (0, react_1.useRef)(null);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [isNextLoading, setIsNextLoading] = (0, react_1.useState)(false);
+    const [fetchMyGalleriesV2, { /*refetch*/ fetchMore }] = (0, client_1.useLazyQuery)(api_1.galleriesSchema.FetchMyGalleriesV2Document, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ fetchMyGalleriesV2: { galleries, nextPageToken } }) => {
+            nextPageTokenRef.current = nextPageToken || null;
+            setGalleries(galleries.map((gallery) => new GalleryEntityV2_1.default(gallery)));
+        },
+        onError: () => {
+            nextPageTokenRef.current = null;
+            setGalleries([]);
+        },
+    });
+    function load({ pageSize, pageToken }) {
+        setIsLoading(true);
+        fetchMyGalleriesV2({
+            variables: { pageSize, pageToken },
+        }).finally(() => {
+            setIsLoading(false);
+        });
+    }
+    // async function refetchQuery() {
+    //   await refetch();
+    // }
+    async function loadMore() {
+        const pageToken = nextPageTokenRef.current;
+        if (!pageToken || galleries.length >= maxUserFavoritesLength || isLoading)
+            return;
+        setIsNextLoading(true);
+        try {
+            const { data } = await fetchMore({
+                variables: { pageToken },
+            });
+            const { galleries, nextPageToken } = data.fetchMyGalleriesV2;
+            if (galleries) {
+                nextPageTokenRef.current = nextPageToken || null;
+                setGalleries((prev) => [
+                    ...prev,
+                    ...galleries.map((gallery) => new GalleryEntityV2_1.default(gallery)),
+                ]);
+            }
+        }
+        finally {
+            setIsNextLoading(false);
+        }
+    }
+    return {
+        galleryItems: galleries,
+        isNextLoading,
+        loadMore,
+        load,
+        isLoading,
+    };
+};
+exports.useFetchMyGalleriesV2 = useFetchMyGalleriesV2;

package/build/api/server-galleries/queries/useFetchSubscribedGalleries/index.d.ts

@@ -0,0 +1,9 @@
+declare const useFetchSubscribedGalleries: (pageSize: number, userId: string) => {
+    load: () => void;
+    loadMore: (pageToken: string) => Promise<void>;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    galleries: never[];
+    nextPageToken: null;
+};
+export default useFetchSubscribedGalleries;

package/build/api/server-galleries/queries/useFetchSubscribedGalleries/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const FETCH_SUBSCRIBED_GALLERIES_QUERY = (0, client_1.gql) `
+  query FetchSubscribedGalleries(
+    $userId: ID!
+    $pageSize: Int!
+    $pageToken: String
+  ) {
+    fetchSubscribedGalleries(
+      userId: $userId
+      pageSize: $pageSize
+      pageToken: $pageToken
+    ) {
+      nextPageToken
+      galleries {
+        galleryId
+        name
+        description
+        customUrl
+        userId
+        username
+        subscribes
+        items
+      }
+    }
+  }
+`;
+const useFetchSubscribedGalleries = (pageSize, userId) => {
+    const [galleries, setGalleries] = (0, react_1.useState)([]);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [fetchSubscribedGalleries, { error, loading, fetchMore }] = (0, client_1.useLazyQuery)(FETCH_SUBSCRIBED_GALLERIES_QUERY, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        pollInterval: 0,
+        notifyOnNetworkStatusChange: true,
+        fetchPolicy: 'cache-and-network',
+        ssr: true,
+        partialRefetch: true,
+        returnPartialData: true,
+        onCompleted: ({ fetchSubscribedGalleries: { galleries: fetchedGalleries, nextPageToken, }, }) => {
+            setNextPageToken(nextPageToken);
+            setGalleries(fetchedGalleries);
+        },
+    });
+    return { load, loadMore, loading, error, galleries, nextPageToken };
+    function load() {
+        fetchSubscribedGalleries({
+            variables: { userId, pageSize },
+        });
+    }
+    async function loadMore(pageToken) {
+        await fetchMore({
+            variables: { userId, pageSize, pageToken },
+            updateQuery: (prev, { fetchMoreResult }) => {
+                if (!fetchMoreResult)
+                    return prev;
+                const { galleries: prevGalleries } = prev.fetchSubscribedGalleries;
+                const { nextPageToken, galleries: nextGalleries } = fetchMoreResult.fetchSubscribedGalleries;
+                const galleries = prevGalleries.concat(nextGalleries);
+                return { fetchSubscribedGalleries: { galleries, nextPageToken } };
+            },
+        });
+    }
+};
+exports.default = useFetchSubscribedGalleries;

package/build/api/server-galleries/queries/useFetchUserFavorites/index.d.ts

@@ -0,0 +1,11 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+import GalleryEntityV2 from '@/dto/GalleryEntityV2';
+declare const useFetchUserFavoritesV2: ({ userId, pageSize, pageToken, }: schema.IQueryFetchUserFavoritesV2Args) => {
+    loadingFavorites: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    favorites: GalleryEntityV2[];
+    nextPageToken: string | null;
+    refetchQuery: () => Promise<void>;
+    loadMore: (pageToken: string) => Promise<void>;
+};
+export { useFetchUserFavoritesV2 };

package/build/api/server-galleries/queries/useFetchUserFavorites/index.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchUserFavoritesV2 = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const GalleryEntityV2_1 = __importDefault(require("@/dto/GalleryEntityV2"));
+const maxUserFavoritesLength = 1000;
+const useFetchUserFavoritesV2 = ({ userId, pageSize, pageToken, }) => {
+    const [favorites, setFavorites] = (0, react_1.useState)([]);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const { error, loading, refetch, fetchMore } = (0, client_1.useQuery)(api_1.galleriesSchema.FetchUserFavoritesV2Document, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        variables: { pageSize, userId, pageToken },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ fetchUserFavoritesV2: { galleries, nextPageToken } }) => {
+            setNextPageToken(nextPageToken);
+            setFavorites(galleries.map((gallery) => new GalleryEntityV2_1.default(gallery)));
+        },
+        onError: () => {
+            setNextPageToken(null);
+            setFavorites([]);
+        },
+    });
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || favorites.length >= maxUserFavoritesLength)
+            return;
+        await fetchMore({
+            variables: { pageToken },
+            updateQuery: (prev, { fetchMoreResult }) => {
+                if (!fetchMoreResult)
+                    return prev;
+                const { nextPageToken, favorites: nextFavorites } = fetchMoreResult.fetchUserFavoritesV2;
+                if (prev !== null && prev.hasOwnProperty('fetchUserFavoritesV2')) {
+                    const { favorites: prevFavorites } = prev.fetchUserFavoritesV2;
+                    return {
+                        fetchUserFavorites: {
+                            favorites: [...prevFavorites, ...nextFavorites],
+                            nextPageToken,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        findCreations: { favorites: nextFavorites, nextPageToken },
+                    };
+                }
+            },
+        });
+    }
+    return {
+        loadingFavorites: loading,
+        error,
+        favorites,
+        nextPageToken,
+        refetchQuery,
+        loadMore,
+    };
+};
+exports.useFetchUserFavoritesV2 = useFetchUserFavoritesV2;

package/build/api/server-identities/mutations/useAddWalletElrond/index.d.ts

@@ -0,0 +1,6 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useAddWalletElrond: () => {
+    addWalletElrond: ({ signature, address, }: schema.IMutationAddWalletElrondArgs) => Promise<import("@apollo/client").FetchResult<any>>;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export default useAddWalletElrond;

package/build/api/server-identities/mutations/useAddWalletElrond/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("@/store/ui");
+const useAddWalletElrond = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.identitySchema.AddWalletElrondDocument, {
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: () => {
+            openAlert({
+                ...data_1.alertSuccess,
+                caption: 'MultiversX wallet successfully added !',
+                text: '',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { addWalletElrond, error };
+    function addWalletElrond({ signature, address, }) {
+        return mutate({
+            variables: { signature, address },
+        });
+    }
+};
+exports.default = useAddWalletElrond;

package/build/api/server-identities/mutations/useAddWalletFlow/index.d.ts

@@ -0,0 +1,5 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useAddWalletFlow: () => {
+    addWalletFlow: ({ signature, address, }: schema.IMutationAddWalletFlowArgs) => Promise<void>;
+};
+export default useAddWalletFlow;

package/build/api/server-identities/mutations/useAddWalletFlow/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("@/store/ui");
+const useAddWalletFlow = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = (0, client_1.useMutation)(api_1.identitySchema.AddWalletFlowDocument, {
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: () => {
+            openAlert({
+                ...data_1.alertSuccess,
+                caption: 'Flow wallet successfully added !',
+                text: '',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { addWalletFlow };
+    async function addWalletFlow({ signature, address, }) {
+        mutate({
+            variables: { signature, address },
+        });
+    }
+};
+exports.default = useAddWalletFlow;

package/build/api/server-identities/mutations/useAddWalletMetamask/index.d.ts

@@ -0,0 +1,12 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useAddWalletMetamask: () => {
+    addWalletMetamask: ({ signature, address, chainId, }: schema.IAddWalletMetamaskMutationVariables) => Promise<{
+        userId: any;
+        wallets: any;
+        authToken: any;
+        refreshToken: any;
+        newUser: any;
+    } | undefined>;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export default useAddWalletMetamask;

package/build/api/server-identities/mutations/useAddWalletMetamask/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("@/store/ui");
+const useAddWalletMetamask = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.identitySchema.AddWalletMetamaskDocument, {
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: () => {
+            openAlert({
+                ...data_1.alertSuccess,
+                caption: 'Metamask wallet successfully added !',
+                text: '',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { addWalletMetamask, error };
+    async function addWalletMetamask({ signature, address, chainId, }) {
+        const { data } = await mutate({
+            variables: { signature, address, chainId },
+        });
+        if (data) {
+            const { signInMetamask: { userId, wallets, authToken, refreshToken, newUser }, } = data;
+            return { userId, wallets, authToken, refreshToken, newUser };
+        }
+    }
+};
+exports.default = useAddWalletMetamask;

package/build/api/server-identities/mutations/useAddWalletSolana/index.d.ts

@@ -0,0 +1,5 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useAddWalletSolana: () => {
+    addWalletSolana: ({ signature, pubkey, }: schema.IAddWalletSolanaMutationVariables) => Promise<void>;
+};
+export default useAddWalletSolana;

package/build/api/server-identities/mutations/useAddWalletSolana/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("@/store/ui");
+const useAddWalletSolana = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = (0, client_1.useMutation)(api_1.identitySchema.AddWalletSolanaDocument, {
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: () => {
+            openAlert({
+                ...data_1.alertSuccess,
+                caption: 'Solana wallet successfully added !',
+                text: '',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { addWalletSolana };
+    async function addWalletSolana({ signature, pubkey, }) {
+        await mutate({
+            variables: { signature, pubkey },
+        });
+    }
+};
+exports.default = useAddWalletSolana;

package/build/api/server-identities/mutations/useAddWalletTezos/index.d.ts

@@ -0,0 +1,5 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useAddWalletTezos: () => {
+    addWalletTezos: ({ signature, pubkey, }: schema.IMutationAddWalletTezosArgs) => Promise<void>;
+};
+export default useAddWalletTezos;

package/build/api/server-identities/mutations/useAddWalletTezos/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("@/store/ui");
+const useAddWalletTezos = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = (0, client_1.useMutation)(api_1.identitySchema.AddWalletTezosDocument, {
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: () => {
+            openAlert({
+                ...data_1.alertSuccess,
+                caption: 'Tezos wallet successfully added !',
+                text: '',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { addWalletTezos };
+    async function addWalletTezos({ signature, pubkey, }) {
+        mutate({
+            variables: { signature, pubkey },
+        });
+    }
+};
+exports.default = useAddWalletTezos;

package/build/api/server-identities/mutations/useFollowProfile/index.d.ts

@@ -0,0 +1,7 @@
+declare const useFollowProfile: (followingUserId: string) => {
+    followProfile: (options?: import("@apollo/client").MutationFunctionOptions<any, import("@apollo/client").OperationVariables, {
+        uri: string;
+    }, import("@apollo/client").ApolloCache<any>> | undefined) => Promise<import("@apollo/client").FetchResult<any>>;
+    isFollowedProfile: boolean;
+};
+export default useFollowProfile;

package/build/api/server-identities/mutations/useFollowProfile/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const ui_1 = require("@/store/ui");
+const FOLLOW_PROFILE_MUTATION = (0, client_1.gql) `
+  mutation FollowProfile($followingUserId: ID!) {
+    followProfile(followingUserId: $followingUserId)
+  }
+`;
+const useFollowProfile = (followingUserId) => {
+    const [isFollowedProfile, setIsFollowed] = (0, react_1.useState)(false);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [followProfile] = (0, client_1.useMutation)(FOLLOW_PROFILE_MUTATION, {
+        variables: { followingUserId },
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ followProfile }) => {
+            setIsFollowed(followProfile);
+            openAlert({
+                type: type_1.alertVariants.success,
+                caption: 'You successfully subscribed!',
+                text: '',
+            });
+        },
+        onError: (err) => {
+            setIsFollowed(false);
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+        },
+    });
+    return { followProfile, isFollowedProfile };
+};
+exports.default = useFollowProfile;

package/build/api/server-identities/mutations/useGenerateNewInviteCodes/index.d.ts

@@ -0,0 +1,7 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useGenerateNewInviteCodes: () => {
+    generateNewInviteCodes: ({ codesNum, }: schema.IMutationGenerateNewInviteCodesArgs) => Promise<void>;
+    generatedCodes: schema.IUserInviteCode[] | null;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export default useGenerateNewInviteCodes;

package/build/api/server-identities/mutations/useGenerateNewInviteCodes/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useGenerateNewInviteCodes = () => {
+    const [generatedCodes, setGeneratedCodes] = (0, react_1.useState)(null);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.identitySchema.GenerateNewInviteCodesDocument, {
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: ({ generateNewInviteCodes }) => {
+            setGeneratedCodes(generateNewInviteCodes);
+        },
+        onError: () => {
+            setGeneratedCodes(null);
+        },
+    });
+    return { generateNewInviteCodes, generatedCodes, error };
+    async function generateNewInviteCodes({ codesNum, }) {
+        try {
+            await mutate({
+                variables: { codesNum },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.default = useGenerateNewInviteCodes;

package/build/api/server-identities/mutations/useInviteCode/index.d.ts

@@ -0,0 +1,7 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useInviteCode: () => {
+    activateInviteCode: ({ inviteCode, }: schema.IUseInviteCodeMutationVariables) => Promise<import("@apollo/client").FetchResult<schema.IUseInviteCodeMutation>>;
+    error: import("@apollo/client").ApolloError | undefined;
+    loading: boolean;
+};
+export default useInviteCode;

package/build/api/server-identities/mutations/useInviteCode/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("@/store/ui");
+const useInviteCode = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error, loading }] = api_1.identitySchema.useUseInviteCodeMutation({
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: () => {
+            openAlert({
+                ...data_1.alertSuccess,
+                caption: 'Success!',
+                text: 'Invite code applied',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { activateInviteCode, error, loading };
+    async function activateInviteCode({ inviteCode, }) {
+        return mutate({
+            variables: { inviteCode },
+        });
+    }
+};
+exports.default = useInviteCode;

package/build/api/server-identities/mutations/useRemoveWallet/index.d.ts

@@ -0,0 +1,6 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useRemoveWallet: ({ userId }: schema.IQueryFetchUserWalletsArgs) => {
+    removeWallet: ({ blockchain, address, chainId, }: schema.IMutationRemoveWalletArgs) => Promise<import("@apollo/client").FetchResult<schema.IRemoveWalletMutation>>;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export default useRemoveWallet;

package/build/api/server-identities/mutations/useRemoveWallet/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("@/store/ui");
+const useRemoveWallet = ({ userId }) => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = api_1.identitySchema.useRemoveWalletMutation({
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        refetchQueries: [
+            {
+                query: api_1.identitySchema.FetchUserWalletsDocument,
+                fetchPolicy: 'no-cache',
+                context: {
+                    uri: api_1.hosts.identityHost,
+                },
+                variables: { userId },
+            },
+        ],
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { removeWallet, error };
+    function removeWallet({ blockchain, address, chainId, }) {
+        return mutate({
+            variables: { blockchain, address, chainId },
+        });
+    }
+};
+exports.default = useRemoveWallet;

package/build/api/server-identities/mutations/useRevokeToken/index.d.ts

@@ -0,0 +1,4 @@
+declare const useRevokeToken: () => {
+    revokeToken: () => Promise<void>;
+};
+export default useRevokeToken;

package/build/api/server-identities/mutations/useRevokeToken/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useRevokeToken = () => {
+    const [mutate] = (0, client_1.useMutation)(api_1.authSchema.RevokeTokenDocument, {
+        context: {
+            uri: api_1.hosts.authHost,
+        },
+    });
+    return { revokeToken };
+    async function revokeToken() {
+        try {
+            await mutate();
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.default = useRevokeToken;