@ludo.ninja/api 1.0.21 → 1.0.22

package/src/config/index.ts

@@ -1,199 +1,199 @@
-import { ApolloClient, InMemoryCache, from, NormalizedCacheObject, fromPromise } from "@apollo/client";
-import { authHost } from "../hosts";
-import { RefreshTokenDocument, RevokeTokenDocument } from "../graphql_tools/__generated__/schema";
-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";
-
-let isRefreshing = false;
-let pendingRequests: never[] = [];
-let mainDomain = "";
-
-const resolvePendingRequests = () => {
-  pendingRequests.map((callback: any) => callback());
-  pendingRequests = [];
-};
-
-let apolloClient: ApolloClient<NormalizedCacheObject> | undefined;
-
-const errorLink = onError(({ graphQLErrors, networkError, operation, forward }) => {
-  const { authToken, refreshToken } = getCookies();
-
-  // console.log(graphQLErrors, "graphQLErrors");
-
-  if (graphQLErrors) {
-    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: authHost },
-                variables: { refreshToken },
-                mutation: RefreshTokenDocument,
-              })
-              .then(
-                ({
-                  data: {
-                    refreshToken: { tokenAuth, tokenRefresh },
-                  },
-                }) => {
-                  refreshCookies(tokenAuth, tokenRefresh, mainDomain);
-                  resolvePendingRequests();
-                  return true;
-                },
-              )
-              .catch(async () => {
-                await apolloClient?.mutate({
-                  context: { uri: authHost },
-                  mutation: 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));
-      }
-    }
-  }
-
-  if (networkError) {
-    console.warn(`[Network error]: ${networkError}`);
-
-    if (networkError.message.includes("401") && authToken) {
-      let forward$;
-      const client = apolloClient ?? createApolloClient();
-      if (!isRefreshing) {
-        isRefreshing = true;
-        forward$ = fromPromise(
-          client
-            .mutate({
-              context: { uri: authHost },
-              variables: { refreshToken },
-              mutation: RefreshTokenDocument,
-            })
-            .then(
-              ({
-                data: {
-                  refreshToken: { tokenAuth, tokenRefresh },
-                },
-              }) => {
-                refreshCookies(tokenAuth, tokenRefresh, mainDomain);
-                resolvePendingRequests();
-                return true;
-              },
-            )
-            .catch(async () => {
-              await apolloClient?.mutate({
-                context: { uri: authHost },
-                mutation: 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));
-    }
-  }
-});
-
-const authLink = setContext(async (operation, { headers }) => {
-  const { authToken } = getCookies();
-
-  const header = authToken
-    ? {
-        headers: { ...headers, "x-client-authorization": `${authToken}` },
-      }
-    : { headers: { ...headers } };
-
-  return {
-    headers: header.headers,
-  };
-});
-
-const httpLink = createUploadLink({
-  uri: authHost,
-});
-
-function createApolloClient() {
-  return new ApolloClient({
-    ssrMode: typeof window === "undefined",
-    link: from([errorLink, authLink, httpLink]),
-    cache: new InMemoryCache({
-      typePolicies: typePoliciesPortal,
-      addTypename: true,
-      resultCaching: true,
-    }),
-  });
-}
-
-export function initializeApollo(initialState = null, domain = "ludo.ninja") {
-  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;
-}
+import { ApolloClient, InMemoryCache, from, NormalizedCacheObject, fromPromise } from "@apollo/client";
+import { authHost } from "../hosts";
+import { RefreshTokenDocument, RevokeTokenDocument } from "../graphql_tools/__generated__/schema";
+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";
+
+let isRefreshing = false;
+let pendingRequests: never[] = [];
+let mainDomain = "";
+
+const resolvePendingRequests = () => {
+  pendingRequests.map((callback: any) => callback());
+  pendingRequests = [];
+};
+
+let apolloClient: ApolloClient<NormalizedCacheObject> | undefined;
+
+const errorLink = onError(({ graphQLErrors, networkError, operation, forward }) => {
+  const { authToken, refreshToken } = getCookies();
+
+  // console.log(graphQLErrors, "graphQLErrors");
+
+  if (graphQLErrors) {
+    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: authHost },
+                variables: { refreshToken },
+                mutation: RefreshTokenDocument,
+              })
+              .then(
+                ({
+                  data: {
+                    refreshToken: { tokenAuth, tokenRefresh },
+                  },
+                }) => {
+                  refreshCookies(tokenAuth, tokenRefresh, mainDomain);
+                  resolvePendingRequests();
+                  return true;
+                },
+              )
+              .catch(async () => {
+                await apolloClient?.mutate({
+                  context: { uri: authHost },
+                  mutation: 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));
+      }
+    }
+  }
+
+  if (networkError) {
+    console.warn(`[Network error]: ${networkError}`);
+
+    if (networkError.message.includes("401") && authToken) {
+      let forward$;
+      const client = apolloClient ?? createApolloClient();
+      if (!isRefreshing) {
+        isRefreshing = true;
+        forward$ = fromPromise(
+          client
+            .mutate({
+              context: { uri: authHost },
+              variables: { refreshToken },
+              mutation: RefreshTokenDocument,
+            })
+            .then(
+              ({
+                data: {
+                  refreshToken: { tokenAuth, tokenRefresh },
+                },
+              }) => {
+                refreshCookies(tokenAuth, tokenRefresh, mainDomain);
+                resolvePendingRequests();
+                return true;
+              },
+            )
+            .catch(async () => {
+              await apolloClient?.mutate({
+                context: { uri: authHost },
+                mutation: 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));
+    }
+  }
+});
+
+const authLink = setContext(async (operation, { headers }) => {
+  const { authToken } = getCookies();
+
+  const header = authToken
+    ? {
+        headers: { ...headers, "x-client-authorization": `${authToken}` },
+      }
+    : { headers: { ...headers } };
+
+  return {
+    headers: header.headers,
+  };
+});
+
+const httpLink = createUploadLink({
+  uri: authHost,
+});
+
+function createApolloClient() {
+  return new ApolloClient({
+    ssrMode: typeof window === "undefined",
+    link: from([errorLink, authLink, httpLink]),
+    cache: new InMemoryCache({
+      typePolicies: typePoliciesPortal,
+      addTypename: true,
+      resultCaching: true,
+    }),
+  });
+}
+
+export function initializeApollo(initialState = null, domain = "ludo.ninja") {
+  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/config/typePolicies.ts

@@ -1,56 +1,56 @@
-import { TypePolicies } from "@apollo/client";
-
-export const typePoliciesPortal: TypePolicies = {
-  Query: {
-    fields: {
-      fetchAsset: {
-        keyArgs: ["rank", "likes", "assetId"],
-        merge: true,
-      },
-      findUserCreations: {
-        keyArgs: ["itemId"],
-        merge: true,
-      },
-      fetchUserGalleries: {
-        keyArgs: ["galleryId"],
-        merge: true,
-      },
-      fetchUserFavorites: {
-        keyArgs: ["galleryId"],
-        merge: true,
-      },
-      fetchUserFavoritesV2: {
-        keyArgs: ["galleryId"],
-        merge: true,
-      },
-      fetchMyFavoritesV2: {
-        keyArgs: ["galleryId"],
-        merge: true,
-      },
-      fetchMyGalleriesV2: {
-        keyArgs: ["galleryId"],
-        merge: true,
-      },
-      fetchUserGalleriesV2: {
-        keyArgs: ["galleryId"],
-        merge: true,
-      },
-      fetchCreations: {
-        keyArgs: ["itemId"],
-        merge: true,
-      },
-      CollectionPage: {
-        keyArgs: ["collectionId"],
-        merge: true,
-      },
-      CreationsPage: {
-        keyArgs: ["itemId"],
-        merge: true,
-      },
-      fetchCreationsByItemType: {
-        keyArgs: ["nextPageToken"],
-        merge: true,
-      },
-    },
-  },
-};
+import { TypePolicies } from "@apollo/client";
+
+export const typePoliciesPortal: TypePolicies = {
+  Query: {
+    fields: {
+      fetchAsset: {
+        keyArgs: ["rank", "likes", "assetId"],
+        merge: true,
+      },
+      findUserCreations: {
+        keyArgs: ["itemId"],
+        merge: true,
+      },
+      fetchUserGalleries: {
+        keyArgs: ["galleryId"],
+        merge: true,
+      },
+      fetchUserFavorites: {
+        keyArgs: ["galleryId"],
+        merge: true,
+      },
+      fetchUserFavoritesV2: {
+        keyArgs: ["galleryId"],
+        merge: true,
+      },
+      fetchMyFavoritesV2: {
+        keyArgs: ["galleryId"],
+        merge: true,
+      },
+      fetchMyGalleriesV2: {
+        keyArgs: ["galleryId"],
+        merge: true,
+      },
+      fetchUserGalleriesV2: {
+        keyArgs: ["galleryId"],
+        merge: true,
+      },
+      fetchCreations: {
+        keyArgs: ["itemId"],
+        merge: true,
+      },
+      CollectionPage: {
+        keyArgs: ["collectionId"],
+        merge: true,
+      },
+      CreationsPage: {
+        keyArgs: ["itemId"],
+        merge: true,
+      },
+      fetchCreationsByItemType: {
+        keyArgs: ["nextPageToken"],
+        merge: true,
+      },
+    },
+  },
+};

package/src/cookies/index.ts

@@ -1,83 +1,83 @@
-import { destroyCookie, parseCookies, setCookie } from "nookies";
-
-const assignCookies = (
-  userId: string,
-  wallets: Array<string>,
-  authToken: string,
-  refreshToken: string,
-  newUser: string,
-  domain = "ludo.ninja",
-) => {
-  if (userId) setCookie(null, "userId", userId, { maxAge: 24 * 60 * 60, path: "/", domain });
-  if (wallets)
-    setCookie(null, "wallets", wallets.join(), {
-      maxAge: 24 * 60 * 60,
-      path: "/",
-      domain,
-    });
-  if (authToken)
-    setCookie(null, "authToken", authToken, {
-      maxAge: 24 * 60 * 60,
-      path: "/",
-      domain,
-    });
-  if (refreshToken)
-    setCookie(null, "refreshToken", refreshToken, {
-      maxAge: 24 * 60 * 60,
-      path: "/",
-      domain,
-    });
-  if (newUser)
-    setCookie(null, "newUser", newUser, {
-      maxAge: 24 * 60 * 60,
-      path: "/",
-      domain,
-    });
-};
-
-const refreshCookies = (authToken: string, refreshToken: string, domain = "ludo.ninja") => {
-  if (authToken)
-    setCookie(null, "authToken", authToken, {
-      maxAge: 24 * 60 * 60,
-      path: "/",
-      domain,
-    });
-  if (refreshToken)
-    setCookie(null, "refreshToken", refreshToken, {
-      maxAge: 24 * 60 * 60,
-      path: "/",
-      domain,
-    });
-};
-
-const getCookies = () => {
-  const { authToken, refreshToken, userId, wallets, newUser } = parseCookies();
-
-  if (authToken && refreshToken && userId && wallets && newUser) {
-    return {
-      authToken,
-      refreshToken,
-      userId,
-      wallets,
-      newUser,
-    };
-  }
-
-  return {
-    authToken: null,
-    refreshToken: null,
-    userId: null,
-    wallets: null,
-    newUser: null,
-  };
-};
-
-const destroyCookies = (domain = "ludo.ninja") => {
-  destroyCookie(null, "userId", { path: "/", domain });
-  destroyCookie(null, "wallets", { path: "/", domain });
-  destroyCookie(null, "authToken", { path: "/", domain });
-  destroyCookie(null, "refreshToken", { path: "/", domain });
-  destroyCookie(null, "newUser", { path: "/", domain });
-};
-
-export { assignCookies, refreshCookies, destroyCookies, getCookies };
+import { destroyCookie, parseCookies, setCookie } from "nookies";
+
+const assignCookies = (
+  userId: string,
+  wallets: Array<string>,
+  authToken: string,
+  refreshToken: string,
+  newUser: string,
+  domain = "ludo.ninja",
+) => {
+  if (userId) setCookie(null, "userId", userId, { maxAge: 24 * 60 * 60, path: "/", domain });
+  if (wallets)
+    setCookie(null, "wallets", wallets.join(), {
+      maxAge: 24 * 60 * 60,
+      path: "/",
+      domain,
+    });
+  if (authToken)
+    setCookie(null, "authToken", authToken, {
+      maxAge: 24 * 60 * 60,
+      path: "/",
+      domain,
+    });
+  if (refreshToken)
+    setCookie(null, "refreshToken", refreshToken, {
+      maxAge: 24 * 60 * 60,
+      path: "/",
+      domain,
+    });
+  if (newUser)
+    setCookie(null, "newUser", newUser, {
+      maxAge: 24 * 60 * 60,
+      path: "/",
+      domain,
+    });
+};
+
+const refreshCookies = (authToken: string, refreshToken: string, domain = "ludo.ninja") => {
+  if (authToken)
+    setCookie(null, "authToken", authToken, {
+      maxAge: 24 * 60 * 60,
+      path: "/",
+      domain,
+    });
+  if (refreshToken)
+    setCookie(null, "refreshToken", refreshToken, {
+      maxAge: 24 * 60 * 60,
+      path: "/",
+      domain,
+    });
+};
+
+const getCookies = () => {
+  const { authToken, refreshToken, userId, wallets, newUser } = parseCookies();
+
+  if (authToken && refreshToken && userId && wallets && newUser) {
+    return {
+      authToken,
+      refreshToken,
+      userId,
+      wallets,
+      newUser,
+    };
+  }
+
+  return {
+    authToken: null,
+    refreshToken: null,
+    userId: null,
+    wallets: null,
+    newUser: null,
+  };
+};
+
+const destroyCookies = (domain = "ludo.ninja") => {
+  destroyCookie(null, "userId", { path: "/", domain });
+  destroyCookie(null, "wallets", { path: "/", domain });
+  destroyCookie(null, "authToken", { path: "/", domain });
+  destroyCookie(null, "refreshToken", { path: "/", domain });
+  destroyCookie(null, "newUser", { path: "/", domain });
+};
+
+export { assignCookies, refreshCookies, destroyCookies, getCookies };