@opexa/portal-components 0.0.98 → 0.0.100

package/dist/services/auth.js

@@ -0,0 +1,152 @@
+import { AUTH_ENDPOINT } from '../constants/index.js';
+import { httpRequest } from './httpRequest.js';
+import { sha256 } from './sha256.js';
+export async function createSession(input, options) {
+    const headers = new Headers();
+    if (input.type === 'NAME_AND_PASSWORD') {
+        const password = await sha256(input.password);
+        headers.set('Authorization', `Basic ${Buffer.from(`${input.name}:${password}`).toString('base64')}`);
+    }
+    if (input.type === 'MOBILE_NUMBER') {
+        headers.set('Authorization', `MobileNumberOTP ${Buffer.from(`${input.mobileNumber}:${input.verificationCode}`).toString('base64')}`);
+    }
+    if (input.type === 'MAYA') {
+        headers.set('Authorization', `MayaSession ${input.session}`);
+    }
+    if (input.type === 'LIBANGAN') {
+        headers.set('Authorization', `Libangan ${input.session}`);
+    }
+    if (input.type === 'SOCIALS') {
+        headers.set('Authorization', `Token ${input.token}`);
+    }
+    if (input.type === 'CABINET') {
+        headers.set('Authorization', `Opexa-Cabinet-Token ${input.token}`);
+    }
+    if (input.type === 'SINGLE_USE_TOKEN') {
+        headers.set('Authorization', `Single-Use-Token ${input.token}`);
+    }
+    new Headers(options?.headers).forEach((value, key) => {
+        headers.set(key, value);
+    });
+    try {
+        return await httpRequest.json(input.type === 'LIBANGAN'
+            ? `${AUTH_ENDPOINT}/v2/sessions`
+            : `${AUTH_ENDPOINT}/sessions`, {
+            ...options,
+            method: 'POST',
+            headers,
+        });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw e;
+        }
+        else {
+            const error = new Error();
+            error.name = 'AccountNotFoundError';
+            error.message = 'Account not found';
+            Error.captureStackTrace?.(error, createSession);
+            throw error;
+        }
+    }
+}
+export async function authenticate(input, options) {
+    if (input.type === 'SECURITY_QUESTION') {
+        try {
+            return await httpRequest.json(`${AUTH_ENDPOINT}/session/${input.token}/authenticate`, {
+                ...options,
+                method: 'POST',
+                body: JSON.stringify({
+                    secretAnswer: await sha256(input.secretAnswer),
+                }),
+            });
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                throw e;
+            }
+            else {
+                const error = new Error();
+                error.name = 'AccountNotFoundError';
+                error.message = 'Account not found';
+                Error.captureStackTrace?.(error, authenticate);
+                throw error;
+            }
+        }
+    }
+    throw new Error("Invalid input 'type'");
+}
+export async function refreshSession(options) {
+    try {
+        return await httpRequest.json(`${AUTH_ENDPOINT}/session:refresh`, {
+            ...options,
+            method: 'POST',
+        });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw e;
+        }
+        else {
+            const error = new Error();
+            error.name = 'AccountNotFoundError';
+            error.message = 'Account not found';
+            Error.captureStackTrace?.(error, refreshSession);
+            throw error;
+        }
+    }
+}
+export async function destroySession(options) {
+    try {
+        await httpRequest(`${AUTH_ENDPOINT}/session`, {
+            ...options,
+            method: 'DELETE',
+        });
+    }
+    catch {
+        /* ignore */
+    }
+}
+export async function verifySession(options) {
+    try {
+        const res = await httpRequest(`${AUTH_ENDPOINT}/session`, options);
+        return res.ok;
+    }
+    catch {
+        /* Assume session is still valid for unknown errors like Network */
+        return true;
+    }
+}
+export async function sendVerificationCode(input, options) {
+    const { strict, ...rest } = input;
+    const headers = new Headers();
+    headers.set('Accept', 'application/json');
+    headers.set('Content-Type', 'application/json');
+    new Headers(options?.headers).forEach((value, key) => {
+        headers.set(key, value);
+    });
+    return httpRequest(`${AUTH_ENDPOINT}/otps`, {
+        ...options,
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+            verificationType: strict ? 'MEMBER' : undefined,
+            ...rest,
+        }),
+    });
+}
+export async function createSingleUseToken(options) {
+    try {
+        return await httpRequest.json(`${AUTH_ENDPOINT}/token`, {
+            ...options,
+            method: 'POST',
+        });
+    }
+    catch {
+        const error = new Error();
+        error.name = 'InvalidTokenError';
+        error.message = 'Invalid token';
+        Error.captureStackTrace?.(error, createSingleUseToken);
+        throw error;
+    }
+}

