@opexa/portal-components 0.0.83 → 0.0.84

package/dist/utils/graphqlRequest.js

@@ -0,0 +1,255 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BYPASS_RECAPTCHA, PLATFORM_CODE, PLATFORM_ID, SITE_ID, TEST_PASS_HEADER_KEY, } from '../constants/index.js';
+export async function graphqlRequest(url, query, variables, options) {
+    const headers = new Headers();
+    headers.set('Role', 'MEMBER');
+    headers.set('Site-ID', SITE_ID);
+    headers.set('Platform-ID', PLATFORM_ID);
+    headers.set('Platform-Code', PLATFORM_CODE);
+    headers.set('Accept', 'application/json');
+    headers.set('Content-Type', 'application/json');
+    new Headers(options?.headers).forEach((value, key) => {
+        headers.set(key, value);
+    });
+    if (BYPASS_RECAPTCHA) {
+        headers.set(TEST_PASS_HEADER_KEY, '');
+    }
+    const info = getOperationInfo(query);
+    const url_ = new URL(url);
+    if (info) {
+        url_.searchParams.set(`_${info.type}`, info.name);
+    }
+    try {
+        const response = await fetch(url_, {
+            ...options,
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                query,
+                variables,
+            }),
+        });
+        if (response.status === 400) {
+            const error = new Error();
+            error.name = 'GraphQLRequestError';
+            error.message = 'Bad Request';
+            Error.captureStackTrace?.(error, graphqlRequest);
+            throw error;
+        }
+        if (response.status === 401) {
+            const error = new Error();
+            error.name = 'GraphQLRequestError';
+            error.message = 'Unauthorized';
+            Error.captureStackTrace?.(error, graphqlRequest);
+            throw error;
+        }
+        if (response.status === 403) {
+            const error = new Error();
+            error.name = 'GraphQLRequestError';
+            error.message = 'Forbidden';
+            Error.captureStackTrace?.(error, graphqlRequest);
+            throw error;
+        }
+        if (!response.ok) {
+            const error = new Error();
+            error.name = 'GraphQLRequestError';
+            error.message = 'Network error';
+            Error.captureStackTrace?.(error, graphqlRequest);
+            throw error;
+        }
+        const obj = (await response.json());
+        if (!obj.errors?.length)
+            return obj.data;
+        const error = new Error();
+        if (obj.errors[0].extensions?.code === 'FORBIDDEN') {
+            error.name = 'GraphQLRequestError';
+            error.message = 'Forbidden';
+        }
+        else if (obj.errors[0].extensions?.code === 'ACCESS_TOKEN_EXPIRED') {
+            error.name = 'GraphQLRequestError';
+            error.message = 'Access Token Expired';
+        }
+        else if (obj.errors[0].extensions?.code === 'UNAUTHORIZED') {
+            error.name = 'GraphQLRequestError';
+            error.message = 'Unauthorized';
+        }
+        else if (obj.errors[0].extensions?.code === 'BAD_USER_INPUT') {
+            error.name = 'GraphQLRequestError';
+            error.message = 'Bad User Input';
+        }
+        else if (obj.errors[0].extensions?.code === 'BAD_REQUEST') {
+            error.name = 'GraphQLRequestError';
+            error.message = 'Bad Request';
+        }
+        else {
+            error.name = 'GraphQLRequestError';
+            error.message = 'Internal Server Error';
+        }
+        Error.captureStackTrace?.(error, graphqlRequest);
+        throw error;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        else {
+            const e = new Error();
+            e.name = 'GraphQLRequestError';
+            e.message = 'Network error';
+            Error.captureStackTrace?.(e, graphqlRequest);
+            throw e;
+        }
+    }
+}
+export async function graphqlUpload(url, query, variables, options) {
+    const headers = new Headers();
+    new Headers(options?.headers).forEach((value, key) => {
+        headers.set(key, value);
+    });
+    headers.set('Role', 'MEMBER');
+    headers.set('Site-ID', SITE_ID);
+    headers.set('Platform-ID', PLATFORM_ID);
+    headers.set('Platform-Code', PLATFORM_CODE);
+    headers.delete('Content-Type');
+    if (BYPASS_RECAPTCHA) {
+        headers.set(TEST_PASS_HEADER_KEY, '');
+    }
+    const body = createUploadBody(query, variables);
+    const info = getOperationInfo(query);
+    const url_ = new URL(url);
+    if (info) {
+        url_.searchParams.set(`_${info.type}`, info.name);
+    }
+    try {
+        const response = await fetch(url_, {
+            ...options,
+            method: 'POST',
+            headers,
+            body,
+        });
+        if (response.status === 400) {
+            const error = new Error();
+            error.name = 'GraphQLUploadError';
+            error.message = 'Bad Request';
+            Error.captureStackTrace?.(error, graphqlUpload);
+            throw error;
+        }
+        if (response.status === 401) {
+            const error = new Error();
+            error.name = 'GraphQLUploadError';
+            error.message = 'Unauthorized';
+            Error.captureStackTrace?.(error, graphqlUpload);
+            throw error;
+        }
+        if (response.status === 403) {
+            const error = new Error();
+            error.name = 'GraphQLUploadError';
+            error.message = 'Forbidden';
+            Error.captureStackTrace?.(error, graphqlUpload);
+            throw error;
+        }
+        if (!response.ok) {
+            const error = new Error();
+            error.name = 'GraphQLUploadError';
+            error.message = 'Failed to upload file';
+            Error.captureStackTrace?.(error, graphqlUpload);
+            throw error;
+        }
+        const obj = (await response.json());
+        if (!obj.errors?.length)
+            return obj.data;
+        const error = new Error();
+        if (obj.errors[0].extensions?.code === 'FORBIDDEN') {
+            error.name = 'GraphQLUploadError';
+            error.message = 'Forbidden';
+        }
+        else if (obj.errors[0].extensions?.code === 'ACCESS_TOKEN_EXPIRED') {
+            error.name = 'GraphQLUploadError';
+            error.message = 'Access Token Expired';
+        }
+        else if (obj.errors[0].extensions?.code === 'UNAUTHORIZED') {
+            error.name = 'GraphQLUploadError';
+            error.message = 'Unauthorized';
+        }
+        else if (obj.errors[0].extensions?.code === 'BAD_USER_INPUT') {
+            error.name = 'GraphQLUploadError';
+            error.message = 'Bad User Input';
+        }
+        else if (obj.errors[0].extensions?.code === 'BAD_REQUEST') {
+            error.name = 'GraphQLUploadError';
+            error.message = 'Bad Request';
+        }
+        else {
+            error.name = 'GraphQLUploadError';
+            error.message = 'Internal Server Error';
+        }
+        Error.captureStackTrace?.(error, graphqlUpload);
+        throw error;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        else {
+            const error = new Error();
+            error.name = 'GraphQLUploadError';
+            error.message = 'Network error';
+            Error.captureStackTrace?.(error, graphqlUpload);
+            throw error;
+        }
+    }
+}
+function getOperationInfo(query) {
+    const l = query.match(/(query|mutation)\s+(\w+)/);
+    if (!l)
+        return null;
+    const k = l.at(1);
+    const v = l.at(2);
+    return k && v ? { type: k, name: v } : null;
+}
+function createUploadBody(query, variables) {
+    const files = pair(variables).filter((o) => o.value instanceof File || o.value instanceof Blob);
+    const body = new FormData();
+    body.append('operations', JSON.stringify({
+        query,
+        variables,
+    }));
+    const map = {};
+    files.forEach((o, i) => {
+        map[i.toString()] = [`variables.${o.key.join('.')}`];
+    });
+    body.append('map', JSON.stringify(map));
+    files.forEach((o, i) => {
+        body.append(i.toString(), o.value);
+    });
+    return body;
+}
+function isPlainObject(value) {
+    return (Object.prototype.toString.call(value) === '[object Object]' &&
+        Object(value) === value);
+}
+function pair(value) {
+    const result = [];
+    function fn(o, parentKeys = []) {
+        for (const k in o) {
+            const v = o[k];
+            if (isPlainObject(v)) {
+                fn(v, [...parentKeys, k]);
+            }
+            else if (Array.isArray(v)) {
+                fn([...parentKeys, k].reduce((o, v, i) => {
+                    o[i] = v;
+                    return o;
+                }, {}));
+            }
+            else {
+                result.push({
+                    key: [...parentKeys, k],
+                    value: v,
+                });
+            }
+        }
+    }
+    fn(value);
+    return result;
+}

