@vertikalx/vtx-backend-client 1.0.0-dev.4 → 1.0.0-dev.41

package/src/api/vtx-base-api.js

@@ -0,0 +1,897 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VTXBaseAPI = void 0;
+const package_json_1 = require("../../package.json");
+const client_1 = require("../client");
+const api_call_headers_1 = require("./api-call-headers");
+const response_builder_1 = require("./response-builder");
+const domains_1 = require("./domains");
+class VTXBaseAPI {
+    constructor(headers, backendUrl) {
+        this.headers = headers ?? api_call_headers_1.DEFAULT_HEADERS;
+        this.backendUrl = backendUrl ?? VTXBaseAPI.getDefaultBackendUrl();
+    }
+    setHeader(key, value) {
+        this.headers[key] = value;
+    }
+    static getDefaultBackendUrl() {
+        let retValue = api_call_headers_1.DEFAULT_PROD_URL;
+        switch (process.env?.NODE_ENV) {
+            case 'production':
+                retValue = api_call_headers_1.DEFAULT_PROD_URL;
+                break;
+            case 'preprod':
+                retValue = api_call_headers_1.DEFAULT_PREPROD_URL;
+                break;
+            case 'development':
+            case 'devlocal':
+                retValue = api_call_headers_1.DEFAULT_DEV_LOCAL_URL;
+                break;
+            case 'devremote':
+                retValue = api_call_headers_1.DEFAULT_DEV_REMOTE_URL;
+                break;
+            default:
+                retValue = api_call_headers_1.DEFAULT_PROD_URL;
+                break;
+        }
+        return retValue;
+    }
+    static getVersion() {
+        return package_json_1.default?.version ?? '0.0.0';
+    }
+    static isBrowser() {
+        if (typeof process === 'object' && typeof require === 'function') {
+            return false;
+        }
+        if (typeof importScripts === 'function') {
+            return false;
+        }
+        if (typeof window === 'object') {
+            return true;
+        }
+        return false;
+    }
+    async findUserByEmail(email) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        const curatedEmail = email.trim().toLocaleLowerCase();
+        let retValue = {};
+        try {
+            const response = await client.query({
+                findUserByEmail: {
+                    __args: {
+                        email: curatedEmail,
+                    },
+                    _id: true,
+                    loginEmail: true,
+                    suspended: true,
+                    domains: {
+                        _id: true,
+                        name: true,
+                        description: true
+                    }
+                },
+            });
+            console.log(JSON.stringify(response, null, 2));
+            if (response?.findUserByEmail?._id) {
+                try {
+                    retValue.data = response.findUserByEmail;
+                }
+                catch (casterr) {
+                    console.log('Error trying to cast to User');
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else if (response?.errors) {
+                if (Array.isArray(response.errors)) {
+                    retValue.errors = response.errors;
+                }
+                else {
+                    retValue.errors = [response.errors];
+                }
+            }
+            else if (response?.error) {
+                if (Array.isArray(response.error)) {
+                    retValue.errors = response.error;
+                }
+                else {
+                    retValue.errors = [response.error];
+                }
+            }
+            else {
+                retValue.errors = ['Error: Obtained incorrect data from Backend'];
+            }
+        }
+        catch (err1) {
+            try {
+                console.log('ERROR trying to call server');
+                console.log(JSON.stringify(err1, null, 2));
+            }
+            catch (ex) { }
+            if (Array.isArray(err1)) {
+                retValue.errors = err1;
+            }
+            else {
+                retValue.errors = [err1];
+            }
+        }
+        return retValue;
+    }
+    async loginUserFromEmail(loginEmail) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + '/graphql',
+            headers: this.headers,
+        });
+        const curatedEmail = loginEmail.trim().toLocaleLowerCase();
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                loginUserFromEmail: {
+                    __args: {
+                        email: curatedEmail,
+                    },
+                    actualToken: true,
+                    refreshToken: true,
+                },
+            });
+            console.log(JSON.stringify(response, null, 2));
+            if (response?.loginUserFromEmail?.actualToken) {
+                try {
+                    retValue.data =
+                        response.loginUserFromEmail;
+                }
+                catch (casterr) {
+                    console.log('Error trying to cast to UserToken:');
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else if (response?.errors) {
+                if (Array.isArray(response.errors)) {
+                    retValue.errors = response.errors;
+                }
+                else {
+                    retValue.errors = [response.errors];
+                }
+            }
+            else if (response?.error) {
+                if (Array.isArray(response.error)) {
+                    retValue.errors = response.error;
+                }
+                else {
+                    retValue.errors = [response.error];
+                }
+            }
+            else {
+                retValue.errors = ['Error: Obtained incorrect data from Backend'];
+            }
+        }
+        catch (err1) {
+            console.log(JSON.stringify(err1, null, 2));
+            if (Array.isArray(err1)) {
+                retValue.errors = err1;
+            }
+            else {
+                retValue.errors = [err1];
+            }
+        }
+        return retValue;
+    }
+    async createUserAndLogin(loginEmail) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const curatedEmail = loginEmail.trim().toLowerCase();
+        const payload = {
+            loginEmail: curatedEmail
+        };
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                createUserAndLogin: {
+                    __args: {
+                        user: payload
+                    },
+                    _id: true,
+                    loginEmail: true,
+                    suspended: true,
+                    token: {
+                        actualToken: true,
+                        refreshToken: true
+                    }
+                }
+            });
+            console.log(JSON.stringify(response, null, 2));
+            if (response?.createUserAndLogin?._id) {
+                try {
+                    retValue.data = response.createUserAndLogin;
+                }
+                catch (casterr) {
+                    console.log('Error trying to cast to UserToken:');
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else if (response?.errors) {
+                if (Array.isArray(response.errors)) {
+                    retValue.errors = response.errors;
+                }
+                else {
+                    retValue.errors = [response.errors];
+                }
+            }
+            else if (response?.error) {
+                if (Array.isArray(response.error)) {
+                    retValue.errors = response.error;
+                }
+                else {
+                    retValue.errors = [response.error];
+                }
+            }
+            else if (response?.data?._id) {
+                try {
+                    retValue.data = response?.data;
+                }
+                catch (casterr) {
+                    console.log('Error trying to cast to UserWithToken:');
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else {
+                retValue.errors = ['Error: Obtained incorrect data from Backend'];
+            }
+        }
+        catch (err1) {
+            console.log(JSON.stringify(err1, null, 2));
+            if (Array.isArray(err1)) {
+                retValue.errors = err1;
+            }
+            else {
+                retValue.errors = [err1];
+            }
+        }
+        return retValue;
+    }
+    async registerAthlete(payload) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            const response = await client.mutation({
+                registerAthlete: {
+                    __args: {
+                        input: payload
+                    },
+                    _id: true,
+                    firstName: true,
+                    lastName: true,
+                    screenName: true,
+                    countryId: true,
+                    countryName: true
+                }
+            });
+            console.log(JSON.stringify(response, null, 2));
+            if (response?.registerAthlete?._id) {
+                try {
+                    retValue.data = response?.registerAthlete;
+                }
+                catch (casterr) {
+                    console.log('Error trying to cast to Athlete:');
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else if (response?.errors) {
+                if (Array.isArray(response.errors)) {
+                    retValue.errors = response.errors;
+                }
+                else {
+                    retValue.errors = [response.errors];
+                }
+            }
+            else if (response?.error) {
+                if (Array.isArray(response.error)) {
+                    retValue.errors = response.error;
+                }
+                else {
+                    retValue.errors = [response.error];
+                }
+            }
+            else if (response?.data?._id) {
+                try {
+                    retValue.data = response?.data;
+                }
+                catch (casterr) {
+                    console.log('Error trying to cast to Athlete:');
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else {
+                retValue.errors = ['Error: Obtained incorrect data from Backend'];
+            }
+        }
+        catch (err1) {
+            console.log(JSON.stringify(err1, null, 2));
+            if (Array.isArray(err1)) {
+                retValue.errors = err1;
+            }
+            else {
+                retValue.errors = [err1];
+            }
+        }
+        return retValue;
+    }
+    async findBrandByName(name, translations = false) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        try {
+            let response = null;
+            if (translations) {
+                response = await client.query({
+                    getBrandByName: {
+                        __args: {
+                            name: name,
+                            translations: true
+                        },
+                        _id: true,
+                        name: true,
+                        slogan: true,
+                        website: true,
+                        description: true,
+                        logo: {
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        },
+                        banner: {
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        },
+                        translations: {
+                            name: true,
+                            slogan: true,
+                            description: true,
+                            language: true
+                        },
+                    }
+                });
+            }
+            else {
+                response = await client.query({
+                    getBrandByName: {
+                        __args: {
+                            name: name,
+                            translations: false
+                        },
+                        _id: true,
+                        name: true,
+                        slogan: true,
+                        website: true,
+                        description: true,
+                        logo: {
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        },
+                        banner: {
+                            name: true,
+                            contentType: true,
+                            size: true,
+                            useType: true,
+                            url: true,
+                            key: true
+                        }
+                    }
+                });
+            }
+            if (response?.getBrandByName?._id) {
+                try {
+                    retValue.data = response?.getBrandByName;
+                }
+                catch (casterr) {
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else if (response?.errors) {
+                if (Array.isArray(response.errors)) {
+                    retValue.errors = response.errors;
+                }
+                else {
+                    retValue.errors = [response.errors];
+                }
+            }
+            else if (response?.error) {
+                if (Array.isArray(response.error)) {
+                    retValue.errors = response.error;
+                }
+                else {
+                    retValue.errors = [response.error];
+                }
+            }
+            else if (response?.data?._id) {
+                try {
+                    retValue.data = response?.data;
+                }
+                catch (casterr) {
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else {
+                retValue.errors = ['Error: Obtained incorrect data from Backend'];
+            }
+        }
+        catch (err1) {
+            if (Array.isArray(err1)) {
+                retValue.errors = err1;
+            }
+            else {
+                retValue.errors = [err1];
+            }
+        }
+        return retValue;
+    }
+    async createBrand(dto, desiredFields) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = desiredFields ?? { _id: true };
+        try {
+            const response = await client.mutation({
+                createBrand: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                }
+            });
+            console.log('Create Brand Response:');
+            console.log(JSON.stringify(response, null, 2));
+            if (response?.createBrand?._id) {
+                try {
+                    retValue.data = response?.createBrand;
+                }
+                catch (casterr) {
+                    console.log('Error trying to cast to Brand:');
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else if (response?.errors) {
+                if (Array.isArray(response.errors)) {
+                    retValue.errors = response.errors;
+                }
+                else {
+                    retValue.errors = [response.errors];
+                }
+            }
+            else if (response?.error) {
+                if (Array.isArray(response.error)) {
+                    retValue.errors = response.error;
+                }
+                else {
+                    retValue.errors = [response.error];
+                }
+            }
+            else if (response?.data?._id) {
+                try {
+                    retValue.data = response?.data;
+                }
+                catch (casterr) {
+                    console.log('Error trying to cast to Brand:');
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else {
+                retValue.errors = ['Error: Obtained incorrect data from Backend'];
+            }
+        }
+        catch (err1) {
+            console.log(JSON.stringify(err1, null, 2));
+            if (Array.isArray(err1)) {
+                retValue.errors = err1;
+            }
+            else {
+                retValue.errors = [err1];
+            }
+        }
+        return retValue;
+    }
+    async getS3UploadUrl(dto) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        let retValue = {};
+        const fields = {
+            uploadUrl: true,
+            fields: {
+                key: true,
+                value: true
+            },
+            downloadUrl: true,
+            bucket: true,
+            key: true
+        };
+        try {
+            const response = await client.query({
+                getUploadUrl: {
+                    __args: {
+                        input: dto
+                    },
+                    ...fields
+                }
+            });
+            console.log('getUploadUrl Response:');
+            console.log(JSON.stringify(response, null, 2));
+            if (response?.getUploadUrl?.key) {
+                try {
+                    retValue.data = response?.getUploadUrl;
+                }
+                catch (casterr) {
+                    console.log('Error trying to cast to AWSS3UploadUrl:');
+                    retValue.errors = ['Error: Obtained incorrect data from Backend'];
+                }
+            }
+            else {
+                retValue.errors = ["Unable to generate correct upload URL"];
+            }
+        }
+        catch (err1) {
+            console.log(JSON.stringify(err1, null, 2));
+            if (Array.isArray(err1)) {
+                retValue.errors = err1;
+            }
+            else {
+                retValue.errors = [err1];
+            }
+        }
+        return retValue;
+    }
+    async refreshToken(currentToken, refreshToken) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        console.log('HEADERS:');
+        console.log(JSON.stringify(this.headers, null, 2));
+        const fields = {
+            actualToken: true,
+            refreshToken: true
+        };
+        const dto = {
+            refreshToken: refreshToken
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                refreshToken: {
+                    __args: {
+                        dto: dto
+                    },
+                    ...fields
+                }
+            });
+            console.log('refreshToken Response:');
+            console.log(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'refreshToken', (r) => {
+                const isResponseOk = true && response?.refreshToken?.refreshToken;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            console.log('refreshToken err1:');
+            console.log(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerNewDomainTenant(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            email: true,
+            tenant_uri: true,
+            owner: {
+                _id: true,
+                loginEmail: true,
+                suspended: true
+            },
+            domain: {
+                _id: true,
+                name: true,
+                description: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                registerNewDomainTenant: {
+                    __args: {
+                        tenant: input
+                    },
+                    ...fields
+                }
+            });
+            console.log('registerNewDomainTenant Response:');
+            console.log(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'registerNewDomainTenant', (r) => {
+                const isResponseOk = true && response?.registerNewDomainTenant?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            console.log('registerNewDomainTenant err1:');
+            console.log(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerNewDomainTenantWithLogin(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            name: true,
+            email: true,
+            tenant_uri: true,
+            owner: {
+                _id: true,
+                loginEmail: true,
+                suspended: true
+            },
+            domain: {
+                _id: true,
+                name: true,
+                description: true
+            },
+            user: {
+                _id: true,
+                loginEmail: true,
+                suspended: true,
+                domains: {
+                    _id: true,
+                    name: true,
+                    description: true
+                },
+                token: {
+                    actualToken: true,
+                    refreshToken: true
+                }
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                registerNewDomainTenantWithLogin: {
+                    __args: {
+                        tenant: input
+                    },
+                    ...fields
+                }
+            });
+            console.log('registerNewDomainTenant Response:');
+            console.log(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'TenantWithUserLogin', (r) => {
+                const isResponseOk = true && response?.TenantWithUserLogin?._id;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            console.log('registerNewDomainTenantWithLogin err1:');
+            console.log(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async registerUserToDomainFromEmail(input) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            loginEmail: true,
+            suspended: true,
+            domains: {
+                _id: true,
+                name: true,
+                description: true,
+                tenant: {
+                    _id: true,
+                    name: true,
+                    tenant_uri: true
+                }
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.mutation({
+                registerUserToDomainFromEmail: {
+                    __args: {
+                        input: input
+                    },
+                    ...fields
+                }
+            });
+            console.log('registerUserToDomainFromEmail Response:');
+            console.log(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'registerUserToDomainFromEmail', (r) => {
+                const isResponseOk = true && response?.registerUserToDomainFromEmail?.loginEmail;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            console.log('registerUserToDomainFromEmail err1:');
+            console.log(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getPublicSponsorships() {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            title: true,
+            description: true,
+            terms: true,
+            banner: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            stats: {
+                totalApplications: true,
+                newApplications: true,
+                discardedApplications: true,
+                selectedApplications: true,
+                approvedApplications: true,
+                grantedSponsorships: true,
+                remainingSponsorships: true
+            },
+            approved: true,
+            published: true,
+            criteria: {
+                _id: true,
+                label: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getPublicSponsorships: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            console.log('getPublicSponsorships Response:');
+            console.log(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getPublicSponsorships', (r) => {
+                console.log(JSON.stringify(response, null, 2));
+                const isResponseOk = true;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            console.log('getPublicSponsorships err1:');
+            console.log(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+    async getTenantSponsorshipsFromUri(tenantUri, token) {
+        if ((!tenantUri) || (tenantUri.trim() === "")) {
+            return {
+                errors: ["INVALID Tenant URI: " + tenantUri]
+            };
+        }
+        const credential = token.domains.find(c => {
+            if (c.tenant) {
+                if ((c.tenant.tenant_uri == tenantUri) && (c._id == domains_1.DOMAIN_SPONSOR)) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (!credential) {
+            return {
+                errors: ["Tenant in domain SPONSOR not found in domains with URI " + tenantUri]
+            };
+        }
+        const tenantId = credential.tenant?._id ?? null;
+        if ((!tenantId) || (tenantId == "ALL")) {
+            return {
+                errors: ["INVALID Tenant ID: " + tenantId]
+            };
+        }
+        return this.getTenantSponsorships(tenantId);
+    }
+    async getTenantSponsorships(tenantId) {
+        const client = (0, client_1.createClient)({
+            url: this.backendUrl + "/graphql",
+            headers: this.headers,
+        });
+        const fields = {
+            _id: true,
+            title: true,
+            description: true,
+            terms: true,
+            banner: {
+                _id: true,
+                name: true,
+                contentType: true,
+                size: true,
+                useType: true,
+                url: true,
+                key: true
+            },
+            stats: {
+                totalApplications: true,
+                newApplications: true,
+                discardedApplications: true,
+                selectedApplications: true,
+                approvedApplications: true,
+                grantedSponsorships: true,
+                remainingSponsorships: true
+            },
+            approved: true,
+            published: true,
+            criteria: {
+                _id: true,
+                label: true
+            }
+        };
+        let retValue;
+        try {
+            const response = await client.query({
+                getTenantSponsorships: {
+                    __args: {},
+                    ...fields
+                }
+            });
+            console.log('getTenantSponsorships Response:');
+            console.log(JSON.stringify(response, null, 2));
+            retValue = (0, response_builder_1.buildResponse)(response, 'getTenantSponsorships', (r) => {
+                console.log(JSON.stringify(response, null, 2));
+                const isResponseOk = true;
+                return isResponseOk;
+            });
+        }
+        catch (err1) {
+            console.log('getTenantSponsorships err1:');
+            console.log(err1);
+            retValue = (0, response_builder_1.buildErrorResponse)(err1);
+        }
+        return retValue;
+    }
+}
+exports.VTXBaseAPI = VTXBaseAPI;
+//# sourceMappingURL=vtx-base-api.js.map