@ludo.ninja/api 2.8.57 → 2.8.59

package/src/config/index.ts

@@ -7,17 +7,17 @@ import {
   split,
   ApolloLink,
 } from "@apollo/client";
-import {onError} from "@apollo/client/link/error";
-import {setContext} from "@apollo/client/link/context";
-import {createUploadLink} from "apollo-upload-client";
+import { onError } from "@apollo/client/link/error";
+import { setContext } from "@apollo/client/link/context";
+import { createUploadLink } from "apollo-upload-client";
 import merge from "deepmerge";
 import isEqual from "lodash.isequal";
-import {destroyCookies, getCookies, refreshCookies} from "../cookies";
-import {typePoliciesPortal} from "./typePolicies";
-import {GraphQLWsLink} from "@apollo/client/link/subscriptions";
-import {getMainDefinition} from "@apollo/client/utilities";
-import {createClient} from "graphql-ws";
-import {hosts, authSchema as schema} from "../index";
+import { destroyCookies, getCookies, refreshCookies } from "../cookies";
+import { typePoliciesPortal } from "./typePolicies";
+import { GraphQLWsLink } from "@apollo/client/link/subscriptions";
+import { getMainDefinition } from "@apollo/client/utilities";
+import { createClient } from "graphql-ws";
+import { hosts, authSchema as schema } from "../index";
 
 let isRefreshing = false;
 let pendingRequests: never[] = [];