package/dist/utils/httpRequest.d.ts

@@ -0,0 +1,6 @@
+export interface HttpRequestOptions extends RequestInit {
+}
+export declare function httpRequest(url: string, opts?: HttpRequestOptions): Promise<Response>;
+export declare namespace httpRequest {
+    var json: <T>(url: string, opts?: HttpRequestOptions) => Promise<T>;
+}

package/dist/utils/httpRequest.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { BYPASS_RECAPTCHA, PLATFORM_CODE, PLATFORM_ID, SITE_ID, TEST_PASS_HEADER_KEY, } from '../constants/index.js';
+export async function httpRequest(url, opts = {}) {
+    const headers = new Headers(opts.headers);
+    headers.set('Role', 'Member');
+    headers.set('Site-ID', SITE_ID);
+    headers.set('Platform-ID', PLATFORM_ID);
+    headers.set('Platform-Code', PLATFORM_CODE);
+    new Headers(opts.headers).forEach((value, key) => {
+        headers.set(key, value);
+    });
+    if (BYPASS_RECAPTCHA) {
+        headers.set(TEST_PASS_HEADER_KEY, '');
+    }
+    const res = await fetch(url, {
+        ...opts,
+        headers,
+    });
+    if (!res.ok) {
+        const code = KnownErrorSchema.parse(await res.json());
+        const exception = new Error();
+        exception.name = code ?? 'HttpRequestError';
+        exception.message = code
+            ? getErrorMessage(code)
+            : `Error ${res.status}: ${res.statusText}`;
+        Error.captureStackTrace?.(exception, httpRequest.json);
+        throw exception;
+    }
+    return res;
+}
+httpRequest.json = async (url, opts = {}) => {
+    const headers = new Headers();
+    headers.set('Role', 'Member');
+    headers.set('Site-ID', SITE_ID);
+    headers.set('Platform-ID', PLATFORM_ID);
+    headers.set('Platform-Code', PLATFORM_CODE);
+    headers.set('Accept', 'application/json');
+    headers.set('Content-Type', 'application/json');
+    new Headers(opts.headers).forEach((value, key) => {
+        headers.set(key, value);
+    });
+    if (BYPASS_RECAPTCHA) {
+        headers.set(TEST_PASS_HEADER_KEY, '');
+    }
+    const response = await fetch(url, {
+        ...opts,
+        headers,
+    });
+    if (!response.ok) {
+        const code = KnownErrorSchema.parse(await response.json());
+        const exception = new Error();
+        exception.name = code ?? 'HttpRequestError';
+        exception.message = code
+            ? getErrorMessage(code)
+            : `Error ${response.status}: ${response.statusText}`;
+        Error.captureStackTrace?.(exception, httpRequest.json);
+        throw exception;
+    }
+    const json = await response.json();
+    return json;
+};
+const KnownErrorSchema = z
+    .object({
+    code: z.string().optional(),
+    message: z.string().optional(),
+})
+    .nullable()
+    .catch(null)
+    .transform((v) => v?.code ?? v?.message ?? null);
+function getErrorMessage(code) {
+    switch (code) {
+        case 'ACCOUNT_BLACKLISTED':
+            return 'Account is blacklisted';
+        case 'MEMBER_ACCOUNT_SUSPENDED':
+            return 'Account is suspended';
+        case 'INVALID_RECAPTCHA_RESPONSE':
+            return 'Invalid reCAPTCHA response';
+        case 'MEMBER_NOT_FOUND':
+            return 'Account not found';
+        case 'RATE_LIMIT_REACH':
+            return 'Rate limit exceeded';
+        case 'NOT_READY_TO_SEND_VERIFICATION_ERROR':
+            return 'Not ready to send verification code';
+        default:
+            return 'Something went wrong. Please try again later.';
+    }
+}

