skapi-js 0.2.0-alpha.0 → 0.2.0

package/esm/methods/database.js

@@ -1,952 +0,0 @@
-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 { extractFormMeta, generateRandom } from '../utils/utils';
-import validator from '../utils/validator';
-import { request } from './request';
-import { checkAdmin } from './user';
-const __index_number_range = 4503599627370496;
-function normalizeRecord(record) {
-    function base_decode(chars) {
-        let charset = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-        return chars.split('').reverse().reduce((prev, curr, i) => prev + (charset.indexOf(curr) * (Math.pow(62, i))), 0);
-    }
-    const output = {
-        user_id: '',
-        record_id: '',
-        updated: 0,
-        uploaded: 0,
-        table: {
-            name: '',
-            access_group: 0
-        },
-        reference: {
-            reference_limit: null,
-            allow_multiple_reference: true,
-            referenced_count: 0
-        },
-        ip: '',
-        bin: []
-    };
-    const keys = {
-        'ip': (r) => {
-            output.ip = r;
-        },
-        'rec': (r) => {
-            if (!r)
-                return;
-            output.record_id = r;
-            let base62timestamp = r.substring(0, r.length - 9);
-            let uploaded = base_decode(base62timestamp);
-            output.uploaded = uploaded;
-        },
-        'usr': (r) => {
-            output.user_id = r;
-        },
-        'tbl': (r) => {
-            if (!r)
-                return;
-            let rSplit = r.split('/');
-            output.table.name = rSplit[0];
-            output.table.access_group = rSplit[2] == '**' ? 'private' : parseInt(rSplit[2]);
-            if (rSplit === null || rSplit === void 0 ? void 0 : rSplit[3]) {
-                output.table.subscription = {
-                    user_id: rSplit[3],
-                    group: parseInt(rSplit[4])
-                };
-            }
-        },
-        'usr_tbl': (r) => {
-            let rSplit = r.split('/');
-            output.user_id = rSplit[0];
-            output.table.name = rSplit[1];
-            output.table.access_group = rSplit[3] == '**' ? 'private' : parseInt(rSplit[3]);
-            if (rSplit === null || rSplit === void 0 ? void 0 : rSplit[4]) {
-                output.table.subscription = {
-                    user_id: rSplit[4],
-                    group: parseInt(rSplit[5])
-                };
-            }
-        },
-        'idx': (r) => {
-            if (!r)
-                return;
-            let rSplit = r.split('!');
-            let name = rSplit.splice(0, 1)[0];
-            let value = normalizeTypedString('!' + rSplit.join('!'));
-            output.index = {
-                name,
-                value
-            };
-        },
-        'ref': (r) => {
-            if (!r)
-                return;
-            output.reference.record_id = r.split('/')[0];
-        },
-        'tags': (r) => {
-            output.tags = r;
-        },
-        'upd': (r) => {
-            output.updated = r;
-        },
-        'acpt_mrf': (r) => {
-            output.reference.allow_multiple_reference = r;
-        },
-        'ref_limt': (r) => {
-            output.reference.reference_limit = r;
-        },
-        'rfd': (r) => {
-            output.reference.referenced_count = r;
-        },
-        'bin': (r) => {
-            output.bin = r;
-        },
-        'data': (r) => {
-            let data = r;
-            if (r === '!D%{}') {
-                data = {};
-            }
-            else if (r === '!L%[]') {
-                data = [];
-            }
-            output.data = data;
-        }
-    };
-    if (record.record_id) {
-        return record;
-    }
-    for (let k in keys) {
-        if (record.hasOwnProperty(k)) {
-            keys[k](record[k]);
-        }
-    }
-    return output;
-}
-function normalizeTypedString(v) {
-    let value = v.substring(3);
-    let type = v.substring(0, 3);
-    switch (type) {
-        case "!S%":
-            return value;
-        case "!N%":
-            return Number(value) - 4503599627370496;
-        case "!B%":
-            return value === '1';
-        case "!L%":
-        case "!D%":
-            try {
-                return JSON.parse(value);
-            }
-            catch (err) {
-                throw new SkapiError('Value parse error.', { code: 'PARSE_ERROR' });
-            }
-        default:
-            return v;
-    }
-}
-export function deleteFiles(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let isAdmin = yield checkAdmin.bind(this)();
-        let { service = this.service, endpoints, storage = 'records' } = params;
-        if (storage === 'host' && !isAdmin) {
-            throw new SkapiError("No access", { code: 'INVALID_REQUEST' });
-        }
-        if (typeof endpoints === 'string') {
-            endpoints = [endpoints];
-        }
-        if (!Array.isArray(endpoints)) {
-            throw new SkapiError('"endpoints" should be type: array | string.', { code: 'INVALID_PARAMETER' });
-        }
-        if (storage !== 'host' && storage !== 'records') {
-            throw new SkapiError('"storage" should be type: "records" | "host".', { code: 'INVALID_PARAMETER' });
-        }
-        return request.bind(this)('del-files', {
-            service,
-            endpoints,
-            storage
-        }, { auth: true, method: 'post' });
-    });
-}
-export function uploadFiles(fileList, params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let isAdmin = yield checkAdmin.bind(this)();
-        if (fileList instanceof SubmitEvent) {
-            fileList = fileList.target;
-        }
-        if (fileList instanceof HTMLFormElement) {
-            fileList = new FormData(fileList);
-        }
-        if (fileList instanceof FormData) {
-            let fileEntries = [];
-            for (let entry of fileList.entries()) {
-                let value = entry[1];
-                if (value instanceof File) {
-                    fileEntries.push(value);
-                }
-            }
-            fileList = fileEntries;
-        }
-        if (!(fileList[0] instanceof File)) {
-            throw new SkapiError('"fileList" should be a FileList or array of File object.', { code: 'INVALID_PARAMETER' });
-        }
-        let reserved_key = generateRandom();
-        let getSignedParams = {
-            reserved_key,
-            service: (params === null || params === void 0 ? void 0 : params.service) || this.service,
-            request: (params === null || params === void 0 ? void 0 : params.request) || 'post'
-        };
-        if (getSignedParams.request === 'host') {
-            if (!isAdmin) {
-                throw new SkapiError('The user has no access.', { code: 'INVALID_REQUEST' });
-            }
-            getSignedParams.request === 'post-host';
-        }
-        if (params === null || params === void 0 ? void 0 : params.record_id) {
-            getSignedParams.id = params.record_id;
-        }
-        else if (!isAdmin) {
-            throw new SkapiError('Record ID is required.', { code: 'INVALID_PARAMETER' });
-        }
-        let xhr;
-        let fetchProgress = (url, body, progressCallback) => {
-            return new Promise((res, rej) => {
-                xhr = new XMLHttpRequest();
-                xhr.open('POST', url);
-                xhr.onload = (e) => {
-                    let result = xhr.responseText;
-                    try {
-                        result = JSON.parse(result);
-                    }
-                    catch (err) { }
-                    if (xhr.status >= 200 && xhr.status < 300) {
-                        let result = xhr.responseText;
-                        try {
-                            result = JSON.parse(result);
-                        }
-                        catch (err) { }
-                        res(result);
-                    }
-                    else {
-                        rej(result);
-                    }
-                };
-                xhr.onerror = () => rej('Network error');
-                xhr.onabort = () => rej('Aborted');
-                xhr.ontimeout = () => rej('Timeout');
-                if (xhr.upload && typeof params.progress === 'function') {
-                    xhr.upload.onprogress = progressCallback;
-                }
-                xhr.send(body);
-            });
-        };
-        let completed = [];
-        let failed = [];
-        function toBase62(num) {
-            const base62Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-            if (num === 0)
-                return base62Chars[0];
-            let result = '';
-            while (num > 0) {
-                result = base62Chars[num % 62] + result;
-                num = Math.floor(num / 62);
-            }
-            return result;
-        }
-        for (let f of fileList) {
-            let signedParams = Object.assign({
-                key: f.name,
-                sizeKey: toBase62(f.size),
-                contentType: f.type || null
-            }, getSignedParams);
-            let { fields = null, url } = yield request.bind(this)('get-signed-url', signedParams, { auth: true });
-            let form = new FormData();
-            for (let name in fields) {
-                form.append(name, fields[name]);
-            }
-            form.append('file', f);
-            try {
-                yield fetchProgress(url, form, (p) => {
-                    params.progress({
-                        status: 'upload',
-                        progress: p.loaded / p.total * 100,
-                        currentFile: f,
-                        completed,
-                        failed,
-                        loaded: p.loaded,
-                        total: p.total,
-                        abort: () => xhr.abort()
-                    });
-                });
-                completed.push(f);
-            }
-            catch (err) {
-                failed.push(f);
-            }
-        }
-        return { completed, failed };
-    });
-}
-export function getFile(url, config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        validator.Url(url);
-        let isValidEndpoint = false;
-        let splitUrl = url.split('/');
-        let host = splitUrl[2];
-        let splitHost = host.split('.');
-        let subdomain = null;
-        if (splitHost.length === 3 && splitHost[1] === 'skapi') {
-            subdomain = splitHost[0];
-            isValidEndpoint = true;
-        }
-        let target_key = splitUrl.slice(3);
-        if (!isValidEndpoint) {
-            if (target_key[0] !== 'auth' && target_key[0] !== 'publ') {
-                throw new SkapiError('Invalid file url.', { code: 'INVALID_PARAMETER' });
-            }
-            try {
-                validator.UserId(target_key[2]);
-                validator.UserId(target_key[3]);
-            }
-            catch (_a) {
-                throw new SkapiError('Invalid file url.', { code: 'INVALID_PARAMETER' });
-            }
-        }
-        let service = subdomain ? null : target_key[1];
-        validator.Params(config, {
-            expiration: ['number', () => 60],
-            noCdn: ['boolean', () => false],
-            dataType: ['base64', 'blob', 'endpoint', 'download', () => 'download']
-        }, [], ['progress']);
-        let needAuth = target_key[0] == 'auth';
-        let filename = url.split('/').slice(-1)[0];
-        if ((config === null || config === void 0 ? void 0 : config.noCdn) || needAuth && ((config === null || config === void 0 ? void 0 : config.dataType) === 'download' || (config === null || config === void 0 ? void 0 : config.dataType) === 'endpoint')) {
-            let params = {
-                request: subdomain ? 'get-host' : 'get',
-                id: subdomain || target_key[5],
-                key: url
-            };
-            if (service) {
-                params.service = service;
-            }
-            url = encodeURIComponent((yield request.bind(this)('get-signed-url', params, { auth: true })).url);
-        }
-        if ((config === null || config === void 0 ? void 0 : config.dataType) === 'download') {
-            let a = document.createElement('a');
-            a.href = url;
-            document.body.appendChild(a);
-            a.setAttribute('download', filename);
-            a.target = '_blank';
-            a.click();
-            document.body.removeChild(a);
-            return null;
-        }
-        if ((config === null || config === void 0 ? void 0 : config.dataType) === 'endpoint') {
-            return url;
-        }
-        let blob = yield request.bind(this)(url, { service: service || this.service }, { method: 'get', auth: needAuth, contentType: null, responseType: 'blob', fetchOptions: { progress: config === null || config === void 0 ? void 0 : config.progress } });
-        if ((config === null || config === void 0 ? void 0 : config.dataType) === 'base64') {
-            function blobToBase64(blob) {
-                return new Promise((resolve, _) => {
-                    const reader = new FileReader();
-                    reader.onloadend = () => resolve(reader.result);
-                    reader.readAsDataURL(blob);
-                });
-            }
-            return blobToBase64(blob);
-        }
-        return blob;
-    });
-}
-export function getRecords(query, fetchOptions) {
-    var _a, _b, _c;
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        const indexTypes = {
-            '$updated': 'number',
-            '$uploaded': 'number',
-            '$referenced_count': 'number'
-        };
-        if (typeof (query === null || query === void 0 ? void 0 : query.table) === 'string') {
-            query.table = {
-                name: query.table,
-                access_group: 0
-            };
-        }
-        const struct = {
-            table: {
-                name: 'string',
-                access_group: ['number', 'private', 'public', 'authorized'],
-                subscription: {
-                    user_id: (v) => validator.UserId(v, 'User ID in "subscription.user_id"'),
-                    group: (v) => {
-                        if (typeof v !== 'number') {
-                            throw new SkapiError('"subscription.group" should be type: number.', { code: 'INVALID_PARAMETER' });
-                        }
-                        if (v > 99 || v < 0) {
-                            throw new SkapiError('"subscription.group" should be within range: 0 ~ 99.', { code: 'INVALID_PARAMETER' });
-                        }
-                        return v;
-                    }
-                }
-            },
-            reference: 'string',
-            index: {
-                name: (v) => {
-                    if (typeof v !== 'string') {
-                        throw new SkapiError('"index.name" should be type: string.', { code: 'INVALID_PARAMETER' });
-                    }
-                    if (indexTypes.hasOwnProperty(v)) {
-                        return v;
-                    }
-                    if (['$uploaded', '$updated', '$referenced_count', '$user_id'].includes(v)) {
-                        return v;
-                    }
-                    return validator.specialChars(v, 'index.name', true, false);
-                },
-                value: (v) => {
-                    var _a, _b;
-                    if (((_a = query.index) === null || _a === void 0 ? void 0 : _a.name) && indexTypes.hasOwnProperty(query.index.name)) {
-                        let tp = indexTypes[query.index.name];
-                        if (typeof v === tp) {
-                            return v;
-                        }
-                        else {
-                            throw new SkapiError(`"index.value" should be type: ${tp}.`, { code: 'INVALID_PARAMETER' });
-                        }
-                    }
-                    if (typeof v === 'number') {
-                        if (v > __index_number_range || v < -__index_number_range) {
-                            throw new SkapiError(`Number value should be within range -${__index_number_range} ~ +${__index_number_range}`, { code: 'INVALID_PARAMETER' });
-                        }
-                        return v;
-                    }
-                    else if (typeof v === 'boolean') {
-                        return v;
-                    }
-                    else {
-                        if ('$user_id' == ((_b = query.index) === null || _b === void 0 ? void 0 : _b.name)) {
-                            return validator.UserId(v);
-                        }
-                        return validator.specialChars(v, 'index.value', false, true);
-                    }
-                },
-                condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne'],
-                range: (v) => {
-                    if (!query.index || !('value' in query.index)) {
-                        throw new SkapiError('"index.value" is required.', { code: 'INVALID_PARAMETER' });
-                    }
-                    if (query.index.name === '$record_id') {
-                        throw new SkapiError(`Cannot do "index.range" on ${query.index.name}`, { code: 'INVALID_PARAMETER' });
-                    }
-                    if (typeof query.index.value !== typeof v) {
-                        throw new SkapiError('"index.range" type should match the type of "index.value".', { code: 'INVALID_PARAMETER' });
-                    }
-                    if (typeof v === 'string') {
-                        return validator.specialChars(v, 'index.value');
-                    }
-                    return v;
-                }
-            },
-            tag: 'string',
-            private_access_key: 'string'
-        };
-        if (query === null || query === void 0 ? void 0 : query.table) {
-            if (query.table.access_group === 'public') {
-                query.table.access_group = 0;
-            }
-            else if (query.table.access_group === 'authorized') {
-                query.table.access_group = 1;
-            }
-            if (typeof query.table.access_group === 'number') {
-                if (!this.__user) {
-                    if (0 < query.table.access_group) {
-                        throw new SkapiError("User has no access", { code: 'INVALID_REQUEST' });
-                    }
-                }
-                else if (this.user.access_group < query.table.access_group) {
-                    throw new SkapiError("User has no access", { code: 'INVALID_REQUEST' });
-                }
-            }
-        }
-        if ((query === null || query === void 0 ? void 0 : query.index) && !((_a = query.index) === null || _a === void 0 ? void 0 : _a.name)) {
-            throw new SkapiError('"index.name" is required when using "index" parameter.', { code: 'INVALID_REQUEST' });
-        }
-        if (query === null || query === void 0 ? void 0 : query.record_id) {
-            validator.specialChars(query.record_id, 'record_id', false, false);
-            let outputObj = { record_id: query.record_id };
-            if (query === null || query === void 0 ? void 0 : query.service) {
-                outputObj.service = query.service;
-            }
-            query = outputObj;
-        }
-        else {
-            let ref_user;
-            if (!this.session && ((_b = query.table) === null || _b === void 0 ? void 0 : _b.access_group) === 'private') {
-                throw new SkapiError('Unsigned users have no access to private records.', { code: 'INVALID_REQUEST' });
-            }
-            if (query.reference) {
-                try {
-                    ref_user = validator.UserId(query === null || query === void 0 ? void 0 : query.reference);
-                }
-                catch (err) {
-                }
-            }
-            query = validator.Params(query || {}, struct, ref_user ? [] : ['table']);
-            if (((_c = query.table) === null || _c === void 0 ? void 0 : _c.subscription) && !this.session) {
-                throw new SkapiError('Unsigned users have no access to subscription records.', { code: 'INVALID_REQUEST' });
-            }
-        }
-        let auth = query.hasOwnProperty('access_group') && query.table.access_group ? true : !!this.__user;
-        let result = yield request.bind(this)('get-records', query, {
-            fetchOptions,
-            auth,
-            method: auth ? 'post' : 'get'
-        });
-        for (let i in result.list) {
-            result.list[i] = normalizeRecord(result.list[i]);
-        }
-        ;
-        return result;
-    });
-}
-export function postRecord(form, config) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        let isAdmin = yield this.checkAdmin();
-        if (!config) {
-            throw new SkapiError('"config" argument is required.', { code: 'INVALID_PARAMETER' });
-        }
-        if (!this.user) {
-            throw new SkapiError('Login is required.', { code: 'INVALID_REQUEST' });
-        }
-        let fetchOptions = {};
-        if (typeof (config === null || config === void 0 ? void 0 : config.formData) === 'function') {
-            fetchOptions.formData = config.formData;
-            delete config.formData;
-        }
-        if (typeof config.table === 'string') {
-            config.table = {
-                name: config.table
-            };
-            if (!config.record_id) {
-                config.table.access_group = 0;
-            }
-        }
-        let progress = config.progress || null;
-        config = validator.Params(config || {}, {
-            record_id: 'string',
-            table: {
-                name: 'string',
-                subscription_group: ['number', null],
-                access_group: ['number', 'private', 'public', 'authorized']
-            },
-            reference: {
-                record_id: ['string', null],
-                reference_limit: (v) => {
-                    if (v === null) {
-                        return null;
-                    }
-                    else if (typeof v === 'number') {
-                        if (0 > v) {
-                            throw new SkapiError(`"reference_limit" should be >= 0`, { code: 'INVALID_PARAMETER' });
-                        }
-                        if (v > 4503599627370546) {
-                            throw new SkapiError(`"reference_limit" should be <= 4503599627370546`, { code: 'INVALID_PARAMETER' });
-                        }
-                        return v;
-                    }
-                    throw new SkapiError(`"reference_limit" should be type: <number | null>`, { code: 'INVALID_PARAMETER' });
-                },
-                allow_multiple_reference: 'boolean',
-            },
-            index: {
-                name: 'string',
-                value: ['string', 'number', 'boolean']
-            },
-            tags: (v) => {
-                if (v === null) {
-                    return v;
-                }
-                if (typeof v === 'string') {
-                    return [v];
-                }
-                if (Array.isArray(v)) {
-                    for (let i of v) {
-                        if (typeof i !== 'string') {
-                            throw new SkapiError(`"tags" should be type: <string | string[]>`, { code: 'INVALID_PARAMETER' });
-                        }
-                        validator.specialChars(v, 'tag', false, true);
-                    }
-                    return v;
-                }
-                throw new SkapiError(`"tags" should be type: <string | string[]>`, { code: 'INVALID_PARAMETER' });
-            }
-        }, [], ['response', 'onerror', 'progress'], null);
-        if (!(config === null || config === void 0 ? void 0 : config.table) && !(config === null || config === void 0 ? void 0 : config.record_id)) {
-            throw new SkapiError('Either "record_id" or "table" should have a value.', { code: 'INVALID_PARAMETER' });
-        }
-        if (config.table) {
-            if (config.table.access_group === 'public') {
-                config.table.access_group = 0;
-            }
-            else if (config.table.access_group === 'authorized') {
-                config.table.access_group = 1;
-            }
-            if (typeof config.table.access_group === 'number') {
-                if (!isAdmin && this.user.access_group < config.table.access_group) {
-                    throw new SkapiError("User has no access", { code: 'INVALID_REQUEST' });
-                }
-            }
-            if (!config.table.name) {
-                throw new SkapiError('"table.name" cannot be empty string.', { code: 'INVALID_PARAMETER' });
-            }
-            if (isAdmin) {
-                if (config.table.access_group === 'private') {
-                    throw new SkapiError('Service owner cannot write private records.', { code: 'INVALID_REQUEST' });
-                }
-                if (config.table.hasOwnProperty('subscription_group')) {
-                    throw new SkapiError('Service owner cannot write to subscription table.', { code: 'INVALID_REQUEST' });
-                }
-            }
-            if (typeof ((_a = config.table) === null || _a === void 0 ? void 0 : _a.subscription_group) === 'number' && config.table.subscription_group < 0 || config.table.subscription_group > 99) {
-                throw new SkapiError("Subscription group should be within range: 0 ~ 99", { code: 'INVALID_PARAMETER' });
-            }
-        }
-        delete config.response;
-        delete config.onerror;
-        delete config.progress;
-        if (config.index) {
-            if (!config.index.name || typeof config.index.name !== 'string') {
-                throw new SkapiError('"index.name" is required. type: string.', { code: 'INVALID_PARAMETER' });
-            }
-            if (!['$uploaded', '$updated', '$referenced_count', '$user_id'].includes(config.index.name)) {
-                validator.specialChars(config.index.name, 'index name', true);
-            }
-            if (!config.index.hasOwnProperty('value')) {
-                throw new SkapiError('"index.value" is required.', { code: 'INVALID_PARAMETER' });
-            }
-            if (typeof config.index.value === 'string') {
-                validator.specialChars(config.index.value, 'index value', false, true);
-            }
-            else if (typeof config.index.value === 'number') {
-                if (config.index.value > __index_number_range || config.index.value < -__index_number_range) {
-                    throw new SkapiError(`Number value should be within range -${__index_number_range} ~ +${__index_number_range}`, { code: 'INVALID_PARAMETER' });
-                }
-            }
-        }
-        let options = { auth: true };
-        let postData = null;
-        if ((form instanceof HTMLFormElement) || (form instanceof FormData) || (form instanceof SubmitEvent)) {
-            let toConvert = (form instanceof SubmitEvent) ? form.target : form;
-            let formData = !(form instanceof FormData) ? new FormData(toConvert) : form;
-            let formMeta = extractFormMeta(form);
-            options.meta = config;
-            if (Object.keys(formMeta.meta).length) {
-                options.meta.data = formMeta.meta;
-            }
-            let formToRemove = {};
-            for (let [key, value] of formData.entries()) {
-                if (formMeta.meta.hasOwnProperty(key) && !(value instanceof Blob)) {
-                    let f = formData.getAll(key);
-                    let f_idx = f.indexOf(value);
-                    if (formToRemove.hasOwnProperty(key)) {
-                        formToRemove[key].push(f_idx);
-                    }
-                    else {
-                        formToRemove[key] = [f_idx];
-                    }
-                }
-            }
-            if (Object.keys(formToRemove).length) {
-                for (let key in formToRemove) {
-                    let values = formData.getAll(key);
-                    let val_len = values.length;
-                    while (val_len--) {
-                        if (formToRemove[key].includes(val_len)) {
-                            values.splice(val_len, 1);
-                        }
-                    }
-                    formData.delete(key);
-                    for (let dat of values) {
-                        formData.append(key, dat, dat instanceof File ? dat.name : null);
-                    }
-                }
-            }
-            postData = formData;
-        }
-        else {
-            postData = Object.assign({ data: form }, config);
-        }
-        if (typeof progress === 'function') {
-            fetchOptions.progress = progress;
-        }
-        if (Object.keys(fetchOptions).length) {
-            Object.assign(options, { fetchOptions });
-        }
-        return normalizeRecord(yield request.bind(this)('post-record', postData, options));
-    });
-}
-export function getTables(query, fetchOptions) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let res = yield request.bind(this)('get-table', validator.Params(query || {}, {
-            table: 'string',
-            condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne']
-        }), Object.assign({ auth: true }, { fetchOptions }));
-        let convert = {
-            'cnt_rec': 'number_of_records',
-            'tbl': 'table',
-            'srvc': 'service'
-        };
-        if (Array.isArray(res.list)) {
-            for (let t of res.list) {
-                for (let k in convert) {
-                    if (t.hasOwnProperty(k)) {
-                        t[convert[k]] = t[k];
-                        delete t[k];
-                    }
-                }
-            }
-        }
-        return res;
-    });
-}
-export function getIndexes(query, fetchOptions) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        let p = validator.Params(query || {}, {
-            table: 'string',
-            index: (v) => validator.specialChars(v, 'index name', true, false),
-            order: {
-                by: [
-                    'average_number',
-                    'total_number',
-                    'number_count',
-                    'average_bool',
-                    'total_bool',
-                    'bool_count',
-                    'string_count',
-                    'index_name',
-                    'number_of_records'
-                ],
-                value: ['string', 'number', 'boolean'],
-                condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne']
-            }
-        }, ['table']);
-        if (p.hasOwnProperty('order')) {
-            if (!((_a = p.order) === null || _a === void 0 ? void 0 : _a.by)) {
-                throw new SkapiError('"order.by" is required.', { code: 'INVALID_PARAMETER' });
-            }
-            if (p.order.hasOwnProperty('condition') && !p.order.hasOwnProperty('value')) {
-                throw new SkapiError('"value" is required for "condition".', { code: 'INVALID_PARAMETER' });
-            }
-            if (p.hasOwnProperty('index')) {
-                if (p.index.substring(p.index.length - 1) !== '.') {
-                    throw new SkapiError('"index" should be a parent index name of the compound index when using "order.by"', { code: 'INVALID_PARAMETER' });
-                }
-            }
-        }
-        let res = yield request.bind(this)('get-index', p, Object.assign({ auth: true }, { fetchOptions }));
-        let convert = {
-            'cnt_bool': 'boolean_count',
-            'cnt_numb': 'number_count',
-            'totl_numb': 'total_number',
-            'totl_bool': 'total_bool',
-            'avrg_numb': 'average_number',
-            'avrg_bool': 'average_bool',
-            'cnt_str': 'string_count'
-        };
-        if (Array.isArray(res.list)) {
-            res.list = res.list.map((i) => {
-                let iSplit = i.idx.split('/');
-                let resolved = {
-                    table: iSplit[1],
-                    index: iSplit[2],
-                    number_of_records: i.cnt_rec
-                };
-                for (let k in convert) {
-                    if (i === null || i === void 0 ? void 0 : i[k]) {
-                        resolved[convert[k]] = i[k];
-                    }
-                }
-                return resolved;
-            });
-        }
-        return res;
-    });
-}
-export function getTags(query, fetchOptions) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let res = yield request.bind(this)('get-tag', validator.Params(query || {}, {
-            table: 'string',
-            tag: 'string',
-            condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne']
-        }), Object.assign({ auth: true }, { fetchOptions }));
-        if (Array.isArray(res.list)) {
-            for (let i in res.list) {
-                let item = res.list[i];
-                let tSplit = item.tag.split('/');
-                res.list[i] = {
-                    table: tSplit[1],
-                    tag: tSplit[0],
-                    number_of_records: item.cnt_rec
-                };
-            }
-        }
-        return res;
-    });
-}
-export function deleteRecords(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let isAdmin = yield this.checkAdmin();
-        if (isAdmin && !(params === null || params === void 0 ? void 0 : params.service)) {
-            throw new SkapiError('Service ID is required.', { code: 'INVALID_PARAMETER' });
-        }
-        if (params === null || params === void 0 ? void 0 : params.record_id) {
-            return yield request.bind(this)('del-records', {
-                service: params.service || this.service,
-                record_id: (v => {
-                    let id = validator.specialChars(v, 'record_id', false, false);
-                    if (typeof id === 'string') {
-                        return [id];
-                    }
-                    if (id.length > 100) {
-                        throw new SkapiError('"record_id" should not exceed 100 items.', { code: 'INVALID_PARAMETER' });
-                    }
-                    return id;
-                })(params.record_id)
-            }, { auth: true });
-        }
-        else {
-            if (!(params === null || params === void 0 ? void 0 : params.table)) {
-                if (isAdmin) {
-                    return null;
-                }
-                throw new SkapiError('Either "table" or "record_id" is required.', { code: 'INVALID_PARAMETER' });
-            }
-            let struct = {
-                access_group: (v) => {
-                    if (typeof v === 'string' && ['private', 'public', 'authorized'].includes(v)) {
-                        switch (v) {
-                            case 'private':
-                                return v;
-                            case 'public':
-                                return 0;
-                            case 'authorized':
-                                return 1;
-                        }
-                    }
-                    else if (typeof v === 'number' && v >= 0 && v < 100) {
-                        return v;
-                    }
-                    throw new SkapiError('Invalid "table.access_group". Access group should be type <number (0~99) | "private" | "public" | "authorized">.', { code: 'INVALID_PARAMETER' });
-                },
-                name: 'string',
-                subscription: (v) => {
-                    if (isAdmin) {
-                        return validator.UserId(v, 'User ID in "table.subscription"');
-                    }
-                    throw new SkapiError('"table.subscription" is an invalid parameter key.', { code: 'INVALID_PARAMETER' });
-                },
-                subscription_group: (v) => {
-                    var _a;
-                    if (isAdmin && typeof ((_a = params === null || params === void 0 ? void 0 : params.table) === null || _a === void 0 ? void 0 : _a.subscription) !== 'string') {
-                        throw new SkapiError('"table.subscription" is required.', { code: 'INVALID_PARAMETER' });
-                    }
-                    if (typeof v === 'number') {
-                        if (v >= 0 && v < 99) {
-                            return v;
-                        }
-                    }
-                    throw new SkapiError('Subscription group should be between 0 ~ 99.', { code: 'INVALID_PARAMETER' });
-                }
-            };
-            params.table = validator.Params(params.table || {}, struct, isAdmin ? [] : ['name']);
-        }
-        return yield request.bind(this)('del-records', params, { auth: true });
-    });
-}
-export function grantPrivateRecordAccess(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!params.record_id) {
-            throw new SkapiError(`Record ID is required.`, { code: 'INVALID_PARAMETER' });
-        }
-        if (!params.user_id || Array.isArray(params.user_id) && !params.user_id.length) {
-            throw new SkapiError(`User ID is required.`, { code: 'INVALID_PARAMETER' });
-        }
-        return recordAccess({
-            record_id: params.record_id,
-            user_id: params.user_id || null,
-            execute: 'add'
-        });
-    });
-}
-export function removePrivateRecordAccess(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!params.record_id) {
-            throw new SkapiError(`Record ID is required.`, { code: 'INVALID_PARAMETER' });
-        }
-        if (!params.user_id || Array.isArray(params.user_id) && !params.user_id.length) {
-            throw new SkapiError(`User ID is required.`, { code: 'INVALID_PARAMETER' });
-        }
-        return recordAccess({
-            record_id: params.record_id,
-            user_id: params.user_id || null,
-            execute: 'remove'
-        });
-    });
-}
-export function listPrivateRecordAccess(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return recordAccess({
-            record_id: params.record_id,
-            user_id: params.user_id || null,
-            execute: 'list'
-        });
-    });
-}
-export function requestPrivateRecordAccessKey(record_id) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield request.bind(this)('request-private-access-key', { record_id }, { auth: true });
-    });
-}
-function recordAccess(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let execute = params.execute;
-        let req = validator.Params(params, {
-            record_id: 'string',
-            user_id: (v) => {
-                if (!v) {
-                    if (execute == 'list') {
-                        return null;
-                    }
-                    throw new SkapiError(`User ID is required.`, { code: 'INVALID_PARAMETER' });
-                }
-                let id = validator.specialChars(v, 'user id', false, false);
-                if (typeof id === 'string') {
-                    return [id];
-                }
-                if (id.length > 100) {
-                    throw new SkapiError(`Cannot process more than 100 users at once.`, { code: 'INVALID_REQUEST' });
-                }
-                return id;
-            },
-            execute: ['add', 'remove', 'list']
-        }, [
-            'execute',
-            'record_id',
-            'user_id'
-        ]);
-        if (!req.user_id) {
-            req.user_id = null;
-        }
-        yield request.bind(this)('grant-private-access', req, { auth: true });
-    });
-}