skapi-js 0.1.124 → 0.2.0-alpha.0

package/esm/methods/request.js

@@ -0,0 +1,687 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import SkapiError from '../main/error';
+import { MD5 } from '../utils/utils';
+import validator from '../utils/validator';
+const __pendingRequest = {};
+export function getConnection() {
+    return this.__connection;
+}
+export function listHostDirectory(params, fetchOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let is_admin = yield this.checkAdmin();
+        if (is_admin) {
+            if (!(params === null || params === void 0 ? void 0 : params.dir)) {
+                params.dir = '/';
+            }
+            return request.bind(this)('list-host-directory', params, {
+                fetchOptions,
+                auth: true,
+                method: 'post'
+            });
+        }
+        return [];
+    });
+}
+export function request(url, data = null, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    return __awaiter(this, void 0, void 0, function* () {
+        options = options || {};
+        let { auth = false, method = 'post', meta = null, bypassAwaitConnection = false, } = options;
+        method = method.toLowerCase();
+        let __connection = bypassAwaitConnection ? null : (yield this.__connection);
+        if (!__connection && !bypassAwaitConnection) {
+            throw new SkapiError('Invalid connection. The service could have been disabled, or has a restricted CORS.', { code: 'INVALID_REQUEST' });
+        }
+        let token = auth ? (_b = (_a = this.session) === null || _a === void 0 ? void 0 : _a.idToken) === null || _b === void 0 ? void 0 : _b.jwtToken : null;
+        if (auth) {
+            if (!token) {
+                this.logout();
+                throw new SkapiError('User login is required.', { code: 'INVALID_REQUEST' });
+            }
+            else {
+                let currTime = Date.now() / 1000;
+                if (this.session.idToken.payload.exp < currTime) {
+                    try {
+                        yield this.authentication().getSession({ refreshToken: true });
+                        token = (_d = (_c = this.session) === null || _c === void 0 ? void 0 : _c.idToken) === null || _d === void 0 ? void 0 : _d.jwtToken;
+                    }
+                    catch (err) {
+                        this.logout();
+                        throw new SkapiError('User login is required.', { code: 'INVALID_REQUEST' });
+                    }
+                }
+            }
+        }
+        let isExternalUrl = '';
+        try {
+            isExternalUrl = validator.Url(url);
+        }
+        catch (err) {
+        }
+        const getEndpoint = (dest, auth) => __awaiter(this, void 0, void 0, function* () {
+            var _o;
+            const endpoints = yield Promise.all([
+                this.admin_endpoint,
+                this.record_endpoint
+            ]);
+            const admin = endpoints[0];
+            const record = endpoints[1];
+            const get_ep = () => {
+                switch (dest) {
+                    case 'get-newsletters':
+                    case 'get-public-newsletters':
+                    case 'delete-newsletter':
+                    case 'block-account':
+                    case 'register-service':
+                    case 'get-users':
+                    case 'post-userdata':
+                    case 'remove-account':
+                    case 'post-secure':
+                    case 'subscribe-newsletter':
+                    case 'subscribe-public-newsletter':
+                    case 'signup':
+                    case 'confirm-signup':
+                    case 'recover-account':
+                    case 'mock':
+                    case 'get-services':
+                    case 'service':
+                    case 'grant-access':
+                    case 'last-verified-email':
+                    case 'get-newsletter-subscription':
+                    case 'request-username-change':
+                    case 'register-subdomain':
+                    case 'list-host-directory':
+                    case 'refresh-cdn':
+                    case 'request-newsletter-sender':
+                    case 'set-404':
+                        return {
+                            public: admin.admin_public,
+                            private: admin.admin_private
+                        };
+                    case 'post-record':
+                    case 'get-records':
+                    case 'subscription':
+                    case 'get-subscription':
+                    case 'del-records':
+                    case 'get-table':
+                    case 'get-tag':
+                    case 'get-index':
+                    case 'storage-info':
+                    case 'get-signed-url':
+                    case 'grant-private-access':
+                    case 'request-private-access-key':
+                    case 'del-files':
+                        return {
+                            private: record.record_private,
+                            public: record.record_public
+                        };
+                    default:
+                        return null;
+                }
+            };
+            return (((_o = get_ep()) === null || _o === void 0 ? void 0 : _o[auth ? 'private' : 'public']) || '') + dest;
+        });
+        let endpoint = isExternalUrl || (yield getEndpoint(url, !!auth));
+        let service = ((_f = (_e = this.session) === null || _e === void 0 ? void 0 : _e.attributes) === null || _f === void 0 ? void 0 : _f['custom:service']) || (__connection === null || __connection === void 0 ? void 0 : __connection.service) || this.service;
+        let owner = ((_h = (_g = this.session) === null || _g === void 0 ? void 0 : _g.attributes) === null || _h === void 0 ? void 0 : _h['custom:owner']) || (__connection === null || __connection === void 0 ? void 0 : __connection.owner) || this.owner;
+        if (meta) {
+            if (typeof meta === 'object' && !Array.isArray(meta)) {
+                meta = JSON.parse(JSON.stringify(meta));
+            }
+            else {
+                throw new SkapiError('Invalid meta data.', { code: 'INVALID_REQUEST' });
+            }
+        }
+        if (Array.isArray(data) || data && typeof data !== 'object') {
+            throw new SkapiError('Request data should be a JSON Object | FormData | HTMLFormElement.', { code: 'INVALID_REQUEST' });
+        }
+        let required = (options === null || options === void 0 ? void 0 : options.responseType) !== 'blob' ? { service, owner } : {};
+        let fetchOptions = {};
+        let { fetchMore = false, progress } = (options === null || options === void 0 ? void 0 : options.fetchOptions) || {};
+        if ((options === null || options === void 0 ? void 0 : options.fetchOptions) && Object.keys(options.fetchOptions).length) {
+            let fetOpt = validator.Params({
+                limit: ((_j = options.fetchOptions) === null || _j === void 0 ? void 0 : _j.limit) || 50,
+                startKey: ((_k = options.fetchOptions) === null || _k === void 0 ? void 0 : _k.startKey) || null,
+                ascending: typeof ((_l = options.fetchOptions) === null || _l === void 0 ? void 0 : _l.ascending) === 'boolean' ? options.fetchOptions.ascending : true
+            }, {
+                limit: ['number', () => 50],
+                startKey: null,
+                ascending: ['boolean', () => true]
+            });
+            if (fetOpt.hasOwnProperty('limit') && typeof fetOpt.limit === 'number') {
+                if (fetOpt.limit > 1000) {
+                    throw new SkapiError('Fetch limit should be below 1000.', { code: 'INVALID_REQUEST' });
+                }
+                Object.assign(fetchOptions, { limit: fetOpt.limit });
+            }
+            if (fetOpt.hasOwnProperty('startKey') && typeof fetOpt.startKey === 'object' && fetOpt.startKey && Object.keys(fetOpt.startKey)) {
+                Object.assign(fetchOptions, { startKey: fetOpt.startKey });
+            }
+            if (fetOpt.hasOwnProperty('ascending') && typeof fetOpt.ascending === 'boolean') {
+                Object.assign(fetchOptions, { ascending: fetOpt.ascending });
+            }
+        }
+        Object.assign(required, fetchOptions);
+        let isForm = false;
+        if (data instanceof SubmitEvent) {
+            data = data === null || data === void 0 ? void 0 : data.target;
+        }
+        if (data instanceof HTMLFormElement) {
+            data = new FormData(data);
+        }
+        if (data instanceof FormData) {
+            isForm = true;
+        }
+        if (meta) {
+            meta = Object.assign(required, meta);
+        }
+        else {
+            if (!data) {
+                data = required;
+            }
+            else if (isForm) {
+                for (let k in required) {
+                    if (required[k] !== undefined) {
+                        data.set(k, new Blob([JSON.stringify(required[k])], {
+                            type: 'application/json'
+                        }));
+                    }
+                }
+            }
+            else {
+                data = Object.assign(required, data);
+            }
+        }
+        if (isForm && typeof ((_m = options === null || options === void 0 ? void 0 : options.fetchOptions) === null || _m === void 0 ? void 0 : _m.formData) === 'function') {
+            let cb = options.fetchOptions.formData(data);
+            if (cb instanceof Promise) {
+                cb = yield cb;
+            }
+            if (cb instanceof FormData) {
+                data = cb;
+            }
+            if (data instanceof FormData) {
+                let totalFileSize = 0;
+                for (let pair of data.entries()) {
+                    let v = pair[1];
+                    if (v instanceof File) {
+                        totalFileSize += v.size;
+                    }
+                    else if (v instanceof FileList) {
+                        if (v && v.length > 0) {
+                            for (let idx = 0; idx <= v.length - 1; idx++) {
+                                totalFileSize += v.item(idx).size;
+                            }
+                        }
+                    }
+                }
+                if (totalFileSize > 4200000) {
+                    throw new SkapiError('Files cannot exceed 4MB. Use skapi.uploadFiles(...) instead.', { code: 'INVALID_REQUEST' });
+                }
+            }
+            else {
+                throw new SkapiError('Callback for extractFormData() should return FormData', { code: 'INVALID_PARAMETER' });
+            }
+        }
+        let requestKey = load_startKey_keys.bind(this)({
+            params: data,
+            url: isExternalUrl || url,
+            fetchMore: isForm ? false : fetchMore
+        });
+        if (requestKey && typeof requestKey === 'object') {
+            return requestKey;
+        }
+        if (typeof requestKey === 'string') {
+            if (!(__pendingRequest[requestKey] instanceof Promise)) {
+                let headers = {
+                    'Accept': '*/*'
+                };
+                if (token) {
+                    headers.Authorization = token;
+                }
+                if (meta) {
+                    headers["Content-Meta"] = window.btoa(encodeURIComponent(typeof meta === 'string' ? meta : JSON.stringify(meta)));
+                }
+                if (options.hasOwnProperty('contentType')) {
+                    if (options === null || options === void 0 ? void 0 : options.contentType) {
+                        headers["Content-Type"] = options.contentType;
+                    }
+                }
+                else if (!(data instanceof FormData)) {
+                    headers["Content-Type"] = 'application/json';
+                }
+                let opt = { headers };
+                if (options === null || options === void 0 ? void 0 : options.responseType) {
+                    opt.responseType = options.responseType;
+                }
+                if (method === 'post') {
+                    __pendingRequest[requestKey] = _post.bind(this)(endpoint, data, opt, progress);
+                }
+                else if (method === 'get') {
+                    __pendingRequest[requestKey] = _get.bind(this)(endpoint, data, opt, progress);
+                }
+            }
+            try {
+                let response = yield __pendingRequest[requestKey];
+                if (isForm) {
+                    return response;
+                }
+                else {
+                    return yield update_startKey_keys.bind(this)({
+                        hashedParam: requestKey,
+                        url,
+                        response
+                    });
+                }
+            }
+            catch (err) {
+                throw err;
+            }
+            finally {
+                if (requestKey && __pendingRequest.hasOwnProperty(requestKey)) {
+                    delete __pendingRequest[requestKey];
+                }
+            }
+        }
+    });
+}
+;
+function load_startKey_keys(option) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    let { params = {}, url, fetchMore = false } = option || {};
+    if (params.hasOwnProperty('startKey') && params.startKey) {
+        if (typeof params.startKey !== 'object' && !Object.keys(params.startKey).length &&
+            params.startKey !== 'start' && params.startKey !== 'end') {
+            throw new SkapiError(`"${params.startKey}" is invalid startKey key.`, { code: 'INVALID_PARAMETER' });
+        }
+        switch (params.startKey) {
+            case 'start':
+                fetchMore = false;
+                delete params.startKey;
+        }
+    }
+    let hashedParams = (() => {
+        if (params && typeof params === 'object' && Object.keys(params).length) {
+            function orderObjectKeys(obj) {
+                function sortObject(obj) {
+                    if (typeof obj === 'object' && obj) {
+                        return Object.keys(obj).sort().reduce((res, key) => (res[key] = obj[key], res), {});
+                    }
+                    return obj;
+                }
+                ;
+                let _obj = sortObject(obj);
+                if (_obj.hasOwnProperty('limit')) {
+                    delete _obj.limit;
+                }
+                for (let k in _obj) {
+                    if (_obj[k] && typeof _obj[k] === 'object') {
+                        _obj[k] = sortObject(obj[k]);
+                    }
+                }
+                return _obj;
+            }
+            return MD5.hash(url + '/' + JSON.stringify(orderObjectKeys(params)));
+        }
+        return MD5.hash(url + '/' + this.service);
+    })();
+    if (!fetchMore && ((_b = (_a = this.__startKeyHistory) === null || _a === void 0 ? void 0 : _a[url]) === null || _b === void 0 ? void 0 : _b[hashedParams])) {
+        if (((_c = this.__cached_requests) === null || _c === void 0 ? void 0 : _c[url]) && ((_e = (_d = this.__cached_requests) === null || _d === void 0 ? void 0 : _d[url]) === null || _e === void 0 ? void 0 : _e[hashedParams])) {
+            delete this.__cached_requests[url][hashedParams];
+        }
+        if (Array.isArray(this.__startKeyHistory[url][hashedParams]) && this.__startKeyHistory[url][hashedParams].length) {
+            for (let p of this.__startKeyHistory[url][hashedParams]) {
+                let hashedParams_cached = hashedParams + '/' + MD5.hash(JSON.stringify(p));
+                if (((_f = this.__cached_requests) === null || _f === void 0 ? void 0 : _f[url]) && ((_h = (_g = this.__cached_requests) === null || _g === void 0 ? void 0 : _g[url]) === null || _h === void 0 ? void 0 : _h[hashedParams_cached])) {
+                    delete this.__cached_requests[url][hashedParams_cached];
+                }
+            }
+        }
+        delete this.__startKeyHistory[url][hashedParams];
+        return hashedParams;
+    }
+    if (!Array.isArray((_k = (_j = this.__startKeyHistory) === null || _j === void 0 ? void 0 : _j[url]) === null || _k === void 0 ? void 0 : _k[hashedParams])) {
+        return hashedParams;
+    }
+    let list_of_startKeys = this.__startKeyHistory[url][hashedParams];
+    let last_startKey_key = list_of_startKeys[list_of_startKeys.length - 1];
+    let cache_hashedParams = hashedParams;
+    if (last_startKey_key) {
+        if (last_startKey_key === 'end') {
+            return {
+                list: [],
+                startKey: 'end',
+                endOfList: true,
+                startKeyHistory: this.__startKeyHistory[url][hashedParams]
+            };
+        }
+        else {
+            cache_hashedParams += MD5.hash(last_startKey_key);
+            params.startKey = JSON.parse(last_startKey_key);
+        }
+    }
+    if ((_m = (_l = this.__cached_requests) === null || _l === void 0 ? void 0 : _l[url]) === null || _m === void 0 ? void 0 : _m[cache_hashedParams]) {
+        return this.__cached_requests[url][cache_hashedParams];
+    }
+    return hashedParams;
+}
+;
+function update_startKey_keys(option) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        let { hashedParam, url, response } = option;
+        let fetched = null;
+        if (response instanceof Promise) {
+            fetched = yield response;
+        }
+        else {
+            fetched = response;
+        }
+        if (!fetched ||
+            typeof fetched !== 'object' ||
+            !fetched.hasOwnProperty('startKey') ||
+            !hashedParam ||
+            !url) {
+            return fetched;
+        }
+        if (!this.__startKeyHistory.hasOwnProperty(url)) {
+            this.__startKeyHistory[url] = {};
+        }
+        if (!((_a = this.__cached_requests) === null || _a === void 0 ? void 0 : _a[url])) {
+            this.__cached_requests[url] = {};
+        }
+        this.__cached_requests[url][hashedParam] = fetched;
+        if (!this.__startKeyHistory[url].hasOwnProperty(hashedParam)) {
+            this.__startKeyHistory[url][hashedParam] = [];
+        }
+        let startKey_string = fetched.startKey === 'end' ? 'end' : JSON.stringify(fetched.startKey);
+        if (!this.__startKeyHistory[url][hashedParam].includes(startKey_string)) {
+            this.__startKeyHistory[url][hashedParam].push(startKey_string);
+        }
+        this.__cached_requests[url][hashedParam] = fetched;
+        return Object.assign({ startKeyHistory: this.__startKeyHistory[url][hashedParam] }, fetched);
+    });
+}
+;
+function _fetch(url, opt, progress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let fetchProgress = (url, opts, progress) => {
+            return new Promise((res, rej) => {
+                let xhr = new XMLHttpRequest();
+                xhr.open((opt.method || 'GET').toUpperCase(), url);
+                for (var k in opts.headers || {}) {
+                    xhr.setRequestHeader(k, opts.headers[k]);
+                }
+                if (opt.responseType) {
+                    xhr.responseType = opt.responseType;
+                }
+                xhr.onload = () => {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        if (opts.responseType == 'json' || opts.responseType == 'blob') {
+                            res(xhr.response);
+                        }
+                        else {
+                            let result = xhr.responseText;
+                            try {
+                                result = JSON.parse(result);
+                            }
+                            catch (err) { }
+                            res(result);
+                        }
+                    }
+                    else {
+                        let status = xhr.status;
+                        let errCode = [
+                            'INVALID_CORS',
+                            'INVALID_REQUEST',
+                            'SERVICE_DISABLED',
+                            'INVALID_PARAMETER',
+                            'ERROR',
+                            'EXISTS',
+                            'NOT_EXISTS'
+                        ];
+                        let result = xhr.responseText;
+                        try {
+                            result = JSON.parse(result);
+                        }
+                        catch (err) { }
+                        if (typeof result === 'string') {
+                            let errMsg = xhr.response.split(':');
+                            let code = errMsg.splice(0, 1)[0].trim();
+                            rej(new SkapiError(errMsg.join('').trim(), { code: (errCode.includes(code) ? code : 'ERROR') }));
+                        }
+                        else if (typeof result === 'object' && (result === null || result === void 0 ? void 0 : result.message)) {
+                            let code = ((result === null || result === void 0 ? void 0 : result.code) || (status ? status.toString() : null) || 'ERROR');
+                            rej(new SkapiError(result === null || result === void 0 ? void 0 : result.message, { code: code }));
+                        }
+                    }
+                };
+                xhr.onerror = () => rej('Network error');
+                xhr.onabort = () => rej('Aborted');
+                xhr.ontimeout = () => rej('Timeout');
+                if (typeof progress === 'function') {
+                    xhr.onprogress = (p) => {
+                        progress({
+                            status: 'download',
+                            progress: p.loaded / p.total * 100,
+                            loaded: p.loaded,
+                            total: p.total,
+                            abort: () => xhr.abort()
+                        });
+                    };
+                    if (xhr.upload) {
+                        xhr.upload.onprogress = (p) => {
+                            progress({
+                                status: 'upload',
+                                progress: p.loaded / p.total * 100,
+                                loaded: p.loaded,
+                                total: p.total,
+                                abort: () => xhr.abort()
+                            });
+                        };
+                    }
+                }
+                xhr.send(opts.body);
+            });
+        };
+        let received = yield fetchProgress(url, {
+            headers: opt === null || opt === void 0 ? void 0 : opt.headers,
+            body: opt.body,
+            responseType: opt === null || opt === void 0 ? void 0 : opt.responseType
+        }, progress);
+        if (typeof received === 'object' && opt.method === 'GET' && received.hasOwnProperty('body')) {
+            try {
+                received = JSON.parse(received.body);
+            }
+            catch (err) { }
+        }
+        return received;
+    });
+}
+;
+function _post(url, params, option, progress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let opt = Object.assign({
+            method: 'POST'
+        }, option, {
+            body: params instanceof FormData ? params : JSON.stringify(params)
+        });
+        return _fetch.bind(this)(url, opt, progress);
+    });
+}
+;
+function _get(url, params, option, progress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (params && typeof params === 'object' && Object.keys(params).length) {
+            if (url.substring(url.length - 1) !== '?') {
+                url = url + '?';
+            }
+            let query = Object.keys(params)
+                .map(k => {
+                let value = params[k];
+                if (typeof value !== 'string') {
+                    value = JSON.stringify(value);
+                }
+                return encodeURIComponent(k) + '=' + encodeURIComponent(value);
+            })
+                .join('&');
+            url += query;
+        }
+        let opt = Object.assign({
+            method: 'GET'
+        }, option);
+        return _fetch.bind(this)(url, opt, progress);
+    });
+}
+;
+export function secureRequest(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let paramsStruct = {
+            url: (v) => {
+                return validator.Url(v);
+            },
+            data: null,
+            sync: ['boolean', () => true]
+        };
+        if (Array.isArray(params)) {
+            for (let r of params) {
+                r = validator.Params(r, paramsStruct);
+            }
+        }
+        else {
+            params = validator.Params(params, paramsStruct);
+        }
+        return yield request.bind(this)('post-secure', params, { auth: true });
+    });
+}
+;
+export function mock(data, formCallback, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        options = options || {};
+        if (formCallback && (formCallback === null || formCallback === void 0 ? void 0 : formCallback.formData) && typeof formCallback.formData === 'function') {
+            let fetchOptions = {
+                formData: formCallback.formData
+            };
+            Object.assign(options, fetchOptions);
+        }
+        return request.bind(this)('mock', data, options);
+    });
+}
+;
+export function getFormResponse() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield this.__connection;
+        let responseKey = `${this.service}:${MD5.hash(window.location.href.split('?')[0])}`;
+        let stored = window.sessionStorage.getItem(responseKey);
+        if (stored !== null) {
+            try {
+                stored = JSON.parse(stored);
+            }
+            catch (err) { }
+            return stored;
+        }
+        throw new SkapiError("Form response doesn't exist.", { code: 'NOT_EXISTS' });
+    });
+}
+;
+const pendPromise = {};
+export function formHandler(options) {
+    let { preventMultipleCalls = false } = options || {};
+    return function (target, propertyKey, descriptor) {
+        const fn = descriptor.value;
+        descriptor.value = function (...arg) {
+            let form = arg[0];
+            let option = (arg === null || arg === void 0 ? void 0 : arg[1]) || {};
+            let routeWithDataKey = true;
+            let formEl = null;
+            let actionDestination = '';
+            if (form instanceof SubmitEvent) {
+                form.preventDefault();
+                let currentUrl = window.location.href;
+                formEl = form.target;
+                let href = new URL(formEl.action);
+                actionDestination = href.href;
+                if (!formEl.action || href.href === currentUrl) {
+                    routeWithDataKey = false;
+                }
+            }
+            const handleResponse = (response) => {
+                if (option === null || option === void 0 ? void 0 : option.response) {
+                    if (typeof option.response === 'function')
+                        return option.response(response);
+                    else
+                        throw new SkapiError('Callback "response" should be type: function.', { code: 'INVALID_PARAMETER' });
+                }
+                if (formEl) {
+                    if (routeWithDataKey) {
+                        window.sessionStorage.setItem(`${this.service}:${MD5.hash(actionDestination)}`, JSON.stringify(response));
+                        window.location.href = actionDestination;
+                    }
+                }
+                return response;
+            };
+            let response;
+            let handleError = (err) => {
+                if (form instanceof SubmitEvent) {
+                    form.preventDefault();
+                }
+                let is_err = err instanceof Error ? err : new SkapiError(err);
+                if (option === null || option === void 0 ? void 0 : option.onerror) {
+                    if (typeof option.onerror === 'function')
+                        return option.onerror(is_err);
+                    else
+                        throw new SkapiError('Callback "onerror" should be type: function.', { code: 'INVALID_PARAMETER' });
+                }
+                throw is_err;
+            };
+            const executeMethod = () => {
+                try {
+                    response = fn.bind(this)(...arg);
+                }
+                catch (err) {
+                    let is_err = handleError(err);
+                    if (is_err instanceof Error) {
+                        throw is_err;
+                    }
+                    return is_err;
+                }
+                if (response instanceof Promise) {
+                    return (() => __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            let resolved = yield response;
+                            return handleResponse(resolved);
+                        }
+                        catch (err) {
+                            return handleError(err);
+                        }
+                    }))();
+                }
+            };
+            if (preventMultipleCalls) {
+                return (() => __awaiter(this, void 0, void 0, function* () {
+                    if ((pendPromise === null || pendPromise === void 0 ? void 0 : pendPromise[propertyKey]) instanceof Promise) {
+                        let res = yield pendPromise[propertyKey];
+                        pendPromise[propertyKey] = null;
+                        return res;
+                    }
+                    else {
+                        pendPromise[propertyKey] = executeMethod().finally(() => {
+                            pendPromise[propertyKey] = null;
+                        });
+                        return pendPromise[propertyKey];
+                    }
+                }))();
+            }
+            return executeMethod();
+        };
+    };
+}
+;