package/dist/services/cmsPortal.d.ts

@@ -0,0 +1,43 @@
+import type { SimplifyDeep } from 'type-fest';
+import type { EnumFilterField, Game, GameProvider, GameTag, GameType, ObjectIdFilterField, PaginatedQueryResult, Site, SortOrder } from '../types';
+import { type HttpRequestOptions } from './httpRequest';
+export interface SiteQuery {
+    data: Site;
+}
+export declare const getSite: (id: string, options?: HttpRequestOptions) => Promise<Site | null>;
+export interface GamesQueryVariables {
+    after?: string;
+    first?: number;
+    search?: string;
+    filter?: {
+        tags?: EnumFilterField<GameTag>;
+        type?: EnumFilterField<GameType>;
+        provider?: EnumFilterField<GameProvider>;
+        reference?: ObjectIdFilterField;
+    };
+    sort?: SortOrder;
+}
+export interface GamesQuery {
+    data: Game[];
+    next?: string | null;
+    totalCount?: number | null;
+}
+export type GamesInput = SimplifyDeep<GamesQueryVariables>;
+export declare function getGames(input?: GamesInput, options?: HttpRequestOptions): Promise<PaginatedQueryResult<Game>>;
+export interface GamesQueryVariables__Next {
+    after?: string;
+    first?: number;
+    search?: string;
+    filter?: {
+        tags?: EnumFilterField<GameTag>;
+        type?: EnumFilterField<GameType>;
+        provider?: EnumFilterField<GameProvider>;
+        reference?: ObjectIdFilterField;
+    };
+    sort?: {
+        order: SortOrder;
+        context: string;
+    };
+}
+export type GamesInput__Next = SimplifyDeep<GamesQueryVariables__Next>;
+export declare const getGames__next: (input?: GamesInput__Next, options?: HttpRequestOptions) => Promise<PaginatedQueryResult<Game>>;

package/dist/services/cmsPortal.js

