skapi-js 0.2.0 → 0.2.2

package/js/methods/request.d.ts

@@ -0,0 +1,36 @@
+import { Form, FormSubmitCallback, FetchOptions, Connection } from '../Types';
+export declare function getConnection(): Promise<Connection | null>;
+export declare function listHostDirectory(params: {
+    service: string;
+    dir: string;
+}, fetchOptions: FetchOptions): Promise<any>;
+export declare function request(url: string, data?: Form<any> | null, options?: {
+    fetchOptions?: FetchOptions & FormSubmitCallback;
+    auth?: boolean;
+    method?: string;
+    meta?: Record<string, any>;
+    bypassAwaitConnection?: boolean;
+    responseType?: string;
+    contentType?: string;
+}): Promise<any>;
+export declare function secureRequest<RequestParams = {
+    url: string;
+    data?: any;
+    sync?: boolean;
+}>(params: RequestParams | RequestParams[]): Promise<any>;
+export declare function mock(data: Form<any | {
+    raise?: 'ERR_INVALID_REQUEST' | 'ERR_INVALID_PARAMETER' | 'SOMETHING_WENT_WRONG' | 'ERR_EXISTS' | 'ERR_NOT_EXISTS';
+}>, formCallback?: FormSubmitCallback, options?: {
+    auth?: boolean;
+    method?: string;
+    meta?: Record<string, any>;
+    bypassAwaitConnection?: boolean;
+    responseType?: string;
+    contentType?: string;
+}): Promise<{
+    mockResponse: Record<string, any>;
+}>;
+export declare function getFormResponse(): Promise<any>;
+export declare function formHandler(options?: {
+    preventMultipleCalls: boolean;
+}): (target: object, propertyKey: string, descriptor: any) => void;

package/js/methods/request.js

@@ -0,0 +1,656 @@
+import SkapiError from '../main/error';
+import { MD5 } from '../utils/utils';
+import validator from '../utils/validator';
+const __pendingRequest = {};
+export function getConnection() {
+    return this.__connection;
+}
+export async function listHostDirectory(params, fetchOptions) {
+    let is_admin = await this.checkAdmin();
+    if (is_admin) {
+        if (!params?.dir) {
+            params.dir = '/';
+        }
+        return request.bind(this)('list-host-directory', params, {
+            fetchOptions,
+            auth: true,
+            method: 'post'
+        });
+    }
+    return [];
+}
+export async function request(url, data = null, options) {
+    options = options || {};
+    let { auth = false, method = 'post', meta = null, bypassAwaitConnection = false, } = options;
+    method = method.toLowerCase();
+    let __connection = bypassAwaitConnection ? null : (await 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 ? this.session?.idToken?.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 {
+                    await this.authentication().getSession({ refreshToken: true });
+                    token = this.session?.idToken?.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 = async (dest, auth) => {
+        const endpoints = await 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 (get_ep()?.[auth ? 'private' : 'public'] || '') + dest;
+    };
+    let endpoint = isExternalUrl || (await getEndpoint(url, !!auth));
+    let service = this.session?.attributes?.['custom:service'] || __connection?.service || this.service;
+    let owner = this.session?.attributes?.['custom:owner'] || __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?.responseType !== 'blob' ? { service, owner } : {};
+    let fetchOptions = {};
+    let { fetchMore = false, progress } = options?.fetchOptions || {};
+    if (options?.fetchOptions && Object.keys(options.fetchOptions).length) {
+        let fetOpt = validator.Params({
+            limit: options.fetchOptions?.limit || 50,
+            startKey: options.fetchOptions?.startKey || null,
+            ascending: typeof options.fetchOptions?.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?.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 options?.fetchOptions?.formData === 'function') {
+        let cb = options.fetchOptions.formData(data);
+        if (cb instanceof Promise) {
+            cb = await 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?.contentType) {
+                    headers["Content-Type"] = options.contentType;
+                }
+            }
+            else if (!(data instanceof FormData)) {
+                headers["Content-Type"] = 'application/json';
+            }
+            let opt = { headers };
+            if (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 = await __pendingRequest[requestKey];
+            if (isForm) {
+                return response;
+            }
+            else {
+                return await 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) {
+    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 && this.__startKeyHistory?.[url]?.[hashedParams]) {
+        if (this.__cached_requests?.[url] && this.__cached_requests?.[url]?.[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 (this.__cached_requests?.[url] && this.__cached_requests?.[url]?.[hashedParams_cached]) {
+                    delete this.__cached_requests[url][hashedParams_cached];
+                }
+            }
+        }
+        delete this.__startKeyHistory[url][hashedParams];
+        return hashedParams;
+    }
+    if (!Array.isArray(this.__startKeyHistory?.[url]?.[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 (this.__cached_requests?.[url]?.[cache_hashedParams]) {
+        return this.__cached_requests[url][cache_hashedParams];
+    }
+    return hashedParams;
+}
+;
+async function update_startKey_keys(option) {
+    let { hashedParam, url, response } = option;
+    let fetched = null;
+    if (response instanceof Promise) {
+        fetched = await 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 (!this.__cached_requests?.[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);
+}
+;
+async function _fetch(url, opt, progress) {
+    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?.message) {
+                        let code = (result?.code || (status ? status.toString() : null) || 'ERROR');
+                        rej(new SkapiError(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 = await fetchProgress(url, {
+        headers: opt?.headers,
+        body: opt.body,
+        responseType: opt?.responseType
+    }, progress);
+    if (typeof received === 'object' && opt.method === 'GET' && received.hasOwnProperty('body')) {
+        try {
+            received = JSON.parse(received.body);
+        }
+        catch (err) { }
+    }
+    return received;
+}
+;
+async function _post(url, params, option, progress) {
+    let opt = Object.assign({
+        method: 'POST'
+    }, option, {
+        body: params instanceof FormData ? params : JSON.stringify(params)
+    });
+    return _fetch.bind(this)(url, opt, progress);
+}
+;
+async function _get(url, params, option, progress) {
+    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 async function secureRequest(params) {
+    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 await request.bind(this)('post-secure', params, { auth: true });
+}
+;
+export async function mock(data, formCallback, options) {
+    options = options || {};
+    if (formCallback && formCallback?.formData && typeof formCallback.formData === 'function') {
+        let fetchOptions = {
+            formData: formCallback.formData
+        };
+        Object.assign(options, fetchOptions);
+    }
+    return request.bind(this)('mock', data, options);
+}
+;
+export async function getFormResponse() {
+    await 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?.[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?.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?.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 (async () => {
+                        try {
+                            let resolved = await response;
+                            return handleResponse(resolved);
+                        }
+                        catch (err) {
+                            return handleError(err);
+                        }
+                    })();
+                }
+            };
+            if (preventMultipleCalls) {
+                return (async () => {
+                    if (pendPromise?.[propertyKey] instanceof Promise) {
+                        let res = await pendPromise[propertyKey];
+                        pendPromise[propertyKey] = null;
+                        return res;
+                    }
+                    else {
+                        pendPromise[propertyKey] = executeMethod().finally(() => {
+                            pendPromise[propertyKey] = null;
+                        });
+                        return pendPromise[propertyKey];
+                    }
+                })();
+            }
+            return executeMethod();
+        };
+    };
+}
+;