@opexa/portal-components 0.0.83 → 0.0.85

package/dist/services/file.service.js

@@ -0,0 +1,18 @@
+import { cache } from 'react';
+import { FILE_GRAPHQL_ENDPOINT } from '../constants/index.js';
+import { graphqlRequest, graphqlUpload, } from './graphqlRequest.js';
+import { FILE, UPLOAD_PRIVATE_IMAGE_FILE } from './queries.js';
+export const getFile = cache(async (id, options) => {
+    const res = await graphqlRequest(FILE_GRAPHQL_ENDPOINT, FILE, { id }, options);
+    return res.node ?? null;
+});
+export const uploadPrivateImageFile = async (input, options) => {
+    const res = await graphqlUpload(FILE_GRAPHQL_ENDPOINT, UPLOAD_PRIVATE_IMAGE_FILE, { input }, options);
+    if (res.uploadPrivateImageFile) {
+        const error = new Error();
+        error.name = res.uploadPrivateImageFile.name;
+        error.message = res.uploadPrivateImageFile.message;
+        Error.captureStackTrace?.(error, uploadPrivateImageFile);
+        throw error;
+    }
+};

package/dist/services/game.service.d.ts

@@ -0,0 +1,44 @@
+import type { Simplify } from 'type-fest';
+import type { GameSession, GameSession__Legacy } from '../types';
+import { type GraphQLRequestOptions } from './graphqlRequest';
+export interface GameSessionQuery__Legacy {
+    node?: GameSession__Legacy | null;
+}
+export interface GameSessionQueryVariables__Legacy {
+    id: string;
+}
+export declare const getGameSession__legacy: (id: string, options?: GraphQLRequestOptions) => Promise<GameSession | null>;
+export type CreateGameSessionError__Legacy = {
+    name: 'GameDoesNotExistError';
+    message: string;
+};
+export interface CreateGameSessionMutation__Legacy {
+    createGameSession?: null | CreateGameSessionError__Legacy;
+}
+export interface CreateGameSessionMutationVariables__Legacy {
+    input: {
+        id: string;
+        game: string;
+    };
+}
+export type CreateGameSessionInput__Legacy = Simplify<CreateGameSessionMutationVariables__Legacy['input']>;
+export declare function createGameSession__legacy(input: CreateGameSessionInput__Legacy, options?: GraphQLRequestOptions): Promise<void>;
+export type EndGameSessionError = {
+    name: 'GameSessionDoesNotExistError';
+    message: string;
+} | {
+    name: 'GameSessionAlreadyClosedError';
+    message: string;
+} | {
+    name: 'GameProviderError';
+    message: string;
+};
+export interface EndGameSessionMutation__Legacy {
+    endGameSession?: null | EndGameSessionError;
+}
+export interface EndGameSessionMutationVariables__Legacy {
+    input: {
+        id: string;
+    };
+}
+export declare function endGameSession__legacy(id: string, options?: GraphQLRequestOptions): Promise<void>;

package/dist/services/game.service.js

@@ -0,0 +1,33 @@
+import { cache } from 'react';
+import { GAME_GRAPHQL_ENDPOINT } from '../constants/index.js';
+import { graphqlRequest } from './graphqlRequest.js';
+import { CREATE_GAME_SESSION, END_GAME_SESSION__LEGACY, GAME_SESSION__LEGACY, } from './queries.js';
+export const getGameSession__legacy = cache(async (id, options) => {
+    const res = await graphqlRequest(GAME_GRAPHQL_ENDPOINT, GAME_SESSION__LEGACY, { id }, options);
+    if (!res.node)
+        return null;
+    return {
+        ...res.node,
+        game: res.node.game.id,
+    };
+});
+export async function createGameSession__legacy(input, options) {
+    const res = await graphqlRequest(GAME_GRAPHQL_ENDPOINT, CREATE_GAME_SESSION, { input }, options);
+    if (res.createGameSession) {
+        const error = new Error();
+        error.name = res.createGameSession.name;
+        error.message = res.createGameSession.message;
+        Error.captureStackTrace?.(error, createGameSession__legacy);
+        throw error;
+    }
+}
+export async function endGameSession__legacy(id, options) {
+    const res = await graphqlRequest(GAME_GRAPHQL_ENDPOINT, END_GAME_SESSION__LEGACY, { input: { id } }, options);
+    if (res.endGameSession) {
+        const error = new Error();
+        error.name = res.endGameSession.name;
+        error.message = res.endGameSession.message;
+        Error.captureStackTrace?.(error, endGameSession__legacy);
+        throw error;
+    }
+}

package/dist/services/graphqlRequest.d.ts

@@ -0,0 +1,4 @@
+export interface GraphQLRequestOptions extends Omit<RequestInit, 'body' | 'method'> {
+}
+export declare function graphqlRequest<T, V extends Record<string, any> = never>(url: string, query: string, variables?: V, options?: GraphQLRequestOptions): Promise<T>;
+export declare function graphqlUpload<T, V extends Record<string, any> = never>(url: string, query: string, variables: V, options?: GraphQLRequestOptions): Promise<T>;

package/dist/services/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/services/httpRequest.d.ts

@@ -0,0 +1,23 @@
+export interface HttpRequestOptions extends RequestInit {
+}
+export declare function httpRequest(url: string, opts?: HttpRequestOptions): Promise<{
+    json<T>(): Promise<T>;
+    headers: Headers;
+    ok: boolean;
+    redirected: boolean;
+    status: number;
+    statusText: string;
+    type: ResponseType;
+    url: string;
+    clone(): Response;
+    body: ReadableStream<Uint8Array> | null;
+    bodyUsed: boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    bytes(): Promise<Uint8Array>;
+    formData(): Promise<FormData>;
+    text(): Promise<string>;
+}>;
+export declare namespace httpRequest {
+    var json: <T>(url: string, opts?: HttpRequestOptions) => Promise<T>;
+}