@@ -0,0 +1,148 @@
+import { cache } from 'react';
+import { CMS_PORTAL_ENDPOINT } from '../constants/index.js';
+import { httpRequest } from './httpRequest.js';
+export const getSite = cache(async (id, options) => {
+    try {
+        const { data } = await httpRequest.json(`${CMS_PORTAL_ENDPOINT}/v1/sites/${id}`, options);
+        return data ?? null;
+    }
+    catch {
+        return null;
+    }
+});
+export async function getGames(input, options) {
+    const search = new URLSearchParams();
+    if (input?.first)
+        search.set('first', input.first.toString());
+    if (input?.after)
+        search.set('after', input.after);
+    if (input?.search)
+        search.set('search', input.search);
+    if (input?.filter?.type?.equal)
+        search.set('filter[type][eq]', input.filter.type.equal);
+    if (input?.filter?.type?.notEqual)
+        search.set('filter[type][neq]', input.filter.type.notEqual);
+    if (input?.filter?.type?.in)
+        search.set('filter[type][in]', input.filter.type.in.join(','));
+    if (input?.filter?.type?.notIn)
+        search.set('filter[type][nin]', input.filter.type.notIn.join(','));
+    if (input?.filter?.provider?.equal)
+        search.set('filter[provider][eq]', input.filter.provider.equal);
+    if (input?.filter?.provider?.notEqual)
+        search.set('filter[provider][neq]', input.filter.provider.notEqual);
+    if (input?.filter?.provider?.in)
+        search.set('filter[provider][in]', input.filter.provider.in.join(','));
+    if (input?.filter?.provider?.notIn)
+        search.set('filter[provider][nin]', input.filter.provider.notIn.join(','));
+    if (input?.filter?.tags?.equal)
+        search.set('filter[tags][eq]', input.filter.tags.equal.toLowerCase());
+    if (input?.filter?.tags?.notEqual)
+        search.set('filter[tags][neq]', input.filter.tags.notEqual.toLowerCase());
+    if (input?.filter?.tags?.in)
+        search.set('filter[tags][in]', input.filter.tags.in.map((v) => v.toLowerCase()).join(','));
+    if (input?.filter?.tags?.notIn)
+        search.set('filter[tags][nin]', input.filter.tags.notIn.map((v) => v.toLowerCase()).join(','));
+    if (input?.filter?.reference?.equal)
+        search.set('filter[reference][eq]', input.filter.reference.equal);
+    if (input?.filter?.reference?.notEqual)
+        search.set('filter[reference][neq]', input.filter.reference.notEqual);
+    if (input?.filter?.reference?.in)
+        search.set('filter[reference][in]', input.filter.reference.in.join(','));
+    if (input?.filter?.reference?.notIn)
+        search.set('filter[reference][nin]', input.filter.reference.notIn.join(','));
+    if (input?.sort)
+        search.set('sort[order]', input.sort);
+    try {
+        const res = await httpRequest.json(`${CMS_PORTAL_ENDPOINT}/v1/games?${search.toString()}`, options);
+        return {
+            edges: res.data.map((node) => ({
+                node,
+                cursor: node.cursor,
+            })),
+            totalCount: res.totalCount ?? 0,
+            pageInfo: {
+                hasNextPage: Boolean(res.next),
+                endCursor: res.next,
+            },
+        };
+    }
+    catch {
+        return {
+            edges: [],
+            totalCount: 0,
+            pageInfo: {
+                hasNextPage: false,
+                endCursor: null,
+            },
+        };
+    }
+}
+export const getGames__next = cache(async (input, options) => {
+    const search = new URLSearchParams();
+    if (input?.first)
+        search.set('first', input.first.toString());
+    if (input?.after)
+        search.set('after', input.after);
+    if (input?.search)
+        search.set('search', input.search);
+    if (input?.filter?.type?.equal)
+        search.set('filter[type][eq]', input.filter.type.equal);
+    if (input?.filter?.type?.notEqual)
+        search.set('filter[type][neq]', input.filter.type.notEqual);
+    if (input?.filter?.type?.in)
+        search.set('filter[type][in]', input.filter.type.in.join(','));
+    if (input?.filter?.type?.notIn)
+        search.set('filter[type][nin]', input.filter.type.notIn.join(','));
+    if (input?.filter?.provider?.equal)
+        search.set('filter[provider][eq]', input.filter.provider.equal);
+    if (input?.filter?.provider?.notEqual)
+        search.set('filter[provider][neq]', input.filter.provider.notEqual);
+    if (input?.filter?.provider?.in)
+        search.set('filter[provider][in]', input.filter.provider.in.join(','));
+    if (input?.filter?.provider?.notIn)
+        search.set('filter[provider][nin]', input.filter.provider.notIn.join(','));
+    if (input?.filter?.tags?.equal)
+        search.set('filter[tags][eq]', input.filter.tags.equal.toLowerCase());
+    if (input?.filter?.tags?.notEqual)
+        search.set('filter[tags][neq]', input.filter.tags.notEqual.toLowerCase());
+    if (input?.filter?.tags?.in)
+        search.set('filter[tags][in]', input.filter.tags.in.map((v) => v.toLowerCase()).join(','));
+    if (input?.filter?.tags?.notIn)
+        search.set('filter[tags][nin]', input.filter.tags.notIn.map((v) => v.toLowerCase()).join(','));
+    if (input?.filter?.reference?.equal)
+        search.set('filter[reference][eq]', input.filter.reference.equal);
+    if (input?.filter?.reference?.notEqual)
+        search.set('filter[reference][neq]', input.filter.reference.notEqual);
+    if (input?.filter?.reference?.in)
+        search.set('filter[reference][in]', input.filter.reference.in.join(','));
+    if (input?.filter?.reference?.notIn)
+        search.set('filter[reference][nin]', input.filter.reference.notIn.join(','));
+    if (input?.sort) {
+        search.set('sort[order]', input.sort.order);
+        search.set('sort[context]', input.sort.context.toLowerCase());
+    }
+    try {
+        const res = await httpRequest.json(`${CMS_PORTAL_ENDPOINT}/v2/games?${search.toString()}`, options);
+        return {
+            edges: res.data.map((node) => ({
+                node,
+                cursor: node.cursor,
+            })),
+            totalCount: res.totalCount ?? 0,
+            pageInfo: {
+                endCursor: res.next,
+                hasNextPage: Boolean(res.next),
+            },
+        };
+    }
+    catch {
+        return {
+            edges: [],
+            totalCount: 0,
+            pageInfo: {
+                hasNextPage: false,
+                endCursor: null,
+            },
+        };
+    }
+});

