@opexa/portal-components 0.0.83 → 0.0.84

package/dist/services/account.service.js

@@ -0,0 +1,233 @@
+import { cache } from 'react';
+import { ACCOUNT_GRAPHQL_ENDPOINT } from '../constants/index.js';
+import { graphqlRequest } from './graphqlRequest.js';
+import { ANNOUNCEMENTS, CREATE_MEMBER_VERIFICATION, CREATE_MEMBER_VERIFICATION__NEXT, DELETE_MEMBER_ACCOUNT, GOOGLE_CLIENT_ID, MEMBER_ACCOUNT, MEMBER_VERIFICATION, PAYMENT_SETTINGS, POINTS_CLUB_SETTINGS, PROFILE_COMPLETION, REFERRAL_CODE, REGISTER_MAYA_MEMBER_ACCOUNT, REGISTER_MEMBER_ACCOUNT, REGISTER_MEMBER_ACCOUNT__NEXT, REGISTER_MEMBER_ACCOUNT_BY_MOBILE_NUMBER, REGISTER_MEMBER_ACCOUNT_BY_NAME, REGISTER_MEMBER_ACCOUNT_VIA_MOBILE, RESET_PASSWORD, UPDATE_MEMBER_ACCOUNT, UPDATE_MEMBER_VERIFICATION, UPDATE_REFERRAL_CODE, VERIFY_MOBILE_NUMBER, } from './queries.js';
+import { sha256 } from './sha256.js';
+export const getMemberAccount = cache(async (options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, MEMBER_ACCOUNT, undefined, options);
+    return res.memberAccount;
+});
+export const registerMemberAccount = async (input, options) => {
+    const { password, referralCode, verificationCode, ...rest } = input;
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, REGISTER_MEMBER_ACCOUNT, {
+        input: {
+            password: await sha256(password),
+            ...rest,
+        },
+        referralCode,
+        verificationCode,
+    }, options);
+    if (res.registerMemberAccount) {
+        const error = new Error();
+        error.name = res.registerMemberAccount.name;
+        error.message = res.registerMemberAccount.message;
+        Error.captureStackTrace?.(error, registerMemberAccount);
+        throw error;
+    }
+};
+export const registerMemberAccountViaMobile = async (input, options) => {
+    const { verificationCode, referralCode, ...rest } = input;
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, REGISTER_MEMBER_ACCOUNT_VIA_MOBILE, {
+        input: {
+            ...rest,
+        },
+        referralCode,
+        verificationCode,
+    }, options);
+    if (res.registerMemberAccountViaMobile) {
+        const error = new Error();
+        error.name = res.registerMemberAccountViaMobile.name;
+        error.message = res.registerMemberAccountViaMobile.message;
+        Error.captureStackTrace?.(error, registerMemberAccountViaMobile);
+        throw error;
+    }
+};
+export const registerMemberAccountByMobileNumber = async (input, options) => {
+    const { password, mobileNumberVerificationCode, ...rest } = input;
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, REGISTER_MEMBER_ACCOUNT_BY_MOBILE_NUMBER, {
+        input: {
+            password: await sha256(password),
+            ...rest,
+        },
+        mobileNumberVerificationCode,
+    }, options);
+    if (res.registerMemberAccountByMobileNumber) {
+        const error = new Error();
+        error.name = res.registerMemberAccountByMobileNumber.name;
+        error.message = res.registerMemberAccountByMobileNumber.message;
+        Error.captureStackTrace?.(error, registerMemberAccountByMobileNumber);
+        throw error;
+    }
+};
+export const registerMemberAccount__next = async (input, options) => {
+    const { password, ...rest } = input;
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, REGISTER_MEMBER_ACCOUNT__NEXT, {
+        input: {
+            password: await sha256(password),
+            ...rest,
+        },
+    }, options);
+    if (res.registerMemberAccount) {
+        const error = new Error();
+        error.name = res.registerMemberAccount.name;
+        error.message = res.registerMemberAccount.message;
+        Error.captureStackTrace?.(error, registerMemberAccount__next);
+        throw error;
+    }
+};
+export const registerMemberAccountByName = async (input, options) => {
+    const { password, ...rest } = input;
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, REGISTER_MEMBER_ACCOUNT_BY_NAME, {
+        input: {
+            password: await sha256(password),
+            ...rest,
+        },
+    }, options);
+    if (res.registerMemberAccountByName) {
+        const error = new Error();
+        error.name = res.registerMemberAccountByName.name;
+        error.message = res.registerMemberAccountByName.message;
+        Error.captureStackTrace?.(error, registerMemberAccountByName);
+        throw error;
+    }
+};
+export const updateMemberAccount = async (id, data, options) => {
+    const { password, secretAnswer, ...rest } = data;
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, UPDATE_MEMBER_ACCOUNT, {
+        input: {
+            id,
+            data: {
+                password: password ? await sha256(password) : undefined,
+                secretAnswer: secretAnswer ? await sha256(secretAnswer) : undefined,
+                ...rest,
+            },
+        },
+    }, options);
+    if (res.updateMemberAccount) {
+        const error = new Error();
+        error.name = res.updateMemberAccount.name;
+        error.message = res.updateMemberAccount.message;
+        Error.captureStackTrace?.(error, updateMemberAccount);
+        throw error;
+    }
+};
+export const deleteMemberAccount = async (id, options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, DELETE_MEMBER_ACCOUNT, { input: { id } }, options);
+    if (!res.deleteMemberAccount) {
+        const error = new Error();
+        error.name = 'DeleteMemberAccountError';
+        error.message = 'Failed to delete member account';
+        Error.captureStackTrace?.(error, deleteMemberAccount);
+        throw error;
+    }
+};
+export const resetPassword = async (input, options) => {
+    const { newPassword, verificationCode, ...rest } = input;
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, RESET_PASSWORD, {
+        input: {
+            newPassword: await sha256(newPassword),
+            ...rest,
+        },
+        verificationCode,
+    }, options);
+    if (res.resetPassword) {
+        const error = new Error();
+        error.name = res.resetPassword.name;
+        error.message = res.resetPassword.message;
+        Error.captureStackTrace?.(error, resetPassword);
+        throw error;
+    }
+};
+export const getProfileCompletion = cache(async (options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, PROFILE_COMPLETION, undefined, options);
+    return res.profileCompletion;
+});
+export const getPaymentSettings = cache(async (options) => {
+    return await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, PAYMENT_SETTINGS, undefined, options);
+});
+export const verifyMobileNumber = async (verificationCode, options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, VERIFY_MOBILE_NUMBER, { input: { verificationCode } }, options);
+    if (res.verifyMobileNumber) {
+        const error = new Error();
+        error.name = res.verifyMobileNumber.name;
+        error.message = res.verifyMobileNumber.message;
+        Error.captureStackTrace?.(error, verifyMobileNumber);
+        throw error;
+    }
+};
+export const createMemberVerification = async (input, options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, CREATE_MEMBER_VERIFICATION, { input }, options);
+    if (res.createMemberVerification) {
+        const error = new Error();
+        error.name = res.createMemberVerification.name;
+        error.message = res.createMemberVerification.message;
+        Error.captureStackTrace?.(error, createMemberVerification);
+        throw error;
+    }
+};
+export const createMemberVerification__next = async (input, options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, CREATE_MEMBER_VERIFICATION__NEXT, { input }, options);
+    if (res.createMemberVerification) {
+        const error = new Error();
+        error.name = res.createMemberVerification.name;
+        error.message = res.createMemberVerification.message;
+        Error.captureStackTrace?.(error, createMemberVerification__next);
+        throw error;
+    }
+};
+export const updateMemberVerification = async (id, data, options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, UPDATE_MEMBER_VERIFICATION, { input: { id, data } }, options);
+    if (res.updateMemberVerification) {
+        const error = new Error();
+        error.name = res.updateMemberVerification.name;
+        error.message = res.updateMemberVerification.message;
+        Error.captureStackTrace?.(error, updateMemberVerification);
+        throw error;
+    }
+};
+export const getMemberVerification = cache(async (options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, MEMBER_VERIFICATION, undefined, options);
+    return res.memberAccount.verification ?? null;
+});
+export const getAnnouncements = cache(async (input, options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, ANNOUNCEMENTS, input, options);
+    return res.announcements;
+});
+export const registerMayaMemberAccount = async (input, options) => {
+    const { password, ...rest } = input;
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, REGISTER_MAYA_MEMBER_ACCOUNT, {
+        input: {
+            password: await sha256(password),
+            ...rest,
+        },
+    }, options);
+    if (res.registerMayaMemberAccount) {
+        const error = new Error();
+        error.name = res.registerMayaMemberAccount.name;
+        error.message = res.registerMayaMemberAccount.message;
+        Error.captureStackTrace?.(error, registerMayaMemberAccount);
+        throw error;
+    }
+};
+export const getReferralCode = cache(async (options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, REFERRAL_CODE, undefined, options);
+    return res.referralCode ?? null;
+});
+export const updateReferralCode = async (code, options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, UPDATE_REFERRAL_CODE, { input: { code } }, options);
+    if (res.updateReferralCode) {
+        const error = new Error();
+        error.name = res.updateReferralCode.name;
+        error.message = res.updateReferralCode.message;
+        Error.captureStackTrace?.(error, updateReferralCode);
+        throw error;
+    }
+};
+export const getPointsClubSettings = cache(async (options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, POINTS_CLUB_SETTINGS, undefined, options);
+    return res.pointsClubSettings ?? null;
+});
+export const getGoogleClientId = cache(async (options) => {
+    const res = await graphqlRequest(ACCOUNT_GRAPHQL_ENDPOINT, GOOGLE_CLIENT_ID, undefined, options);
+    return res.googleClientId ?? null;
+});

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