package/dist/services/httpRequest.js

@@ -0,0 +1,93 @@
+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,
+        async json() {
+            const o = await res.json();
+            return o;
+        },
+    };
+}
+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/services/index.d.ts

@@ -0,0 +1,12 @@
+export * from './account.service';
+export * from './auth.service';
+export * from './cmsPortal.service';
+export * from './file.service';
+export * from './game.service';
+export * from './graphqlRequest';
+export * from './httpRequest';
+export * from './portal.service';
+export * from './report.service';
+export * from './sha256';
+export * from './trigger.service';
+export * from './wallet.service';

package/dist/services/index.js

@@ -0,0 +1,12 @@
+export * from './account.service.js';
+export * from './auth.service.js';
+export * from './cmsPortal.service.js';
+export * from './file.service.js';
+export * from './game.service.js';
+export * from './graphqlRequest.js';
+export * from './httpRequest.js';
+export * from './portal.service.js';
+export * from './report.service.js';
+export * from './sha256.js';
+export * from './trigger.service.js';
+export * from './wallet.service.js';

package/dist/services/portal.service.d.ts

@@ -0,0 +1,37 @@
+import type { Simplify } from 'type-fest';
+import type { GameType, LatestBetRecord, OnboardingPlayerExperience, OnboardingStatus, Platform, RecommendedGame, TopWin } from '../types';
+import { type GraphQLRequestOptions } from './graphqlRequest';
+export interface LatestBetRecordsQuery {
+    latestBetRecords: LatestBetRecord[];
+}
+export declare const getLatestBetRecords: (options?: GraphQLRequestOptions) => Promise<LatestBetRecord[]>;
+export interface PlatformQuery extends Platform {
+}
+export declare const getPlatform: (options?: GraphQLRequestOptions) => Promise<PlatformQuery>;
+export interface RecommendedGamesQuery {
+    recommendedGames: RecommendedGame[];
+}
+export declare const getRecommendedGames: (options?: GraphQLRequestOptions) => Promise<RecommendedGame[]>;
+export interface OnboardingStatusQuery {
+    onboardingStatus?: OnboardingStatus | null;
+}
+export declare const getOnboardingStatus: (options?: GraphQLRequestOptions) => Promise<OnboardingStatus | null>;
+export interface CompleteOnboardingMutationVariables {
+    input: {
+        playerExperience: OnboardingPlayerExperience;
+        favoriteGameTypes: GameType[];
+    };
+}
+export interface CompleteOnboardingMutation {
+    completeOnboarding: boolean;
+}
+export type CompleteOnboardingInput = Simplify<CompleteOnboardingMutationVariables['input']>;
+export declare const completeOnboarding: (input: CompleteOnboardingInput, options?: GraphQLRequestOptions) => Promise<void>;
+export interface SkipOnboardingMutation {
+    skipOnboarding: boolean;
+}
+export declare const skipOnboarding: (options?: GraphQLRequestOptions) => Promise<void>;
+export interface TopWinsQuery {
+    topWins: TopWin[];
+}
+export declare const getTopWins: (options?: GraphQLRequestOptions) => Promise<TopWin[]>;

package/dist/services/portal.service.js

@@ -0,0 +1,44 @@
+import { cache } from 'react';
+import { PORTAL_GRAPHQL_ENDPOINT } from '../constants/index.js';
+import { graphqlRequest } from './graphqlRequest.js';
+import { COMPLETE_ONBOARDING, LATEST_BET_RECORDS, ONBOARDING_STATUS, PLATFORM, RECOMMENDED_GAMES, SKIP_ONBOARDING, TOP_WINS, } from './queries.js';
+export const getLatestBetRecords = cache(async (options) => {
+    const res = await graphqlRequest(PORTAL_GRAPHQL_ENDPOINT, LATEST_BET_RECORDS, undefined, options);
+    return res.latestBetRecords;
+});
+export const getPlatform = cache(async (options) => {
+    const res = await graphqlRequest(PORTAL_GRAPHQL_ENDPOINT, PLATFORM, undefined, options);
+    return res;
+});
+export const getRecommendedGames = cache(async (options) => {
+    const res = await graphqlRequest(PORTAL_GRAPHQL_ENDPOINT, RECOMMENDED_GAMES, undefined, options);
+    return res.recommendedGames;
+});
+export const getOnboardingStatus = cache(async (options) => {
+    const res = await graphqlRequest(PORTAL_GRAPHQL_ENDPOINT, ONBOARDING_STATUS, undefined, options);
+    return res.onboardingStatus ?? null;
+});
+export const completeOnboarding = async (input, options) => {
+    const res = await graphqlRequest(PORTAL_GRAPHQL_ENDPOINT, COMPLETE_ONBOARDING, { input }, options);
+    if (!res.completeOnboarding) {
+        const error = new Error();
+        error.name = 'UnknownError';
+        error.message = 'Something went wrong';
+        Error.captureStackTrace?.(error, completeOnboarding);
+        throw error;
+    }
+};
+export const skipOnboarding = async (options) => {
+    const res = await graphqlRequest(PORTAL_GRAPHQL_ENDPOINT, SKIP_ONBOARDING, undefined, options);
+    if (!res.skipOnboarding) {
+        const error = new Error();
+        error.name = 'UnknownError';
+        error.message = 'Something went wrong';
+        Error.captureStackTrace?.(error, skipOnboarding);
+        throw error;
+    }
+};
+export const getTopWins = cache(async (options) => {
+    const res = await graphqlRequest(PORTAL_GRAPHQL_ENDPOINT, TOP_WINS, undefined, options);
+    return res.topWins;
+});