package/dist/services/file.d.ts

@@ -0,0 +1,33 @@
+import type { File } from '../types';
+import { type GraphQLRequestOptions } from './graphqlRequest';
+export interface FileQuery {
+    node?: File | null;
+}
+export interface FileQueryVariables {
+    id: string;
+}
+export declare const getFile: (id: string, options?: GraphQLRequestOptions) => Promise<File | null>;
+export type UploadPrivateImageFileError = {
+    name: 'FileFormatNotSupportedError';
+    message: string;
+} | {
+    name: 'FileNameTooLongError';
+    message: string;
+} | {
+    name: 'FileSizeTooBigError';
+    message: string;
+};
+export interface UploadPrivateImageFileMutation {
+    uploadPrivateImageFile?: null | UploadPrivateImageFileError;
+}
+export interface UploadPrivateImageFileMutationVariables {
+    input: {
+        id: string;
+        file: globalThis.File;
+    };
+}
+export interface UploadPrivateImageFileInput {
+    id: string;
+    file: globalThis.File;
+}
+export declare const uploadPrivateImageFile: (input: UploadPrivateImageFileInput, options?: GraphQLRequestOptions) => Promise<void>;

package/dist/services/file.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.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.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.js

@@ -23,14 +23,6 @@ export async function graphqlRequest(url, query, variables, options) {
     }
     try {
         const response = await fetch(url_, {
-            cache: 'force-cache',
-            next: {
-                revalidate: 1,
-                tags: [
-                    url_.toString(),
-                    variables ? JSON.stringify(variables) : '',
-                ].filter(Boolean),
-            },
             ...options,
             method: 'POST',
             headers,
@@ -134,14 +126,6 @@ export async function graphqlUpload(url, query, variables, options) {
     }
     try {
         const response = await fetch(url_, {
-            cache: 'force-cache',
-            next: {
-                revalidate: 1,
-                tags: [
-                    url_.toString(),
-                    variables ? JSON.stringify(variables) : '',
-                ].filter(Boolean),
-            },
             ...options,
             method: 'POST',
             headers,

package/dist/services/httpRequest.js

@@ -15,11 +15,6 @@ export async function httpRequest(url, opts = {}) {
         headers.delete(RECAPTCHA_HEADER_KEY);
     }
     const res = await fetch(url, {
-        cache: 'force-cache',
-        next: {
-            revalidate: 1,
-            tags: [url, JSON.stringify(opts.body ?? {})].filter(Boolean),
-        },
         ...opts,
         headers,
     });
@@ -57,11 +52,6 @@ httpRequest.json = async (url, opts = {}) => {
         headers.delete(RECAPTCHA_HEADER_KEY);
     }
     const response = await fetch(url, {
-        cache: 'force-cache',
-        next: {
-            revalidate: 1,
-            tags: [url, JSON.stringify(opts.body ?? {})].filter(Boolean),
-        },
         ...opts,
         headers,
     });

package/dist/services/portal.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.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;
+});