@@ -0,0 +1,80 @@
+import type { Authenticator } from '../types';
+import { type HttpRequestOptions } from './httpRequest';
+export interface CreateSessionInput__UsernameAndPassword {
+    type: 'NAME_AND_PASSWORD';
+    name: string;
+    password: string;
+}
+export interface CreateSessionInput__MobileNumber {
+    type: 'MOBILE_NUMBER';
+    mobileNumber: string;
+    verificationCode: string;
+}
+export interface CreateSessionInput__Maya {
+    type: 'MAYA';
+    session: string;
+}
+export interface CreateSessionInput__Libangan {
+    type: 'LIBANGAN';
+    session: string;
+}
+export interface CreateSessionInput__Token {
+    type: 'SOCIALS' | 'CABINET' | 'SINGLE_USE_TOKEN';
+    token: string;
+}
+export type CreateSessionInput = CreateSessionInput__UsernameAndPassword | CreateSessionInput__MobileNumber | CreateSessionInput__Maya | CreateSessionInput__Libangan | CreateSessionInput__Token;
+export interface CreateSessionTwoFactorAuthDisabledMutation {
+    session: {
+        id: string;
+        dateTimeCreated: string;
+    };
+    accessToken: string;
+    refreshToken: string;
+    authenticator?: never;
+}
+export interface CreateSessionTwoFactorAuthEnabledMutation {
+    authenticator: Authenticator;
+}
+export type CreateSessionMutation = CreateSessionTwoFactorAuthDisabledMutation | CreateSessionTwoFactorAuthEnabledMutation;
+export declare function createSession(input: CreateSessionInput, options?: HttpRequestOptions): Promise<CreateSessionMutation>;
+export interface AuthenticateInput__SecurityQuestion {
+    type: 'SECURITY_QUESTION';
+    token: string;
+    secretAnswer: string;
+}
+export interface AuthenticateMutation extends RefreshSessionMutation {
+}
+export type AuthenticateInput = AuthenticateInput__SecurityQuestion;
+export declare function authenticate(input: AuthenticateInput, options?: HttpRequestOptions): Promise<AuthenticateMutation>;
+export interface RefreshSessionMutation extends Omit<CreateSessionTwoFactorAuthDisabledMutation, 'authenticator'> {
+}
+export declare function refreshSession(options?: HttpRequestOptions): Promise<RefreshSessionMutation>;
+export declare function destroySession(options?: HttpRequestOptions): Promise<void>;
+export declare function verifySession(options?: HttpRequestOptions): Promise<boolean>;
+export interface SendVerificationCodeInput {
+    strict?: boolean;
+    channel: 'SMS' | 'EMAIL';
+    recipient: string;
+}
+export declare function sendVerificationCode(input: SendVerificationCodeInput, options?: 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 interface CreateSingleUseTokenMutation {
+    token: string;
+}
+export declare function createSingleUseToken(options?: HttpRequestOptions): Promise<CreateSingleUseTokenMutation>;

package/dist/services/auth.service.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.service.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.service.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.service.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>;