@ludo.ninja/api 2.6.0 → 2.6.1

package/build/config/index.d.ts

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

package/build/config/index.js

@@ -0,0 +1,186 @@
+"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 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");
+const subscriptions_1 = require("@apollo/client/link/subscriptions");
+const utilities_1 = require("@apollo/client/utilities");
+const graphql_ws_1 = require("graphql-ws");
+const index_1 = require("../index");
+let isRefreshing = false;
+let pendingRequests = [];
+let mainDomain = "";
+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}`));
+        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$ = (0, client_1.fromPromise)(client
+                        .mutate({
+                        context: { uri: index_1.hosts.authHost },
+                        variables: { refreshToken },
+                        mutation: index_1.schema.RefreshTokenDocument,
+                    })
+                        .then(({ data: { refreshToken: { tokenAuth, tokenRefresh }, }, }) => {
+                        console.log(tokenAuth, "newAuthToken");
+                        (0, cookies_1.refreshCookies)(tokenAuth, tokenRefresh, mainDomain);
+                        resolvePendingRequests();
+                        return true;
+                    })
+                        .catch(async () => {
+                        await apolloClient?.mutate({
+                            context: { uri: index_1.hosts.authHost },
+                            mutation: index_1.schema.RevokeTokenDocument,
+                        });
+                        (0, cookies_1.destroyCookies)(mainDomain);
+                        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));
+            }
+        }
+    }
+    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: index_1.hosts.authHost },
+                    variables: { refreshToken },
+                    mutation: index_1.schema.RefreshTokenDocument,
+                })
+                    .then(({ data: { refreshToken: { tokenAuth, tokenRefresh }, }, }) => {
+                    (0, cookies_1.refreshCookies)(tokenAuth, tokenRefresh, mainDomain);
+                    resolvePendingRequests();
+                    return true;
+                })
+                    .catch(async () => {
+                    await apolloClient?.mutate({
+                        context: { uri: index_1.hosts.authHost },
+                        mutation: index_1.schema.RevokeTokenDocument,
+                    });
+                    (0, cookies_1.destroyCookies)(mainDomain);
+                    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: index_1.hosts.authHost,
+});
+const wsLink = typeof window !== "undefined"
+    ? new subscriptions_1.GraphQLWsLink((0, graphql_ws_1.createClient)({
+        url: index_1.hosts.experiencesSubscriptionHost,
+        retryAttempts: 3,
+        on: {
+            connected: () => console.log("GraphQLWsLink connected"),
+            closed: () => console.log("GraphQLWsLink closed"),
+        },
+    }))
+    : null;
+const opsLink = (0, client_1.from)([errorLink, authLink, httpLink]);
+const terminatingLink = typeof window !== "undefined" && wsLink !== null
+    ? (0, client_1.split)(({ query }) => {
+        const definition = (0, utilities_1.getMainDefinition)(query);
+        return definition.kind === "OperationDefinition" && definition.operation === "subscription";
+    }, wsLink, opsLink)
+    : httpLink;
+function createApolloClient() {
+    return new client_1.ApolloClient({
+        ssrMode: typeof window === "undefined",
+        link: terminatingLink,
+        cache: new client_1.InMemoryCache({
+            typePolicies: typePolicies_1.typePoliciesPortal,
+            addTypename: true,
+            resultCaching: true,
+        }),
+    });
+}
+function initializeApollo(initialState = null, domain) {
+    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 = (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,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typePoliciesPortal = void 0;
+exports.typePoliciesPortal = {
+    Query: {
+        fields: {
+            fetchAsset: {
+                keyArgs: ["rank", "likes", "assetId"],
+                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,
+            },
+            fetchCreationsByType: {
+                keyArgs: ["nextPageToken"],
+                merge: true,
+            },
+            fetchAllCreations: {
+                keyArgs: ["nextPageToken"],
+                merge: true,
+            },
+        },
+    },
+};

package/build/cookies/index.d.ts

@@ -0,0 +1,25 @@
+import * as express from "express";
+import * as next from 'next';
+declare const assignCookies: (userId: string, wallets: Array<string>, authToken: string, refreshToken: string, newUser: string, inviteCode: string, domain?: string) => void;
+declare const refreshCookies: (authToken: string, refreshToken: string, domain?: string) => void;
+declare const getCookies: (ctx?: Pick<next.NextPageContext, 'req'> | {
+    req: next.NextApiRequest;
+} | {
+    req: express.Request;
+} | null | undefined) => {
+    authToken: null;
+    refreshToken: null;
+    userId: null;
+    wallets: null;
+    newUser: null;
+    inviteCode: null;
+} | {
+    authToken: string;
+    refreshToken: string;
+    userId: string;
+    wallets: string[];
+    newUser: string;
+    inviteCode: string;
+};
+declare const destroyCookies: (domain?: string) => void;
+export { assignCookies, refreshCookies, destroyCookies, getCookies };

package/build/cookies/index.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCookies = exports.destroyCookies = exports.refreshCookies = exports.assignCookies = void 0;
+const nookies_1 = require("nookies");
+// handle change version when update cookies structure
+const cookiesVersion = '1.0.1';
+const addVersionCookies = (domain) => {
+    (0, nookies_1.setCookie)(null, "versionAuth", cookiesVersion, {
+        maxAge: 2629800000,
+        path: "/",
+        domain,
+        sameSite: true,
+    });
+};
+const validationVersion = (version) => version === cookiesVersion;
+const assignCookies = (userId, wallets, authToken, refreshToken, newUser, inviteCode, domain) => {
+    addVersionCookies(domain);
+    if (userId)
+        (0, nookies_1.setCookie)(null, "userId", userId, { maxAge: 2629800000, path: "/", domain });
+    if (wallets)
+        (0, nookies_1.setCookie)(null, "wallets", encodeURIComponent(JSON.stringify(wallets)), {
+            maxAge: 2629800000,
+            path: "/",
+            domain,
+            sameSite: true,
+        });
+    if (authToken)
+        (0, nookies_1.setCookie)(null, "authToken", authToken, {
+            maxAge: 2629800000,
+            path: "/",
+            domain,
+            sameSite: true,
+        });
+    if (refreshToken)
+        (0, nookies_1.setCookie)(null, "refreshToken", refreshToken, {
+            maxAge: 2629800000,
+            path: "/",
+            domain,
+            sameSite: true,
+        });
+    if (newUser)
+        (0, nookies_1.setCookie)(null, "newUser", newUser, {
+            maxAge: 2629800000,
+            path: "/",
+            domain,
+            sameSite: true,
+        });
+    if (inviteCode)
+        (0, nookies_1.setCookie)(null, "inviteCode", inviteCode, {
+            maxAge: 2629800000,
+            path: "/",
+            domain,
+            sameSite: true,
+        });
+};
+exports.assignCookies = assignCookies;
+const refreshCookies = (authToken, refreshToken, domain) => {
+    if (authToken)
+        (0, nookies_1.setCookie)(null, "authToken", authToken, {
+            maxAge: 2629800000,
+            path: "/",
+            domain,
+            sameSite: true,
+        });
+    if (refreshToken)
+        (0, nookies_1.setCookie)(null, "refreshToken", refreshToken, {
+            maxAge: 2629800000,
+            path: "/",
+            domain,
+            sameSite: true,
+        });
+};
+exports.refreshCookies = refreshCookies;
+const getCookies = (ctx) => {
+    const { authToken, refreshToken, userId, wallets, newUser, inviteCode, versionAuth } = (0, nookies_1.parseCookies)(ctx);
+    const nullResult = {
+        authToken: null,
+        refreshToken: null,
+        userId: null,
+        wallets: null,
+        newUser: null,
+        inviteCode: null,
+    };
+    if (authToken && refreshToken && userId && wallets && newUser && inviteCode && versionAuth && validationVersion(versionAuth)) {
+        let walletsParsed;
+        try {
+            walletsParsed = JSON.parse(decodeURIComponent(wallets));
+            if (!Array.isArray(walletsParsed)) {
+                return nullResult;
+            }
+        }
+        catch (e) {
+            return nullResult;
+        }
+        return {
+            authToken,
+            refreshToken,
+            userId,
+            wallets: walletsParsed,
+            newUser,
+            inviteCode,
+        };
+    }
+    return nullResult;
+};
+exports.getCookies = getCookies;
+const destroyCookies = (domain) => {
+    (0, nookies_1.destroyCookie)(null, "userId", { path: "/", domain });
+    (0, nookies_1.destroyCookie)(null, "wallets", { path: "/", domain });
+    (0, nookies_1.destroyCookie)(null, "authToken", { path: "/", domain });
+    (0, nookies_1.destroyCookie)(null, "refreshToken", { path: "/", domain });
+    (0, nookies_1.destroyCookie)(null, "newUser", { path: "/", domain });
+    (0, nookies_1.destroyCookie)(null, "inviteCode", { path: "/", domain });
+};
+exports.destroyCookies = destroyCookies;