@ludo.ninja/api 1.0.4 → 1.0.6

package/build/config/index.d.ts

@@ -0,0 +1,2 @@
+import { ApolloClient, NormalizedCacheObject } from "@apollo/client";
+export declare function initializeApollo(initialState?: null): ApolloClient<NormalizedCacheObject>;

package/build/config/index.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeApollo = void 0;
+const client_1 = require("@apollo/client");
+const hosts_1 = require("../hosts");
+const schema_1 = require("../graphql_tools/__generated__/schema");
+const error_1 = require("@apollo/client/link/error");
+const context_1 = require("@apollo/client/link/context");
+const apollo_upload_client_1 = require("apollo-upload-client");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+const cookies_1 = require("../cookies");
+const typePolicies_1 = require("./typePolicies");
+let isRefreshing = false;
+let pendingRequests = [];
+const resolvePendingRequests = () => {
+    pendingRequests.map((callback) => callback());
+    pendingRequests = [];
+};
+let apolloClient;
+const errorLink = (0, error_1.onError)(({ graphQLErrors, networkError, operation, forward }) => {
+    const { authToken, refreshToken } = (0, cookies_1.getCookies)();
+    if (graphQLErrors) {
+        graphQLErrors.forEach(({ message, locations, path }) => console.warn(`[GraphQL error]: Message: ${message}, Location: ${locations}, Path: ${path}`));
+    }
+    if (networkError) {
+        console.warn(`[Network error]: ${networkError}`);
+        if (networkError.message.includes("401") && authToken) {
+            let forward$;
+            const client = apolloClient ?? createApolloClient();
+            if (!isRefreshing) {
+                isRefreshing = true;
+                forward$ = (0, client_1.fromPromise)(client
+                    .mutate({
+                    context: { uri: hosts_1.authHost },
+                    variables: { refreshToken },
+                    mutation: schema_1.RefreshTokenDocument,
+                })
+                    .then(({ data: { refreshToken: { tokenAuth, tokenRefresh }, }, }) => {
+                    (0, cookies_1.refreshCookies)(tokenAuth, tokenRefresh);
+                    resolvePendingRequests();
+                    return true;
+                })
+                    .catch(async () => {
+                    await apolloClient?.mutate({
+                        context: { uri: hosts_1.authHost },
+                        mutation: schema_1.RevokeTokenDocument,
+                    });
+                    (0, cookies_1.destroyCookies)();
+                    pendingRequests = [];
+                    window.location.reload();
+                    return false;
+                })
+                    .finally(() => {
+                    isRefreshing = false;
+                })).filter((value) => Boolean(value));
+            }
+            else {
+                forward$ = (0, client_1.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 = (0, context_1.setContext)(async (operation, { headers }) => {
+    const { authToken } = (0, cookies_1.getCookies)();
+    const header = authToken
+        ? {
+            headers: { ...headers, "x-client-authorization": `${authToken}` },
+        }
+        : { headers: { ...headers } };
+    return {
+        headers: header.headers,
+    };
+});
+const httpLink = (0, apollo_upload_client_1.createUploadLink)({
+    uri: hosts_1.authHost,
+});
+function createApolloClient() {
+    return new client_1.ApolloClient({
+        ssrMode: typeof window === "undefined",
+        link: (0, client_1.from)([errorLink, authLink, httpLink]),
+        cache: new client_1.InMemoryCache({
+            typePolicies: typePolicies_1.typePoliciesPortal,
+            addTypename: true,
+            resultCaching: true,
+        }),
+    });
+}
+function initializeApollo(initialState = null) {
+    const _apolloClient = apolloClient ?? createApolloClient();
+    // 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 = (0, deepmerge_1.default)(existingCache, initialState, {
+            // combine arrays using object equality (like in sets)
+            arrayMerge: (destinationArray, sourceArray) => [
+                ...sourceArray,
+                ...destinationArray.filter((d) => sourceArray.every((s) => !(0, lodash_isequal_1.default)(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;
+}
+exports.initializeApollo = initializeApollo;

package/build/config/typePolicies.d.ts

@@ -0,0 +1,2 @@
+import { TypePolicies } from "@apollo/client";
+export declare const typePoliciesPortal: TypePolicies;

package/build/config/typePolicies.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typePoliciesPortal = void 0;
+exports.typePoliciesPortal = {
+    Query: {
+        fields: {
+            fetchAsset: {
+                keyArgs: ["rank", "likes", "assetId"],
+                merge: true,
+            },
+            findUserCreations: {
+                keyArgs: ["itemId"],
+                merge: true,
+            },
+            fetchUserGalleries: {
+                keyArgs: ["galleryId"],
+                merge: true,
+            },
+            fetchUserFavorites: {
+                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/build/cookies/index.d.ts

@@ -0,0 +1,17 @@
+declare const assignCookies: (userId: string, wallets: Array<string>, authToken: string, refreshToken: string, newUser: string) => void;
+declare const refreshCookies: (authToken: string, refreshToken: string) => void;
+declare const getCookies: () => {
+    authToken: string;
+    refreshToken: string;
+    userId: string;
+    wallets: string;
+    newUser: string;
+} | {
+    authToken: null;
+    refreshToken: null;
+    userId: null;
+    wallets: null;
+    newUser: null;
+};
+declare const destroyCookies: () => void;
+export { assignCookies, refreshCookies, destroyCookies, getCookies };

package/build/cookies/index.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCookies = exports.destroyCookies = exports.refreshCookies = exports.assignCookies = void 0;
+const nookies_1 = require("nookies");
+const assignCookies = (userId, wallets, authToken, refreshToken, newUser) => {
+    if (userId)
+        (0, nookies_1.setCookie)(null, "userId", userId, { maxAge: 24 * 60 * 60, path: "/", domain: "ludo.ninja" });
+    if (wallets)
+        (0, nookies_1.setCookie)(null, "wallets", wallets.join(), {
+            maxAge: 24 * 60 * 60,
+            path: "/",
+            domain: "ludo.ninja",
+        });
+    if (authToken)
+        (0, nookies_1.setCookie)(null, "authToken", authToken, {
+            maxAge: 24 * 60 * 60,
+            path: "/",
+            domain: "ludo.ninja",
+        });
+    if (refreshToken)
+        (0, nookies_1.setCookie)(null, "refreshToken", refreshToken, {
+            maxAge: 24 * 60 * 60,
+            path: "/",
+            domain: "ludo.ninja",
+        });
+    if (newUser)
+        (0, nookies_1.setCookie)(null, "newUser", newUser, {
+            maxAge: 24 * 60 * 60,
+            path: "/",
+            domain: "ludo.ninja",
+        });
+};
+exports.assignCookies = assignCookies;
+const refreshCookies = (authToken, refreshToken) => {
+    if (authToken)
+        (0, nookies_1.setCookie)(null, "authToken", authToken, {
+            maxAge: 24 * 60 * 60,
+            path: "/",
+            domain: "ludo.ninja",
+        });
+    if (refreshToken)
+        (0, nookies_1.setCookie)(null, "refreshToken", refreshToken, {
+            maxAge: 24 * 60 * 60,
+            path: "/",
+            domain: "ludo.ninja",
+        });
+};
+exports.refreshCookies = refreshCookies;
+const getCookies = () => {
+    const { authToken, refreshToken, userId, wallets, newUser } = (0, nookies_1.parseCookies)();
+    if (authToken && refreshToken && userId && wallets && newUser) {
+        return {
+            authToken,
+            refreshToken,
+            userId,
+            wallets,
+            newUser,
+        };
+    }
+    return {
+        authToken: null,
+        refreshToken: null,
+        userId: null,
+        wallets: null,
+        newUser: null,
+    };
+};
+exports.getCookies = getCookies;
+const destroyCookies = () => {
+    (0, nookies_1.destroyCookie)(null, "userId", { path: "/" });
+    (0, nookies_1.destroyCookie)(null, "wallets", { path: "/" });
+    (0, nookies_1.destroyCookie)(null, "authToken", { path: "/" });
+    (0, nookies_1.destroyCookie)(null, "refreshToken", { path: "/" });
+    (0, nookies_1.destroyCookie)(null, "newUser", { path: "/" });
+};
+exports.destroyCookies = destroyCookies;