package/dist/utils/queryKeys.d.ts

@@ -1,5 +1,5 @@
-import type { AvailablePromosInput, BetRecordsInput, DepositRecordsInput, GamesInput__Next, JackpotPayoutsInput, JackpotsInput, MessagesInput, TournamentsInput, TransactionRecordsInput, UnreadMessagesCountInput, WithdrawalRecordsInput } from '@opexa/portal-sdk-core';
 import type { MutationKey, QueryKey } from '@tanstack/react-query';
+import type { AvailablePromosInput, BetRecordsInput, DepositRecordsInput, GamesInput__Next, JackpotPayoutsInput, JackpotsInput, MessagesInput, TournamentsInput, TransactionRecordsInput, UnreadMessagesCountInput, WithdrawalRecordsInput } from '../services';
 export declare const getAccountQueryKey: () => QueryKey;
 export declare const getProfileCompletionQueryKey: () => QueryKey;
 export declare const getAuthenticateMutationKey: () => MutationKey;

package/dist/utils/sha256.d.ts

@@ -0,0 +1,4 @@
+declare global {
+    var EdgeRuntime: string | undefined;
+}
+export declare function sha256(input: string): Promise<string>;

package/dist/utils/sha256.js

@@ -0,0 +1,16 @@
+export async function sha256(input) {
+    /*
+     * crypto and other node apis are not available in edge runtime
+     * ref: https://vercel.com/docs/functions/runtimes/edge#check-if-you're-running-on-the-edge-runtime
+     */
+    if (typeof EdgeRuntime === 'string') {
+        throw new Error("Cannot use 'sha256' in edge runtime");
+    }
+    if (typeof window === 'undefined') {
+        const crypto = await import('crypto');
+        return crypto.createHash('sha256').update(input).digest('hex');
+    }
+    return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(input))))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}