@@ -30,63 +30,59 @@ const resolvePendingRequests = () => {
 
 let apolloClient: ApolloClient<NormalizedCacheObject> | undefined;
 
-const errorLink = onError(({graphQLErrors, networkError, operation, forward}) => {
-  const {authToken, refreshToken} = getCookies();
+const handleTokenRefresh = (operation: any, forward: any) => {
+  const { refreshToken } = getCookies();
+  const client = apolloClient ?? createApolloClient();
+
+  if (!isRefreshing) {
+    isRefreshing = true;
+    return fromPromise(
+      client
+        .mutate({
+          context: { uri: hosts.authHost },
+          variables: { refreshToken },
+          mutation: schema.RefreshTokenDocument,
+        })
+        .then(({ data: { refreshToken: { tokenAuth, tokenRefresh } } }) => {
+          refreshCookies(tokenAuth, tokenRefresh, mainDomain);
+          resolvePendingRequests();
+          return true;
+        })
+        .catch(async () => {
+          await apolloClient?.mutate({
+            context: { uri: hosts.authHost },
+            mutation: schema.RevokeTokenDocument,
+          });
+          destroyCookies(mainDomain);
+          pendingRequests = [];
+          window.location.reload();
+          return false;
+        })
+        .finally(() => {
+          isRefreshing = false;
+        })
+    ).filter((value) => Boolean(value));
+  } else {
+    return fromPromise(
+      new Promise((resolve) => {
+        // @ts-ignore
+        pendingRequests.push(() => resolve());
+      })
+    );
+  }
+};
+
+const errorLink = onError(({ graphQLErrors, networkError, operation, forward }) => {
+  const { authToken } = getCookies();
 
   if (graphQLErrors) {
-    graphQLErrors.forEach(({message, locations, path}) =>
-      console.warn(`[GraphQL error]: Message: ${message}, Location: ${locations}, Path: ${path}`),
+    graphQLErrors.forEach(({ message, locations, path }) =>
+      console.warn(`[GraphQL error]: Message: ${message}, Location: ${locations}, Path: ${path}`)
     );
 
     for (const err of graphQLErrors) {
       if (err.message.includes("Auth token not found") && authToken) {
-        let forward$;
-        const client = apolloClient ?? createApolloClient();
-        if (!isRefreshing) {
-          isRefreshing = true;
-          forward$ = fromPromise(
-            client
-              .mutate({
-                context: {uri: hosts.authHost},
-                variables: {refreshToken},
-                mutation: schema.RefreshTokenDocument,
-              })
-              .then(
-                ({
-                   data: {
-                     refreshToken: {tokenAuth, tokenRefresh},
-                   },
-                 }) => {
-                  refreshCookies(tokenAuth, tokenRefresh, mainDomain);
-                  resolvePendingRequests();
-                  return true;
-                },
-              )
-              .catch(async () => {
-                await apolloClient?.mutate({
-                  context: {uri: hosts.authHost},
-                  mutation: schema.RevokeTokenDocument,
-                });
-
-                destroyCookies(mainDomain);
-                pendingRequests = [];
-                window.location.reload();
-                return false;
-              })
-              .finally(() => {
-                isRefreshing = false;
-              }),
-          ).filter((value) => Boolean(value));
-        } else {
-          forward$ = fromPromise(
-            new Promise((resolve) => {
-              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-              // @ts-ignore
-              pendingRequests.push(() => resolve());
-            }),
-          );
-        }
-        return forward$.flatMap(() => forward(operation));
+        return handleTokenRefresh(operation, forward).flatMap(() => forward(operation));
       }
     }
   }
@@ -94,66 +90,24 @@ const errorLink = onError(({graphQLErrors, networkError, operation, forward}) =>
   if (networkError) {
     console.warn(`[Network error]: ${networkError}`);
 
+    if (networkError.message.includes("503")) {
+      console.error(`[503 Service Unavailable]: ${networkError.message}`);
+    }
+
     if (networkError.message.includes("401") && authToken) {
-      let forward$;
-      const client = apolloClient ?? createApolloClient();
-      if (!isRefreshing) {
-        isRefreshing = true;
-        forward$ = fromPromise(
-          client
-            .mutate({
-              context: {uri: hosts.authHost},
-              variables: {refreshToken},
-              mutation: schema.RefreshTokenDocument,
-            })
-            .then(
-              ({
-                 data: {
-                   refreshToken: {tokenAuth, tokenRefresh},
-                 },
-               }) => {
-                refreshCookies(tokenAuth, tokenRefresh, mainDomain);
-                resolvePendingRequests();
-                return true;
-              },
-            )
-            .catch(async () => {
-              await apolloClient?.mutate({
-                context: {uri: hosts.authHost},
-                mutation: schema.RevokeTokenDocument,
-              });
-
-              destroyCookies(mainDomain);
-              pendingRequests = [];
-              window.location.reload();
-              return false;
-            })
-            .finally(() => {
-              isRefreshing = false;
-            }),
-        ).filter((value) => Boolean(value));
-      } else {
-        forward$ = fromPromise(
-          new Promise((resolve) => {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            pendingRequests.push(() => resolve());
-          }),
-        );
-      }
-      return forward$.flatMap(() => forward(operation));
+      return handleTokenRefresh(operation, forward).flatMap(() => forward(operation));
     }
   }
 });
 
-const authLink = setContext(async (operation, {headers}) => {
-  const {authToken} = getCookies();
+const authLink = setContext(async (operation, { headers }) => {
+  const { authToken } = getCookies();
 
   const header = authToken
     ? {
-      headers: {...headers, "x-client-authorization": `${authToken}`},
+      headers: { ...headers, "x-client-authorization": `${authToken}` },
     }
-    : {headers: {...headers}};
+    : { headers: { ...headers } };
 
   return {
     headers: header.headers,
@@ -174,7 +128,7 @@ const wsLink =
           connected: () => console.log("GraphQLWsLink connected"),
           closed: () => console.log("GraphQLWsLink closed"),
         },
-      }),
+      })
     )
     : null;
 
@@ -183,12 +137,12 @@ const opsLink: ApolloLink = from([errorLink, authLink, httpLink as unknown as Ap
 const terminatingLink =
   typeof window !== "undefined" && wsLink !== null
     ? split(
-      ({query}) => {
+      ({ query }) => {
         const definition = getMainDefinition(query);
         return definition.kind === "OperationDefinition" && definition.operation === "subscription";
       },
       wsLink,
-      opsLink,
+      opsLink
     )
     : httpLink;
 
@@ -198,8 +152,8 @@ function createApolloClient() {
     link: terminatingLink as ApolloLink,
     cache: new InMemoryCache({
       typePolicies: typePoliciesPortal,
-        addTypename: true,
-        resultCaching: true,
+      addTypename: true,
+      resultCaching: true,
     }),
   });
 }
@@ -208,27 +162,19 @@ export function initializeApollo(initialState = null, domain?: string) {
   const _apolloClient = apolloClient ?? createApolloClient();
   mainDomain = domain || '';
 
-  // If your page has Next.js data fetching methods that use Apollo Client, the initial state
-  // gets hydrated here
   if (initialState) {
-    // Get existing cache, loaded during client side data fetching
     const existingCache = _apolloClient.extract();
-
-    // Merge the initialState from getStaticProps/getServerSideProps in the existing cache
     const data = merge(existingCache, initialState, {
-      // combine arrays using object equality (like in sets)
       arrayMerge: (destinationArray, sourceArray) => [
         ...sourceArray,
         ...destinationArray.filter((d) => sourceArray.every((s) => !isEqual(d, s))),
       ],
     });
 
-    // Restore the cache with the merged data
     _apolloClient.cache.restore(data);
   }
-  // For SSG and SSR always create a new Apollo Client
+
   if (typeof window === "undefined") return _apolloClient;
-  // Create the Apollo Client once in the client
   if (!apolloClient) apolloClient = _apolloClient;
 
   return _apolloClient;

package/src/graphql_tools/__generated__/adminHost/schema.ts

@@ -554,6 +554,7 @@ export type IQuery = {
   fetchFormOpportunityPage: IFormOpportunityPage;
   fetchPartnershipInquiryPage: IPartnershipInquiryPage;
   fetchUserFeedbackPage: IUserFeedbackPage;
+  fetchRegistrationInvitePage: IRegistrationInvitePage;
   fetchAdminInvitesPage: IInvitesPage;
   fetchAdminOpportunitiesPage: IOpportunitiesPage;
   fetchAdminCategories: Array<IAdminCategory>;
@@ -609,6 +610,13 @@ export type IQueryFetchUserFeedbackPageArgs = {
 };
 
 
+export type IQueryFetchRegistrationInvitePageArgs = {
+  filter: IRegistrationInviteFilterInput;
+  sort: IRegistrationInviteSortInput;
+  page: IAdminPageInput;
+};
+
+
 export type IQueryFetchAdminInvitesPageArgs = {
   filter: IInvitesFilterInput;
   sort: IInvitesSortInput;
@@ -682,6 +690,29 @@ export type IReferredUsersInfo = {
   referredUsersPerUrlNum: Scalars['Int'];
 };
 
+export type IRegistrationInvite = {
+  id: Scalars['String'];
+  userId?: Maybe<Scalars['String']>;
+  ludoIdOrAddress?: Maybe<Scalars['String']>;
+  reason?: Maybe<Scalars['String']>;
+};
+
+export type IRegistrationInviteFilterInput = {
+  idTerm?: Maybe<Scalars['String']>;
+  userIdTerm?: Maybe<Scalars['String']>;
+  ludoIdOrAddressTerm?: Maybe<Scalars['String']>;
+  reasonTerm?: Maybe<Scalars['String']>;
+};
+
+export type IRegistrationInvitePage = {
+  registrationInvites: Array<IRegistrationInvite>;
+  nextPage?: Maybe<IAdminPage>;
+};
+
+export type IRegistrationInviteSortInput = {
+  sortByUserId?: Maybe<ISort>;
+};
+
 export type ISort = {
   enabled: Scalars['Boolean'];
   direction?: Maybe<ISortDirection>;
@@ -916,6 +947,10 @@ export type IResolversTypes = {
   ReferralsPage: ResolverTypeWrapper<IReferralsPage>;
   ReferralsSortInput: IReferralsSortInput;
   ReferredUsersInfo: ResolverTypeWrapper<IReferredUsersInfo>;
+  RegistrationInvite: ResolverTypeWrapper<IRegistrationInvite>;
+  RegistrationInviteFilterInput: IRegistrationInviteFilterInput;
+  RegistrationInvitePage: ResolverTypeWrapper<IRegistrationInvitePage>;
+  RegistrationInviteSortInput: IRegistrationInviteSortInput;
   Sort: ISort;
   SortDirection: ISortDirection;
   Upload: ResolverTypeWrapper<Scalars['Upload']>;
@@ -991,6 +1026,10 @@ export type IResolversParentTypes = {
   ReferralsPage: IReferralsPage;
   ReferralsSortInput: IReferralsSortInput;
   ReferredUsersInfo: IReferredUsersInfo;
+  RegistrationInvite: IRegistrationInvite;
+  RegistrationInviteFilterInput: IRegistrationInviteFilterInput;
+  RegistrationInvitePage: IRegistrationInvitePage;
+  RegistrationInviteSortInput: IRegistrationInviteSortInput;
   Sort: ISort;
   Upload: Scalars['Upload'];
   UserFeedback: IUserFeedback;
@@ -1285,6 +1324,7 @@ export type IQueryResolvers<ContextType = any, ParentType extends IResolversPare
   fetchFormOpportunityPage?: Resolver<IResolversTypes['FormOpportunityPage'], ParentType, ContextType, RequireFields<IQueryFetchFormOpportunityPageArgs, 'filter' | 'sort' | 'page'>>;
   fetchPartnershipInquiryPage?: Resolver<IResolversTypes['PartnershipInquiryPage'], ParentType, ContextType, RequireFields<IQueryFetchPartnershipInquiryPageArgs, 'filter' | 'sort' | 'page'>>;
   fetchUserFeedbackPage?: Resolver<IResolversTypes['UserFeedbackPage'], ParentType, ContextType, RequireFields<IQueryFetchUserFeedbackPageArgs, 'filter' | 'sort' | 'page'>>;
+  fetchRegistrationInvitePage?: Resolver<IResolversTypes['RegistrationInvitePage'], ParentType, ContextType, RequireFields<IQueryFetchRegistrationInvitePageArgs, 'filter' | 'sort' | 'page'>>;
   fetchAdminInvitesPage?: Resolver<IResolversTypes['InvitesPage'], ParentType, ContextType, RequireFields<IQueryFetchAdminInvitesPageArgs, 'filter' | 'sort' | 'page'>>;
   fetchAdminOpportunitiesPage?: Resolver<IResolversTypes['OpportunitiesPage'], ParentType, ContextType, RequireFields<IQueryFetchAdminOpportunitiesPageArgs, 'filter' | 'sort' | 'page'>>;
   fetchAdminCategories?: Resolver<Array<IResolversTypes['AdminCategory']>, ParentType, ContextType>;
@@ -1310,6 +1350,20 @@ export type IReferredUsersInfoResolvers<ContextType = any, ParentType extends IR
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 
+export type IRegistrationInviteResolvers<ContextType = any, ParentType extends IResolversParentTypes['RegistrationInvite'] = IResolversParentTypes['RegistrationInvite']> = {
+  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  userId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  ludoIdOrAddress?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  reason?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IRegistrationInvitePageResolvers<ContextType = any, ParentType extends IResolversParentTypes['RegistrationInvitePage'] = IResolversParentTypes['RegistrationInvitePage']> = {
+  registrationInvites?: Resolver<Array<IResolversTypes['RegistrationInvite']>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['AdminPage']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
 export interface IUploadScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Upload'], any> {
   name: 'Upload';
 }
@@ -1382,6 +1436,8 @@ export type IResolvers<ContextType = any> = {
   Query?: IQueryResolvers<ContextType>;
   ReferralsPage?: IReferralsPageResolvers<ContextType>;
   ReferredUsersInfo?: IReferredUsersInfoResolvers<ContextType>;
+  RegistrationInvite?: IRegistrationInviteResolvers<ContextType>;
+  RegistrationInvitePage?: IRegistrationInvitePageResolvers<ContextType>;
   Upload?: GraphQLScalarType;
   UserFeedback?: IUserFeedbackResolvers<ContextType>;
   UserFeedbackPage?: IUserFeedbackPageResolvers<ContextType>;
@@ -1512,6 +1568,15 @@ export type IFetchPartnershipInquiryPageQueryVariables = Exact<{
 
 export type IFetchPartnershipInquiryPageQuery = { fetchPartnershipInquiryPage: { partnershipInquiries: Array<Pick<IAdminPartnershipInquiry, 'userId' | 'id' | 'email' | 'name' | 'projectName' | 'website' | 'aboutProject' | 'partnershipType' | 'ludoReferrerInfo'>>, nextPage?: Maybe<Pick<IAdminPage, 'elements' | 'lastNum' | 'num' | 'size' | 'token'>> } };
 
+export type IFetchRegistrationInvitePageQueryVariables = Exact<{
+  filter: IRegistrationInviteFilterInput;
+  sort: IRegistrationInviteSortInput;
+  page: IAdminPageInput;
+}>;
+
+
+export type IFetchRegistrationInvitePageQuery = { fetchRegistrationInvitePage: { registrationInvites: Array<Pick<IRegistrationInvite, 'userId' | 'id' | 'ludoIdOrAddress' | 'reason'>>, nextPage?: Maybe<Pick<IAdminPage, 'elements' | 'lastNum' | 'num' | 'size' | 'token'>> } };
+
 export type IFetchUserFeedbackPageQueryVariables = Exact<{
   filter: IUserFeedbackFilterInput;
   sort: IUserFeedbackSortInput;
@@ -2149,6 +2214,53 @@ export function useFetchPartnershipInquiryPageLazyQuery(baseOptions?: Apollo.Laz
 export type FetchPartnershipInquiryPageQueryHookResult = ReturnType<typeof useFetchPartnershipInquiryPageQuery>;
 export type FetchPartnershipInquiryPageLazyQueryHookResult = ReturnType<typeof useFetchPartnershipInquiryPageLazyQuery>;
 export type FetchPartnershipInquiryPageQueryResult = Apollo.QueryResult<IFetchPartnershipInquiryPageQuery, IFetchPartnershipInquiryPageQueryVariables>;
+export const FetchRegistrationInvitePageDocument = gql`
+    query FetchRegistrationInvitePage($filter: RegistrationInviteFilterInput!, $sort: RegistrationInviteSortInput!, $page: AdminPageInput!) {
+  fetchRegistrationInvitePage(filter: $filter, sort: $sort, page: $page) {
+    registrationInvites {
+      userId
+      id
+      ludoIdOrAddress
+      reason
+    }
+    nextPage {
+      elements
+      lastNum
+      num
+      size
+      token
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchRegistrationInvitePageQuery__
+ *
+ * To run a query within a React component, call `useFetchRegistrationInvitePageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchRegistrationInvitePageQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFetchRegistrationInvitePageQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      sort: // value for 'sort'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchRegistrationInvitePageQuery(baseOptions: Apollo.QueryHookOptions<IFetchRegistrationInvitePageQuery, IFetchRegistrationInvitePageQueryVariables>) {
+        return Apollo.useQuery<IFetchRegistrationInvitePageQuery, IFetchRegistrationInvitePageQueryVariables>(FetchRegistrationInvitePageDocument, baseOptions);
+      }
+export function useFetchRegistrationInvitePageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchRegistrationInvitePageQuery, IFetchRegistrationInvitePageQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchRegistrationInvitePageQuery, IFetchRegistrationInvitePageQueryVariables>(FetchRegistrationInvitePageDocument, baseOptions);
+        }
+export type FetchRegistrationInvitePageQueryHookResult = ReturnType<typeof useFetchRegistrationInvitePageQuery>;
+export type FetchRegistrationInvitePageLazyQueryHookResult = ReturnType<typeof useFetchRegistrationInvitePageLazyQuery>;
+export type FetchRegistrationInvitePageQueryResult = Apollo.QueryResult<IFetchRegistrationInvitePageQuery, IFetchRegistrationInvitePageQueryVariables>;
 export const FetchUserFeedbackPageDocument = gql`
     query FetchUserFeedbackPage($filter: UserFeedbackFilterInput!, $sort: UserFeedbackSortInput!, $page: AdminPageInput!) {
   fetchUserFeedbackPage(filter: $filter, sort: $sort, page: $page) {